Mir ist aufgefallen, dass es keine solche Frage gibt, also hier ist es:

Haben Sie allgemeine Tipps zum Golfen im Maschinencode? Wenn der Tipp nur für eine bestimmte Umgebung oder Anrufkonvention gilt, geben Sie dies bitte in Ihrer Antwort an.

Bitte nur einen Tipp pro Antwort (siehe hier ).

mov-immediate ist teuer für Konstanten

Das mag offensichtlich sein, aber ich werde es trotzdem hier platzieren. Im Allgemeinen lohnt es sich, über die Darstellung einer Zahl auf Bitebene nachzudenken, wenn Sie einen Wert initialisieren müssen.

Initialisierung eaxmit 0:

b8 00 00 00 00          mov    $0x0,%eax

sollte gekürzt werden ( aus Gründen der Leistung sowie der Codegröße ) auf

31 c0                   xor    %eax,%eax

Initialisierung eaxmit -1:

b8 ff ff ff ff          mov    $-1,%eax

kann auf gekürzt werden

31 c0                   xor    %eax,%eax
48                      dec    %eax

oder

83 c8 ff                or     $-1,%eax

Im Allgemeinen kann jeder vorzeichenerweiterte 8-Bit-Wert in 3 Bytes mit push -12(2 Bytes) / pop %eax(1 Byte) erstellt werden. Dies funktioniert sogar für 64-Bit-Register ohne zusätzliches REX-Präfix. push/ popdefault Operandengröße = 64.

6a f3                   pushq  $0xfffffffffffffff3
5d                      pop    %rbp

Oder wenn Sie eine bekannte Konstante in einem Register haben, können Sie mit lea 123(%eax), %ecx(3 Byte) eine weitere Konstante in der Nähe erstellen . Dies ist praktisch, wenn Sie ein Nullregister und eine Konstante benötigen . xor-zero (2 Bytes) + lea-disp8(3 Bytes).

31 c0                   xor    %eax,%eax
8d 48 0c                lea    0xc(%eax),%ecx

Siehe auch Alle Bits im CPU-Register effizient auf 1 setzen

In vielen Fällen sind akkumulatorbasierte Befehle (dh Befehle, die (R|E)AXals Zieloperanden dienen) 1 Byte kürzer als allgemeine Befehle. Siehe diese Frage auf StackOverflow.

Wählen Sie Ihre Anrufkonvention, um die Argumente an die von Ihnen gewünschte Stelle zu setzen.

Die Sprache Ihrer Antwort ist asm (tatsächlich Maschinencode). Behandeln Sie sie daher als Teil eines in asm geschriebenen Programms, nicht in C-compiled-for-x86. Ihre Funktion muss mit keiner Standard-Aufrufkonvention von C aus leicht aufrufbar sein. Das ist aber ein schöner Bonus, wenn es Sie keine zusätzlichen Bytes kostet.

In einem reinen asm-Programm ist es normal, dass einige Hilfsfunktionen eine für sie und ihren Aufrufer geeignete Aufrufkonvention verwenden. Solche Funktionen dokumentieren ihre Aufrufkonvention (Ein- / Ausgänge / Clobber) mit Kommentaren.

Im wirklichen Leben tendieren sogar ASM-Programme (glaube ich) dazu, konsistente Aufrufkonventionen für die meisten Funktionen zu verwenden (insbesondere für verschiedene Quelldateien), aber jede wichtige Funktion könnte etwas Besonderes bewirken. Beim Code-Golf optimieren Sie den Mist aus einer einzigen Funktion heraus, es ist also offensichtlich wichtig / besonders.

Um Ihre Funktion in einem C-Programm zu testen, können Sie einen Wrapper schreiben , der args an die richtigen Stellen setzt, alle zusätzlichen Register speichert / wiederherstellt, die Sie überladen, und den Rückgabewert dort ablegen, e/raxwo er noch nicht vorhanden war.

Die Grenzen des Zumutbaren: Alles, was dem Anrufer keine unzumutbare Last auferlegt:

• ESP / RSP muss aufrufsicher sein. andere Ganzzahlregs sind Freiwild. (RBP und RBX werden in der Regel in normalen Konventionen für Anrufe beibehalten , aber Sie können beide blockieren.)
• Jedes Argument in einem beliebigen Register (außer RSP) ist sinnvoll, jedoch nicht die Aufforderung an den Aufrufer, dasselbe Argument in mehrere Register zu kopieren.

