Soft Float on x86_64

Question

Lavoro su software per un sistema embedded che non ha FPU. Mi piacerebbe essere in grado di costruire questo software con una libreria software in virgola mobile sul mio desktop per ottenere una visione più realistica delle prestazioni. Qualcuno ha qualche idea su come ottenere questo?

Finora non ho fatto molti progressi con l'utilizzo di -msoft-float con gcc. Attualmente sto cercando di usare clang. Usando i flag -Xclang -msoft-float -Xclang -no-implicit-float e specificando una libreria che ha implementazioni di routine soft-float, sono in grado di compilare la mia applicazione. Quando provo a eseguirlo, sempre segfaults. Come meglio posso dire, questo è dovuto al fatto che le librerie da cui dipende questo programma non sono state compilate con soft-float. L'app dipende da gtk, sqlite, expat, gcrypt, un certo numero di librerie interne e libc.

Vorrei provare a capire come creare un ambiente di compilazione completo con supporto flottante. Ho provato il buildroot di uclibc e l'impostazione di CC e CXX in file binari di clang, ma questo non ha funzionato a causa dei requisiti per la compilazione della toolchain gcc (cose come gli autotools che lamentavano l'errata versione del compilatore). Dato che mi piacerebbe usare clang come compilatore nel nuovo buildroot (per avere supporto per il soft float), non vedo la necessità di costruire gcc. È possibile farlo senza gcc?

Answer 1

GCC non può essere eseguito senza alcune librerie aggiuntive. Fondamentalmente, -msoft-float genera solo chiamate per librerie in virgola mobile ma le librerie richieste non fanno parte di GCC.

Per collegare le librerie soft-fp è possibile utilizzare lo switch -lsoft-fp.

L'architettura X86_64 contiene estensioni SSE, quindi il compilatore proverà a generare codice SSE per operazioni di base come + - * /. Useremo lo switch -mno-sse per sopprimere questo comportamento non autorizzato.

Può sembrare come segue:

gcc -g -msoft-float -mno-sse -m64 -lsoft-fp 

Per il codice:

int main() 
{ 
    float a = 10; 
    float b = 20; 

    float c = a * b; 

    return 0; 
} 

Il gruppo risultante sarà:

.file "12.cpp" 
    .def __main; .scl 2; .type 32; .endef 
    .def __mulsf3; .scl 2; .type 32; .endef 
    .text 
    .globl main 
    .def main; .scl 2; .type 32; .endef 
    .seh_proc main 
main: 
    pushq %rbp 
    .seh_pushreg %rbp 
    movq %rsp, %rbp 
    subq $48, %rsp 
    .seh_stackalloc 48 
    .seh_setframe %rbp, 48 
    .seh_endprologue 
    call __main 
    movl .LC0(%rip), %eax 
    movl %eax, -4(%rbp) 
    movl .LC1(%rip), %eax 
    movl %eax, -8(%rbp) 
    movl -8(%rbp), %edx 
    movl -4(%rbp), %ecx 
    call __mulsf3 
    movl %eax, -12(%rbp) 
    movl $0, %eax 
    addq $48, %rsp 
    popq %rbp 
    ret 
    .seh_endproc 
    .section .rdata,"dr" 
    .align 4 
.LC0: 
    .long 1092616192 
    .align 4 
.LC1: 
    .long 1101004800 
    .ident "GCC: (GNU) 4.8.0 20120624 (experimental)" 

istruzioni SSE Non sono stati generati. Notare la chiamata a __mulsf3.

Alcune idee interessanti si possono trovare in questa domanda: Using software floating point on x86 linux