Odd address trap и LPC23xx, А что, LPC не генерит unaligned access exeption? Опции

[VslavX]

У меня в тестовой прошивке есть такой небольшой чудный кусочек кода:

Код

{
    ungigned long *p;
    dprintf("\r\nNon aligned DWORD read.. ");
    dflush();
    p = (unsigned long*)(0x209 + LPC_ISRAM);
    dprintf("%08X", *p);
}

Назначение этого кусочка - протестировать работу соответствующего обработчика исключения. Код прекрасно отработал на S3C44BOX, S3C2410, IXP42x, SAM7xx, PXA2xx/3xx и много лет все было чудесно. И вот, "понимаете, в машине в которой мы ехали, случайно, совершенно случайно, оказался цемент" ©. Я "совершенно случайно" запустил этот код на LPC2388, и... не увидел свой любимый "ODD ADDRESS TRAP".
Смотрим документацию, "усер мануал" на LPC23xx вообще не содержит слова "unaligned". В-общем, красота - при невыравненном адресе - на LPC23xx читается/пишется переставленный мусор, и все это МОЛЧА. Такая низость в самом деле имеет место, или я чего-то недопонимаю?

[zltigo]

Имхо, это уж совсем клиническая ситуация - "невыровненный кольцевой буфер 16-битных слов" - такого я еще не встречал.

Ну маленько не так написал - буфер само-собой выровненный, а слова лежащие в нем, естественно, уже нет. Буфера обслуживают 16bit SPI, протокол старинный и тоже 16bit - пришел из 70x годов с машины которая про 8bit вобще не знала

[VslavX]

Мне правда интересно. На ARM-е можно любой невыравненный USHORT (16-битное целое) загрузить за 3 инструкции

Код

