Le topic de la programmation, string, chaînes, cuir et compagnie

**Tramb** · 03/04/2017, 14h47

rOut et Glouglou t'ont expliqué, mais le point important, c'est que "c'est comme ça". Même si on ne sait pas pourquoi, il ne faut pas essayer d'être plus malin que les normes.
C'est complètement language-agnostic comme problème

Related : https://sourceware.org/bugzilla/show_bug.cgi?id=12518

**William Vaurien** · 03/04/2017, 15h01

Je suis désolé, mais je n'ai pas bien compris les explications...
Je ne vois pas le rapport entre le code while ((*dest++ = *src++) != '\0') et les explications. Et pourquoi un coup ça marche et pas l'autre.

Faut pas m'en vouloir, je suis un peu con, j'ai fait du Java pendant presque 20 ans

En fait c'est bien du TGCM. C'est Linus qui le dit (dans le lien de Tramb):

And now applications will randomly do different things depending on the phase of the moon (technically, depending on which CPU they have and what particular version of memcpy() glibc happens to choose).

Me voilà rassuré

**Tramb** · 03/04/2017, 15h09

Randomly pour les applications qui utilisent du "undefined behaviour"

Essaie en Java dans ton debugger, tu auras le même souci, ça n'a pas grand chose à voir avec le langage.

**William Vaurien** · 03/04/2017, 15h19

Je ne crois pas pouvoir reproduire ce genre de comportement en Java... ou alors avec du multi-threading mais ça ne serait pas la même cause...

Pour info:
http://softwareengineering.stackexch...aviour-in-java
et son pendant pour le C:
http://stackoverflow.com/questions/3...-should-know-a

**Tramb** · 03/04/2017, 15h28

Si tu portes la version C avec des indices, tu auras toujours le souci.
Tu pourras donc la porter en Java avec des tableaux de char, et exhiber le "bug".

**Møgluglu** · 03/04/2017, 15h31

Envoyé par Tramb

Related : https://sourceware.org/bugzilla/show_bug.cgi?id=12518

Oui, je crois que c'est la discussion épique Torvalds vs Drepper (et d'autres gourous et language lawyers) à laquelle je pensais, merci.

Envoyé par William Vaurien

Je suis désolé, mais je n'ai pas bien compris les explications...
Je ne vois pas le rapport entre le code while ((*dest++ = *src++) != '\0') et les explications. Et pourquoi un coup ça marche et pas l'autre.

Bah essaie avec ton exemple dans l'autre sens :
strcpy(str+n, str);

Quand tu arrives à la position n tu lis depuis des données que tu as déjà écrasées et ça copie la même séquence en boucle. (Outre le problème de la condition d'arrêt, mais c'est une autre histoire.)

**Tramb** · 03/04/2017, 15h33

Envoyé par Møgluglu

Oui, je crois que c'est la discussion épique Torvalds vs Drepper (et d'autres gourous et language lawyers) à laquelle je pensais, merci.

C'est assez... sec :D

**William Vaurien** · 03/04/2017, 15h43

Envoyé par Tramb

Si tu portes la version C avec des indices, tu auras toujours le souci.
Tu pourras donc la porter en Java avec des tableaux de char, et exhiber le "bug".

Comme ça au débotté et au doigt mouillé, je dirais non. Sauf si l'implémentation est en fait du JNI...
Je ne vois pas comment avoir quelque chose de non prédictible en Java (hors multi-thread).
Buggué, oui, imprédictible, non...

**Teocali** · 03/04/2017, 15h47

Envoyé par Tramb

Related : https://sourceware.org/bugzilla/show_bug.cgi?id=12518

Putain, j'suis super déçu : Linus est resté poli et même aimable tout au long de ses interventions. Un mythe s'effondre.

**Tramb** · 03/04/2017, 15h51

Envoyé par William Vaurien

Comme ça au débotté et au doigt mouillé, je dirais non. Sauf si l'implémentation est en fait du JNI...
Je ne vois pas comment avoir quelque chose de non prédictible en Java (hors multi-thread).
Buggué, oui, imprédictible, non...

Oublie strcpy, c'est pas une question de strcpy, c'est une question de while ((*dest++ = *src++) != '\0') (l'implémentation basique historique de strcpy).
C'est complètement déterministe (si tu n'invoques pas un autre UB en tapant dans de la mémoire non initialisée ou un buffer trop petit).

- - - Mise à jour - - -

Envoyé par Teocali

Putain, j'suis super déçu : Linus est resté poli et même aimable tout au long de ses interventions. Un mythe s'effondre.

Bah il est pas dans son petit jardin, là, il peut pas se permettre d'être aussi méchant que dans le kernel

**William Vaurien** · 03/04/2017, 15h53

Envoyé par Tramb

c'est une question de while ((*dest++ = *src++) != '\0'); C'est complètement déterministe.

là je suis perdu...

**Tramb** · 03/04/2017, 15h57

strcpy est un nom magique que tu n'as pas le droit d'appeler sur des buffers qui s'overlappent

Là, tu dis mais pourquoi, j'aimerais comprendre, par exemple avec son implementation en "while ((*dest++ = *src++) != '\0');"
Cette routine ne marche pas dans les cas d'overlap, comme tes tests le montrent. Pour des raisons algorithmiques, pas magiques. Et reproductibles dans n'importe quel langage.

Mais il y a plein d'autres implémentations valides de strcpy qui donneraient des résultats différents dans les cas "undefined".

**William Vaurien** · 03/04/2017, 16h00

Envoyé par Tramb

Et reproductibles dans n'importe quel langage.

Fais péter la version Java, je te défie de reproduire ce bug avec

(Je suis prêt à te payer un café / une mousse en vrai ou via paypal

)

**Møgluglu** · 03/04/2017, 16h25

Mon Java est rouillé, mais en pseudocode :

Code:

void mymemcpy(char dest[], char src[])
{
  int i = 0;
  while(src[i] != 0) { dest[i] = src[i]; ++i; }
}

void main() {
  char input[42] = { 't', 'o', 't', 'o', '\0' };
  mymemcpy(input+2, input);  // Décale toto de 2 rangs vers la droite?
}

En Java je suppose qu'il faudrait trimballer des indices un peu partout parce que tu ne peux pas faire input+2 pour décaler l'adresse de base du tableau, mais c'est l'idée. Le comportement est déterministe mais ne fait pas du tout ce que tu veux (lever une exception après avoir pourri tout le tableau).

Envoyé par Tramb

Bah il est pas dans son petit jardin, là, il peut pas se permettre d'être aussi méchant que dans le kernel

Ouais et avec l'ami Ulrich en face, il fait pas son malin, il sait qu'il fait pas le poids.

**Tramb** · 03/04/2017, 16h31

Code:

public class MesCouillesEnDeltaplane
{
  public static void main(String[] args)
  {
    // Là on fabrique une C-string "123"
    char[] pTest = new char[16];
    pTest[0] = '1';
    pTest[1] = '2';
    pTest[2] = '3';
    pTest[3] = '4';
    pTest[4] = '\0';
        
    System.out.print(pTest);
    
    // Là on fait un "strcpy"(pTest + dstIndex, pTest+srcIndex)
    char c;
    int srcIndex = 0;
    int dstIndex = 1;
    do
    {
      c = pTest[srcIndex];
      pTest[dstIndex] = c;
      ++srcIndex;
      ++dstIndex;
    }
    while (c != '\0');
    
    System.out.print(pTest);
  }
}

Comme dit Mogluglu, cette simulation de strpcy(pStr+1, pStr) fait boom.

**William Vaurien** · 03/04/2017, 16h37

tu as fais un programme qui plante avec un ArrayIndexOutOfBoundsException... pas un truc qui plante en fonction de ton CPU et de la lune...
Ca plante parce que dans ce cas précis le '\0' fini par se faire écraser par autre chose...

Si tu changes les indexes pour copier de droite à gauche et non-plus de gauche à droite, tout va bien.
Pourtant la version C ne marche une fois sur deux dans ce sens.

