La Division et le modulo en utilisant un seul divl instruction (i386, amd64)

J'essayais de venir avec inline assemblée pour gcc pour obtenir à la fois la division et le modulo en utilisant un seul divl instruction. Malheureusement, je ne suis pas bon à l'assemblée. Quelqu'un pourrait-il svp m'aider sur ce point? Merci.

Voir stackoverflow.com/questions/3323445/... où j'ai utilisé cela comme un exemple de MSVC inline asm vs GNU C asm inline. (Y compris un travail divl wrapper fonction inline, avec une seule instruction à l'intérieur de l'asm inline déclaration, le même que D0SBoots la bonne réponse ici.)
Voir aussi stackoverflow.com/questions/32741032/... pour un doublon, montrer que vous n'avez pas besoin d'utiliser asm inline (le compilateur le fait pour vous), mais aussi à montrer comment le faire correctement en ligne de l'asm. (Pas de différence significative pour DOSBoot réponse)

OriginalL'auteur | 2011-04-09

3

Oui -- un divl produira le quotient dans eax et le reste dans edx. À l'aide d'Intel syntaxe, par exemple:
```
mov eax, 17
mov ebx, 3
xor edx, edx
div ebx
; eax = 5
; edx = 2
```
Jerry, c'est drôle parce que gcc n'a même pas essayer d'optimiser les deux de ces opérations en un seul. Je vais vous acheter une bière si vous pouviez me donner gcc assemblée, de sorte que je peux l'utiliser comme fonction en ligne ou quelque chose...
Fausse alarme. Désolé. CCAG-t-il pour moi si je n'oublie pas d'indiquer les drapeaux.
Cette réponse est assez hors sujet, car la question est spécifique à la GCC et de vous répondre avec de l'assemblée Intel syntaxe Charles et raylu sont tout autour de mieux.
il a demandé a une séquence d'instructions de montage qui permettrait de produire à la fois le quotient et le reste à l'aide d'une seule instruction div. Aucun de ces "réponses" des tentatives de le leur fournir. Ils sont tous les deux vraiment de commentaires, pas de réponses. La seule autre réponse réelle ici est DOSBoots'.
Non ce n'est pas ce qu'il demande, lisez la question: "j'ai essayé de venir avec inline assemblée pour gcc pour obtenir à la fois la division et le modulo en utilisant un seul divl de l'instruction".

OriginalL'auteur Jerry Coffin
9

Vous êtes à la recherche de quelque chose comme ceci:
```
__asm__("divl %2\n"
       : "=d" (remainder), "=a" (quotient)
       : "g" (modulus), "d" (high), "a" (low));
```
Bien que je suis d'accord avec les autres commentateurs qui, généralement, GCC fera pour vous et vous devez éviter l'assembly en ligne lorsque cela est possible, parfois, vous avez besoin de cette construction.

Par exemple, si le mot est inférieur au module, alors il est sûr d'effectuer la division de ce genre. Cependant, GCC n'est pas assez intelligent pour s'en rendre compte, parce que dans le cas général de la division d'une 64 bits d'un nombre par un nombre 32 bits peut conduire à débordement, et il en appelle à une routine de bibliothèque pour faire du travail supplémentaire. (Remplacer avec 128 bits/64 bits pour 64 bits Isa.)

