簡述

最近看docker和k8s的底層實現原理,嚴重感覺自己對底層的知識瞭解不足，於是開始業餘時間深入看一些底層書籍，就找了本據說是理解整個計算機體系的入門書-《深入理解計算機系統》.直接買的最新的第三版，從第三章開始看的，第二章接下來有心情再看(看了幾眼全是如何手算進位制間計算之類的感覺用處不是很大)…由於第三版剛出不久，而且題目跟第二版的不一樣，網上幾乎沒有答案。。。於是自己艱難的做完後,就打算把自己的解法和思路放到部落格上，基本都是自己做的,大都自己在機器上驗證過了(差點累死..),但想必肯定會有很多錯誤和不足(不知道有多少手殘打錯的地方)，歡迎同樣在看這本書的多多留言交流討論題目解法，我會積極吸收建議,並不斷修正完善我的博文，最重要的是給其他正在看這本書的一個答案參考(其實就是騙訪問量)。

第三章的主要內容是組合語言，剛開始看的時候完全不知所云，前四節看的異常艱難，平均每小時看一頁的速度。。。有的地方實在看不懂，就先略過了，看到後面的時候發現用到前面的，就又回過頭來看前面的，有時候僅僅這個回頭看就是兩個多小時,一天光回頭看了。。後來終於弄明白前四節之後，大體明白是怎麼一個套路了，再看後面幾節的時候，速度就很快了，基本就是跟看小說似的一次性過了。。。所以建議前面的一定要認真讀,不要心急,慢慢看,找到彙編的套路後後面的就看的飛快了

*3.58

decode2:
    subq    %rdx, %rsi # %rsi = y - z;
    imulq   %rsi
 
, %rdi # %rdi = (y - z) * x;
    movq    %rsi, %rax # %rax = y - z;
    salq    $63,  %rax # %rax = (y - z) << 63;
    sarq    $63,  %rax # %rax = ((y - z) << 63) >> 63;
    xorq    %rdi, %rax # %rax=(((y - z) << 63) >> 63) ^ ((y - z) * x)
    ret

因此相應的C程式碼為(((y-z)<<63)>>63)^((y-z)*x)

**3.59

這題之前一直沒弄明白,原來是我沒有仔細看課本3.5.5節,對cqto理解錯了..在此感謝下面的評論中給的參考答案 :) .不過確實還是有些地方不太好理解,我下面會盡最大努力講的清楚一些.(不過我的語文水平堪憂…)
這裡有一點需要注意,%rdx與%rax共同代表一個128位數的意思,是指用可以用計算公式%rdx*2^64+%rax來表示這個數,而並不是把這%rdx和%rax的二進位制串串連起來表示這個數,區別在於,當這個數為負數的時候,%rdx是-1.意思是所有位都為1,而如果串連起來的話,顯然只有%rdx的第一位為1,後面全為0.因此這裡的數學公式推理才正確,所以對於彙編的第10行為什麼要加上%rcx,就不要用串連起來的表示方法去想象這一行的正確性,而應該用數學公式去推.
下面用x0,y0來分別表示x和y的低位,用x1,y1來分別表示x和y的高位,用W表示2^64,因此下面的公式成立:

 p = x * y
   = (x1*W + x0) * (y1*W + y0) 
   = (x1*y1*W*W) + W(x1*y0+x0*y1) + x0*y0

公式中x1*y1*W*W超過了128位,而且未超出128位部分始終全為0,因此可以去掉.於是公式變成了p=W(x1*y0+x0*y1) + x0*y0,然後可以繼續轉化,注意這裡的x0*y0是很可能會超出64位的,假設x0*y0的超出64位的部分為z1,未超出64位的部分為z0.那麼公式可以變成如下:

p = W(x1*y0+x0*y1+z1) + z0

很明顯,需要將x1*y0+x0*y1+z1放到最終結果的高位,即(%rdi),z0放到最終結果的低位,即8(%rdi)
然後仔細翻譯下各個語句