**Tramb** · 03/04/2017, 16h44

Ca ne plante jamais en fonction de la lune, et si ça plante en fonction du CPU ou du compilateur, c'est parce que ça appelle des variantes différentes (mais CONFORMES AU STANDARD) de strcpy.
Exercice: dérouler 4 fois la boucle en C et faire les 4 loads à la suite, puis les 4 store. Observer que ça donne un résultat différent, alors que c'est encore une implémentation conformante.
Ceci-dit, tu vois bien pourquoi ce n'est pas une implémentation valable si les buffers s'overlappent, au moins ? Ca serait bien si tu te concentrais sur le problème fondamental, de pourquoi on ne pas copier des tableaux qui s'overlappent en avançant.
Et si tu ne captes pas ça nous ramène à ma règle initiale "FAUT PAS LE FAIRE C'EST COMME CA, C'EST LA NORME".

- - - Mise à jour - - -

Envoyé par Møgluglu

Ouais et avec l'ami Ulrich en face, il fait pas son malin, il sait qu'il fait pas le poids.

On pourrait les mettre tous les deux avec Théo dans une fosse avec des couteaux et n'en laisser qu'un sortir.

**Nattefrost** · 03/04/2017, 16h51

Envoyé par Tramb

On pourrait les mettre tous les deux avec Théo dans une fosse avec des couteaux et n'en laisser qu'un sortir.

De raadt ? Le théo de NetBSD puis OpenBSD?

**Tramb** · 03/04/2017, 16h52

Envoyé par Nattefrost

De raadt ? Le théo de NetBSD puis OpenBSD?

Ouais, c'est un bon candidat pour L'île du Trolling ou Code Lantha.

**William Vaurien** · 03/04/2017, 16h55

Tu es sûrement très fort, mais ta pédagogie laisse à désirer

Je n'ai pas été très clair dans ma première question, (j'étais surtout focalisé sur mon cas et je n'ai pas donné le contexte):
recopie des caractères vers la gauche. Dans ce cas la question reste ouverte:

Pourquoi la recopie des chars de droite à gauche (n+1 vers n) marche pour la deuxième ligne et pas pour la première...
remove '/' in '/1234/' with strcpy --> expected result '1234', obtained result: '1244' ? ERROR
remove '/' in '/12/34/' with strcpy --> expected result '1234', obtained result: '1234' ? OK

Je ne cherchais pas à comprendre pourquoi ça plante, mais pourquoi c'est aléatoire (ou non déterministe ou undefined) avec.

Sinon oui, je vois bien le \0 qui se fait défoncer dans ton example en Java, mais au moins c'est consistent: ça plante tout le temps !

Et de toute façon un grand merci pour vos liens et votre aide

**Nattefrost** · 03/04/2017, 16h56

Ouais d'après ses interviews il n'a pas l'air très sympathique, mais j'adore les chansons de release OpenBSD

**Tramb** · 03/04/2017, 16h58

C'est pas évident de découper en plus petits problèmes

Le truc, c'est que le strcpy de ton test n'est pas le while tout con que tu as vu, mais un truc beaucoup plus compliqué, qui est codé en supposant que tu ne l'invoques pas avec de l'overlap. Et pour comprendre pourquoi ça fait ça, il faudrait le désassembler/tracer dedans.
Mais le point c'est que ce n'est pas important, parce que strcpy/memcpy, c'est de la magie vaudou de ton compilateur. Et pour que cette magie marche, il faut en respecter les règles du jeu.
On a juste essayé de t'expliquer pourquoi il y avait ces règles du jeu.

A mon avis, ton strcpy fait ça en gros : memcpy(pDst, pSrc, strlen(pSrc)); c'est pour ça qu'il termine. Ou il est déroulé.
MAis il faut bien comprendre que ce n'est pas aléatoire ou non-déterministe du tout, là.

PS: Mais du coup, tu devrais essayer des outils comme valgrind ou address-sanitizer pour vous aider à repérer tous ces bugs latents.
Ou DrMemory si c'est sous Windows.

**William Vaurien** · 03/04/2017, 19h16

Je crois que je suis frustré de ne pas compendre et de me rendre compte en même temps que pour comprendre il me faudrait apprendre et comprendre des choses dont finalement je n'ai pas vraiment utilité (à la fin cette appli c'est un pauvre CRUD et des batch de calcul).
En fait TGCM me va bien finalement

mais c'est un peu inquiétant de voir que les bases sont un peu foireuse...

Valgrind ou address-sanitizer ça marcherait sur un projet avec Makefile merdique et pre-processeur violent (proc-c) ?

**Cwningen** · 03/04/2017, 19h36

Envoyé par William Vaurien

Mais je voudrais bien comprendre pourquoi ça ce passe comme ça, et aussi pourquoi ça marche sur d'autres OS...

Je ne pense que ça dépendre de l'OS (strcpy n'est pas un appel système), il faut regarder du coté du compilateur, de la libc, des options de compilations (optimisations) et l'architecture.

Comme le suggère Tramb, si tu veux vraiment comprendre les détails, il faut regarder l'assembleur généré. Les normes qui interdisent l'overlap, c'est justement pour laisser le plus de liberté possible au compilateur pour qu'il puisse faire sa magie.

J'ai regardé vite fait l'assembleur de __strcpy_sse2_unaligned sur un debian x86_64, et j'ai pas envie de le lire (en plus je connais pas les mmx/sse). En tout cas, ça ne ressemble pas à une simple boucle while :

Spoiler Alert!

Code:

0x7ffff7acef70 <__strcpy_sse2_unaligned>        mov    %rsi,%rcx
0x7ffff7acef73 <__strcpy_sse2_unaligned+3>      mov    %rdi,%rax
0x7ffff7acef76 <__strcpy_sse2_unaligned+6>      and    $0x3f,%rcx
0x7ffff7acef7a <__strcpy_sse2_unaligned+10>     cmp    $0x20,%rcx
0x7ffff7acef7e <__strcpy_sse2_unaligned+14>     jbe    0x7ffff7acf193 <__strcpy_sse2_unaligned+547>
0x7ffff7acef84 <__strcpy_sse2_unaligned+20>     and    $0xfffffffffffffff0,%rsi
0x7ffff7acef88 <__strcpy_sse2_unaligned+24>     and    $0xf,%rcx
0x7ffff7acef8c <__strcpy_sse2_unaligned+28>     pxor   %xmm0,%xmm0
0x7ffff7acef90 <__strcpy_sse2_unaligned+32>     pxor   %xmm1,%xmm1
0x7ffff7acef94 <__strcpy_sse2_unaligned+36>     pcmpeqb (%rsi),%xmm1
0x7ffff7acef98 <__strcpy_sse2_unaligned+40>     pmovmskb %xmm1,%edx
0x7ffff7acef9c <__strcpy_sse2_unaligned+44>     shr    %cl,%rdx
0x7ffff7acef9f <__strcpy_sse2_unaligned+47>     test   %rdx,%rdx
0x7ffff7acefa2 <__strcpy_sse2_unaligned+50>     jne    0x7ffff7acf1f0 <__strcpy_sse2_unaligned+640>
0x7ffff7acefa8 <__strcpy_sse2_unaligned+56>     pcmpeqb 0x10(%rsi),%xmm0
0x7ffff7acefad <__strcpy_sse2_unaligned+61>     pmovmskb %xmm0,%edx
0x7ffff7acefb1 <__strcpy_sse2_unaligned+65>     test   %rdx,%rdx
0x7ffff7acefb4 <__strcpy_sse2_unaligned+68>     jne    0x7ffff7acf230 <__strcpy_sse2_unaligned+704>
0x7ffff7acefba <__strcpy_sse2_unaligned+74>     movdqu (%rsi,%rcx,1),%xmm1
0x7ffff7acefbf <__strcpy_sse2_unaligned+79>     movdqu %xmm1,(%rdi)
0x7ffff7acefc3 <__strcpy_sse2_unaligned+83>     nopl   (%rax)
0x7ffff7acefc6 <__strcpy_sse2_unaligned+86>     nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acefd0 <__strcpy_sse2_unaligned+96>     sub    %rcx,%rdi
0x7ffff7acefd3 <__strcpy_sse2_unaligned+99>     mov    $0x10,%rcx
0x7ffff7acefda <__strcpy_sse2_unaligned+106>    movdqa (%rsi,%rcx,1),%xmm1
0x7ffff7acefdf <__strcpy_sse2_unaligned+111>    movaps 0x10(%rsi,%rcx,1),%xmm2
0x7ffff7acefe4 <__strcpy_sse2_unaligned+116>    movdqu %xmm1,(%rdi,%rcx,1)
0x7ffff7acefe9 <__strcpy_sse2_unaligned+121>    pcmpeqb %xmm2,%xmm0
0x7ffff7acefed <__strcpy_sse2_unaligned+125>    pmovmskb %xmm0,%edx
0x7ffff7aceff1 <__strcpy_sse2_unaligned+129>    add    $0x10,%rcx
0x7ffff7aceff5 <__strcpy_sse2_unaligned+133>    test   %rdx,%rdx
0x7ffff7aceff8 <__strcpy_sse2_unaligned+136>    jne    0x7ffff7acf1d0 <__strcpy_sse2_unaligned+608>
0x7ffff7aceffe <__strcpy_sse2_unaligned+142>    movaps 0x10(%rsi,%rcx,1),%xmm3
0x7ffff7acf003 <__strcpy_sse2_unaligned+147>    movdqu %xmm2,(%rdi,%rcx,1)
0x7ffff7acf008 <__strcpy_sse2_unaligned+152>    pcmpeqb %xmm3,%xmm0
0x7ffff7acf00c <__strcpy_sse2_unaligned+156>    pmovmskb %xmm0,%edx
0x7ffff7acf010 <__strcpy_sse2_unaligned+160>    add    $0x10,%rcx
0x7ffff7acf014 <__strcpy_sse2_unaligned+164>    test   %rdx,%rdx
0x7ffff7acf017 <__strcpy_sse2_unaligned+167>    jne    0x7ffff7acf1d0 <__strcpy_sse2_unaligned+608>
0x7ffff7acf01d <__strcpy_sse2_unaligned+173>    movaps 0x10(%rsi,%rcx,1),%xmm4
0x7ffff7acf022 <__strcpy_sse2_unaligned+178>    movdqu %xmm3,(%rdi,%rcx,1)
0x7ffff7acf027 <__strcpy_sse2_unaligned+183>    pcmpeqb %xmm4,%xmm0
0x7ffff7acf02b <__strcpy_sse2_unaligned+187>    pmovmskb %xmm0,%ed
0x7ffff7acf02f <__strcpy_sse2_unaligned+191>    add    $0x10,%rcx
0x7ffff7acf033 <__strcpy_sse2_unaligned+195>    test   %rdx,%rdx
0x7ffff7acf036 <__strcpy_sse2_unaligned+198>    jne    0x7ffff7acf1d0 <__strcpy_sse2_unaligned+608>
0x7ffff7acf03c <__strcpy_sse2_unaligned+204>    movaps 0x10(%rsi,%rcx,1),%xmm1
0x7ffff7acf041 <__strcpy_sse2_unaligned+209>    movdqu %xmm4,(%rdi,%rcx,1)
0x7ffff7acf046 <__strcpy_sse2_unaligned+214>    pcmpeqb %xmm1,%xmm0
0x7ffff7acf04a <__strcpy_sse2_unaligned+218>    pmovmskb %xmm0,%edx
0x7ffff7acf04e <__strcpy_sse2_unaligned+222>    add    $0x10,%rcx
0x7ffff7acf052 <__strcpy_sse2_unaligned+226>    test   %rdx,%rdx
0x7ffff7acf055 <__strcpy_sse2_unaligned+229>    jne    0x7ffff7acf1d0 <__strcpy_sse2_unaligned+608>
0x7ffff7acf05b <__strcpy_sse2_unaligned+235>    movaps 0x10(%rsi,%rcx,1),%xmm2
0x7ffff7acf060 <__strcpy_sse2_unaligned+240>    movdqu %xmm1,(%rdi,%rcx,1)
0x7ffff7acf065 <__strcpy_sse2_unaligned+245>    pcmpeqb %xmm2,%xmm0
0x7ffff7acf069 <__strcpy_sse2_unaligned+249>    pmovmskb %xmm0,%edx
0x7ffff7acf06d <__strcpy_sse2_unaligned+253>    add    $0x10,%rcx
0x7ffff7acf071 <__strcpy_sse2_unaligned+257>    test   %rdx,%rdx
0x7ffff7acf074 <__strcpy_sse2_unaligned+260>    jne    0x7ffff7acf1d0 <__strcpy_sse2_unaligned+608>
0x7ffff7acf07a <__strcpy_sse2_unaligned+266>    movaps 0x10(%rsi,%rcx,1),%xmm3
0x7ffff7acf07f <__strcpy_sse2_unaligned+271>    movdqu %xmm2,(%rdi,%rcx,1)
0x7ffff7acf084 <__strcpy_sse2_unaligned+276>    pcmpeqb %xmm3,%xmm0
0x7ffff7acf088 <__strcpy_sse2_unaligned+280>    pmovmskb %xmm0,%edx
0x7ffff7acf08c <__strcpy_sse2_unaligned+284>    add    $0x10,%rcx
0x7ffff7acf090 <__strcpy_sse2_unaligned+288>    test   %rdx,%rdx
0x7ffff7acf093 <__strcpy_sse2_unaligned+291>    jne    0x7ffff7acf1d0 <__strcpy_sse2_unaligned+608>
0x7ffff7acf099 <__strcpy_sse2_unaligned+297>    movdqu %xmm3,(%rdi,%rcx,1)
0x7ffff7acf09e <__strcpy_sse2_unaligned+302>    mov    %rsi,%rdx
0x7ffff7acf0a1 <__strcpy_sse2_unaligned+305>    lea    0x10(%rsi,%rcx,1),%rsi
0x7ffff7acf0a6 <__strcpy_sse2_unaligned+310>    and    $0xffffffffffffffc0,%rsi
0x7ffff7acf0aa <__strcpy_sse2_unaligned+314>    sub    %rsi,%rdx
0x7ffff7acf0ad <__strcpy_sse2_unaligned+317>    sub    %rdx,%rdi
0x7ffff7acf0b0 <__strcpy_sse2_unaligned+320>    movaps (%rsi),%xmm2
0x7ffff7acf0b3 <__strcpy_sse2_unaligned+323>    movaps %xmm2,%xmm4
0x7ffff7acf0b6 <__strcpy_sse2_unaligned+326>    movaps 0x10(%rsi),%xmm5
0x7ffff7acf0ba <__strcpy_sse2_unaligned+330>    movaps 0x20(%rsi),%xmm3
0x7ffff7acf0be <__strcpy_sse2_unaligned+334>    movaps %xmm3,%xmm6
0x7ffff7acf0c1 <__strcpy_sse2_unaligned+337>    movaps 0x30(%rsi),%xmm7
0x7ffff7acf0c5 <__strcpy_sse2_unaligned+341>    pminub %xmm5,%xmm2
0x7ffff7acf0c9 <__strcpy_sse2_unaligned+345>    pminub %xmm7,%xmm3
0x7ffff7acf0cd <__strcpy_sse2_unaligned+349>    pminub %xmm2,%xmm3
0x7ffff7acf0d1 <__strcpy_sse2_unaligned+353>    pcmpeqb %xmm0,%xmm3
0x7ffff7acf0d5 <__strcpy_sse2_unaligned+357>    pmovmskb %xmm3,%edx
0x7ffff7acf0d9 <__strcpy_sse2_unaligned+361>    test   %rdx,%rd
0x7ffff7acf0dc <__strcpy_sse2_unaligned+364>    jne    0x7ffff7acf129 <__strcpy_sse2_unaligned+441>
0x7ffff7acf0de <__strcpy_sse2_unaligned+366>    add    $0x40,%rdi
0x7ffff7acf0e2 <__strcpy_sse2_unaligned+370>    add    $0x40,%rsi
0x7ffff7acf0e6 <__strcpy_sse2_unaligned+374>    movdqu %xmm4,-0x40(%rdi)
0x7ffff7acf0eb <__strcpy_sse2_unaligned+379>    movaps (%rsi),%xmm2
0x7ffff7acf0ee <__strcpy_sse2_unaligned+382>    movdqa %xmm2,%xmm4
0x7ffff7acf0f2 <__strcpy_sse2_unaligned+386>    movdqu %xmm5,-0x30(%rdi)
0x7ffff7acf0f7 <__strcpy_sse2_unaligned+391>    movaps 0x10(%rsi),%xmm5
0x7ffff7acf0fb <__strcpy_sse2_unaligned+395>    pminub %xmm5,%xmm2
0x7ffff7acf0ff <__strcpy_sse2_unaligned+399>    movaps 0x20(%rsi),%xmm3
0x7ffff7acf103 <__strcpy_sse2_unaligned+403>    movdqu %xmm6,-0x20(%rdi)
0x7ffff7acf108 <__strcpy_sse2_unaligned+408>    movaps %xmm3,%xmm6
0x7ffff7acf10b <__strcpy_sse2_unaligned+411>    movdqu %xmm7,-0x10(%rdi)
0x7ffff7acf110 <__strcpy_sse2_unaligned+416>    movaps 0x30(%rsi),%xmm7
0x7ffff7acf114 <__strcpy_sse2_unaligned+420>    pminub %xmm7,%xmm3
0x7ffff7acf118 <__strcpy_sse2_unaligned+424>    pminub %xmm2,%xmm3
0x7ffff7acf11c <__strcpy_sse2_unaligned+428>    pcmpeqb %xmm0,%xmm3
0x7ffff7acf120 <__strcpy_sse2_unaligned+432>    pmovmskb %xmm3,%edx
0x7ffff7acf124 <__strcpy_sse2_unaligned+436>    test   %rdx,%rdx
0x7ffff7acf127 <__strcpy_sse2_unaligned+439>    je     0x7ffff7acf0de <__strcpy_sse2_unaligned+366>
0x7ffff7acf129 <__strcpy_sse2_unaligned+441>    pxor   %xmm1,%xmm1
0x7ffff7acf12d <__strcpy_sse2_unaligned+445>    pcmpeqb %xmm4,%xmm0
0x7ffff7acf131 <__strcpy_sse2_unaligned+449>    pcmpeqb %xmm5,%xmm1
0x7ffff7acf135 <__strcpy_sse2_unaligned+453>    pmovmskb %xmm0,%edx
0x7ffff7acf139 <__strcpy_sse2_unaligned+457>    pmovmskb %xmm1,%ecx
0x7ffff7acf13d <__strcpy_sse2_unaligned+461>    test   %rdx,%rdx
0x7ffff7acf140 <__strcpy_sse2_unaligned+464>    jne    0x7ffff7acf250 <__strcpy_sse2_unaligned+736>
0x7ffff7acf146 <__strcpy_sse2_unaligned+470>    test   %rcx,%rcx
0x7ffff7acf149 <__strcpy_sse2_unaligned+473>    jne    0x7ffff7acf270 <__strcpy_sse2_unaligned+768>
0x7ffff7acf14f <__strcpy_sse2_unaligned+479>    pcmpeqb %xmm6,%xmm0
0x7ffff7acf153 <__strcpy_sse2_unaligned+483>    pcmpeqb %xmm7,%xmm1
0x7ffff7acf157 <__strcpy_sse2_unaligned+487>    pmovmskb %xmm0,%edx
0x7ffff7acf15b <__strcpy_sse2_unaligned+491>    pmovmskb %xmm1,%ecx
0x7ffff7acf15f <__strcpy_sse2_unaligned+495>    test   %rdx,%rdx
0x7ffff7acf162 <__strcpy_sse2_unaligned+498>    jne    0x7ffff7acf2a0 <__strcpy_sse2_unaligned+816>
0x7ffff7acf168 <__strcpy_sse2_unaligned+504>    bsf    %rcx,%rdx
0x7ffff7acf16c <__strcpy_sse2_unaligned+508>    movdqu %xmm4,(%rdi)
0x7ffff7acf170 <__strcpy_sse2_unaligned+512>    movdqu %xmm5,0x10(%rdi)
0x7ffff7acf175 <__strcpy_sse2_unaligned+517>    movdqu %xmm6,0x20(%rdi)
0x7ffff7acf17a <__strcpy_sse2_unaligned+522>    add    $0x30,%rsi
0x7ffff7acf17e <__strcpy_sse2_unaligned+526>    add    $0x30,%rdi
0x7ffff7acf182 <__strcpy_sse2_unaligned+530>    lea    0xc8a7f(%rip),%r11        # 0x7ffff7b97c08
0x7ffff7acf189 <__strcpy_sse2_unaligned+537>    movslq (%r11,%rdx,4),%rcx
0x7ffff7acf18d <__strcpy_sse2_unaligned+541>    lea    (%r11,%rcx,1),%rcx
0x7ffff7acf191 <__strcpy_sse2_unaligned+545>    jmpq   *%rcx
0x7ffff7acf193 <__strcpy_sse2_unaligned+547>    pxor   %xmm0,%xmm0
0x7ffff7acf197 <__strcpy_sse2_unaligned+551>    movdqu (%rsi),%xmm1
0x7ffff7acf19b <__strcpy_sse2_unaligned+555>    movdqu 0x10(%rsi),%xmm2
0x7ffff7acf1a0 <__strcpy_sse2_unaligned+560>    pcmpeqb %xmm1,%xmm0
0x7ffff7acf1a4 <__strcpy_sse2_unaligned+564>    pmovmskb %xmm0,%edx
0x7ffff7acf1a8 <__strcpy_sse2_unaligned+568>    test   %rdx,%rdx
0x7ffff7acf1ab <__strcpy_sse2_unaligned+571>    jne    0x7ffff7acf218 <__strcpy_sse2_unaligned+680>
0x7ffff7acf1ad <__strcpy_sse2_unaligned+573>    pcmpeqb %xmm2,%xmm0
0x7ffff7acf1b1 <__strcpy_sse2_unaligned+577>    movdqu %xmm1,(%rdi)
0x7ffff7acf1b5 <__strcpy_sse2_unaligned+581>    pmovmskb %xmm0,%edx
0x7ffff7acf1b9 <__strcpy_sse2_unaligned+585>    test   %rdx,%rdx
0x7ffff7acf1bc <__strcpy_sse2_unaligned+588>    jne    0x7ffff7acf210 <__strcpy_sse2_unaligned+672>
0x7ffff7acf1be <__strcpy_sse2_unaligned+590>    and    $0xfffffffffffffff0,%rsi
0x7ffff7acf1c2 <__strcpy_sse2_unaligned+594>    and    $0xf,%rcx
0x7ffff7acf1c6 <__strcpy_sse2_unaligned+598>    jmpq   0x7ffff7acefd0 <__strcpy_sse2_unaligned+96>
0x7ffff7acf1cb <__strcpy_sse2_unaligned+603>    nopl   0x0(%rax,%rax,1)
0x7ffff7acf1d0 <__strcpy_sse2_unaligned+608>    add    %rcx,%rdi
0x7ffff7acf1d3 <__strcpy_sse2_unaligned+611>    add    %rcx,%rsi
0x7ffff7acf1d6 <__strcpy_sse2_unaligned+614>    bsf    %rdx,%rdx
0x7ffff7acf1da <__strcpy_sse2_unaligned+618>    lea    0xc8a27(%rip),%r11        # 0x7ffff7b97c08
0x7ffff7acf1e1 <__strcpy_sse2_unaligned+625>    movslq (%r11,%rdx,4),%rcx
0x7ffff7acf1e5 <__strcpy_sse2_unaligned+629>    lea    (%r11,%rcx,1),%rcx
0x7ffff7acf1e9 <__strcpy_sse2_unaligned+633>    jmpq   *%rcx
0x7ffff7acf1eb <__strcpy_sse2_unaligned+635>    nopl   0x0(%rax,%rax,1)
0x7ffff7acf1f0 <__strcpy_sse2_unaligned+640>    add    %rcx,%rsi
0x7ffff7acf1f3 <__strcpy_sse2_unaligned+643>    bsf    %rdx,%rdx
0x7ffff7acf1f7 <__strcpy_sse2_unaligned+647>    lea    0xc8a0a(%rip),%r11        # 0x7ffff7b97c08
0x7ffff7acf1fe <__strcpy_sse2_unaligned+654>    movslq (%r11,%rdx,4),%rcx
0x7ffff7acf202 <__strcpy_sse2_unaligned+658>    lea    (%r11,%rcx,1),%rcx
0x7ffff7acf206 <__strcpy_sse2_unaligned+662>    jmpq   *%rcx
0x7ffff7acf208 <__strcpy_sse2_unaligned+664>    nopl   0x0(%rax,%rax,1)
0x7ffff7acf210 <__strcpy_sse2_unaligned+672>    add    $0x10,%rsi
0x7ffff7acf214 <__strcpy_sse2_unaligned+676>    add    $0x10,%rdi
0x7ffff7acf218 <__strcpy_sse2_unaligned+680>    bsf    %rdx,%rdx
0x7ffff7acf21c <__strcpy_sse2_unaligned+684>    lea    0xc89e5(%rip),%r11        # 0x7ffff7b97c08
0x7ffff7acf223 <__strcpy_sse2_unaligned+691>    movslq (%r11,%rdx,4),%rcx
0x7ffff7acf227 <__strcpy_sse2_unaligned+695>    lea    (%r11,%rcx,1),%rcx
0x7ffff7acf22b <__strcpy_sse2_unaligned+699>    jmpq   *%rcx
0x7ffff7acf22d <__strcpy_sse2_unaligned+701>    nopl   (%rax)
0x7ffff7acf230 <__strcpy_sse2_unaligned+704>    bsf    %rdx,%rdx
0x7ffff7acf234 <__strcpy_sse2_unaligned+708>    add    %rcx,%rsi
0x7ffff7acf237 <__strcpy_sse2_unaligned+711>    add    $0x10,%rdx
0x7ffff7acf23b <__strcpy_sse2_unaligned+715>    sub    %rcx,%rdx
0x7ffff7acf23e <__strcpy_sse2_unaligned+718>    lea    0xc89c3(%rip),%r11        # 0x7ffff7b97c08
0x7ffff7acf245 <__strcpy_sse2_unaligned+725>    movslq (%r11,%rdx,4),%rcx
0x7ffff7acf249 <__strcpy_sse2_unaligned+729>    lea    (%r11,%rcx,1),%rcx
0x7ffff7acf24d <__strcpy_sse2_unaligned+733>    jmpq   *%rcx
0x7ffff7acf24f <__strcpy_sse2_unaligned+735>    nop
0x7ffff7acf250 <__strcpy_sse2_unaligned+736>    bsf    %rdx,%rdx
0x7ffff7acf254 <__strcpy_sse2_unaligned+740>    lea    0xc89ad(%rip),%r11        # 0x7ffff7b97c08
0x7ffff7acf25b <__strcpy_sse2_unaligned+747>    movslq (%r11,%rdx,4),%rcx
0x7ffff7acf25f <__strcpy_sse2_unaligned+751>    lea    (%r11,%rcx,1),%rcx
0x7ffff7acf263 <__strcpy_sse2_unaligned+755>    jmpq   *%rcx
0x7ffff7acf265 <__strcpy_sse2_unaligned+757>    nop
0x7ffff7acf266 <__strcpy_sse2_unaligned+758>    nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf270 <__strcpy_sse2_unaligned+768>    bsf    %rcx,%rdx
0x7ffff7acf274 <__strcpy_sse2_unaligned+772>    movdqu %xmm4,(%rdi)
0x7ffff7acf278 <__strcpy_sse2_unaligned+776>    add    $0x10,%rsi
0x7ffff7acf27c <__strcpy_sse2_unaligned+780>    add    $0x10,%rdi
0x7ffff7acf280 <__strcpy_sse2_unaligned+784>    lea    0xc8981(%rip),%r11        # 0x7ffff7b97c08
0x7ffff7acf287 <__strcpy_sse2_unaligned+791>    movslq (%r11,%rdx,4),%rcx
0x7ffff7acf28b <__strcpy_sse2_unaligned+795>    lea    (%r11,%rcx,1),%rcx
0x7ffff7acf28f <__strcpy_sse2_unaligned+799>    jmpq   *%rcx
0x7ffff7acf291 <__strcpy_sse2_unaligned+801>    nopl   0x0(%rax,%rax,1)
0x7ffff7acf296 <__strcpy_sse2_unaligned+806>    nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf2a0 <__strcpy_sse2_unaligned+816>    bsf    %rdx,%rdx
0x7ffff7acf2a4 <__strcpy_sse2_unaligned+820>    movdqu %xmm4,(%rdi)
0x7ffff7acf2a8 <__strcpy_sse2_unaligned+824>    movdqu %xmm5,0x10(%rdi)
0x7ffff7acf2ad <__strcpy_sse2_unaligned+829>    add    $0x20,%rsi
0x7ffff7acf2b1 <__strcpy_sse2_unaligned+833>    add    $0x20,%rdi
0x7ffff7acf2b5 <__strcpy_sse2_unaligned+837>    lea    0xc894c(%rip),%r11        # 0x7ffff7b97c08
0x7ffff7acf2bc <__strcpy_sse2_unaligned+844>    movslq (%r11,%rdx,4),%rcx
0x7ffff7acf2c0 <__strcpy_sse2_unaligned+848>    lea    (%r11,%rcx,1),%rcx
0x7ffff7acf2c4 <__strcpy_sse2_unaligned+852>    jmpq   *%rcx
0x7ffff7acf2c6 <__strcpy_sse2_unaligned+854>    nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf2d0 <__strcpy_sse2_unaligned+864>    mov    %dh,(%rdi)
0x7ffff7acf2d2 <__strcpy_sse2_unaligned+866>    retq
0x7ffff7acf2d3 <__strcpy_sse2_unaligned+867>    nopl   (%rax)
0x7ffff7acf2d6 <__strcpy_sse2_unaligned+870>    nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf2e0 <__strcpy_sse2_unaligned+880>    mov    (%rsi),%dx
0x7ffff7acf2e3 <__strcpy_sse2_unaligned+883>    mov    %dx,(%rdi)
0x7ffff7acf2e6 <__strcpy_sse2_unaligned+886>    retq
0x7ffff7acf2e7 <__strcpy_sse2_unaligned+887>    nopw   0x0(%rax,%rax,1)
0x7ffff7acf2f0 <__strcpy_sse2_unaligned+896>    mov    (%rsi),%cx
0x7ffff7acf2f3 <__strcpy_sse2_unaligned+899>    mov    %cx,(%rdi)
0x7ffff7acf2f6 <__strcpy_sse2_unaligned+902>    mov    %dh,0x2(%rdi)
0x7ffff7acf2f9 <__strcpy_sse2_unaligned+905>    retq
0x7ffff7acf2fa <__strcpy_sse2_unaligned+906>    nopw   0x0(%rax,%rax,1)
0x7ffff7acf300 <__strcpy_sse2_unaligned+912>    mov    (%rsi),%edx
0x7ffff7acf302 <__strcpy_sse2_unaligned+914>    mov    %edx,(%rdi)
0x7ffff7acf304 <__strcpy_sse2_unaligned+916>    retq
0x7ffff7acf305 <__strcpy_sse2_unaligned+917>    nop
0x7ffff7acf306 <__strcpy_sse2_unaligned+918>    nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf310 <__strcpy_sse2_unaligned+928>    mov    (%rsi),%ecx
0x7ffff7acf312 <__strcpy_sse2_unaligned+930>    mov    %dh,0x4(%rdi)
0x7ffff7acf315 <__strcpy_sse2_unaligned+933>    mov    %ecx,(%rdi)
0x7ffff7acf317 <__strcpy_sse2_unaligned+935>    retq
0x7ffff7acf318 <__strcpy_sse2_unaligned+936>    nopl   0x0(%rax,%rax,1)
0x7ffff7acf320 <__strcpy_sse2_unaligned+944>    mov    (%rsi),%ecx
0x7ffff7acf322 <__strcpy_sse2_unaligned+946>    mov    0x4(%rsi),%dx
0x7ffff7acf326 <__strcpy_sse2_unaligned+950>    mov    %ecx,(%rdi)
0x7ffff7acf328 <__strcpy_sse2_unaligned+952>    mov    %dx,0x4(%rdi)
0x7ffff7acf32c <__strcpy_sse2_unaligned+956>    retq
0x7ffff7acf32d <__strcpy_sse2_unaligned+957>    nopl   (%rax)
0x7ffff7acf330 <__strcpy_sse2_unaligned+960>    mov    (%rsi),%ecx
0x7ffff7acf332 <__strcpy_sse2_unaligned+962>    mov    0x3(%rsi),%edx
0x7ffff7acf335 <__strcpy_sse2_unaligned+965>    mov    %ecx,(%rdi)
0x7ffff7acf337 <__strcpy_sse2_unaligned+967>    mov    %edx,0x3(%rdi)
0x7ffff7acf33a <__strcpy_sse2_unaligned+970>    retq
0x7ffff7acf33b <__strcpy_sse2_unaligned+971>    nopl   0x0(%rax,%rax,1)
0x7ffff7acf340 <__strcpy_sse2_unaligned+976>    mov    (%rsi),%rdx
0x7ffff7acf343 <__strcpy_sse2_unaligned+979>    mov    %rdx,(%rdi)
0x7ffff7acf346 <__strcpy_sse2_unaligned+982>    retq
0x7ffff7acf347 <__strcpy_sse2_unaligned+983>    nopw   0x0(%rax,%rax,1)
0x7ffff7acf350 <__strcpy_sse2_unaligned+992>    mov    (%rsi),%rcx
0x7ffff7acf353 <__strcpy_sse2_unaligned+995>    mov    %dh,0x8(%rdi)
0x7ffff7acf356 <__strcpy_sse2_unaligned+998>    mov    %rcx,(%rdi)
0x7ffff7acf359 <__strcpy_sse2_unaligned+1001>   retq
0x7ffff7acf35a <__strcpy_sse2_unaligned+1002>   nopw   0x0(%rax,%rax,1)
0x7ffff7acf360 <__strcpy_sse2_unaligned+1008>   mov    (%rsi),%rcx
0x7ffff7acf363 <__strcpy_sse2_unaligned+1011>   mov    0x8(%rsi),%dx
0x7ffff7acf367 <__strcpy_sse2_unaligned+1015>   mov    %rcx,(%rdi)
0x7ffff7acf36a <__strcpy_sse2_unaligned+1018>   mov    %dx,0x8(%rdi)
0x7ffff7acf36e <__strcpy_sse2_unaligned+1022>   retq
0x7ffff7acf36f <__strcpy_sse2_unaligned+1023>   nop
0x7ffff7acf370 <__strcpy_sse2_unaligned+1024>   mov    (%rsi),%rcx
0x7ffff7acf373 <__strcpy_sse2_unaligned+1027>   mov    0x7(%rsi),%edx
0x7ffff7acf376 <__strcpy_sse2_unaligned+1030>   mov    %rcx,(%rdi)
0x7ffff7acf379 <__strcpy_sse2_unaligned+1033>   mov    %edx,0x7(%rdi)
0x7ffff7acf37c <__strcpy_sse2_unaligned+1036>   retq
0x7ffff7acf37d <__strcpy_sse2_unaligned+1037>   nopl   (%rax)
0x7ffff7acf380 <__strcpy_sse2_unaligned+1040>   mov    (%rsi),%rcx
0x7ffff7acf383 <__strcpy_sse2_unaligned+1043>   mov    0x8(%rsi),%edx
0x7ffff7acf386 <__strcpy_sse2_unaligned+1046>   mov    %rcx,(%rdi)
0x7ffff7acf389 <__strcpy_sse2_unaligned+1049>   mov    %edx,0x8(%rdi)
0x7ffff7acf38c <__strcpy_sse2_unaligned+1052>   retq
0x7ffff7acf38d <__strcpy_sse2_unaligned+1053>   nopl   (%rax)
0x7ffff7acf390 <__strcpy_sse2_unaligned+1056>   mov    (%rsi),%rcx
0x7ffff7acf393 <__strcpy_sse2_unaligned+1059>   mov    0x5(%rsi),%rdx
0x7ffff7acf397 <__strcpy_sse2_unaligned+1063>   mov    %rcx,(%rdi)
0x7ffff7acf39a <__strcpy_sse2_unaligned+1066>   mov    %rdx,0x5(%rdi)
0x7ffff7acf39e <__strcpy_sse2_unaligned+1070>   retq
0x7ffff7acf39f <__strcpy_sse2_unaligned+1071>   nop
0x7ffff7acf3a0 <__strcpy_sse2_unaligned+1072>   mov    (%rsi),%rcx
0x7ffff7acf3a3 <__strcpy_sse2_unaligned+1075>   mov    0x6(%rsi),%rdx
0x7ffff7acf3a7 <__strcpy_sse2_unaligned+1079>   mov    %rcx,(%rdi)
0x7ffff7acf3aa <__strcpy_sse2_unaligned+1082>   mov    %rdx,0x6(%rdi)
0x7ffff7acf3ae <__strcpy_sse2_unaligned+1086>   retq
0x7ffff7acf3af <__strcpy_sse2_unaligned+1087>   nop
0x7ffff7acf3b0 <__strcpy_sse2_unaligned+1088>   mov    (%rsi),%rcx
0x7ffff7acf3b3 <__strcpy_sse2_unaligned+1091>   mov    0x7(%rsi),%rdx
0x7ffff7acf3b7 <__strcpy_sse2_unaligned+1095>   mov    %rcx,(%rdi)
0x7ffff7acf3ba <__strcpy_sse2_unaligned+1098>   mov    %rdx,0x7(%rdi)
0x7ffff7acf3be <__strcpy_sse2_unaligned+1102>   retq
0x7ffff7acf3bf <__strcpy_sse2_unaligned+1103>   nop
0x7ffff7acf3c0 <__strcpy_sse2_unaligned+1104>   movdqu (%rsi),%xmm0
0x7ffff7acf3c4 <__strcpy_sse2_unaligned+1108>   movdqu %xmm0,(%rdi)
0x7ffff7acf3c8 <__strcpy_sse2_unaligned+1112>   retq
0x7ffff7acf3c9 <__strcpy_sse2_unaligned+1113>   nopl   0x0(%rax)
0x7ffff7acf3d0 <__strcpy_sse2_unaligned+1120>   movdqu (%rsi),%xmm0
0x7ffff7acf3d4 <__strcpy_sse2_unaligned+1124>   movdqu %xmm0,(%rdi)
0x7ffff7acf3d8 <__strcpy_sse2_unaligned+1128>   mov    %dh,0x10(%rdi)
0x7ffff7acf3db <__strcpy_sse2_unaligned+1131>   retq
0x7ffff7acf3dc <__strcpy_sse2_unaligned+1132>   nopl   0x0(%rax)
0x7ffff7acf3e0 <__strcpy_sse2_unaligned+1136>   movdqu (%rsi),%xmm0
0x7ffff7acf3e4 <__strcpy_sse2_unaligned+1140>   mov    0x10(%rsi),%cx
0x7ffff7acf3e8 <__strcpy_sse2_unaligned+1144>   movdqu %xmm0,(%rdi)
0x7ffff7acf3ec <__strcpy_sse2_unaligned+1148>   mov    %cx,0x10(%rdi)
0x7ffff7acf3f0 <__strcpy_sse2_unaligned+1152>   retq
0x7ffff7acf3f1 <__strcpy_sse2_unaligned+1153>   nopl   0x0(%rax,%rax,1)
0x7ffff7acf3f6 <__strcpy_sse2_unaligned+1158>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf400 <__strcpy_sse2_unaligned+1168>   movdqu (%rsi),%xmm0
0x7ffff7acf404 <__strcpy_sse2_unaligned+1172>   mov    0xf(%rsi),%ecx
0x7ffff7acf407 <__strcpy_sse2_unaligned+1175>   movdqu %xmm0,(%rdi)
0x7ffff7acf40b <__strcpy_sse2_unaligned+1179>   mov    %ecx,0xf(%rdi)
0x7ffff7acf40e <__strcpy_sse2_unaligned+1182>   retq
0x7ffff7acf40f <__strcpy_sse2_unaligned+1183>   nop
0x7ffff7acf410 <__strcpy_sse2_unaligned+1184>   movdqu (%rsi),%xmm0
0x7ffff7acf414 <__strcpy_sse2_unaligned+1188>   mov    0x10(%rsi),%ecx
0x7ffff7acf417 <__strcpy_sse2_unaligned+1191>   movdqu %xmm0,(%rdi)
0x7ffff7acf41b <__strcpy_sse2_unaligned+1195>   mov    %ecx,0x10(%rdi)
0x7ffff7acf41e <__strcpy_sse2_unaligned+1198>   retq
0x7ffff7acf41f <__strcpy_sse2_unaligned+1199>   nop
0x7ffff7acf420 <__strcpy_sse2_unaligned+1200>   movdqu (%rsi),%xmm0
0x7ffff7acf424 <__strcpy_sse2_unaligned+1204>   mov    0x10(%rsi),%ecx
0x7ffff7acf427 <__strcpy_sse2_unaligned+1207>   movdqu %xmm0,(%rdi)
0x7ffff7acf42b <__strcpy_sse2_unaligned+1211>   mov    %ecx,0x10(%rdi)
0x7ffff7acf42e <__strcpy_sse2_unaligned+1214>   mov    %dh,0x14(%rdi)
0x7ffff7acf431 <__strcpy_sse2_unaligned+1217>   retq
0x7ffff7acf432 <__strcpy_sse2_unaligned+1218>   nopl   0x0(%rax)
0x7ffff7acf436 <__strcpy_sse2_unaligned+1222>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf440 <__strcpy_sse2_unaligned+1232>   movdqu (%rsi),%xmm0
0x7ffff7acf444 <__strcpy_sse2_unaligned+1236>   mov    0xe(%rsi),%rcx
0x7ffff7acf448 <__strcpy_sse2_unaligned+1240>   movdqu %xmm0,(%rdi)
0x7ffff7acf44c <__strcpy_sse2_unaligned+1244>   mov    %rcx,0xe(%rdi)
0x7ffff7acf450 <__strcpy_sse2_unaligned+1248>   retq
0x7ffff7acf451 <__strcpy_sse2_unaligned+1249>   nopl   0x0(%rax,%rax,1)
0x7ffff7acf456 <__strcpy_sse2_unaligned+1254>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf460 <__strcpy_sse2_unaligned+1264>   movdqu (%rsi),%xmm0
0x7ffff7acf464 <__strcpy_sse2_unaligned+1268>   mov    0xf(%rsi),%rcx
0x7ffff7acf468 <__strcpy_sse2_unaligned+1272>   movdqu %xmm0,(%rdi)
0x7ffff7acf46c <__strcpy_sse2_unaligned+1276>   mov    %rcx,0xf(%rdi)
0x7ffff7acf470 <__strcpy_sse2_unaligned+1280>   retq
0x7ffff7acf471 <__strcpy_sse2_unaligned+1281>   nopl   0x0(%rax,%rax,1)
0x7ffff7acf476 <__strcpy_sse2_unaligned+1286>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf480 <__strcpy_sse2_unaligned+1296>   movdqu (%rsi),%xmm0
0x7ffff7acf484 <__strcpy_sse2_unaligned+1300>   mov    0x10(%rsi),%rc
0x7ffff7acf488 <__strcpy_sse2_unaligned+1304>   movdqu %xmm0,(%rdi)
0x7ffff7acf48c <__strcpy_sse2_unaligned+1308>   mov    %rcx,0x10(%rdi)
0x7ffff7acf490 <__strcpy_sse2_unaligned+1312>   retq
0x7ffff7acf491 <__strcpy_sse2_unaligned+1313>   nopl   0x0(%rax,%rax,1)
0x7ffff7acf496 <__strcpy_sse2_unaligned+1318>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf4a0 <__strcpy_sse2_unaligned+1328>   movdqu (%rsi),%xmm0
0x7ffff7acf4a4 <__strcpy_sse2_unaligned+1332>   mov    0x10(%rsi),%rcx
0x7ffff7acf4a8 <__strcpy_sse2_unaligned+1336>   movdqu %xmm0,(%rdi)
0x7ffff7acf4ac <__strcpy_sse2_unaligned+1340>   mov    %rcx,0x10(%rdi)
0x7ffff7acf4b0 <__strcpy_sse2_unaligned+1344>   mov    %dh,0x18(%rdi)
0x7ffff7acf4b3 <__strcpy_sse2_unaligned+1347>   retq
0x7ffff7acf4b4 <__strcpy_sse2_unaligned+1348>   xchg   %ax,%ax
0x7ffff7acf4b6 <__strcpy_sse2_unaligned+1350>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf4c0 <__strcpy_sse2_unaligned+1360>   movdqu (%rsi),%xmm0
0x7ffff7acf4c4 <__strcpy_sse2_unaligned+1364>   mov    0x10(%rsi),%rdx
0x7ffff7acf4c8 <__strcpy_sse2_unaligned+1368>   mov    0x18(%rsi),%cx
0x7ffff7acf4cc <__strcpy_sse2_unaligned+1372>   movdqu %xmm0,(%rdi)
0x7ffff7acf4d0 <__strcpy_sse2_unaligned+1376>   mov    %rdx,0x10(%rdi)
0x7ffff7acf4d4 <__strcpy_sse2_unaligned+1380>   mov    %cx,0x18(%rdi)
0x7ffff7acf4d8 <__strcpy_sse2_unaligned+1384>   retq
0x7ffff7acf4d9 <__strcpy_sse2_unaligned+1385>   nopl   0x0(%rax)
0x7ffff7acf4e0 <__strcpy_sse2_unaligned+1392>   movdqu (%rsi),%xmm0
0x7ffff7acf4e4 <__strcpy_sse2_unaligned+1396>   mov    0x10(%rsi),%rdx
0x7ffff7acf4e8 <__strcpy_sse2_unaligned+1400>   mov    0x17(%rsi),%ecx
0x7ffff7acf4eb <__strcpy_sse2_unaligned+1403>   movdqu %xmm0,(%rdi)
0x7ffff7acf4ef <__strcpy_sse2_unaligned+1407>   mov    %rdx,0x10(%rdi)
0x7ffff7acf4f3 <__strcpy_sse2_unaligned+1411>   mov    %ecx,0x17(%rdi)
0x7ffff7acf4f6 <__strcpy_sse2_unaligned+1414>   retq
0x7ffff7acf4f7 <__strcpy_sse2_unaligned+1415>   nopw   0x0(%rax,%rax,1)
0x7ffff7acf500 <__strcpy_sse2_unaligned+1424>   movdqu (%rsi),%xmm0
0x7ffff7acf504 <__strcpy_sse2_unaligned+1428>   mov    0x10(%rsi),%rdx
0x7ffff7acf508 <__strcpy_sse2_unaligned+1432>   mov    0x18(%rsi),%ecx
0x7ffff7acf50b <__strcpy_sse2_unaligned+1435>   movdqu %xmm0,(%rdi)
0x7ffff7acf50f <__strcpy_sse2_unaligned+1439>   mov    %rdx,0x10(%rdi)
0x7ffff7acf513 <__strcpy_sse2_unaligned+1443>   mov    %ecx,0x18(%rdi)
0x7ffff7acf516 <__strcpy_sse2_unaligned+1446>   retq
0x7ffff7acf517 <__strcpy_sse2_unaligned+1447>   nopw   0x0(%rax,%rax,1)
0x7ffff7acf520 <__strcpy_sse2_unaligned+1456>   movdqu (%rsi),%xmm0
0x7ffff7acf524 <__strcpy_sse2_unaligned+1460>   movdqu 0xd(%rsi),%xmm2
0x7ffff7acf529 <__strcpy_sse2_unaligned+1465>   movdqu %xmm0,(%rdi)
0x7ffff7acf52d <__strcpy_sse2_unaligned+1469>   movdqu %xmm2,0xd(%rdi)
0x7ffff7acf532 <__strcpy_sse2_unaligned+1474>   retq
0x7ffff7acf532 <__strcpy_sse2_unaligned+1474>   retq
0x7ffff7acf533 <__strcpy_sse2_unaligned+1475>   nopl   (%rax)
0x7ffff7acf536 <__strcpy_sse2_unaligned+1478>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf540 <__strcpy_sse2_unaligned+1488>   movdqu (%rsi),%xmm0
0x7ffff7acf544 <__strcpy_sse2_unaligned+1492>   movdqu 0xe(%rsi),%xmm2
0x7ffff7acf549 <__strcpy_sse2_unaligned+1497>   movdqu %xmm0,(%rdi)
0x7ffff7acf54d <__strcpy_sse2_unaligned+1501>   movdqu %xmm2,0xe(%rdi)
0x7ffff7acf552 <__strcpy_sse2_unaligned+1506>   retq
0x7ffff7acf553 <__strcpy_sse2_unaligned+1507>   nopl   (%rax)
0x7ffff7acf556 <__strcpy_sse2_unaligned+1510>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf560 <__strcpy_sse2_unaligned+1520>   movdqu (%rsi),%xmm0
0x7ffff7acf564 <__strcpy_sse2_unaligned+1524>   movdqu 0xf(%rsi),%xmm2
0x7ffff7acf569 <__strcpy_sse2_unaligned+1529>   movdqu %xmm0,(%rdi)
0x7ffff7acf56d <__strcpy_sse2_unaligned+1533>   movdqu %xmm2,0xf(%rdi)
0x7ffff7acf572 <__strcpy_sse2_unaligned+1538>   retq
0x7ffff7acf573 <__strcpy_sse2_unaligned+1539>   nopl   (%rax)
0x7ffff7acf576 <__strcpy_sse2_unaligned+1542>   nopw   %cs:0x0(%rax,%rax,1)
0x7ffff7acf580 <__strcpy_sse2_unaligned+1552>   movdqu (%rsi),%xmm0
0x7ffff7acf584 <__strcpy_sse2_unaligned+1556>   movdqu 0x10(%rsi),%xmm2
0x7ffff7acf589 <__strcpy_sse2_unaligned+1561>   movdqu %xmm0,(%rdi)
0x7ffff7acf58d <__strcpy_sse2_unaligned+1565>   movdqu %xmm2,0x10(%rdi)
0x7ffff7acf592 <__strcpy_sse2_unaligned+1570>   retq