ldrb R1, [R0, #0]
ldrb R2, [R0, #1]
orr  R1, R1, R2, shl #8

Как можно грузить быстрее - ума не приложу . Если даже воспользоваться изращенным способом загрузки от NXP - то все равно нужна проверка, что 16-битное не пересекает границу 32-битного слова.
Вот я такой тестик запустил:

Код

{
    BYTE a[8];
    DWORD i;
    for(i=0; i<sizeof(a); i++) a[i] = (BYTE)(i+1);
    dprintf("\r\n%08X %08X %08X %08X",
                *((PDWORD)&a[0]),
                *((PDWORD)&a[1]),
                *((PDWORD)&a[2]),
                *((PDWORD)&a[3]));
}

Результат: 04030201 01040302 02010403 03020104
То есть, действительно имеет место циклический сдвиг - так еще (дополнительно к проверке вмещения в одно слово) и старшие биты чистить надо. Не понимаю, где тут можно выиграть

[zltigo]

Не понимаю, где тут можно выиграть

У меня память под буфера внешняя и замена одного из двух ldrb из внешней памяти банальным tst регистр,#0x3 мне и понравилась, хотя и те-же "три инструкции", как понравилось и использование (кусочек на ASM) только одного регистра вместо 2 ( у Вас даже 3x ).

[VslavX]

У меня память под буфера внешняя и замена одного из двух ldrb из внешней памяти банальным tst регистр,#0x3 мне и понравилась, хотя и те-же "три инструкции", как понравилось и использование (кусочек на ASM) только одного регистра вместо 2 ( у Вас даже 3x ).

Ну, допустим, доступ к внешней памяти медленный. Но ведь если, например, младшие два бита адреса равны 0x03, то все равно надо читать два раза из памяти - два последовательных DWORD/WORD-a. И дополнительная проверка на равенство этих битов адреса на 0x03 с последующим ветвлением/пропуском тоже нужна. Где собак зарыт?
P.S. Переписал свой тестик на использование 16-битных невыравненных слов - там еще результаты мрачней. Ну никак за одно обращение два слова (16 или 32-битных) не читается.
P.P.S. "Листинг, сестра, листинг"

[zltigo]

Ну, допустим, доступ к внешней памяти медленный. Но ведь если, например, младшие два бита адреса равны 0x03, то все равно надо читать два раза из памяти - два последовательных DWORD/WORD-a.

В этом моем случае - нет - все двухбайтовое. 0x3 я просто так использовал. Ну а в случае реального смещения на байт речь уже идет о той-же двухкратно разнице - 2 или 4 обращения.

И дополнительная проверка на равенство этих битов адреса на 0x03

Одна команда

с последующим ветвлением/пропуском тоже нужна. Где собак зарыт?

Для ARM без ветвления

P.P.S. "Листинг, сестра, листинг"

Код

tst      R0,#0x3
ldrh     R0,[R0, #+0]
lsrne    R0,R0,#+8

вместо

Код

ldrb     R1,[R0, #+0]
ldrb     R0,[R0, #+1]
orr      R0,R1,R0, lsl #+8

[GetSmart]

Код

lsrne    R0,R0,#+8

Это что за команда? IAR ругается. Может это movne ...,lsr #8 ?

[zltigo]

Это что за команда? IAR ругается. Может это movne ...,lsr #8 ?

С чего-бы это вдруг? обычный сдвиг при условии.

вот аж листинг из  сишного исходника

Код

    108          int test_b( BYTE *buff )
    109          {
    110              if( (ulong)buff & 0x3 )
   \                     test_b:
   \   00000000   030010E3           TST      R0,#0x3
   \   00000004   B000D0E1           LDRH     R0,[R0, #+0]
    111                  return( *(ushort *)buff>>8 );
   \   00000008   2004A011           LSRNE    R0,R0,#+8
    112              else
    113                  return( *(ushort *)buff );
   \   0000000C   0EF0A0E1           MOV      PC,LR           ;; return
    114          }

Другое дело, что все это бред - что-то переклинило . В моем примере это просто ldrh вне зависимости от смещения.

Код

BYTE tbuff[8] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };

int test( BYTE *buff )
{
 return( *(ushort *)buff );
}

void test_short(void)
{
 xprintf( "%04X %04X %04X %04X\r", test(tbuff), test(tbuff+2), test(tbuff+4), test(tbuff+6) );
}

 

Результат: 


0201 0403 0605 0807

Листинг суперфункции:

Код

    114          int test( BYTE *buff )
    115          {
    116              return( *(ushort *)buff );
   \                     test:
   \   00000000   B000D0E1           LDRH     R0,[R0, #+0]
   \   00000004   0EF0A0E1           MOV      PC,LR           ;; return
    117          }

[VslavX]

Код

BYTE tbuff[8] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };

int test( BYTE *buff )
{
 return( *(ushort *)buff );
}

void test_short(void)
{
 xprintf( "%04X %04X %04X %04X\r", test(tbuff), test(tbuff+2), test(tbuff+4), test(tbuff+6) );
}

 
А чего Вы хотели, если у Вас буфер выравнен (как стековая переменная) на 32-битную границу?
(сорри, пропустил, это у меня стековая, а у Вас - глобальная. Но, на 99% уверен, что буфер таки выравнен -
надо для 100% гарантии еще &tbuff[0] посмотреть бы).
Так что, это - не фокус, попробуйте написать так:

Код

BYTE tbuff[9] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };

int test( BYTE *buff )
{
 return( *(ushort *)buff );
}

void test_short(void)
{
 xprintf( "%04X %04X %04X %04X\r", test(tbuff+1), test(tbuff+3), test(tbuff+5), test(tbuff+7) );
}

 

Думаю, результат будет: 1000002 3000004 5000006 7000008
А должен бы быть: 0302 0504 0706 0908.

[zltigo]

А чего Вы хотели, если у Вас буфер выравнен (как стековая переменная) на 32-битную границу?

Писал об этом несметное число раз.

Думаю, результат будет: 1000002 3000004 5000006 7000008

Я где-то для этих условий утверждал обратное?