store_prod:
    movq   %rdx, %rax   # %rax = y0.
    cqto                # 有符號運算,因此用cqto,這裡會自動關聯%rdx和%rax分別表示高位和低位,假如y是負數,那麼%rdx所有位都是1(此時值是-1),否則,%rdx全為0, %rdx = y1.
    movq   %rsi, %rcx   # %rcx = x0.
    sarq   $63,  %rcx   # 將%rcx向右移63位,跟%rdx的含義一樣,要麼是-1,要麼是0, %rcx = x1.
    imulq  %rax, %rcx   # %rcx = y0 * x1
    imulq  %rsi, %rdx   # %rdx = x0 * y1
    addq   %rdx, %rcx   # %rcx = y0 * x1 + x0 * y1
    mulq   %rsi         # 無符號計算 x0*y0,並將x0*y0的128位結果的高位放在%rdx,低位放在%rax,因此這裡%rdx = z1, %rax = z0.
    addq   %rcx, %rdx   # %rdx = y0*x1+x0*y1+z1
    movq   %rax, (%rdi) # 將%rax的值放到結果的低位
    movq   %rdx, 8(%rdi)# 將%rdx的值放到結果的高位,可以發現跟上面用數學公式推理的結果完全一致!!!!
    ret

**3.60

loop:
    movl  %esi, %ecx # %ecx=n;
    movl  $1, %edx   # %edx=1; --> mask 
    movl  $0, %eax   # %eax=0; --> result
    jmp   .L2
.L3:
    movq  %rdi, %r8  # %r8=x;
    andq  %rdx, %r8  # %r8=x&%rdx; -->x&mask
    orq   %r8, %rax  # %rax=%rax | (x&%rdx); -->result |= x & mask
    salq  %cl, %rdx  # %rdx=%rdx<<(n&0xFF); -->mask<<=(n&0xFF)
.L2:
    testq %rdx, %rdx
    jne   .L3.       # if %rdx!=0 goto L3. -->mask!=0
    rep; ret

A.

%rdi, %r8 --> x
%esi, %ecx --> n
%rdx --> mask
%rax --> result

B.

result = 0;
mask = 1；

C.

mask != 0

D.

mask<<=(n&0xFF)

E.

result |= x & mask

F.

long loop(long x, int n)
{
    long result = 0;
    long mask;
    for(mask = 1;mask != 0;mask = mask << (n&0xFF)){
        result |= x & mask;
    }
    return result;
}

**3.61

傳送指令會對條件分別求值，於是假如xp為空指標，那麼這裡產生對空指標讀資料的操作，顯然是不可以的。於是這裡不能存在*xp,可以用指標來代替，最後判斷出值之後，再進行讀取資料，因此這裡0也必須賦予一個地址，於是需要加個變數來儲存0這個數字。因此答案可以是：

long cread_alt(long *xp)
{
    int t=0;
    int *p = xp ? xp : &t;
    return *p;
}

**3.62

這個題就是純翻譯彙編，沒有什麼可講的。

case MODE_A:
    result = *p2;
    action = *p1;
    *p2 = action;
    break;
case MODE_B:
    result = *p1 + *p2;
    *p1 = result;
    break;
case MODE_C:
    *p1 = 59;
    result = *p2;
    break;
case MODE_D:
    result = *p2;
    *p1 = result;
    result = 27;
    break;
case MODE_E:
    result = 27;
    break;
default:
    result = 12;

**3.63

<switch_prob>:
    400590: 48 83 ee 3c    sub $0x3c, %rsi
    # 說明下面的數都要加上60 
    400594: 48 83 fe 05    cmp $0x5, %rsi
    400598: 77 29          ja  4005c3 <switch_prob+0x33>
    # 如果大於65，跳到4005c3那一行
    40059a: ff 24 f5 f8 06 40 00   jmpq *0x4006f8(,%rsi,8)
    # 跳到跳轉表對應的位置，假設跳轉表對應陣列a[x],那麼分別跳到a[0x4006f8+8*(n-60)]的位置
    4005a1: 48 8d 04 fd 00 00 00   lea  0x0(,%rdi,8),%rax
    # 60和62會跳到這個位置
    4005a8: 00
    400593: c3             retq
    4005aa: 48 89 f8       mov %rdi, %rax
    # 63會跳到這個位置
    4005ad: 48 c1 f8 03    sar $0x3, %rax
    4005b1: c3             retq
    4005b2: 48 89 f8       mov %rdi, %rax
    # 64會跳到這個位置
    4005b5: 48 c1 e0 04    shl $0x4, %rax
    4005b9: 48 29 f8       sub %rdi, %rax
    4005bc: 48 89 c7       mov %rax, %rdi
    4005bf: 48 0f af ff    imul %rdi, %rdi
    # 65會跳到這個位置
    4005c3: 48 8d 47 4b    lea 0x4b(%rdi), %rax
    # 大於65和61會跳到這個位置
    4005c7: c3             retq 

