Do you have a *sane* motivating example? 
Generally, mixing fork and threads is considered harmful even w/o asan. 
We are not making things worse. 

Motivation is exactly what you say - it's generally harmful to call fork() if you have
multiple threads, especially if you rely on contents of thread-local memory (say, use
variables stored in stacks of other threads). We can potentially produce error report
in such cases.

Alexey has yesterday found a nice example of a custom condvar implementation that pings
the threads waiting on it by updating their local variables.
Someone creates two threads waiting on the same condvar and calls fork(). In the child
process the second thread disappears. Once the first thread releases the condvar, it
writes some value in the place where the second thread's stack used to be.

(In this particular case the third thread had already started and reused the stack
of the second thread, which was quite a problem)

Um-m, afair there were no writes, reads were enough to spoil things:
threads waiting on a condvar create structs on their local stacks, and ptrs
to these structs are stored in a queue associated with condvar. If a thread
disappears after a fork(), its local stack gets re-used in a child process,
and we'll read garbage while accessing condvar from a child process.

Adding Project:AddressSanitizer as part of GitHub migration.