| 1 |
721 |
jeremybenn |
/*
|
| 2 |
|
|
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
|
| 3 |
|
|
* Copyright (c) 2001 by Hewlett-Packard Company. All rights reserved.
|
| 4 |
|
|
*
|
| 5 |
|
|
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
| 6 |
|
|
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
| 7 |
|
|
*
|
| 8 |
|
|
* Permission is hereby granted to use or copy this program
|
| 9 |
|
|
* for any purpose, provided the above notices are retained on all copies.
|
| 10 |
|
|
* Permission to modify the code and to distribute modified code is granted,
|
| 11 |
|
|
* provided the above notices are retained, and a notice that the code was
|
| 12 |
|
|
* modified is included with the above copyright notice.
|
| 13 |
|
|
*
|
| 14 |
|
|
*/
|
| 15 |
|
|
|
| 16 |
|
|
/*
|
| 17 |
|
|
* This contains interfaces to the GC marker that are likely to be useful to
|
| 18 |
|
|
* clients that provide detailed heap layout information to the collector.
|
| 19 |
|
|
* This interface should not be used by normal C or C++ clients.
|
| 20 |
|
|
* It will be useful to runtimes for other languages.
|
| 21 |
|
|
*
|
| 22 |
|
|
* This is an experts-only interface! There are many ways to break the
|
| 23 |
|
|
* collector in subtle ways by using this functionality.
|
| 24 |
|
|
*/
|
| 25 |
|
|
#ifndef GC_MARK_H
|
| 26 |
|
|
# define GC_MARK_H
|
| 27 |
|
|
|
| 28 |
|
|
# ifndef GC_H
|
| 29 |
|
|
# include "gc.h"
|
| 30 |
|
|
# endif
|
| 31 |
|
|
|
| 32 |
|
|
/* A client supplied mark procedure. Returns new mark stack pointer. */
|
| 33 |
|
|
/* Primary effect should be to push new entries on the mark stack. */
|
| 34 |
|
|
/* Mark stack pointer values are passed and returned explicitly. */
|
| 35 |
|
|
/* Global variables decribing mark stack are not necessarily valid. */
|
| 36 |
|
|
/* (This usually saves a few cycles by keeping things in registers.) */
|
| 37 |
|
|
/* Assumed to scan about GC_PROC_BYTES on average. If it needs to do */
|
| 38 |
|
|
/* much more work than that, it should do it in smaller pieces by */
|
| 39 |
|
|
/* pushing itself back on the mark stack. */
|
| 40 |
|
|
/* Note that it should always do some work (defined as marking some */
|
| 41 |
|
|
/* objects) before pushing more than one entry on the mark stack. */
|
| 42 |
|
|
/* This is required to ensure termination in the event of mark stack */
|
| 43 |
|
|
/* overflows. */
|
| 44 |
|
|
/* This procedure is always called with at least one empty entry on the */
|
| 45 |
|
|
/* mark stack. */
|
| 46 |
|
|
/* Currently we require that mark procedures look for pointers in a */
|
| 47 |
|
|
/* subset of the places the conservative marker would. It must be safe */
|
| 48 |
|
|
/* to invoke the normal mark procedure instead. */
|
| 49 |
|
|
/* WARNING: Such a mark procedure may be invoked on an unused object */
|
| 50 |
|
|
/* residing on a free list. Such objects are cleared, except for a */
|
| 51 |
|
|
/* free list link field in the first word. Thus mark procedures may */
|
| 52 |
|
|
/* not count on the presence of a type descriptor, and must handle this */
|
| 53 |
|
|
/* case correctly somehow. */
|
| 54 |
|
|
# define GC_PROC_BYTES 100
|
| 55 |
|
|
struct GC_ms_entry;
|
| 56 |
|
|
typedef struct GC_ms_entry * (*GC_mark_proc) GC_PROTO((
|
| 57 |
|
|
GC_word * addr, struct GC_ms_entry * mark_stack_ptr,
|
| 58 |
|
|
struct GC_ms_entry * mark_stack_limit, GC_word env));
|
| 59 |
|
|
|
| 60 |
|
|
# define GC_LOG_MAX_MARK_PROCS 6
|
| 61 |
|
|
# define GC_MAX_MARK_PROCS (1 << GC_LOG_MAX_MARK_PROCS)
|
| 62 |
|
|
|
| 63 |
|
|
/* In a few cases it's necessary to assign statically known indices to */
|
| 64 |
|
|
/* certain mark procs. Thus we reserve a few for well known clients. */
|
| 65 |
|
|
/* (This is necessary if mark descriptors are compiler generated.) */
|
| 66 |
|
|
#define GC_RESERVED_MARK_PROCS 8
|
| 67 |
|
|
# define GC_GCJ_RESERVED_MARK_PROC_INDEX 0
|
| 68 |
|
|
|
| 69 |
|
|
/* Object descriptors on mark stack or in objects. Low order two */
|
| 70 |
|
|
/* bits are tags distinguishing among the following 4 possibilities */
|
| 71 |
|
|
/* for the high order 30 bits. */
|
| 72 |
|
|
#define GC_DS_TAG_BITS 2
|
| 73 |
|
|
#define GC_DS_TAGS ((1 << GC_DS_TAG_BITS) - 1)
|
| 74 |
|
|
#define GC_DS_LENGTH 0 /* The entire word is a length in bytes that */
|
| 75 |
|
|
/* must be a multiple of 4. */
|
| 76 |
|
|
#define GC_DS_BITMAP 1 /* 30 (62) bits are a bitmap describing pointer */
|
| 77 |
|
|
/* fields. The msb is 1 iff the first word */
|
| 78 |
|
|
/* is a pointer. */
|
| 79 |
|
|
/* (This unconventional ordering sometimes */
|
| 80 |
|
|
/* makes the marker slightly faster.) */
|
| 81 |
|
|
/* Zeroes indicate definite nonpointers. Ones */
|
| 82 |
|
|
/* indicate possible pointers. */
|
| 83 |
|
|
/* Only usable if pointers are word aligned. */
|
| 84 |
|
|
#define GC_DS_PROC 2
|
| 85 |
|
|
/* The objects referenced by this object can be */
|
| 86 |
|
|
/* pushed on the mark stack by invoking */
|
| 87 |
|
|
/* PROC(descr). ENV(descr) is passed as the */
|
| 88 |
|
|
/* last argument. */
|
| 89 |
|
|
# define GC_MAKE_PROC(proc_index, env) \
|
| 90 |
|
|
(((((env) << GC_LOG_MAX_MARK_PROCS) \
|
| 91 |
|
|
| (proc_index)) << GC_DS_TAG_BITS) | GC_DS_PROC)
|
| 92 |
|
|
#define GC_DS_PER_OBJECT 3 /* The real descriptor is at the */
|
| 93 |
|
|
/* byte displacement from the beginning of the */
|
| 94 |
|
|
/* object given by descr & ~DS_TAGS */
|
| 95 |
|
|
/* If the descriptor is negative, the real */
|
| 96 |
|
|
/* descriptor is at (*<object_start>) - */
|
| 97 |
|
|
/* (descr & ~DS_TAGS) - GC_INDIR_PER_OBJ_BIAS */
|
| 98 |
|
|
/* The latter alternative can be used if each */
|
| 99 |
|
|
/* object contains a type descriptor in the */
|
| 100 |
|
|
/* first word. */
|
| 101 |
|
|
/* Note that in multithreaded environments */
|
| 102 |
|
|
/* per object descriptors maust be located in */
|
| 103 |
|
|
/* either the first two or last two words of */
|
| 104 |
|
|
/* the object, since only those are guaranteed */
|
| 105 |
|
|
/* to be cleared while the allocation lock is */
|
| 106 |
|
|
/* held. */
|
| 107 |
|
|
#define GC_INDIR_PER_OBJ_BIAS 0x10
|
| 108 |
|
|
|
| 109 |
|
|
extern GC_PTR GC_least_plausible_heap_addr;
|
| 110 |
|
|
extern GC_PTR GC_greatest_plausible_heap_addr;
|
| 111 |
|
|
/* Bounds on the heap. Guaranteed valid */
|
| 112 |
|
|
/* Likely to include future heap expansion. */
|
| 113 |
|
|
|
| 114 |
|
|
/* Handle nested references in a custom mark procedure. */
|
| 115 |
|
|
/* Check if obj is a valid object. If so, ensure that it is marked. */
|
| 116 |
|
|
/* If it was not previously marked, push its contents onto the mark */
|
| 117 |
|
|
/* stack for future scanning. The object will then be scanned using */
|
| 118 |
|
|
/* its mark descriptor. */
|
| 119 |
|
|
/* Returns the new mark stack pointer. */
|
| 120 |
|
|
/* Handles mark stack overflows correctly. */
|
| 121 |
|
|
/* Since this marks first, it makes progress even if there are mark */
|
| 122 |
|
|
/* stack overflows. */
|
| 123 |
|
|
/* Src is the address of the pointer to obj, which is used only */
|
| 124 |
|
|
/* for back pointer-based heap debugging. */
|
| 125 |
|
|
/* It is strongly recommended that most objects be handled without mark */
|
| 126 |
|
|
/* procedures, e.g. with bitmap descriptors, and that mark procedures */
|
| 127 |
|
|
/* be reserved for exceptional cases. That will ensure that */
|
| 128 |
|
|
/* performance of this call is not extremely performance critical. */
|
| 129 |
|
|
/* (Otherwise we would need to inline GC_mark_and_push completely, */
|
| 130 |
|
|
/* which would tie the client code to a fixed collector version.) */
|
| 131 |
|
|
/* Note that mark procedures should explicitly call FIXUP_POINTER() */
|
| 132 |
|
|
/* if required. */
|
| 133 |
|
|
struct GC_ms_entry *GC_mark_and_push
|
| 134 |
|
|
GC_PROTO((GC_PTR obj,
|
| 135 |
|
|
struct GC_ms_entry * mark_stack_ptr,
|
| 136 |
|
|
struct GC_ms_entry * mark_stack_limit, GC_PTR *src));
|
| 137 |
|
|
|
| 138 |
|
|
#define GC_MARK_AND_PUSH(obj, msp, lim, src) \
|
| 139 |
|
|
(((GC_word)obj >= (GC_word)GC_least_plausible_heap_addr && \
|
| 140 |
|
|
(GC_word)obj <= (GC_word)GC_greatest_plausible_heap_addr)? \
|
| 141 |
|
|
GC_mark_and_push(obj, msp, lim, src) : \
|
| 142 |
|
|
msp)
|
| 143 |
|
|
|
| 144 |
|
|
extern size_t GC_debug_header_size;
|
| 145 |
|
|
/* The size of the header added to objects allocated through */
|
| 146 |
|
|
/* the GC_debug routines. */
|
| 147 |
|
|
/* Defined as a variable so that client mark procedures don't */
|
| 148 |
|
|
/* need to be recompiled for collector version changes. */
|
| 149 |
|
|
#define GC_USR_PTR_FROM_BASE(p) ((GC_PTR)((char *)(p) + GC_debug_header_size))
|
| 150 |
|
|
|
| 151 |
|
|
/* And some routines to support creation of new "kinds", e.g. with */
|
| 152 |
|
|
/* custom mark procedures, by language runtimes. */
|
| 153 |
|
|
/* The _inner versions assume the caller holds the allocation lock. */
|
| 154 |
|
|
|
| 155 |
|
|
/* Return a new free list array. */
|
| 156 |
|
|
void ** GC_new_free_list GC_PROTO((void));
|
| 157 |
|
|
void ** GC_new_free_list_inner GC_PROTO((void));
|
| 158 |
|
|
|
| 159 |
|
|
/* Return a new kind, as specified. */
|
| 160 |
|
|
int GC_new_kind GC_PROTO((void **free_list, GC_word mark_descriptor_template,
|
| 161 |
|
|
int add_size_to_descriptor, int clear_new_objects));
|
| 162 |
|
|
/* The last two parameters must be zero or one. */
|
| 163 |
|
|
int GC_new_kind_inner GC_PROTO((void **free_list,
|
| 164 |
|
|
GC_word mark_descriptor_template,
|
| 165 |
|
|
int add_size_to_descriptor,
|
| 166 |
|
|
int clear_new_objects));
|
| 167 |
|
|
|
| 168 |
|
|
/* Return a new mark procedure identifier, suitable for use as */
|
| 169 |
|
|
/* the first argument in GC_MAKE_PROC. */
|
| 170 |
|
|
int GC_new_proc GC_PROTO((GC_mark_proc));
|
| 171 |
|
|
int GC_new_proc_inner GC_PROTO((GC_mark_proc));
|
| 172 |
|
|
|
| 173 |
|
|
/* Allocate an object of a given kind. Note that in multithreaded */
|
| 174 |
|
|
/* contexts, this is usually unsafe for kinds that have the descriptor */
|
| 175 |
|
|
/* in the object itself, since there is otherwise a window in which */
|
| 176 |
|
|
/* the descriptor is not correct. Even in the single-threaded case, */
|
| 177 |
|
|
/* we need to be sure that cleared objects on a free list don't */
|
| 178 |
|
|
/* cause a GC crash if they are accidentally traced. */
|
| 179 |
|
|
/* ptr_t */char * GC_generic_malloc GC_PROTO((GC_word lb, int k));
|
| 180 |
|
|
|
| 181 |
|
|
/* FIXME - Should return void *, but that requires other changes. */
|
| 182 |
|
|
|
| 183 |
|
|
typedef void (*GC_describe_type_fn) GC_PROTO((void *p, char *out_buf));
|
| 184 |
|
|
/* A procedure which */
|
| 185 |
|
|
/* produces a human-readable */
|
| 186 |
|
|
/* description of the "type" of object */
|
| 187 |
|
|
/* p into the buffer out_buf of length */
|
| 188 |
|
|
/* GC_TYPE_DESCR_LEN. This is used by */
|
| 189 |
|
|
/* the debug support when printing */
|
| 190 |
|
|
/* objects. */
|
| 191 |
|
|
/* These functions should be as robust */
|
| 192 |
|
|
/* as possible, though we do avoid */
|
| 193 |
|
|
/* invoking them on objects on the */
|
| 194 |
|
|
/* global free list. */
|
| 195 |
|
|
# define GC_TYPE_DESCR_LEN 40
|
| 196 |
|
|
|
| 197 |
|
|
void GC_register_describe_type_fn GC_PROTO((int kind, GC_describe_type_fn knd));
|
| 198 |
|
|
/* Register a describe_type function */
|
| 199 |
|
|
/* to be used when printing objects */
|
| 200 |
|
|
/* of a particular kind. */
|
| 201 |
|
|
|
| 202 |
|
|
#endif /* GC_MARK_H */
|
| 203 |
|
|
|