Tu peux le décortiquer ou accepter le TGCM.

Edit: le premier saut se fait sur l'alignement, ça peut déjà expliquer quelques différences étranges entre tes cas tests.

**Tramb** · 03/04/2017, 19h47

Envoyé par William Vaurien

Je crois que je suis frustré de ne pas compendre et de me rendre compte en même temps que pour comprendre il me faudrait apprendre et comprendre des choses dont finalement je n'ai pas vraiment utilité (à la fin cette appli c'est un pauvre CRUD et des batch de calcul).
En fait TGCM me va bien finalement

mais c'est un peu inquiétant de voir que les bases sont un peu foireuse...

Le truc, c'est que c'est impossible de tout apprendre (et de tout expliquer) en une passe, donc le plus important, c'est de comprendre l'enjeu du undefined behaviour : c'est pas une coquetterie de l'éviter, c'est pour être future-proof et portable

Envoyé par William Vaurien

Valgrind ou address-sanitizer ça marcherait sur un projet avec Makefile merdique et pre-processeur violent (proc-c) ?

Valgrind il marche sur le binaire résultant donc aucun souci.
Et pour l'address sanitizer, ça peut s'adapter à ton Makefile sans trop de souci, normalement. Ça reste plus compliqué à mettre en place que valgrind mais ça te donnera de meilleures perfs et un meilleur reporting d'erreur.
Vue votre base de code vétuste/bancale, tu vas sans doute trouver plein de bugs et passer pour une rockstar dans ton équipe