• Es ist normal, dass DF (Zeichenfolgenrichtungsflag für lods/ stos/ usw.) beim Aufrufen / Zurückrufen (nach oben) frei sein muss. Es wäre in Ordnung, wenn es beim Anrufen / Zurückrufen undefiniert wäre. Es wäre seltsam, wenn es beim Betreten gelöscht oder eingestellt werden müsste, aber bei der Rückkehr geändert werden müsste.

• Die Rückgabe von FP-Werten in x87 st0ist sinnvoll, die Rückgabe st3mit Garbage in einem anderen x87-Register jedoch nicht. Der Aufrufer müsste den x87-Stack aufräumen. Auch die Rückkehr st0mit nicht leeren höheren Stack-Registern wäre fraglich (es sei denn, Sie geben mehrere Werte zurück).

• Ihre Funktion wird mit aufgerufen call, ebenso [rsp]Ihre Absenderadresse. Sie könnencall / retauf x86 vermeiden, indem Sie Linkregister wie lea rbx, [ret_addr]/ verwenden jmp functionund mit zurückkehren jmp rbx, aber das ist nicht "vernünftig". Das ist nicht so effizient wie call / ret, es ist also nichts, was man in echtem Code plausibel finden würde.
• Unbegrenzten Speicher über RSP zu blockieren ist nicht sinnvoll, aber das Blockieren Ihrer Funktionsargumente auf dem Stack ist in normalen Aufrufkonventionen zulässig. x64 Windows benötigt 32 Byte Schattenspeicherplatz über der Rücksprungadresse, während x86-64 System V eine 128 Byte große rote Zone unter RSP anzeigt. (Oder sogar eine viel größere rote Zone, insbesondere in einem eigenständigen Programm, anstatt zu funktionieren.)

Grenzfälle: Schreiben Sie eine Funktion, die eine Sequenz in einem Array erzeugt, wenn die ersten beiden Elemente als Funktionsargumente angegeben werden . Ich habe mich dafür entschieden , dass der Aufrufer den Beginn der Sequenz im Array speichert und nur einen Zeiger auf das Array übergibt. Dies ist definitiv eine Biegung der Anforderungen der Frage. Ich betrachtete die args Einnahme verpackt in xmm0für movlps [rdi], xmm0, die auch eine seltsame Aufrufkonvention wäre.

Rückgabe eines Booleschen Wertes in FLAGS (Bedingungscodes)

OS X-Systemaufrufe führen dies aus ( CF=0bedeutet, dass kein Fehler vorliegt): Wird die Verwendung des Flags-Registers als boolescher Rückgabewert als schlechte Praxis angesehen? .

Jede Bedingung, die mit einem JCC überprüft werden kann, ist völlig zumutbar, insbesondere wenn Sie eine Bedingung auswählen können, die für das Problem semantisch relevant ist. (Zum Beispiel kann eine Vergleichsfunktion Flags setzen, jnedie verwendet werden, wenn sie nicht gleich sind.)

Es ist erforderlich, dass schmale Args (wie a char) ein Vorzeichen oder eine Null sind, die auf 32 oder 64 Bit erweitert ist.

Das ist nicht unvernünftig. Die Verwendung von movzxoder movsx zur Vermeidung von Teilregister-Verlangsamungen ist in modernen x86-Umgebungen normal. Tatsächlich erstellt clang / LLVM bereits Code, der von einer undokumentierten Erweiterung der x86-64-System-V-Aufrufkonvention abhängt: Argumente, die schmaler als 32 Bit sind, werden vom Aufrufer mit Vorzeichen oder Null auf 32 Bit erweitert .

Sie können die Erweiterung auf 64 Bit schriftlich uint64_toder int64_tin Ihrem Prototyp dokumentieren / beschreiben, wenn Sie möchten. Sie können also einen loopBefehl verwenden, der die gesamten 64 Bits von RCX verwendet, es sei denn, Sie verwenden ein Adressgrößenpräfix, um die Größe auf 32-Bit-ECX herabzusetzen (ja, tatsächlich, Adressgröße nicht Operandengröße).

