Ist es garantiert sicher, memcpy(0,0,0) auszuführen?

Question 1

Ich kenne mich mit dem C-Standard nicht so gut aus, also bitte haben Sie Geduld mit mir.

Ich würde gerne wissen, ob dies durch den Standard garantiert ist memcpy(0,0,0) ist sicher.

Die einzige Einschränkung, die ich finden konnte, ist, dass das Verhalten undefiniert ist, wenn sich die Speicherbereiche überlappen …

Aber können wir davon ausgehen, dass sich die Speicherregionen hier überschneiden?

Question 2

Ich habe eine Entwurfsversion des C-Standards (ISO/IEC 9899:1999), und es gibt einige lustige Dinge über diesen Aufruf zu sagen. Für den Anfang erwähnt es (§7.21.1/2) in Bezug auf memcpy das

Wo ein Argument als deklariert wird size_t n gibt die Länge des Arrays für eine Funktion an, n kann bei einem Aufruf dieser Funktion den Wert Null annehmen. Sofern in der Beschreibung einer bestimmten Funktion in diesem Unterabschnitt nicht ausdrücklich anders angegeben, Zeigerargumente bei einem solchen Aufruf müssen weiterhin gültige Werte haben, wie in 7.1.4 beschrieben. Bei einem solchen Aufruf findet eine Funktion, die ein Zeichen findet, kein Vorkommen, eine Funktion, die zwei Zeichenfolgen vergleicht, gibt Null zurück, und eine Funktion, die Zeichen kopiert, kopiert null Zeichen.

Darauf weist die hier angegebene Referenz hin:

Wenn ein Argument für eine Funktion einen ungültigen Wert hat (z. B. einen Wert außerhalb der Domäne der Funktion oder einen Zeiger außerhalb des Adressraums des Programms,
oder ein Nullzeigeroder ein Zeiger auf nicht modifizierbaren Speicher, wenn der entsprechende Parameter nicht konstant qualifiziert ist) oder ein Typ (nach der Heraufstufung), der von einer Funktion mit variabler Anzahl von Argumenten nicht erwartet wird, Das Verhalten ist undefiniert.

So sieht es laut C-Spec aus, Calling

memcpy(0, 0, 0)

führt zu undefiniertem Verhalten, da Nullzeiger als “ungültige Werte” betrachtet werden.

Das heißt, ich wäre absolut erstaunt, wenn eine tatsächliche Umsetzung von memcpy brach, wenn Sie dies taten, da die meisten intuitiven Implementierungen, die mir einfallen, überhaupt nichts bewirken würden, wenn Sie sagten, null Bytes zu kopieren.

Question 3

Nur zum Spaß weisen die Versionshinweise für gcc-4.9 darauf hin, dass sein Optimierer diese Regeln verwendet und zum Beispiel die Bedingung in entfernen kann

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

was dann zu unerwarteten Ergebnissen führt, wenn copy(0,0,0) heißt (vgl https://gcc.gnu.org/gcc-4.9/porting_to.html).

Ich bin etwas ambivalent bezüglich des Verhaltens von gcc-4.9; Das Verhalten ist möglicherweise standardkonform, aber die Möglichkeit, memmove(0,0,0) aufzurufen, ist manchmal eine nützliche Erweiterung dieser Standards.

Question 4

Sie können auch diese Verwendung von in Betracht ziehen memmove gesehen in Git 2.14.x (Q3 2017)

Sehen Commit 168e635 (16. Juli 2017) und 1773664 festschreiben, f331ab9 übergeben, Festschreiben 5783980 (15. Juli 2017) von René Scharfe (rscharfe).
^{(Zusammengeführt von Junio C. Hamano — gitster — in Commit 32f902511.08.2017)}

Es verwendet ein Hilfsmakro MOVE_ARRAY die die Größe anhand der angegebenen Anzahl von Elementen für uns berechnet und stützt NULL
Zeiger, wenn diese Zahl Null ist.
Roh memmove(3) telefoniert mit NULL kann dazu führen, dass der Compiler später (übereifrig) optimiert NULL Schecks.

MOVE_ARRAY fügt einen sicheren und bequemen Helfer zum Verschieben potenziell überlappender Bereiche von Array-Einträgen hinzu.
Es leitet die Elementgröße ab, multipliziert automatisch und sicher, um die Größe in Bytes zu erhalten, führt eine grundlegende Typsicherheitsprüfung durch, indem es Elementgrößen vergleicht und unterscheidet memmove(3) es unterstützt NULL Zeiger wenn 0 Elemente verschoben werden sollen.

#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));
}

Beispiele:

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

Es verwendet die Makro BUILD_ASSERT_OR_ZERO die eine Build-Time-Abhängigkeit geltend macht, als Ausdruck (with @cond die Bedingung zur Kompilierzeit ist, die wahr sein muss).
Die Kompilierung schlägt fehl, wenn die Bedingung nicht wahr ist oder vom Compiler nicht ausgewertet werden kann.

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

Beispiel:

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

Question 5

Nein, memcpy(0,0,0) ist nicht sicher. Die Standardbibliothek wird bei diesem Aufruf wahrscheinlich nicht fehlschlagen. In einer Testumgebung kann jedoch zusätzlicher Code in memcpy() vorhanden sein, um Pufferüberläufe und andere Probleme zu erkennen. Und wie diese spezielle Version von memcpy() auf NULL-Zeiger reagiert, ist, nun ja, undefiniert.