**William Vaurien** · 03/04/2017, 22h29

Heureusement ils avaient déjà remplacer le strcpy dans 99% des cas pour utiliser une méthode 'maison' qui ne génère pas d'entropie.
Clairement j'ai accepté l'enjeu du 'undefined behaviour'. J'ai l'habitude de ce genre de merde en Java avec certains trucs moisis (hello SimpleDateFormat), mais là je trouvais rageant de pas du tout comprendre...

@Cwningen merci pour l'assembleur

En effet ça à l'air plutôt balaise pour un truc qui est censé faire juste 'while ((*dest++ = *src++) != '\0');'
Donc le compilo génère tout ce tas de bordel à partir de cette pauvre ligne ? Je crois bien me rappeler maintenant pourquoi j'était si content de passer au Java à l'IUT après avoir mangé du C et ses coredump...

Au bureau j'ai déjà atteint le rang de demi-dieu avec les warnings de base

et là je viens de leur montrer le debugger de Netbeans en remote, c'est trop la fête

Je vais essayer de mettre en place ces outils pour voir.

Je vous dois bien une mousse

**Tramb** · 03/04/2017, 22h43

Envoyé par William Vaurien

@Cwningen merci pour l'assembleur

En effet ça à l'air plutôt balaise pour un truc qui est censé faire juste 'while ((*dest++ = *src++) != '\0');'
Donc le compilo génère tout ce tas de bordel à partir de cette pauvre ligne ? Je crois bien me rappeler maintenant pourquoi j'était si content de passer au Java à l'IUT après avoir mangé du C et ses coredump...

