Control Flow ইন অ্যাসেম্বলি — cmp, test, আর conditional jump-এর পরিবার

If/else — সবচেয়ে সরল রূপ

int classify(int x) {
    if (x > 0) {
        return 1;
    } else {
        return -1;
    }
}

classify:
        cmp     $0, %edi          # x - 0 গণনা করে flags সেট করে
        jg      .L_positive        # SF=OF এবং ZF=0 হলে (x > 0), জাম্প
        mov     $-1, %eax          # else শাখা — fall-through (জাম্প না হলে)
        jmp     .L_end
.L_positive:
        mov     $1, %eax           # if শাখা
.L_end:
        ret

লক্ষ্য করুন কাঠামোটা — cmp দিয়ে flags সেট, jg (signed greater) দিয়ে branch, “then” branch-এর জন্য একটা label, “else” শাখা fall-through হিসেবে (কোনো label লাগে না, স্বাভাবিক sequential execution), আর else-এর শেষে একটা jmp দিয়ে then-শাখার কোড এড়িয়ে .L_end-এ চলে যাওয়া (নাহলে else-এর execution then-এর কোডেও পড়ে যেত)।

While loop — test-at-bottom কাঠামো

int sum_to_n(int n) {
    int total = 0;
    int i = 1;
    while (i <= n) {
        total += i;
        i++;
    }
    return total;
}

sum_to_n:
        mov     $0, %eax           # total = 0   (eax-এই থাকবে, return-এর জন্য প্রস্তুত)
        mov     $1, %ecx           # i = 1
        jmp     .L_test             # আগে test-এ — hood সেকশনের ব্যাখ্যা অনুযায়ী
.L_body:
        add     %ecx, %eax          # total += i
        add     $1, %ecx            # i++
.L_test:
        cmp     %edi, %ecx          # i - n গণনা করে flags সেট করে
        jle     .L_body              # i <= n হলে (signed), আবার body-তে
        ret                          # loop শেষ — total (eax-এ) return

মাত্র একটা conditional jump (jle) — প্রতিটা iteration-এ ঠিক এই একটাই jump execute হয়, hood সেকশনে ব্যাখ্যা করা optimization অনুযায়ী।

For loop — while-এরই একটা সিনট্যাক্টিক রূপ

int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

factorial:
        mov     $1, %eax            # result = 1
        mov     $1, %ecx            # i = 1   (for-এর init অংশ)
        jmp     .L_test
.L_body:
        imul    %ecx, %eax           # result *= i
        add     $1, %ecx             # i++     (for-এর increment অংশ)
.L_test:
        cmp     %edi, %ecx           # i - n
        jle     .L_body               # for-এর condition অংশ
        ret

এই assembly-টা হুবহু আগের while-loop-এর কাঠামো — শুধু C source-এ init/condition/increment তিনটা আলাদা জায়গায় লেখা হয়েছিল, compiled output-এ তারা যথাক্রমে ঠিক সেই একই তিনটা জায়গায় বসেছে (init prologue-এর পরে, condition .L_test-এ, increment body-র শেষে)। এটাই স্পষ্ট প্রমাণ — for আসলে while-এরই “syntactic sugar”, hardware-স্তরে দুটোর মধ্যে কোনো পার্থক্যই নেই।

test reg, reg ইডিয়ম বাস্তব কম্পাইলার-আউটপুটে

int is_nonzero(int x) {
    return x != 0;
}

is_nonzero:
        test    %edi, %edi          # edi এর সাথে edi-র AND — শূন্য কি না চেক
        setne   %al                  # ZF=0 হলে (edi ≠ 0), al = 1, নাহলে al = 0
        movzbl  %al, %eax            # al-কে zero-extend করে পূর্ণ eax বানানো
        ret

setne (Jcc-পরিবারেরই একটা আত্মীয় — jump-এর বদলে সরাসরি একটা byte-এ ০/১ বসায়, flags থেকে) আর movzbl (byte থেকে long-এ zero-extend) — একসাথে branch-ছাড়াই একটা boolean মান তৈরি করার প্রচলিত প্যাটার্ন, test reg, reg-এর সরাসরি ব্যবহার।

