相关：Code-golf打印Fib的前1000位（10**9）：my x86 asm answer使用扩展精度adc循环，并将二进制转换为字符串。内环针对速度进行了优化，其他部分针对尺寸进行了优化。
计算Fibonacci sequence只需要保持两个状态：当前和前一个元素。我不知道你想用fibInitial做什么，除了计算它的长度。这不是perl，你在这里做for $n (0..5)。
我知道你们刚刚开始学习asm，但我还是要谈谈性能。学习asm without knowing what's fast and what's not的理由并不多。如果你不需要性能，让编译器从C源代码为你创建asm。另请参阅https://stackoverflow.com/tags/x86/info上的其他链接
使用状态寄存器可以简化在计算a[1]时需要查看a[-1]的问题。您从curr=1、prev=0开始，然后从a[0] = curr开始。要生成Fibonacci numbers的“现代”零开始序列，请从curr=0，prev=1开始。
幸运的是，我最近正在考虑一个有效的Fibonacci循环，所以我花了时间写了一个完整的函数。请参阅下面的展开和矢量化版本（保存存储指令，但即使在32位CPU编译时也可以使64位int快速）：

; fib.asm
;void fib(int32_t *dest, uint32_t count);
; not-unrolled version.  See below for a version which avoids all the mov instructions
global fib
fib:
    ; 64bit SysV register-call ABI:
    ; args: rdi: output buffer pointer.  esi: count  (and you can assume the upper32 are zeroed, so using rsi is safe)

    ;; locals:  rsi: endp
    ;; eax: current   edx: prev
    ;; ecx: tmp
    ;; all of these are caller-saved in the SysV ABI, like r8-r11
    ;; so we can use them without push/pop to save/restore them.
    ;; The Windows ABI is different.

    test   esi, esi       ; test a reg against itself instead of cmp esi, 0
    jz     .early_out     ; count == 0.  

    mov    eax, 1         ; current = 1
    xor    edx, edx       ; prev    = 0

    lea    rsi, [rdi + rsi * 4]  ; endp = &out[count];  // loop-end pointer
    ;; lea is very useful for combining add, shift, and non-destructive operation
    ;; this is equivalent to shl rsi, 4  /  add rsi, rdi

align 16
.loop:                    ; do {
    mov    [rdi], eax     ;   *buf = current
    add    rdi, 4         ;   buf++

    lea    ecx, [rax + rdx] ; tmp = curr+prev = next_cur
    mov    edx,  eax      ; prev = curr
    mov    eax,  ecx      ; curr=tmp
 ;; see below for an unrolled version that doesn't need any reg->reg mov instructions

    ; you might think this would be faster:
    ; add  edx, eax    ; but it isn't
    ; xchg eax, edx    ; This is as slow as 3 mov instructions, but we only needed 2 thanks to using lea

    cmp    rdi, rsi       ; } while(buf < endp);
    jb    .loop           ; jump if (rdi BELOW rsi).  unsigned compare
    ;; the LOOP instruction is very slow, avoid it

.early_out:
    ret

另一个循环条件可能是

dec     esi         ; often you'd use ecx for counts, but we had it in esi
    jnz     .loop

AMD CPU可以融合cmp/分支，但不能融合dec/branch。英特尔CPU也可以macro-fusedec/jnz。（或有符号小于零/大于零）。dec/inc不会更新进位标志，所以你不能将它们与上面/下面的无符号ja/jb一起使用。我认为这个想法是，你可以在一个循环中做一个adc（带进位的加法），使用inc/dec作为循环计数器，不干扰进位标志，但使用partial-flags slowdowns make this bad on modern CPUs。
lea ecx, [eax + edx]需要一个额外的字节（地址大小前缀），这就是我使用32位dest和64位地址的原因。（这些是64位模式下lea的默认操作数大小）。对速度没有直接影响，只是通过代码大小间接影响。
另一个循环体可以是：

mov  ecx, eax      ; tmp=curr.  This stays true after every iteration
.loop:

    mov  [rdi], ecx
    add  ecx, edx      ; tmp+=prev  ;; shorter encoding than lea
    mov  edx, eax      ; prev=curr
    mov  eax, ecx      ; curr=tmp

展开循环进行更多的迭代将意味着更少的 Shuffle 。而不是mov指令，您只需跟踪哪个寄存器保存哪个变量。也就是说，你用一种寄存器重命名来处理赋值。

.loop:     ;; on entry:       ; curr:eax  prev:edx
    mov  [rdi], eax             ; store curr
    add  edx, eax             ; curr:edx  prev:eax
.oddentry:
    mov  [rdi + 4], edx         ; store curr
    add  eax, edx             ; curr:eax  prev:edx

    ;; we're back to our starting state, so we can loop
    add  rdi, 8
    cmp  rdi, rsi
    jb   .loop

