Отличие BSD memcmp(3) между руководством и реализацией

Это ошибка компилятора. Компилятор неправильно оценивает вызовы memcmp, когда оба аргумента являются литералами. Когда memcmp действительно вызывается, он возвращает ожидаемый результат.

Следующее было протестировано с Apple LLVM версии 9.1.0 (clang-902.0.39.1) в macOS 10.13.4 (17E199). Я скомпилировал с помощью «clang -std=c11», либо с «-O0», либо с «-O3» для выбора уровня оптимизации и с «-S» для создания сборки.

Рассмотрим четыре альтернативных вызова memcmp:

    printf("%i\n", memcmp("\200", "\0", 1));

    printf("%i\n", memcmp((char[] ) { '\200' }, "\0", 1));

    printf("%i\n", memcmp((unsigned char[] ) { '\200' }, "\0", 1));

    char a[1] = { 128 };
    char b[1] = { 0 };
    printf("%i\n", memcmp(a, b, 1));

Для первых двух вызовов компилятор генерирует неправильную сборку, которая передает жестко заданное значение от -1 до printf. Нет вызова memcmp; он был оптимизирован, даже в версии «-O0». (В версиях «-O0» -1 кодируется как 4294967295, что эквивалентно в его контексте.) Когда memcmp вызывается со строковыми литералами или составными литералами, его возвращаемое значение известно во время компиляции, поэтому компилятор оценил Это. Однако сделал это неправильно.

Для третьего вызова компилятор генерирует неправильную сборку, которая передает жестко закодированное значение 1. Это говорит о том, что компилятор (неправильно) использует тип литерала в своей оценке.

Для четвертого вызова, в котором мы используем определенные объекты, не являющиеся литералами, версия «-O0» вызывает memcmp. При запуске программа выводит правильный результат, 128. Для версии «-O3» компилятор генерирует правильный ассемблер с жестко заданным значением 128. Таким образом, компилятор < strong>имеет алгоритм, который правильно оценивает memcmp во время компиляции, но он использовал другой ошибочный алгоритм для случаев с литералами.

Когда используется один литерал и один нелитерал, компилятор генерирует правильный код. Это объясняет, почему эта ошибка не была обнаружена и исправлена ​​ранее: вызовы memcmp с двумя литералами редки, а код, который делает то же самое и зависит от величины результата или использует символы с установленными старшими битами, встречается реже.

(Я сообщил об ошибке в Apple.)

Похоже, в вашей конкретной реализации memcmp есть ошибка.

Я попробовал вашу программу на своей системе OSX/Darwin и получил положительное число. Так что в моей системе нет ошибки.

Как ни странно, поведение в моей системе различается в зависимости от того, использую ли я clang или gcc. Я думал, что они используют одни и те же библиотеки, но clang дает 128, а gcc дает 1. (Возможно, memcmp реализован как компилятор, встроенный в один или другой.)

Кроме того, кстати, man memcmp в моей системе не имеет предложения «Это поведение не требуется для C».

Это ошибка в мануале. Он описывает strcmp(), который прекращает сравнение, когда достигает нулевого байта в одной из строк, поскольку это признак конца строки; более длинная строка будет считаться большей ("foobar" больше, чем "foo"). Но memcmp() предназначен для сравнения произвольных областей памяти, а не строк, поэтому нулевые байты специально не обрабатываются.

Однако это не объясняет, почему memcmp() возвращает -1. Он должен сравнивать '\200' и '\0' и возвращать положительное значение. Кажется, что Дарвин memcmp() сравнивает их как signed char, а не как unsigned char, поэтому '\200' это -128, а не 128. Если первая строка имеет значение от "\200" до "\377", она возвращает этот неверный результат.

Когда я пробую ваш код в Linux, я получаю 1, а не -1. Так что это похоже на ошибку в библиотеке Дарвина. А также ошибка на странице руководства, так как там написано, что они сравниваются как unsigned char.

Я пробовал эту программу:

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

int main()
{
    printf("memcmp: %i\n", memcmp("\200", "\0", 1));
    printf("bcmp: %i\n", bcmp("\200", "\0", 1));
    printf("strcmp: %i\n", strcmp("\200", "\0"));
    return (0);
}

В Mac OS High Sierra он печатает:

memcmp: -1
bcmp: 128
strcmp: 128

в Debian Linux я получаю:

memcmp: 1
bcmp: 1
strcmp: 1

Упоминание строк нулевой длины на странице руководства также неверно. "\0abc" и "\0def" являются строками нулевой длины, поскольку строки логически заканчиваются нулевым байтом. Но они сравнивают разные с memcmp()

printf("memcmp: %i\n", memcmp("\0abc", "\0def", 4));
printf("bcmp: %i\n", bcmp("\0abc", "\0def", 4));
printf("strcmp: %i\n", strcmp("\0abc", "\0def"));

печатает:

memcmp: -1
bcmp: -3
strcmp: 0