Проблема с указателями NULL на платформе Harvard Architecture

Интересная проблема, с которой мы столкнулись на этой неделе.

Мы работаем в C на встроенной платформе Harvard Architecture, которая имеет 16-битные адреса данных и 32-разрядные коды.

Проблема возникает, когда вы работаете с указателями функций. Если у вас есть код типа

if (fp) fp();

или

if (fp != 0) fp();

все в порядке.

Однако, если у вас есть код типа

if (fp != NULL) fp();

тогда, поскольку NULL определяется как (void *) 0, компилятор (gcc в этом случае) a) не предупреждает и b) выполняет 16-битное сравнение с вашим указателем функции вместо 32-битного сравнения. До тех пор, пока ваш указатель функции не окажется на границе 64k, поэтому все нижние 16 бит равны 0.

В настоящий момент мы имеем большие фрагменты кода, которые содержат явные проверки против NULL. Большинство из них будут указателями данных, но некоторые из них будут указателями функций. Быстрый grep для != NULL или == NULL показал более 3000 результатов, для многих, чтобы пройти вручную, чтобы проверить.

Итак, теперь мы хотели бы либо

способ найти все случаи, когда сопоставляются указатели на функции (но не указатели данных) (поэтому мы можем вместо этого сравнивать их с FP_NULL, которые мы будем определять как 32-разрядные 0), или
чтобы переопределить NULL таким образом, чтобы он поступал правильно.
(Или, я полагаю, обновите наш gcc-порт, чтобы обнаружить и правильно обработайте этот случай).

Я не могу придумать какой-либо подход, который работает для 1. Единственный подход, который я могу представить для 2, - это переопределить NULL как указатель функции 0, который был бы очень расточительным для подавляющего большинства сравнений, которые противоречат данным указатели. (32-разрядное сравнение - 4 команды, 16-разрядное сравнение - 1 инструкция).

Любые мысли или предложения?

Ответ 1

Мне кажется, что самый простой способ - заменить все вхождения NULL на 0. Это работает для указателя функции (как вы говорите) и указателей объектов.

Это вариант (2) Переопределить NULL равным 0.

Но тот факт, что вы не можете сравнивать указатели на функции с NULL, является ошибкой в вашей реализации. В C99 указано, что сравнение константы нулевого указателя возможно с помощью указателей объектов и функций и что NULL должен расширяться до этой константы.

Небольшое добавление из вопроса C-FAQ 5.8:

Q: Действителен ли NULL для указателей на функции?
A: Да (но см. Вопрос 4.13)

Указатели функций смешивания с `(void *) 0`

(Ответ на комментарий R..). Я считаю, что использование указателей функций и (void *) 0 вместе хорошо определено. В моих рассуждениях я буду ссылаться на разделы проекта 1256 C99, но не буду приводить большие части, чтобы держать их читаемыми. Он также должен быть применим к C89.

6.3.2.3 (3) определяет целочисленное выражение константы 0 и такие выражения, которые отливаются от (void *) как константа нулевого указателя. И: "Если константа нулевого указателя преобразуется в тип указателя, полученный указатель, называемый нулевым указателем, гарантированно сравнивает неравные к указателю на любой объект или функцию. "
6.8.9 определяет операнды == и != для (среди прочих) операнда указателя и константы нулевого указателя. Для этого: "Если один операнд является указателем, а другой - константа нулевой указатель, константа нулевого указателя преобразуется в тип указателя. "

Заключение: в fp == (void *) 0 константа нулевого указателя преобразуется в тип fp. Этот нулевой указатель можно сравнить с fp и гарантированно будет неравным с fp, если он указывает на функцию. Назначение (=) имеет аналогичное предложение, поэтому fp = (void *) 0; также хорошо определен C.

Ответ 2

Вы можете попробовать следующее:

#ifdef NULL
  #undef NULL
#endif
#define NULL 0

Ответ 3

Способ, которым вы описываете, должен работать:

6.3.2.3/3 Целочисленное константное выражение со значением 0 или такое выражение, отлитое от типа void *, называется константой нулевого указателя. Если константа нулевого указателя преобразуется в тип указателя, результирующий указатель, называемый нулевым указателем, гарантированно сравнится неравномерно с указателем на любой объект или функцию.

Итак, либо NULL был переопределен чем-то, а не 0 или (void*)0 (или эквивалент?), или ваш компилятор является несоответствующим.

Попробуйте переопределить NULL самостоятельно (до простого 0) после того, как все #includes во всех файлах: -)

просто для ударов: попробуйте gcc -E (чтобы вывести предварительно обработанный источник) в файл проблемы и проверьте расширение NULL

Ответ 4

Вы можете попробовать взломать сегмент (на самом деле только хак), поэтому вы можете использовать быстрое сравнение 16 бит без какого-либо риска. Создавайте сегменты на каждой границе n * 0x10000 с размером 4 (или даже меньше), поэтому никогда не существует реальной функции.

Это зависит от вашего пространства памяти встроенного устройства, если это хорошее или очень плохое решение. Он может работать, если у вас 1MB нормальный Flash, который никогда не изменится. Это будет болезненно, если у вас 64MB Nand Flash.

Ответ 5

Вот несколько советов:

временно изменить NULL на (char*)0 или что-то еще, что неявно конвертируется в указатель функции. Это должно давать предупреждение о каждом сравнении с не совпадающим указателем. Затем вы можете запустить созданный вывод компилятора с помощью инструмента grep и найти типичный шаблон для указателей на функции, например (*)(.
переопределить NULL как 0 (без приведения в действие void *). Это еще одно допустимое определение для NULL и может сделать для вас правильное дело, но никаких гарантий.

Ответ 6

Отредактируйте заголовки системы реализации, чтобы заменить все записи

#define NULL ((void *)0)

#define NULL 0

Затем напишите отчет об ошибке поставщику. Вам не нужно изменять свой (совершенно правильный, хотя и уродливый) код из-за ошибки в компиляторе поставщика.