mallocx.c

   1 /*
   2  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
   3  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
   4  * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
   5  * Copyright (c) 2000 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 #include "gc_inline.h" /* for GC_malloc_kind */
  19
  20 /*
  21  * These are extra allocation routines which are likely to be less
  22  * frequently used than those in malloc.c.  They are separate in the
  23  * hope that the .o file will be excluded from statically linked
  24  * executables.  We should probably break this up further.
  25  */
  26
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #ifdef MSWINCE
  31 # ifndef WIN32_LEAN_AND_MEAN
  32 #   define WIN32_LEAN_AND_MEAN 1
  33 # endif
  34 # define NOSERVICE
  35 # include <windows.h>
  36 #else
  37 # include <errno.h>
  38 #endif
  39
  40 /* Some externally visible but unadvertised variables to allow access to */
  41 /* free lists from inlined allocators without including gc_priv.h        */
  42 /* or introducing dependencies on internal data structure layouts.       */
  43 #include "gc_alloc_ptrs.h"
  44 void ** const GC_objfreelist_ptr = GC_objfreelist;
  45 void ** const GC_aobjfreelist_ptr = GC_aobjfreelist;
  46 void ** const GC_uobjfreelist_ptr = GC_uobjfreelist;
  47 # ifdef GC_ATOMIC_UNCOLLECTABLE
  48     void ** const GC_auobjfreelist_ptr = GC_auobjfreelist;
  49 # endif
  50
  51 GC_API int GC_CALL GC_get_kind_and_size(const void * p, size_t * psize)
  52 {
  53     hdr * hhdr = HDR(p);
  54
  55     if (psize != NULL) {
  56         *psize = (size_t)hhdr->hb_sz;
  57     }
  58     return hhdr -> hb_obj_kind;
  59 }
  60
  61 GC_API GC_ATTR_MALLOC void * GC_CALL GC_generic_or_special_malloc(size_t lb,
  62                                                                   int knd)
  63 {
  64     switch(knd) {
  65         case PTRFREE:
  66         case NORMAL:
  67             return GC_malloc_kind(lb, knd);
  68         case UNCOLLECTABLE:
  69 #       ifdef GC_ATOMIC_UNCOLLECTABLE
  70           case AUNCOLLECTABLE:
  71 #       endif
  72             return GC_generic_malloc_uncollectable(lb, knd);
  73         default:
  74             return GC_generic_malloc(lb, knd);
  75     }
  76 }
  77
  78 /* Change the size of the block pointed to by p to contain at least   */
  79 /* lb bytes.  The object may be (and quite likely will be) moved.     */
  80 /* The kind (e.g. atomic) is the same as that of the old.             */
  81 /* Shrinking of large blocks is not implemented well.                 */
  82 GC_API void * GC_CALL GC_realloc(void * p, size_t lb)
  83 {
  84     struct hblk * h;
  85     hdr * hhdr;
  86     void * result;
  87     size_t sz;      /* Current size in bytes    */
  88     size_t orig_sz; /* Original sz in bytes     */
  89     int obj_kind;
  90
  91     if (p == 0) return(GC_malloc(lb));  /* Required by ANSI */
  92     if (0 == lb) /* and p != NULL */ {
  93 #     ifndef IGNORE_FREE
  94         GC_free(p);
  95 #     endif
  96       return NULL;
  97     }
  98     h = HBLKPTR(p);
  99     hhdr = HDR(h);
 100     sz = (size_t)hhdr->hb_sz;
 101     obj_kind = hhdr -> hb_obj_kind;
 102     orig_sz = sz;
 103
 104     if (sz > MAXOBJBYTES) {
 105         /* Round it up to the next whole heap block */
 106         word descr = GC_obj_kinds[obj_kind].ok_descriptor;
 107
 108         sz = (sz + HBLKSIZE-1) & ~HBLKMASK;
 109         if (GC_obj_kinds[obj_kind].ok_relocate_descr)
 110           descr += sz;
 111         /* GC_realloc might be changing the block size while            */
 112         /* GC_reclaim_block or GC_clear_hdr_marks is examining it.      */
 113         /* The change to the size field is benign, in that GC_reclaim   */
 114         /* (and GC_clear_hdr_marks) would work correctly with either    */
 115         /* value, since we are not changing the number of objects in    */
 116         /* the block.  But seeing a half-updated value (though unlikely */
 117         /* to occur in practice) could be probably bad.                 */
 118         /* Using unordered atomic accesses on the size and hb_descr     */
 119         /* fields would solve the issue.  (The alternate solution might */
 120         /* be to initially overallocate large objects, so we do not     */
 121         /* have to adjust the size in GC_realloc, if they still fit.    */
 122         /* But that is probably more expensive, since we may end up     */
 123         /* scanning a bunch of zeros during GC.)                        */
 124 #       ifdef AO_HAVE_store
 125           GC_STATIC_ASSERT(sizeof(hhdr->hb_sz) == sizeof(AO_t));
 126           AO_store((volatile AO_t *)&hhdr->hb_sz, (AO_t)sz);
 127           AO_store((volatile AO_t *)&hhdr->hb_descr, (AO_t)descr);
 128 #       else
 129           {
 130             DCL_LOCK_STATE;
 131
 132             LOCK();
 133             hhdr -> hb_sz = sz;
 134             hhdr -> hb_descr = descr;
 135             UNLOCK();
 136           }
 137 #       endif
 138
 139 #         ifdef MARK_BIT_PER_OBJ
 140             GC_ASSERT(hhdr -> hb_inv_sz == LARGE_INV_SZ);
 141 #         endif
 142 #         ifdef MARK_BIT_PER_GRANULE
 143             GC_ASSERT((hhdr -> hb_flags & LARGE_BLOCK) != 0
 144                         && hhdr -> hb_map[ANY_INDEX] == 1);
 145 #         endif
 146           if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz);
 147           /* Extra area is already cleared by GC_alloc_large_and_clear. */
 148     }
 149     if (ADD_SLOP(lb) <= sz) {
 150         if (lb >= (sz >> 1)) {
 151             if (orig_sz > lb) {
 152               /* Clear unneeded part of object to avoid bogus pointer */
 153               /* tracing.                                             */
 154                 BZERO(((ptr_t)p) + lb, orig_sz - lb);
 155             }
 156             return(p);
 157         }
 158         /* shrink */
 159         sz = lb;
 160     }
 161     result = GC_generic_or_special_malloc((word)lb, obj_kind);
 162     if (result != NULL) {
 163       /* In case of shrink, it could also return original object.       */
 164       /* But this gives the client warning of imminent disaster.        */
 165       BCOPY(p, result, sz);
 166 #     ifndef IGNORE_FREE
 167         GC_free(p);
 168 #     endif
 169     }
 170     return result;
 171 }
 172
 173 # if defined(REDIRECT_MALLOC) && !defined(REDIRECT_REALLOC)
 174 #   define REDIRECT_REALLOC GC_realloc
 175 # endif
 176
 177 # ifdef REDIRECT_REALLOC
 178
 179 /* As with malloc, avoid two levels of extra calls here.        */
 180 # define GC_debug_realloc_replacement(p, lb) \
 181         GC_debug_realloc(p, lb, GC_DBG_EXTRAS)
 182
 183 # if !defined(REDIRECT_MALLOC_IN_HEADER)
 184     void * realloc(void * p, size_t lb)
 185     {
 186       return(REDIRECT_REALLOC(p, lb));
 187     }
 188 # endif
 189
 190 # undef GC_debug_realloc_replacement
 191 # endif /* REDIRECT_REALLOC */
 192
 193 /* Allocate memory such that only pointers to near the          */
 194 /* beginning of the object are considered.                      */
 195 /* We avoid holding allocation lock while we clear the memory.  */
 196 GC_API GC_ATTR_MALLOC void * GC_CALL
 197     GC_generic_malloc_ignore_off_page(size_t lb, int k)
 198 {
 199     void *result;
 200     size_t lg;
 201     size_t lb_rounded;
 202     word n_blocks;
 203     GC_bool init;
 204     DCL_LOCK_STATE;
 205
 206     if (SMALL_OBJ(lb))
 207         return GC_generic_malloc(lb, k);
 208     GC_ASSERT(k < MAXOBJKINDS);
 209     lg = ROUNDED_UP_GRANULES(lb);
 210     lb_rounded = GRANULES_TO_BYTES(lg);
 211     n_blocks = OBJ_SZ_TO_BLOCKS(lb_rounded);
 212     init = GC_obj_kinds[k].ok_init;
 213     if (EXPECT(GC_have_errors, FALSE))
 214       GC_print_all_errors();
 215     GC_INVOKE_FINALIZERS();
 216     GC_DBG_COLLECT_AT_MALLOC(lb);
 217     LOCK();
 218     result = (ptr_t)GC_alloc_large(ADD_SLOP(lb), k, IGNORE_OFF_PAGE);
 219     if (NULL == result) {
 220         GC_oom_func oom_fn = GC_oom_fn;
 221         UNLOCK();
 222         return (*oom_fn)(lb);
 223     }
 224
 225     if (GC_debugging_started) {
 226         BZERO(result, n_blocks * HBLKSIZE);
 227     } else {
 228 #       ifdef THREADS
 229             /* Clear any memory that might be used for GC descriptors   */
 230             /* before we release the lock.                              */
 231             ((word *)result)[0] = 0;
 232             ((word *)result)[1] = 0;
 233             ((word *)result)[GRANULES_TO_WORDS(lg)-1] = 0;
 234             ((word *)result)[GRANULES_TO_WORDS(lg)-2] = 0;
 235 #       endif
 236     }
 237     GC_bytes_allocd += lb_rounded;
 238     UNLOCK();
 239     if (init && !GC_debugging_started) {
 240         BZERO(result, n_blocks * HBLKSIZE);
 241     }
 242     return(result);
 243 }
 244
 245 GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_ignore_off_page(size_t lb)
 246 {
 247     return GC_generic_malloc_ignore_off_page(lb, NORMAL);
 248 }
 249
 250 GC_API GC_ATTR_MALLOC void * GC_CALL
 251     GC_malloc_atomic_ignore_off_page(size_t lb)
 252 {
 253     return GC_generic_malloc_ignore_off_page(lb, PTRFREE);
 254 }
 255
 256 /* Increment GC_bytes_allocd from code that doesn't have direct access  */
 257 /* to GC_arrays.                                                        */
 258 GC_API void GC_CALL GC_incr_bytes_allocd(size_t n)
 259 {
 260     GC_bytes_allocd += n;
 261 }
 262
 263 /* The same for GC_bytes_freed.                         */
 264 GC_API void GC_CALL GC_incr_bytes_freed(size_t n)
 265 {
 266     GC_bytes_freed += n;
 267 }
 268
 269 GC_API size_t GC_CALL GC_get_expl_freed_bytes_since_gc(void)
 270 {
 271     return (size_t)GC_bytes_freed;
 272 }
 273
 274 # ifdef PARALLEL_MARK
 275     STATIC volatile AO_t GC_bytes_allocd_tmp = 0;
 276                         /* Number of bytes of memory allocated since    */
 277                         /* we released the GC lock.  Instead of         */
 278                         /* reacquiring the GC lock just to add this in, */
 279                         /* we add it in the next time we reacquire      */
 280                         /* the lock.  (Atomically adding it doesn't     */
 281                         /* work, since we would have to atomically      */
 282                         /* update it in GC_malloc, which is too         */
 283                         /* expensive.)                                  */
 284 # endif /* PARALLEL_MARK */
 285
 286 /* Return a list of 1 or more objects of the indicated size, linked     */
 287 /* through the first word in the object.  This has the advantage that   */
 288 /* it acquires the allocation lock only once, and may greatly reduce    */
 289 /* time wasted contending for the allocation lock.  Typical usage would */
 290 /* be in a thread that requires many items of the same size.  It would  */
 291 /* keep its own free list in thread-local storage, and call             */
 292 /* GC_malloc_many or friends to replenish it.  (We do not round up      */
 293 /* object sizes, since a call indicates the intention to consume many   */
 294 /* objects of exactly this size.)                                       */
 295 /* We assume that the size is a multiple of GRANULE_BYTES.              */
 296 /* We return the free-list by assigning it to *result, since it is      */
 297 /* not safe to return, e.g. a linked list of pointer-free objects,      */
 298 /* since the collector would not retain the entire list if it were      */
 299 /* invoked just as we were returning.                                   */
 300 /* Note that the client should usually clear the link field.            */
 301 GC_API void GC_CALL GC_generic_malloc_many(size_t lb, int k, void **result)
 302 {
 303     void *op;
 304     void *p;
 305     void **opp;
 306     size_t lw;      /* Length in words.     */
 307     size_t lg;      /* Length in granules.  */
 308     signed_word my_bytes_allocd = 0;
 309     struct obj_kind * ok = &(GC_obj_kinds[k]);
 310     struct hblk ** rlh;
 311     DCL_LOCK_STATE;
 312
 313     GC_ASSERT(lb != 0 && (lb & (GRANULE_BYTES-1)) == 0);
 314     /* Currently a single object is always allocated if manual VDB. */
 315     /* TODO: GC_dirty should be called for each linked object (but  */
 316     /* the last one) to support multiple objects allocation.        */
 317     if (!SMALL_OBJ(lb) || GC_manual_vdb) {
 318         op = GC_generic_malloc(lb, k);
 319         if (EXPECT(0 != op, TRUE))
 320             obj_link(op) = 0;
 321         *result = op;
 322 #       ifndef GC_DISABLE_INCREMENTAL
 323           if (GC_manual_vdb && GC_is_heap_ptr(result)) {
 324             GC_dirty_inner(result);
 325             REACHABLE_AFTER_DIRTY(op);
 326           }
 327 #       endif
 328         return;
 329     }
 330     GC_ASSERT(k < MAXOBJKINDS);
 331     lw = BYTES_TO_WORDS(lb);
 332     lg = BYTES_TO_GRANULES(lb);
 333     if (EXPECT(GC_have_errors, FALSE))
 334       GC_print_all_errors();
 335     GC_INVOKE_FINALIZERS();
 336     GC_DBG_COLLECT_AT_MALLOC(lb);
 337     if (!EXPECT(GC_is_initialized, TRUE)) GC_init();
 338     LOCK();
 339     /* Do our share of marking work */
 340       if (GC_incremental && !GC_dont_gc) {
 341         ENTER_GC();
 342         GC_collect_a_little_inner(1);
 343         EXIT_GC();
 344       }
 345     /* First see if we can reclaim a page of objects waiting to be */
 346     /* reclaimed.                                                  */
 347     rlh = ok -> ok_reclaim_list;
 348     if (rlh != NULL) {
 349         struct hblk * hbp;
 350         hdr * hhdr;
 351
 352         rlh += lg;
 353         while ((hbp = *rlh) != 0) {
 354             hhdr = HDR(hbp);
 355             *rlh = hhdr -> hb_next;
 356             GC_ASSERT(hhdr -> hb_sz == lb);
 357             hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no;
 358 #           ifdef PARALLEL_MARK
 359               if (GC_parallel) {
 360                   signed_word my_bytes_allocd_tmp =
 361                                 (signed_word)AO_load(&GC_bytes_allocd_tmp);
 362                   GC_ASSERT(my_bytes_allocd_tmp >= 0);
 363                   /* We only decrement it while holding the GC lock.    */
 364                   /* Thus we can't accidentally adjust it down in more  */
 365                   /* than one thread simultaneously.                    */
 366
 367                   if (my_bytes_allocd_tmp != 0) {
 368                     (void)AO_fetch_and_add(&GC_bytes_allocd_tmp,
 369                                            (AO_t)(-my_bytes_allocd_tmp));
 370                     GC_bytes_allocd += my_bytes_allocd_tmp;
 371                   }
 372                   GC_acquire_mark_lock();
 373                   ++ GC_fl_builder_count;
 374                   UNLOCK();
 375                   GC_release_mark_lock();
 376               }
 377 #           endif
 378             op = GC_reclaim_generic(hbp, hhdr, lb,
 379                                     ok -> ok_init, 0, &my_bytes_allocd);
 380             if (op != 0) {
 381 #             ifdef PARALLEL_MARK
 382                 if (GC_parallel) {
 383                   *result = op;
 384                   (void)AO_fetch_and_add(&GC_bytes_allocd_tmp,
 385                                          (AO_t)my_bytes_allocd);
 386                   GC_acquire_mark_lock();
 387                   -- GC_fl_builder_count;
 388                   if (GC_fl_builder_count == 0) GC_notify_all_builder();
 389 #                 ifdef THREAD_SANITIZER
 390                     GC_release_mark_lock();
 391                     LOCK();
 392                     GC_bytes_found += my_bytes_allocd;
 393                     UNLOCK();
 394 #                 else
 395                     GC_bytes_found += my_bytes_allocd;
 396                                         /* The result may be inaccurate. */
 397                     GC_release_mark_lock();
 398 #                 endif
 399                   (void) GC_clear_stack(0);
 400                   return;
 401                 }
 402 #             endif
 403               /* We also reclaimed memory, so we need to adjust       */
 404               /* that count.                                          */
 405               GC_bytes_found += my_bytes_allocd;
 406               GC_bytes_allocd += my_bytes_allocd;
 407               goto out;
 408             }
 409 #           ifdef PARALLEL_MARK
 410               if (GC_parallel) {
 411                 GC_acquire_mark_lock();
 412                 -- GC_fl_builder_count;
 413                 if (GC_fl_builder_count == 0) GC_notify_all_builder();
 414                 GC_release_mark_lock();
 415                 LOCK();
 416                 /* GC lock is needed for reclaim list access.   We      */
 417                 /* must decrement fl_builder_count before reacquiring   */
 418                 /* the lock.  Hopefully this path is rare.              */
 419               }
 420 #           endif
 421         }
 422     }
 423     /* Next try to use prefix of global free list if there is one.      */
 424     /* We don't refill it, but we need to use it up before allocating   */
 425     /* a new block ourselves.                                           */
 426       opp = &(GC_obj_kinds[k].ok_freelist[lg]);
 427       if ( (op = *opp) != 0 ) {
 428         *opp = 0;
 429         my_bytes_allocd = 0;
 430         for (p = op; p != 0; p = obj_link(p)) {
 431           my_bytes_allocd += lb;
 432           if ((word)my_bytes_allocd >= HBLKSIZE) {
 433             *opp = obj_link(p);
 434             obj_link(p) = 0;
 435             break;
 436           }
 437         }
 438         GC_bytes_allocd += my_bytes_allocd;
 439         goto out;
 440       }
 441     /* Next try to allocate a new block worth of objects of this size.  */
 442     {
 443         struct hblk *h = GC_allochblk(lb, k, 0);
 444         if (h != 0) {
 445           if (IS_UNCOLLECTABLE(k)) GC_set_hdr_marks(HDR(h));
 446           GC_bytes_allocd += HBLKSIZE - HBLKSIZE % lb;
 447 #         ifdef PARALLEL_MARK
 448             if (GC_parallel) {
 449               GC_acquire_mark_lock();
 450               ++ GC_fl_builder_count;
 451               UNLOCK();
 452               GC_release_mark_lock();
 453
 454               op = GC_build_fl(h, lw,
 455                         (ok -> ok_init || GC_debugging_started), 0);
 456
 457               *result = op;
 458               GC_acquire_mark_lock();
 459               -- GC_fl_builder_count;
 460               if (GC_fl_builder_count == 0) GC_notify_all_builder();
 461               GC_release_mark_lock();
 462               (void) GC_clear_stack(0);
 463               return;
 464             }
 465 #         endif
 466           op = GC_build_fl(h, lw, (ok -> ok_init || GC_debugging_started), 0);
 467           goto out;
 468         }
 469     }
 470
 471     /* As a last attempt, try allocating a single object.  Note that    */
 472     /* this may trigger a collection or expand the heap.                */
 473       op = GC_generic_malloc_inner(lb, k);
 474       if (0 != op) obj_link(op) = 0;
 475
 476   out:
 477     *result = op;
 478     UNLOCK();
 479     (void) GC_clear_stack(0);
 480 }
 481
 482 /* Note that the "atomic" version of this would be unsafe, since the    */
 483 /* links would not be seen by the collector.                            */
 484 GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_many(size_t lb)
 485 {
 486     void *result;
 487
 488     /* Add EXTRA_BYTES and round up to a multiple of a granule. */
 489     lb = SIZET_SAT_ADD(lb, EXTRA_BYTES + GRANULE_BYTES - 1)
 490             & ~(GRANULE_BYTES - 1);
 491
 492     GC_generic_malloc_many(lb, NORMAL, &result);
 493     return result;
 494 }
 495
 496 #include <limits.h>
 497
 498 /* Debug version is tricky and currently missing.       */
 499 GC_API GC_ATTR_MALLOC void * GC_CALL GC_memalign(size_t align, size_t lb)
 500 {
 501     size_t new_lb;
 502     size_t offset;
 503     ptr_t result;
 504
 505     if (align <= GRANULE_BYTES) return GC_malloc(lb);
 506     if (align >= HBLKSIZE/2 || lb >= HBLKSIZE/2) {
 507         if (align > HBLKSIZE) {
 508           return (*GC_get_oom_fn())(LONG_MAX-1024); /* Fail */
 509         }
 510         return GC_malloc(lb <= HBLKSIZE? HBLKSIZE : lb);
 511             /* Will be HBLKSIZE aligned.        */
 512     }
 513     /* We could also try to make sure that the real rounded-up object size */
 514     /* is a multiple of align.  That would be correct up to HBLKSIZE.      */
 515     new_lb = SIZET_SAT_ADD(lb, align - 1);
 516     result = (ptr_t)GC_malloc(new_lb);
 517             /* It is OK not to check result for NULL as in that case    */
 518             /* GC_memalign returns NULL too since (0 + 0 % align) is 0. */
 519     offset = (word)result % align;
 520     if (offset != 0) {
 521         offset = align - offset;
 522         if (!GC_all_interior_pointers) {
 523             GC_STATIC_ASSERT(VALID_OFFSET_SZ <= HBLKSIZE);
 524             GC_ASSERT(offset < VALID_OFFSET_SZ);
 525             GC_register_displacement(offset);
 526         }
 527     }
 528     result += offset;
 529     GC_ASSERT((word)result % align == 0);
 530     return result;
 531 }
 532
 533 /* This one exists largely to redirect posix_memalign for leaks finding. */
 534 GC_API int GC_CALL GC_posix_memalign(void **memptr, size_t align, size_t lb)
 535 {
 536   /* Check alignment properly.  */
 537   size_t align_minus_one = align - 1; /* to workaround a cppcheck warning */
 538   if (align < sizeof(void *) || (align_minus_one & align) != 0) {
 539 #   ifdef MSWINCE
 540       return ERROR_INVALID_PARAMETER;
 541 #   else
 542       return EINVAL;
 543 #   endif
 544   }
 545
 546   if ((*memptr = GC_memalign(align, lb)) == NULL) {
 547 #   ifdef MSWINCE
 548       return ERROR_NOT_ENOUGH_MEMORY;
 549 #   else
 550       return ENOMEM;
 551 #   endif
 552   }
 553   return 0;
 554 }
 555
 556 /* provide a version of strdup() that uses the collector to allocate the
 557    copy of the string */
 558 GC_API GC_ATTR_MALLOC char * GC_CALL GC_strdup(const char *s)
 559 {
 560   char *copy;
 561   size_t lb;
 562   if (s == NULL) return NULL;
 563   lb = strlen(s) + 1;
 564   copy = (char *)GC_malloc_atomic(lb);
 565   if (NULL == copy) {
 566 #   ifndef MSWINCE
 567       errno = ENOMEM;
 568 #   endif
 569     return NULL;
 570   }
 571   BCOPY(s, copy, lb);
 572   return copy;
 573 }
 574
 575 GC_API GC_ATTR_MALLOC char * GC_CALL GC_strndup(const char *str, size_t size)
 576 {
 577   char *copy;
 578   size_t len = strlen(str); /* str is expected to be non-NULL  */
 579   if (len > size)
 580     len = size;
 581   copy = (char *)GC_malloc_atomic(len + 1);
 582   if (copy == NULL) {
 583 #   ifndef MSWINCE
 584       errno = ENOMEM;
 585 #   endif
 586     return NULL;
 587   }
 588   if (EXPECT(len > 0, TRUE))
 589     BCOPY(str, copy, len);
 590   copy[len] = '\0';
 591   return copy;
 592 }
 593
 594 #ifdef GC_REQUIRE_WCSDUP
 595 # include <wchar.h> /* for wcslen() */
 596
 597   GC_API GC_ATTR_MALLOC wchar_t * GC_CALL GC_wcsdup(const wchar_t *str)
 598   {
 599     size_t lb = (wcslen(str) + 1) * sizeof(wchar_t);
 600     wchar_t *copy = (wchar_t *)GC_malloc_atomic(lb);
 601
 602     if (copy == NULL) {
 603 #     ifndef MSWINCE
 604         errno = ENOMEM;
 605 #     endif
 606       return NULL;
 607     }
 608     BCOPY(str, copy, lb);
 609     return copy;
 610   }
 611 #endif /* GC_REQUIRE_WCSDUP */
 612
 613 #ifndef CPPCHECK
 614   GC_API void * GC_CALL GC_malloc_stubborn(size_t lb)
 615   {
 616     return GC_malloc(lb);
 617   }
 618
 619   GC_API void GC_CALL GC_change_stubborn(const void *p GC_ATTR_UNUSED)
 620   {
 621     /* Empty. */
 622   }
 623 #endif /* !CPPCHECK */
 624
 625 GC_API void GC_CALL GC_end_stubborn_change(const void *p)
 626 {
 627   GC_dirty(p); /* entire object */
 628 }
 629
 630 GC_API void GC_CALL GC_ptr_store_and_dirty(void *p, const void *q)
 631 {
 632   *(const void **)p = q;
 633   GC_dirty(p);
 634   REACHABLE_AFTER_DIRTY(q);
 635 }