URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [boehm-gc/] [ptr_chck.c] - Blame information for rev 12

Details | Compare with Previous | View Log


/*
 * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
 *
 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
 * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
 *
 * Permission is hereby granted to use or copy this program
 * for any purpose,  provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is granted,
 * provided the above notices are retained, and a notice that the code was
 * modified is included with the above copyright notice.
 */
 
/*
 * These are checking routines calls to which could be inserted by a
 * preprocessor to validate C pointer arithmetic.
 */
 
#include "private/gc_pmark.h"
 
#ifdef __STDC__
void GC_default_same_obj_print_proc(GC_PTR p, GC_PTR q)
#else
void GC_default_same_obj_print_proc (p, q)
GC_PTR p, q;
#endif
{
    GC_err_printf2("0x%lx and 0x%lx are not in the same object\n",
                   (unsigned long)p, (unsigned long)q);
    ABORT("GC_same_obj test failed");
}
 
void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR, GC_PTR))
                = GC_default_same_obj_print_proc;
 
/* Check that p and q point to the same object.  Call           */
/* *GC_same_obj_print_proc if they don't.                       */
/* Returns the first argument.  (Return value may be hard       */
/* to use,due to typing issues.  But if we had a suitable       */
/* preprocessor ...)                                            */
/* Succeeds if neither p nor q points to the heap.              */
/* We assume this is performance critical.  (It shouldn't       */
/* be called by production code, but this can easily make       */
/* debugging intolerably slow.)                                 */
#ifdef __STDC__
  GC_PTR GC_same_obj(register void *p, register void *q)
#else
  GC_PTR GC_same_obj(p, q)
  register char *p, *q;
#endif
{
    register struct hblk *h;
    register hdr *hhdr;
    register ptr_t base, limit;
    register word sz;
 
    if (!GC_is_initialized) GC_init();
    hhdr = HDR((word)p);
    if (hhdr == 0) {
        if (divHBLKSZ((word)p) != divHBLKSZ((word)q)
            && HDR((word)q) != 0) {
            goto fail;
        }
        return(p);
    }
    /* If it's a pointer to the middle of a large object, move it       */
    /* to the beginning.                                                */
    if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
        h = HBLKPTR(p) - (word)hhdr;
        hhdr = HDR(h);
        while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
           h = FORWARDED_ADDR(h, hhdr);
           hhdr = HDR(h);
        }
        limit = (ptr_t)((word *)h + hhdr -> hb_sz);
        if ((ptr_t)p >= limit || (ptr_t)q >= limit || (ptr_t)q < (ptr_t)h ) {
            goto fail;
        }
        return(p);
    }
    sz = WORDS_TO_BYTES(hhdr -> hb_sz);
    if (sz > MAXOBJBYTES) {
      base = (ptr_t)HBLKPTR(p);
      limit = base + sz;
      if ((ptr_t)p >= limit) {
        goto fail;
      }
    } else {
      register int map_entry;
      register int pdispl = HBLKDISPL(p);
 
      map_entry = MAP_ENTRY((hhdr -> hb_map), pdispl);
      if (map_entry > CPP_MAX_OFFSET) {
         map_entry = BYTES_TO_WORDS(pdispl) % BYTES_TO_WORDS(sz);
         if (HBLKPTR(p) != HBLKPTR(q)) goto fail;
                /* W/o this check, we might miss an error if    */
                /* q points to the first object on a page, and  */
                /* points just before the page.                 */
      }
      base = (char *)((word)p & ~(WORDS_TO_BYTES(1) - 1));
      base -= WORDS_TO_BYTES(map_entry);
      limit = base + sz;
    }
    /* [base, limit) delimits the object containing p, if any.  */
    /* If p is not inside a valid object, then either q is      */
    /* also outside any valid object, or it is outside          */
    /* [base, limit).                                           */
    if ((ptr_t)q >= limit || (ptr_t)q < base) {
        goto fail;
    }
    return(p);
fail:
    (*GC_same_obj_print_proc)((ptr_t)p, (ptr_t)q);
    return(p);
}
 