Beachten Sie, dass longes sich beim Windows 64-Bit-ABI und beim Linux x32-ABI nur um einen 32-Bit-Typ handelt . uint64_tist eindeutig und kürzer als unsigned long long.

Bestehende Anrufkonventionen:

• Windows 32-Bit __fastcall, bereits von einer anderen Antwort vorgeschlagen : Integer-Argumente in ecxund edx.

• x86-64-System V : Übergibt viele Argumente in Registern und verfügt über viele Call-Clobbered-Register, die Sie ohne REX-Präfixe verwenden können. Noch wichtiger ist, dass Compiler memcpyso rep movsbeinfach inline oder memset arbeiten können: Die ersten 6 Integer / Pointer-Args werden in RDI, RSI, RDX, RCX, R8, R9 übergeben.

  Wenn Ihre Funktion lodsd/ stosdin einer Schleife verwendet, die rcx(mit der loopAnweisung) Zeiten ausführt, können Sie sagen, dass "von C wie int foo(int *rdi, const int *rsi, int dummy, uint64_t len)mit der x86-64-System V-Aufrufkonvention aufrufbar " ist. Beispiel: Chromakey .

• 32-Bit-GCC regparm: Ganzzahlige Argumente in EAX , ECX, EDX, Rückgabe in EAX (oder EDX: EAX). Das erste Argument im selben Register wie der Rückgabewert zu haben, ermöglicht einige Optimierungen, wie in diesem Fall mit einem Beispielaufrufer und einem Prototyp mit einem Funktionsattribut . Und natürlich ist AL / EAX speziell für einige Anweisungen.

• Das Linux x32-ABI verwendet im Langmodus 32-Bit-Zeiger, sodass Sie beim Ändern eines Zeigers ein REX-Präfix speichern können ( Beispielanwendungsfall ). Sie können weiterhin die 64-Bit-Adressgröße verwenden, es sei denn, Sie haben eine negative 32-Bit-Ganzzahl mit der Erweiterung Null in einem Register (dies wäre in diesem Fall ein großer vorzeichenloser Wert [rdi + rdx]).

  Beachten Sie, dass push rsp/ pop rax2 Bytes entspricht mov rax,rsp, sodass Sie weiterhin vollständige 64-Bit-Register in 2 Bytes kopieren können .

Verwenden Sie spezielle Kurzformkodierungen für AL / AX / EAX sowie andere Kurzformen und Einzelbyte-Anweisungen

Bei den Beispielen wird der 32/64-Bit-Modus angenommen, bei dem die Standardoperandengröße 32 Bit beträgt. Ein Präfix mit Operandengröße ändert den Befehl in AX anstelle von EAX (oder umgekehrt im 16-Bit-Modus).

• inc/decein Register (außer 8-Bit): inc eax/ dec ebp. (Nicht x86-64: Die 0x4xOpcode-Bytes wurden als REX-Präfixe verwendet. Dies inc r/m32ist die einzige Codierung.)

  8-Bit - inc bl2 Byte, unter Verwendung des inc r/m8opcode + ModR / M - Operanden kodieren . So verwenden inc ebxzu erhöhen bl, wenn es sicher ist. (zB wenn Sie das ZF-Ergebnis nicht benötigen, wenn die oberen Bytes möglicherweise nicht Null sind).

• scasd: e/rdi+=4, erfordert, dass das Register auf einen lesbaren Speicher zeigt. Manchmal nützlich, auch wenn Sie sich nicht für das FLAGS-Ergebnis interessieren (wie cmp eax,[rdi]/ rdi+=4). Und im 64-Bit-Modus scasbkann als 1-Byte arbeiteninc rdi , wenn lodsb oder stosb nicht nützlich sind.

• xchg eax, r32: Hier wird von 0x90 NOP kam: xchg eax,eax. Beispiel: 3 Register mit zwei xchgBefehlen in einer cdq/ idiv-Schleife für GCD in 8 Bytes neu anordnen, wobei die meisten Befehle Einzelbytes sind, einschließlich eines Missbrauchs von inc ecx/ loopanstelle von test ecx,ecx/jnz

• cdq: Vorzeichenerweiterung von EAX in EDX: EAX, dh Kopieren des hohen EAX-Bits in alle EDX-Bits. Um eine Null mit bekannten nicht-negativen Werten zu erstellen, oder um eine 0 / -1 zu erhalten, mit der / sub oder maskiert wird. x86-Geschichtsstunde: cltqvs.movslq , und auch AT & T vs. Intel-Mnemonics für diese und die verwandten cdqe.

