So verschieben Sie 128-Bit-Immediate in XMM-Register

Gibt es schon eine Frage auf diese, aber es war geschlossen als "mehrdeutig" also, ich bin eine neue zu öffnen - ich habe die Antwort gefunden, vielleicht hilft es anderen auch.

Die Frage ist: wie schreibt man eine Folge von Assembler-code zur Initialisierung eines XMM-Registers mit einer 128-bit-immediate (Konstante) Wert?

InformationsquelleAutor der Frage Virgil | 2011-07-11

15

Wollte nur hinzufügen, dass man Lesen kann über die verschiedenen Konstanten mit Montage in Agner Fog ' s manual Optimierung von Unterprogrammen in Assemblerdie Generierung von Konstanten, Abschnitt 13.4, Seite 121.

InformationsquelleAutor der Antwort Norbert P.
10

Können Sie es so machen, mit nur einem movaps Anleitung:
```
.section .rodata    # put your constants in the read-only data section
.p2align 4          # align to 16 = 1<<4
LC0:
        .long   1082130432
        .long   1077936128
        .long   1073741824
        .long   1065353216

.text
foo:
        movaps  LC0(%rip), %xmm0
```
Laden mit laden der Daten ist in der Regel vorzuziehen Einbettung in den Unterricht stream, besonders weil, wie viele Anweisungen es braucht. Das sind mehrere zusätzliche uops für die CPU zum ausführen, für eine beliebige Konstante, kann nicht erzeugt werden von allen-diejenigen, die mit ein paar Verschiebungen.

Wenn es einfacher ist, Sie können die Konstanten direkt vor oder nach einer Funktion, die Sie jit-kompilieren, statt in einem separaten Abschnitt. Aber da die CPUs aufgeteilt L1d /L1i-caches und TLBs, ist es im Allgemeinen am besten zu Konstanten Gruppe zusammen getrennt von Anweisungen.

Wenn beide Hälften Ihre Konstanten sind die gleichen, Sie können broadcast-laden Sie es mit SSE3

movddup (m64), %xmm0.

InformationsquelleAutor der Antwort Paul R
6

Gibt es mehrere Möglichkeiten, von Einbettung Konstanten in der instruction stream:
1. durch die Verwendung von immediate-Operanden
2. durch das laden von PC-relative Adressen
So, während es gibt keine Möglichkeit zu tun, eine eine sofortige Belastung in eine XMM registrieren, ist es möglich, eine PC-relative Last (in 64bit) aus einem gespeicherten Wert "rechts neben", wo der code ausgeführt wird. Das schafft so etwas wie:
```
.align 4
.val:
    .long   0x12345678
    .long   0x9abcdef0
    .long   0xfedbca98
    .long   0x76543210
func:
     movdqa .val(%rip), %xmm0
```
Beim zerlegen:
```
0000000000000000 : 
0: 78 56 34 12 f0 de bc 9a 
8: ca 98 db fe 10 32 54 76 

0000000000000010 : 
10: 66 0f 6f 05 e8 ff ff movdqa -0x18(%rip),%xmm0 # 0 
```
ist äußerst kompakte23 Byte.

Andere Optionen zu konstruieren, der Wert auf den stack legen und wieder laden Sie es von dort. Im 32-bit-x86, wo Sie nicht %rip-relative-memory-access, kann man immer noch tun, dass in 24 Bytes (vorausgesetzt der stackpointer ist ausgerichtet auf Eintrag; sonst, unaligned load erforderlich):
```
00000000 : 
0: 68 78 56 34 12 drücken Sie $0x12345678 
5: 68 f0 de bc 9a push - $0x9abcdef0 
a: 68 98 ca db fe push - $0xfedbca98 
f: 68 10 32 54 76 push - $0x76543210 
14: 66 0f 6f 04 24 movdqa (%esp),%xmm0
```
Während in 64bit (stackpointer-Ausrichtung an der Funktion Eintrag ist garantiert, da der ABI) ,hatte eine 27 Bytes:
```
0000000000000000 : 
0: 48 b8 f0 de bc 9a 78 56 34 12 movabs $0x123456789abcdef0,%rax 
a: 50 push %rax 
b: 48 b8 10 32 54 76 98 ba dc fe movabs $0xfedcba9876543210,%rax 
15: 50 push %rax 
16: 66 0f 6f 04 24 movdqa (%rsp),%xmm0
```
Wenn Sie vergleichen diese mit den MOVLHPS version, werden Sie feststellen, es ist die längste:
```
0000000000000000 : 
0: 48 b8 f0 de bc 9a 78 56 34 12 movabs $0x123456789abcdef0,%rax 
a: 66 48 0f 6e c0 movq %rax,%xmm0 
f: 48 b8 10 32 54 76 98 ba dc fe movabs $0xfedcba9876543210,%rax 
19: 66 48 0f 6e c8 movq %rax,%xmm1 
1e: 0f 16 c1 movlhps %xmm1,%xmm0
```
33 Bytes.

Der andere Vorteil von dem laden direkt aus dem instruction memory ist, dass die movdqa hängt nicht von irgendetwas vorherigen. Wahrscheinlich die erste version, wie @Paul R, ist der Schnellste, den man bekommen kann.

InformationsquelleAutor der Antwort FrankH.

Als einer der 10000 Möglichkeiten, es zu tun, verwenden Sie SSE4.1 pinsrq

mov    rax, first half
movq   xmm0, rax      ; better than pinsrq xmm0,rax,0 for performance and code-size

mov    rax, second half
pinsrq xmm0, rax, 1

InformationsquelleAutor der Antwort Pierre

5

Die beste Lösung (vor allem, wenn Sie halten wollen, SSE2, d.h. Sie zu vermeiden, mit AVX) zum initialisieren von zwei Registern (sagen, xmm0 und xmm1) mit den beiden 64-bit-Hälften von Ihrem unmittelbaren Wert, tun MOVLHPS xmm0,xmm1
Zur Initialisierung eines 64-bit-Wert, die einfachste Lösung ist die Verwendung eines general-purpose-register (sagen, AX), und verwenden Sie dann MOVQ übertragen Ihren Wert auf die XMM-register.
Also die Reihenfolge wäre in etwa so:
```
MOV RAX, <first_half>
MOVQ XMM0, RAX
MOV RAX, <second_half>
MOVQ XMM1, RAX
MOVLHPS XMM0,XMM1
```
InformationsquelleAutor der Antwort Virgil

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.