Похоже, что компилятор просматривает не отдельные инструкции, а целые фрагменты текста. Об этом говорит вспыхивающие то там то тут топики, про то что изменил порядок следования операндов или ещё что-нибудь не существенное с точки зрения алгоритма, а результирующий код увеличился либо уменьшился весьма существенно. А рекомендаций по данному вопросу нет. Да и как их дашь если это зависит от компилятора и даже от его версии. Тем не менее наверняка каждый выработал для себя такие "оптимальные конструкции". Естественно, что каждый раз не будешь их проверять, но всё же. И вот у меня два вопроса.

1) Имеется переменная 32 бита (X) и 4 байта (b0-b3). Мне необходимо занести значение b0-b3 в X. На первый взгляд напрашивается две конструкции. Хотя может я и не угадал ни разу.
а)
X=b0;
X+=(uint32_t)b1<<8; // Или '|='
X+=(uint32_t)b2<<16;
X+=(uint32_t)b3<<24;
б)
X=b0;
X+=b1*0x100;
X+=b2*0x10000;
X+=b3*0x1000000;

2) Необходимо байт 0 многобитной переменной X занести в байт b.
При конструкции
b=X; // Компилятор выдаёт предупреждение, но выполняет правильно
Если использовать
b=X & 0xff; // То компилятор не ругается.

А как записать эффективней.

1)
X = b3;
X = (X<<8) | b2;
X = (X<<8) | b1;
X = (X<<8) | b0;

2)
По моему не имеет разницы - код должен быть одинаков.

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

Если переменные (b0-b3) связаны по смыслу, то ИМХО их удобнее собрать в массив , а дальше можно сделать так:

А в этом случае в результирующем коде случайно не будет сдвигов?

Просто хотелось бы получить в результате простых 4 команды mov.

Вариант с наложением массива я уже где-то спрашивал, и мне ответили, что он не коректен, так как в зависимости от реализации непонятно как компилятор хранит: младшим или старшим вперёд.

Вариант b = (uint8_t)X принимается.

1) а не проще так

#define LBYTE(w) (*((byte*)&w))
#define HBYTE(w) (*(((byte*)&w)+1))
#define L2BYTE(w) (*(((byte*)&w)+2))
#define H2BYTE(w) (*(((byte*)&w)+3))

LBYTE(X) = b0;
HBYTE(X) = b1;
L2BYTE(X) = b2;
H2BYTE(X) = b3;

&w - берем адрес переменной (адрес первого байта)
((byte*)&w) - это мы говорим что значение выражения *(&w) будет иметь тип byte
далее в зависимости от нужного байта прибавляем адрес
((byte*)&w)
(((byte*)&w)+1)
...
и далее работаем с переменной *((byte*)&w)

Не совсем понял:младшим или старшим (байтом) вперёд, в зависимости от реализации ЧЕГО? Если не сложно приведите пример, я, честно говоря, думал, что всегда первым в памяти располагается нулевой элемент массива...
Есть еще вариант, в моем примере вместо массива использовать структуру, первым в памяти будет располагаться первый член структуры (по крайней мере в ИАРЕ)...

В СИ вроде бы нигде и не определен порядок хранения байтов данных в памяти. Точно также как и данных в структуре. Гарантируется только, что будет соблюден порядок следования членов структуры, но не порядок их размещения в памяти. Тем более когда члены структуры имеют разный тип/размер. Особенно это касается невыровненных структур.

Первый вариант прекрасно компилируется в четыре mov. Второй без оптимизации может вызвать подтягивание библиотечной функции умножения. Использование "+" или " | " по моим наблюдениям на результат не влияли. 10 лет назад влияли, " | " было предпочтительней. По второму вопросу уже ответили.

А что мешает посмотреть листинг?

Пожалуйста не думайте, что я неуважаю Ваше личное время. Учитывая, что я начинающий на Си я просматриваю листинг. Правда всё время это делать не будешь. А задаю вопрос потому что ...



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



До этого не додумался. Спасибо всем ответившим.

И ещё один вопрос.
Имеется структура с битовыми полями к примеру.
__no_init struct
{
uint8_t RXOFF : 1, //Буфер переполнен, загрузка приостановлена
RMaster : 1,// Контроллер в режиме "Мастер"
RLoadActKom : 1,/ Разрешена Загрузка команд в "активную зону"
Color : 3, // цвет
} Flag;

У меня почему-то не работает такая конструкция (компилятор не ругается)
Flag.Color=7;
Flag.Color--;

Что я делаю не так.

Что значит "не работает"?
Я только что проверил, всё отлично работает.
Разве что после Color : 3 надо не запятую писать, а точку с запятой.