#ifdef __STDC__
void GC_default_is_valid_displacement_print_proc (GC_PTR p)
#else
void GC_default_is_valid_displacement_print_proc (p)
GC_PTR p;
#endif
{
    GC_err_printf1("0x%lx does not point to valid object displacement\n",
                   (unsigned long)p);
    ABORT("GC_is_valid_displacement test failed");
}
 
void (*GC_is_valid_displacement_print_proc) GC_PROTO((GC_PTR)) =
        GC_default_is_valid_displacement_print_proc;
 
/* Check that if p is a pointer to a heap page, then it points to       */
/* a valid displacement within a heap object.                           */
/* Uninteresting with GC_all_interior_pointers.                         */
/* Always returns its argument.                                         */
/* Note that we don't lock, since nothing relevant about the header     */
/* should change while we have a valid object pointer to the block.     */
#ifdef __STDC__
  void * GC_is_valid_displacement(void *p)
#else
  char *GC_is_valid_displacement(p)
  char *p;
#endif
{
    register hdr *hhdr;
    register word pdispl;
    register struct hblk *h;
    register map_entry_type map_entry;
    register word sz;
 
    if (!GC_is_initialized) GC_init();
    hhdr = HDR((word)p);
    if (hhdr == 0) return(p);
    h = HBLKPTR(p);
    if (GC_all_interior_pointers) {
        while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
           h = FORWARDED_ADDR(h, hhdr);
           hhdr = HDR(h);
        }
    }
    if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
        goto fail;
    }
    sz = WORDS_TO_BYTES(hhdr -> hb_sz);
    pdispl = HBLKDISPL(p);
    map_entry = MAP_ENTRY((hhdr -> hb_map), pdispl);
    if (map_entry == OBJ_INVALID
        || sz > MAXOBJBYTES && (ptr_t)p >= (ptr_t)h + sz) {
        goto fail;
    }
    return(p);
fail:
    (*GC_is_valid_displacement_print_proc)((ptr_t)p);
    return(p);
}
 
#ifdef __STDC__
void GC_default_is_visible_print_proc(GC_PTR p)
#else
void GC_default_is_visible_print_proc(p)
GC_PTR p;
#endif
{
    GC_err_printf1("0x%lx is not a GC visible pointer location\n",
                   (unsigned long)p);
    ABORT("GC_is_visible test failed");
}
 
void (*GC_is_visible_print_proc) GC_PROTO((GC_PTR p)) =
        GC_default_is_visible_print_proc;
 
/* Could p be a stack address? */
GC_bool GC_on_stack(p)
ptr_t p;
{
#   ifdef THREADS
        return(TRUE);
#   else
        int dummy;
#       ifdef STACK_GROWS_DOWN
            if ((ptr_t)p >= (ptr_t)(&dummy) && (ptr_t)p < GC_stackbottom ) {
                return(TRUE);
            }
#       else
            if ((ptr_t)p <= (ptr_t)(&dummy) && (ptr_t)p > GC_stackbottom ) {
                return(TRUE);
            }
#       endif
        return(FALSE);
#   endif
}
 
/* Check that p is visible                                              */
/* to the collector as a possibly pointer containing location.          */
/* If it isn't invoke *GC_is_visible_print_proc.                        */
/* Returns the argument in all cases.  May erroneously succeed          */
/* in hard cases.  (This is intended for debugging use with             */
/* untyped allocations.  The idea is that it should be possible, though */
/* slow, to add such a call to all indirect pointer stores.)            */
/* Currently useless for multithreaded worlds.                          */
#ifdef __STDC__
  void * GC_is_visible(void *p)
#else
  char *GC_is_visible(p)
  char *p;
