Why does strlen(NULL) cause a compile-time warning, while my custom ft_strlen(NULL) only crashes at runtime?

Why does strlen(NULL) cause a compile-time error, while my custom ft_strlen(NULL) only crashes at runtime?

Because your C implementation provides features beyond those contemplated by the C language specification, and uses them to detect this issue. The spec itself does not require compile-time null checks under any circumstances, but it does allow implementations to emit whatever diagnostics they like (in addition to required diagnostics for a variety of specific issues), and to reject sources more or less arbitrarily.

In your particular case, some of the possibilities include

• the compiler has special knowledge of some functions from the standard library, including strlen(), which it uses to diagnose the issue
• the system provides some way to mark arbitrary pointer-type function parameters as requiring non-null arguments, and uses it on strlen(). This would mean that the system's declaration for strlen() is not actually the same as that of your ft_strlen(). In Glibc, for example, there is a __nonnull__ attribute (a Glibc / GCC extension) indicating that the argument should not be null

The way to use standard C to express that the argument must not be null involves expressing the parameter's type as an array with static length:

size_t ft_strlen(const char s[static 1]);

That still declares the parameter as a pointer to const char, but the [static 1] expresses that the function relies on the caller to provide an argument that points to at least one element (which a null pointer definitely does not do). Whether your compiler will actually emit a diagnostic about null arguments in calls to such a function is a different question, but there's a decent chance of it.

I'm trying to understand the compiler-level behavior and how standard library functions differ from user-defined ones,…

Knowledge about strlen is built into the compiler. This is possible because the specification of strlen is written in the C standard and the standard reserves the name strlen (and others in the standard C library) for this purpose. C 2024 7.1.3 says “… All identifiers with external linkage in any of the following subclauses … are always reserved for use as identifiers with external linkage…”

In contrast, the compiler knows nothing about your function other than what you tell it.

… and how can I potentially replicate strlen() myself.

In this case, you can get the same behavior using the static keyword to tell the compiler the function expects a pointer to at least one element:

size_t ft_strlen(const char s[static 1]);

In general, replicating the compiler behavior for standard library functions may not be possible using only features in the C standard. It may be necessary to use compiler extensions and, even then, may not be possible for certain behaviors.

I understand your question is multi-layered, and the run-time crashing of your custom strlen() is nearly a side note, but I thought I'd address just this one aspect nonetheless. Does your code care for the possibility of a NULL parameter as does the following custom strlen()?

Runnable code here: https://godbolt.org/z/5fGTrjaKE

#include <stdio.h>   /* printf()  */

size_t mstrlen( const char *str )
{
    size_t len = 0;

    if( str )  /* Prevent run-time crash on NULL pointer. */
    {
        for(; str[len]; len++);
    }
    return len;
}


int main()
{

    char s[] = "stars";

    printf("mstrlen(%s) = %zu\n", s, mstrlen(s));
    printf("mstrlen(NULL) = %zu\n",  mstrlen(NULL));

    return 0;
}

Look at the prototype of strlen() in <string.h> and you will probably see the reason:

• on my system it is declared as __pure, which probably means it is an intrinsic function of the compiler with different checking in the compiler than is done for normal user functions.

• Of course, you can check in the function for a NULL value passed as argument. Did you do that? probably not.