dlls/msvcrt/heap.c

   1 /*
   2  * msvcrt.dll heap functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Note: Win32 heap operations are MT safe. We only lock the new
  21  *       handler and non atomic heap operations
  22  */
  23
  24 #include "msvcrt.h"
  25 #include "mtdll.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  29
  30 /* MT */
  31 #define LOCK_HEAP   _mlock( _HEAP_LOCK )
  32 #define UNLOCK_HEAP _munlock( _HEAP_LOCK )
  33
  34 /* _aligned */
  35 #define SAVED_PTR(x) ((void *)((DWORD_PTR)((char *)x - sizeof(void *)) & \
  36                                ~(sizeof(void *) - 1)))
  37 #define ALIGN_PTR(ptr, alignment, offset) ((void *) \
  38     ((((DWORD_PTR)((char *)ptr + alignment + sizeof(void *) + offset)) & \
  39       ~(alignment - 1)) - offset))
  40
  41 #define SB_HEAP_ALIGN 16
  42
  43 static HANDLE heap, sb_heap;
  44
  45 typedef int (CDECL *MSVCRT_new_handler_func)(MSVCRT_size_t size);
  46
  47 static MSVCRT_new_handler_func MSVCRT_new_handler;
  48 static int MSVCRT_new_mode;
  49
  50 /* FIXME - According to documentation it should be 8*1024, at runtime it returns 16 */
  51 static unsigned int MSVCRT_amblksiz = 16;
  52 /* FIXME - According to documentation it should be 480 bytes, at runtime default is 0 */
  53 static MSVCRT_size_t MSVCRT_sbh_threshold = 0;
  54
  55 static void* msvcrt_heap_alloc(DWORD flags, MSVCRT_size_t size)
  56 {
  57     if(size < MSVCRT_sbh_threshold)
  58     {
  59         void *memblock, *temp, **saved;
  60
  61         temp = HeapAlloc(sb_heap, flags, size+sizeof(void*)+SB_HEAP_ALIGN);
  62         if(!temp) return NULL;
  63
  64         memblock = ALIGN_PTR(temp, SB_HEAP_ALIGN, 0);
  65         saved = SAVED_PTR(memblock);
  66         *saved = temp;
  67         return memblock;
  68     }
  69
  70     return HeapAlloc(heap, flags, size);
  71 }
  72
  73 static void* msvcrt_heap_realloc(DWORD flags, void *ptr, MSVCRT_size_t size)
  74 {
  75     if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
  76     {
  77         /* TODO: move data to normal heap if it exceeds sbh_threshold limit */
  78         void *memblock, *temp, **saved;
  79         MSVCRT_size_t old_padding, new_padding, old_size;
  80
  81         saved = SAVED_PTR(ptr);
  82         old_padding = (char*)ptr - (char*)*saved;
  83         old_size = HeapSize(sb_heap, 0, *saved);
  84         if(old_size == -1)
  85             return NULL;
  86         old_size -= old_padding;
  87
  88         temp = HeapReAlloc(sb_heap, flags, *saved, size+sizeof(void*)+SB_HEAP_ALIGN);
  89         if(!temp) return NULL;
  90
  91         memblock = ALIGN_PTR(temp, SB_HEAP_ALIGN, 0);
  92         saved = SAVED_PTR(memblock);
  93         new_padding = (char*)memblock - (char*)temp;
  94
  95         if(new_padding != old_padding)
  96             memmove(memblock, (char*)temp+old_padding, old_size>size ? size : old_size);
  97
  98         *saved = temp;
  99         return memblock;
 100     }
 101
 102     return HeapReAlloc(heap, flags, ptr, size);
 103 }
 104
 105 static BOOL msvcrt_heap_free(void *ptr)
 106 {
 107     if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
 108     {
 109         void **saved = SAVED_PTR(ptr);
 110         return HeapFree(sb_heap, 0, *saved);
 111     }
 112
 113     return HeapFree(heap, 0, ptr);
 114 }
 115
 116 static MSVCRT_size_t msvcrt_heap_size(void *ptr)
 117 {
 118     if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
 119     {
 120         void **saved = SAVED_PTR(ptr);
 121         return HeapSize(sb_heap, 0, *saved);
 122     }
 123
 124     return HeapSize(heap, 0, ptr);
 125 }
 126
 127 /*********************************************************************
 128  *              ??2@YAPAXI@Z (MSVCRT.@)
 129  */
 130 void* CDECL MSVCRT_operator_new(MSVCRT_size_t size)
 131 {
 132   void *retval;
 133   int freed;
 134
 135   do
 136   {
 137     retval = msvcrt_heap_alloc(0, size);
 138     if(retval)
 139     {
 140       TRACE("(%ld) returning %p\n", size, retval);
 141       return retval;
 142     }
 143
 144     LOCK_HEAP;
 145     if(MSVCRT_new_handler)
 146       freed = (*MSVCRT_new_handler)(size);
 147     else
 148       freed = 0;
 149     UNLOCK_HEAP;
 150   } while(freed);
 151
 152   TRACE("(%ld) out of memory\n", size);
 153 #if _MSVCR_VER >= 80
 154   throw_bad_alloc("bad allocation");
 155 #endif
 156   return NULL;
 157 }
 158
 159
 160 /*********************************************************************
 161  *              ??2@YAPAXIHPBDH@Z (MSVCRT.@)
 162  */
 163 void* CDECL MSVCRT_operator_new_dbg(MSVCRT_size_t size, int type, const char *file, int line)
 164 {
 165     return MSVCRT_operator_new( size );
 166 }
 167
 168
 169 /*********************************************************************
 170  *              ??3@YAXPAX@Z (MSVCRT.@)
 171  */
 172 void CDECL MSVCRT_operator_delete(void *mem)
 173 {
 174   TRACE("(%p)\n", mem);
 175   msvcrt_heap_free(mem);
 176 }
 177
 178
 179 /*********************************************************************
 180  *              ?_query_new_handler@@YAP6AHI@ZXZ (MSVCRT.@)
 181  */
 182 MSVCRT_new_handler_func CDECL MSVCRT__query_new_handler(void)
 183 {
 184   return MSVCRT_new_handler;
 185 }
 186
 187
 188 /*********************************************************************
 189  *              ?_query_new_mode@@YAHXZ (MSVCRT.@)
 190  */
 191 int CDECL MSVCRT__query_new_mode(void)
 192 {
 193   return MSVCRT_new_mode;
 194 }
 195
 196 /*********************************************************************
 197  *              ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z (MSVCRT.@)
 198  */
 199 MSVCRT_new_handler_func CDECL MSVCRT__set_new_handler(MSVCRT_new_handler_func func)
 200 {
 201   MSVCRT_new_handler_func old_handler;
 202   LOCK_HEAP;
 203   old_handler = MSVCRT_new_handler;
 204   MSVCRT_new_handler = func;
 205   UNLOCK_HEAP;
 206   return old_handler;
 207 }
 208
 209 /*********************************************************************
 210  *              ?set_new_handler@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
 211  */
 212 MSVCRT_new_handler_func CDECL MSVCRT_set_new_handler(void *func)
 213 {
 214   TRACE("(%p)\n",func);
 215   MSVCRT__set_new_handler(NULL);
 216   return NULL;
 217 }
 218
 219 /*********************************************************************
 220  *              ?_set_new_mode@@YAHH@Z (MSVCRT.@)
 221  */
 222 int CDECL MSVCRT__set_new_mode(int mode)
 223 {
 224   int old_mode;
 225   LOCK_HEAP;
 226   old_mode = MSVCRT_new_mode;
 227   MSVCRT_new_mode = mode;
 228   UNLOCK_HEAP;
 229   return old_mode;
 230 }
 231
 232 /*********************************************************************
 233  *              _callnewh (MSVCRT.@)
 234  */
 235 int CDECL _callnewh(MSVCRT_size_t size)
 236 {
 237   if(MSVCRT_new_handler)
 238     (*MSVCRT_new_handler)(size);
 239   return 0;
 240 }
 241
 242 /*********************************************************************
 243  *              _expand (MSVCRT.@)
 244  */
 245 void* CDECL _expand(void* mem, MSVCRT_size_t size)
 246 {
 247   return msvcrt_heap_realloc(HEAP_REALLOC_IN_PLACE_ONLY, mem, size);
 248 }
 249
 250 /*********************************************************************
 251  *              _heapchk (MSVCRT.@)
 252  */
 253 int CDECL _heapchk(void)
 254 {
 255   if (!HeapValidate(heap, 0, NULL) ||
 256           (sb_heap && !HeapValidate(sb_heap, 0, NULL)))
 257   {
 258     msvcrt_set_errno(GetLastError());
 259     return MSVCRT__HEAPBADNODE;
 260   }
 261   return MSVCRT__HEAPOK;
 262 }
 263
 264 /*********************************************************************
 265  *              _heapmin (MSVCRT.@)
 266  */
 267 int CDECL _heapmin(void)
 268 {
 269   if (!HeapCompact( heap, 0 ) ||
 270           (sb_heap && !HeapCompact( sb_heap, 0 )))
 271   {
 272     if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
 273       msvcrt_set_errno(GetLastError());
 274     return -1;
 275   }
 276   return 0;
 277 }
 278
 279 /*********************************************************************
 280  *              _heapwalk (MSVCRT.@)
 281  */
 282 int CDECL _heapwalk(struct MSVCRT__heapinfo* next)
 283 {
 284   PROCESS_HEAP_ENTRY phe;
 285
 286   if (sb_heap)
 287       FIXME("small blocks heap not supported\n");
 288
 289   LOCK_HEAP;
 290   phe.lpData = next->_pentry;
 291   phe.cbData = next->_size;
 292   phe.wFlags = next->_useflag == MSVCRT__USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
 293
 294   if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
 295       !HeapValidate( heap, 0, phe.lpData ))
 296   {
 297     UNLOCK_HEAP;
 298     msvcrt_set_errno(GetLastError());
 299     return MSVCRT__HEAPBADNODE;
 300   }
 301
 302   do
 303   {
 304     if (!HeapWalk( heap, &phe ))
 305     {
 306       UNLOCK_HEAP;
 307       if (GetLastError() == ERROR_NO_MORE_ITEMS)
 308          return MSVCRT__HEAPEND;
 309       msvcrt_set_errno(GetLastError());
 310       if (!phe.lpData)
 311         return MSVCRT__HEAPBADBEGIN;
 312       return MSVCRT__HEAPBADNODE;
 313     }
 314   } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));
 315
 316   UNLOCK_HEAP;
 317   next->_pentry = phe.lpData;
 318   next->_size = phe.cbData;
 319   next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? MSVCRT__USEDENTRY : MSVCRT__FREEENTRY;
 320   return MSVCRT__HEAPOK;
 321 }
 322
 323 /*********************************************************************
 324  *              _heapset (MSVCRT.@)
 325  */
 326 int CDECL _heapset(unsigned int value)
 327 {
 328   int retval;
 329   struct MSVCRT__heapinfo heap;
 330
 331   memset( &heap, 0, sizeof(heap) );
 332   LOCK_HEAP;
 333   while ((retval = _heapwalk(&heap)) == MSVCRT__HEAPOK)
 334   {
 335     if (heap._useflag == MSVCRT__FREEENTRY)
 336       memset(heap._pentry, value, heap._size);
 337   }
 338   UNLOCK_HEAP;
 339   return retval == MSVCRT__HEAPEND? MSVCRT__HEAPOK : retval;
 340 }
 341
 342 /*********************************************************************
 343  *              _heapadd (MSVCRT.@)
 344  */
 345 int CDECL _heapadd(void* mem, MSVCRT_size_t size)
 346 {
 347   TRACE("(%p,%ld) unsupported in Win32\n", mem,size);
 348   *MSVCRT__errno() = MSVCRT_ENOSYS;
 349   return -1;
 350 }
 351
 352 /*********************************************************************
 353  *              _get_heap_handle (MSVCRT.@)
 354  */
 355 MSVCRT_intptr_t CDECL _get_heap_handle(void)
 356 {
 357     return (MSVCRT_intptr_t)heap;
 358 }
 359
 360 /*********************************************************************
 361  *              _msize (MSVCRT.@)
 362  */
 363 MSVCRT_size_t CDECL _msize(void* mem)
 364 {
 365   MSVCRT_size_t size = msvcrt_heap_size(mem);
 366   if (size == ~(MSVCRT_size_t)0)
 367   {
 368     WARN(":Probably called with non wine-allocated memory, ret = -1\n");
 369     /* At least the Win32 crtdll/msvcrt also return -1 in this case */
 370   }
 371   return size;
 372 }
 373
 374 /*********************************************************************
 375  * _aligned_msize (MSVCR100.@)
 376  */
 377 size_t CDECL _aligned_msize(void *p, MSVCRT_size_t alignment, MSVCRT_size_t offset)
 378 {
 379     void **alloc_ptr;
 380
 381     if(!MSVCRT_CHECK_PMT(p)) return -1;
 382
 383     if(alignment < sizeof(void*))
 384         alignment = sizeof(void*);
 385
 386     alloc_ptr = SAVED_PTR(p);
 387     return _msize(*alloc_ptr)-alignment-sizeof(void*);
 388 }
 389
 390 /*********************************************************************
 391  *              calloc (MSVCRT.@)
 392  */
 393 void* CDECL MSVCRT_calloc(MSVCRT_size_t size, MSVCRT_size_t count)
 394 {
 395   return msvcrt_heap_alloc(HEAP_ZERO_MEMORY, size*count);
 396 }
 397
 398 /*********************************************************************
 399  *              free (MSVCRT.@)
 400  */
 401 void CDECL MSVCRT_free(void* ptr)
 402 {
 403   msvcrt_heap_free(ptr);
 404 }
 405
 406 /*********************************************************************
 407  *                  malloc (MSVCRT.@)
 408  */
 409 void* CDECL MSVCRT_malloc(MSVCRT_size_t size)
 410 {
 411   void *ret = msvcrt_heap_alloc(0, size);
 412   if (!ret)
 413       *MSVCRT__errno() = MSVCRT_ENOMEM;
 414   return ret;
 415 }
 416
 417 /*********************************************************************
 418  *              realloc (MSVCRT.@)
 419  */
 420 void* CDECL MSVCRT_realloc(void* ptr, MSVCRT_size_t size)
 421 {
 422   if (!ptr) return MSVCRT_malloc(size);
 423   if (size) return msvcrt_heap_realloc(0, ptr, size);
 424   MSVCRT_free(ptr);
 425   return NULL;
 426 }
 427
 428 /*********************************************************************
 429  * _recalloc (MSVCR100.@)
 430  */
 431 void* CDECL _recalloc(void *mem, MSVCRT_size_t num, MSVCRT_size_t size)
 432 {
 433     MSVCRT_size_t old_size;
 434     void *ret;
 435
 436     if(!mem)
 437         return MSVCRT_calloc(num, size);
 438
 439     size = num*size;
 440     old_size = _msize(mem);
 441
 442     ret = MSVCRT_realloc(mem, size);
 443     if(!ret) {
 444         *MSVCRT__errno() = MSVCRT_ENOMEM;
 445         return NULL;
 446     }
 447
 448     if(size>old_size)
 449         memset((BYTE*)ret+old_size, 0, size-old_size);
 450     return ret;
 451 }
 452
 453 /*********************************************************************
 454  *              __p__amblksiz (MSVCRT.@)
 455  */
 456 unsigned int* CDECL __p__amblksiz(void)
 457 {
 458   return &MSVCRT_amblksiz;
 459 }
 460
 461 /*********************************************************************
 462  *              _get_sbh_threshold (MSVCRT.@)
 463  */
 464 MSVCRT_size_t CDECL _get_sbh_threshold(void)
 465 {
 466   return MSVCRT_sbh_threshold;
 467 }
 468
 469 /*********************************************************************
 470  *              _set_sbh_threshold (MSVCRT.@)
 471  */
 472 int CDECL _set_sbh_threshold(MSVCRT_size_t threshold)
 473 {
 474 #ifdef _WIN64
 475   return 0;
 476 #else
 477   if(threshold > 1016)
 478      return 0;
 479
 480   if(!sb_heap)
 481   {
 482       sb_heap = HeapCreate(0, 0, 0);
 483       if(!sb_heap)
 484           return 0;
 485   }
 486
 487   MSVCRT_sbh_threshold = (threshold+0xf) & ~0xf;
 488   return 1;
 489 #endif
 490 }
 491
 492 /*********************************************************************
 493  *              _aligned_free (MSVCRT.@)
 494  */
 495 void CDECL _aligned_free(void *memblock)
 496 {
 497     TRACE("(%p)\n", memblock);
 498
 499     if (memblock)
 500     {
 501         void **saved = SAVED_PTR(memblock);
 502         MSVCRT_free(*saved);
 503     }
 504 }
 505
 506 /*********************************************************************
 507  *              _aligned_offset_malloc (MSVCRT.@)
 508  */
 509 void * CDECL _aligned_offset_malloc(MSVCRT_size_t size, MSVCRT_size_t alignment, MSVCRT_size_t offset)
 510 {
 511     void *memblock, *temp, **saved;
 512     TRACE("(%lu, %lu, %lu)\n", size, alignment, offset);
 513
 514     /* alignment must be a power of 2 */
 515     if ((alignment & (alignment - 1)) != 0)
 516     {
 517         *MSVCRT__errno() = MSVCRT_EINVAL;
 518         return NULL;
 519     }
 520
 521     /* offset must be less than size */
 522     if (offset && offset >= size)
 523     {
 524         *MSVCRT__errno() = MSVCRT_EINVAL;
 525         return NULL;
 526     }
 527
 528     /* don't align to less than void pointer size */
 529     if (alignment < sizeof(void *))
 530         alignment = sizeof(void *);
 531
 532     /* allocate enough space for void pointer and alignment */
 533     temp = MSVCRT_malloc(size + alignment + sizeof(void *));
 534
 535     if (!temp)
 536         return NULL;
 537
 538     /* adjust pointer for proper alignment and offset */
 539     memblock = ALIGN_PTR(temp, alignment, offset);
 540
 541     /* Save the real allocation address below returned address */
 542     /* so it can be found later to free. */
 543     saved = SAVED_PTR(memblock);
 544     *saved = temp;
 545
 546     return memblock;
 547 }
 548
 549 /*********************************************************************
 550  *              _aligned_malloc (MSVCRT.@)
 551  */
 552 void * CDECL _aligned_malloc(MSVCRT_size_t size, MSVCRT_size_t alignment)
 553 {
 554     TRACE("(%lu, %lu)\n", size, alignment);
 555     return _aligned_offset_malloc(size, alignment, 0);
 556 }
 557
 558 /*********************************************************************
 559  *              _aligned_offset_realloc (MSVCRT.@)
 560  */
 561 void * CDECL _aligned_offset_realloc(void *memblock, MSVCRT_size_t size,
 562                                      MSVCRT_size_t alignment, MSVCRT_size_t offset)
 563 {
 564     void * temp, **saved;
 565     MSVCRT_size_t old_padding, new_padding, old_size;
 566     TRACE("(%p, %lu, %lu, %lu)\n", memblock, size, alignment, offset);
 567
 568     if (!memblock)
 569         return _aligned_offset_malloc(size, alignment, offset);
 570
 571     /* alignment must be a power of 2 */
 572     if ((alignment & (alignment - 1)) != 0)
 573     {
 574         *MSVCRT__errno() = MSVCRT_EINVAL;
 575         return NULL;
 576     }
 577
 578     /* offset must be less than size */
 579     if (offset >= size)
 580     {
 581         *MSVCRT__errno() = MSVCRT_EINVAL;
 582         return NULL;
 583     }
 584
 585     if (size == 0)
 586     {
 587         _aligned_free(memblock);
 588         return NULL;
 589     }
 590
 591     /* don't align to less than void pointer size */
 592     if (alignment < sizeof(void *))
 593         alignment = sizeof(void *);
 594
 595     /* make sure alignment and offset didn't change */
 596     saved = SAVED_PTR(memblock);
 597     if (memblock != ALIGN_PTR(*saved, alignment, offset))
 598     {
 599         *MSVCRT__errno() = MSVCRT_EINVAL;
 600         return NULL;
 601     }
 602
 603     old_padding = (char *)memblock - (char *)*saved;
 604
 605     /* Get previous size of block */
 606     old_size = _msize(*saved);
 607     if (old_size == -1)
 608     {
 609         /* It seems this function was called with an invalid pointer. Bail out. */
 610         return NULL;
 611     }
 612
 613     /* Adjust old_size to get amount of actual data in old block. */
 614     if (old_size < old_padding)
 615     {
 616         /* Shouldn't happen. Something's weird, so bail out. */
 617         return NULL;
 618     }
 619     old_size -= old_padding;
 620
 621     temp = MSVCRT_realloc(*saved, size + alignment + sizeof(void *));
 622
 623     if (!temp)
 624         return NULL;
 625
 626     /* adjust pointer for proper alignment and offset */
 627     memblock = ALIGN_PTR(temp, alignment, offset);
 628
 629     /* Save the real allocation address below returned address */
 630     /* so it can be found later to free. */
 631     saved = SAVED_PTR(memblock);
 632
 633     new_padding = (char *)memblock - (char *)temp;
 634
 635 /*
 636    Memory layout of old block is as follows:
 637    +-------+---------------------+-+--------------------------+-----------+
 638    |  ...  | "old_padding" bytes | | ... "old_size" bytes ... |    ...    |
 639    +-------+---------------------+-+--------------------------+-----------+
 640            ^                     ^ ^
 641            |                     | |
 642         *saved               saved memblock
 643
 644    Memory layout of new block is as follows:
 645    +-------+-----------------------------+-+----------------------+-------+
 646    |  ...  |    "new_padding" bytes      | | ... "size" bytes ... |  ...  |
 647    +-------+-----------------------------+-+----------------------+-------+
 648            ^                             ^ ^
 649            |                             | |
 650           temp                       saved memblock
 651
 652    However, in the new block, actual data is still written as follows
 653    (because it was copied by MSVCRT_realloc):
 654    +-------+---------------------+--------------------------------+-------+
 655    |  ...  | "old_padding" bytes |   ... "old_size" bytes ...     |  ...  |
 656    +-------+---------------------+--------------------------------+-------+
 657            ^                             ^ ^
 658            |                             | |
 659           temp                       saved memblock
 660
 661    Therefore, min(old_size,size) bytes of actual data have to be moved
 662    from the offset they were at in the old block (temp + old_padding),
 663    to the offset they have to be in the new block (temp + new_padding == memblock).
 664 */
 665     if (new_padding != old_padding)
 666         memmove((char *)memblock, (char *)temp + old_padding, (old_size < size) ? old_size : size);
 667
 668     *saved = temp;
 669
 670     return memblock;
 671 }
 672
 673 /*********************************************************************
 674  *              _aligned_realloc (MSVCRT.@)
 675  */
 676 void * CDECL _aligned_realloc(void *memblock, MSVCRT_size_t size, MSVCRT_size_t alignment)
 677 {
 678     TRACE("(%p, %lu, %lu)\n", memblock, size, alignment);
 679     return _aligned_offset_realloc(memblock, size, alignment, 0);
 680 }
 681
 682 /*********************************************************************
 683  *              memmove_s (MSVCRT.@)
 684  */
 685 int CDECL MSVCRT_memmove_s(void *dest, MSVCRT_size_t numberOfElements, const void *src, MSVCRT_size_t count)
 686 {
 687     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
 688
 689     if(!count)
 690         return 0;
 691
 692     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 693     if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
 694     if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
 695
 696     memmove(dest, src, count);
 697     return 0;
 698 }
 699
 700 /*********************************************************************
 701  *              wmemmove_s (MSVCR100.@)
 702  */
 703 int CDECL wmemmove_s(MSVCRT_wchar_t *dest, MSVCRT_size_t numberOfElements,
 704         const MSVCRT_wchar_t *src, MSVCRT_size_t count)
 705 {
 706     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
 707
 708     if (!count)
 709         return 0;
 710
 711     /* Native does not seem to conform to 6.7.1.2.3 in
 712      * http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1225.pdf
 713      * in that it does not zero the output buffer on constraint violation.
 714      */
 715     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 716     if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
 717     if (!MSVCRT_CHECK_PMT_ERR(count <= numberOfElements, MSVCRT_ERANGE)) return MSVCRT_ERANGE;
 718
 719     memmove(dest, src, sizeof(MSVCRT_wchar_t)*count);
 720     return 0;
 721 }
 722
 723 /*********************************************************************
 724  *              memcpy_s (MSVCRT.@)
 725  */
 726 int CDECL MSVCRT_memcpy_s(void *dest, MSVCRT_size_t numberOfElements, const void *src, MSVCRT_size_t count)
 727 {
 728     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
 729
 730     if(!count)
 731         return 0;
 732
 733     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 734     if (!MSVCRT_CHECK_PMT(src != NULL))
 735     {
 736         memset(dest, 0, numberOfElements);
 737         return MSVCRT_EINVAL;
 738     }
 739     if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, MSVCRT_ERANGE ))
 740     {
 741         memset(dest, 0, numberOfElements);
 742         return MSVCRT_ERANGE;
 743     }
 744
 745     memcpy(dest, src, count);
 746     return 0;
 747 }
 748
 749 /*********************************************************************
 750  *              wmemcpy_s (MSVCR100.@)
 751  */
 752 int CDECL wmemcpy_s(MSVCRT_wchar_t *dest, MSVCRT_size_t numberOfElements,
 753         const MSVCRT_wchar_t *src, MSVCRT_size_t count)
 754 {
 755     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
 756
 757     if (!count)
 758         return 0;
 759
 760     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 761
 762     if (!MSVCRT_CHECK_PMT(src != NULL)) {
 763         memset(dest, 0, numberOfElements*sizeof(MSVCRT_wchar_t));
 764         return MSVCRT_EINVAL;
 765     }
 766     if (!MSVCRT_CHECK_PMT_ERR(count <= numberOfElements, MSVCRT_ERANGE)) {
 767         memset(dest, 0, numberOfElements*sizeof(MSVCRT_wchar_t));
 768         return MSVCRT_ERANGE;
 769     }
 770
 771     memcpy(dest, src, sizeof(MSVCRT_wchar_t)*count);
 772     return 0;
 773 }
 774
 775 /*********************************************************************
 776  *              strncpy_s (MSVCRT.@)
 777  */
 778 int CDECL MSVCRT_strncpy_s(char *dest, MSVCRT_size_t numberOfElements,
 779         const char *src, MSVCRT_size_t count)
 780 {
 781     MSVCRT_size_t i, end;
 782
 783     TRACE("(%p %lu %s %lu)\n", dest, numberOfElements, debugstr_a(src), count);
 784
 785     if(!count) {
 786         if(dest && numberOfElements)
 787             *dest = 0;
 788         return 0;
 789     }
 790
 791     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 792     if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
 793     if (!MSVCRT_CHECK_PMT(numberOfElements != 0)) return MSVCRT_EINVAL;
 794
 795     if(count!=MSVCRT__TRUNCATE && count<numberOfElements)
 796         end = count;
 797     else
 798         end = numberOfElements-1;
 799
 800     for(i=0; i<end && src[i]; i++)
 801         dest[i] = src[i];
 802
 803     if(!src[i] || end==count || count==MSVCRT__TRUNCATE) {
 804         dest[i] = '\0';
 805         return 0;
 806     }
 807
 808     MSVCRT_INVALID_PMT("dest[numberOfElements] is too small", MSVCRT_EINVAL);
 809     dest[0] = '\0';
 810     return MSVCRT_EINVAL;
 811 }
 812
 813 BOOL msvcrt_init_heap(void)
 814 {
 815     heap = HeapCreate(0, 0, 0);
 816     return heap != NULL;
 817 }
 818
 819 void msvcrt_destroy_heap(void)
 820 {
 821     HeapDestroy(heap);
 822     if(sb_heap)
 823         HeapDestroy(sb_heap);
 824 }