根據上面的分析過程可得答案如下：

long switch_prob(long x, long n){
    long result = x;
    switch(n):{
        case 60:
        case 62:
            result = x * 8;
            break;
        case 63:
            result = result >> 3;
            break;
        case 64:
            result = (result << 4) - x;
            x = result;
        case 65:
            x = x * x;
        case 61: # 也可以去掉這行
        default:
            result = x + 0x4b;
    }
}

***3.64

store_ele:
    leaq  (%rsi, %rsi, 2), %rax  # %rax = 3 * j
    leaq  (%rsi, %rax, 4), %rax  # %rax = 13 * j
    leaq  %rdi, %rsi             # %rsi = i
    salq  $6, %rsi               # %rsi * = 64
    addq  %rsi, %rdi             # %rdi = 65 * i
    addq  %rax, %rdi             # %rdi = 65 * i + 13 * j
    addq  %rdi, %rdx             # %rdx = 65 * i + 13 * j + k
    movq  A(, %rdx, 8), %rax     # %rax = A + 8 * (65 * i + 13 * j + k)
    movq  %rax, (%rcx)           # *dest = A[65 * i + 13 * j + k]
    movl  $3640, %eax            # sizeof(A) = 3640
    ret

A.

&D[i][j][k] = X_D + L(i * S * T + j * T + k)

B.

由A題目中的公式以及彙編至第9行第10行計算出來的可得：

S * T = 65
T = 13
S * T * R * 8 = 3640

很容易可以計算出來

R = 7
S = 5
T = 13

*3.65

.L6:
    movq  (%rdx), %rcx  # t1 = A[i][j]
    movq  (%rax), %rsi  # t2 = A[j][i]
    movq  %rsi, (%rdx)  # A[i][j] = t2
    movq  %rcx, (%rax)  # A[j][i] = t1
    addq  $8, %rdx      # &A[i][j] += 8
    addq  $120, %rax    # &A[j][i] += 120
    cmpq  %rdi, %rax    
    jne   .L6           # if A[j][i] != A[M][M]

A.

從2～5行裡無法區分A[i][j]和A[j][i]，只能從第6和7行來看，A[i][j]每次只移動一個單位，所以每次+8的暫存器%rdx就是指的A[i][j]。

B.

因為暫存器%rdx是A[i][j]，所以另一個暫存器%rax是A[j][i]。

C.

A[j][i]每次移動一行的距離，所以可得公式:8 * M = 120,顯然，M=15。

*3.66

sum_col:
    leaq   1(, %rdi, 4), %r8        # %r8 = 4 * n + 1
    leaq   (%rdi, %rdi, 2), %rax    # result = 3 * n
    movq   %rax, %rdi               # %rdi = 3 * n
    testq  %rax, %rax
    jle    .L4                      # if %rax <= 0, goto L4
    salq   $3, %r8                  # %r8 = 8 * (4 * n + 1)
    leaq   (%rsi, %rdx, 8), %rcx    # %rcx = A[0][j]
    movl   $0, %eax                 # result = 0
    movl   $0, %edx                 # i = 0
.L3:
    addq   (%rcx), %rax             # result = result + A[i][j]
    addq   $1, %rdx                 # i += 1
    addq   %r8, %rcx                # 這裡每次+8*(4n+1),說明每一行有4n+1個，因此NC(n)為4*n+1
    cmpq   %rdi, %rdx               
    jne    .L3                      # 這裡說明一直迴圈到3*n才結束，所以可以說明一共有3n行，因此NR(n)為3*n
    rep; ret
.L4:
    movl $0, %eax
    ret

根據上述程式碼中的分析，可以得出

NR(n) = 3 * n
NC(n) = 4 * n + 1

**3.67

這個的彙編翻譯很簡單，基本都是直接在棧上賦值，就不再一句句翻譯了.
這裡要注意一點!!也是我想了很長時間的一點,就是當呼叫一個函式時,%rsp會減去8來存一個返回地址,因此process裡的24(%rsp),16(%rsp),8(%rsp)分別對應著原來的16(%rsp),8(%rsp),(%rsp)!!

A.

相對於%rsp的偏移量	儲存的值
%rsp+24	z
%rsp+16	&z
%rsp+8	y
%rsp	x

