Interesting, but maybe I'm missing something here. If I just want automatic deallocation, why would I use bdwgc instead of using "vanilla" smart pointers from standard C++?
It significantly predates the C++11 standard.
Most of the smartpointers in the modern C++ standard weren't official until TR1 in 2003; even then, a lot of compilers took a long time to catch up. Prior to 2003, the only smartpointer in the C++ standard was std::auto_ptr, which had some really unpleasant semantics.
There were two basic choices: go with a smartpointer library like Boost or Loki, or go with the Boehm-Demers-Weiser GC. The GC route was pretty easy and minimal pain, while Boost and Loki were moving targets. A lot of places went with the more stable BDWGC instead.
In my recollection, smart pointers were a fairly common C++ idiom in the early 1990s. Ref-counted shared_ptr and scoped_ptr were even proposed in 1994 for standardization, but didn't quite make it (scoped_ptr mutated into auto_ptr). There were also cow, deep-copying, intrusive, and ref-linked smart pointers. It was easy to write your own smart pointer, while GC was something alien and magic.
But, to put my Devil's Advocate hat on a moment: the environment could be GCed and new could be overridden to return a GCed pointer, as opposed to a naked pointer. (There are lots of good GCs for C++ -- see, e.g., http://www.hboehm.info/gc/)
One of the great things about C++ is how thoroughly you can customize the system using operator overloading. One of the big drawbacks about C++ is that without knowing the precise environment in which the code is operating, you really don't know what 'new' does. Or any other operator, for that matter. :)