Short-circuit evaluation — &&-এর দ্বিতীয় অংশ মূল্যায়নই না হওয়া

int safe_check(int *p) {
    if (p != 0 && *p > 0) {
        return 1;
    }
    return 0;
}

safe_check:
        test    %rdi, %rdi          # p == NULL চেক (0-র সাথে তুলনা, test দিয়ে)
        je      .L_false             # p == NULL হলে সরাসরি false — *p একদম স্পর্শই করা হয়নি
        mov     (%rdi), %eax         # শুধু এই পথে পৌঁছালেই *p পড়া হয় — p নিশ্চিতভাবে non-NULL
        cmp     $0, %eax
        jle     .L_false
        mov     $1, %eax
        ret
.L_false:
        mov     $0, %eax
        ret

লক্ষ্য করুন — mov (%rdi), %eax (যেটা *p পড়ে) instruction-টা শুধুমাত্র .L_false-এ jump না-হওয়া পথে execute হয়, অর্থাৎ শুধু তখনই যখন p != 0 ইতিমধ্যে নিশ্চিত। এটা নিছক একটা optimization না — C-র ভাষাগত নিয়ম (&&-এর short-circuit semantics) এই নির্দিষ্ট jump-কাঠামো ছাড়া বাস্তবায়নই করা যেত না। যদি compiler দুইটা condition আগেই আলাদাভাবে গণনা করে রাখত (branch ছাড়া), p == NULL-এর ক্ষেত্রে *p পড়তে গিয়ে একটা null-pointer-dereference crash হতো — ঠিক সেই bug-টাই এই jump-কাঠামো এড়িয়ে যায়।

Switch statement — অনেক case হলে jump table

int day_type(int day) {
    switch (day) {
        case 0: return 100;
        case 1: return 101;
        case 2: return 102;
        case 3: return 103;
        default: return -1;
    }
}

অল্প কয়েকটা case হলে compiler সাধারণত chained cmp/je-ই ব্যবহার করে (এই লেসনের if/else প্যাটার্নের সম্প্রসারণ মাত্র)। কিন্তু case-সংখ্যা বেশি আর ক্রমিক (0, 1, 2, 3, …) হলে, compiler প্রায়ই একটা jump table ব্যবহার করে:

day_type:
        cmp     $3, %edi              # সীমার বাইরে কি না — default-এর জন্য একটামাত্র bounds-check
        ja      .L_default
        mov     %edi, %eax
        lea     .L_table(%rip), %rdx
        movslq  (%rdx,%rax,4), %rax    # table[day] থেকে সরাসরি target-এর offset পড়া
        add     %rdx, %rax
        jmp     *%rax                  # ★ indirect jump — target একটা register থেকে, কোনো label সরাসরি লেখা নেই
.L_case0:
        mov     $100, %eax
        ret
.L_case1:
        mov     $101, %eax
        ret
.L_case2:
        mov     $102, %eax
        ret
.L_case3:
        mov     $103, %eax
        ret
.L_default:
        mov     $-1, %eax
        ret

.L_table:
        .long   .L_case0 - .L_table
        .long   .L_case1 - .L_table
        .long   .L_case2 - .L_table
        .long   .L_case3 - .L_table

jmp *%rax — একটা indirect jump, target সরাসরি assembly-তে লেখা কোনো label না, বরং একটা register-এ থাকা মান (যেটা runtime-এ table থেকে পড়া হয়েছে)। এটা এই লেসনের বাকি সব jump (je, jl, jmp .L_body) থেকে গুণগতভাবে ভিন্ন — সেগুলোর target compile-time-এ স্থির, jmp *%rax-এর target শুধু runtime-এই জানা যায়। day-এর মান সরাসরি table-এর index হিসেবে ব্যবহৃত হচ্ছে — n-টা cmp/je চেইনের O(n) তুলনার বদলে, একটামাত্র bounds-check (cmp $3, %edi; ja) আর একটা array-lookup দিয়ে সরাসরি সঠিক case-এ পৌঁছানো, O(1)।