展开的问题是，您需要清理任何剩余的奇数迭代。2的幂展开因子可以使清理循环稍微容易一些，但是加12并不比加16快。（请参阅本文的上一个版本，其中使用lea在第三个寄存器中生成curr + prev，因为我没有意识到实际上并不需要临时变量。感谢rcgldr捕捉到了这一点。）
下面是一个完整的工作展开版本，它可以处理任何计数。
测试前端（本版本新增：金丝雀元素，用于检测写入超过缓冲区末尾的ASM错误。）

// fib-main.c
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

void fib(uint32_t *buf, uint32_t count);

int main(int argc, const char *argv[]) {
    uint32_t count = 15;
    if (argc > 1) {
        count = atoi(argv[1]);
    }
    uint32_t buf[count+1]; // allocated on the stack
    // Fib overflows uint32 at count = 48, so it's not like a lot of space is useful

    buf[count] = 0xdeadbeefUL;
    // uint32_t count = sizeof(buf)/sizeof(buf[0]);
    fib(buf, count);
    for (uint32_t i ; i < count ; i++){
        printf("%u ", buf[i]);
    }
    putchar('\n');

    if (buf[count] != 0xdeadbeefUL) {
        printf("fib wrote past the end of buf: sentinel = %x\n", buf[count]);
    }
}

这段代码是完全工作和测试（除非我错过了复制我的本地文件中的更改回答案>.<）：

peter@tesla:~/src/SO$ yasm -f elf64 fib.asm && gcc -std=gnu11 -g -Og fib-main.c fib.o
peter@tesla:~/src/SO$ ./a.out 48
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 512559680

展开版本

再次感谢rcgldr让我思考如何处理奇数与甚至在循环设置中计数，而不是在结束时进行清理迭代。
我使用了无分支设置代码，它将4 * count%2添加到起始指针。它可以是零，但添加零比分支更便宜，看看我们是否应该。斐波那契序列很快就会溢出寄存器，因此保持序言代码紧凑和高效非常重要，而不仅仅是循环内的代码。（如果我们要优化的话，我们希望优化许多短长度的调用）。

; 64bit SysV register-call ABI
    ; args: rdi: output buffer pointer.  rsi: count

    ;; locals:  rsi: endp
    ;; eax: current   edx: prev
    ;; ecx: tmp
    ;; all of these are caller-saved in the SysV ABI, like r8-r11
    ;; so we can use them without push/pop to save/restore them.
    ;; The Windows ABI is different.

