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