• lodsb / d : like mov eax, [rsi]/ rsi += 4without clobbering flags. (Angenommen, DF ist klar, welche Standardaufrufkonventionen für die Funktionseingabe erforderlich sind.) Außerdem stosb / d, manchmal scas und seltener movs / cmps.

• push/ pop reg. ZB im 64-Bit-Modus ist push rsp/ pop rdi2 Byte, mov rdi, rspbenötigt aber ein REX-Präfix und ist 3 Byte.

xlatbexistiert, ist aber selten nützlich. Eine große Nachschlagetabelle sollte vermieden werden. Ich habe auch noch nie eine Verwendung für AAA / DAA oder andere gepackte BCD- oder 2-ASCII-Ziffern-Anweisungen gefunden.

1 Byte lahf/ sahfsind selten nützlich. Sie könnten lahf / and ah, 1als Alternative zu setc ah, aber es ist in der Regel nicht nützlich.

Und speziell für CF gibt sbb eax,eaxes eine 0 / -1 oder sogar eine nicht dokumentierte, aber universell unterstützte 1-Byte-Größe salc(setze AL von Carry), die effektiv keine sbb al,alAuswirkung auf Flags hat. (In x86-64 entfernt). Ich habe SALC in der User Appreciation Challenge # 1 verwendet: Dennis ♦ .

1-Byte cmc/ clc/ stc(Flip ("Komplement"), Clear oder Set CF) sind selten nützlich, obwohl ich eine Verwendung für einecmc Addition mit erweiterter Genauigkeit mit Basis 10 ^ 9-Chunks gefunden habe. Um CF bedingungslos zu setzen / löschen, lassen Sie dies normalerweise als Teil eines anderen Befehls geschehen, z. B. xor eax,eaxCF und EAX löschen. Es gibt keine entsprechenden Anweisungen für andere Bedingungsflags, nur DF (Zeichenfolgenrichtung) und IF (Interrupts). Das Carry Flag ist speziell für viele Anweisungen. Shifts setzen es, adc al, 0können es in 2 Byte zu AL hinzufügen, und ich erwähnte zuvor die undokumentierte SALC.

std/ cldScheinen selten wert . Insbesondere im 32-Bit-Code ist es besser, nur deceinen Zeiger und einen movoder einen Speicherquellenoperanden für einen ALU-Befehl zu verwenden, anstatt DF so zu setzen lodsb/ stosbnach unten statt nach oben zu gehen. Normalerweise , wenn Sie nach unten überhaupt brauchen, haben Sie noch einen anderen Zeiger geht nach oben, so dass Sie mehr brauchen würden als eine stdund cldin der gesamten Funktion Verwendung lods/ stosfür beide. Verwenden Sie stattdessen einfach die Zeichenfolgenanweisungen für die Aufwärtsrichtung. (Die Standardaufrufkonventionen garantieren DF = 0 bei der Funktionseingabe, sodass Sie davon ausgehen können, dass dies ohne Verwendung von kostenlos ist cld.)

8086 history: Warum gibt es diese Kodierungen?

Im Original 8086 war AX ganz Besonderes: Anweisungen wie lodsb/ stosb, cbw, mul/ divund andere implizit verwenden. Das ist natürlich immer noch der Fall; Der aktuelle x86 hat keinen der 8086-Opcodes gelöscht (zumindest keinen der offiziell dokumentierten). Spätere CPUs fügten neue Anweisungen hinzu, die bessere / effizientere Möglichkeiten boten, Dinge zu erledigen, ohne sie zuerst in AX zu kopieren oder zu tauschen. (Oder zu EAX im 32-Bit-Modus.)

Zum Beispiel fehlten bei 8086 spätere Zusätze wie movsx/ movzxzum Laden oder Verschieben + Vorzeichen-Erweitern oder 2- und 3-Operanden imul cx, bx, 1234, die kein High-Half-Ergebnis liefern und keine impliziten Operanden haben.

