Prepend output file with 'malloctrace.' even when env var is not set.

Also add some code comments on future things to do.

Simplify code and reduce overhead at trace time.

We now evaluate the IP to module connection at evaluation time,
rather than during tracing to reduce the overhead. This also gets
rid of the rather large IP cache, thereby reducing the memory
overhead.

Save ptr start and end address instead of start + size.

Also output that size.

Return early for now, without bzipping output files.

Add a threaded test application

Extract some more information on the allocation data, such as a size histogram.

Use stack-allocated trace buffer.

This seems to be required in multithreaded applications as otherwise
I get random crashes or deadlocks...

Break when encountering zero-IP.

This is senseless imo. Also, continuing would be very slow as
libunwind would try to ask dwarf info for the next IP for that
address which is bad, performance wise. And again, it will never
find anything and we just pay for nothing.

Take trace size into account for hash generation.

Skip instructions which we cannot make sense of.

Fixup environment passing via gdb to the library.

Abort on failure.

Preallocate trace buffer once.

Cleanup environment

Disable error messages when dwarf info is missing.

Get file and line from dwarf info if possible.

Update trace script.

Use vectors everywhere and be pedantic about input data.

Print total leaked bytes and number of allocations.

Don't do manual reserve calls, its slower than the default way.

Introduce a memleak in the test app.

Print top allocators and all leaks in a sorted way.

Refactor code: work with just a single file and use vector for traces.

The latter will allow us to sort the traces later on for evaluation
purposes easily.

Demangle function names.

Refactor malloc tracing, synchronize most of the stuff after all.

I completely forgot before that a free can follow a malloc in a
different thread which is perfectly fine. To support this, we must
centralize our data handler after all.

This is not too bad as we can merge the multi-thread data into one
file that way and have it interleaved properly which will be good
for later evaluation.

From a contention point of view, I tried to minimize it as much as
possible. Further evaluation and profiling will be done later.

Bring back trace and ip cache to reduce generated filesize.

Also speeds up things as repeated large prints are actually quite
slow. Furthermore we extend the tool to actually interpret the data.

Check for valid malloc/free before handling it.

Reserve place for 32 modules.

Reimplement backtrace reading and offload dwarf info interpretation.

This makes the profiling run much faster. The later evaluation is
not so performance critical then thereafter.

Fix regression I introduced

Use relative module offsets instead of baseAddress + address.

Add kdev project file.

Add start of a malloc trace evaluation executable.

This shows that we can do post-mortem address resolution.
Not yet really functional but enough for a quick test.

Remove uuid code, not required for my usecase afaik.

Cleanup code, insert data directly in a sorted order.

Port bsearch to C++ STL's std::lower_bound.

Adapt code to my coding style.

Cleanup code a bit by removing unused functions.

Get proper dwarf-based backtraces with filename and line numbers.

This code is based on the libbacktrace from GCC, see:
https://github.com/mirrors/gcc/tree/master/libbacktrace

Furthermore, we include btrace.{cpp,h} and CMakeLists.txt, based
on Vogl from Valve Software/RAD Game Tools, see:
https://github.com/ValveSoftware/vogl.git

Add todo on sub-tree matching

Don't create single-entry trees output.

Save memory, use unsigned int instead of size_t for ids.

The number of call stacks should hopefully fit into that range.

Only print a given call-tree once

Stop at static_initialization_and_destruction

Move test files and compile them in debug mode.

Use namespace std;

Add kateconfig

Write output into per-thread files and merge that then later.

Skip handleMalloc properly.

Add support for posix_memalign, aligned_alloc and valloc.

Handle calloc.

Handle realloc

Also output calls to free

Print full backtraces

Make it possible to run the malloc tracer in GDB easily.

Cleanup code and only output function names once.

Also don't keep them in memory afterwards. This means we'll need a
separate tool to interpret the data, but its much faster this way.

Cache unw_get_proc_name for the ip's we encounter

Print caller of malloc/operator new/operator new[] instead of full backtrace.

On-demand initialize real_* func ptrs.

We must not rely on static initialization order here.

Only local unwind is required

add c++ example

extend test.c a bit.

Add simple malloc/free tracer

don't trace child apps

Append PID to output files

add simple run script

simplify

Make output actually usable and also possible to dump to a custom file

Make output destination configurable

Only enable c++11 for c++ files

Add test binary to verify that this trick also works with pure C applications

true instead of 1

fix usage message

Use raw pointer to not get a double delete on exit.

Add snapshot ID and timestamp to output.

add LGPL v2+ license

Initial import of dumpmallocinfo.

This is a little library that you can LD_PRELOAD to your application.
It will then call malloc_info in user-defined intervals (configured
via DUMP_MALLOC_INFO_INTERVAL environment variable).

See `man malloc_info 3` for more information.