;void fib(int32_t *dest, uint32_t count);  // unrolled version
global fib
fib:
    cmp    esi, 1
    jb     .early_out       ; count below 1  (i.e. count==0, since it's unsigned)

    mov    eax, 1           ; current = 1
    mov    [rdi], eax
    je     .early_out       ; count == 1, flags still set from cmp
    ;; need this 2nd early-out because the loop always does 2 iterations

;;; branchless handling of odd counts:
;;;   always do buf[0]=1, then start the loop from 0 or 1
;;; Writing to an address you just wrote to is very cheap
;;; mov/lea is about as cheap as best-case for branching (correctly-predicted test/jcc for count%2==0)
;;; and saves probably one unconditional jump that would be needed either in the odd or even branch

    mov    edx, esi         ;; we could save this mov by using esi for prev, and loading the end pointer into a different reg
    and    edx, eax         ; prev = count & 1 = count%2

    lea    rsi, [rdi + rsi*4] ; end pointer: same regardless of starting at 0 or 1

    lea    rdi, [rdi + rdx*4] ; buf += count%2
    ;; even count: loop starts at buf[0], with curr=1, prev=0
    ;; odd  count: loop starts at buf[1], with curr=1, prev=1

align 16  ;; the rest of this func is just *slightly* longer than 16B, so there's a lot of padding.  Tempting to omit this alignment for CPUs with a loop buffer.
.loop:                      ;; do {
    mov    [rdi], eax       ;;   *buf = current
             ; on loop entry: curr:eax  prev:edx
    add   edx, eax          ; curr:edx  prev:eax

;.oddentry: ; unused, we used a branchless sequence to handle odd counts
    mov   [rdi+4], edx
    add   eax, edx          ; curr:eax  prev:edx
                            ;; back to our starting arrangement
    add    rdi, 8           ;;   buf++
    cmp    rdi, rsi         ;; } while(buf < endp);
    jb    .loop

;   dec   esi   ;  set up for this version with sub esi, edx; instead of lea
;   jnz   .loop
.early_out:
    ret

要生成从零开始的序列，请执行以下操作

curr=count&1;   // and esi, 1
buf += curr;    // lea [rdi], [rdi + rsi*4]
prev= 1 ^ curr; // xor eax, esi

而不是现在

curr = 1;
prev = count & 1;
buf += count & 1;

我们还可以在两个版本中保存mov指令，方法是使用esi保存prev，因为prev依赖于count。

;; optimized for code size, NOT speed.  Prob. could be smaller, esp. if we want to keep the loop start aligned, and jump between before and after it.
  ;; most of the savings are from avoiding mov reg, imm32,
  ;; and from counting down the loop counter, instead of checking an end-pointer.
  ;; loop prologue for sequence starting with 0 1 1 2
    xor    edx, edx
    cmp    esi, 1
    jb     .early_out         ; count below 1, no stores
    mov    [rdi], edx         ; store first element
    je     .early_out         ; count == 1, flags still set from cmp

    xor    eax, eax  ; movzx after setcc would be faster, but one more byte
    shr    esi, 1             ; two counts per iteration, divide by two
  ;; shift sets CF = the last bit shifted out
    setc   al                 ; curr =   count&1
    setnc  dl                 ; prev = !(count&1)

    lea    rdi, [rdi + rax*4] ; buf+= count&1

  ;; extra uop or partial register stall internally when reading eax after writing al, on Intel (except P4 & silvermont)
  ;; EAX:curr EDX:prev  (same as 1 1 2 setup)
  ;; even count: loop starts at buf[0], with curr=0, prev=1
  ;; odd  count: loop starts at buf[1], with curr=1, prev=0

  .loop:
       ...
    dec  esi                  ; 1B smaller than 64b cmp, needs count/2 in esi
    jnz .loop
  .early_out:
    ret

矢量化：

斐波那契数列不是特别可并行化的。没有简单的方法可以从F（i）和F（i-4）得到F（i+4），或者类似的东西。我们对向量所能做的就是减少存储到内存中的次数。开始：

a = [f3 f2 f1 f0 ]   -> store this to buf
b = [f2 f1 f0 f-1]

然后a+=b; b+=a; a+=b; b+=a;产生：

a = [f7 f6 f5 f4 ]   -> store this to buf
b = [f6 f5 f4 f3 ]

当使用两个64位整型打包成128 b向量时，这就不那么愚蠢了。即使在32位代码中，您也可以使用SSE进行64位整数运算。
此答案的以前版本有一个未完成的压缩32位向量版本，无法正确处理count%4 != 0。为了加载序列的前4个值，我使用了pmovzxbd，所以当我只能使用4 B时，我不需要16 B的数据。得到第一个-1。将序列的1个值装入向量寄存器要容易得多，因为只有一个非零值要加载和混洗。

;void fib64_sse(uint64_t *dest, uint32_t count);
; using SSE for fewer but larger stores, and for 64bit integers even in 32bit mode
global fib64_sse
fib64_sse:
    mov eax, 1
    movd    xmm1, eax               ; xmm1 = [0 1] = [f0 f-1]
    pshufd  xmm0, xmm1, 11001111b   ; xmm0 = [1 0] = [f1 f0]

    sub esi, 2
    jae .entry  ; make the common case faster with fewer branches
    ;; could put the handling for count==0 and count==1 right here, with its own ret

    jmp .cleanup
align 16
.loop:                          ; do {
    paddq   xmm0, xmm1          ; xmm0 = [ f3 f2 ]
.entry:
    ;; xmm1: [ f0 f-1 ]         ; on initial entry, count already decremented by 2
    ;; xmm0: [ f1 f0  ]
    paddq   xmm1, xmm0          ; xmm1 = [ f4 f3 ]  (or [ f2 f1 ] on first iter)
    movdqu  [rdi], xmm0         ; store 2nd last compute result, ready for cleanup of odd count
        add     rdi, 16         ;   buf += 2
    sub esi, 2
        jae   .loop             ; } while((count-=2) >= 0);
    .cleanup:
    ;; esi <= 0 : -2 on the count=0 special case, otherwise -1 or 0

    ;; xmm1: [ f_rc   f_rc-1 ]  ; rc = count Rounded down to even: count & ~1
    ;; xmm0: [ f_rc+1 f_rc   ]  ; f(rc+1) is the value we need to store if count was odd
    cmp esi, -1
    jne   .out  ; this could be a test on the Parity flag, with no extra cmp, if we wanted to be really hard to read and need a big comment explaining the logic
    ;; xmm1 = [f1 f0]
    movhps  [rdi], xmm1         ; store the high 64b of xmm0.  There is no integer version of this insn, but that doesn't matter
    .out:
        ret

没有必要进一步展开，dep链延迟限制了吞吐量，因此我们总是可以平均每个周期存储一个元素。减少uops中的循环开销可以帮助实现超线程，但这是非常次要的。

正如您所看到的，即使展开两个，处理所有的角落情况也是非常复杂的。它需要额外的启动开销，即使您试图优化它以将其保持在最低限度。很容易以大量的条件分支结束。
更新了main：

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdlib.h>

#ifdef USE32
void fib(uint32_t *buf, uint32_t count);
typedef uint32_t buftype_t;
#define FMTx PRIx32
#define FMTu PRIu32
#define FIB_FN fib
#define CANARY 0xdeadbeefUL
#else
void fib64_sse(uint64_t *buf, uint32_t count);
typedef uint64_t buftype_t;
#define FMTx PRIx64
#define FMTu PRIu64
#define FIB_FN fib64_sse
#define CANARY 0xdeadbeefdeadc0deULL
#endif

#define xstr(s) str(s)
#define str(s) #s

int main(int argc, const char *argv[]) {
    uint32_t count = 15;
    if (argc > 1) {
        count = atoi(argv[1]);
    }
    int benchmark = argc > 2;

    buftype_t buf[count+1]; // allocated on the stack
    // Fib overflows uint32 at count = 48, so it's not like a lot of space is useful

    buf[count] = CANARY;
    // uint32_t count = sizeof(buf)/sizeof(buf[0]);
    if (benchmark) {
       int64_t reps = 1000000000 / count;
       for (int i=0 ; i<=reps ; i++)
           FIB_FN(buf, count);

    } else {
       FIB_FN(buf, count);
       for (uint32_t i ; i < count ; i++){
           printf("%" FMTu " ", buf[i]);
       }
       putchar('\n');
    }
    if (buf[count] != CANARY) {
        printf(xstr(FIB_FN) " wrote past the end of buf: sentinel = %" FMTx "\n", buf[count]);
    }
}

性能

对于count略低于8192（适合L1 d缓存），在我的Sandybridge i5- 2500 k上，展开2个非向量版本运行接近其理论最大吞吐量，即每个周期1个存储（每个周期3.5条指令）。8192 * 4 B/int = 32768 = L1缓存大小。在实践中，我看到~3.3至~3.4 insn /周期。不过，我用Linux perf stat计算整个程序，而不仅仅是紧循环。（注意repeat循环调用Fib函数，所以程序的大部分时间都花在了它上面，尽管有一些启动开销。
不管怎样，没有什么必要再继续下去了。显然，在count=47之后，这不再是一个斐波那契序列，因为我们使用了uint32_t。但是，对于较大的count，吞吐量受到内存带宽的限制，低至~2.6 insn /周期。在这一点上，我们基本上是在看如何优化memset。
使用movdqu存储（fib64_sse）的64位整数版本以每周期3 insns（每两个时钟一个128 b存储）的速度运行，阵列大小约为L2缓存大小的1.5倍。（即./fib64 49152）。随着阵列大小增加到L3高速缓存大小的更大部分，性能下降到L3高速缓存大小的3/4时每个周期约2 insn（每3个时钟存储一次）。在大小> L3高速缓存时，它达到每6个周期1次存储。
因此，使用向量存储比使用标量存储更好，其中数组对于L1 d缓存来说太大，但可以放入L2缓存。

考虑到fib（93）= 12200160415121876738是适合64位无符号整数的最大值，尝试优化它可能没有太多意义，除非计算fib（n）模某个（通常是素数）大n。
有一种方法可以在log2（n）次迭代中直接计算fib（n），使用lucas序列方法或Fibonacci的矩阵方法。lucas序列更快，如下所示。这些可以被修改以执行对某个数字取模的数学运算。

/* lucas sequence method */
uint64_t fibl(int n) {
    uint64_t a, b, p, q, qq, aq;
    a = q = 1;
    b = p = 0;
    while(1){
        if(n & 1) {
            aq = a*q;
            a = b*q + aq + a*p;
            b = b*p + aq;
        }
        n >>= 1;
        if(n == 0)
            break;
        qq = q*q;
        q = 2*p*q + qq;
        p = p*p + qq;
    }
    return b;
}

.386
.model flat, stdcall
.stack 4096
ExitProcess proto, dwExitCode:dword

.data
    fib word 1, 1, 5 dup(?);you create an array with the number of the fibonacci series that you want to get
.code
main proc
    mov esi, offset fib ;set the stack index to the offset of the array.Note that this can also be set to 0
    mov cx, lengthof fib ;set the counter for the array to the length of the array. This keeps track of the number of times your loop will go

L1: ;start the loop
    mov ax, [esi]; move the first element to ax ;move the first element in the array to the ax register
    add ax, [esi + type fib]; add the second element to the value in ax. Which gives the next element in the series
    mov[esi + 2* type fib], ax; assign the addition to the third value in the array, i.e the next number in the fibonacci series
    add esi, type fib;increment the index to move to the next value
    loop L1; repeat

    invoke ExitProcess, 0
main endp
end main