Valgrind not showing error regarding memory region overlap

In the process of testing all kinds of dynamic memory-related errors using Valgrind (or to be specific, Memcheck), I came accross a situation where, I'm creating the memory overlap intentionally, but there is no error report from Valgrind/memcheck. Below are the codes used. Please share what I'm missing.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    char * pOne;
    char * pTwo;

    pOne = (char *)malloc (24);
    pTwo = pOne + 4;
    strcpy (pOne, "Sourav Ghosh");
    printf("pOne = %s\npTwo = %s\n", pOne, pTwo);
    memcpy (pTwo, pOne, 16); //Overlapping issue should be here
    printf("pOne = %s\npTwo = %s\n", pOne, pTwo);

    free (pOne);
    return 0;
}

Compilation

[sourav@titan temp]$ gcc -g srvtest.c -o memory

Sample run and output

[sourav@titan temp]$ valgrind --leak-check=full ./memory
==6982== Memcheck, a memory error detector
==6982== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al.
==6982== Using Valgrind-3.5.0 and LibVEX; rerun with -h for copyright info
==6982== Command: ./memory
==6982==
pOne = Sourav Ghosh
pTwo = av Ghosh
==6982== Conditional jump or move depends on uninitialised value(s)
==6982==    at 0x4006817: strlen (mc_replace_strmem.c:275)
==6982==    by 0xAD0C0D: vfprintf (in /lib/libc-2.5.so)
==6982==    by 0xAD6E82: printf (in /lib/libc-2.5.so)
==6982==    by 0x8048477: main (srvtest.c:15)
==6982==
pOne = SourSourSourSourSour
pTwo = SourSourSourSour
==6982==
==6982== HEAP SUMMARY:
==6982==     in use at exit: 0 bytes in 0 blocks
==6982==   total heap usage: 1 allocs, 1 frees, 24 bytes allocated
==6982==
==6982== All heap blocks were freed -- no leaks are possible
==6982==
==6982== For counts of detected and suppressed errors, rerun with: -v
==6982== Use --track-origins=yes to see where uninitialised values come from
==6982== ERROR SUMMARY: 2 errors from 1 contexts (suppressed: 12 from 8)
[sourav@titan temp]$

There is actually no information about the memory region overlap. As per the Valgrind manual, it should have showwn something like:

==27492== Source and destination overlap in memcpy(0xbffff294, 0xbffff280, 21)

What is the missing part in my case?

System information:

[sourav@titan temp]$ uname -r
2.6.18-194.el5PAE
[sourav@titan temp]$ gcc --version
gcc (GCC) 4.1.2 20080704 (Red Hat 4.1.2-48)
[sourav@titan temp]$ ldd --version
ldd (GNU libc) 2.5
[sourav@titan temp]$ valgrind --version
valgrind-3.5.0

Thanks to @Hasturkun, the issue was with the compiler inlining memcpy() with a builtin. So, valgrind was not able to hook the memcpy() and catch the error.

Modified compilation

 [sourav@titan temp]$ gcc -g -fno-builtin srvtest.c -o memory

Modified Output

[sourav@titan temp]$ valgrind --leak-check=full ./memory 
==19785== Memcheck, a memory error detector
==19785== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al.
==19785== Using Valgrind-3.5.0 and LibVEX; rerun with -h for copyright info
==19785== Command: ./memory
==19785== 
pOne = Sourav Ghosh
pTwo = av Ghosh
==19785== Source and destination overlap in memcpy(0x402602c, 0x4026028, 16)
==19785==    at 0x4007AE2: memcpy (mc_replace_strmem.c:482)
==19785==    by 0x80484B3: main (srvtest.c:14)
==19785== 
pOne = SourSourav Ghosh
pTwo = Sourav Ghosh
==19785== 
==19785== HEAP SUMMARY:
==19785==     in use at exit: 0 bytes in 0 blocks
==19785==   total heap usage: 1 allocs, 1 frees, 24 bytes allocated
==19785== 
==19785== All heap blocks were freed -- no leaks are possible
==19785== 
==19785== For counts of detected and suppressed errors, rerun with: -v
==19785== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 12 from 8)
[sourav@titan temp]$