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