boehm-gc/os_dep.c

   1 /*
   2  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
   3  * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
   4  * Copyright (c) 1996-1999 by Silicon Graphics.  All rights reserved.
   5  * Copyright (c) 1999 by Hewlett-Packard Company.  All rights reserved.
   6  *
   7  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   8  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   9  *
  10  * Permission is hereby granted to use or copy this program
  11  * for any purpose,  provided the above notices are retained on all copies.
  12  * Permission to modify the code and to distribute modified code is granted,
  13  * provided the above notices are retained, and a notice that the code was
  14  * modified is included with the above copyright notice.
  15  */
  16
  17 # include "private/gc_priv.h"
  18
  19 # if defined(LINUX) && !defined(POWERPC)
  20 #   include <linux/version.h>
  21 #   if (LINUX_VERSION_CODE <= 0x10400)
  22       /* Ugly hack to get struct sigcontext_struct definition.  Required      */
  23       /* for some early 1.3.X releases.  Will hopefully go away soon. */
  24       /* in some later Linux releases, asm/sigcontext.h may have to   */
  25       /* be included instead.                                         */
  26 #     define __KERNEL__
  27 #     include <asm/signal.h>
  28 #     undef __KERNEL__
  29 #   else
  30       /* Kernels prior to 2.1.1 defined struct sigcontext_struct instead of */
  31       /* struct sigcontext.  libc6 (glibc2) uses "struct sigcontext" in     */
  32       /* prototypes, so we have to include the top-level sigcontext.h to    */
  33       /* make sure the former gets defined to be the latter if appropriate. */
  34 #     include <features.h>
  35 #     if 2 <= __GLIBC__
  36 #       if 2 == __GLIBC__ && 0 == __GLIBC_MINOR__
  37           /* glibc 2.1 no longer has sigcontext.h.  But signal.h        */
  38           /* has the right declaration for glibc 2.1.                   */
  39 #         include <sigcontext.h>
  40 #       endif /* 0 == __GLIBC_MINOR__ */
  41 #     else /* not 2 <= __GLIBC__ */
  42         /* libc5 doesn't have <sigcontext.h>: go directly with the kernel   */
  43         /* one.  Check LINUX_VERSION_CODE to see which we should reference. */
  44 #       include <asm/sigcontext.h>
  45 #     endif /* 2 <= __GLIBC__ */
  46 #   endif
  47 # endif
  48 # if !defined(OS2) && !defined(PCR) && !defined(AMIGA) && !defined(MACOS) \
  49     && !defined(MSWINCE)
  50 #   include <sys/types.h>
  51 #   if !defined(MSWIN32) && !defined(SUNOS4)
  52 #       include <unistd.h>
  53 #   endif
  54 # endif
  55
  56 # include <stdio.h>
  57 # if defined(MSWINCE)
  58 #   define SIGSEGV 0 /* value is irrelevant */
  59 # else
  60 #   include <signal.h>
  61 # endif
  62
  63 #if defined(LINUX) || defined(LINUX_STACKBOTTOM)
  64 # include <ctype.h>
  65 #endif
  66
  67 /* Blatantly OS dependent routines, except for those that are related   */
  68 /* to dynamic loading.                                                  */
  69
  70 # if defined(HEURISTIC2) || defined(SEARCH_FOR_DATA_START)
  71 #   define NEED_FIND_LIMIT
  72 # endif
  73
  74 # if !defined(STACKBOTTOM) && defined(HEURISTIC2)
  75 #   define NEED_FIND_LIMIT
  76 # endif
  77
  78 # if (defined(SUNOS4) && defined(DYNAMIC_LOADING)) && !defined(PCR)
  79 #   define NEED_FIND_LIMIT
  80 # endif
  81
  82 # if (defined(SVR4) || defined(AUX) || defined(DGUX) \
  83       || (defined(LINUX) && defined(SPARC))) && !defined(PCR)
  84 #   define NEED_FIND_LIMIT
  85 # endif
  86
  87 #if defined(FREEBSD) && (defined(I386) || defined(X86_64) || defined(powerpc) || defined(__powerpc__))
  88 #  include <machine/trap.h>
  89 #  if !defined(PCR)
  90 #    define NEED_FIND_LIMIT
  91 #  endif
  92 #endif
  93
  94 #if (defined(NETBSD) || defined(OPENBSD)) && defined(__ELF__) \
  95     && !defined(NEED_FIND_LIMIT)
  96    /* Used by GC_init_netbsd_elf() below.       */
  97 #  define NEED_FIND_LIMIT
  98 #endif
  99
 100 #ifdef NEED_FIND_LIMIT
 101 #   include <setjmp.h>
 102 #endif
 103
 104 #ifdef AMIGA
 105 # define GC_AMIGA_DEF
 106 # include "AmigaOS.c"
 107 # undef GC_AMIGA_DEF
 108 #endif
 109
 110 #if defined(MSWIN32) || defined(MSWINCE)
 111 # define WIN32_LEAN_AND_MEAN
 112 # define NOSERVICE
 113 # include <windows.h>
 114 #endif
 115
 116 #ifdef MACOS
 117 # include <Processes.h>
 118 #endif
 119
 120 #ifdef IRIX5
 121 # include <sys/uio.h>
 122 # include <malloc.h>   /* for locking */
 123 #endif
 124 #if defined(USE_MMAP) || defined(USE_MUNMAP)
 125 # ifndef USE_MMAP
 126     --> USE_MUNMAP requires USE_MMAP
 127 # endif
 128 # include <sys/types.h>
 129 # include <sys/mman.h>
 130 # include <sys/stat.h>
 131 # include <errno.h>
 132 #endif
 133
 134 #ifdef UNIX_LIKE
 135 # include <fcntl.h>
 136 # if defined(SUNOS5SIGS) && !defined(FREEBSD)
 137 #  include <sys/siginfo.h>
 138 # endif
 139   /* Define SETJMP and friends to be the version that restores  */
 140   /* the signal mask.                                           */
 141 # define SETJMP(env) sigsetjmp(env, 1)
 142 # define LONGJMP(env, val) siglongjmp(env, val)
 143 # define JMP_BUF sigjmp_buf
 144 #else
 145 # define SETJMP(env) setjmp(env)
 146 # define LONGJMP(env, val) longjmp(env, val)
 147 # define JMP_BUF jmp_buf
 148 #endif
 149
 150 #ifdef DARWIN
 151 /* for get_etext and friends */
 152 #include <mach-o/getsect.h>
 153 #endif
 154
 155 #ifdef DJGPP
 156   /* Apparently necessary for djgpp 2.01.  May cause problems with      */
 157   /* other versions.                                                    */
 158   typedef long unsigned int caddr_t;
 159 #endif
 160
 161 #ifdef PCR
 162 # include "il/PCR_IL.h"
 163 # include "th/PCR_ThCtl.h"
 164 # include "mm/PCR_MM.h"
 165 #endif
 166
 167 #if !defined(NO_EXECUTE_PERMISSION)
 168 # define OPT_PROT_EXEC PROT_EXEC
 169 #else
 170 # define OPT_PROT_EXEC 0
 171 #endif
 172
 173 #if defined(LINUX) && \
 174     (defined(USE_PROC_FOR_LIBRARIES) || defined(IA64) || !defined(SMALL_CONFIG))
 175
 176 /* We need to parse /proc/self/maps, either to find dynamic libraries,  */
 177 /* and/or to find the register backing store base (IA64).  Do it once   */
 178 /* here.                                                                */
 179
 180 #define READ read
 181
 182 /* Repeatedly perform a read call until the buffer is filled or */
 183 /* we encounter EOF.                                            */
 184 ssize_t GC_repeat_read(int fd, char *buf, size_t count)
 185 {
 186     ssize_t num_read = 0;
 187     ssize_t result;
 188
 189     while (num_read < count) {
 190         result = READ(fd, buf + num_read, count - num_read);
 191         if (result < 0) return result;
 192         if (result == 0) break;
 193         num_read += result;
 194     }
 195     return num_read;
 196 }
 197
 198 /*
 199  * Apply fn to a buffer containing the contents of /proc/self/maps.
 200  * Return the result of fn or, if we failed, 0.
 201  * We currently do nothing to /proc/self/maps other than simply read
 202  * it.  This code could be simplified if we could determine its size
 203  * ahead of time.
 204  */
 205
 206 word GC_apply_to_maps(word (*fn)(char *))
 207 {
 208     int f;
 209     int result;
 210     size_t maps_size = 4000;  /* Initial guess.         */
 211     static char init_buf[1];
 212     static char *maps_buf = init_buf;
 213     static size_t maps_buf_sz = 1;
 214
 215     /* Read /proc/self/maps, growing maps_buf as necessary.     */
 216         /* Note that we may not allocate conventionally, and    */
 217         /* thus can't use stdio.                                */
 218         do {
 219             if (maps_size >= maps_buf_sz) {
 220               /* Grow only by powers of 2, since we leak "too small" buffers. */
 221               while (maps_size >= maps_buf_sz) maps_buf_sz *= 2;
 222               maps_buf = GC_scratch_alloc(maps_buf_sz);
 223               if (maps_buf == 0) return 0;
 224             }
 225             f = open("/proc/self/maps", O_RDONLY);
 226             if (-1 == f) return 0;
 227             maps_size = 0;
 228             do {
 229                 result = GC_repeat_read(f, maps_buf, maps_buf_sz-1);
 230                 if (result <= 0) return 0;
 231                 maps_size += result;
 232             } while (result == maps_buf_sz-1);
 233             close(f);
 234         } while (maps_size >= maps_buf_sz);
 235         maps_buf[maps_size] = '\0';
 236
 237     /* Apply fn to result. */
 238         return fn(maps_buf);
 239 }
 240
 241 #endif /* Need GC_apply_to_maps */
 242
 243 #if defined(LINUX) && (defined(USE_PROC_FOR_LIBRARIES) || defined(IA64))
 244 //
 245 //  GC_parse_map_entry parses an entry from /proc/self/maps so we can
 246 //  locate all writable data segments that belong to shared libraries.
 247 //  The format of one of these entries and the fields we care about
 248 //  is as follows:
 249 //  XXXXXXXX-XXXXXXXX r-xp 00000000 30:05 260537     name of mapping...\n
 250 //  ^^^^^^^^ ^^^^^^^^ ^^^^          ^^
 251 //  start    end      prot          maj_dev
 252 //
 253 //  Note that since about auguat 2003 kernels, the columns no longer have
 254 //  fixed offsets on 64-bit kernels.  Hence we no longer rely on fixed offsets
 255 //  anywhere, which is safer anyway.
 256 //
 257
 258 /*
 259  * Assign various fields of the first line in buf_ptr to *start, *end,
 260  * *prot_buf and *maj_dev.  Only *prot_buf may be set for unwritable maps.
 261  */
 262 char *GC_parse_map_entry(char *buf_ptr, word *start, word *end,
 263                                 char *prot_buf, unsigned int *maj_dev)
 264 {
 265     char *start_start, *end_start, *prot_start, *maj_dev_start;
 266     char *p;
 267     char *endp;
 268
 269     if (buf_ptr == NULL || *buf_ptr == '\0') {
 270         return NULL;
 271     }
 272
 273     p = buf_ptr;
 274     while (isspace(*p)) ++p;
 275     start_start = p;
 276     GC_ASSERT(isxdigit(*start_start));
 277     *start = strtoul(start_start, &endp, 16); p = endp;
 278     GC_ASSERT(*p=='-');
 279
 280     ++p;
 281     end_start = p;
 282     GC_ASSERT(isxdigit(*end_start));
 283     *end = strtoul(end_start, &endp, 16); p = endp;
 284     GC_ASSERT(isspace(*p));
 285
 286     while (isspace(*p)) ++p;
 287     prot_start = p;
 288     GC_ASSERT(*prot_start == 'r' || *prot_start == '-');
 289     memcpy(prot_buf, prot_start, 4);
 290     prot_buf[4] = '\0';
 291     if (prot_buf[1] == 'w') {/* we can skip the rest if it's not writable. */
 292         /* Skip past protection field to offset field */
 293           while (!isspace(*p)) ++p; while (isspace(*p)) ++p;
 294           GC_ASSERT(isxdigit(*p));
 295         /* Skip past offset field, which we ignore */
 296           while (!isspace(*p)) ++p; while (isspace(*p)) ++p;
 297         maj_dev_start = p;
 298         GC_ASSERT(isxdigit(*maj_dev_start));
 299         *maj_dev = strtoul(maj_dev_start, NULL, 16);
 300     }
 301
 302     while (*p && *p++ != '\n');
 303
 304     return p;
 305 }
 306
 307 #endif /* Need to parse /proc/self/maps. */
 308
 309 #if defined(SEARCH_FOR_DATA_START)
 310   /* The I386 case can be handled without a search.  The Alpha case     */
 311   /* used to be handled differently as well, but the rules changed      */
 312   /* for recent Linux versions.  This seems to be the easiest way to    */
 313   /* cover all versions.                                                */
 314
 315 # ifdef LINUX
 316     /* Some Linux distributions arrange to define __data_start.  Some   */
 317     /* define data_start as a weak symbol.  The latter is technically   */
 318     /* broken, since the user program may define data_start, in which   */
 319     /* case we lose.  Nonetheless, we try both, prefering __data_start. */
 320     /* We assume gcc-compatible pragmas.        */
 321 #   pragma weak __data_start
 322     extern int __data_start[];
 323 #   pragma weak data_start
 324     extern int data_start[];
 325 # endif /* LINUX */
 326   extern int _end[];
 327
 328   ptr_t GC_data_start;
 329
 330   void GC_init_linux_data_start()
 331   {
 332     extern ptr_t GC_find_limit();
 333
 334 #   ifdef LINUX
 335       /* Try the easy approaches first: */
 336       if ((ptr_t)__data_start != 0) {
 337           GC_data_start = (ptr_t)(__data_start);
 338           return;
 339       }
 340       if ((ptr_t)data_start != 0) {
 341           GC_data_start = (ptr_t)(data_start);
 342           return;
 343       }
 344 #   endif /* LINUX */
 345     GC_data_start = GC_find_limit((ptr_t)(_end), FALSE);
 346   }
 347 #endif
 348
 349 # ifdef ECOS
 350
 351 # ifndef ECOS_GC_MEMORY_SIZE
 352 # define ECOS_GC_MEMORY_SIZE (448 * 1024)
 353 # endif /* ECOS_GC_MEMORY_SIZE */
 354
 355 // setjmp() function, as described in ANSI para 7.6.1.1
 356 #undef SETJMP
 357 #define SETJMP( __env__ )  hal_setjmp( __env__ )
 358
 359 // FIXME: This is a simple way of allocating memory which is
 360 // compatible with ECOS early releases.  Later releases use a more
 361 // sophisticated means of allocating memory than this simple static
 362 // allocator, but this method is at least bound to work.
 363 static char memory[ECOS_GC_MEMORY_SIZE];
 364 static char *brk = memory;
 365
 366 static void *tiny_sbrk(ptrdiff_t increment)
 367 {
 368   void *p = brk;
 369
 370   brk += increment;
 371
 372   if (brk >  memory + sizeof memory)
 373     {
 374       brk -= increment;
 375       return NULL;
 376     }
 377
 378   return p;
 379 }
 380 #define sbrk tiny_sbrk
 381 # endif /* ECOS */
 382
 383 #if (defined(NETBSD) || defined(OPENBSD)) && defined(__ELF__)
 384   ptr_t GC_data_start;
 385
 386   void GC_init_netbsd_elf()
 387   {
 388     extern ptr_t GC_find_limit();
 389     extern char **environ;
 390         /* This may need to be environ, without the underscore, for     */
 391         /* some versions.                                               */
 392     GC_data_start = GC_find_limit((ptr_t)&environ, FALSE);
 393   }
 394 #endif
 395
 396 # ifdef OS2
 397
 398 # include <stddef.h>
 399
 400 # if !defined(__IBMC__) && !defined(__WATCOMC__) /* e.g. EMX */
 401
 402 struct exe_hdr {
 403     unsigned short      magic_number;
 404     unsigned short      padding[29];
 405     long                new_exe_offset;
 406 };
 407
 408 #define E_MAGIC(x)      (x).magic_number
 409 #define EMAGIC          0x5A4D
 410 #define E_LFANEW(x)     (x).new_exe_offset
 411
 412 struct e32_exe {
 413     unsigned char       magic_number[2];
 414     unsigned char       byte_order;
 415     unsigned char       word_order;
 416     unsigned long       exe_format_level;
 417     unsigned short      cpu;
 418     unsigned short      os;
 419     unsigned long       padding1[13];
 420     unsigned long       object_table_offset;
 421     unsigned long       object_count;
 422     unsigned long       padding2[31];
 423 };
 424
 425 #define E32_MAGIC1(x)   (x).magic_number[0]
 426 #define E32MAGIC1       'L'
 427 #define E32_MAGIC2(x)   (x).magic_number[1]
 428 #define E32MAGIC2       'X'
 429 #define E32_BORDER(x)   (x).byte_order
 430 #define E32LEBO         0
 431 #define E32_WORDER(x)   (x).word_order
 432 #define E32LEWO         0
 433 #define E32_CPU(x)      (x).cpu
 434 #define E32CPU286       1
 435 #define E32_OBJTAB(x)   (x).object_table_offset
 436 #define E32_OBJCNT(x)   (x).object_count
 437
 438 struct o32_obj {
 439     unsigned long       size;
 440     unsigned long       base;
 441     unsigned long       flags;
 442     unsigned long       pagemap;
 443     unsigned long       mapsize;
 444     unsigned long       reserved;
 445 };
 446
 447 #define O32_FLAGS(x)    (x).flags
 448 #define OBJREAD         0x0001L
 449 #define OBJWRITE        0x0002L
 450 #define OBJINVALID      0x0080L
 451 #define O32_SIZE(x)     (x).size
 452 #define O32_BASE(x)     (x).base
 453
 454 # else  /* IBM's compiler */
 455
 456 /* A kludge to get around what appears to be a header file bug */
 457 # ifndef WORD
 458 #   define WORD unsigned short
 459 # endif
 460 # ifndef DWORD
 461 #   define DWORD unsigned long
 462 # endif
 463
 464 # define EXE386 1
 465 # include <newexe.h>
 466 # include <exe386.h>
 467
 468 # endif  /* __IBMC__ */
 469
 470 # define INCL_DOSEXCEPTIONS
 471 # define INCL_DOSPROCESS
 472 # define INCL_DOSERRORS
 473 # define INCL_DOSMODULEMGR
 474 # define INCL_DOSMEMMGR
 475 # include <os2.h>
 476
 477
 478 /* Disable and enable signals during nontrivial allocations     */
 479
 480 void GC_disable_signals(void)
 481 {
 482     ULONG nest;
 483
 484     DosEnterMustComplete(&nest);
 485     if (nest != 1) ABORT("nested GC_disable_signals");
 486 }
 487
 488 void GC_enable_signals(void)
 489 {
 490     ULONG nest;
 491
 492     DosExitMustComplete(&nest);
 493     if (nest != 0) ABORT("GC_enable_signals");
 494 }
 495
 496
 497 # else
 498
 499 #  if !defined(PCR) && !defined(AMIGA) && !defined(MSWIN32) \
 500       && !defined(MSWINCE) \
 501       && !defined(MACOS) && !defined(DJGPP) && !defined(DOS4GW) \
 502       && !defined(NOSYS) && !defined(ECOS)
 503
 504 #   if defined(SIG_BLOCK)
 505         /* Use POSIX/SYSV interface */
 506 #       define SIGSET_T sigset_t
 507 #       define SIG_DEL(set, signal) sigdelset(&(set), (signal))
 508 #       define SIG_FILL(set) sigfillset(&set)
 509 #       define SIGSETMASK(old, new) sigprocmask(SIG_SETMASK, &(new), &(old))
 510 #   elif defined(sigmask) && !defined(UTS4) && !defined(HURD)
 511         /* Use the traditional BSD interface */
 512 #       define SIGSET_T int
 513 #       define SIG_DEL(set, signal) (set) &= ~(sigmask(signal))
 514 #       define SIG_FILL(set)  (set) = 0x7fffffff
 515           /* Setting the leading bit appears to provoke a bug in some   */
 516           /* longjmp implementations.  Most systems appear not to have  */
 517           /* a signal 32.                                               */
 518 #       define SIGSETMASK(old, new) (old) = sigsetmask(new)
 519 #   else
 520 #       error undetectable signal API
 521 #   endif
 522
 523 static GC_bool mask_initialized = FALSE;
 524
 525 static SIGSET_T new_mask;
 526
 527 static SIGSET_T old_mask;
 528
 529 static SIGSET_T dummy;
 530
 531 #if defined(PRINTSTATS) && !defined(THREADS)
 532 # define CHECK_SIGNALS
 533   int GC_sig_disabled = 0;
 534 #endif
 535
 536 void GC_disable_signals()
 537 {
 538     if (!mask_initialized) {
 539         SIG_FILL(new_mask);
 540
 541         SIG_DEL(new_mask, SIGSEGV);
 542         SIG_DEL(new_mask, SIGILL);
 543         SIG_DEL(new_mask, SIGQUIT);
 544 #       ifdef SIGBUS
 545             SIG_DEL(new_mask, SIGBUS);
 546 #       endif
 547 #       ifdef SIGIOT
 548             SIG_DEL(new_mask, SIGIOT);
 549 #       endif
 550 #       ifdef SIGEMT
 551             SIG_DEL(new_mask, SIGEMT);
 552 #       endif
 553 #       ifdef SIGTRAP
 554             SIG_DEL(new_mask, SIGTRAP);
 555 #       endif
 556         mask_initialized = TRUE;
 557     }
 558 #   ifdef CHECK_SIGNALS
 559         if (GC_sig_disabled != 0) ABORT("Nested disables");
 560         GC_sig_disabled++;
 561 #   endif
 562     SIGSETMASK(old_mask,new_mask);
 563 }
 564
 565 void GC_enable_signals()
 566 {
 567 #   ifdef CHECK_SIGNALS
 568         if (GC_sig_disabled != 1) ABORT("Unmatched enable");
 569         GC_sig_disabled--;
 570 #   endif
 571     SIGSETMASK(dummy,old_mask);
 572 }
 573
 574 #  endif  /* !PCR */
 575
 576 # endif /*!OS/2 */
 577
 578 /* Ivan Demakov: simplest way (to me) */
 579 #if defined (DOS4GW)
 580   void GC_disable_signals() { }
 581   void GC_enable_signals() { }
 582 #endif
 583
 584 /* Find the page size */
 585 word GC_page_size;
 586
 587 # if defined(MSWIN32) || defined(MSWINCE)
 588   void GC_setpagesize()
 589   {
 590     GetSystemInfo(&GC_sysinfo);
 591     GC_page_size = GC_sysinfo.dwPageSize;
 592   }
 593
 594 # else
 595 #   if defined(MPROTECT_VDB) || defined(PROC_VDB) || defined(USE_MMAP) \
 596        || defined(USE_MUNMAP)
 597         void GC_setpagesize()
 598         {
 599             GC_page_size = GETPAGESIZE();
 600         }
 601 #   else
 602         /* It's acceptable to fake it. */
 603         void GC_setpagesize()
 604         {
 605             GC_page_size = HBLKSIZE;
 606         }
 607 #   endif
 608 # endif
 609
 610 /*
 611  * Find the base of the stack.
 612  * Used only in single-threaded environment.
 613  * With threads, GC_mark_roots needs to know how to do this.
 614  * Called with allocator lock held.
 615  */
 616 # if defined(MSWIN32) || defined(MSWINCE)
 617 # define is_writable(prot) ((prot) == PAGE_READWRITE \
 618                             || (prot) == PAGE_WRITECOPY \
 619                             || (prot) == PAGE_EXECUTE_READWRITE \
 620                             || (prot) == PAGE_EXECUTE_WRITECOPY)
 621 /* Return the number of bytes that are writable starting at p.  */
 622 /* The pointer p is assumed to be page aligned.                 */
 623 /* If base is not 0, *base becomes the beginning of the         */
 624 /* allocation region containing p.                              */
 625 word GC_get_writable_length(ptr_t p, ptr_t *base)
 626 {
 627     MEMORY_BASIC_INFORMATION buf;
 628     word result;
 629     word protect;
 630
 631     result = VirtualQuery(p, &buf, sizeof(buf));
 632     if (result != sizeof(buf)) ABORT("Weird VirtualQuery result");
 633     if (base != 0) *base = (ptr_t)(buf.AllocationBase);
 634     protect = (buf.Protect & ~(PAGE_GUARD | PAGE_NOCACHE));
 635     if (!is_writable(protect)) {
 636         return(0);
 637     }
 638     if (buf.State != MEM_COMMIT) return(0);
 639     return(buf.RegionSize);
 640 }
 641
 642 ptr_t GC_get_stack_base()
 643 {
 644     int dummy;
 645     ptr_t sp = (ptr_t)(&dummy);
 646     ptr_t trunc_sp = (ptr_t)((word)sp & ~(GC_page_size - 1));
 647     word size = GC_get_writable_length(trunc_sp, 0);
 648
 649     return(trunc_sp + size);
 650 }
 651
 652
 653 # endif /* MS Windows */
 654
 655 # ifdef BEOS
 656 # include <kernel/OS.h>
 657 ptr_t GC_get_stack_base(){
 658         thread_info th;
 659         get_thread_info(find_thread(NULL),&th);
 660         return th.stack_end;
 661 }
 662 # endif /* BEOS */
 663
 664
 665 # ifdef OS2
 666
 667 ptr_t GC_get_stack_base()
 668 {
 669     PTIB ptib;
 670     PPIB ppib;
 671
 672     if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
 673         GC_err_printf0("DosGetInfoBlocks failed\n");
 674         ABORT("DosGetInfoBlocks failed\n");
 675     }
 676     return((ptr_t)(ptib -> tib_pstacklimit));
 677 }
 678
 679 # endif /* OS2 */
 680
 681 # ifdef AMIGA
 682 #   define GC_AMIGA_SB
 683 #   include "AmigaOS.c"
 684 #   undef GC_AMIGA_SB
 685 # endif /* AMIGA */
 686
 687 # if defined(NEED_FIND_LIMIT) || defined(UNIX_LIKE)
 688
 689 #   ifdef __STDC__
 690         typedef void (*handler)(int);
 691 #   else
 692         typedef void (*handler)();
 693 #   endif
 694
 695 #   if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \
 696     || defined(HURD) || defined(NETBSD)
 697         static struct sigaction old_segv_act;
 698 #       if defined(IRIX5) || defined(HPUX) \
 699         || defined(HURD) || defined(NETBSD)
 700             static struct sigaction old_bus_act;
 701 #       endif
 702 #   else
 703         static handler old_segv_handler, old_bus_handler;
 704 #   endif
 705
 706 #   ifdef __STDC__
 707       void GC_set_and_save_fault_handler(handler h)
 708 #   else
 709       void GC_set_and_save_fault_handler(h)
 710       handler h;
 711 #   endif
 712     {
 713 #       if defined(SUNOS5SIGS) || defined(IRIX5)  \
 714         || defined(OSF1) || defined(HURD) || defined(NETBSD)
 715           struct sigaction      act;
 716
 717           act.sa_handler        = h;
 718 #         if 0 /* Was necessary for Solaris 2.3 and very temporary      */
 719                /* NetBSD bugs.                                          */
 720             act.sa_flags          = SA_RESTART | SA_NODEFER;
 721 #         else
 722             act.sa_flags          = SA_RESTART;
 723 #         endif
 724
 725           (void) sigemptyset(&act.sa_mask);
 726 #         ifdef GC_IRIX_THREADS
 727                 /* Older versions have a bug related to retrieving and  */
 728                 /* and setting a handler at the same time.              */
 729                 (void) sigaction(SIGSEGV, 0, &old_segv_act);
 730                 (void) sigaction(SIGSEGV, &act, 0);
 731                 (void) sigaction(SIGBUS, 0, &old_bus_act);
 732                 (void) sigaction(SIGBUS, &act, 0);
 733 #         else
 734                 (void) sigaction(SIGSEGV, &act, &old_segv_act);
 735 #               if defined(IRIX5) \
 736                    || defined(HPUX) || defined(HURD) || defined(NETBSD)
 737                     /* Under Irix 5.x or HP/UX, we may get SIGBUS.      */
 738                     /* Pthreads doesn't exist under Irix 5.x, so we     */
 739                     /* don't have to worry in the threads case.         */
 740                     (void) sigaction(SIGBUS, &act, &old_bus_act);
 741 #               endif
 742 #         endif /* GC_IRIX_THREADS */
 743 #       else
 744           old_segv_handler = signal(SIGSEGV, h);
 745 #         ifdef SIGBUS
 746             old_bus_handler = signal(SIGBUS, h);
 747 #         endif
 748 #       endif
 749     }
 750 # endif /* NEED_FIND_LIMIT || UNIX_LIKE */
 751
 752 # ifdef NEED_FIND_LIMIT
 753   /* Some tools to implement HEURISTIC2 */
 754 #   define MIN_PAGE_SIZE 256    /* Smallest conceivable page size, bytes */
 755     /* static */ JMP_BUF GC_jmp_buf;
 756
 757     /*ARGSUSED*/
 758     void GC_fault_handler(sig)
 759     int sig;
 760     {
 761         LONGJMP(GC_jmp_buf, 1);
 762     }
 763
 764     void GC_setup_temporary_fault_handler()
 765     {
 766         GC_set_and_save_fault_handler(GC_fault_handler);
 767     }
 768
 769     void GC_reset_fault_handler()
 770     {
 771 #       if defined(SUNOS5SIGS) || defined(IRIX5) \
 772            || defined(OSF1) || defined(HURD) || defined(NETBSD)
 773           (void) sigaction(SIGSEGV, &old_segv_act, 0);
 774 #         if defined(IRIX5) \
 775              || defined(HPUX) || defined(HURD) || defined(NETBSD)
 776               (void) sigaction(SIGBUS, &old_bus_act, 0);
 777 #         endif
 778 #       else
 779           (void) signal(SIGSEGV, old_segv_handler);
 780 #         ifdef SIGBUS
 781             (void) signal(SIGBUS, old_bus_handler);
 782 #         endif
 783 #       endif
 784     }
 785
 786     /* Return the first nonaddressible location > p (up) or     */
 787     /* the smallest location q s.t. [q,p) is addressable (!up). */
 788     /* We assume that p (up) or p-1 (!up) is addressable.       */
 789     ptr_t GC_find_limit(p, up)
 790     ptr_t p;
 791     GC_bool up;
 792     {
 793         static VOLATILE ptr_t result;
 794                 /* Needs to be static, since otherwise it may not be    */
 795                 /* preserved across the longjmp.  Can safely be         */
 796                 /* static since it's only called once, with the         */
 797                 /* allocation lock held.                                */
 798
 799
 800         GC_setup_temporary_fault_handler();
 801         if (SETJMP(GC_jmp_buf) == 0) {
 802             result = (ptr_t)(((word)(p))
 803                               & ~(MIN_PAGE_SIZE-1));
 804             for (;;) {
 805                 if (up) {
 806                     result += MIN_PAGE_SIZE;
 807                 } else {
 808                     result -= MIN_PAGE_SIZE;
 809                 }
 810                 GC_noop1((word)(*result));
 811             }
 812         }
 813         GC_reset_fault_handler();
 814         if (!up) {
 815             result += MIN_PAGE_SIZE;
 816         }
 817         return(result);
 818     }
 819 # endif
 820
 821 #if defined(ECOS) || defined(NOSYS)
 822   ptr_t GC_get_stack_base()
 823   {
 824     return STACKBOTTOM;
 825   }
 826 #endif
 827
 828 #ifdef HPUX_STACKBOTTOM
 829
 830 #include <sys/param.h>
 831 #include <sys/pstat.h>
 832
 833   ptr_t GC_get_register_stack_base(void)
 834   {
 835     struct pst_vm_status vm_status;
 836
 837     int i = 0;
 838     while (pstat_getprocvm(&vm_status, sizeof(vm_status), 0, i++) == 1) {
 839       if (vm_status.pst_type == PS_RSESTACK) {
 840         return (ptr_t) vm_status.pst_vaddr;
 841       }
 842     }
 843
 844     /* old way to get the register stackbottom */
 845     return (ptr_t)(((word)GC_stackbottom - BACKING_STORE_DISPLACEMENT - 1)
 846                    & ~(BACKING_STORE_ALIGNMENT - 1));
 847   }
 848
 849 #endif /* HPUX_STACK_BOTTOM */
 850
 851 #ifdef LINUX_STACKBOTTOM
 852
 853 #include <sys/types.h>
 854 #include <sys/stat.h>
 855
 856 # define STAT_SKIP 27   /* Number of fields preceding startstack        */
 857                         /* field in /proc/self/stat                     */
 858
 859 #ifdef USE_LIBC_PRIVATES
 860 # pragma weak __libc_stack_end
 861   extern ptr_t __libc_stack_end;
 862 #endif
 863
 864 # ifdef IA64
 865     /* Try to read the backing store base from /proc/self/maps. */
 866     /* We look for the writable mapping with a 0 major device,  */
 867     /* which is as close to our frame as possible, but below it.*/
 868     static word backing_store_base_from_maps(char *maps)
 869     {
 870       char prot_buf[5];
 871       char *buf_ptr = maps;
 872       word start, end;
 873       unsigned int maj_dev;
 874       word current_best = 0;
 875       word dummy;
 876
 877       for (;;) {
 878         buf_ptr = GC_parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev);
 879         if (buf_ptr == NULL) return current_best;
 880         if (prot_buf[1] == 'w' && maj_dev == 0) {
 881             if (end < (word)(&dummy) && start > current_best) current_best = start;
 882         }
 883       }
 884       return current_best;
 885     }
 886
 887     static word backing_store_base_from_proc(void)
 888     {
 889         return GC_apply_to_maps(backing_store_base_from_maps);
 890     }
 891
 892 #   ifdef USE_LIBC_PRIVATES
 893 #     pragma weak __libc_ia64_register_backing_store_base
 894       extern ptr_t __libc_ia64_register_backing_store_base;
 895 #   endif
 896
 897     ptr_t GC_get_register_stack_base(void)
 898     {
 899 #     ifdef USE_LIBC_PRIVATES
 900         if (0 != &__libc_ia64_register_backing_store_base
 901             && 0 != __libc_ia64_register_backing_store_base) {
 902           /* Glibc 2.2.4 has a bug such that for dynamically linked     */
 903           /* executables __libc_ia64_register_backing_store_base is     */
 904           /* defined but uninitialized during constructor calls.        */
 905           /* Hence we check for both nonzero address and value.         */
 906           return __libc_ia64_register_backing_store_base;
 907         }
 908 #     endif
 909       word result = backing_store_base_from_proc();
 910       if (0 == result) {
 911           /* Use dumb heuristics.  Works only for default configuration. */
 912           result = (word)GC_stackbottom - BACKING_STORE_DISPLACEMENT;
 913           result += BACKING_STORE_ALIGNMENT - 1;
 914           result &= ~(BACKING_STORE_ALIGNMENT - 1);
 915           /* Verify that it's at least readable.  If not, we goofed. */
 916           GC_noop1(*(word *)result);
 917       }
 918       return (ptr_t)result;
 919     }
 920 # endif
 921
 922   ptr_t GC_linux_stack_base(void)
 923   {
 924     /* We read the stack base value from /proc/self/stat.  We do this   */
 925     /* using direct I/O system calls in order to avoid calling malloc   */
 926     /* in case REDIRECT_MALLOC is defined.                              */
 927 #   define STAT_BUF_SIZE 4096
 928 #   define STAT_READ read
 929           /* Should probably call the real read, if read is wrapped.    */
 930     char stat_buf[STAT_BUF_SIZE];
 931     int f;
 932     char c;
 933     word result = 0;
 934     size_t i, buf_offset = 0;
 935
 936     /* First try the easy way.  This should work for glibc 2.2  */
 937     /* This fails in a prelinked ("prelink" command) executable */
 938     /* since the correct value of __libc_stack_end never        */
 939     /* becomes visible to us.  The second test works around     */
 940     /* this.                                                    */
 941 #   ifdef USE_LIBC_PRIVATES
 942       if (0 != &__libc_stack_end && 0 != __libc_stack_end ) {
 943 #       ifdef IA64
 944           /* Some versions of glibc set the address 16 bytes too        */
 945           /* low while the initialization code is running.              */
 946           if (((word)__libc_stack_end & 0xfff) + 0x10 < 0x1000) {
 947             return __libc_stack_end + 0x10;
 948           } /* Otherwise it's not safe to add 16 bytes and we fall      */
 949             /* back to using /proc.                                     */
 950 #       else
 951 #       ifdef SPARC
 952           /* Older versions of glibc for 64-bit Sparc do not set
 953            * this variable correctly, it gets set to either zero
 954            * or one.
 955            */
 956           if (__libc_stack_end != (ptr_t) (unsigned long)0x1)
 957             return __libc_stack_end;
 958 #       else
 959           return __libc_stack_end;
 960 #       endif
 961 #       endif
 962       }
 963 #   endif
 964     f = open("/proc/self/stat", O_RDONLY);
 965     if (f < 0 || STAT_READ(f, stat_buf, STAT_BUF_SIZE) < 2 * STAT_SKIP) {
 966         ABORT("Couldn't read /proc/self/stat");
 967     }
 968     c = stat_buf[buf_offset++];
 969     /* Skip the required number of fields.  This number is hopefully    */
 970     /* constant across all Linux implementations.                       */
 971       for (i = 0; i < STAT_SKIP; ++i) {
 972         while (isspace(c)) c = stat_buf[buf_offset++];
 973         while (!isspace(c)) c = stat_buf[buf_offset++];
 974       }
 975     while (isspace(c)) c = stat_buf[buf_offset++];
 976     while (isdigit(c)) {
 977       result *= 10;
 978       result += c - '0';
 979       c = stat_buf[buf_offset++];
 980     }
 981     close(f);
 982     if (result < 0x10000000) ABORT("Absurd stack bottom value");
 983     return (ptr_t)result;
 984   }
 985
 986 #endif /* LINUX_STACKBOTTOM */
 987
 988 #ifdef FREEBSD_STACKBOTTOM
 989
 990 /* This uses an undocumented sysctl call, but at least one expert       */
 991 /* believes it will stay.                                               */
 992
 993 #include <unistd.h>
 994 #include <sys/types.h>
 995 #include <sys/sysctl.h>
 996
 997   ptr_t GC_freebsd_stack_base(void)
 998   {
 999     int nm[2] = {CTL_KERN, KERN_USRSTACK};
1000     ptr_t base;
1001     size_t len = sizeof(ptr_t);
1002     int r = sysctl(nm, 2, &base, &len, NULL, 0);
1003
1004     if (r) ABORT("Error getting stack base");
1005
1006     return base;
1007   }
1008
1009 #endif /* FREEBSD_STACKBOTTOM */
1010
1011 #if !defined(BEOS) && !defined(AMIGA) && !defined(MSWIN32) \
1012     && !defined(MSWINCE) && !defined(OS2) && !defined(NOSYS) && !defined(ECOS)
1013
1014 ptr_t GC_get_stack_base()
1015 {
1016 #   if defined(HEURISTIC1) || defined(HEURISTIC2) || \
1017        defined(LINUX_STACKBOTTOM) || defined(FREEBSD_STACKBOTTOM)
1018     word dummy;
1019     ptr_t result;
1020 #   endif
1021
1022 #   define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1)
1023
1024 #   ifdef STACKBOTTOM
1025         return(STACKBOTTOM);
1026 #   else
1027 #       ifdef HEURISTIC1
1028 #          ifdef STACK_GROWS_DOWN
1029              result = (ptr_t)((((word)(&dummy))
1030                                + STACKBOTTOM_ALIGNMENT_M1)
1031                               & ~STACKBOTTOM_ALIGNMENT_M1);
1032 #          else
1033              result = (ptr_t)(((word)(&dummy))
1034                               & ~STACKBOTTOM_ALIGNMENT_M1);
1035 #          endif
1036 #       endif /* HEURISTIC1 */
1037 #       ifdef LINUX_STACKBOTTOM
1038            result = GC_linux_stack_base();
1039 #       endif
1040 #       ifdef FREEBSD_STACKBOTTOM
1041            result = GC_freebsd_stack_base();
1042 #       endif
1043 #       ifdef HEURISTIC2
1044 #           ifdef STACK_GROWS_DOWN
1045                 result = GC_find_limit((ptr_t)(&dummy), TRUE);
1046 #               ifdef HEURISTIC2_LIMIT
1047                     if (result > HEURISTIC2_LIMIT
1048                         && (ptr_t)(&dummy) < HEURISTIC2_LIMIT) {
1049                             result = HEURISTIC2_LIMIT;
1050                     }
1051 #               endif
1052 #           else
1053                 result = GC_find_limit((ptr_t)(&dummy), FALSE);
1054 #               ifdef HEURISTIC2_LIMIT
1055                     if (result < HEURISTIC2_LIMIT
1056                         && (ptr_t)(&dummy) > HEURISTIC2_LIMIT) {
1057                             result = HEURISTIC2_LIMIT;
1058                     }
1059 #               endif
1060 #           endif
1061
1062 #       endif /* HEURISTIC2 */
1063 #       ifdef STACK_GROWS_DOWN
1064             if (result == 0) result = (ptr_t)(signed_word)(-sizeof(ptr_t));
1065 #       endif
1066         return(result);
1067 #   endif /* STACKBOTTOM */
1068 }
1069
1070 # endif /* ! AMIGA, !OS 2, ! MS Windows, !BEOS, !NOSYS, !ECOS */
1071
1072 /*
1073  * Register static data segment(s) as roots.
1074  * If more data segments are added later then they need to be registered
1075  * add that point (as we do with SunOS dynamic loading),
1076  * or GC_mark_roots needs to check for them (as we do with PCR).
1077  * Called with allocator lock held.
1078  */
1079
1080 # ifdef OS2
1081
1082 void GC_register_data_segments()
1083 {
1084     PTIB ptib;
1085     PPIB ppib;
1086     HMODULE module_handle;
1087 #   define PBUFSIZ 512
1088     UCHAR path[PBUFSIZ];
1089     FILE * myexefile;
1090     struct exe_hdr hdrdos;      /* MSDOS header.        */
1091     struct e32_exe hdr386;      /* Real header for my executable */
1092     struct o32_obj seg; /* Currrent segment */
1093     int nsegs;
1094
1095
1096     if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
1097         GC_err_printf0("DosGetInfoBlocks failed\n");
1098         ABORT("DosGetInfoBlocks failed\n");
1099     }
1100     module_handle = ppib -> pib_hmte;
1101     if (DosQueryModuleName(module_handle, PBUFSIZ, path) != NO_ERROR) {
1102         GC_err_printf0("DosQueryModuleName failed\n");
1103         ABORT("DosGetInfoBlocks failed\n");
1104     }
1105     myexefile = fopen(path, "rb");
1106     if (myexefile == 0) {
1107         GC_err_puts("Couldn't open executable ");
1108         GC_err_puts(path); GC_err_puts("\n");
1109         ABORT("Failed to open executable\n");
1110     }
1111     if (fread((char *)(&hdrdos), 1, sizeof hdrdos, myexefile) < sizeof hdrdos) {
1112         GC_err_puts("Couldn't read MSDOS header from ");
1113         GC_err_puts(path); GC_err_puts("\n");
1114         ABORT("Couldn't read MSDOS header");
1115     }
1116     if (E_MAGIC(hdrdos) != EMAGIC) {
1117         GC_err_puts("Executable has wrong DOS magic number: ");
1118         GC_err_puts(path); GC_err_puts("\n");
1119         ABORT("Bad DOS magic number");
1120     }
1121     if (fseek(myexefile, E_LFANEW(hdrdos), SEEK_SET) != 0) {
1122         GC_err_puts("Seek to new header failed in ");
1123         GC_err_puts(path); GC_err_puts("\n");
1124         ABORT("Bad DOS magic number");
1125     }
1126     if (fread((char *)(&hdr386), 1, sizeof hdr386, myexefile) < sizeof hdr386) {
1127         GC_err_puts("Couldn't read MSDOS header from ");
1128         GC_err_puts(path); GC_err_puts("\n");
1129         ABORT("Couldn't read OS/2 header");
1130     }
1131     if (E32_MAGIC1(hdr386) != E32MAGIC1 || E32_MAGIC2(hdr386) != E32MAGIC2) {
1132         GC_err_puts("Executable has wrong OS/2 magic number:");
1133         GC_err_puts(path); GC_err_puts("\n");
1134         ABORT("Bad OS/2 magic number");
1135     }
1136     if ( E32_BORDER(hdr386) != E32LEBO || E32_WORDER(hdr386) != E32LEWO) {
1137         GC_err_puts("Executable %s has wrong byte order: ");
1138         GC_err_puts(path); GC_err_puts("\n");
1139         ABORT("Bad byte order");
1140     }
1141     if ( E32_CPU(hdr386) == E32CPU286) {
1142         GC_err_puts("GC can't handle 80286 executables: ");
1143         GC_err_puts(path); GC_err_puts("\n");
1144         EXIT();
1145     }
1146     if (fseek(myexefile, E_LFANEW(hdrdos) + E32_OBJTAB(hdr386),
1147               SEEK_SET) != 0) {
1148         GC_err_puts("Seek to object table failed: ");
1149         GC_err_puts(path); GC_err_puts("\n");
1150         ABORT("Seek to object table failed");
1151     }
1152     for (nsegs = E32_OBJCNT(hdr386); nsegs > 0; nsegs--) {
1153       int flags;
1154       if (fread((char *)(&seg), 1, sizeof seg, myexefile) < sizeof seg) {
1155         GC_err_puts("Couldn't read obj table entry from ");
1156         GC_err_puts(path); GC_err_puts("\n");
1157         ABORT("Couldn't read obj table entry");
1158       }
1159       flags = O32_FLAGS(seg);
1160       if (!(flags & OBJWRITE)) continue;
1161       if (!(flags & OBJREAD)) continue;
1162       if (flags & OBJINVALID) {
1163           GC_err_printf0("Object with invalid pages?\n");
1164           continue;
1165       }
1166       GC_add_roots_inner(O32_BASE(seg), O32_BASE(seg)+O32_SIZE(seg), FALSE);
1167     }
1168 }
1169
1170 # else /* !OS2 */
1171
1172 # if defined(MSWIN32) || defined(MSWINCE)
1173
1174 # ifdef MSWIN32
1175   /* Unfortunately, we have to handle win32s very differently from NT,  */
1176   /* Since VirtualQuery has very different semantics.  In particular,   */
1177   /* under win32s a VirtualQuery call on an unmapped page returns an    */
1178   /* invalid result.  Under NT, GC_register_data_segments is a noop and */
1179   /* all real work is done by GC_register_dynamic_libraries.  Under     */
1180   /* win32s, we cannot find the data segments associated with dll's.    */
1181   /* We register the main data segment here.                            */
1182   GC_bool GC_no_win32_dlls = FALSE;
1183         /* This used to be set for gcc, to avoid dealing with           */
1184         /* the structured exception handling issues.  But we now have   */
1185         /* assembly code to do that right.                              */
1186   GC_bool GC_wnt = FALSE;
1187         /* This is a Windows NT derivative, i.e. NT, W2K, XP or later.  */
1188
1189   void GC_init_win32()
1190   {
1191     /* if we're running under win32s, assume that no DLLs will be loaded */
1192     DWORD v = GetVersion();
1193     GC_wnt = !(v & 0x80000000);
1194     GC_no_win32_dlls |= ((!GC_wnt) && (v & 0xff) <= 3);
1195   }
1196
1197   /* Return the smallest address a such that VirtualQuery               */
1198   /* returns correct results for all addresses between a and start.     */
1199   /* Assumes VirtualQuery returns correct information for start.        */
1200   ptr_t GC_least_described_address(ptr_t start)
1201   {
1202     MEMORY_BASIC_INFORMATION buf;
1203     DWORD result;
1204     LPVOID limit;
1205     ptr_t p;
1206     LPVOID q;
1207
1208     limit = GC_sysinfo.lpMinimumApplicationAddress;
1209     p = (ptr_t)((word)start & ~(GC_page_size - 1));
1210     for (;;) {
1211         q = (LPVOID)(p - GC_page_size);
1212         if ((ptr_t)q > (ptr_t)p /* underflow */ || q < limit) break;
1213         result = VirtualQuery(q, &buf, sizeof(buf));
1214         if (result != sizeof(buf) || buf.AllocationBase == 0) break;
1215         p = (ptr_t)(buf.AllocationBase);
1216     }
1217     return(p);
1218   }
1219 # endif
1220
1221 # ifndef REDIRECT_MALLOC
1222   /* We maintain a linked list of AllocationBase values that we know    */
1223   /* correspond to malloc heap sections.  Currently this is only called */
1224   /* during a GC.  But there is some hope that for long running         */
1225   /* programs we will eventually see most heap sections.                */
1226
1227   /* In the long run, it would be more reliable to occasionally walk    */
1228   /* the malloc heap with HeapWalk on the default heap.  But that       */
1229   /* apparently works only for NT-based Windows.                        */
1230
1231   /* In the long run, a better data structure would also be nice ...    */
1232   struct GC_malloc_heap_list {
1233     void * allocation_base;
1234     struct GC_malloc_heap_list *next;
1235   } *GC_malloc_heap_l = 0;
1236
1237   /* Is p the base of one of the malloc heap sections we already know   */
1238   /* about?                                                             */
1239   GC_bool GC_is_malloc_heap_base(ptr_t p)
1240   {
1241     struct GC_malloc_heap_list *q = GC_malloc_heap_l;
1242
1243     while (0 != q) {
1244       if (q -> allocation_base == p) return TRUE;
1245       q = q -> next;
1246     }
1247     return FALSE;
1248   }
1249
1250   void *GC_get_allocation_base(void *p)
1251   {
1252     MEMORY_BASIC_INFORMATION buf;
1253     DWORD result = VirtualQuery(p, &buf, sizeof(buf));
1254     if (result != sizeof(buf)) {
1255       ABORT("Weird VirtualQuery result");
1256     }
1257     return buf.AllocationBase;
1258   }
1259
1260   size_t GC_max_root_size = 100000;     /* Appr. largest root size.     */
1261
1262   void GC_add_current_malloc_heap()
1263   {
1264     struct GC_malloc_heap_list *new_l =
1265                  malloc(sizeof(struct GC_malloc_heap_list));
1266     void * candidate = GC_get_allocation_base(new_l);
1267
1268     if (new_l == 0) return;
1269     if (GC_is_malloc_heap_base(candidate)) {
1270       /* Try a little harder to find malloc heap.                       */
1271         size_t req_size = 10000;
1272         do {
1273           void *p = malloc(req_size);
1274           if (0 == p) { free(new_l); return; }
1275           candidate = GC_get_allocation_base(p);
1276           free(p);
1277           req_size *= 2;
1278         } while (GC_is_malloc_heap_base(candidate)
1279                  && req_size < GC_max_root_size/10 && req_size < 500000);
1280         if (GC_is_malloc_heap_base(candidate)) {
1281           free(new_l); return;
1282         }
1283     }
1284 #   ifdef CONDPRINT
1285       if (GC_print_stats)
1286           GC_printf1("Found new system malloc AllocationBase at 0x%lx\n",
1287                      candidate);
1288 #   endif
1289     new_l -> allocation_base = candidate;
1290     new_l -> next = GC_malloc_heap_l;
1291     GC_malloc_heap_l = new_l;
1292   }
1293 # endif /* REDIRECT_MALLOC */
1294
1295   /* Is p the start of either the malloc heap, or of one of our */
1296   /* heap sections?                                             */
1297   GC_bool GC_is_heap_base (ptr_t p)
1298   {
1299
1300      unsigned i;
1301
1302 #    ifndef REDIRECT_MALLOC
1303        static word last_gc_no = -1;
1304
1305        if (last_gc_no != GC_gc_no) {
1306          GC_add_current_malloc_heap();
1307          last_gc_no = GC_gc_no;
1308        }
1309        if (GC_root_size > GC_max_root_size) GC_max_root_size = GC_root_size;
1310        if (GC_is_malloc_heap_base(p)) return TRUE;
1311 #    endif
1312      for (i = 0; i < GC_n_heap_bases; i++) {
1313          if (GC_heap_bases[i] == p) return TRUE;
1314      }
1315      return FALSE ;
1316   }
1317
1318 # ifdef MSWIN32
1319   void GC_register_root_section(ptr_t static_root)
1320   {
1321       MEMORY_BASIC_INFORMATION buf;
1322       DWORD result;
1323       DWORD protect;
1324       LPVOID p;
1325       char * base;
1326       char * limit, * new_limit;
1327
1328       if (!GC_no_win32_dlls) return;
1329       p = base = limit = GC_least_described_address(static_root);
1330       while (p < GC_sysinfo.lpMaximumApplicationAddress) {
1331         result = VirtualQuery(p, &buf, sizeof(buf));
1332         if (result != sizeof(buf) || buf.AllocationBase == 0
1333             || GC_is_heap_base(buf.AllocationBase)) break;
1334         new_limit = (char *)p + buf.RegionSize;
1335         protect = buf.Protect;
1336         if (buf.State == MEM_COMMIT
1337             && is_writable(protect)) {
1338             if ((char *)p == limit) {
1339                 limit = new_limit;
1340             } else {
1341                 if (base != limit) GC_add_roots_inner(base, limit, FALSE);
1342                 base = p;
1343                 limit = new_limit;
1344             }
1345         }
1346         if (p > (LPVOID)new_limit /* overflow */) break;
1347         p = (LPVOID)new_limit;
1348       }
1349       if (base != limit) GC_add_roots_inner(base, limit, FALSE);
1350   }
1351 #endif
1352
1353   void GC_register_data_segments()
1354   {
1355 #     ifdef MSWIN32
1356       static char dummy;
1357       GC_register_root_section((ptr_t)(&dummy));
1358 #     endif
1359   }
1360
1361 # else /* !OS2 && !Windows */
1362
1363 # if (defined(SVR4) || defined(AUX) || defined(DGUX) \
1364       || (defined(LINUX) && defined(SPARC))) && !defined(PCR)
1365 ptr_t GC_SysVGetDataStart(max_page_size, etext_addr)
1366 int max_page_size;
1367 int * etext_addr;
1368 {
1369     word text_end = ((word)(etext_addr) + sizeof(word) - 1)
1370                     & ~(sizeof(word) - 1);
1371         /* etext rounded to word boundary       */
1372     word next_page = ((text_end + (word)max_page_size - 1)
1373                       & ~((word)max_page_size - 1));
1374     word page_offset = (text_end & ((word)max_page_size - 1));
1375     VOLATILE char * result = (char *)(next_page + page_offset);
1376     /* Note that this isnt equivalent to just adding            */
1377     /* max_page_size to &etext if &etext is at a page boundary  */
1378
1379     GC_setup_temporary_fault_handler();
1380     if (SETJMP(GC_jmp_buf) == 0) {
1381         /* Try writing to the address.  */
1382         *result = *result;
1383         GC_reset_fault_handler();
1384     } else {
1385         GC_reset_fault_handler();
1386         /* We got here via a longjmp.  The address is not readable.     */
1387         /* This is known to happen under Solaris 2.4 + gcc, which place */
1388         /* string constants in the text segment, but after etext.       */
1389         /* Use plan B.  Note that we now know there is a gap between    */
1390         /* text and data segments, so plan A bought us something.       */
1391         result = (char *)GC_find_limit((ptr_t)(DATAEND), FALSE);
1392     }
1393     return((ptr_t)result);
1394 }
1395 # endif
1396
1397 # if defined(FREEBSD) && (defined(I386) || defined(X86_64) || defined(powerpc) || defined(__powerpc__)) && !defined(PCR)
1398 /* Its unclear whether this should be identical to the above, or        */
1399 /* whether it should apply to non-X86 architectures.                    */
1400 /* For now we don't assume that there is always an empty page after     */
1401 /* etext.  But in some cases there actually seems to be slightly more.  */
1402 /* This also deals with holes between read-only data and writable data. */
1403 ptr_t GC_FreeBSDGetDataStart(max_page_size, etext_addr)
1404 int max_page_size;
1405 int * etext_addr;
1406 {
1407     word text_end = ((word)(etext_addr) + sizeof(word) - 1)
1408                      & ~(sizeof(word) - 1);
1409         /* etext rounded to word boundary       */
1410     VOLATILE word next_page = (text_end + (word)max_page_size - 1)
1411                               & ~((word)max_page_size - 1);
1412     VOLATILE ptr_t result = (ptr_t)text_end;
1413     GC_setup_temporary_fault_handler();
1414     if (SETJMP(GC_jmp_buf) == 0) {
1415         /* Try reading at the address.                          */
1416         /* This should happen before there is another thread.   */
1417         for (; next_page < (word)(DATAEND); next_page += (word)max_page_size)
1418             *(VOLATILE char *)next_page;
1419         GC_reset_fault_handler();
1420     } else {
1421         GC_reset_fault_handler();
1422         /* As above, we go to plan B    */
1423         result = GC_find_limit((ptr_t)(DATAEND), FALSE);
1424     }
1425     return(result);
1426 }
1427
1428 # endif
1429
1430
1431 #ifdef AMIGA
1432
1433 #  define GC_AMIGA_DS
1434 #  include "AmigaOS.c"
1435 #  undef GC_AMIGA_DS
1436
1437 #else /* !OS2 && !Windows && !AMIGA */
1438
1439 void GC_register_data_segments()
1440 {
1441 #   if !defined(PCR) && !defined(SRC_M3) && !defined(MACOS)
1442 #     if defined(REDIRECT_MALLOC) && defined(GC_SOLARIS_THREADS)
1443         /* As of Solaris 2.3, the Solaris threads implementation        */
1444         /* allocates the data structure for the initial thread with     */
1445         /* sbrk at process startup.  It needs to be scanned, so that    */
1446         /* we don't lose some malloc allocated data structures          */
1447         /* hanging from it.  We're on thin ice here ...                 */
1448         extern caddr_t sbrk();
1449
1450         GC_add_roots_inner(DATASTART, (char *)sbrk(0), FALSE);
1451 #     else
1452         GC_add_roots_inner(DATASTART, (char *)(DATAEND), FALSE);
1453 #       if defined(DATASTART2)
1454          GC_add_roots_inner(DATASTART2, (char *)(DATAEND2), FALSE);
1455 #       endif
1456 #     endif
1457 #   endif
1458 #   if defined(MACOS)
1459     {
1460 #   if defined(THINK_C)
1461         extern void* GC_MacGetDataStart(void);
1462         /* globals begin above stack and end at a5. */
1463         GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
1464                            (ptr_t)LMGetCurrentA5(), FALSE);
1465 #   else
1466 #     if defined(__MWERKS__)
1467 #       if !__POWERPC__
1468           extern void* GC_MacGetDataStart(void);
1469           /* MATTHEW: Function to handle Far Globals (CW Pro 3) */
1470 #         if __option(far_data)
1471           extern void* GC_MacGetDataEnd(void);
1472 #         endif
1473           /* globals begin above stack and end at a5. */
1474           GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
1475                              (ptr_t)LMGetCurrentA5(), FALSE);
1476           /* MATTHEW: Handle Far Globals */
1477 #         if __option(far_data)
1478       /* Far globals follow he QD globals: */
1479           GC_add_roots_inner((ptr_t)LMGetCurrentA5(),
1480                              (ptr_t)GC_MacGetDataEnd(), FALSE);
1481 #         endif
1482 #       else
1483           extern char __data_start__[], __data_end__[];
1484           GC_add_roots_inner((ptr_t)&__data_start__,
1485                              (ptr_t)&__data_end__, FALSE);
1486 #       endif /* __POWERPC__ */
1487 #     endif /* __MWERKS__ */
1488 #   endif /* !THINK_C */
1489     }
1490 #   endif /* MACOS */
1491
1492     /* Dynamic libraries are added at every collection, since they may  */
1493     /* change.                                                          */
1494 }
1495
1496 # endif  /* ! AMIGA */
1497 # endif  /* ! MSWIN32 && ! MSWINCE*/
1498 # endif  /* ! OS2 */
1499
1500 /*
1501  * Auxiliary routines for obtaining memory from OS.
1502  */
1503
1504 # if !defined(OS2) && !defined(PCR) && !defined(AMIGA) \
1505         && !defined(MSWIN32) && !defined(MSWINCE) \
1506         && !defined(MACOS) && !defined(DOS4GW)
1507
1508 # ifdef SUNOS4
1509     extern caddr_t sbrk();
1510 # endif
1511 # ifdef __STDC__
1512 #   define SBRK_ARG_T ptrdiff_t
1513 # else
1514 #   define SBRK_ARG_T int
1515 # endif
1516
1517
1518 # if 0 && defined(RS6000)  /* We now use mmap */
1519 /* The compiler seems to generate speculative reads one past the end of */
1520 /* an allocated object.  Hence we need to make sure that the page       */
1521 /* following the last heap page is also mapped.                         */
1522 ptr_t GC_unix_get_mem(bytes)
1523 word bytes;
1524 {
1525     caddr_t cur_brk = (caddr_t)sbrk(0);
1526     caddr_t result;
1527     SBRK_ARG_T lsbs = (word)cur_brk & (GC_page_size-1);
1528     static caddr_t my_brk_val = 0;
1529
1530     if ((SBRK_ARG_T)bytes < 0) return(0); /* too big */
1531     if (lsbs != 0) {
1532         if((caddr_t)(sbrk(GC_page_size - lsbs)) == (caddr_t)(-1)) return(0);
1533     }
1534     if (cur_brk == my_brk_val) {
1535         /* Use the extra block we allocated last time. */
1536         result = (ptr_t)sbrk((SBRK_ARG_T)bytes);
1537         if (result == (caddr_t)(-1)) return(0);
1538         result -= GC_page_size;
1539     } else {
1540         result = (ptr_t)sbrk(GC_page_size + (SBRK_ARG_T)bytes);
1541         if (result == (caddr_t)(-1)) return(0);
1542     }
1543     my_brk_val = result + bytes + GC_page_size; /* Always page aligned */
1544     return((ptr_t)result);
1545 }
1546
1547 #else  /* Not RS6000 */
1548
1549 #if defined(USE_MMAP) || defined(USE_MUNMAP)
1550
1551 #ifdef USE_MMAP_FIXED
1552 #   define GC_MMAP_FLAGS MAP_FIXED | MAP_PRIVATE
1553         /* Seems to yield better performance on Solaris 2, but can      */
1554         /* be unreliable if something is already mapped at the address. */
1555 #else
1556 #   define GC_MMAP_FLAGS MAP_PRIVATE
1557 #endif
1558
1559 #ifdef USE_MMAP_ANON
1560 # define zero_fd -1
1561 # if defined(MAP_ANONYMOUS)
1562 #   define OPT_MAP_ANON MAP_ANONYMOUS
1563 # else
1564 #   define OPT_MAP_ANON MAP_ANON
1565 # endif
1566 #else
1567   static int zero_fd;
1568 # define OPT_MAP_ANON 0
1569 #endif
1570
1571 #endif /* defined(USE_MMAP) || defined(USE_MUNMAP) */
1572
1573 #if defined(USE_MMAP)
1574 /* Tested only under Linux, IRIX5 and Solaris 2 */
1575
1576 #ifndef HEAP_START
1577 #   define HEAP_START 0
1578 #endif
1579
1580 ptr_t GC_unix_get_mem(bytes)
1581 word bytes;
1582 {
1583     void *result;
1584     static ptr_t last_addr = HEAP_START;
1585
1586 #   ifndef USE_MMAP_ANON
1587       static GC_bool initialized = FALSE;
1588
1589       if (!initialized) {
1590           zero_fd = open("/dev/zero", O_RDONLY);
1591           fcntl(zero_fd, F_SETFD, FD_CLOEXEC);
1592           initialized = TRUE;
1593       }
1594 #   endif
1595
1596     if (bytes & (GC_page_size -1)) ABORT("Bad GET_MEM arg");
1597     result = mmap(last_addr, bytes, PROT_READ | PROT_WRITE | OPT_PROT_EXEC,
1598                   GC_MMAP_FLAGS | OPT_MAP_ANON, zero_fd, 0/* offset */);
1599     if (result == MAP_FAILED) return(0);
1600     last_addr = (ptr_t)result + bytes + GC_page_size - 1;
1601     last_addr = (ptr_t)((word)last_addr & ~(GC_page_size - 1));
1602 #   if !defined(LINUX)
1603       if (last_addr == 0) {
1604         /* Oops.  We got the end of the address space.  This isn't      */
1605         /* usable by arbitrary C code, since one-past-end pointers      */
1606         /* don't work, so we discard it and try again.                  */
1607         munmap(result, (size_t)(-GC_page_size) - (size_t)result);
1608                         /* Leave last page mapped, so we can't repeat. */
1609         return GC_unix_get_mem(bytes);
1610       }
1611 #   else
1612       GC_ASSERT(last_addr != 0);
1613 #   endif
1614     return((ptr_t)result);
1615 }
1616
1617 #else /* Not RS6000, not USE_MMAP */
1618 ptr_t GC_unix_get_mem(bytes)
1619 word bytes;
1620 {
1621   ptr_t result;
1622 # ifdef IRIX5
1623     /* Bare sbrk isn't thread safe.  Play by malloc rules.      */
1624     /* The equivalent may be needed on other systems as well.   */
1625     __LOCK_MALLOC();
1626 # endif
1627   {
1628     ptr_t cur_brk = (ptr_t)sbrk(0);
1629     SBRK_ARG_T lsbs = (word)cur_brk & (GC_page_size-1);
1630
1631     if ((SBRK_ARG_T)bytes < 0) return(0); /* too big */
1632     if (lsbs != 0) {
1633         if((ptr_t)sbrk(GC_page_size - lsbs) == (ptr_t)(-1)) return(0);
1634     }
1635     result = (ptr_t)sbrk((SBRK_ARG_T)bytes);
1636     if (result == (ptr_t)(-1)) result = 0;
1637   }
1638 # ifdef IRIX5
1639     __UNLOCK_MALLOC();
1640 # endif
1641   return(result);
1642 }
1643
1644 #endif /* Not USE_MMAP */
1645 #endif /* Not RS6000 */
1646
1647 # endif /* UN*X */
1648
1649 # ifdef OS2
1650
1651 void * os2_alloc(size_t bytes)
1652 {
1653     void * result;
1654
1655     if (DosAllocMem(&result, bytes, PAG_EXECUTE | PAG_READ |
1656                                     PAG_WRITE | PAG_COMMIT)
1657                     != NO_ERROR) {
1658         return(0);
1659     }
1660     if (result == 0) return(os2_alloc(bytes));
1661     return(result);
1662 }
1663
1664 # endif /* OS2 */
1665
1666
1667 # if defined(MSWIN32) || defined(MSWINCE)
1668 SYSTEM_INFO GC_sysinfo;
1669 # endif
1670
1671 # ifdef MSWIN32
1672
1673 # ifdef USE_GLOBAL_ALLOC
1674 #   define GLOBAL_ALLOC_TEST 1
1675 # else
1676 #   define GLOBAL_ALLOC_TEST GC_no_win32_dlls
1677 # endif
1678
1679 word GC_n_heap_bases = 0;
1680
1681 ptr_t GC_win32_get_mem(bytes)
1682 word bytes;
1683 {
1684     ptr_t result;
1685
1686     if (GLOBAL_ALLOC_TEST) {
1687         /* VirtualAlloc doesn't like PAGE_EXECUTE_READWRITE.    */
1688         /* There are also unconfirmed rumors of other           */
1689         /* problems, so we dodge the issue.                     */
1690         result = (ptr_t) GlobalAlloc(0, bytes + HBLKSIZE);
1691         result = (ptr_t)(((word)result + HBLKSIZE) & ~(HBLKSIZE-1));
1692     } else {
1693         /* VirtualProtect only works on regions returned by a   */
1694         /* single VirtualAlloc call.  Thus we allocate one      */
1695         /* extra page, which will prevent merging of blocks     */
1696         /* in separate regions, and eliminate any temptation    */
1697         /* to call VirtualProtect on a range spanning regions.  */
1698         /* This wastes a small amount of memory, and risks      */
1699         /* increased fragmentation.  But better alternatives    */
1700         /* would require effort.                                */
1701         result = (ptr_t) VirtualAlloc(NULL, bytes + 1,
1702                                       MEM_COMMIT | MEM_RESERVE,
1703                                       PAGE_EXECUTE_READWRITE);
1704     }
1705     if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1706         /* If I read the documentation correctly, this can      */
1707         /* only happen if HBLKSIZE > 64k or not a power of 2.   */
1708     if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections");
1709     GC_heap_bases[GC_n_heap_bases++] = result;
1710     return(result);
1711 }
1712
1713 void GC_win32_free_heap ()
1714 {
1715     if (GC_no_win32_dlls) {
1716         while (GC_n_heap_bases > 0) {
1717             GlobalFree (GC_heap_bases[--GC_n_heap_bases]);
1718             GC_heap_bases[GC_n_heap_bases] = 0;
1719         }
1720     }
1721 }
1722 # endif
1723
1724 #ifdef AMIGA
1725 # define GC_AMIGA_AM
1726 # include "AmigaOS.c"
1727 # undef GC_AMIGA_AM
1728 #endif
1729
1730
1731 # ifdef MSWINCE
1732 word GC_n_heap_bases = 0;
1733
1734 ptr_t GC_wince_get_mem(bytes)
1735 word bytes;
1736 {
1737     ptr_t result;
1738     word i;
1739
1740     /* Round up allocation size to multiple of page size */
1741     bytes = (bytes + GC_page_size-1) & ~(GC_page_size-1);
1742
1743     /* Try to find reserved, uncommitted pages */
1744     for (i = 0; i < GC_n_heap_bases; i++) {
1745         if (((word)(-(signed_word)GC_heap_lengths[i])
1746              & (GC_sysinfo.dwAllocationGranularity-1))
1747             >= bytes) {
1748             result = GC_heap_bases[i] + GC_heap_lengths[i];
1749             break;
1750         }
1751     }
1752
1753     if (i == GC_n_heap_bases) {
1754         /* Reserve more pages */
1755         word res_bytes = (bytes + GC_sysinfo.dwAllocationGranularity-1)
1756                          & ~(GC_sysinfo.dwAllocationGranularity-1);
1757         /* If we ever support MPROTECT_VDB here, we will probably need to       */
1758         /* ensure that res_bytes is strictly > bytes, so that VirtualProtect    */
1759         /* never spans regions.  It seems to be OK for a VirtualFree argument   */
1760         /* to span regions, so we should be OK for now.                         */
1761         result = (ptr_t) VirtualAlloc(NULL, res_bytes,
1762                                       MEM_RESERVE | MEM_TOP_DOWN,
1763                                       PAGE_EXECUTE_READWRITE);
1764         if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1765             /* If I read the documentation correctly, this can  */
1766             /* only happen if HBLKSIZE > 64k or not a power of 2.       */
1767         if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections");
1768         GC_heap_bases[GC_n_heap_bases] = result;
1769         GC_heap_lengths[GC_n_heap_bases] = 0;
1770         GC_n_heap_bases++;
1771     }
1772
1773     /* Commit pages */
1774     result = (ptr_t) VirtualAlloc(result, bytes,
1775                                   MEM_COMMIT,
1776                                   PAGE_EXECUTE_READWRITE);
1777     if (result != NULL) {
1778         if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1779         GC_heap_lengths[i] += bytes;
1780     }
1781
1782     return(result);
1783 }
1784 # endif
1785
1786 #ifdef USE_MUNMAP
1787
1788 /* For now, this only works on Win32/WinCE and some Unix-like   */
1789 /* systems.  If you have something else, don't define           */
1790 /* USE_MUNMAP.                                                  */
1791 /* We assume ANSI C to support this feature.                    */
1792
1793 #if !defined(MSWIN32) && !defined(MSWINCE)
1794
1795 #include <unistd.h>
1796 #include <sys/mman.h>
1797 #include <sys/stat.h>
1798 #include <sys/types.h>
1799
1800 #endif
1801
1802 /* Compute a page aligned starting address for the unmap        */
1803 /* operation on a block of size bytes starting at start.        */
1804 /* Return 0 if the block is too small to make this feasible.    */
1805 ptr_t GC_unmap_start(ptr_t start, word bytes)
1806 {
1807     ptr_t result = start;
1808     /* Round start to next page boundary.       */
1809         result += GC_page_size - 1;
1810         result = (ptr_t)((word)result & ~(GC_page_size - 1));
1811     if (result + GC_page_size > start + bytes) return 0;
1812     return result;
1813 }
1814
1815 /* Compute end address for an unmap operation on the indicated  */
1816 /* block.                                                       */
1817 ptr_t GC_unmap_end(ptr_t start, word bytes)
1818 {
1819     ptr_t end_addr = start + bytes;
1820     end_addr = (ptr_t)((word)end_addr & ~(GC_page_size - 1));
1821     return end_addr;
1822 }
1823
1824 /* Under Win32/WinCE we commit (map) and decommit (unmap)       */
1825 /* memory using VirtualAlloc and VirtualFree.  These functions  */
1826 /* work on individual allocations of virtual memory, made       */
1827 /* previously using VirtualAlloc with the MEM_RESERVE flag.     */
1828 /* The ranges we need to (de)commit may span several of these   */
1829 /* allocations; therefore we use VirtualQuery to check          */
1830 /* allocation lengths, and split up the range as necessary.     */
1831
1832 /* We assume that GC_remap is called on exactly the same range  */
1833 /* as a previous call to GC_unmap.  It is safe to consistently  */
1834 /* round the endpoints in both places.                          */
1835 void GC_unmap(ptr_t start, word bytes)
1836 {
1837     ptr_t start_addr = GC_unmap_start(start, bytes);
1838     ptr_t end_addr = GC_unmap_end(start, bytes);
1839     word len = end_addr - start_addr;
1840     if (0 == start_addr) return;
1841 #   if defined(MSWIN32) || defined(MSWINCE)
1842       while (len != 0) {
1843           MEMORY_BASIC_INFORMATION mem_info;
1844           GC_word free_len;
1845           if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1846               != sizeof(mem_info))
1847               ABORT("Weird VirtualQuery result");
1848           free_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1849           if (!VirtualFree(start_addr, free_len, MEM_DECOMMIT))
1850               ABORT("VirtualFree failed");
1851           GC_unmapped_bytes += free_len;
1852           start_addr += free_len;
1853           len -= free_len;
1854       }
1855 #   else
1856       /* We immediately remap it to prevent an intervening mmap from    */
1857       /* accidentally grabbing the same address space.                  */
1858       {
1859         void * result;
1860         result = mmap(start_addr, len, PROT_NONE,
1861                       MAP_PRIVATE | MAP_FIXED | OPT_MAP_ANON,
1862                       zero_fd, 0/* offset */);
1863         if (result != (void *)start_addr) ABORT("mmap(...PROT_NONE...) failed");
1864       }
1865       GC_unmapped_bytes += len;
1866 #   endif
1867 }
1868
1869
1870 void GC_remap(ptr_t start, word bytes)
1871 {
1872     ptr_t start_addr = GC_unmap_start(start, bytes);
1873     ptr_t end_addr = GC_unmap_end(start, bytes);
1874     word len = end_addr - start_addr;
1875
1876 #   if defined(MSWIN32) || defined(MSWINCE)
1877       ptr_t result;
1878
1879       if (0 == start_addr) return;
1880       while (len != 0) {
1881           MEMORY_BASIC_INFORMATION mem_info;
1882           GC_word alloc_len;
1883           if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1884               != sizeof(mem_info))
1885               ABORT("Weird VirtualQuery result");
1886           alloc_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1887           result = VirtualAlloc(start_addr, alloc_len,
1888                                 MEM_COMMIT,
1889                                 PAGE_EXECUTE_READWRITE);
1890           if (result != start_addr) {
1891               ABORT("VirtualAlloc remapping failed");
1892           }
1893           GC_unmapped_bytes -= alloc_len;
1894           start_addr += alloc_len;
1895           len -= alloc_len;
1896       }
1897 #   else
1898       /* It was already remapped with PROT_NONE. */
1899       int result;
1900
1901       if (0 == start_addr) return;
1902       result = mprotect(start_addr, len,
1903                         PROT_READ | PROT_WRITE | OPT_PROT_EXEC);
1904       if (result != 0) {
1905           GC_err_printf3(
1906                 "Mprotect failed at 0x%lx (length %ld) with errno %ld\n",
1907                 start_addr, len, errno);
1908           ABORT("Mprotect remapping failed");
1909       }
1910       GC_unmapped_bytes -= len;
1911 #   endif
1912 }
1913
1914 /* Two adjacent blocks have already been unmapped and are about to      */
1915 /* be merged.  Unmap the whole block.  This typically requires          */
1916 /* that we unmap a small section in the middle that was not previously  */
1917 /* unmapped due to alignment constraints.                               */
1918 void GC_unmap_gap(ptr_t start1, word bytes1, ptr_t start2, word bytes2)
1919 {
1920     ptr_t start1_addr = GC_unmap_start(start1, bytes1);
1921     ptr_t end1_addr = GC_unmap_end(start1, bytes1);
1922     ptr_t start2_addr = GC_unmap_start(start2, bytes2);
1923     ptr_t end2_addr = GC_unmap_end(start2, bytes2);
1924     ptr_t start_addr = end1_addr;
1925     ptr_t end_addr = start2_addr;
1926     word len;
1927     GC_ASSERT(start1 + bytes1 == start2);
1928     if (0 == start1_addr) start_addr = GC_unmap_start(start1, bytes1 + bytes2);
1929     if (0 == start2_addr) end_addr = GC_unmap_end(start1, bytes1 + bytes2);
1930     if (0 == start_addr) return;
1931     len = end_addr - start_addr;
1932 #   if defined(MSWIN32) || defined(MSWINCE)
1933       while (len != 0) {
1934           MEMORY_BASIC_INFORMATION mem_info;
1935           GC_word free_len;
1936           if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1937               != sizeof(mem_info))
1938               ABORT("Weird VirtualQuery result");
1939           free_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1940           if (!VirtualFree(start_addr, free_len, MEM_DECOMMIT))
1941               ABORT("VirtualFree failed");
1942           GC_unmapped_bytes += free_len;
1943           start_addr += free_len;
1944           len -= free_len;
1945       }
1946 #   else
1947       if (len != 0 && munmap(start_addr, len) != 0) ABORT("munmap failed");
1948       GC_unmapped_bytes += len;
1949 #   endif
1950 }
1951
1952 #endif /* USE_MUNMAP */
1953
1954 /* Routine for pushing any additional roots.  In THREADS        */
1955 /* environment, this is also responsible for marking from       */
1956 /* thread stacks.                                               */
1957 #ifndef THREADS
1958 void (*GC_push_other_roots)() = 0;
1959 #else /* THREADS */
1960
1961 # ifdef PCR
1962 PCR_ERes GC_push_thread_stack(PCR_Th_T *t, PCR_Any dummy)
1963 {
1964     struct PCR_ThCtl_TInfoRep info;
1965     PCR_ERes result;
1966
1967     info.ti_stkLow = info.ti_stkHi = 0;
1968     result = PCR_ThCtl_GetInfo(t, &info);
1969     GC_push_all_stack((ptr_t)(info.ti_stkLow), (ptr_t)(info.ti_stkHi));
1970     return(result);
1971 }
1972
1973 /* Push the contents of an old object. We treat this as stack   */
1974 /* data only becasue that makes it robust against mark stack    */
1975 /* overflow.                                                    */
1976 PCR_ERes GC_push_old_obj(void *p, size_t size, PCR_Any data)
1977 {
1978     GC_push_all_stack((ptr_t)p, (ptr_t)p + size);
1979     return(PCR_ERes_okay);
1980 }
1981
1982
1983 void GC_default_push_other_roots GC_PROTO((void))
1984 {
1985     /* Traverse data allocated by previous memory managers.             */
1986         {
1987           extern struct PCR_MM_ProcsRep * GC_old_allocator;
1988
1989           if ((*(GC_old_allocator->mmp_enumerate))(PCR_Bool_false,
1990                                                    GC_push_old_obj, 0)
1991               != PCR_ERes_okay) {
1992               ABORT("Old object enumeration failed");
1993           }
1994         }
1995     /* Traverse all thread stacks. */
1996         if (PCR_ERes_IsErr(
1997                 PCR_ThCtl_ApplyToAllOtherThreads(GC_push_thread_stack,0))
1998               || PCR_ERes_IsErr(GC_push_thread_stack(PCR_Th_CurrThread(), 0))) {
1999               ABORT("Thread stack marking failed\n");
2000         }
2001 }
2002
2003 # endif /* PCR */
2004
2005 # ifdef SRC_M3
2006
2007 # ifdef ALL_INTERIOR_POINTERS
2008     --> misconfigured
2009 # endif
2010
2011 void GC_push_thread_structures GC_PROTO((void))
2012 {
2013     /* Not our responsibibility. */
2014 }
2015
2016 extern void ThreadF__ProcessStacks();
2017
2018 void GC_push_thread_stack(start, stop)
2019 word start, stop;
2020 {
2021    GC_push_all_stack((ptr_t)start, (ptr_t)stop + sizeof(word));
2022 }
2023
2024 /* Push routine with M3 specific calling convention. */
2025 GC_m3_push_root(dummy1, p, dummy2, dummy3)
2026 word *p;
2027 ptr_t dummy1, dummy2;
2028 int dummy3;
2029 {
2030     word q = *p;
2031
2032     GC_PUSH_ONE_STACK(q, p);
2033 }
2034
2035 /* M3 set equivalent to RTHeap.TracedRefTypes */
2036 typedef struct { int elts[1]; }  RefTypeSet;
2037 RefTypeSet GC_TracedRefTypes = {{0x1}};
2038
2039 void GC_default_push_other_roots GC_PROTO((void))
2040 {
2041     /* Use the M3 provided routine for finding static roots.     */
2042     /* This is a bit dubious, since it presumes no C roots.      */
2043     /* We handle the collector roots explicitly in GC_push_roots */
2044         RTMain__GlobalMapProc(GC_m3_push_root, 0, GC_TracedRefTypes);
2045         if (GC_words_allocd > 0) {
2046             ThreadF__ProcessStacks(GC_push_thread_stack);
2047         }
2048         /* Otherwise this isn't absolutely necessary, and we have       */
2049         /* startup ordering problems.                                   */
2050 }
2051
2052 # endif /* SRC_M3 */
2053
2054 # if defined(GC_SOLARIS_THREADS) || defined(GC_PTHREADS) || \
2055      defined(GC_WIN32_THREADS)
2056
2057 extern void GC_push_all_stacks();
2058
2059 void GC_default_push_other_roots GC_PROTO((void))
2060 {
2061     GC_push_all_stacks();
2062 }
2063
2064 # endif /* GC_SOLARIS_THREADS || GC_PTHREADS */
2065
2066 void (*GC_push_other_roots) GC_PROTO((void)) = GC_default_push_other_roots;
2067
2068 #endif /* THREADS */
2069
2070 /*
2071  * Routines for accessing dirty  bits on virtual pages.
2072  * We plan to eventually implement four strategies for doing so:
2073  * DEFAULT_VDB: A simple dummy implementation that treats every page
2074  *              as possibly dirty.  This makes incremental collection
2075  *              useless, but the implementation is still correct.
2076  * PCR_VDB:     Use PPCRs virtual dirty bit facility.
2077  * PROC_VDB:    Use the /proc facility for reading dirty bits.  Only
2078  *              works under some SVR4 variants.  Even then, it may be
2079  *              too slow to be entirely satisfactory.  Requires reading
2080  *              dirty bits for entire address space.  Implementations tend
2081  *              to assume that the client is a (slow) debugger.
2082  * MPROTECT_VDB:Protect pages and then catch the faults to keep track of
2083  *              dirtied pages.  The implementation (and implementability)
2084  *              is highly system dependent.  This usually fails when system
2085  *              calls write to a protected page.  We prevent the read system
2086  *              call from doing so.  It is the clients responsibility to
2087  *              make sure that other system calls are similarly protected
2088  *              or write only to the stack.
2089  */
2090 GC_bool GC_dirty_maintained = FALSE;
2091
2092 # ifdef DEFAULT_VDB
2093
2094 /* All of the following assume the allocation lock is held, and */
2095 /* signals are disabled.                                        */
2096
2097 /* The client asserts that unallocated pages in the heap are never      */
2098 /* written.                                                             */
2099
2100 /* Initialize virtual dirty bit implementation.                 */
2101 void GC_dirty_init()
2102 {
2103 #   ifdef PRINTSTATS
2104       GC_printf0("Initializing DEFAULT_VDB...\n");
2105 #   endif
2106     GC_dirty_maintained = TRUE;
2107 }
2108
2109 /* Retrieve system dirty bits for heap to a local buffer.       */
2110 /* Restore the systems notion of which pages are dirty.         */
2111 void GC_read_dirty()
2112 {}
2113
2114 /* Is the HBLKSIZE sized page at h marked dirty in the local buffer?    */
2115 /* If the actual page size is different, this returns TRUE if any       */
2116 /* of the pages overlapping h are dirty.  This routine may err on the   */
2117 /* side of labelling pages as dirty (and this implementation does).     */
2118 /*ARGSUSED*/
2119 GC_bool GC_page_was_dirty(h)
2120 struct hblk *h;
2121 {
2122     return(TRUE);
2123 }
2124
2125 /*
2126  * The following two routines are typically less crucial.  They matter
2127  * most with large dynamic libraries, or if we can't accurately identify
2128  * stacks, e.g. under Solaris 2.X.  Otherwise the following default
2129  * versions are adequate.
2130  */
2131
2132 /* Could any valid GC heap pointer ever have been written to this page? */
2133 /*ARGSUSED*/
2134 GC_bool GC_page_was_ever_dirty(h)
2135 struct hblk *h;
2136 {
2137     return(TRUE);
2138 }
2139
2140 /* Reset the n pages starting at h to "was never dirty" status. */
2141 void GC_is_fresh(h, n)
2142 struct hblk *h;
2143 word n;
2144 {
2145 }
2146
2147 /* A call that:                                         */
2148 /* I) hints that [h, h+nblocks) is about to be written. */
2149 /* II) guarantees that protection is removed.           */
2150 /* (I) may speed up some dirty bit implementations.     */
2151 /* (II) may be essential if we need to ensure that      */
2152 /* pointer-free system call buffers in the heap are     */
2153 /* not protected.                                       */
2154 /*ARGSUSED*/
2155 void GC_remove_protection(h, nblocks, is_ptrfree)
2156 struct hblk *h;
2157 word nblocks;
2158 GC_bool is_ptrfree;
2159 {
2160 }
2161
2162 # endif /* DEFAULT_VDB */
2163
2164
2165 # ifdef MPROTECT_VDB
2166
2167 /*
2168  * See DEFAULT_VDB for interface descriptions.
2169  */
2170
2171 /*
2172  * This implementation maintains dirty bits itself by catching write
2173  * faults and keeping track of them.  We assume nobody else catches
2174  * SIGBUS or SIGSEGV.  We assume no write faults occur in system calls.
2175  * This means that clients must ensure that system calls don't write
2176  * to the write-protected heap.  Probably the best way to do this is to
2177  * ensure that system calls write at most to POINTERFREE objects in the
2178  * heap, and do even that only if we are on a platform on which those
2179  * are not protected.  Another alternative is to wrap system calls
2180  * (see example for read below), but the current implementation holds
2181  * a lock across blocking calls, making it problematic for multithreaded
2182  * applications.
2183  * We assume the page size is a multiple of HBLKSIZE.
2184  * We prefer them to be the same.  We avoid protecting POINTERFREE
2185  * objects only if they are the same.
2186  */
2187
2188 # if !defined(MSWIN32) && !defined(MSWINCE) && !defined(DARWIN)
2189
2190 #   include <sys/mman.h>
2191 #   include <signal.h>
2192 #   include <sys/syscall.h>
2193
2194 #   define PROTECT(addr, len) \
2195           if (mprotect((caddr_t)(addr), (size_t)(len), \
2196                        PROT_READ | OPT_PROT_EXEC) < 0) { \
2197             ABORT("mprotect failed"); \
2198           }
2199 #   define UNPROTECT(addr, len) \
2200           if (mprotect((caddr_t)(addr), (size_t)(len), \
2201                        PROT_WRITE | PROT_READ | OPT_PROT_EXEC ) < 0) { \
2202             ABORT("un-mprotect failed"); \
2203           }
2204
2205 # else
2206
2207 # ifdef DARWIN
2208     /* Using vm_protect (mach syscall) over mprotect (BSD syscall) seems to
2209        decrease the likelihood of some of the problems described below. */
2210     #include <mach/vm_map.h>
2211     static mach_port_t GC_task_self;
2212     #define PROTECT(addr,len) \
2213         if(vm_protect(GC_task_self,(vm_address_t)(addr),(vm_size_t)(len), \
2214                 FALSE,VM_PROT_READ) != KERN_SUCCESS) { \
2215             ABORT("vm_portect failed"); \
2216         }
2217     #define UNPROTECT(addr,len) \
2218         if(vm_protect(GC_task_self,(vm_address_t)(addr),(vm_size_t)(len), \
2219                 FALSE,VM_PROT_READ|VM_PROT_WRITE) != KERN_SUCCESS) { \
2220             ABORT("vm_portect failed"); \
2221         }
2222 # else
2223
2224 #   ifndef MSWINCE
2225 #     include <signal.h>
2226 #   endif
2227
2228     static DWORD protect_junk;
2229 #   define PROTECT(addr, len) \
2230           if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READ, \
2231                               &protect_junk)) { \
2232             DWORD last_error = GetLastError(); \
2233             GC_printf1("Last error code: %lx\n", last_error); \
2234             ABORT("VirtualProtect failed"); \
2235           }
2236 #   define UNPROTECT(addr, len) \
2237           if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READWRITE, \
2238                               &protect_junk)) { \
2239             ABORT("un-VirtualProtect failed"); \
2240           }
2241 # endif /* !DARWIN */
2242 # endif /* MSWIN32 || MSWINCE || DARWIN */
2243
2244 #if defined(SUNOS4) || (defined(FREEBSD) && !defined(SUNOS5SIGS))
2245     typedef void (* SIG_PF)();
2246 #endif /* SUNOS4 || (FREEBSD && !SUNOS5SIGS) */
2247
2248 #if defined(SUNOS5SIGS) || defined(OSF1) || defined(LINUX) \
2249     || defined(HURD)
2250 # ifdef __STDC__
2251     typedef void (* SIG_PF)(int);
2252 # else
2253     typedef void (* SIG_PF)();
2254 # endif
2255 #endif /* SUNOS5SIGS || OSF1 || LINUX || HURD */
2256
2257 #if defined(MSWIN32)
2258     typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_PF;
2259 #   undef SIG_DFL
2260 #   define SIG_DFL (LPTOP_LEVEL_EXCEPTION_FILTER) (-1)
2261 #endif
2262 #if defined(MSWINCE)
2263     typedef LONG (WINAPI *SIG_PF)(struct _EXCEPTION_POINTERS *);
2264 #   undef SIG_DFL
2265 #   define SIG_DFL (SIG_PF) (-1)
2266 #endif
2267
2268 #if defined(IRIX5) || defined(OSF1) || defined(HURD)
2269     typedef void (* REAL_SIG_PF)(int, int, struct sigcontext *);
2270 #endif /* IRIX5 || OSF1 || HURD */
2271
2272 #if defined(SUNOS5SIGS)
2273 # if defined(HPUX) || defined(FREEBSD)
2274 #   define SIGINFO_T siginfo_t
2275 # else
2276 #   define SIGINFO_T struct siginfo
2277 # endif
2278 # ifdef __STDC__
2279     typedef void (* REAL_SIG_PF)(int, SIGINFO_T *, void *);
2280 # else
2281     typedef void (* REAL_SIG_PF)();
2282 # endif
2283 #endif /* SUNOS5SIGS */
2284
2285 #if defined(LINUX)
2286 #   if __GLIBC__ > 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ >= 2
2287       typedef struct sigcontext s_c;
2288 #   else  /* glibc < 2.2 */
2289 #     include <linux/version.h>
2290 #     if (LINUX_VERSION_CODE >= 0x20100) && !defined(M68K) || defined(ALPHA) || defined(ARM32)
2291         typedef struct sigcontext s_c;
2292 #     else
2293         typedef struct sigcontext_struct s_c;
2294 #     endif
2295 #   endif  /* glibc < 2.2 */
2296 #   if defined(ALPHA) || defined(M68K)
2297       typedef void (* REAL_SIG_PF)(int, int, s_c *);
2298 #   else
2299 #     if defined(IA64) || defined(HP_PA) || defined(X86_64)
2300         typedef void (* REAL_SIG_PF)(int, siginfo_t *, s_c *);
2301         /* FIXME:                                                 */
2302         /* According to SUSV3, the last argument should have type */
2303         /* void * or ucontext_t *                                 */
2304 #     else
2305         typedef void (* REAL_SIG_PF)(int, s_c);
2306 #     endif
2307 #   endif
2308 #   ifdef ALPHA
2309     /* Retrieve fault address from sigcontext structure by decoding     */
2310     /* instruction.                                                     */
2311     char * get_fault_addr(s_c *sc) {
2312         unsigned instr;
2313         word faultaddr;
2314
2315         instr = *((unsigned *)(sc->sc_pc));
2316         faultaddr = sc->sc_regs[(instr >> 16) & 0x1f];
2317         faultaddr += (word) (((int)instr << 16) >> 16);
2318         return (char *)faultaddr;
2319     }
2320 #   endif /* !ALPHA */
2321 # endif /* LINUX */
2322
2323 #ifndef DARWIN
2324 SIG_PF GC_old_bus_handler;
2325 SIG_PF GC_old_segv_handler;     /* Also old MSWIN32 ACCESS_VIOLATION filter */
2326 #endif /* !DARWIN */
2327
2328 #if defined(THREADS)
2329 /* We need to lock around the bitmap update in the write fault handler  */
2330 /* in order to avoid the risk of losing a bit.  We do this with a       */
2331 /* test-and-set spin lock if we know how to do that.  Otherwise we      */
2332 /* check whether we are already in the handler and use the dumb but     */
2333 /* safe fallback algorithm of setting all bits in the word.             */
2334 /* Contention should be very rare, so we do the minimum to handle it    */
2335 /* correctly.                                                           */
2336 #ifdef GC_TEST_AND_SET_DEFINED
2337   static VOLATILE unsigned int fault_handler_lock = 0;
2338   void async_set_pht_entry_from_index(VOLATILE page_hash_table db, int index) {
2339     while (GC_test_and_set(&fault_handler_lock)) {}
2340     /* Could also revert to set_pht_entry_from_index_safe if initial    */
2341     /* GC_test_and_set fails.                                           */
2342     set_pht_entry_from_index(db, index);
2343     GC_clear(&fault_handler_lock);
2344   }
2345 #else /* !GC_TEST_AND_SET_DEFINED */
2346   /* THIS IS INCORRECT! The dirty bit vector may be temporarily wrong,  */
2347   /* just before we notice the conflict and correct it. We may end up   */
2348   /* looking at it while it's wrong.  But this requires contention      */
2349   /* exactly when a GC is triggered, which seems far less likely to     */
2350   /* fail than the old code, which had no reported failures.  Thus we   */
2351   /* leave it this way while we think of something better, or support   */
2352   /* GC_test_and_set on the remaining platforms.                        */
2353   static VOLATILE word currently_updating = 0;
2354   void async_set_pht_entry_from_index(VOLATILE page_hash_table db, int index) {
2355     unsigned int update_dummy;
2356     currently_updating = (word)(&update_dummy);
2357     set_pht_entry_from_index(db, index);
2358     /* If we get contention in the 10 or so instruction window here,    */
2359     /* and we get stopped by a GC between the two updates, we lose!     */
2360     if (currently_updating != (word)(&update_dummy)) {
2361         set_pht_entry_from_index_safe(db, index);
2362         /* We claim that if two threads concurrently try to update the  */
2363         /* dirty bit vector, the first one to execute UPDATE_START      */
2364         /* will see it changed when UPDATE_END is executed.  (Note that */
2365         /* &update_dummy must differ in two distinct threads.)  It      */
2366         /* will then execute set_pht_entry_from_index_safe, thus        */
2367         /* returning us to a safe state, though not soon enough.        */
2368     }
2369   }
2370 #endif /* !GC_TEST_AND_SET_DEFINED */
2371 #else /* !THREADS */
2372 # define async_set_pht_entry_from_index(db, index) \
2373         set_pht_entry_from_index(db, index)
2374 #endif /* !THREADS */
2375
2376 /*ARGSUSED*/
2377 #if !defined(DARWIN)
2378 # if defined (SUNOS4) || (defined(FREEBSD) && !defined(SUNOS5SIGS))
2379     void GC_write_fault_handler(sig, code, scp, addr)
2380     int sig, code;
2381     struct sigcontext *scp;
2382     char * addr;
2383 #   ifdef SUNOS4
2384 #     define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
2385 #     define CODE_OK (FC_CODE(code) == FC_PROT \
2386                     || (FC_CODE(code) == FC_OBJERR \
2387                        && FC_ERRNO(code) == FC_PROT))
2388 #   endif
2389 #   ifdef FREEBSD
2390 #     define SIG_OK (sig == SIGBUS)
2391 #     define CODE_OK TRUE
2392 #   endif
2393 # endif /* SUNOS4 || (FREEBSD && !SUNOS5SIGS) */
2394
2395 # if defined(IRIX5) || defined(OSF1) || defined(HURD)
2396 #   include <errno.h>
2397     void GC_write_fault_handler(int sig, int code, struct sigcontext *scp)
2398 #   ifdef OSF1
2399 #     define SIG_OK (sig == SIGSEGV)
2400 #     define CODE_OK (code == 2 /* experimentally determined */)
2401 #   endif
2402 #   ifdef IRIX5
2403 #     define SIG_OK (sig == SIGSEGV)
2404 #     define CODE_OK (code == EACCES)
2405 #   endif
2406 #   ifdef HURD
2407 #     define SIG_OK (sig == SIGBUS || sig == SIGSEGV)
2408 #     define CODE_OK  TRUE
2409 #   endif
2410 # endif /* IRIX5 || OSF1 || HURD */
2411
2412 # if defined(LINUX)
2413 #   if defined(ALPHA) || defined(M68K)
2414       void GC_write_fault_handler(int sig, int code, s_c * sc)
2415 #   else
2416 #     if defined(IA64) || defined(HP_PA) || defined(X86_64)
2417         void GC_write_fault_handler(int sig, siginfo_t * si, s_c * scp)
2418 #     else
2419 #       if defined(ARM32)
2420           void GC_write_fault_handler(int sig, int a2, int a3, int a4, s_c sc)
2421 #       else
2422           void GC_write_fault_handler(int sig, s_c sc)
2423 #       endif
2424 #     endif
2425 #   endif
2426 #   define SIG_OK (sig == SIGSEGV)
2427 #   define CODE_OK TRUE
2428         /* Empirically c.trapno == 14, on IA32, but is that useful?     */
2429         /* Should probably consider alignment issues on other           */
2430         /* architectures.                                               */
2431 # endif /* LINUX */
2432
2433 # if defined(SUNOS5SIGS)
2434 #  ifdef __STDC__
2435     void GC_write_fault_handler(int sig, SIGINFO_T *scp, void * context)
2436 #  else
2437     void GC_write_fault_handler(sig, scp, context)
2438     int sig;
2439     SIGINFO_T *scp;
2440     void * context;
2441 #  endif
2442 #   ifdef HPUX
2443 #     define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
2444 #     define CODE_OK (scp -> si_code == SEGV_ACCERR) \
2445                      || (scp -> si_code == BUS_ADRERR) \
2446                      || (scp -> si_code == BUS_UNKNOWN) \
2447                      || (scp -> si_code == SEGV_UNKNOWN) \
2448                      || (scp -> si_code == BUS_OBJERR)
2449 #   else
2450 #     ifdef FREEBSD
2451 #       define SIG_OK (sig == SIGBUS)
2452 #       define CODE_OK (scp -> si_code == BUS_PAGE_FAULT)
2453 #     else
2454 #       define SIG_OK (sig == SIGSEGV)
2455 #       define CODE_OK (scp -> si_code == SEGV_ACCERR)
2456 #     endif
2457 #   endif
2458 # endif /* SUNOS5SIGS */
2459
2460 # if defined(MSWIN32) || defined(MSWINCE)
2461     LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info)
2462 #   define SIG_OK (exc_info -> ExceptionRecord -> ExceptionCode == \
2463                         STATUS_ACCESS_VIOLATION)
2464 #   define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] == 1)
2465                         /* Write fault */
2466 # endif /* MSWIN32 || MSWINCE */
2467 {
2468     register unsigned i;
2469 #   if defined(HURD)
2470         char *addr = (char *) code;
2471 #   endif
2472 #   ifdef IRIX5
2473         char * addr = (char *) (size_t) (scp -> sc_badvaddr);
2474 #   endif
2475 #   if defined(OSF1) && defined(ALPHA)
2476         char * addr = (char *) (scp -> sc_traparg_a0);
2477 #   endif
2478 #   ifdef SUNOS5SIGS
2479         char * addr = (char *) (scp -> si_addr);
2480 #   endif
2481 #   ifdef LINUX
2482 #     if defined(I386)
2483         char * addr = (char *) (sc.cr2);
2484 #     else
2485 #       if defined(M68K)
2486           char * addr = NULL;
2487
2488           struct sigcontext *scp = (struct sigcontext *)(sc);
2489
2490           int format = (scp->sc_formatvec >> 12) & 0xf;
2491           unsigned long *framedata = (unsigned long *)(scp + 1);
2492           unsigned long ea;
2493
2494           if (format == 0xa || format == 0xb) {
2495                 /* 68020/030 */
2496                 ea = framedata[2];
2497           } else if (format == 7) {
2498                 /* 68040 */
2499                 ea = framedata[3];
2500                 if (framedata[1] & 0x08000000) {
2501                         /* correct addr on misaligned access */
2502                         ea = (ea+4095)&(~4095);
2503                 }
2504           } else if (format == 4) {
2505                 /* 68060 */
2506                 ea = framedata[0];
2507                 if (framedata[1] & 0x08000000) {
2508                         /* correct addr on misaligned access */
2509                         ea = (ea+4095)&(~4095);
2510                 }
2511           }
2512           addr = (char *)ea;
2513 #       else
2514 #         ifdef ALPHA
2515             char * addr = get_fault_addr(sc);
2516 #         else
2517 #           if defined(IA64) || defined(HP_PA) || defined(X86_64)
2518               char * addr = si -> si_addr;
2519               /* I believe this is claimed to work on all platforms for */
2520               /* Linux 2.3.47 and later.  Hopefully we don't have to    */
2521               /* worry about earlier kernels on IA64.                   */
2522 #           else
2523 #             if defined(POWERPC)
2524                 char * addr = (char *) (sc.regs->dar);
2525 #             else
2526 #               if defined(ARM32)
2527                   char * addr = (char *)sc.fault_address;
2528 #               else
2529 #                 if defined(CRIS)
2530                     char * addr = (char *)sc.regs.csraddr;
2531 #                 else
2532                     --> architecture not supported
2533 #                 endif
2534 #               endif
2535 #             endif
2536 #           endif
2537 #         endif
2538 #       endif
2539 #     endif
2540 #   endif
2541 #   if defined(MSWIN32) || defined(MSWINCE)
2542         char * addr = (char *) (exc_info -> ExceptionRecord
2543                                 -> ExceptionInformation[1]);
2544 #       define sig SIGSEGV
2545 #   endif
2546
2547     if (SIG_OK && CODE_OK) {
2548         register struct hblk * h =
2549                         (struct hblk *)((word)addr & ~(GC_page_size-1));
2550         GC_bool in_allocd_block;
2551
2552 #       ifdef SUNOS5SIGS
2553             /* Address is only within the correct physical page.        */
2554             in_allocd_block = FALSE;
2555             for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
2556               if (HDR(h+i) != 0) {
2557                 in_allocd_block = TRUE;
2558               }
2559             }
2560 #       else
2561             in_allocd_block = (HDR(addr) != 0);
2562 #       endif
2563         if (!in_allocd_block) {
2564             /* FIXME - We should make sure that we invoke the   */
2565             /* old handler with the appropriate calling         */
2566             /* sequence, which often depends on SA_SIGINFO.     */
2567
2568             /* Heap blocks now begin and end on page boundaries */
2569             SIG_PF old_handler;
2570
2571             if (sig == SIGSEGV) {
2572                 old_handler = GC_old_segv_handler;
2573             } else {
2574                 old_handler = GC_old_bus_handler;
2575             }
2576             if (old_handler == SIG_DFL) {
2577 #               if !defined(MSWIN32) && !defined(MSWINCE)
2578                     GC_err_printf1("Segfault at 0x%lx\n", addr);
2579                     ABORT("Unexpected bus error or segmentation fault");
2580 #               else
2581                     return(EXCEPTION_CONTINUE_SEARCH);
2582 #               endif
2583             } else {
2584 #               if defined (SUNOS4) \
2585                     || (defined(FREEBSD) && !defined(SUNOS5SIGS))
2586                     (*old_handler) (sig, code, scp, addr);
2587                     return;
2588 #               endif
2589 #               if defined (SUNOS5SIGS)
2590                     /*
2591                      * FIXME: For FreeBSD, this code should check if the
2592                      * old signal handler used the traditional BSD style and
2593                      * if so call it using that style.
2594                      */
2595                     (*(REAL_SIG_PF)old_handler) (sig, scp, context);
2596                     return;
2597 #               endif
2598 #               if defined (LINUX)
2599 #                   if defined(ALPHA) || defined(M68K)
2600                         (*(REAL_SIG_PF)old_handler) (sig, code, sc);
2601 #                   else
2602 #                     if defined(IA64) || defined(HP_PA) || defined(X86_64)
2603                         (*(REAL_SIG_PF)old_handler) (sig, si, scp);
2604 #                     else
2605                         (*(REAL_SIG_PF)old_handler) (sig, sc);
2606 #                     endif
2607 #                   endif
2608                     return;
2609 #               endif
2610 #               if defined (IRIX5) || defined(OSF1) || defined(HURD)
2611                     (*(REAL_SIG_PF)old_handler) (sig, code, scp);
2612                     return;
2613 #               endif
2614 #               ifdef MSWIN32
2615                     return((*old_handler)(exc_info));
2616 #               endif
2617             }
2618         }
2619         UNPROTECT(h, GC_page_size);
2620         /* We need to make sure that no collection occurs between       */
2621         /* the UNPROTECT and the setting of the dirty bit.  Otherwise   */
2622         /* a write by a third thread might go unnoticed.  Reversing     */
2623         /* the order is just as bad, since we would end up unprotecting */
2624         /* a page in a GC cycle during which it's not marked.           */
2625         /* Currently we do this by disabling the thread stopping        */
2626         /* signals while this handler is running.  An alternative might */
2627         /* be to record the fact that we're about to unprotect, or      */
2628         /* have just unprotected a page in the GC's thread structure,   */
2629         /* and then to have the thread stopping code set the dirty      */
2630         /* flag, if necessary.                                          */
2631         for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
2632             register int index = PHT_HASH(h+i);
2633
2634             async_set_pht_entry_from_index(GC_dirty_pages, index);
2635         }
2636 #       if defined(OSF1)
2637             /* These reset the signal handler each time by default. */
2638             signal(SIGSEGV, (SIG_PF) GC_write_fault_handler);
2639 #       endif
2640         /* The write may not take place before dirty bits are read.     */
2641         /* But then we'll fault again ...                               */
2642 #       if defined(MSWIN32) || defined(MSWINCE)
2643             return(EXCEPTION_CONTINUE_EXECUTION);
2644 #       else
2645             return;
2646 #       endif
2647     }
2648 #if defined(MSWIN32) || defined(MSWINCE)
2649     return EXCEPTION_CONTINUE_SEARCH;
2650 #else
2651     GC_err_printf1("Segfault at 0x%lx\n", addr);
2652     ABORT("Unexpected bus error or segmentation fault");
2653 #endif
2654 }
2655 #endif /* !DARWIN */
2656
2657 /*
2658  * We hold the allocation lock.  We expect block h to be written
2659  * shortly.  Ensure that all pages containing any part of the n hblks
2660  * starting at h are no longer protected.  If is_ptrfree is false,
2661  * also ensure that they will subsequently appear to be dirty.
2662  */
2663 void GC_remove_protection(h, nblocks, is_ptrfree)
2664 struct hblk *h;
2665 word nblocks;
2666 GC_bool is_ptrfree;
2667 {
2668     struct hblk * h_trunc;  /* Truncated to page boundary */
2669     struct hblk * h_end;    /* Page boundary following block end */
2670     struct hblk * current;
2671     GC_bool found_clean;
2672
2673     if (!GC_dirty_maintained) return;
2674     h_trunc = (struct hblk *)((word)h & ~(GC_page_size-1));
2675     h_end = (struct hblk *)(((word)(h + nblocks) + GC_page_size-1)
2676                             & ~(GC_page_size-1));
2677     found_clean = FALSE;
2678     for (current = h_trunc; current < h_end; ++current) {
2679         int index = PHT_HASH(current);
2680
2681         if (!is_ptrfree || current < h || current >= h + nblocks) {
2682             async_set_pht_entry_from_index(GC_dirty_pages, index);
2683         }
2684     }
2685     UNPROTECT(h_trunc, (ptr_t)h_end - (ptr_t)h_trunc);
2686 }
2687
2688 #if !defined(DARWIN)
2689 void GC_dirty_init()
2690 {
2691 #   if defined(SUNOS5SIGS) || defined(IRIX5) || defined(LINUX) || \
2692        defined(OSF1) || defined(HURD)
2693       struct sigaction  act, oldact;
2694       /* We should probably specify SA_SIGINFO for Linux, and handle    */
2695       /* the different architectures more uniformly.                    */
2696 #     if defined(IRIX5) || defined(LINUX) && !defined(X86_64) \
2697          || defined(OSF1) || defined(HURD)
2698         act.sa_flags    = SA_RESTART;
2699         act.sa_handler  = (SIG_PF)GC_write_fault_handler;
2700 #     else
2701         act.sa_flags    = SA_RESTART | SA_SIGINFO;
2702         act.sa_sigaction = GC_write_fault_handler;
2703 #     endif
2704       (void)sigemptyset(&act.sa_mask);
2705 #     ifdef SIG_SUSPEND
2706         /* Arrange to postpone SIG_SUSPEND while we're in a write fault */
2707         /* handler.  This effectively makes the handler atomic w.r.t.   */
2708         /* stopping the world for GC.                                   */
2709         (void)sigaddset(&act.sa_mask, SIG_SUSPEND);
2710 #     endif /* SIG_SUSPEND */
2711 #    endif
2712 #   ifdef PRINTSTATS
2713         GC_printf0("Inititalizing mprotect virtual dirty bit implementation\n");
2714 #   endif
2715     GC_dirty_maintained = TRUE;
2716     if (GC_page_size % HBLKSIZE != 0) {
2717         GC_err_printf0("Page size not multiple of HBLKSIZE\n");
2718         ABORT("Page size not multiple of HBLKSIZE");
2719     }
2720 #   if defined(SUNOS4) || (defined(FREEBSD) && !defined(SUNOS5SIGS))
2721       GC_old_bus_handler = signal(SIGBUS, GC_write_fault_handler);
2722       if (GC_old_bus_handler == SIG_IGN) {
2723         GC_err_printf0("Previously ignored bus error!?");
2724         GC_old_bus_handler = SIG_DFL;
2725       }
2726       if (GC_old_bus_handler != SIG_DFL) {
2727 #       ifdef PRINTSTATS
2728           GC_err_printf0("Replaced other SIGBUS handler\n");
2729 #       endif
2730       }
2731 #   endif
2732 #   if defined(SUNOS4)
2733       GC_old_segv_handler = signal(SIGSEGV, (SIG_PF)GC_write_fault_handler);
2734       if (GC_old_segv_handler == SIG_IGN) {
2735         GC_err_printf0("Previously ignored segmentation violation!?");
2736         GC_old_segv_handler = SIG_DFL;
2737       }
2738       if (GC_old_segv_handler != SIG_DFL) {
2739 #       ifdef PRINTSTATS
2740           GC_err_printf0("Replaced other SIGSEGV handler\n");
2741 #       endif
2742       }
2743 #   endif
2744 #   if (defined(SUNOS5SIGS) && !defined(FREEBSD)) || defined(IRIX5) \
2745        || defined(LINUX) || defined(OSF1) || defined(HURD)
2746       /* SUNOS5SIGS includes HPUX */
2747 #     if defined(GC_IRIX_THREADS)
2748         sigaction(SIGSEGV, 0, &oldact);
2749         sigaction(SIGSEGV, &act, 0);
2750 #     else
2751         {
2752           int res = sigaction(SIGSEGV, &act, &oldact);
2753           if (res != 0) ABORT("Sigaction failed");
2754         }
2755 #     endif
2756 #     if defined(_sigargs) || defined(HURD) || !defined(SA_SIGINFO)
2757         /* This is Irix 5.x, not 6.x.  Irix 5.x does not have   */
2758         /* sa_sigaction.                                        */
2759         GC_old_segv_handler = oldact.sa_handler;
2760 #     else /* Irix 6.x or SUNOS5SIGS or LINUX */
2761         if (oldact.sa_flags & SA_SIGINFO) {
2762           GC_old_segv_handler = (SIG_PF)(oldact.sa_sigaction);
2763         } else {
2764           GC_old_segv_handler = oldact.sa_handler;
2765         }
2766 #     endif
2767       if (GC_old_segv_handler == SIG_IGN) {
2768              GC_err_printf0("Previously ignored segmentation violation!?");
2769              GC_old_segv_handler = SIG_DFL;
2770       }
2771       if (GC_old_segv_handler != SIG_DFL) {
2772 #       ifdef PRINTSTATS
2773           GC_err_printf0("Replaced other SIGSEGV handler\n");
2774 #       endif
2775       }
2776 #   endif /* (SUNOS5SIGS && !FREEBSD) || IRIX5 || LINUX || OSF1 || HURD */
2777 #   if defined(HPUX) || defined(LINUX) || defined(HURD) \
2778       || (defined(FREEBSD) && defined(SUNOS5SIGS))
2779       sigaction(SIGBUS, &act, &oldact);
2780       GC_old_bus_handler = oldact.sa_handler;
2781       if (GC_old_bus_handler == SIG_IGN) {
2782              GC_err_printf0("Previously ignored bus error!?");
2783              GC_old_bus_handler = SIG_DFL;
2784       }
2785       if (GC_old_bus_handler != SIG_DFL) {
2786 #       ifdef PRINTSTATS
2787           GC_err_printf0("Replaced other SIGBUS handler\n");
2788 #       endif
2789       }
2790 #   endif /* HPUX || LINUX || HURD || (FREEBSD && SUNOS5SIGS) */
2791 #   if defined(MSWIN32)
2792       GC_old_segv_handler = SetUnhandledExceptionFilter(GC_write_fault_handler);
2793       if (GC_old_segv_handler != NULL) {
2794 #       ifdef PRINTSTATS
2795           GC_err_printf0("Replaced other UnhandledExceptionFilter\n");
2796 #       endif
2797       } else {
2798           GC_old_segv_handler = SIG_DFL;
2799       }
2800 #   endif
2801 }
2802 #endif /* !DARWIN */
2803
2804 int GC_incremental_protection_needs()
2805 {
2806     if (GC_page_size == HBLKSIZE) {
2807         return GC_PROTECTS_POINTER_HEAP;
2808     } else {
2809         return GC_PROTECTS_POINTER_HEAP | GC_PROTECTS_PTRFREE_HEAP;
2810     }
2811 }
2812
2813 #define HAVE_INCREMENTAL_PROTECTION_NEEDS
2814
2815 #define IS_PTRFREE(hhdr) ((hhdr)->hb_descr == 0)
2816
2817 #define PAGE_ALIGNED(x) !((word)(x) & (GC_page_size - 1))
2818 void GC_protect_heap()
2819 {
2820     ptr_t start;
2821     word len;
2822     struct hblk * current;
2823     struct hblk * current_start;  /* Start of block to be protected. */
2824     struct hblk * limit;
2825     unsigned i;
2826     GC_bool protect_all =
2827           (0 != (GC_incremental_protection_needs() & GC_PROTECTS_PTRFREE_HEAP));
2828     for (i = 0; i < GC_n_heap_sects; i++) {
2829         start = GC_heap_sects[i].hs_start;
2830         len = GC_heap_sects[i].hs_bytes;
2831         if (protect_all) {
2832           PROTECT(start, len);
2833         } else {
2834           GC_ASSERT(PAGE_ALIGNED(len))
2835           GC_ASSERT(PAGE_ALIGNED(start))
2836           current_start = current = (struct hblk *)start;
2837           limit = (struct hblk *)(start + len);
2838           while (current < limit) {
2839             hdr * hhdr;
2840             word nhblks;
2841             GC_bool is_ptrfree;
2842
2843             GC_ASSERT(PAGE_ALIGNED(current));
2844             GET_HDR(current, hhdr);
2845             if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
2846               /* This can happen only if we're at the beginning of a    */
2847               /* heap segment, and a block spans heap segments.         */
2848               /* We will handle that block as part of the preceding     */
2849               /* segment.                                               */
2850               GC_ASSERT(current_start == current);
2851               current_start = ++current;
2852               continue;
2853             }
2854             if (HBLK_IS_FREE(hhdr)) {
2855               GC_ASSERT(PAGE_ALIGNED(hhdr -> hb_sz));
2856               nhblks = divHBLKSZ(hhdr -> hb_sz);
2857               is_ptrfree = TRUE;        /* dirty on alloc */
2858             } else {
2859               nhblks = OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
2860               is_ptrfree = IS_PTRFREE(hhdr);
2861             }
2862             if (is_ptrfree) {
2863               if (current_start < current) {
2864                 PROTECT(current_start, (ptr_t)current - (ptr_t)current_start);
2865               }
2866               current_start = (current += nhblks);
2867             } else {
2868               current += nhblks;
2869             }
2870           }
2871           if (current_start < current) {
2872             PROTECT(current_start, (ptr_t)current - (ptr_t)current_start);
2873           }
2874         }
2875     }
2876 }
2877
2878 /* We assume that either the world is stopped or its OK to lose dirty   */
2879 /* bits while this is happenning (as in GC_enable_incremental).         */
2880 void GC_read_dirty()
2881 {
2882     BCOPY((word *)GC_dirty_pages, GC_grungy_pages,
2883           (sizeof GC_dirty_pages));
2884     BZERO((word *)GC_dirty_pages, (sizeof GC_dirty_pages));
2885     GC_protect_heap();
2886 }
2887
2888 GC_bool GC_page_was_dirty(h)
2889 struct hblk * h;
2890 {
2891     register word index = PHT_HASH(h);
2892
2893     return(HDR(h) == 0 || get_pht_entry_from_index(GC_grungy_pages, index));
2894 }
2895
2896 /*
2897  * Acquiring the allocation lock here is dangerous, since this
2898  * can be called from within GC_call_with_alloc_lock, and the cord
2899  * package does so.  On systems that allow nested lock acquisition, this
2900  * happens to work.
2901  * On other systems, SET_LOCK_HOLDER and friends must be suitably defined.
2902  */
2903
2904 static GC_bool syscall_acquired_lock = FALSE;   /* Protected by GC lock. */
2905
2906 void GC_begin_syscall()
2907 {
2908     if (!I_HOLD_LOCK()) {
2909         LOCK();
2910         syscall_acquired_lock = TRUE;
2911     }
2912 }
2913
2914 void GC_end_syscall()
2915 {
2916     if (syscall_acquired_lock) {
2917         syscall_acquired_lock = FALSE;
2918         UNLOCK();
2919     }
2920 }
2921
2922 void GC_unprotect_range(addr, len)
2923 ptr_t addr;
2924 word len;
2925 {
2926     struct hblk * start_block;
2927     struct hblk * end_block;
2928     register struct hblk *h;
2929     ptr_t obj_start;
2930
2931     if (!GC_dirty_maintained) return;
2932     obj_start = GC_base(addr);
2933     if (obj_start == 0) return;
2934     if (GC_base(addr + len - 1) != obj_start) {
2935         ABORT("GC_unprotect_range(range bigger than object)");
2936     }
2937     start_block = (struct hblk *)((word)addr & ~(GC_page_size - 1));
2938     end_block = (struct hblk *)((word)(addr + len - 1) & ~(GC_page_size - 1));
2939     end_block += GC_page_size/HBLKSIZE - 1;
2940     for (h = start_block; h <= end_block; h++) {
2941         register word index = PHT_HASH(h);
2942
2943         async_set_pht_entry_from_index(GC_dirty_pages, index);
2944     }
2945     UNPROTECT(start_block,
2946               ((ptr_t)end_block - (ptr_t)start_block) + HBLKSIZE);
2947 }
2948
2949 #if 0
2950
2951 /* We no longer wrap read by default, since that was causing too many   */
2952 /* problems.  It is preferred that the client instead avoids writing    */
2953 /* to the write-protected heap with a system call.                      */
2954 /* This still serves as sample code if you do want to wrap system calls.*/
2955
2956 #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(GC_USE_LD_WRAP)
2957 /* Replacement for UNIX system call.                                      */
2958 /* Other calls that write to the heap should be handled similarly.        */
2959 /* Note that this doesn't work well for blocking reads:  It will hold     */
2960 /* the allocation lock for the entire duration of the call. Multithreaded */
2961 /* clients should really ensure that it won't block, either by setting    */
2962 /* the descriptor nonblocking, or by calling select or poll first, to     */
2963 /* make sure that input is available.                                     */
2964 /* Another, preferred alternative is to ensure that system calls never    */
2965 /* write to the protected heap (see above).                               */
2966 # if defined(__STDC__) && !defined(SUNOS4)
2967 #   include <unistd.h>
2968 #   include <sys/uio.h>
2969     ssize_t read(int fd, void *buf, size_t nbyte)
2970 # else
2971 #   ifndef LINT
2972       int read(fd, buf, nbyte)
2973 #   else
2974       int GC_read(fd, buf, nbyte)
2975 #   endif
2976     int fd;
2977     char *buf;
2978     int nbyte;
2979 # endif
2980 {
2981     int result;
2982
2983     GC_begin_syscall();
2984     GC_unprotect_range(buf, (word)nbyte);
2985 #   if defined(IRIX5) || defined(GC_LINUX_THREADS)
2986         /* Indirect system call may not always be easily available.     */
2987         /* We could call _read, but that would interfere with the       */
2988         /* libpthread interception of read.                             */
2989         /* On Linux, we have to be careful with the linuxthreads        */
2990         /* read interception.                                           */
2991         {
2992             struct iovec iov;
2993
2994             iov.iov_base = buf;
2995             iov.iov_len = nbyte;
2996             result = readv(fd, &iov, 1);
2997         }
2998 #   else
2999 #     if defined(HURD)
3000         result = __read(fd, buf, nbyte);
3001 #     else
3002         /* The two zero args at the end of this list are because one
3003            IA-64 syscall() implementation actually requires six args
3004            to be passed, even though they aren't always used. */
3005         result = syscall(SYS_read, fd, buf, nbyte, 0, 0);
3006 #     endif /* !HURD */
3007 #   endif
3008     GC_end_syscall();
3009     return(result);
3010 }
3011 #endif /* !MSWIN32 && !MSWINCE && !GC_LINUX_THREADS */
3012
3013 #if defined(GC_USE_LD_WRAP) && !defined(THREADS)
3014     /* We use the GNU ld call wrapping facility.                        */
3015     /* This requires that the linker be invoked with "--wrap read".     */
3016     /* This can be done by passing -Wl,"--wrap read" to gcc.            */
3017     /* I'm not sure that this actually wraps whatever version of read   */
3018     /* is called by stdio.  That code also mentions __read.             */
3019 #   include <unistd.h>
3020     ssize_t __wrap_read(int fd, void *buf, size_t nbyte)
3021     {
3022         int result;
3023
3024         GC_begin_syscall();
3025         GC_unprotect_range(buf, (word)nbyte);
3026         result = __real_read(fd, buf, nbyte);
3027         GC_end_syscall();
3028         return(result);
3029     }
3030
3031     /* We should probably also do this for __read, or whatever stdio    */
3032     /* actually calls.                                                  */
3033 #endif
3034
3035 #endif /* 0 */
3036
3037 /*ARGSUSED*/
3038 GC_bool GC_page_was_ever_dirty(h)
3039 struct hblk *h;
3040 {
3041     return(TRUE);
3042 }
3043
3044 /* Reset the n pages starting at h to "was never dirty" status. */
3045 /*ARGSUSED*/
3046 void GC_is_fresh(h, n)
3047 struct hblk *h;
3048 word n;
3049 {
3050 }
3051
3052 # endif /* MPROTECT_VDB */
3053
3054 # ifdef PROC_VDB
3055
3056 /*
3057  * See DEFAULT_VDB for interface descriptions.
3058  */
3059
3060 /*
3061  * This implementaion assumes a Solaris 2.X like /proc pseudo-file-system
3062  * from which we can read page modified bits.  This facility is far from
3063  * optimal (e.g. we would like to get the info for only some of the
3064  * address space), but it avoids intercepting system calls.
3065  */
3066
3067 #include <errno.h>
3068 #include <sys/types.h>
3069 #include <sys/signal.h>
3070 #include <sys/fault.h>
3071 #include <sys/syscall.h>
3072 #include <sys/procfs.h>
3073 #include <sys/stat.h>
3074
3075 #define INITIAL_BUF_SZ 16384
3076 word GC_proc_buf_size = INITIAL_BUF_SZ;
3077 char *GC_proc_buf;
3078
3079 #ifdef GC_SOLARIS_THREADS
3080 /* We don't have exact sp values for threads.  So we count on   */
3081 /* occasionally declaring stack pages to be fresh.  Thus we     */
3082 /* need a real implementation of GC_is_fresh.  We can't clear   */
3083 /* entries in GC_written_pages, since that would declare all    */
3084 /* pages with the given hash address to be fresh.               */
3085 #   define MAX_FRESH_PAGES 8*1024       /* Must be power of 2 */
3086     struct hblk ** GC_fresh_pages;      /* A direct mapped cache.       */
3087                                         /* Collisions are dropped.      */
3088
3089 #   define FRESH_PAGE_SLOT(h) (divHBLKSZ((word)(h)) & (MAX_FRESH_PAGES-1))
3090 #   define ADD_FRESH_PAGE(h) \
3091         GC_fresh_pages[FRESH_PAGE_SLOT(h)] = (h)
3092 #   define PAGE_IS_FRESH(h) \
3093         (GC_fresh_pages[FRESH_PAGE_SLOT(h)] == (h) && (h) != 0)
3094 #endif
3095
3096 /* Add all pages in pht2 to pht1 */
3097 void GC_or_pages(pht1, pht2)
3098 page_hash_table pht1, pht2;
3099 {
3100     register int i;
3101
3102     for (i = 0; i < PHT_SIZE; i++) pht1[i] |= pht2[i];
3103 }
3104
3105 int GC_proc_fd;
3106
3107 void GC_dirty_init()
3108 {
3109     int fd;
3110     char buf[30];
3111
3112     GC_dirty_maintained = TRUE;
3113     if (GC_words_allocd != 0 || GC_words_allocd_before_gc != 0) {
3114         register int i;
3115
3116         for (i = 0; i < PHT_SIZE; i++) GC_written_pages[i] = (word)(-1);
3117 #       ifdef PRINTSTATS
3118             GC_printf1("Allocated words:%lu:all pages may have been written\n",
3119                        (unsigned long)
3120                                 (GC_words_allocd + GC_words_allocd_before_gc));
3121 #       endif
3122     }
3123     sprintf(buf, "/proc/%d", getpid());
3124     fd = open(buf, O_RDONLY);
3125     if (fd < 0) {
3126         ABORT("/proc open failed");
3127     }
3128     GC_proc_fd = syscall(SYS_ioctl, fd, PIOCOPENPD, 0);
3129     close(fd);
3130     syscall(SYS_fcntl, GC_proc_fd, F_SETFD, FD_CLOEXEC);
3131     if (GC_proc_fd < 0) {
3132         ABORT("/proc ioctl failed");
3133     }
3134     GC_proc_buf = GC_scratch_alloc(GC_proc_buf_size);
3135 #   ifdef GC_SOLARIS_THREADS
3136         GC_fresh_pages = (struct hblk **)
3137           GC_scratch_alloc(MAX_FRESH_PAGES * sizeof (struct hblk *));
3138         if (GC_fresh_pages == 0) {
3139             GC_err_printf0("No space for fresh pages\n");
3140             EXIT();
3141         }
3142         BZERO(GC_fresh_pages, MAX_FRESH_PAGES * sizeof (struct hblk *));
3143 #   endif
3144 }
3145
3146 /* Ignore write hints. They don't help us here. */
3147 /*ARGSUSED*/
3148 void GC_remove_protection(h, nblocks, is_ptrfree)
3149 struct hblk *h;
3150 word nblocks;
3151 GC_bool is_ptrfree;
3152 {
3153 }
3154
3155 #ifdef GC_SOLARIS_THREADS
3156 #   define READ(fd,buf,nbytes) syscall(SYS_read, fd, buf, nbytes)
3157 #else
3158 #   define READ(fd,buf,nbytes) read(fd, buf, nbytes)
3159 #endif
3160
3161 void GC_read_dirty()
3162 {
3163     unsigned long ps, np;
3164     int nmaps;
3165     ptr_t vaddr;
3166     struct prasmap * map;
3167     char * bufp;
3168     ptr_t current_addr, limit;
3169     int i;
3170 int dummy;
3171
3172     BZERO(GC_grungy_pages, (sizeof GC_grungy_pages));
3173
3174     bufp = GC_proc_buf;
3175     if (READ(GC_proc_fd, bufp, GC_proc_buf_size) <= 0) {
3176 #       ifdef PRINTSTATS
3177             GC_printf1("/proc read failed: GC_proc_buf_size = %lu\n",
3178                        GC_proc_buf_size);
3179 #       endif
3180         {
3181             /* Retry with larger buffer. */
3182             word new_size = 2 * GC_proc_buf_size;
3183             char * new_buf = GC_scratch_alloc(new_size);
3184
3185             if (new_buf != 0) {
3186                 GC_proc_buf = bufp = new_buf;
3187                 GC_proc_buf_size = new_size;
3188             }
3189             if (READ(GC_proc_fd, bufp, GC_proc_buf_size) <= 0) {
3190                 WARN("Insufficient space for /proc read\n", 0);
3191                 /* Punt:        */
3192                 memset(GC_grungy_pages, 0xff, sizeof (page_hash_table));
3193                 memset(GC_written_pages, 0xff, sizeof(page_hash_table));
3194 #               ifdef GC_SOLARIS_THREADS
3195                     BZERO(GC_fresh_pages,
3196                           MAX_FRESH_PAGES * sizeof (struct hblk *));
3197 #               endif
3198                 return;
3199             }
3200         }
3201     }
3202     /* Copy dirty bits into GC_grungy_pages */
3203         nmaps = ((struct prpageheader *)bufp) -> pr_nmap;
3204         /* printf( "nmaps = %d, PG_REFERENCED = %d, PG_MODIFIED = %d\n",
3205                      nmaps, PG_REFERENCED, PG_MODIFIED); */
3206         bufp = bufp + sizeof(struct prpageheader);
3207         for (i = 0; i < nmaps; i++) {
3208             map = (struct prasmap *)bufp;
3209             vaddr = (ptr_t)(map -> pr_vaddr);
3210             ps = map -> pr_pagesize;
3211             np = map -> pr_npage;
3212             /* printf("vaddr = 0x%X, ps = 0x%X, np = 0x%X\n", vaddr, ps, np); */
3213             limit = vaddr + ps * np;
3214             bufp += sizeof (struct prasmap);
3215             for (current_addr = vaddr;
3216                  current_addr < limit; current_addr += ps){
3217                 if ((*bufp++) & PG_MODIFIED) {
3218                     register struct hblk * h = (struct hblk *) current_addr;
3219
3220                     while ((ptr_t)h < current_addr + ps) {
3221                         register word index = PHT_HASH(h);
3222
3223                         set_pht_entry_from_index(GC_grungy_pages, index);
3224 #                       ifdef GC_SOLARIS_THREADS
3225                           {
3226                             register int slot = FRESH_PAGE_SLOT(h);
3227
3228                             if (GC_fresh_pages[slot] == h) {
3229                                 GC_fresh_pages[slot] = 0;
3230                             }
3231                           }
3232 #                       endif
3233                         h++;
3234                     }
3235                 }
3236             }
3237             bufp += sizeof(long) - 1;
3238             bufp = (char *)((unsigned long)bufp & ~(sizeof(long)-1));
3239         }
3240     /* Update GC_written_pages. */
3241         GC_or_pages(GC_written_pages, GC_grungy_pages);
3242 #   ifdef GC_SOLARIS_THREADS
3243       /* Make sure that old stacks are considered completely clean      */
3244       /* unless written again.                                          */
3245         GC_old_stacks_are_fresh();
3246 #   endif
3247 }
3248
3249 #undef READ
3250
3251 GC_bool GC_page_was_dirty(h)
3252 struct hblk *h;
3253 {
3254     register word index = PHT_HASH(h);
3255     register GC_bool result;
3256
3257     result = get_pht_entry_from_index(GC_grungy_pages, index);
3258 #   ifdef GC_SOLARIS_THREADS
3259         if (result && PAGE_IS_FRESH(h)) result = FALSE;
3260         /* This happens only if page was declared fresh since   */
3261         /* the read_dirty call, e.g. because it's in an unused  */
3262         /* thread stack.  It's OK to treat it as clean, in      */
3263         /* that case.  And it's consistent with                 */
3264         /* GC_page_was_ever_dirty.                              */
3265 #   endif
3266     return(result);
3267 }
3268
3269 GC_bool GC_page_was_ever_dirty(h)
3270 struct hblk *h;
3271 {
3272     register word index = PHT_HASH(h);
3273     register GC_bool result;
3274
3275     result = get_pht_entry_from_index(GC_written_pages, index);
3276 #   ifdef GC_SOLARIS_THREADS
3277         if (result && PAGE_IS_FRESH(h)) result = FALSE;
3278 #   endif
3279     return(result);
3280 }
3281
3282 /* Caller holds allocation lock.        */
3283 void GC_is_fresh(h, n)
3284 struct hblk *h;
3285 word n;
3286 {
3287
3288     register word index;
3289
3290 #   ifdef GC_SOLARIS_THREADS
3291       register word i;
3292
3293       if (GC_fresh_pages != 0) {
3294         for (i = 0; i < n; i++) {
3295           ADD_FRESH_PAGE(h + i);
3296         }
3297       }
3298 #   endif
3299 }
3300
3301 # endif /* PROC_VDB */
3302
3303
3304 # ifdef PCR_VDB
3305
3306 # include "vd/PCR_VD.h"
3307
3308 # define NPAGES (32*1024)       /* 128 MB */
3309
3310 PCR_VD_DB  GC_grungy_bits[NPAGES];
3311
3312 ptr_t GC_vd_base;       /* Address corresponding to GC_grungy_bits[0]   */
3313                         /* HBLKSIZE aligned.                            */
3314
3315 void GC_dirty_init()
3316 {
3317     GC_dirty_maintained = TRUE;
3318     /* For the time being, we assume the heap generally grows up */
3319     GC_vd_base = GC_heap_sects[0].hs_start;
3320     if (GC_vd_base == 0) {
3321         ABORT("Bad initial heap segment");
3322     }
3323     if (PCR_VD_Start(HBLKSIZE, GC_vd_base, NPAGES*HBLKSIZE)
3324         != PCR_ERes_okay) {
3325         ABORT("dirty bit initialization failed");
3326     }
3327 }
3328
3329 void GC_read_dirty()
3330 {
3331     /* lazily enable dirty bits on newly added heap sects */
3332     {
3333         static int onhs = 0;
3334         int nhs = GC_n_heap_sects;
3335         for( ; onhs < nhs; onhs++ ) {
3336             PCR_VD_WriteProtectEnable(
3337                     GC_heap_sects[onhs].hs_start,
3338                     GC_heap_sects[onhs].hs_bytes );
3339         }
3340     }
3341
3342
3343     if (PCR_VD_Clear(GC_vd_base, NPAGES*HBLKSIZE, GC_grungy_bits)
3344         != PCR_ERes_okay) {
3345         ABORT("dirty bit read failed");
3346     }
3347 }
3348
3349 GC_bool GC_page_was_dirty(h)
3350 struct hblk *h;
3351 {
3352     if((ptr_t)h < GC_vd_base || (ptr_t)h >= GC_vd_base + NPAGES*HBLKSIZE) {
3353         return(TRUE);
3354     }
3355     return(GC_grungy_bits[h - (struct hblk *)GC_vd_base] & PCR_VD_DB_dirtyBit);
3356 }
3357
3358 /*ARGSUSED*/
3359 void GC_remove_protection(h, nblocks, is_ptrfree)
3360 struct hblk *h;
3361 word nblocks;
3362 GC_bool is_ptrfree;
3363 {
3364     PCR_VD_WriteProtectDisable(h, nblocks*HBLKSIZE);
3365     PCR_VD_WriteProtectEnable(h, nblocks*HBLKSIZE);
3366 }
3367
3368 # endif /* PCR_VDB */
3369
3370 #if defined(MPROTECT_VDB) && defined(DARWIN)
3371 /* The following sources were used as a *reference* for this exception handling
3372    code:
3373       1. Apple's mach/xnu documentation
3374       2. Timothy J. Wood's "Mach Exception Handlers 101" post to the
3375          omnigroup's macosx-dev list.
3376          www.omnigroup.com/mailman/archive/macosx-dev/2000-June/014178.html
3377       3. macosx-nat.c from Apple's GDB source code.
3378 */
3379
3380 /* The bug that caused all this trouble should now be fixed. This should
3381    eventually be removed if all goes well. */
3382 /* define BROKEN_EXCEPTION_HANDLING */
3383
3384 #include <mach/mach.h>
3385 #include <mach/mach_error.h>
3386 #include <mach/thread_status.h>
3387 #include <mach/exception.h>
3388 #include <mach/task.h>
3389 #include <pthread.h>
3390
3391 /* These are not defined in any header, although they are documented */
3392 extern boolean_t exc_server(mach_msg_header_t *,mach_msg_header_t *);
3393 extern kern_return_t exception_raise(
3394     mach_port_t,mach_port_t,mach_port_t,
3395     exception_type_t,exception_data_t,mach_msg_type_number_t);
3396 extern kern_return_t exception_raise_state(
3397     mach_port_t,mach_port_t,mach_port_t,
3398     exception_type_t,exception_data_t,mach_msg_type_number_t,
3399     thread_state_flavor_t*,thread_state_t,mach_msg_type_number_t,
3400     thread_state_t,mach_msg_type_number_t*);
3401 extern kern_return_t exception_raise_state_identity(
3402     mach_port_t,mach_port_t,mach_port_t,
3403     exception_type_t,exception_data_t,mach_msg_type_number_t,
3404     thread_state_flavor_t*,thread_state_t,mach_msg_type_number_t,
3405     thread_state_t,mach_msg_type_number_t*);
3406
3407
3408 #define MAX_EXCEPTION_PORTS 16
3409
3410 static struct {
3411     mach_msg_type_number_t count;
3412     exception_mask_t      masks[MAX_EXCEPTION_PORTS];
3413     exception_handler_t   ports[MAX_EXCEPTION_PORTS];
3414     exception_behavior_t  behaviors[MAX_EXCEPTION_PORTS];
3415     thread_state_flavor_t flavors[MAX_EXCEPTION_PORTS];
3416 } GC_old_exc_ports;
3417
3418 static struct {
3419     mach_port_t exception;
3420 #if defined(THREADS)
3421     mach_port_t reply;
3422 #endif
3423 } GC_ports;
3424
3425 typedef struct {
3426     mach_msg_header_t head;
3427 } GC_msg_t;
3428
3429 typedef enum {
3430     GC_MP_NORMAL, GC_MP_DISCARDING, GC_MP_STOPPED
3431 } GC_mprotect_state_t;
3432
3433 /* FIXME: 1 and 2 seem to be safe to use in the msgh_id field,
3434    but it isn't  documented. Use the source and see if they
3435    should be ok. */
3436 #define ID_STOP 1
3437 #define ID_RESUME 2
3438
3439 /* These values are only used on the reply port */
3440 #define ID_ACK 3
3441
3442 #if defined(THREADS)
3443
3444 GC_mprotect_state_t GC_mprotect_state;
3445
3446 /* The following should ONLY be called when the world is stopped  */
3447 static void GC_mprotect_thread_notify(mach_msg_id_t id) {
3448     struct {
3449         GC_msg_t msg;
3450         mach_msg_trailer_t trailer;
3451     } buf;
3452     mach_msg_return_t r;
3453     /* remote, local */
3454     buf.msg.head.msgh_bits =
3455         MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,0);
3456     buf.msg.head.msgh_size = sizeof(buf.msg);
3457     buf.msg.head.msgh_remote_port = GC_ports.exception;
3458     buf.msg.head.msgh_local_port = MACH_PORT_NULL;
3459     buf.msg.head.msgh_id = id;
3460
3461     r = mach_msg(
3462         &buf.msg.head,
3463         MACH_SEND_MSG|MACH_RCV_MSG|MACH_RCV_LARGE,
3464         sizeof(buf.msg),
3465         sizeof(buf),
3466         GC_ports.reply,
3467         MACH_MSG_TIMEOUT_NONE,
3468         MACH_PORT_NULL);
3469     if(r != MACH_MSG_SUCCESS)
3470         ABORT("mach_msg failed in GC_mprotect_thread_notify");
3471     if(buf.msg.head.msgh_id != ID_ACK)
3472         ABORT("invalid ack in GC_mprotect_thread_notify");
3473 }
3474
3475 /* Should only be called by the mprotect thread */
3476 static void GC_mprotect_thread_reply() {
3477     GC_msg_t msg;
3478     mach_msg_return_t r;
3479     /* remote, local */
3480     msg.head.msgh_bits =
3481         MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,0);
3482     msg.head.msgh_size = sizeof(msg);
3483     msg.head.msgh_remote_port = GC_ports.reply;
3484     msg.head.msgh_local_port = MACH_PORT_NULL;
3485     msg.head.msgh_id = ID_ACK;
3486
3487     r = mach_msg(
3488         &msg.head,
3489         MACH_SEND_MSG,
3490         sizeof(msg),
3491         0,
3492         MACH_PORT_NULL,
3493         MACH_MSG_TIMEOUT_NONE,
3494         MACH_PORT_NULL);
3495     if(r != MACH_MSG_SUCCESS)
3496         ABORT("mach_msg failed in GC_mprotect_thread_reply");
3497 }
3498
3499 void GC_mprotect_stop() {
3500     GC_mprotect_thread_notify(ID_STOP);
3501 }
3502 void GC_mprotect_resume() {
3503     GC_mprotect_thread_notify(ID_RESUME);
3504 }
3505
3506 #else /* !THREADS */
3507 /* The compiler should optimize away any GC_mprotect_state computations */
3508 #define GC_mprotect_state GC_MP_NORMAL
3509 #endif
3510
3511 static void *GC_mprotect_thread(void *arg) {
3512     mach_msg_return_t r;
3513     /* These two structures contain some private kernel data. We don't need to
3514        access any of it so we don't bother defining a proper struct. The
3515        correct definitions are in the xnu source code. */
3516     struct {
3517         mach_msg_header_t head;
3518         char data[256];
3519     } reply;
3520     struct {
3521         mach_msg_header_t head;
3522         mach_msg_body_t msgh_body;
3523         char data[1024];
3524     } msg;
3525
3526     mach_msg_id_t id;
3527
3528     GC_darwin_register_mach_handler_thread(mach_thread_self());
3529
3530     for(;;) {
3531         r = mach_msg(
3532             &msg.head,
3533             MACH_RCV_MSG|MACH_RCV_LARGE|
3534                 (GC_mprotect_state == GC_MP_DISCARDING ? MACH_RCV_TIMEOUT : 0),
3535             0,
3536             sizeof(msg),
3537             GC_ports.exception,
3538             GC_mprotect_state == GC_MP_DISCARDING ? 0 : MACH_MSG_TIMEOUT_NONE,
3539             MACH_PORT_NULL);
3540
3541         id = r == MACH_MSG_SUCCESS ? msg.head.msgh_id : -1;
3542
3543 #if defined(THREADS)
3544         if(GC_mprotect_state == GC_MP_DISCARDING) {
3545             if(r == MACH_RCV_TIMED_OUT) {
3546                 GC_mprotect_state = GC_MP_STOPPED;
3547                 GC_mprotect_thread_reply();
3548                 continue;
3549             }
3550             if(r == MACH_MSG_SUCCESS && (id == ID_STOP || id == ID_RESUME))
3551                 ABORT("out of order mprotect thread request");
3552         }
3553 #endif
3554
3555         if(r != MACH_MSG_SUCCESS) {
3556             GC_err_printf2("mach_msg failed with %d %s\n",
3557                 (int)r,mach_error_string(r));
3558             ABORT("mach_msg failed");
3559         }
3560
3561         switch(id) {
3562 #if defined(THREADS)
3563             case ID_STOP:
3564                 if(GC_mprotect_state != GC_MP_NORMAL)
3565                     ABORT("Called mprotect_stop when state wasn't normal");
3566                 GC_mprotect_state = GC_MP_DISCARDING;
3567                 break;
3568             case ID_RESUME:
3569                 if(GC_mprotect_state != GC_MP_STOPPED)
3570                     ABORT("Called mprotect_resume when state wasn't stopped");
3571                 GC_mprotect_state = GC_MP_NORMAL;
3572                 GC_mprotect_thread_reply();
3573                 break;
3574 #endif /* THREADS */
3575             default:
3576                     /* Handle the message (calls catch_exception_raise) */
3577                 if(!exc_server(&msg.head,&reply.head))
3578                     ABORT("exc_server failed");
3579                 /* Send the reply */
3580                 r = mach_msg(
3581                     &reply.head,
3582                     MACH_SEND_MSG,
3583                     reply.head.msgh_size,
3584                     0,
3585                     MACH_PORT_NULL,
3586                     MACH_MSG_TIMEOUT_NONE,
3587                     MACH_PORT_NULL);
3588                 if(r != MACH_MSG_SUCCESS) {
3589                         /* This will fail if the thread dies, but the thread shouldn't
3590                            die... */
3591                         #ifdef BROKEN_EXCEPTION_HANDLING
3592                         GC_err_printf2(
3593                         "mach_msg failed with %d %s while sending exc reply\n",
3594                         (int)r,mach_error_string(r));
3595                 #else
3596                         ABORT("mach_msg failed while sending exception reply");
3597                 #endif
3598                 }
3599         } /* switch */
3600     } /* for(;;) */
3601     /* NOT REACHED */
3602     return NULL;
3603 }
3604
3605 /* All this SIGBUS code shouldn't be necessary. All protection faults should
3606    be going throught the mach exception handler. However, it seems a SIGBUS is
3607    occasionally sent for some unknown reason. Even more odd, it seems to be
3608    meaningless and safe to ignore. */
3609 #ifdef BROKEN_EXCEPTION_HANDLING
3610
3611 typedef void (* SIG_PF)();
3612 static SIG_PF GC_old_bus_handler;
3613
3614 /* Updates to this aren't atomic, but the SIGBUSs seem pretty rare.
3615    Even if this doesn't get updated property, it isn't really a problem */
3616 static int GC_sigbus_count;
3617
3618 static void GC_darwin_sigbus(int num,siginfo_t *sip,void *context) {
3619     if(num != SIGBUS) ABORT("Got a non-sigbus signal in the sigbus handler");
3620
3621     /* Ugh... some seem safe to ignore, but too many in a row probably means
3622        trouble. GC_sigbus_count is reset for each mach exception that is
3623        handled */
3624     if(GC_sigbus_count >= 8) {
3625         ABORT("Got more than 8 SIGBUSs in a row!");
3626     } else {
3627         GC_sigbus_count++;
3628         GC_err_printf0("GC: WARNING: Ignoring SIGBUS.\n");
3629     }
3630 }
3631 #endif /* BROKEN_EXCEPTION_HANDLING */
3632
3633 void GC_dirty_init() {
3634     kern_return_t r;
3635     mach_port_t me;
3636     pthread_t thread;
3637     pthread_attr_t attr;
3638     exception_mask_t mask;
3639
3640 #   ifdef PRINTSTATS
3641         GC_printf0("Inititalizing mach/darwin mprotect virtual dirty bit "
3642             "implementation\n");
3643 #   endif
3644 #       ifdef BROKEN_EXCEPTION_HANDLING
3645         GC_err_printf0("GC: WARNING: Enabling workarounds for various darwin "
3646             "exception handling bugs.\n");
3647 #       endif
3648     GC_dirty_maintained = TRUE;
3649     if (GC_page_size % HBLKSIZE != 0) {
3650         GC_err_printf0("Page size not multiple of HBLKSIZE\n");
3651         ABORT("Page size not multiple of HBLKSIZE");
3652     }
3653
3654     GC_task_self = me = mach_task_self();
3655
3656     r = mach_port_allocate(me,MACH_PORT_RIGHT_RECEIVE,&GC_ports.exception);
3657     if(r != KERN_SUCCESS) ABORT("mach_port_allocate failed (exception port)");
3658
3659     r = mach_port_insert_right(me,GC_ports.exception,GC_ports.exception,
3660         MACH_MSG_TYPE_MAKE_SEND);
3661     if(r != KERN_SUCCESS)
3662         ABORT("mach_port_insert_right failed (exception port)");
3663
3664     #if defined(THREADS)
3665         r = mach_port_allocate(me,MACH_PORT_RIGHT_RECEIVE,&GC_ports.reply);
3666         if(r != KERN_SUCCESS) ABORT("mach_port_allocate failed (reply port)");
3667     #endif
3668
3669     /* The exceptions we want to catch */
3670     mask = EXC_MASK_BAD_ACCESS;
3671
3672     r = task_get_exception_ports(
3673         me,
3674         mask,
3675         GC_old_exc_ports.masks,
3676         &GC_old_exc_ports.count,
3677         GC_old_exc_ports.ports,
3678         GC_old_exc_ports.behaviors,
3679         GC_old_exc_ports.flavors
3680     );
3681     if(r != KERN_SUCCESS) ABORT("task_get_exception_ports failed");
3682
3683     r = task_set_exception_ports(
3684         me,
3685         mask,
3686         GC_ports.exception,
3687         EXCEPTION_DEFAULT,
3688         GC_MACH_THREAD_STATE
3689     );
3690     if(r != KERN_SUCCESS) ABORT("task_set_exception_ports failed");
3691
3692     if(pthread_attr_init(&attr) != 0) ABORT("pthread_attr_init failed");
3693     if(pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED) != 0)
3694         ABORT("pthread_attr_setdetachedstate failed");
3695
3696 #       undef pthread_create
3697     /* This will call the real pthread function, not our wrapper */
3698     if(pthread_create(&thread,&attr,GC_mprotect_thread,NULL) != 0)
3699         ABORT("pthread_create failed");
3700     pthread_attr_destroy(&attr);
3701
3702     /* Setup the sigbus handler for ignoring the meaningless SIGBUSs */
3703     #ifdef BROKEN_EXCEPTION_HANDLING
3704     {
3705         struct sigaction sa, oldsa;
3706         sa.sa_handler = (SIG_PF)GC_darwin_sigbus;
3707         sigemptyset(&sa.sa_mask);
3708         sa.sa_flags = SA_RESTART|SA_SIGINFO;
3709         if(sigaction(SIGBUS,&sa,&oldsa) < 0) ABORT("sigaction");
3710         GC_old_bus_handler = (SIG_PF)oldsa.sa_handler;
3711         if (GC_old_bus_handler != SIG_DFL) {
3712 #               ifdef PRINTSTATS
3713                 GC_err_printf0("Replaced other SIGBUS handler\n");
3714 #               endif
3715         }
3716     }
3717     #endif /* BROKEN_EXCEPTION_HANDLING  */
3718 }
3719
3720 /* The source code for Apple's GDB was used as a reference for the exception
3721    forwarding code. This code is similar to be GDB code only because there is
3722    only one way to do it. */
3723 static kern_return_t GC_forward_exception(
3724         mach_port_t thread,
3725         mach_port_t task,
3726         exception_type_t exception,
3727         exception_data_t data,
3728         mach_msg_type_number_t data_count
3729 ) {
3730     int i;
3731     kern_return_t r;
3732     mach_port_t port;
3733     exception_behavior_t behavior;
3734     thread_state_flavor_t flavor;
3735
3736     thread_state_t thread_state;
3737     mach_msg_type_number_t thread_state_count = THREAD_STATE_MAX;
3738
3739     for(i=0;i<GC_old_exc_ports.count;i++)
3740         if(GC_old_exc_ports.masks[i] & (1 << exception))
3741             break;
3742     if(i==GC_old_exc_ports.count) ABORT("No handler for exception!");
3743
3744     port = GC_old_exc_ports.ports[i];
3745     behavior = GC_old_exc_ports.behaviors[i];
3746     flavor = GC_old_exc_ports.flavors[i];
3747
3748     if(behavior != EXCEPTION_DEFAULT) {
3749         r = thread_get_state(thread,flavor,thread_state,&thread_state_count);
3750         if(r != KERN_SUCCESS)
3751             ABORT("thread_get_state failed in forward_exception");
3752     }
3753
3754     switch(behavior) {
3755         case EXCEPTION_DEFAULT:
3756             r = exception_raise(port,thread,task,exception,data,data_count);
3757             break;
3758         case EXCEPTION_STATE:
3759             r = exception_raise_state(port,thread,task,exception,data,
3760                 data_count,&flavor,thread_state,thread_state_count,
3761                 thread_state,&thread_state_count);
3762             break;
3763         case EXCEPTION_STATE_IDENTITY:
3764             r = exception_raise_state_identity(port,thread,task,exception,data,
3765                 data_count,&flavor,thread_state,thread_state_count,
3766                 thread_state,&thread_state_count);
3767             break;
3768         default:
3769             r = KERN_FAILURE; /* make gcc happy */
3770             ABORT("forward_exception: unknown behavior");
3771             break;
3772     }
3773
3774     if(behavior != EXCEPTION_DEFAULT) {
3775         r = thread_set_state(thread,flavor,thread_state,thread_state_count);
3776         if(r != KERN_SUCCESS)
3777             ABORT("thread_set_state failed in forward_exception");
3778     }
3779
3780     return r;
3781 }
3782
3783 #define FWD() GC_forward_exception(thread,task,exception,code,code_count)
3784
3785 /* This violates the namespace rules but there isn't anything that can be done
3786    about it. The exception handling stuff is hard coded to call this */
3787 kern_return_t
3788 catch_exception_raise(
3789    mach_port_t exception_port,mach_port_t thread,mach_port_t task,
3790    exception_type_t exception,exception_data_t code,
3791    mach_msg_type_number_t code_count
3792 ) {
3793     kern_return_t r;
3794     char *addr;
3795     struct hblk *h;
3796     int i;
3797 #   if defined(POWERPC)
3798 #     if CPP_WORDSZ == 32
3799         thread_state_flavor_t flavor = PPC_EXCEPTION_STATE;
3800         mach_msg_type_number_t exc_state_count = PPC_EXCEPTION_STATE_COUNT;
3801         ppc_exception_state_t exc_state;
3802 #     else
3803         thread_state_flavor_t flavor = PPC_EXCEPTION_STATE64;
3804         mach_msg_type_number_t exc_state_count = PPC_EXCEPTION_STATE64_COUNT;
3805         ppc_exception_state64_t exc_state;
3806 #     endif
3807 #   elif defined(I386) || defined(X86_64)
3808 #     if CPP_WORDSZ == 32
3809         thread_state_flavor_t flavor = x86_EXCEPTION_STATE32;
3810         mach_msg_type_number_t exc_state_count = x86_EXCEPTION_STATE32_COUNT;
3811         x86_exception_state32_t exc_state;
3812 #     else
3813         thread_state_flavor_t flavor = x86_EXCEPTION_STATE64;
3814         mach_msg_type_number_t exc_state_count = x86_EXCEPTION_STATE64_COUNT;
3815         x86_exception_state64_t exc_state;
3816 #     endif
3817 #   else
3818 #       error FIXME for non-ppc darwin
3819 #   endif
3820
3821
3822     if(exception != EXC_BAD_ACCESS || code[0] != KERN_PROTECTION_FAILURE) {
3823         #ifdef DEBUG_EXCEPTION_HANDLING
3824         /* We aren't interested, pass it on to the old handler */
3825         GC_printf3("Exception: 0x%x Code: 0x%x 0x%x in catch....\n",
3826             exception,
3827             code_count > 0 ? code[0] : -1,
3828             code_count > 1 ? code[1] : -1);
3829         #endif
3830         return FWD();
3831     }
3832
3833     r = thread_get_state(thread,flavor,
3834         (natural_t*)&exc_state,&exc_state_count);
3835     if(r != KERN_SUCCESS) {
3836         /* The thread is supposed to be suspended while the exception handler
3837            is called. This shouldn't fail. */
3838         #ifdef BROKEN_EXCEPTION_HANDLING
3839             GC_err_printf0("thread_get_state failed in "
3840                 "catch_exception_raise\n");
3841             return KERN_SUCCESS;
3842         #else
3843             ABORT("thread_get_state failed in catch_exception_raise");
3844         #endif
3845     }
3846
3847     /* This is the address that caused the fault */
3848 #if defined(POWERPC)
3849     addr = (char*) exc_state. THREAD_FLD(dar);
3850 #elif defined (I386) || defined (X86_64)
3851     addr = (char*) exc_state. THREAD_FLD(faultvaddr);
3852 #else
3853 #   error FIXME for non POWERPC/I386
3854 #endif
3855
3856     if((HDR(addr)) == 0) {
3857         /* Ugh... just like the SIGBUS problem above, it seems we get a bogus
3858            KERN_PROTECTION_FAILURE every once and a while. We wait till we get
3859            a bunch in a row before doing anything about it. If a "real" fault
3860            ever occurres it'll just keep faulting over and over and we'll hit
3861            the limit pretty quickly. */
3862         #ifdef BROKEN_EXCEPTION_HANDLING
3863             static char *last_fault;
3864             static int last_fault_count;
3865
3866             if(addr != last_fault) {
3867                 last_fault = addr;
3868                 last_fault_count = 0;
3869             }
3870             if(++last_fault_count < 32) {
3871                 if(last_fault_count == 1)
3872                     GC_err_printf1(
3873                         "GC: WARNING: Ignoring KERN_PROTECTION_FAILURE at %p\n",
3874                         addr);
3875                 return KERN_SUCCESS;
3876             }
3877
3878             GC_err_printf1("Unexpected KERN_PROTECTION_FAILURE at %p\n",addr);
3879             /* Can't pass it along to the signal handler because that is
3880                ignoring SIGBUS signals. We also shouldn't call ABORT here as
3881                signals don't always work too well from the exception handler. */
3882             GC_err_printf0("Aborting\n");
3883             exit(EXIT_FAILURE);
3884         #else /* BROKEN_EXCEPTION_HANDLING */
3885             /* Pass it along to the next exception handler
3886                (which should call SIGBUS/SIGSEGV) */
3887             return FWD();
3888         #endif /* !BROKEN_EXCEPTION_HANDLING */
3889     }
3890
3891     #ifdef BROKEN_EXCEPTION_HANDLING
3892         /* Reset the number of consecutive SIGBUSs */
3893         GC_sigbus_count = 0;
3894     #endif
3895
3896     if(GC_mprotect_state == GC_MP_NORMAL) { /* common case */
3897         h = (struct hblk*)((word)addr & ~(GC_page_size-1));
3898         UNPROTECT(h, GC_page_size);
3899         for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
3900             register int index = PHT_HASH(h+i);
3901             async_set_pht_entry_from_index(GC_dirty_pages, index);
3902         }
3903     } else if(GC_mprotect_state == GC_MP_DISCARDING) {
3904         /* Lie to the thread for now. No sense UNPROTECT()ing the memory
3905            when we're just going to PROTECT() it again later. The thread
3906            will just fault again once it resumes */
3907     } else {
3908         /* Shouldn't happen, i don't think */
3909         GC_printf0("KERN_PROTECTION_FAILURE while world is stopped\n");
3910         return FWD();
3911     }
3912     return KERN_SUCCESS;
3913 }
3914 #undef FWD
3915
3916 /* These should never be called, but just in case...  */
3917 kern_return_t catch_exception_raise_state(mach_port_name_t exception_port,
3918     int exception, exception_data_t code, mach_msg_type_number_t codeCnt,
3919     int flavor, thread_state_t old_state, int old_stateCnt,
3920     thread_state_t new_state, int new_stateCnt)
3921 {
3922     ABORT("catch_exception_raise_state");
3923     return(KERN_INVALID_ARGUMENT);
3924 }
3925 kern_return_t catch_exception_raise_state_identity(
3926     mach_port_name_t exception_port, mach_port_t thread, mach_port_t task,
3927     int exception, exception_data_t code, mach_msg_type_number_t codeCnt,
3928     int flavor, thread_state_t old_state, int old_stateCnt,
3929     thread_state_t new_state, int new_stateCnt)
3930 {
3931     ABORT("catch_exception_raise_state_identity");
3932     return(KERN_INVALID_ARGUMENT);
3933 }
3934
3935
3936 #endif /* DARWIN && MPROTECT_VDB */
3937
3938 # ifndef HAVE_INCREMENTAL_PROTECTION_NEEDS
3939   int GC_incremental_protection_needs()
3940   {
3941     return GC_PROTECTS_NONE;
3942   }
3943 # endif /* !HAVE_INCREMENTAL_PROTECTION_NEEDS */
3944
3945 /*
3946  * Call stack save code for debugging.
3947  * Should probably be in mach_dep.c, but that requires reorganization.
3948  */
3949
3950 /* I suspect the following works for most X86 *nix variants, so         */
3951 /* long as the frame pointer is explicitly stored.  In the case of gcc, */
3952 /* compiler flags (e.g. -fomit-frame-pointer) determine whether it is.  */
3953 #if defined(I386) && defined(LINUX) && defined(SAVE_CALL_CHAIN)
3954 #   include <features.h>
3955
3956     struct frame {
3957         struct frame *fr_savfp;
3958         long    fr_savpc;
3959         long    fr_arg[NARGS];  /* All the arguments go here.   */
3960     };
3961 #endif
3962
3963 #if defined(SPARC)
3964 #  if defined(LINUX)
3965 #    include <features.h>
3966
3967      struct frame {
3968         long    fr_local[8];
3969         long    fr_arg[6];
3970         struct frame *fr_savfp;
3971         long    fr_savpc;
3972 #       ifndef __arch64__
3973           char  *fr_stret;
3974 #       endif
3975         long    fr_argd[6];
3976         long    fr_argx[0];
3977      };
3978 #  else
3979 #    if defined(SUNOS4)
3980 #      include <machine/frame.h>
3981 #    else
3982 #      if defined (DRSNX)
3983 #        include <sys/sparc/frame.h>
3984 #      else
3985 #        if defined(OPENBSD)
3986 #          include <frame.h>
3987 #        else
3988 #          if defined(FREEBSD) || defined(NETBSD)
3989 #            include <machine/frame.h>
3990 #          else
3991 #            include <sys/frame.h>
3992 #          endif
3993 #        endif
3994 #      endif
3995 #    endif
3996 #  endif
3997 #  if NARGS > 6
3998         --> We only know how to to get the first 6 arguments
3999 #  endif
4000 #endif /* SPARC */
4001
4002 #ifdef  NEED_CALLINFO
4003 /* Fill in the pc and argument information for up to NFRAMES of my      */
4004 /* callers.  Ignore my frame and my callers frame.                      */
4005
4006 #ifdef LINUX
4007 #   include <unistd.h>
4008 #endif
4009
4010 #endif /* NEED_CALLINFO */
4011
4012 #if defined(GC_HAVE_BUILTIN_BACKTRACE)
4013 # include <execinfo.h>
4014 #endif
4015
4016 #ifdef SAVE_CALL_CHAIN
4017
4018 #if NARGS == 0 && NFRAMES % 2 == 0 /* No padding */ \
4019     && defined(GC_HAVE_BUILTIN_BACKTRACE)
4020
4021 #ifdef REDIRECT_MALLOC
4022   /* Deal with possible malloc calls in backtrace by omitting   */
4023   /* the infinitely recursing backtrace.                        */
4024 # ifdef THREADS
4025     __thread    /* If your compiler doesn't understand this */
4026                 /* you could use something like pthread_getspecific.    */
4027 # endif
4028   GC_in_save_callers = FALSE;
4029 #endif
4030
4031 void GC_save_callers (info)
4032 struct callinfo info[NFRAMES];
4033 {
4034   void * tmp_info[NFRAMES + 1];
4035   int npcs, i;
4036 # define IGNORE_FRAMES 1
4037
4038   /* We retrieve NFRAMES+1 pc values, but discard the first, since it   */
4039   /* points to our own frame.                                           */
4040 # ifdef REDIRECT_MALLOC
4041     if (GC_in_save_callers) {
4042       info[0].ci_pc = (word)(&GC_save_callers);
4043       for (i = 1; i < NFRAMES; ++i) info[i].ci_pc = 0;
4044       return;
4045     }
4046     GC_in_save_callers = TRUE;
4047 # endif
4048   GC_ASSERT(sizeof(struct callinfo) == sizeof(void *));
4049   npcs = backtrace((void **)tmp_info, NFRAMES + IGNORE_FRAMES);
4050   BCOPY(tmp_info+IGNORE_FRAMES, info, (npcs - IGNORE_FRAMES) * sizeof(void *));
4051   for (i = npcs - IGNORE_FRAMES; i < NFRAMES; ++i) info[i].ci_pc = 0;
4052 # ifdef REDIRECT_MALLOC
4053     GC_in_save_callers = FALSE;
4054 # endif
4055 }
4056
4057 #else /* No builtin backtrace; do it ourselves */
4058
4059 #if (defined(OPENBSD) || defined(NETBSD) || defined(FREEBSD)) && defined(SPARC)
4060 #  define FR_SAVFP fr_fp
4061 #  define FR_SAVPC fr_pc
4062 #else
4063 #  define FR_SAVFP fr_savfp
4064 #  define FR_SAVPC fr_savpc
4065 #endif
4066
4067 #if defined(SPARC) && (defined(__arch64__) || defined(__sparcv9))
4068 #   define BIAS 2047
4069 #else
4070 #   define BIAS 0
4071 #endif
4072
4073 void GC_save_callers (info)
4074 struct callinfo info[NFRAMES];
4075 {
4076   struct frame *frame;
4077   struct frame *fp;
4078   int nframes = 0;
4079 # ifdef I386
4080     /* We assume this is turned on only with gcc as the compiler. */
4081     asm("movl %%ebp,%0" : "=r"(frame));
4082     fp = frame;
4083 # else
4084     frame = (struct frame *) GC_save_regs_in_stack ();
4085     fp = (struct frame *)((long) frame -> FR_SAVFP + BIAS);
4086 #endif
4087
4088    for (; (!(fp HOTTER_THAN frame) && !(GC_stackbottom HOTTER_THAN (ptr_t)fp)
4089            && (nframes < NFRAMES));
4090        fp = (struct frame *)((long) fp -> FR_SAVFP + BIAS), nframes++) {
4091       register int i;
4092
4093       info[nframes].ci_pc = fp->FR_SAVPC;
4094 #     if NARGS > 0
4095         for (i = 0; i < NARGS; i++) {
4096           info[nframes].ci_arg[i] = ~(fp->fr_arg[i]);
4097         }
4098 #     endif /* NARGS > 0 */
4099   }
4100   if (nframes < NFRAMES) info[nframes].ci_pc = 0;
4101 }
4102
4103 #endif /* No builtin backtrace */
4104
4105 #endif /* SAVE_CALL_CHAIN */
4106
4107 #ifdef NEED_CALLINFO
4108
4109 /* Print info to stderr.  We do NOT hold the allocation lock */
4110 void GC_print_callers (info)
4111 struct callinfo info[NFRAMES];
4112 {
4113     register int i;
4114     static int reentry_count = 0;
4115     GC_bool stop = FALSE;
4116
4117     /* FIXME: This should probably use a different lock, so that we     */
4118     /* become callable with or without the allocation lock.             */
4119     LOCK();
4120       ++reentry_count;
4121     UNLOCK();
4122
4123 #   if NFRAMES == 1
4124       GC_err_printf0("\tCaller at allocation:\n");
4125 #   else
4126       GC_err_printf0("\tCall chain at allocation:\n");
4127 #   endif
4128     for (i = 0; i < NFRAMES && !stop ; i++) {
4129         if (info[i].ci_pc == 0) break;
4130 #       if NARGS > 0
4131         {
4132           int j;
4133
4134           GC_err_printf0("\t\targs: ");
4135           for (j = 0; j < NARGS; j++) {
4136             if (j != 0) GC_err_printf0(", ");
4137             GC_err_printf2("%d (0x%X)", ~(info[i].ci_arg[j]),
4138                                         ~(info[i].ci_arg[j]));
4139           }
4140           GC_err_printf0("\n");
4141         }
4142 #       endif
4143         if (reentry_count > 1) {
4144             /* We were called during an allocation during       */
4145             /* a previous GC_print_callers call; punt.          */
4146             GC_err_printf1("\t\t##PC##= 0x%lx\n", info[i].ci_pc);
4147             continue;
4148         }
4149         {
4150 #         ifdef LINUX
4151             FILE *pipe;
4152 #         endif
4153 #         if defined(GC_HAVE_BUILTIN_BACKTRACE) \
4154              && !defined(GC_BACKTRACE_SYMBOLS_BROKEN)
4155             char **sym_name =
4156               backtrace_symbols((void **)(&(info[i].ci_pc)), 1);
4157             char *name = sym_name[0];
4158 #         else
4159             char buf[40];
4160             char *name = buf;
4161             sprintf(buf, "##PC##= 0x%lx", info[i].ci_pc);
4162 #         endif
4163 #         if defined(LINUX) && !defined(SMALL_CONFIG)
4164             /* Try for a line number. */
4165             {
4166 #               define EXE_SZ 100
4167                 static char exe_name[EXE_SZ];
4168 #               define CMD_SZ 200
4169                 char cmd_buf[CMD_SZ];
4170 #               define RESULT_SZ 200
4171                 static char result_buf[RESULT_SZ];
4172                 size_t result_len;
4173                 char *old_preload;
4174 #               define PRELOAD_SZ 200
4175                 char preload_buf[PRELOAD_SZ];
4176                 static GC_bool found_exe_name = FALSE;
4177                 static GC_bool will_fail = FALSE;
4178                 int ret_code;
4179                 /* Try to get it via a hairy and expensive scheme.      */
4180                 /* First we get the name of the executable:             */
4181                 if (will_fail) goto out;
4182                 if (!found_exe_name) {
4183                   ret_code = readlink("/proc/self/exe", exe_name, EXE_SZ);
4184                   if (ret_code < 0 || ret_code >= EXE_SZ
4185                       || exe_name[0] != '/') {
4186                     will_fail = TRUE;   /* Dont try again. */
4187                     goto out;
4188                   }
4189                   exe_name[ret_code] = '\0';
4190                   found_exe_name = TRUE;
4191                 }
4192                 /* Then we use popen to start addr2line -e <exe> <addr> */
4193                 /* There are faster ways to do this, but hopefully this */
4194                 /* isn't time critical.                                 */
4195                 sprintf(cmd_buf, "/usr/bin/addr2line -f -e %s 0x%lx", exe_name,
4196                                  (unsigned long)info[i].ci_pc);
4197                 old_preload = getenv ("LD_PRELOAD");
4198                 if (0 != old_preload) {
4199                   if (strlen (old_preload) >= PRELOAD_SZ) {
4200                     will_fail = TRUE;
4201                     goto out;
4202                   }
4203                   strcpy (preload_buf, old_preload);
4204                   unsetenv ("LD_PRELOAD");
4205                 }
4206                 pipe = popen(cmd_buf, "r");
4207                 if (0 != old_preload
4208                     && 0 != setenv ("LD_PRELOAD", preload_buf, 0)) {
4209                   WARN("Failed to reset LD_PRELOAD\n", 0);
4210                 }
4211                 if (pipe == NULL
4212                     || (result_len = fread(result_buf, 1, RESULT_SZ - 1, pipe))
4213                        == 0) {
4214                   if (pipe != NULL) pclose(pipe);
4215                   will_fail = TRUE;
4216                   goto out;
4217                 }
4218                 if (result_buf[result_len - 1] == '\n') --result_len;
4219                 result_buf[result_len] = 0;
4220                 if (result_buf[0] == '?'
4221                     || result_buf[result_len-2] == ':'
4222                        && result_buf[result_len-1] == '0') {
4223                     pclose(pipe);
4224                     goto out;
4225                 }
4226                 /* Get rid of embedded newline, if any.  Test for "main" */
4227                 {
4228                    char * nl = strchr(result_buf, '\n');
4229                    if (nl != NULL && nl < result_buf + result_len) {
4230                      *nl = ':';
4231                    }
4232                    if (strncmp(result_buf, "main", nl - result_buf) == 0) {
4233                      stop = TRUE;
4234                    }
4235                 }
4236                 if (result_len < RESULT_SZ - 25) {
4237                   /* Add in hex address */
4238                     sprintf(result_buf + result_len, " [0x%lx]",
4239                           (unsigned long)info[i].ci_pc);
4240                 }
4241                 name = result_buf;
4242                 pclose(pipe);
4243                 out:;
4244             }
4245 #         endif /* LINUX */
4246           GC_err_printf1("\t\t%s\n", name);
4247 #         if defined(GC_HAVE_BUILTIN_BACKTRACE) \
4248              && !defined(GC_BACKTRACE_SYMBOLS_BROKEN)
4249             free(sym_name);  /* May call GC_free; that's OK */
4250 #         endif
4251         }
4252     }
4253     LOCK();
4254       --reentry_count;
4255     UNLOCK();
4256 }
4257
4258 #endif /* NEED_CALLINFO */
4259
4260
4261
4262 #if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG)
4263
4264 /* Dump /proc/self/maps to GC_stderr, to enable looking up names for
4265    addresses in FIND_LEAK output. */
4266
4267 static word dump_maps(char *maps)
4268 {
4269     GC_err_write(maps, strlen(maps));
4270     return 1;
4271 }
4272
4273 void GC_print_address_map()
4274 {
4275     GC_err_printf0("---------- Begin address map ----------\n");
4276     GC_apply_to_maps(dump_maps);
4277     GC_err_printf0("---------- End address map ----------\n");
4278 }
4279
4280 #endif
4281
4282