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