B.

傳的是%rsp+64表示的棧地址,而不是結構體s.

C.

直接通過%rsp+偏移量的棧地址來訪問的s的值.

D.

通過所傳的表示棧地址的引數,來間接儲存在棧上.

E.

完成eval時的棧幀圖應該是:

相對於%rsp的偏移量	儲存的值
%rsp+80	z
%rsp+72	x
%rsp+64	y
%rsp+32
%rsp+24	z
%rsp+16	&z
%rsp+8	y
%rsp	x

在從process返回後,eval是通過直接通過訪問的%rsp+偏移量來訪問的結構r的元素.

F.

在涉及結構體這種無法用一個暫存器儲存的引數時,不管是傳入還是返回,都是直接通過在棧上的儲存來進行訪問的.

PS: 寫完這個題的題解,深感自己的語文水平的捉急……不懂得留言問吧…

***3.68

首先,結構體str2型別的最長單位是long,所以按照8位對齊,str1同樣,也是按照8位對齊.
再來看彙編程式碼:

setVal:
    movslq  8(%rsi), %rax
    # 說明str2的t從第8位開始的,因為按照8位對齊,因此sizeof(array[B])小於等於8
    # 因為下邊的t是int型別,只佔4個位元組,為了不讓t與array共佔8個位元組,所以sizeof(array[B])大於4,因此可得5<=B<=8.
    addq    32(%rsi), %rax
    # 說明str2的u從第32位開始的,因此t與s佔了24個位元組,可以將2個s放在t的一行,佔滿8個位元組,剩下的s佔據兩行,因此可得7<=A<=10.
    movq    %rax, 184(%rdi)
    # 說明str1的y從第184位開始的,因此184-8<A*B*4<=184

根據彙編程式碼推出的三個公式:

5<=B<=8
7<=A<=10
184-8<A*B*4<=184

可以算出唯一解為:

A=9
B=5

***3.69

這個題…當時把0x120忘記是16進位制,按照10進位制的120來算的…導致算了好長時間..一度以為題目又出錯了…
這題真的是好題..前後邏輯性非常強,每行程式碼都很關鍵,都可以推出很多推論來,缺少了任意一個推論,這題都無法做出來,強烈建議仔細思考,儘量爭取自己做出來

<test>:
    mov    0x120(%rsi), %ecx
    # 這句話是訪問bp的first,說明first與a一共佔了288個位元組
    add    (%rsi), %rcx
    # %rcx = n
    lea    (%rdi, %rdi, 4), %rax
    # %rax = 5 * i
    lea    (%rsi, %rax, 8), %rax
    # %rax = &bp + 40 * i
    mov    0x8(%rax), %rdx
    # ap->idx = %rax + 8
    # 這兩句表明了&bp->a[i]的地址計算公式,即&bp+8+40i,因此可以說明,a的總大小是40
    # +8說明first自己佔8個位元組,按照的8位對齊,因此a的第一個元素肯定是8個位元組的.
    movslq %ecx, %rcx
    # 在這裡將n進行了型別轉換,int型轉換成了long型,因此說明ap裡的x陣列一定是long型
    mov    %rcx, 0x10(%rax, %rdx, 8)
    # 這句說明了ap->x[ap->idx]的地址計算公式是&bp + 16 + idx * 8
    # +16說明了包含了first以及idx,說明idx是a的第一個元素,根據上面得出的第一個元素肯定是8個位元組的結論,說明idx是long型別.
    # 再因為一共佔大小40,所以x陣列的元素個數為(40 - 8) / 8 = 4
    retq

A.

CNT = (288 - 8) / 40 = 7 

B.

typedef struct {
    long idx;
    long x[4];
}

***3.70

前兩問很基礎,直接說答案,注意是union型別,不會的需要再仔細翻下書咯.

A.

e1.p     0
e1.y     8
e2.x     0
e2.next  8

B.

16

C.

這一問比較有難度,邏輯性也很強,還是建議儘量能夠自己推出來.下面來仔細推一下,這題就不好從頭開始一句句的推了, 需要跳躍性的推理(什麼鬼).

1   proc:
2       movq    8(%rdi), %rax
3       movq    (%rax), %rdx
4       movq    (%rdx), %rdx
5       subq    8(%rax), %rdx
6       movq    %rdx, (%rdi)
7       ret