Auch 8086 Haupt Engpass war Befehl holen, so die Optimierung für die Code-Größe wichtig war für die Leistung damals . Der ISA-Designer von 8086 (Stephen Morse) hat viel Opcode -Code für Sonderfälle für AX / AL ausgegeben, einschließlich spezieller (E) AX / AL-Ziel-Opcodes für alle grundlegenden ALU-Anweisungen von src , nur opcode + instant ohne ModR / M-Byte. 2 Byte add/sub/and/or/xor/cmp/test/... AL,imm8oder AX,imm16oder (im 32-Bit-Modus) EAX,imm32.

Es gibt jedoch keinen Sonderfall für EAX,imm8, sodass die reguläre ModR / M-Codierung add eax,4kürzer ist.

Es wird davon ausgegangen, dass Sie einige Daten in AX / AL bearbeiten möchten. Daher sollten Sie ein Register mit AX tauschen, vielleicht sogar öfter, als ein Register mit AX zu kopierenmov .

Alles, was mit der 8086-Befehlskodierung zu tun hat, unterstützt dieses Paradigma, angefangen von Befehlen lodsb/wüber alle Sonderfallkodierungen für Direktbefehle mit EAX bis hin zur impliziten Verwendung auch für Multiplikationen / Divisionen.

Lass dich nicht mitreißen; Es ist nicht automatisch ein Gewinn, alles zu EAX zu tauschen, besonders wenn Sie Sofort mit 32-Bit-Registern anstelle von 8-Bit verwenden müssen. Oder wenn Sie Operationen mit mehreren Variablen in Registern gleichzeitig verschachteln müssen. Oder wenn Sie Anweisungen mit 2 Registern verwenden, nicht sofort.

Aber denken Sie immer daran: Tue ich irgendetwas, das in EAX / AL kürzer wäre? Kann ich neu anordnen, damit ich dies in AL habe, oder nutze ich derzeit AL besser mit dem, wofür ich es bereits benutze?

Mischen Sie 8-Bit- und 32-Bit-Operationen frei, um die Vorteile zu nutzen, wann immer dies sicher ist (Sie müssen nicht in das vollständige Register oder was auch immer übertragen).

Verwenden Sie fastcallKonventionen

Die x86-Plattform kennt viele Aufrufkonventionen . Sie sollten diejenigen verwenden, die Parameter in Registern übergeben. Auf x86_64 werden die ersten Parameter ohnehin in Registern übergeben, also kein Problem. Auf 32-Bit-Plattformen cdeclübergibt die Standardaufrufkonvention ( ) Parameter im Stapel, was für das Golfen ungeeignet ist - für den Zugriff auf Parameter im Stapel sind lange Anweisungen erforderlich.

Bei Verwendung fastcallauf 32-Bit-Plattformen werden in der Regel 2 erste Parameter in ecxund übergeben edx. Wenn Ihre Funktion 3 Parameter hat, können Sie sie auf einer 64-Bit-Plattform implementieren.

C-Funktionsprototypen für fastcallKonventionen (entnommen aus dieser Beispielantwort ):

extern int __fastcall SwapParity(int value);                 // MSVC
extern int __attribute__((fastcall)) SwapParity(int value);  // GNU   

Subtrahiere -128 anstatt 128 zu addieren

0100 81C38000      ADD     BX,0080
0104 83EB80        SUB     BX,-80

Addiere -128 anstatt 128 zu subtrahieren

Erstelle 3 Nullen mit mul(dann inc/ decum +1 / -1 sowie Null zu bekommen)

Sie können eax und edx auf Null setzen, indem Sie in einem dritten Register mit Null multiplizieren.

xor   ebx, ebx      ; 2B  ebx = 0
mul   ebx           ; 2B  eax=edx = 0

inc   ebx           ; 1B  ebx=1

Dies führt dazu, dass EAX, EDX und EBX in nur vier Bytes Null sind. Sie können EAX und EDX in drei Bytes auf Null setzen:

xor eax, eax
cdq

Von diesem Ausgangspunkt aus können Sie jedoch kein Register mit der dritten Null in einem weiteren Byte oder ein Register mit +1 oder -1 in weiteren 2 Bytes erhalten. Verwenden Sie stattdessen die Mul-Technik.

Anwendungsbeispiel: Verketten der Fibonacci-Zahlen in Binärform .

Beachten Sie, dass LOOPECX nach Beendigung einer Schleife Null ist und zum Nullen von EDX und EAX verwendet werden kann. Sie müssen nicht immer die erste Null mit erstellen xor.

