Prawidłowy sposób na zawijanie CMPXCHG8B w zespole inline GCC, 32 bity

Question

Próbuję napisać inline ASM GCC dla CMPXCHG8B dla ia32. Nie, nie mogę używać __sync_bool_compare_and_swap. Musi działać z opcją -fPIC i bez niej.

tej pory najlepsze jakie (EDIT: nie działa po wszystkim, zobacz moje własne odpowiedzi poniżej) jest

register int32 ebx_val asm("ebx")= set & 0xFFFFFFFF; 
asm ("lock; cmpxchg8b %0;" 
    "setz %1;" 
    : "+m" (*a), "=q" (ret), "+A" (*cmp) 
    : "r" (ebx_val), "c" ((int32)(set >> 32)) 
    : "flags") 

Jednak nie jestem pewien, czy to jest w rzeczywistości prawidłowego .

Nie mogę wykonać "b" ((int32)(set & 0xFFFFFFFF)) dla ebx_val z powodu PIC, ale podobno register asm("ebx") zmienna jest akceptowana przez kompilator.

BONUS: zmienna ret służy do rozgałęzienia, więc kod kończy się wyglądać jak ten:

cmpxchg8b [edi]; 
setz cl; 
cmp cl, 0; 
je foo; 

Każdy pomysł jak opisać argumenty wyjściowe tak, że staje się:

cmpxchg8b [edi] 
jz foo 

?

Dziękuję.

Answer 1

Jak o następujących, które wydaje się działać dla mnie w małym teście:

int sbcas(uint64_t* ptr, uint64_t oldval, uint64_t newval) 
{ 
    int changed = 0; 
    __asm__ (
     "push %%ebx\n\t" // -fPIC uses ebx, so save it 
     "mov %5, %%ebx\n\t" // load ebx with needed value 
     "lock\n\t" 
     "cmpxchg8b %0\n\t" // perform CAS operation 
     "setz %%al\n\t" // eax potentially modified anyway 
     "movzx %%al, %1\n\t" // store result of comparison in 'changed' 
     "pop %%ebx\n\t" // restore ebx 
     : "+m" (*ptr), "=r" (changed) 
     : "d" ((uint32_t)(oldval >> 32)), "a" ((uint32_t)(oldval & 0xffffffff)), "c" ((uint32_t)(newval >> 32)), "r" ((uint32_t)(newval & 0xffffffff)) 
     : "flags", "memory" 
     ); 
    return changed; 
} 

Jeśli ta również zostanie miscompiled mógłbyś to niewielki fragment, który wyzwala to zachowanie?

Jeśli chodzi o pytanie o bonus, nie sądzę, że możliwe jest rozgałęzienie po bloku asemblera przy użyciu kodu warunku z instrukcji cmpxchg8b (chyba że używasz asm goto lub podobnej funkcjonalności).Od GNU C Language Extensions:

Naturalnym pomysłem jest znalezienie sposobu na udostępnienie kodu warunku pozostawionego przez instrukcję assemblera. Jednak, gdy próbowaliśmy to wdrożyć, nie znaleźliśmy sposobu, aby sprawić, by działał on niezawodnie. Problem polega na tym, że operandy wyjściowe mogą wymagać ponownego załadowania, co skutkowałoby dodatkowymi instrukcjami "składowania". Na większości komputerów instrukcje te zmieniłyby kod warunków, zanim zdążyliby go przetestować. Ten problem nie występuje w przypadku zwykłych instrukcji "test" i "porównaj", ponieważ nie mają żadnych argumentów wyjściowych.

EDIT: Nie mogę znaleźć żadnego źródła, które określa jedną lub drugą stronę, czy to jest OK, aby zmodyfikować stos jednocześnie stosując wartości wejściowych %N (This starożytny Link mówi „Można nawet naciskać na swoich rejestrów stos, użyj ich i odłóż. "ale przykład nie ma wejścia).

Ale to powinno być możliwe do zrobienia bez ustalając wartości do innych rejestrów:

int sbcas(uint64_t* ptr, uint64_t oldval, uint64_t newval) 
{ 
    int changed = 0; 
    __asm__ (
     "push %%ebx\n\t" // -fPIC uses ebx 
     "mov %%edi, %%ebx\n\t" // load ebx with needed value 
     "lock\n\t" 
     "cmpxchg8b (%%esi)\n\t" 
     "setz %%al\n\t" // eax potentially modified anyway 
     "movzx %%al, %1\n\t" 
     "pop %%ebx\n\t" 
     : "+S" (ptr), "=a" (changed) 
     : "0" (ptr), "d" ((uint32_t)(oldval >> 32)), "a" ((uint32_t)(oldval & 0xffffffff)), "c" ((uint32_t)(newval >> 32)), "D" ((uint32_t)(newval & 0xffffffff)) 
     : "flags", "memory" 
     ); 
    return changed; 
} 

Answer 2

To jest to, co mam:

bool 
spin_lock(int64_t* lock, int64_t thread_id, int tries) 
{ 
    register int32_t pic_hack asm("ebx") = thread_id & 0xffffffff; 
retry: 
    if (tries-- > 0) { 
     asm goto ("lock cmpxchg8b %0; jnz %l[retry]" 
        : 
        : "m" (*lock), "A" ((int64_t) 0), 
        "c" ((int32_t) (thread_id >> 32)), "r" (pic_hack) 
        : 
        : retry); 
     return true; 
    } 
    return false; 
} 

Wykorzystuje funkcję asm goto, nowe z gcc 4.5, który umożliwia skoki z inline montażu na etykietach C. (Och, widzę twój komentarz o konieczności obsługi starych wersji gcc. No cóż, próbowałem. :-P)

Answer 3

Co zadziwiające, fragment kodu w pytaniu nadal jest niepoprawnie komplikowany w pewnych okolicznościach: jeśli zero Operator th asm pośrednio adresowalny przez EBX (PIC), zanim rejestr EBX zostanie skonfigurowany z register asm, następnie gcc kontynuuje ładowanie operandu przez EBX po przypisaniu go do set & 0xFFFFFFFF!

Jest to kod próbuję uczynić pracę teraz: (EDIT: unikać Push/pop)

asm ("movl %%edi, -4(%%esp);" 
    "leal %0, %%edi;" 
    "xchgl %%ebx, %%esi;" 
    "lock; cmpxchg8b (%%edi);" // Sets ZF 
    "movl %%esi, %%ebx;"  // Preserves ZF 
    "movl -4(%%esp), %%edi;" // Preserves ZF 
    "setz %1;"     // Reads ZF 
    : "+m" (*a), "=q" (ret), "+A" (*cmp) 
    : "S" ((int32)(set & 0xFFFFFFFF)), "c" ((int32)(set >> 32)) 
    : "flags") 

Chodzi o to, aby załadować argumentów przed przebijania się EBX, również unikać wszelkich pośrednie Odnosząc ustawienie wartości EBX dla CMPXCHG8B. Naprawiłem twardy rejestr ESI dla dolnej połowy argumentu operacji, ponieważ gdybym tego nie zrobił, GCC miałby ochotę ponownie wykorzystać każdy inny już zarejestrowany rejestr, jeśli mógłby udowodnić, że wartość była równa. Rejestr EDI jest zapisywany ręcznie, po prostu dodając go do dławionych list katalogowych dławi GCC z "niemożliwymi przeładowaniami", prawdopodobnie z powodu wysokiego ciśnienia rejestrowego. PUSH/POP jest unikany przy zapisywaniu EDI, ponieważ inne operandy mogą być adresowane przez ESP.