Относно библиотеките, там ще бера ядове, то е ясно. Cortex M3 има инструкции за делене, ама едва ли стандартно компилатора ще се сети да ги ползва. Всъщност то трябва да се пробва

Друго нещо което ме занимава сега е защо компилатора ми одравнява данните на 4 байта. Кортекса може да тегли и неподравнени....

Също така се чудя как да дефинирам bool така че да ползва възможностите на Кортекс за bit-bang.

За това не е нужно нещо специално от компилатора. IAR няма нещо специално по въпроса също. Просто си правиш сегмент в съответната област на паметта и там поместваш този тип променливи.

Не знам какви са възможностите за bit-bang, но по принцип в C bool тип няма за съжаление... ти трябва да си го дефинираш.

Относно подравняване, пакетиране и т.н. има атрибути. На всеки обект може да ги задаваш, аз не съм копал много в тая посока. Може би трябва да стане още като предифинираш типовете си.
Гледам че ти ползваш предефинирани типове така че надявам се да ти е по-лесно...
Предполагам трябва да стане с нещо от сорта #define u8 unsigned char __attribute__((...))

Всъщност не съм сигурен... по-добре прочети малко Освен атрибутите прегледай флаговете. Имаше разни за cache line size - трябва да са сетнати правилно щото като включиш оптимизациите и ще се опита да подравни и кода и данните, така че да ти пасват на кеша.

При всички случаи има пълен контрол върху тия неща, въпросът е да стане лесно, щото едва ли на всяка декларация ще ти се задава подравняване

Да така ще стане, ама само за глобалните евентуално и статичните. Стековите няма как да станат, ама айде ще го преглътнем.

Въпроса е че е меко казано досадно да обграждаш всяка bool променлива с location директиви...

За стековите няма как да стане.
Ако стека ти е в областа която може да се адресира побитово и в стека имаш голям битов масив,с малко акробатика с указател може да стане лесно. Но битов масив в стека е екзотика обикновенно.

Иначе дефиницията на bool може да става с макрос
#define BOOL_DECL(my_var) bool my_var @MY_BIT_SEGMENT

и си декларираш съвсем просто
BOOL_DECL(variable_1);
BOOL_DECL(variable_2);
BOOL_DECL(variable_arr[5]) = {0,1,0,1,0};

това е за IAR. Предполагам подобен трик може да стане и в гнуста

да така вероятно ще го бъде.

Има, в C99.

Има ама гледам че компилаторите си го имплементират като 8 битов обикновенно.

тоест все едно че си направил
typedef unsigned char bool;

някаква полезна особенност при bool има ли при C99 която да не съм видял?

Мисля че в C99 семантиката е малко повече от "typedef". Понеже лично не го ползвам не мога да коментирам.

GCC за да бълва код за битови операции трябва и някой да го напише. Не знам дали има или не (или пък планове).

Подходите са поне два - или трябва специално маркиране на битовите променливи (в стила на Keil за 8051), или линкерът трябва да има носи половината компилатор. Първият подход е около два порядъка по-лесен. Така че заровете документации (и самия GCC сорс пудрен за Cortex) и вижте има ли специфични изрази за обявяване на битови полета. Ако има ще е най-вероятно през pragma.


EDIT: Пример за C99:



Това трябва да окастри 'c' до един бит, 0 или 1. Не е просто копиране на "unsigned char". Поне така си мисля.

Не става въпрос за класически битови полета. При кортекса нещата се решени относително елегантно - част от паметта е мапната ,като всеки бит е мапнат като байт по високо в адресното пространство. Така с писане в "горния" байт директно пишеш в 1 бит от долната памет. Естествено не става на 1 клок както на "недуразуменията" като PIC, но пак е по добре от колкото класическото - рид/модифи/райт. И което е по важно - операцията е атомична, т.е. доста по безопасно е.

Та не трябва никакви особенни изяви от компилатора или линкера, просто трябва променливите да са мапнати където трябва.

c = (b = c);

не се каства правилно и в C++ обикновенно. При различни компилатори е различно. Има някаква неясното около bool типа. Затова и винаги си правя кастванията сам.

Мда... сега чета че в С99 вкарали bool, трябва да се разучи

Друг е въпросът, че за моя АРМ7 далавера няма никаква, даже ще стане по-зле като код...

Точно за такива битови операции си говорим. Употребата в края на "битови полета" по-скоро да се чете като битови променливи.
Имаше дори външни чипове за битови операции някога.



Има, но ще стане твърде офф-топик.
Набързо погледнах GCC-4.3 и не видях да има поддръжка на такива. Може би в на CodeSourcery версията може и да има нещо (ако има, там ще да е), но не разбрах набързо има ли начин за свободен даунлоад. Нещо са се комерсиализирали прекалено от последния ми досег с тях преди години.

От C++ не разбирам. Там синтаксиса си прилича но имат разлики на семантично ниво.

Ако 'b' е прост "unsigned char" правилата за промоция и орязване си важат с пълна сила.
За "_Bool" на C99 сигурно си има собствени правила за промоции, но не виждам причина да не са като на "unsigned char". По-важното е че като променлива "_Bool" приема стойност от някакъв интегрален тип трябват нелинейни операции, простото правило че всичко ненулево е ИСТИНА трябва да се докара с инструкции. Тоест близко е до "(c) ? 1 : 0".


@Цецо: Ако имаш разумни аргументи да ползваш битовата памет (след като така или иначе я има), пробвай с асемблерски макроси. Там GCC е много гъвкаво. Нещо от типа на:

Цецо... yagarto пусна нова версия и основните неща са сменени.

Гледах промените... новия релийз на компилатора има подобрения за thunb2, подобрения в оптимизациите. Линкера не гледах какво му е новото, но след като го сложих вече мога да дебъгвам асемблерските си файлове в оригнал... Така и не разбрах преди какъв му беше проблема че някои сорсове не ги показваше, не че беше голяма грижа щото то асемблер и дизасемблер е едно...

А и най-важното вкарал е и последната версия на newliba... та ако имаш късмет може да тръгне вече и с твоя кУртекс