Czy wykonywanie memcpy (0,0,0) jest bezpieczne?

Nie jestem dobrze zorientowany w standardzie C, więc proszę o wyrozumiałość.

Chciałbym wiedzieć, czy standard gwarantuje, że memcpy(0,0,0)jest to bezpieczne.

Jedynym ograniczeniem, jakie mogłem znaleźć, jest to, że jeśli regiony pamięci nakładają się, to zachowanie jest niezdefiniowane ...

Ale czy możemy wziąć pod uwagę, że obszary pamięci nakładają się tutaj?

Mam roboczą wersję standardu C (ISO / IEC 9899: 1999) i mam kilka fajnych rzeczy do powiedzenia na temat tego połączenia. Na początek, to wspomina (§7.21.1 / 2) w odniesieniu do memcpy, że

Gdzie argument zadeklarowany jako size_tn określa długość tablicy dla funkcji, n może mieć wartość zero w wywołaniu tej funkcji. O ile wyraźnie nie określono inaczej w opisie konkretnej funkcji w tym podrozdziale, argumenty wskaźników w takim wywołaniu nadal będą miały prawidłowe wartości, jak opisano w 7.1.4 . W takim wywołaniu funkcja, która lokalizuje znak, nie znajduje żadnego wystąpienia, funkcja porównująca dwie sekwencje znaków zwraca zero, a funkcja kopiująca znaki kopiuje zero znaków.

Wskazane tutaj odniesienie wskazuje na to:

Jeśli argument funkcji ma nieprawidłową wartość (na przykład wartość spoza domeny funkcji lub wskaźnik poza przestrzenią adresową programu, wskaźnik zerowy lub wskaźnik do niemodyfikowalnej pamięci, gdy odpowiedni parametr nie jest kwalifikowana jako stała) lub typ (po promocji), którego nie oczekuje funkcja ze zmienną liczbą argumentów, zachowanie jest niezdefiniowane .

Więc wygląda na to, że zgodnie ze specyfikacją C, dzwonienie

memcpy(0, 0, 0)

powoduje niezdefiniowane zachowanie, ponieważ puste wskaźniki są traktowane jako „nieprawidłowe wartości”.

To powiedziawszy, byłbym całkowicie zdziwiony, gdyby jakakolwiek rzeczywista implementacja memcpyzłamała się, gdybyś to zrobił, ponieważ większość intuicyjnych implementacji, o których przychodzi mi do głowy, nie zrobiłaby nic, gdybyś powiedział, że kopiujesz zero bajtów.

Dla zabawy, uwagi do wydania dla gcc-4.9 wskazują, że jego optymalizator korzysta z tych reguł i na przykład może usunąć warunek w

int copy (int* dest, int* src, size_t nbytes) {
    memmove (dest, src, nbytes);
    if (src != NULL)
        return *src;
    return 0;
}

który następnie daje nieoczekiwane wyniki, gdy copy(0,0,0)zostanie wywołany (patrz https://gcc.gnu.org/gcc-4.9/porting_to.html ).

Jestem nieco ambiwalentny co do zachowania gcc-4.9; zachowanie może być zgodne ze standardami, ale możliwość wywołania memmove (0,0,0) jest czasami przydatnym rozszerzeniem tych standardów.

Możesz również rozważyć to użycie memmovewidoczne w Git 2.14.x (Q3 2017)

Zobacz zatwierdzenie 168e635 (16 lipca 2017) i zatwierdzenie 1773664 , zatwierdzenie f331ab9 , zatwierdzenie 5783980 (15 lipca 2017) autorstwa René Scharfe ( rscharfe) .
^{(Scalone przez Junio ​​C Hamano - gitster- w zatwierdzeniu 32f9025 , 11 sierpnia 2017)}

Używa makra pomocniczego,MOVE_ARRAY które oblicza rozmiar na podstawie określonej dla nas liczby elementów i obsługuje NULL wskaźniki, gdy ta liczba wynosi zero. Wywołania
surowe memmove(3)with NULLmogą spowodować, że kompilator (zbyt chętnie) zoptymalizuje późniejsze NULLsprawdzenia.

MOVE_ARRAYdodaje bezpiecznego i wygodnego pomocnika do przenoszenia potencjalnie nakładających się zakresów wpisów tablicy.
Wychodzi z rozmiaru elementu, mnoży się automatycznie i bezpiecznie, aby uzyskać rozmiar w bajtach, przeprowadza podstawowe sprawdzenie bezpieczeństwa typu, porównując rozmiary elementów iw przeciwieństwie do memmove(3)obsługuje NULLwskaźniki, jeśli 0 elementów ma zostać przesuniętych.

#define MOVE_ARRAY(dst, src, n) move_array((dst), (src), (n), sizeof(*(dst)) + \
    BUILD_ASSERT_OR_ZERO(sizeof(*(dst)) == sizeof(*(src))))
static inline void move_array(void *dst, const void *src, size_t n, size_t size)
{
    if (n)
        memmove(dst, src, st_mult(size, n));
}

Przykłady :

- memmove(dst, src, (n) * sizeof(*dst));
+ MOVE_ARRAY(dst, src, n);

Używa makra,BUILD_ASSERT_OR_ZERO które zapewnia zależność od czasu kompilacji, jako wyrażenie (przy @condczym warunek czasu kompilacji musi być prawdziwy).
Kompilacja zakończy się niepowodzeniem, jeśli warunek nie jest prawdziwy lub nie może zostać oceniony przez kompilator.

#define BUILD_ASSERT_OR_ZERO(cond) \
(sizeof(char [1 - 2*!(cond)]) - 1)

Przykład:

#define foo_to_char(foo)                \
     ((char *)(foo)                     \
      + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))

Nie, memcpy(0,0,0)nie jest bezpieczne. Biblioteka standardowa prawdopodobnie nie zawiedzie podczas tego wywołania. Jednak w środowisku testowym memcpy () może zawierać dodatkowy kod w celu wykrycia przepełnienia bufora i innych problemów. A jak ta specjalna wersja memcpy () reaguje na wskaźniki NULL jest… no cóż, nieokreślone.