CPU-Register und Flags befinden sich in bekannten Startzuständen

Wir können davon ausgehen, dass sich die CPU in einem bekannten und dokumentierten Standardzustand befindet, der auf der Plattform und dem Betriebssystem basiert.

Beispielsweise:

DOS http://www.fysnet.net/yourhelp.htm

Linux x86 ELF http://asm.sourceforge.net/articles/startup.html

Verwenden Sie zum Addieren oder Subtrahieren von 1 das eine Byte incoder die decAnweisungen, die kleiner sind als die Anweisungen zum Addieren und Subtrahieren von Mehrbytes.

lea für Mathe

Dies ist wahrscheinlich eines der ersten Dinge, die man über x86 erfährt, aber ich lasse es hier als Erinnerung. leakann verwendet werden, um eine Multiplikation mit 2, 3, 4, 5, 8 oder 9 durchzuführen und einen Versatz hinzuzufügen.

So berechnen Sie beispielsweise ebx = 9*eax + 3in einem Befehl (im 32-Bit-Modus):

8d 5c c0 03             lea    0x3(%eax,%eax,8),%ebx

Hier ist es ohne Versatz:

8d 1c c0                lea    (%eax,%eax,8),%ebx

Wow! leaKann natürlich auch verwendet werden, um mathematische Aufgaben ebx = edx + 8*eax + 3zur Berechnung der Array-Indizierung auszuführen.

Die Schleifen- und Zeichenkettenbefehle sind kleiner als alternative Befehlssequenzen. Am nützlichsten ist, loop <label>welche kleiner als die beiden Befehlssequenzen dec ECXund jnz <label>und lodsbkleiner als mov al,[esi]und ist inc si.

mov small wird bei Bedarf sofort in die unteren Register verschoben

Wenn Sie bereits wissen, dass die oberen Bits eines Registers 0 sind, können Sie einen kürzeren Befehl verwenden, um ein unmittelbares Bit in die unteren Register zu verschieben.

b8 0a 00 00 00          mov    $0xa,%eax

gegen

b0 0a                   mov    $0xa,%al

Verwenden Sie push/ popfür imm8, um die oberen Bits auf Null zu setzen

Dank an Peter Cordes. xor/ movist 4 Bytes, aber push/ popist nur 3!

6a 0a                   push   $0xa
58                      pop    %eax

Die FLAGS werden nach vielen Anweisungen gesetzt

Nach vielen arithmetischen Anweisungen werden das Carry Flag (ohne Vorzeichen) und das Overflow Flag (mit Vorzeichen) automatisch gesetzt ( weitere Informationen ). Das Vorzeichen-Flag und das Null-Flag werden nach vielen arithmetischen und logischen Operationen gesetzt. Dies kann zur bedingten Verzweigung verwendet werden.

Beispiel:

d1 f8                   sar    %eax

ZF wird durch diese Anweisung gesetzt, sodass wir es zur bedingten Verzweigung verwenden können.

Verwenden Sie do-while-Schleifen anstelle von while-Schleifen

Dies ist nicht x86-spezifisch, aber ein allgemein verwendbarer Einsteigertipp. Wenn Sie wissen, dass eine while-Schleife mindestens einmal ausgeführt wird, speichert das Umschreiben der Schleife als do-while-Schleife mit der Prüfung der Schleifenbedingung am Ende häufig einen 2-Byte-Sprungbefehl. In besonderen Fällen können Sie sogar verwenden loop.

Verwenden Sie die gewünschten Aufrufkonventionen

System V x86 verwendet den Stack und System V x86-64 Anwendungen rdi, rsi, rdx, rcxusw. für Eingabeparameter und raxals Rückgabewert, aber es ist durchaus sinnvoll Ihre eigene Aufrufkonvention zu verwenden. __fastcall verwendet ecxund edxals Eingabeparameter, und andere Compiler / Betriebssysteme verwenden ihre eigenen Konventionen . Verwenden Sie den Stapel und alle Register als Ein- / Ausgabe, wenn Sie dies möchten.

Beispiel: Der repetitive Bytezähler unter Verwendung einer cleveren Aufrufkonvention für eine 1-Byte-Lösung.

