Здравствуйте! Моя программа состоит из нескольких модулей. Есть главный модуль main.c, в нем для инициализации различных частей программы вызываются функции из других модулей. Причем эти функции используются однократно, при запуске программы. Уровень оптимизации стоит максимальный и по размеру кода. Просмотрев дизассемблированный текст, я увидел, что эти функции вызываются с помощью rcall. Нельзя ли что-нибудь настроить, чтоб тело этих функции помещалось на место команды rcall, т.е. чтобы они не вызывались (ведь больше они не где не используются), таким образом экономим память (оптимизация то по размеру).

В общем мой вопрос так звучит: как сделать, чтоб однократно используемые функции не вызывались, а их тело помещалось вместо вызова подпрограммы.

Вообще для этого в IAR (не знаю как в других средах) есть директива #pragma inline=forced.
Но язаметил такую особенность - если функция , например void if(), объявленная как inline, и функция которая вызывает void if(), находятся в одном модуле, то void if(), компилируется как inline без call и ret. Если же функции в разных модулях, то функция void if(), вызывается через call.

А нельзя ли это автоматизировать, что сам компилятор это выполнял. А то трудно уследить какие функции будут использоваться однократно.

Я использую директиву #pragma inline=forced в основном в прерываниях, для разделения задачи на более мелкие подзадачи - так удобнее потом в этом разбираться и мне, и тем, для кого я пишу. Да и при написания процедуры обработки прерывания, если внутри процедуры нет вызовов call, код компилируется меньше за счет сокращения числа сохраненных РОН. А вообще наверное есть смысл подставлять данную директиву везде, если есть вероятность вызова функции всего один раз. На счет автоматизации этого процесса ничего сказать не могу.

2prottoss: спасибо! Я поставля эти директивы в обработчиках прерываний, где функции точно вызываются единожды.

1) Нужно чтобы вызываемые ф-ии были в одном модуле с вызывающей ф-ей.
2) Нужно написать модификатор static перед вызываемой ф-ей.
3) К этим пунктами иногда тербуется включить оптимизацию по скорости (проверь экспериментально). Тогда компилятор сам достаточно умно решает инлайнить ф-ю или нет.

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

Можешь модуль разбить на несколько с помощью #include
Вообще это свойство компилятора. Ф-ии для работающие вместе должны объединяться в модулях. Если есть ф-я, которую нужно инлайнить в нескольких модулях , то объяви её static и запихни в подключенный в эти моули .h файл.
Т.о. модули компилируются отдельно, при этом компилятор ничего не знает о ф-ях в других модулях, кроме прототипов. И только потом линкером сгенерированный из модулей код объединяется.

Компилятор то знает все обо всех функциях, на то он и компилятор. Другое дело, что он не подставляет тело функции из одного модуля, в тело функции из другого. Но если написать тело в .h файл, возможно это и прокатит.
Но тут такая белиберда получится, что ой-ой.

Допустим в модуле объявлена глобальная переменная, а нужная нам инлайн-функция должна работать с этой пременной. Как этой функции, которая описанна в хедере, рассказать что в одноименном модуле для него приготовленна переменная. Писать еще одну функцию в модуле, которая будет возвращать значение переменной инлайн-функции?

Нет, компилятор знает только прототип ф-ии из .h для внешнего модуля, но не тело ф-ии. Исходя из прототипа производится проверка числа и типов аргументов, а в объектный файл ставится rcall без адреса. Реальный адрес проставляется линкером на этапе линковки.



Нужно объявить переменную как extern в .h файле с функцией.
Т.е. в основном модуле пишем:

а в submodule.h пишем:

Тогда объясните зачем вообще нужны отдельные модули, раз уж на то пошло.
Давайте будем писать все в одном модуле, чтоб все все знали обо всех :-)

1) Проще разбираться в исходниках, когда программа разбита на идеологически законченные блоки.
2) К программе можно прилинковать модуль написанный на другом языке.
3) Каждый модуль можно скомпилировать со своими настройками компилятора.
4) Программа быстрее перекомпилируется, т.к. компилятор компилирует только изменившиеся модули.

Да, если проект не очень большой, то так обычно и делается.

К этому Вы забыли еще добавить
5) разграничение пространства имен.

Да, причём, это можно поставить на первое место.
Зачем спрашивал, если сам всё знаешь?

Где ж тут разграничение пространства имен? Если глобальные переменные одного модуля известны всем модулям?