How does D distnguish managed pointers from raw pointers?

[IGotD-]

According to the GC documentation this code snippet

char* p = new char[10];
char* q = p + 6; // ok
q = p + 11;      // error: undefined behavior
q = p - 1;       // error: undefined behavior

suggests that char *p is really a "fat pointer" with size 
information.

However, if get some memory allocated by some C library that is 
allocated with malloc we have no size information. We would get a 
char * without any size information and according to the 
documentation we can do anything including access out of bounds.

How does D internally know that a pointer was previously 
allocated by the GC or malloc?

If we would replace the GC with reference counting. How would D 
be able to distinguish a reference counted pointer from a raw 
pointer at compile time in order to insert the code associated 
with the reference counting?

This brings me back to MS managed C++ where they actually had two 
types of "pointers" a managed pointer and the normal C++ 
pointers. Like this:

MyType^ instance = gcnew MyType();

In this case it was obvious what is done with GC and what wasn't 
(past tense since managed C++ is deprecated). In this case it 
would be trivial to replace the GC algorithm with whatever you 
want since the compiler know the type at compile time.