Soft Float na architekturze x86_64

Question

Pracuję na oprogramowaniu dla systemu wbudowanego, który nie ma jednostki FPU. Chciałbym móc zbudować to oprogramowanie z biblioteką zmiennoprzecinkową na pulpicie, aby uzyskać bardziej realistyczny obraz wydajności. Czy ktoś ma jakieś pomysły na temat tego, jak to osiągnąć?

Do tej pory nie zrobiłem dużego postępu w używaniu -msoft-float z gcc. Obecnie patrzę na użycie klang. Używając flag -Xclang -msoft-float -Xclang -no-implicit-float i określając bibliotekę, która ma implementacje procedur miękkiego float, jestem w stanie skompilować moją aplikację. Kiedy próbuję go uruchomić, to zawsze pęka. Jak najlepiej mogę to stwierdzić, dzieje się tak dlatego, że biblioteki, od których zależy ten program, nie zostały skompilowane za pomocą funkcji miękkiego unosu. Aplikacja zależy od gtk, sqlite, expat, gcrypt, wielu wewnętrznych bibliotek i libc.

Chciałbym spróbować dowiedzieć się, jak zbudować kompletne środowisko kompilacji z obsługą miękkiego pływaka. Próbowałem buildroot uclibc i ustawienia CC i CXX na binaria klang, ale to nie działało ze względu na wymagania dotyczące kompilowania łańcucha narzędzi gcc (rzeczy takie jak autotools narzeka na niepoprawną wersję kompilatora). Ponieważ chciałbym użyć clang jako kompilatora w nowym buildroot (aby mieć wsparcie dla soft-float), nie widzę pilnej potrzeby budowania gcc. Czy można to zrobić bez gcc?

Answer 1

GCC nie może tego zrobić po uruchomieniu bez dodatkowych bibliotek. Zasadniczo, -msoft-float po prostu generuje wywołania dla bibliotek zmiennoprzecinkowych, ale wymagane biblioteki nie są częścią GCC.

Aby połączyć biblioteki soft-fp, można użyć przełącznika -lsoft-fp.

Architektura X86_64 zawiera rozszerzenia SSE, więc kompilator będzie próbował wygenerować kod SSE dla podstawowych operacji, takich jak + - * /. Użyjemy przełącznika -mno-sse, aby wyłączyć to nieautoryzowane zachowanie.

To może wyglądać następująco:

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

Dla kodu:

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

    float c = a * b; 

    return 0; 
} 

Powstały zespół będzie:

.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)" 

instrukcje SSE nie zostały wygenerowane. Zwróć uwagę na numer __mulsf3.

kilka ciekawych pomysłów można znaleźć w tej kwestii: Using software floating point on x86 linux