development/Win32/vld/CHANGES.txt

   1 Visual Leak Detector (VLD) Version 1.9h (beta)
   2
   3   Change Log / Release Notes
   4
   5     Enhancements:
   6   + Added support to work with Visual Studio 2010.
   7
   8 1.9h beta (24 February 2009)
   9 ----------------------------
  10   Enhancements:
  11   + Added support to work with Visual Studio 2008.
  12
  13   Known Bugs/Restrictions:
  14   + Same bugs/restrictions as version 1.9f.
  15
  16
  17 1.9g beta (16 April 2008)
  18 ----------------------------
  19   Bugs Fixed:
  20   + Another deadlock condition may occur when loading DLLs into the process
  21     being debugged. Special thanks to Eric Bissonnette and Kristian Paradis for
  22     contributing this patch.
  23
  24   Known Bugs/Restrictions:
  25   + Same bugs/restrictions as version 1.9f.
  26
  27
  28 1.9f beta (18 November 2006)
  29 ----------------------------
  30   Bugs Fixed:
  31   + Deadlocks or access violations may occur when loading DLLs into
  32     multithreaded processes.
  33
  34   + In multithreaded programs, if the main thread terminates before other
  35     threads in the process, then Visual Leak Detector may cause an access
  36     violation while generating the memory leak report.
  37
  38   Known Bugs/Restrictions:
  39   + Memory allocations made through calls to functions loaded from a DLL using
  40     delayed loading may not be detected.
  41
  42   + Support for programs that use MFC 7.0 or MFC 7.1 is not complete yet. Some
  43     memory leaks from such MFC-based programs may not be detected.
  44
  45   + Visual Leak Detector may report leaks internal to Visual Leak Detector
  46     if the main thread of the process terminates while other threads are still
  47     running.
  48
  49   + If more than one copy of the same C Runtime DLL is loaded in the process at
  50     the same time, then some leaks may go undetected (note that loading more
  51     than one copy of the C Runtime DLL into a process at the same time is
  52     probably a bad idea to begin with).
  53
  54
  55 1.9e beta (16 November 2006)
  56 ----------------------------
  57   New Features/Enhancements:
  58   + Added a master on/off switch configuration option to vld.ini that can be
  59     used to completely disable Visual Leak Detector.
  60
  61   Bugs Fixed:
  62   + Numerous deadlock situations. The multithread synchronization scheme has
  63     been completely re-written which should make deadlocks in VLD much less
  64     likey to happen.
  65
  66   + An access violation will occur in VLD if GetProcAddress is called to obtain
  67     an export's address by ordinal, for certain libraries.
  68
  69   + Problems may potentially occur when the program being debugged exits due to
  70     the Debug Help Library having been detached from the process too early.
  71     Symptoms might include access violation exceptions or other erratic behavior
  72     just as the program exits and while VLD is generating the leak report.
  73
  74   + The copy of vld.ini installed in VLD's installation directory overrides any
  75     other copies of vld.ini that are created, even copies placed in the
  76     working directory of the program being debugged.
  77
  78   Known Bugs/Restrictions:
  79   + Memory allocations made through calls to functions loaded from a DLL using
  80     delayed loading may not be detected.
  81
  82   + Support for programs that use MFC 7.0 or MFC 7.1 is not complete yet. Some
  83     memory leaks from such MFC-based programs may not be detected.
  84
  85   + If more than one copy of the same C Runtime DLL is loaded in the process at
  86     the same time, then some leaks may go undetected (note that loading more
  87     than one copy of the C Runtime DLL into a process at the same time is
  88     probably a bad idea to begin with).
  89
  90
  91 1.9d beta (12 November 2006)
  92 ----------------------------
  93   Bugs Fixed:
  94   + Failed assertion "freed == TRUE" pops up when running a program with VLD
  95     without the debugger attached.
  96
  97   + Some, but not all, multithreaded programs that dynamically load and unload
  98     many DLLs have been known to experience problems, such as deadlocks or
  99     exceptions, when used with VLD.
 100
 101   + Failed assertion "exportmodule != NULL" pops up when running some programs
 102     with VLD.
 103
 104   + VLD fails to show file names or function names in the memory leak report for
 105     some programs that are linked with the dynamic CRT library.
 106
 107   + Access violation exceptions are thrown, but caught by the operating system,
 108     when running some programs with VLD.
 109
 110
 111 1.9c beta (6 November 2006)
 112 ---------------------------
 113   New Features/Enhancments:
 114   + New NSIS installer makes setting up and using VLD much easier.
 115
 116   + No need to manually copy dbghelp.dll to the right location, VLD will always
 117     find the right version.
 118
 119   + MFC 8.0 is now fully supported.
 120
 121   + The memory leak report is now written to the output window much faster.
 122     Support has been added, through a new configuration option, to slow down
 123     the report output for older versions of Visual Studio that have trouble
 124     when it is written too quickly.
 125
 126   Bugs Fixed:
 127   + All known compatibilities with Visual Studio 2005 have been eliminated.
 128
 129   + Leaks from calloc may go undetected.
 130
 131   + Leaks from vector new operator may go undetected.
 132
 133   + VLDDisable and VLDEnable do not work as expected; some memory leaks that
 134     should be ignored by VLD due to a previous call to VLDDisable are still
 135     reported.
 136
 137   + Unloading and reloading a previously loaded module may cause leaks that
 138     occur in the module after it was reloaded to go undetected.
 139
 140   + If vld.h is included in a release build, then the compiler will generate
 141     errors if the VLDEnable or VLDDisable APIs have been used.
 142
 143
 144 1.9b beta (26 October 2006)
 145 ---------------------------
 146   Bugs Fixed:
 147   + Source compiles under Visual Studio 2005 and the binaries are compatible
 148     with applications that link with the Visual Studio 2005 C Runtime Library
 149     (msvcr80d.dll).
 150
 151   Known Restrictions in this Release:
 152   + Memory allocations made through calls to functions loaded from a DLL using
 153     delayed loading may not be detected.
 154
 155   + Support for programs that use MFC 7.0, MFC 7.1, or MFC 8.0 is not complete
 156     yet. Some memory leaks from such MFC-based programs may not be detected. A
 157     workaround for this restriction is to forcefully include the MFC DLLs in
 158     memory leak detection, by setting the "ForceIncludeModules" configuration
 159     option to: "mfc70d.dll mfc71d.dll mfc80d.dll" and explicitly adding vld.lib
 160     as an input file on the linker command line (can be added through project
 161     settings by adding it to the list of library modules in the linker options).
 162     This restriction does not apply to programs that use MFC 4.2, which is fully
 163     supported.
 164
 165
 166 1.9a beta (9 March 2006)
 167 ------------------------
 168   New Features/Enhancments:
 169   + All new leak detection engine detects most, if not all, in-process memory
 170     leaks, not just leaks from "new" or "malloc", including COM-based leaks.
 171
 172   + Packaged as an easier-to-use DLL. There's no longer any need to carefully
 173     decide which modules should be linked with the VLD library. Instead, you
 174     just include the vld.h header file in at least one source file from each
 175     module (DLL or EXE) to be included in memory leak detection.
 176
 177   + Configuration is done from an INI file instead of using preprocessor macros.
 178     This allows VLD's configuration to be changed without needing to recompile
 179     the program.
 180
 181   + Many new configuration options have been added. One of the most often
 182     requested option that has been added is the option to save the leak report
 183     to a file instead of, or in addition to, the debugger.
 184
 185   Bugs Fixed:
 186   + The improved design of the new leak detection engine has resolved all of the
 187     previously known restrictions in version 1.0.
 188
 189   Known Restrictions in this Release:
 190   + Memory allocations made through calls to functions loaded from a DLL using
 191     delayed loading may not be detected.
 192
 193   + Support for programs that use MFC 7.0, MFC 7.1, or MFC 8.0 is not complete
 194     yet. Some memory leaks from such MFC-based programs may not be detected. A
 195     workaround for this restriction is to forcefully include the MFC DLLs in
 196     memory leak detection, by setting the "ForceIncludeModules" configuration
 197     option to: "mfc70d.dll mfc71d.dll mfc80d.dll" and explicitly adding vld.lib
 198     as an input file on the linker command line (can be added through project
 199     settings by adding it to the list of library modules in the linker options).
 200     This restriction does not apply to programs that use MFC 4.2, which is fully
 201     supported.
 202
 203
 204 1.0 (5 August 2005)
 205 -------------------
 206   New Features/Enhancements:
 207   + Memory leak detection can now be selectively disabled and enabled at
 208     runtime, using provided APIs. This provides a straightforward way of
 209     allowing VLD to selectively "ignore" certain allocations. It can also be
 210     used to disable VLD altogether at runtime, improving application performance
 211     without needing to recompile.
 212
 213   + If there are multiple identical memory leaks (i.e. leaks that originate from
 214     the same call stack and that leak the same size memory block) then VLD can
 215     optionally aggregate all of the repeated leaks, showing only the first such
 216     leaked block in detail in the memory leak report. A tally of the total
 217     number of leaks that match that particular size and call stack accompanies
 218     the information for that leak.
 219
 220   + When VLD is initialized at program startup, the library type which was
 221     linked-in is displayed. This can help verify that the expected VLD library
 222     (either single-threaded static, multithreaded static, or multithreaded DLL)
 223     is being linked with your program.
 224
 225   + The Visual Leak Detector name is displayed on most messages output to the
 226     debugger to easily differentiate VLD's output from the output produced by
 227     the built-in memory leak detector.
 228
 229   + If any of the compile-time configuration options have been changed from
 230     their default values, then the current state of the option is displayed in
 231     the debugger when VLD is initialized.
 232
 233   + VLD's memory leak self-checking capability (checking for leaks in VLD
 234     itself) can be verified using a new preprocessor macro that allows VLD to
 235     perform a self-test at runtime.
 236
 237   Bugs Fixed:
 238   + If the MFC libraries are statically linked to the program being debugged,
 239     then MFC will erroneously report memory leaks in the Visual Leak Detector
 240     code and may cause an access violation while attempting to report the false
 241     memory leaks. These bogus leaks are always reported as "client block at
 242     <address>, subtype bf42" and are claimed to be "invalid objects".
 243
 244   + VLD will leak a fixed-sized block of memory when the program exits if VLD
 245     failed to initialize because the Debug Help library (dbghelp.dll) could not
 246     be loaded.
 247
 248   + In multithreaded programs, if the program's main thread terminates before
 249     other threads in the same process, then VLD may cause an access violation
 250     while freeing resources used internally by VLD.
 251
 252
 253 0.9i beta (30 April 2005)
 254 -------------------------
 255   New Features/Enhancements:
 256   + Added support in the source code for x64 architecture. The pre-built
 257     libraries will continue to support 32-bit only. If you need 64-bit support
 258     you'll need to build 64-bit versions of the libraries from source. Note that
 259     x64 is the only 64-bit architecture supported at this time. Itanium (aka
 260     IA-64) is NOT currently supported.
 261
 262   Bugs Fixed:
 263   + VLD does not report memory leaks that are the result of a failure to free
 264     memory allocated via a call to realloc().
 265   + In multithreaded programs, if the program's main thread terminates before
 266     other threads in the same process, then VLD may cause an access violation
 267     while checking for memory leaks.
 268   + If VLD cannot find the source file and line number information for a program
 269     address, the last known file and line number will be repeated in the call
 270     stack section of the memory leak report. The correct behavior should be for
 271     VLD to print "File and line number not available" for that call stack entry.
 272
 273
 274 0.9h beta (22 April 2005)
 275 -------------------------
 276   Bugs Fixed:
 277   + Access Violations occur at random places within the VLD code when using
 278     VLD version 0.9g.
 279   + When using VLD version 0.9g, VLD may fail to report some memory leaks.
 280
 281
 282 0.9g beta (22 April 2005)
 283 -------------------------
 284   New Features/Enhancements:
 285   + Replaced the temporary internal search algorithm with a permanent search
 286     algorithm that is much faster. Programs that dynamically allocate a large
 287     number of memory blocks (tens of thousands or more) will see the most
 288     significant performance boost from this version of VLD versus the previous
 289     version. Overall, this is the fastest version of VLD released to date.
 290
 291
 292 0.9f beta (13 April 2005)
 293 -------------------------
 294   New Features/Enhancements:
 295   + Changed the internal search algorithm to a temporary simpler, but
 296     more stable algorithm. A permanent algorithm which should be much
 297     more efficient will be in a forthcoming release.
 298
 299   Bugs Fixed:
 300   + Access Violation at line 319 in vldutil.cpp may occur when running a
 301     program linked with the VLD library.
 302
 303
 304 0.9e beta (12 April 2005)
 305 -------------------------
 306   New Features/Enhancements:
 307   + VLD no longer uses any STL containers or STL strings. This solves all of the
 308     compatibility problems with Visual Studio .NET when using the pre-built
 309     VLD libraries.
 310
 311   + The configuration preprocessor macros now work with C programs without the
 312     need to call VLDConfigure from within the program being debugged.
 313     Because VLDConfigure is now obsolete, it has been removed.
 314
 315   + One new source file (vldutil.cpp) and one new header (vldutil.h) have been
 316     added. They contain utility functions and utility classes that replace
 317     functionality previously performed by STL containers and strings.
 318
 319   + The VisualLeakDetector global class object is now constructed at C runtime
 320     initialization (i.e. it resides in the "compiler" initialization area).
 321     Because VLD no longer uses any STL components, there is no longer the risk
 322     that VLD will conflict with any STL libraries that also are constructed at
 323     C runtime initialization. The end result is that VLD starts running earlier
 324     and is destroyed later, which leads to more accurate leak detection.
 325
 326   Bugs Fixed:
 327   + Linking to the VLD 0.9d libraries from the VLD distribution under Visual
 328     Studio .NET results in a number of linker "unresolved external symbol"
 329     errors. Unresolved symbols include "__declspec(dllimport) void __cdecl
 330     std::_Xran(void)" and "__declspec(dllimport) private: void __thiscall
 331     std::basic_string,class std::allocator >::_Eos(unsigned int)", among others.
 332
 333   + Call stacks do not appear in the memory leak report when linking against
 334     release VLD libraries built from source with Visual Studio .NET.
 335
 336   + If the preprocessor macro VLD_MAX_DATA_DUMP is defined as 0 (zero), then VLD
 337     will get stuck in an infinite loop, repeatedly printing the same information
 338     while attempting to display the memory leak report in the debugger's output
 339     window.
 340
 341
 342 0.9d beta (30 March 2005)
 343 -------------------------
 344   New Features/Enhancements:
 345   + This version of VLD brings with it some major changes to the way VLD
 346     interfaces with programs that use it. Instead of requiring that VLD be built
 347     from source and then linked with the application, VLD is now packaged as a
 348     pre-built static library. For those who just want to use VLD and are not
 349     interested in modifying the source, this eliminates the complexities of
 350     building VLD from source. A single header file, vld.h, has been added. To
 351     link with the static library, this header needs to be included in one of the
 352     program's source files. Please see the README.txt file for details on how
 353     these changes affect how to use Visual Leak Detector.
 354
 355   + The Microsoft Debug Help Library (dbghelp.dll) version 6.3 is now included
 356     with the VLD distribution.
 357
 358
 359 0.9c beta (17 March 2005)
 360 -------------------------
 361   Bugs Fixed:
 362   + Compile error, "error C2039: 'size' : is not a member of '_CrtMemBlockHeader'"
 363     occurs at line 644 of vld.cpp when building VLD with the VLD_MAX_DATA_DUMP
 364     preprocessor macro defined.
 365
 366
 367 0.9b beta (15 March 2005)
 368 -------------------------
 369   Bugs Fixed:
 370   + VLD fails to detect memory leaks in class constructors if the objects
 371     constructed are global objects.
 372
 373   + If a debug executable is built with certain compiler optimizations turned on,
 374     specifically frame pointer omission optimization or automatic inlining, then
 375     theoretically VLD may produce incomplete or inaccurate stack traces or might
 376     fail to produce stack traces altogether.
 377
 378
 379 0.9a beta (12 March 2005)
 380 -------------------------
 381   Initial Public Release
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393