Неверный результат с математической функцией log10 в armv6 на малине Pi

Ответ 1

Поддержка плавающей точки в дистрибутивах ARM Linux не является тривиальной. Из-за этого вы должны использовать инструментальную цепочку, соответствующую вашей системе, которая является операционной системой и оборудованием, и использовать правильные компиляционные ключи.

Прежде всего вам нужно понять соглашение о вызове ARM, которое составляет около , как аргументы передаются при вызове функции?. ARM, являющаяся архитектурой RISC, может работать только с регистрами. Нет никаких инструкций, непосредственно манипулирующих памятью. Если вам нужно изменить значение в памяти, вам сначала нужно загрузить его в регистр, изменить его, затем вам нужно сохранить его обратно в память.

Когда вы вызываете функцию, вам может потребоваться передать ему аргументы, вы можете поместить аргументы в стек (память), но поскольку ARM может работать только с регистрами, первое, что, вероятно, сделает ваша функция, будет загружать их обратно в регистры. Чтобы избежать этого, конвенция о вызове ARM использует регистры для передачи аргументов. Однако, поскольку ARM имеет ограниченное количество регистров, соглашение о вызове также диктует вам использовать только первые четыре (r0-r3) регистра для первых четырех аргументов, остальные должны по-прежнему использовать стек, который должен быть передан.

Во-вторых, ранние ядра ARM не имеют поддержки с плавающей запятой, операции, реализованные в программном обеспечении. (Это то, что по-прежнему поддерживается через gcc -mfloat-abi=soft.)

Мы можем легко продемонстрировать, что это означает с помощью следующего фрагмента.

float pi2(float a) {
    return a * 3.14f;
}

Компиляция с помощью -c -O3 -mfloat-abi=soft и obdump ing дает нам

00000000 <pi2>:
   0:   f24f 51c3   movw    r1, #62915  ; 0xf5c3
   4:   b508        push    {r3, lr}
   6:   f2c4 0148   movt    r1, #16456  ; 0x4048
   a:   f7ff fffe   bl  0 <__aeabi_fmul>
   e:   bd08        pop {r3, pc}

Как вы можете видеть (на самом деле это не видно:)) pi2 получает свой параметр в r0, заполняет pi constant на r1 и использует __aeabi_fmul для их умножения и возврата результата в r0, Поскольку __aeabi_fmul также использует одно и то же соглашение о вызовах, информация о r0 не отображается. Вся наша функция позволяет заполнить r1 и передать ее на __aeabi_fmul.

Когда плавающая поддержка аппаратного обеспечения добавлена ​​в ARM (опять же из-за стиля архитектуры), у нее появился собственный набор регистров (s0, s1,...).

Если мы скомпилируем тот же фрагмент с -c -O3 -mfloat-abi=softfp и дамп, мы получим

00000000 <pi2>:
   0:   eddf 7a04   vldr    s15, [pc, #16]  ; 14 <pi2+0x14>
   4:   ee07 0a10   vmov    s14, r0
   8:   ee27 7a27   vmul.f32    s14, s14, s15
   c:   ee17 0a10   vmov    r0, s14
  10:   4770        bx  lr
  12:   bf00        nop
  14:   4048f5c3    .word   0x4048f5c3

Как вы теперь видите, компилятор не создает вызов __aeabi_fmul, но вместо этого создает инструкцию vmul.f32 после перемещения аргумента, расположенного в r0, на s14 и заполняет 3.14 на s15, После команды умножения он возвращает результат, доступный в s14, назад к r0 , поскольку любой вызывающий объект этой функции ожидает его из-за соглашения о вызовах.

Теперь, если вы думаете, что pi2 как библиотека, предоставленная вам какой-либо третьей стороной, вы можете понять, что и реализация soft и softfp делает то же самое для вас, и вы можете использовать их взаимозаменяемо. Если система предоставляет их вам, вам все равно, будет ли ваше приложение работать в системе с поддержкой аппаратных средств с плавающей запятой или нет. Это было неплохо, когда старое программное обеспечение работало на новом оборудовании.

Однако, сохраняя совместимость, этот подход вводит накладные расходы движущихся значений между регистрами ARM и регистрами FP. Это, очевидно, влияет на производительность и обращается с помощью нового соглашения о вызовах, называемого hard на gcc. Это новое соглашение гласит, что если у вас есть аргументы с плавающей запятой в вашей функции, вы можете использовать регистры с плавающей запятой, чередующиеся с нормальными, а также вы можете возвращать значения с плавающей запятой в регистр с плавающей запятой s0.

Снова, если мы скомпилируем наш фрагмент с -c -O3 -mfloat-abi=hard и дамп, мы получим

00000000 <pi2>:
   0:   eddf 7a02   vldr    s15, [pc, #8]   ; c <pi2+0xc>
   4:   ee20 0a27   vmul.f32    s0, s0, s15
   8:   4770        bx  lr
   a:   bf00        nop
   c:   4048f5c3    .word   0x4048f5c3

Вы можете видеть, что регистров нет. Аргумент pi2 передается в s0, компилятор создал код для заполнения 3.14 в s15 и использует vmul.f32 s0, s0, s15 для получения результата, который мы хотим в s0.

Большая проблема с этим новым соглашением заключается в том, что вы улучшаете код, созданный компилятором, вы полностью убиваете совместимость. Вы не можете ожидать, что приложение, построенное с помощью соглашения hard, будет работать с библиотеками, созданными для soft/softfp, и приложение, созданное для softfp, не будет работать с библиотеками, созданными для жестких задач.

Для получения дополнительной информации о вызовах вы должны проверить сайт ARM.