Передача аргумента в прерывание (язык C), Кто что использует? Опции

[Nikitoc]

Всем доброго времени суток. Я тут недавно столкнулся с проблемой глобальных переменных, а точнее с тем, что о них всегда нужно помнить (где они инициализируются, где изменяются и т.д.) со всеми вытекающими трудновылавливаемыми глюками. Альтернатива глобальным переменным - передача указателя в функцию. Но вот как передать указатель в подпрограмму обработки прерывания (имеется в виду программа для какого-нибудь микроконтроллера)? Или еще так можно спросить: кто как избавляется от глобальных переменных? Какие есть способы минимизировать их использование? Интересно послушать мнения форумчан.

[sigmaN]

Насчет volatile все очень просто. Это запрет компилятору оптимизировать операции с переменными этого типа, потому как если внутри некоторой функции выполняются какие либо операции с глобальной переменной, декларированной в другой единице компиляции, оптимизатор, скорее всего, такую операцию просто выкинет, посчитав ее ненужной в рамках данной функции.

Не совсем так. Нужно более тонко понимать как мыслит оптимизатор и что на самом деле делает volatile. А ещё это Ваше

оптимизатор, скорее всего, такую операцию просто выкинет

что именно вы имеете ввиду употребляя слово "выкинет"?
Постараюсь внести ясность.
Компилятор при оптимизации практически всегда "кэширует" переменные в регистры, дабы сократить кол-во обращений к памяти. Тем не менее, компилятор лично следит, чтобы те участки кода, которые требуют значения этой переменной - получали его вовремя... Всё это возможно благодаря тому, что компилятор чётко понимает ход выполнения программы.
Но что, если адрес в памяти, по которому лежит переменная, меняется и компилятор не может это проследить? А тут, к примеру, цикл wile( flag ) ; Компилятор может в самом начале функции запихать переменную в регистр и больше не обращаться к памяти. А скорее всего и вовсе этот цикл уберет, т.к. посчитает, что он никогда не исполнится. Или же воспримет цикл как бесконечный и уберет всё, что дальше...зависит от кода.
К чему я клоню.. а к тому, что для компилятора обработчик прерывания - это функция, которая не вызывается никогда. Компилятор просто не может предугадать, когда именно сработает обработчик и изменит flag. И пусть даже он сработает и изменит flag прямо в памяти - ожидающий цикл не будет перечитывать flag из памяти при каждой итерации.
Вот весь механизм и суть тут именно в том, что компилятор не в состоянии отследить изменение переменной. Она меняется за пределами Си кода либо компилятор не в состоянии проследить вызов. То-же самое справедливо и для функций. Компилятор удаляет функции, так или иначе не вызываемые из main(за исключением обработчиков прерываний, они - особый случай).
И если для переменных есть volatile, то для функций как правило предоставляется какая-нибудь #pragma или аттрибут. Суть состоит в том, чтобы показать компилятору, что эта функция вызывается не из Си кода(к примеру из asm модуля) и функцию удалять не следует.

Далее, что касается volatile: такие переменные при каждом обращении считываются из памяти и не кэшируются в регистрах.
Вот так, надеюсь, будет понятно уже)

Исходя из этого, вообще лучше все глобальные переменные объявлять как volatile, чтобы не нарваться на трудноуловимые ошибки, связанные в работой оптимизатора.

Не согласен с Вами. Это излишества, к тому-же бьющие оптимизатору ниже пояса, снижая эффективность генерируемого кода.
И дело всё в том, что если работа с переменной ведётся только из Си кода - то без всяких volatile будет всё прекрасно и без глюков работать.