• 先來看proc的C程式碼,等式右邊中間有個減號,因此,可以去彙編裡找到第5行的subq,所以2~4行就是賦值的被減數.
• 第3行和第4行程式碼分別加了兩次星號,因此可以說明是*(*(A).B)結構,根據第二行,因為是偏移量+8,取得是第二個值,e1.y不是指標,因此只能是e2.next,於是A為e2.next;同理,B說明也是指標,沒有偏移量,是取得第一個值,因此只能是e1.p.所以被減數就推出來了為*(*(up->e2.next).e1.p)
• 再看第5行,減數的偏移量是相對於%rax+8,上一條步驟中,%rax是*(up->e2.next),取第二個值,而且彙編程式碼中並未加星號,因此說明不是指標,那麼只能e1.y,因此減數是*(up->e2.next).e1.y
• 最後只剩等式左邊,來看第6行,偏移量為0說明取得第一個值,且從C程式碼中看未加星號,因此不是指標,所以只能是e2.x.

根據上述推理,可以得出C程式碼為:

void proc(union ele *up){
    up->e2.x = *(*(up->e2.next).e1.p) - *(up->e2.next).e1.y;
}

*3.71

不知道對不對……

#include <stdio.h>
void good_echo()
{
    char str[SIZE];
    while(1){
        char *p = fgets(str, SIZE, stdin);
        if (p == NULL) {
            break;
        }
        printf("%s",p);
    }
}

**3.72

aframe:
    pushq   %rbp
    movq    %rsp, %rbp
    subq    $16, %rsp
    # 將棧頂地址減小16
    leaq    30(,%rdi,8), %rax
    # %rax = 8 * n + 30
    andq    $-16, %rax
    # 這裡的原因跟課本中的那一處一樣的道理,將後4位置0,成為最大的16的倍數.
    subq    %rax, %rsp
    # 將棧頂地址減小%rax位
    leaq    15(%rsp), %r8
    andq    $-16, %r8
    # 這兩句是保證了p的地址是16的倍數,取最小的16的倍數.

A.

s2 = s1 - ((8 * n + 30) & 0xfffffff0)
因此:
if n % 2 == 0:
    s2 = s1 - (8 * n + 16)
else:
    s2 = s1 - (8 * n + 24)

B.

p = (s2 + 15) & 0xfffffff0

C.

這題感覺很好,邏輯難度不大,但是要求對題目所需知識點的要求比較高.可以對著p203的圖來看.然後注意,這題很明顯並不是求具體的值,可以看出n在這裡只有奇偶之分,s1看對16取餘後的值.

• 首先來看使e1最小,那麼e2則是最大,如果要e2最大的話,因為這裡是要16倍數的最小值,因此p最小則為某個對16取餘為1的值,這時e2是15,e2不可能會大於等於16了.然後使e1+e2的和也最小,則是n為偶數時,是8n+16-8n,為16,因此答案是: e1為16-e2=1,此時n為偶數,s1%16=1.
• 使e1最大,則e2最小,e2最小則為p恰好是16的倍數,此時e2為0.然後使e1+e2的和也最大,則是n為奇數時,是8n+24-8n,為24,因此答案是: e1為24-e2=24,此時n為奇數,s1%16=0.

D.

s2保證了能容下8 * n位元組的最小的16的倍數.
p保證了自身對16對齊.

*3.73

很簡單的一道題,直接用4個跳轉就可以了.

find_range:
    vxorps %xmm1, %xmm1, %xmm1
    vucomiss %xmm1, %xmm0
    jp .L1
   ja .L2
   jb .L3
   je .L4
   .L2:
   movl $2, %eax
   jmp .Done
   .L3:
   movl $0, %eax
   jmp .Done
   .L4:
   movl $1, %eax
   jmp .Done
   .L1:
   movl $3, %eax
   .Done

**3.74

跟上題差不多,區別是用條件傳送而不是條件分支.同樣不難.

find_range:
    vxorps %xmm1, %xmm1, %xmm1
    movq $0, %r8
    movq $1, %r9
    movq $2, %r10
    movq $3, %rax
    vucomiss %xmm1, %xmm0
    cmovl %r8, %rax
    cmove %r9, %rax
    cmova %r10, %rax

*3.75

很簡單….找規律就行了

A.

對於第n個引數,則imag部分傳%xmm(2n-1),real部分傳%xmm(2n-2)

B.

imag部分返回值%xmm1, real部分返回值%xmm0.