go for it!

is this done? 

Currently we only define this function in ASan (which is where I need it). We decided
to wait until the stack unwinding code is generalized enough that this function can
be implemented in sanitizer_common, rather than implement it separately in each tool.
I would keep this open until then.

This function is actually super helpful. There's just one problem. Typically you would
use it something like this:

void Class::Method() {
  fprintf(stderr, "Method() in %p\n", this);
  __sanitizer_print_stack_trace();
  ...
}

But now if I set log_path, the stack traces go in the file and all the additional info
still goes to stderr. This is pretty much useless.

So now we may need to expose __sanitizer_report() as well.

May be even __sanitizer_printf, or have __sanitizer_report accept printf-style format
string (the limited format parsed by internal Printf).

I think you're over-complicating things. Your use case can be fixed by calling __sanitizer_set_report_path("stderr").
Why should we expose sanitizer logging machinery to the end-user?

>  Your use case can be fixed by calling __sanitizer_set_report_path("stderr").

In other words, you're suggesting not to use log_path. In Chrome, parsing the output
of several renderers intermixed in the same log is less than fun.

I still find it weird that you essentially use sanitizer runtime for logging. This is
not its purpose. Another way to fix your example - call "fprintf(stderr, "==%d== Method
in %p", getpid(), this)); and match pid to log produced by sanitizer.

I dunno. Sanitizers are essentially debugging tools, so why not add extra debugging
functionality.

> Another way to fix your example - call "fprintf(stderr, "==%d== Method in %p", getpid(),
this)); and match pid to log produced by sanitizer.

This doesn't help in the example above when I want to see which object the stack trace
is associated with.

Sanitizers are small special-purpose tools for detecting certain kinds of errors. Anyway,
that's just my opinion, let's hear from others. Kostya?

Can you make void __sanitizer_print_stack_trace(const char *fmt, ...)
which will both print whatever you need to print and then print stack trace?
just make sure that __sanitizer_print_stack_trace(0) works too

You don't always want to print the stack trace, sometimes you just need a debug print.
But you still want to see the debug output of the process as one stream, with all the
stack traces and without interference from other processes.

I don't *particularly* like the idea of exposing Report() either, but I don't see a
better way to solve this, and moreover I can't come up with a strong case against it.

Ping?

maybe __sanitizer_print_stack_trace(int max_frames, const char *fmt, ...) ?
With max_frames==0 this turns into Report.
We need max_frames anyway, because printing large number of frames may 
slowdown the program significantly and thus hide a time-sensitive bug. 

http://llvm.org/viewvc/llvm-project?rev=196302&view=rev added asan implementation.
we don't have msan and tsan variants yet.

Yes, an MSan implementation would be most welcome. I've had to put fake uninitialized
accesses into Chromium code one too many times...

MSan implementation was added a while ago.
http://llvm.org/viewvc/llvm-project?view=revision&revision=221469 adds TSan implementation.

Adding Project:AddressSanitizer as part of GitHub migration.