Nope c'est codé à la main en asm, ce genre de fonctions, dans 99% des toolchains.
Ex: https://github.com/jeremie-koenig/gl.../strcpy-sse2.S

Après le meilleur strcpy, c'est bien entendu memcpy

Il faut éviter les chaînes à 0 terminal quand on veut de la perf.

**Robix66** · 03/04/2017, 22h57

Il y a un admin TFS dans l'assistance ?

**Cwningen** · 03/04/2017, 23h11

J'avais la flemme de chercher le code source, j'ai pris mon gdb pour avoir l'assembleur. De toute façon, c'est pas beaucoup plus commenté, à part les sauts qui ont des noms.

J'ai quand même regardé un peu plus par curiosité, c'est assez intéressant comme implémentation : il y a à la fois la copie et la recherche du zéro regroupées à l'aide de registres 128 bits (16 octets) et un déroulement de boucle par paquets de 4. Pour la recherche du zéro (la grosse difficulté par rapport au memcpy), je découvre qu'il y a des instructions magiques qui font presque tout (comparaison octets à octets dans les registres 128 bits, copie des bits les plus significatifs de chaque octet dans un registre 16 bits, puis bit scan ou test), pour la boucle déroulée il y a aussi une réduction avec l'opérateur minimum octet par octet entre les quatre registres 128 bits.

**William Vaurien** · 03/04/2017, 23h35

Du coup les sources de string.c, elles sont là pour faire de la figuration ???

Discussion: Le topic de la programmation, string, chaînes, cuir et compagnie

Outils de la discussion

Règles de messages