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