Generally, undefined behavior removes the need for systematically checking for special cases, the most common being out of bounds access.

But it can go further than that. Dereferencing a NULL pointer is undefined behavior, so if a pointer is dereferenced, it can be assumed by the compiler not to be NULL and the code can be optimized. For example:

  void foo(int *p) {
    *p++;
    if (p == NULL) {
      printf("val is NULL\n");
    } else {
      printf("val is %d\n", *p);
    }
  }

can be optimized to:

  void foo(int *p) {
    *p++;
    printf("val is %d\n", *p);
  }

Note that static analyzers will most likely issue a warning here as such a trivial case is most likely a mistake. But the check for NULL may be part of an inline function that is used in many places, and thanks to the undefined behavior, the code that handles the NULL case will only be generated when relevant. The problem, of course, is that it assumes that the programmer knows what he is doing and doesn't make mistakes.

In the case of memcpy(NULL, NULL, 0), there probably isn't much to gain making it undefined. It most likely doesn't help with the memcpy implementation (len=0 is a generally no-op), and inference based on the fact that the arguments can't be NULL is more likely to screw the programmer up than to improve performance.