"g" pour la source et l'opérande n'est pas correct, parce que la DIV ne prend pas en charge immédiate des opérandes. Utilisation "rm". (En fait, vous pourriez vouloir "g" de sorte que votre code va casser au moment de la compilation si vous êtes jamais tirer une balle dans le pied en forçant l'utilisation de DIV lorsque le diviseur est une constante de compilation.) Vous pourriez peut-être également utiliser __builtin_constant_p pour détecter au moment de la compilation-constant opérandes. Cela devrait bien fonctionner avec gcc, mais clang évalue avant la fonction inline (de sorte que vous obtenez de faux négatifs).

OriginalL'auteur D0SBoots
7

Vous ne devriez pas essayer d'optimiser vous-même. GCC fait déjà cela.
```
volatile int some_a = 18, some_b = 7;

int main(int argc, char *argv[]) {
    int a = some_a, b = some_b;
    printf("%d %d\n", a / b, a % b);
    return 0;
}
```
De course
```
gcc -S test.c -O
```
rendements
```
main:
.LFB11:
    .cfi_startproc
    subq    $8, %rsp
    .cfi_def_cfa_offset 16
    movl    some_a(%rip), %esi
    movl    some_b(%rip), %ecx
    movl    %esi, %eax
    movl    %esi, %edx
    sarl    $31, %edx
    idivl   %ecx
    movl    %eax, %esi
    movl    $.LC0, %edi
    movl    $0, %eax
    call    printf
    movl    $0, %eax
    addq    $8, %rsp
    .cfi_def_cfa_offset 8
    ret
```
Avis que le reste, %edx, n'est pas déplacé, car il est aussi le troisième argument passé à printf.

EDIT: La version 32 bits est moins déroutant. En passant -m32 rendements
```
main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    some_a, %eax
    movl    some_b, %ecx
    movl    %eax, %edx
    sarl    $31, %edx
    idivl   %ecx
    movl    %edx, 8(%esp)
    movl    %eax, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf
    movl    $0, %eax
    leave
    ret
```
En fait, gcc n'a pas. Du moins pas avec des drapeaux, je suis en utilisant. Peut-être que je manque quelque chose.
Je suis sur gcc (Debian 4.5.2-4) 4.5.2, mais même 4.3. Êtes-vous en passant -O?
Je suis à l'aide de gcc 4.6.. mais putain! J'ai passé 30 minutes à jouer avec cette avant de demander ici et il s'avère que j'ai juste oublié de préciser "- O3'. J'avais "- mtune=native", mais il n'a pas aidé. Merci! Je devrais dormir un peu...
Pourquoi seulement -O? Utiliser au moins -O2 donc gcc sera judas le signe-extension dans edx avec cdq (aka cltd AT&T de la syntaxe, de l'IIRC). De toute façon, si vous écrivez une fonction qui prend deux arguments, et stocke les résultats à globals (ou les retourner comme une structure, ou de retourner un magasin de l'autre), il permettra d'éviter l'optimisation de loin, mais ont besoin de moins d'instructions que si vous écrivez un main() et l'utilisation volatile. Voir stackoverflow.com/questions/32741032/...
pour montrer que le minimum nécessaire pour obtenir le comportement décrit dans la question.

OriginalL'auteur raylu

Heureusement, vous n'avez pas à recourir à l'assembly en ligne pour atteindre cet objectif. gcc fera automatiquement quand il peut.

$ cat divmod.c

struct sdiv { unsigned long quot; unsigned long rem; };

struct sdiv divide( unsigned long num, unsigned long divisor )
{
        struct sdiv x = { num / divisor, num % divisor };
        return x;
}

$ gcc -O3 -std=c99 -Wall -Wextra -pedantic -S divmod.c -o -

        .file   "divmod.c"
        .text
        .p2align 4,,15
.globl divide
        .type   divide, @function
divide:
.LFB0:
        .cfi_startproc
        movq    %rdi, %rax
        xorl    %edx, %edx
        divq    %rsi
        ret
        .cfi_endproc
.LFE0:
        .size   divide, .-divide
        .ident  "GCC: (GNU) 4.4.4 20100630 (Red Hat 4.4.4-10)"
        .section        .note.GNU-stack,"",@progbits

Ouais, vous avez raison. S'avère que j'avais trop de bière et j'ai oublié de tourner sur des optimisations. Je vous remercie. J'ai upvoted tout le monde.

OriginalL'auteur CB Bailey

Vous devez vous connecter pour publier un commentaire.