Meta: Schreiben Eingang zu den Registern , Schreiben Ausgang Register

Weitere Quellen: Anmerkungen von Agner Fog zu Anrufkonventionen

Verwende bedingte Züge CMOVccund MengenSETcc

Dies ist eher eine Erinnerung an mich selbst, aber auf den Prozessoren P6 (Pentium Pro) oder neuer gibt es Anweisungen für bedingte Sätze und Anweisungen für bedingte Verschiebungen. Es gibt viele Anweisungen, die auf einem oder mehreren in EFLAGS gesetzten Flags basieren.

Sparen Sie jmpBytes, indem Sie in if / then statt if / then / else anordnen

Dies ist sicherlich sehr einfach, dachte nur, ich würde dies als etwas zu denken, wenn Sie Golf spielen. Betrachten Sie als Beispiel den folgenden einfachen Code zum Dekodieren eines hexadezimalen Ziffernzeichens:

    cmp $'A', %al
    jae .Lletter
    sub $'0', %al
    jmp .Lprocess
.Lletter:
    sub $('A'-10), %al
.Lprocess:
    movzbl %al, %eax
    ...

Dies kann um zwei Bytes verkürzt werden, indem ein "then" -Fall in einen "else" -Fall umgewandelt wird:

    cmp $'A', %al
    jb .digit
    sub $('A'-'0'-10), %eax
.digit:
    sub $'0', %eax
    movzbl %al, %eax
    ...

Sie können sequentielle Objekte aus dem Stapel abrufen, indem Sie esi auf esp setzen und eine Sequenz von lodsd / xchg reg, eax ausführen.

Für Codegolf und ASM: Verwenden Sie Anweisungen, verwenden Sie nur Register, drücken Sie Pop, minimieren Sie den Registerspeicher oder speichern Sie sofort

Verwenden Sie zum Kopieren eines 64-Bit-Registers push rcx; pop rdxanstelle eines 3-Byte mov.
Die Standardoperandengröße für Push / Pop ist 64-Bit, ohne dass ein REX-Präfix erforderlich ist.

  51                      push   rcx
  5a                      pop    rdx
                vs.
  48 89 ca                mov    rdx,rcx

(Ein Präfix mit Operandengröße kann die Push / Pop-Größe auf 16-Bit überschreiben, aber die 32-Bit-Push / Pop-Operandengröße kann im 64-Bit-Modus auch mit REX.W = 0 nicht codiert werden .)

Wenn eines oder beide Register r8.. sind r15, verwenden Sie, movda Push und / oder Pop ein REX-Präfix benötigen. Schlimmstenfalls verliert dies tatsächlich, wenn beide REX-Präfixe benötigen. Offensichtlich sollten Sie im Codegolf normalerweise ohnehin r8..r15 meiden.

Sie können Ihre Quelle während der Entwicklung mit diesem NASM-Makro besser lesbar halten . Denken Sie daran, dass die 8 Bytes unterhalb von RSP angezeigt werden. (In der roten Zone in x86-64 System V). Aber unter normalen Bedingungen ist es ein Ersatz für 64-Bit mov r64,r64odermov r64, -128..127

    ; mov  %1, %2       ; use this macro to copy 64-bit registers in 2 bytes (no REX prefix)
%macro MOVE 2
    push  %2
    pop   %1
%endmacro

Beispiele:

   MOVE  rax, rsi            ; 2 bytes  (push + pop)
   MOVE  rbp, rdx            ; 2 bytes  (push + pop)
   mov   ecx, edi            ; 2 bytes.  32-bit operand size doesn't need REX prefixes

   MOVE  r8, r10             ; 4 bytes, don't use
   mov   r8, r10             ; 3 bytes, REX prefix has W=1 and the bits for reg and r/m being high

   xchg  eax, edi            ; 1 byte  (special xchg-with-accumulator opcodes)
   xchg  rax, rdi            ; 2 bytes (REX.W + that)

   xchg  ecx, edx            ; 2 bytes (normal xchg + modrm)
   xchg  rcx, rdx            ; 3 bytes (normal REX + xchg + modrm)

Der xchgTeil des Beispiels ist, weil Sie manchmal einen Wert in EAX oder RAX erhalten müssen und es nicht wichtig ist, die alte Kopie beizubehalten. push / pop hilft dir aber nicht beim tauschen.