#endif
{
    register hdr *hhdr;
 
    if ((word)p & (ALIGNMENT - 1)) goto fail;
    if (!GC_is_initialized) GC_init();
#   ifdef THREADS
        hhdr = HDR((word)p);
        if (hhdr != 0 && GC_base(p) == 0) {
            goto fail;
        } else {
            /* May be inside thread stack.  We can't do much. */
            return(p);
        }
#   else
        /* Check stack first: */
          if (GC_on_stack(p)) return(p);
        hhdr = HDR((word)p);
        if (hhdr == 0) {
            GC_bool result;
 
            if (GC_is_static_root(p)) return(p);
            /* Else do it again correctly:      */
#           if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || \
                defined(MSWINCE) || defined(PCR)) \
                && !defined(SRC_M3)
                DISABLE_SIGNALS();
                GC_register_dynamic_libraries();
                result = GC_is_static_root(p);
                ENABLE_SIGNALS();
                if (result) return(p);
#           endif
            goto fail;
        } else {
            /* p points to the heap. */
            word descr;
            ptr_t base = GC_base(p);    /* Should be manually inlined? */
 
            if (base == 0) goto fail;
            if (HBLKPTR(base) != HBLKPTR(p)) hhdr = HDR((word)p);
            descr = hhdr -> hb_descr;
    retry:
            switch(descr & GC_DS_TAGS) {
                case GC_DS_LENGTH:
                    if ((word)((ptr_t)p - (ptr_t)base) > (word)descr) goto fail;
                    break;
                case GC_DS_BITMAP:
                    if ((ptr_t)p - (ptr_t)base
                         >= WORDS_TO_BYTES(BITMAP_BITS)
                         || ((word)p & (sizeof(word) - 1))) goto fail;
                    if (!((1 << (WORDSZ - ((ptr_t)p - (ptr_t)base) - 1))
                          & descr)) goto fail;
                    break;
                case GC_DS_PROC:
                    /* We could try to decipher this partially.         */
                    /* For now we just punt.                            */
                    break;
                case GC_DS_PER_OBJECT:
                    if ((signed_word)descr >= 0) {
                      descr = *(word *)((ptr_t)base + (descr & ~GC_DS_TAGS));
                    } else {
                      ptr_t type_descr = *(ptr_t *)base;
                      descr = *(word *)(type_descr
                              - (descr - (GC_DS_PER_OBJECT
                                          - GC_INDIR_PER_OBJ_BIAS)));
                    }
                    goto retry;
            }
            return(p);
        }
#   endif
fail:
    (*GC_is_visible_print_proc)((ptr_t)p);
    return(p);
}
 
 
GC_PTR GC_pre_incr (p, how_much)
GC_PTR *p;
size_t how_much;
{
    GC_PTR initial = *p;
    GC_PTR result = GC_same_obj((GC_PTR)((word)initial + how_much), initial);
 
    if (!GC_all_interior_pointers) {
        (void) GC_is_valid_displacement(result);
    }
    return (*p = result);
}
 
GC_PTR GC_post_incr (p, how_much)
GC_PTR *p;
size_t how_much;
{
    GC_PTR initial = *p;
    GC_PTR result = GC_same_obj((GC_PTR)((word)initial + how_much), initial);
 
    if (!GC_all_interior_pointers) {
        (void) GC_is_valid_displacement(result);
    }
    *p = result;
    return(initial);
}

Browse

Tools

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [boehm-gc/] [ptr_chck.c] - Blame information for rev 12

