Всем привет!



Иногда возникает такая проблема, если А не выравнена по слову, попадает смещенная величина.
Вот пример:

В самом начале:
____word___________wordA____
| 00 00 00 00 |____| 00 00 00 00 |

Должно получиться после присваивания:
____word___________wordA____
| 00 00 00 00 |____| 02 00 00 00 |

А получается так:
____word___________wordA____
| 00 00 00 02 |____| 00 00 00 00 |

Кто как борет это?
Компилятор GCC.

Сообщение отредактировал AirDevil - Oct 19 2009, 15:06

Для какой архитектуры компилятор?
Вы что-то путаете.
Для начала вы определитесь какой на вашем таргете порядок байт (big/little)endian.
Поэкспериментируйте в отладчике. И всё встанет на свои места.
А отсутствие выравнивания внутри стандартных встроенных типов данных быть не может никогда!
Выравнивание есть всегда и оно зависит от разрядности таргета и от настроек компилятора и всяких там pragma pack для структур.

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



ARM, например. Не AVR, не x86....

Трудно не согласиться.


В принципе и делал когда глюки были. Выравнивание с помощью memcpy и всё. Я думал, что возможно еще есть пути. Оказывается, что нет и вижу что делал правильно.

С П А С И Б О ! ! !

Сообщение отредактировал AirDevil - Oct 19 2009, 19:29

В чём "говнокодность" присваивания *A = 2 при условии, что A - это указатель на u32? Автор наверняка умолчал о хитром способе вызова функции - это да. А в приведённом коде не вижу никакого криминала.

Да, это указатель на u32, но не выровненный, а находящийся, например, в каком-нибудь буфере передачи.

Для этого в IARе нужно было всего-то объявить невыравненный тип u32_unalign и вообще не напрягаться


Работает ли это в GCC ? Ессно изменив прагму.

Сообщение отредактировал GetSmart - Oct 19 2009, 21:17

Например:

Все-же атрибуты веселее прагм в большинстве случаев.

Даже не знаю, сметься, плакать, или спросить где Вы оба берете такую траву? Можно я помолчу?

От зараза, не сработала
Я обычно через структуру или union работаю (в IARе), а тут решил "сэкономить" и даже не проверил.

Звиняюсь, за спешку. Но этот вариант уже точно правильно работает и при записи и при чтении невыравненных переменных (long/short/float).

Хотя вопрос к тем, кто знает - почему "typedef u32 u32_unalign;" внутри прагмы не работает?

Сообщение отредактировал GetSmart - Oct 19 2009, 22:56

Чем дальше в лес, тем больше дров . Сколько еще "идей"? Может лучше спать, а поутру почитать, что за прагма pack и для чего она годится?

Вы удивитесь, но она не только отключает выравнивание многобайтных переменных внутри структур/юнионов, но и организует побайтный (при pack(1)) доступ ко всем полям внутри структур/юнионов. Я проверил в ИАРе - при обращении к полю l например (в описанном мной юнионе) чтение и запись происходят побайтовые. Я так думаю, что автору темы именно это и надо было.

Сообщение отредактировал GetSmart - Oct 19 2009, 23:42

Потому что
А отдельные переменные и так всегда выровнены.

Отдельные переменные не всегда выравнены. В посте у автора темы параметром передаётся ссылка на u32. Вполне "законно" можно передать туда адрес переменной u32, находящейся в структуре с невыравненными переменными. ИАР при этом выдаст варнинг, что это опасно. GCC не знаю выдаст или нет. Так вот, если бы можно было создать тип u32 с атрибутом побайтового обращения, то не пришлось бы извращаться с юнионом. Отсюда вопрос - можно ли?

Кто так поступает, тот сам себе "злобный буратино". А если уж приспичило, то передавать нужно char-овский указатель, а не long-овский и копировать побайтово. Собственно все то же самое, что делает memcpy, с которой у топикстартера все нормально работает.