Line No.	Rev	Author	Line
1	12	jlechner	`/*`
2			`* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.`
3			`*`
4			`* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED`
5			`* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.`
6			`*`
7			`* Permission is hereby granted to use or copy this program`
8			`* for any purpose, provided the above notices are retained on all copies.`
9			`* Permission to modify the code and to distribute modified code is granted,`
10			`* provided the above notices are retained, and a notice that the code was`
11			`* modified is included with the above copyright notice.`
12			`*/`
13
14			`/*`
15			`* These are checking routines calls to which could be inserted by a`
16			`* preprocessor to validate C pointer arithmetic.`
17			`*/`
18
19			`#include "private/gc_pmark.h"`
20
21			`#ifdef __STDC__`
22			`void GC_default_same_obj_print_proc(GC_PTR p, GC_PTR q)`
23			`#else`
24			`void GC_default_same_obj_print_proc (p, q)`
25			`GC_PTR p, q;`
26			`#endif`
27			`{`
28			`GC_err_printf2("0x%lx and 0x%lx are not in the same object\n",`
29			`(unsigned long)p, (unsigned long)q);`
30			`ABORT("GC_same_obj test failed");`
31			`}`
32
33			`void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR, GC_PTR))`
34			`= GC_default_same_obj_print_proc;`
35
36			`/* Check that p and q point to the same object. Call */`
37			`/* GC_same_obj_print_proc if they don't. /`
38			`/* Returns the first argument. (Return value may be hard */`
39			`/* to use,due to typing issues. But if we had a suitable */`
40			`/* preprocessor ...) */`
41			`/* Succeeds if neither p nor q points to the heap. */`
42			`/* We assume this is performance critical. (It shouldn't */`
43			`/* be called by production code, but this can easily make */`
44			`/* debugging intolerably slow.) */`
45			`#ifdef __STDC__`
46			`GC_PTR GC_same_obj(register void p, register void q)`
47			`#else`
48			`GC_PTR GC_same_obj(p, q)`
49			`register char p, q;`
50			`#endif`
51			`{`
52			`register struct hblk *h;`
53			`register hdr *hhdr;`
54			`register ptr_t base, limit;`
55			`register word sz;`
56
57			`if (!GC_is_initialized) GC_init();`
58			`hhdr = HDR((word)p);`
59			`if (hhdr == 0) {`
60			`if (divHBLKSZ((word)p) != divHBLKSZ((word)q)`
61			`&& HDR((word)q) != 0) {`
62			`goto fail;`
63			`}`
64			`return(p);`
65			`}`
66			`/* If it's a pointer to the middle of a large object, move it */`
67			`/* to the beginning. */`
68			`if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {`
69			`h = HBLKPTR(p) - (word)hhdr;`
70			`hhdr = HDR(h);`
71			`while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {`
72			`h = FORWARDED_ADDR(h, hhdr);`
73			`hhdr = HDR(h);`
74			`}`
75			`limit = (ptr_t)((word *)h + hhdr -> hb_sz);`
76			`if ((ptr_t)p >= limit \|\| (ptr_t)q >= limit \|\| (ptr_t)q < (ptr_t)h ) {`
77			`goto fail;`
78			`}`
79			`return(p);`
80			`}`
81			`sz = WORDS_TO_BYTES(hhdr -> hb_sz);`
82			`if (sz > MAXOBJBYTES) {`
83			`base = (ptr_t)HBLKPTR(p);`
84			`limit = base + sz;`
85			`if ((ptr_t)p >= limit) {`
86			`goto fail;`
87			`}`
88			`} else {`
89			`register int map_entry;`
90			`register int pdispl = HBLKDISPL(p);`
91
92			`map_entry = MAP_ENTRY((hhdr -> hb_map), pdispl);`
93			`if (map_entry > CPP_MAX_OFFSET) {`
94			`map_entry = BYTES_TO_WORDS(pdispl) % BYTES_TO_WORDS(sz);`
95			`if (HBLKPTR(p) != HBLKPTR(q)) goto fail;`
96			`/* W/o this check, we might miss an error if */`
97			`/* q points to the first object on a page, and */`
98			`/* points just before the page. */`
99			`}`
100			`base = (char *)((word)p & ~(WORDS_TO_BYTES(1) - 1));`
101			`base -= WORDS_TO_BYTES(map_entry);`
102			`limit = base + sz;`
103			`}`
104			`/* [base, limit) delimits the object containing p, if any. */`
105			`/* If p is not inside a valid object, then either q is */`
106			`/* also outside any valid object, or it is outside */`
107			`/* [base, limit). */`
108			`if ((ptr_t)q >= limit \|\| (ptr_t)q < base) {`
109			`goto fail;`
110			`}`
111			`return(p);`
112			`fail:`
113			`(*GC_same_obj_print_proc)((ptr_t)p, (ptr_t)q);`
114			`return(p);`
115			`}`
116
117			`#ifdef __STDC__`
118			`void GC_default_is_valid_displacement_print_proc (GC_PTR p)`
119			`#else`
120			`void GC_default_is_valid_displacement_print_proc (p)`
121			`GC_PTR p;`
122			`#endif`
123			`{`
124			`GC_err_printf1("0x%lx does not point to valid object displacement\n",`
125			`(unsigned long)p);`
126			`ABORT("GC_is_valid_displacement test failed");`
127			`}`
128
129			`void (*GC_is_valid_displacement_print_proc) GC_PROTO((GC_PTR)) =`
130			`GC_default_is_valid_displacement_print_proc;`
131
132			`/* Check that if p is a pointer to a heap page, then it points to */`
133			`/* a valid displacement within a heap object. */`
134			`/* Uninteresting with GC_all_interior_pointers. */`
135			`/* Always returns its argument. */`
136			`/* Note that we don't lock, since nothing relevant about the header */`
137			`/* should change while we have a valid object pointer to the block. */`
138			`#ifdef __STDC__`
139			`void * GC_is_valid_displacement(void *p)`
140			`#else`
141			`char *GC_is_valid_displacement(p)`
142			`char *p;`
143			`#endif`
144			`{`
145			`register hdr *hhdr;`
146			`register word pdispl;`
147			`register struct hblk *h;`
148			`register map_entry_type map_entry;`
149			`register word sz;`
150
151			`if (!GC_is_initialized) GC_init();`
152			`hhdr = HDR((word)p);`
153			`if (hhdr == 0) return(p);`
154			`h = HBLKPTR(p);`
155			`if (GC_all_interior_pointers) {`
156			`while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {`
157			`h = FORWARDED_ADDR(h, hhdr);`
158			`hhdr = HDR(h);`
159			`}`
160			`}`
161			`if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {`
162			`goto fail;`
163			`}`
164			`sz = WORDS_TO_BYTES(hhdr -> hb_sz);`
165			`pdispl = HBLKDISPL(p);`
166			`map_entry = MAP_ENTRY((hhdr -> hb_map), pdispl);`
167			`if (map_entry == OBJ_INVALID`
168			`\|\| sz > MAXOBJBYTES && (ptr_t)p >= (ptr_t)h + sz) {`
169			`goto fail;`
170			`}`
171			`return(p);`
172			`fail:`
173			`(*GC_is_valid_displacement_print_proc)((ptr_t)p);`
174			`return(p);`
175			`}`
176
177			`#ifdef __STDC__`
178			`void GC_default_is_visible_print_proc(GC_PTR p)`
179			`#else`
180			`void GC_default_is_visible_print_proc(p)`
181			`GC_PTR p;`
182			`#endif`
183			`{`
184			`GC_err_printf1("0x%lx is not a GC visible pointer location\n",`
185			`(unsigned long)p);`
186			`ABORT("GC_is_visible test failed");`
187			`}`
188
189			`void (*GC_is_visible_print_proc) GC_PROTO((GC_PTR p)) =`
190			`GC_default_is_visible_print_proc;`
191
192			`/* Could p be a stack address? */`
193			`GC_bool GC_on_stack(p)`
194			`ptr_t p;`
195			`{`
196			`# ifdef THREADS`
197			`return(TRUE);`
198			`# else`
199			`int dummy;`
200			`# ifdef STACK_GROWS_DOWN`
201			`if ((ptr_t)p >= (ptr_t)(&dummy) && (ptr_t)p < GC_stackbottom ) {`
202			`return(TRUE);`
203			`}`
204			`# else`
205			`if ((ptr_t)p <= (ptr_t)(&dummy) && (ptr_t)p > GC_stackbottom ) {`
206			`return(TRUE);`
207			`}`
208			`# endif`
209			`return(FALSE);`
210			`# endif`
211			`}`
212
213			`/* Check that p is visible */`
214			`/* to the collector as a possibly pointer containing location. */`
215			`/* If it isn't invoke GC_is_visible_print_proc. /`
216			`/* Returns the argument in all cases. May erroneously succeed */`
217			`/* in hard cases. (This is intended for debugging use with */`
218			`/* untyped allocations. The idea is that it should be possible, though */`
219			`/* slow, to add such a call to all indirect pointer stores.) */`
220			`/* Currently useless for multithreaded worlds. */`
221			`#ifdef __STDC__`
222			`void * GC_is_visible(void *p)`
223			`#else`
224			`char *GC_is_visible(p)`
225			`char *p;`
226			`#endif`
227			`{`
228			`register hdr *hhdr;`
229
230			`if ((word)p & (ALIGNMENT - 1)) goto fail;`
231			`if (!GC_is_initialized) GC_init();`
232			`# ifdef THREADS`
233			`hhdr = HDR((word)p);`
234			`if (hhdr != 0 && GC_base(p) == 0) {`
235			`goto fail;`
236			`} else {`
237			`/* May be inside thread stack. We can't do much. */`
238			`return(p);`
239			`}`
240			`# else`
241			`/* Check stack first: */`
242			`if (GC_on_stack(p)) return(p);`
243			`hhdr = HDR((word)p);`
244			`if (hhdr == 0) {`
245			`GC_bool result;`
246
247			`if (GC_is_static_root(p)) return(p);`
248			`/* Else do it again correctly: */`
249			`# if (defined(DYNAMIC_LOADING) \|\| defined(MSWIN32) \|\| \`
250			`defined(MSWINCE) \|\| defined(PCR)) \`
251			`&& !defined(SRC_M3)`
252			`DISABLE_SIGNALS();`
253			`GC_register_dynamic_libraries();`
254			`result = GC_is_static_root(p);`
255			`ENABLE_SIGNALS();`
256			`if (result) return(p);`
257			`# endif`
258			`goto fail;`
259			`} else {`
260			`/* p points to the heap. */`
261			`word descr;`
262			`ptr_t base = GC_base(p); /* Should be manually inlined? */`
263
264			`if (base == 0) goto fail;`
265			`if (HBLKPTR(base) != HBLKPTR(p)) hhdr = HDR((word)p);`
266			`descr = hhdr -> hb_descr;`
267			`retry:`
268			`switch(descr & GC_DS_TAGS) {`
269			`case GC_DS_LENGTH:`
270			`if ((word)((ptr_t)p - (ptr_t)base) > (word)descr) goto fail;`
271			`break;`
272			`case GC_DS_BITMAP:`
273			`if ((ptr_t)p - (ptr_t)base`
274			`>= WORDS_TO_BYTES(BITMAP_BITS)`
275			`\|\| ((word)p & (sizeof(word) - 1))) goto fail;`
276			`if (!((1 << (WORDSZ - ((ptr_t)p - (ptr_t)base) - 1))`
277			`& descr)) goto fail;`
278			`break;`
279			`case GC_DS_PROC:`
280			`/* We could try to decipher this partially. */`
281			`/* For now we just punt. */`
282			`break;`
283			`case GC_DS_PER_OBJECT:`
284			`if ((signed_word)descr >= 0) {`
285			`descr = (word )((ptr_t)base + (descr & ~GC_DS_TAGS));`
286			`} else {`
287			`ptr_t type_descr = (ptr_t )base;`
288			`descr = (word )(type_descr`
289			`- (descr - (GC_DS_PER_OBJECT`
290			`- GC_INDIR_PER_OBJ_BIAS)));`
291			`}`
292			`goto retry;`
293			`}`
294			`return(p);`
295			`}`
296			`# endif`
297			`fail:`
298			`(*GC_is_visible_print_proc)((ptr_t)p);`
299			`return(p);`
300			`}`
301
302
303			`GC_PTR GC_pre_incr (p, how_much)`
304			`GC_PTR *p;`
305			`size_t how_much;`
306			`{`
307			`GC_PTR initial = *p;`
308			`GC_PTR result = GC_same_obj((GC_PTR)((word)initial + how_much), initial);`
309
310			`if (!GC_all_interior_pointers) {`
311			`(void) GC_is_valid_displacement(result);`
312			`}`
313			`return (*p = result);`
314			`}`
315
316			`GC_PTR GC_post_incr (p, how_much)`
317			`GC_PTR *p;`
318			`size_t how_much;`
319			`{`
320			`GC_PTR initial = *p;`
321			`GC_PTR result = GC_same_obj((GC_PTR)((word)initial + how_much), initial);`
322
323			`if (!GC_all_interior_pointers) {`
324			`(void) GC_is_valid_displacement(result);`
325			`}`
326			`*p = result;`
327			`return(initial);`
328			`}`