C থেকে assembly — stack frame আর calling convention-এর ভেতরে

১ · CPU-র চোখে আপনার C কোড — কেন assembly পড়া শিখবেন

পর্ব ০৩-এ দেখেছিলেন, compiler আপনার .c ফাইলকে প্রথমে assembly-তে অনুবাদ করে, তারপর assembler সেটিকে machine code বানায়। তখন assembly-কে একটি মাঝের ধাপ হিসেবে দেখে আমরা এগিয়ে গিয়েছিলাম। এই পর্বে সেই ধাপেই থামব, আর ফাইলটি খুলে পড়ব।

প্রথম সত্যটি সহজ: CPU কোনো ভ্যারিয়েবল, লুপ বা ফাংশন চেনে না। সে চেনে কয়েকশো খুব ছোট নির্দেশ — “এই ঘর থেকে ওই ঘরে ৪ বাইট আনো”, “দুটি সংখ্যা যোগ করো”, “ফল শূন্য হলে অমুক জায়গায় লাফ দাও।” for, if, ফাংশন কল — সবকিছুই compiler এই সরল নির্দেশের সারিতে ভেঙে দেয়। এই নির্দেশের তালিকাকে বলে CPU-র instruction set; ল্যাপটপ আর সার্ভারে সাধারণত x86-64, আর ফোন ও Apple Silicon Mac-এ ARM64.

তাহলে assembly পড়তে শিখবেন কেন? কারণ তাতে এমন অনেক প্রশ্নের উত্তর নিজের চোখে দেখা যায়:

• ফাংশন ডাকলে আসলে কী হয়? কোথায় argument যায়, ফল কোথা থেকে ফেরে।
• Local ভ্যারিয়েবল কেন হারিয়ে যায়? পর্ব ১৪ আর ১৮-তে শুনেছেন “frame মুছে যায়” — এবার দেখবেন কোন instruction সেটা করে।
• রিকার্শন কেন মেমরি খায়? পর্ব ১৫-এর প্রতিটি frame কত বাইট, তা গুনে দেখা যায়।
• Optimization কেন undefined behavior-ওয়ালা কোডের আচরণ বদলায়? কারণ -O2-এ compiler কোডের গঠনই বদলে দেয়।
• Buffer overflow কীভাবে প্রোগ্রামের নিয়ন্ত্রণ কেড়ে নিতে পারে? কারণ ফেরার ঠিকানা ডেটার ঠিক পাশেই থাকে।

Assembly দেখার তিনটি সহজ উপায় আছে। কোনোটিই মুখস্থ করার দরকার নেই:

gcc -S -O0 -masm=intel area.c        # area.s ফাইলে Intel ধরনের assembly
objdump -d -M intel area             # তৈরি প্রোগ্রাম থেকে উল্টো দিকে assembly (disassembly)
# আর ব্রাউজারে: godbolt.org — বাঁয়ে C, ডানে assembly, রঙ দিয়ে লাইন মেলানো

শেষেরটি, Compiler Explorer (godbolt.org), শেখার জন্য সবচেয়ে ভালো। আর objdump তৈরি হয়ে যাওয়া প্রোগ্রাম থেকে instruction ফিরিয়ে আনে — একে বলে disassembly.

২ · CPU-র ভেতরের ঘর — register, rip আর flag

মেমরি (RAM) বিশাল, কিন্তু CPU-র তুলনায় ধীর। তাই CPU-র ভেতরে আছে অল্প কয়েকটি খুব দ্রুত ঘর — register. x86-64-এ সাধারণ কাজের জন্য ১৬টি ৬৪-বিট register আছে, আর বেশিরভাগ হিসাব এখানেই হয়।

একটি খুঁটিনাটি পরে বারবার দেখবেন: eax হলো rax-এর নিচের ৩২ বিট। C-এর int ৪ বাইট, তাই int নিয়ে কাজ হলে listing-এ eax, edi, esi দেখবেন; pointer ৮ বাইট, তাই সেখানে পুরো rdi, rax. আর x86-64-এর একটি নিয়ম: ৩২-বিট নামে কিছু লিখলে ওপরের ৩২ বিট নিজে থেকেই শূন্য হয়ে যায় — অর্থাৎ একটি zero extension.

Flag — তুলনার ফল কোথায় থাকে

CPU-তে “a < b হলে লাফ দাও” বলে কোনো একক নির্দেশ নেই। কাজটি হয় দুই ধাপে। প্রথমে cmp a, b ভেতরে ভেতরে a − b হিসাব করে, ফল ফেলে দেয়, শুধু কয়েকটি flag বিট বসায়:

৩ · Instruction-এর ছয় পরিবার — আর লেখার দুই ধরন

x86-64-এ হাজারখানেক instruction আছে, কিন্তু সাধারণ C কোডের listing পড়তে মোটামুটি ছয় পরিবার চিনলেই চলে। প্রতিটি instruction-এর একটি ছোট নাম থাকে (mov, add), তারপর এক বা দুটি operand:

lea নিয়ে একটু থামা দরকার, কারণ নতুনরা এখানেই সবচেয়ে বেশি বিভ্রান্ত হন। নামটি “load effective address”, কিন্তু সে মেমরিতে যায়ই না — শুধু বন্ধনীর ভেতরের হিসাবটি করে। [0+rax*4] মানে i * 4: int ৪ বাইটের, তাই a[i] আছে শুরু থেকে i*4 বাইট দূরে। পর্ব ১৮-এর pointer arithmetic মেশিনে ঠিক এই রূপ নেয়। Compiler চালাকি করে lea দিয়ে সাধারণ যোগ-গুণও করে, যেমন lea eax, [rdi+rsi] মানে eax = rdi + rsi.

একই instruction, দুই রকম বানান

x86 assembly লেখার দুটি প্রচলিত ধরন আছে। Linux-এর GNU টুল ডিফল্টভাবে লেখে AT&T syntax; Intel-এর নিজের ম্যানুয়াল আর Windows-এর টুল লেখে Intel syntax. ভেতরের machine code হুবহু এক — শুধু লেখার রীতি আলাদা। নিচে একই area ফাংশন দুই ভাবে, gcc-head -O0 থেকে:

area:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     eax, DWORD PTR [rbp-4]
        imul    eax, DWORD PTR [rbp-8]
        pop     rbp
        ret

area:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    %edi, -4(%rbp)
        movl    %esi, -8(%rbp)
        movl    -4(%rbp), %eax
        imull   -8(%rbp), %eax
        popq    %rbp
        ret

এই পর্বে আমরা Intel ধরন ব্যবহার করব, কারণ mov গন্তব্য, উৎস পড়তে C-এর গন্তব্য = উৎস-এর মতো লাগে। Godbolt-এ এটিই ডিফল্ট; নিজের কম্পিউটারে gcc -masm=intel আর objdump -M intel দিলেই পাবেন।

৪ · প্রথম অনুবাদ পড়া — area, একটি লুপ আর if/else

-O0 মানে optimization বন্ধ। তখন compiler প্রায় অক্ষরে অক্ষরে অনুবাদ করে: প্রতিটি ভ্যারিয়েবলের জন্য মেমরিতে একটি ঘর, প্রতিটি ব্যবহারে সেখান থেকে আনা, প্রতিটি পরিবর্তনে সেখানে রাখা। ধীর, কিন্তু পড়তে সবচেয়ে সহজ — আর debugger-এর জন্য আদর্শ। শুরু করি সবচেয়ে ছোট ফাংশন দিয়ে:

# int area(int w, int h) { return w * h; }
area:
        push    rbp                       # caller-এর rbp বাঁচিয়ে রাখো
        mov     rbp, rsp                  # এই ফাংশনের frame-এর ভিত্তি
        mov     DWORD PTR [rbp-4], edi    # w (এসেছে edi-তে) মেমরিতে রাখো
        mov     DWORD PTR [rbp-8], esi    # h (এসেছে esi-তে) মেমরিতে রাখো
        mov     eax, DWORD PTR [rbp-4]    # eax = w
        imul    eax, DWORD PTR [rbp-8]    # eax = eax * h
        pop     rbp                       # caller-এর rbp ফিরিয়ে দাও
        ret                               # ফল eax-এ, caller-এর কাছে ফেরো

w আর h এসেছে register-এ — edi আর esi-তে, কারণ calling convention তাই বলে (অংশ ৭)। -O0-এ compiler সেগুলোকে আগে মেমরিতে, rbp-এর ৪ আর ৮ বাইট নিচে রাখে, তারপর আবার আনে, গুণ করে, ফল রাখে eax-এ। কোনো return ভ্যারিয়েবল নেই; ফল eax-এ থাকাটাই “ফেরত দেওয়া”।

লুপ: একটি array-র যোগফল

# int sum(const int *a, int n) { int s = 0;
#     for (int i = 0; i < n; i++) s += a[i];  return s; }
sum:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-24], rdi   # a (pointer, ৮ বাইট)
        mov     DWORD PTR [rbp-28], esi   # n
        mov     DWORD PTR [rbp-4], 0      # s = 0
        mov     DWORD PTR [rbp-8], 0      # i = 0
        jmp     .L4                       # আগে শর্ত যাচাই করতে নিচে যাও
.L5:                                      # লুপের দেহ
        mov     eax, DWORD PTR [rbp-8]    # eax = i
        cdqe                              # int i-কে ৬৪-বিটে বাড়াও (চিহ্নসহ)
        lea     rdx, [0+rax*4]            # rdx = i * 4 (বাইটে দূরত্ব)
        mov     rax, QWORD PTR [rbp-24]   # rax = a
        add     rax, rdx                  # rax = &a[i]
        mov     eax, DWORD PTR [rax]      # eax = a[i]
        add     DWORD PTR [rbp-4], eax    # s += a[i]
        add     DWORD PTR [rbp-8], 1      # i++
.L4:                                      # শর্ত
        mov     eax, DWORD PTR [rbp-8]
        cmp     eax, DWORD PTR [rbp-28]   # i আর n তুলনা
        jl      .L5                       # i < n (signed) হলে আবার দেহে
        mov     eax, DWORD PTR [rbp-4]    # ফল = s
        pop     rbp
        ret

তিনটি জিনিস খেয়াল করুন। এক, for-এর শর্ত লুপের নিচে বসেছে, আর শুরুতে একটি jmp সেখানে নিয়ে যায়। দুই, cdqe নির্দেশটি int i-কে ৬৪-বিটে বাড়ায়, চিহ্ন রেখে: এটি একটি sign extension, কারণ ঠিকানার হিসাব ৬৪-বিটে হয়। তিন, তুলনার পরে jl — signed “less than”. i আর n দুটোকেই unsigned করে godbolt-এ দেখুন: jl বদলে হবে jb, আর cdqe উধাও হবে। অংশ ২-এর মূল ধারণা হাতেনাতে।

if/else: শর্ত মানে উল্টো লাফ

# int sign(int x) { if (x < 0) return -1; else return 1; }
sign:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        cmp     DWORD PTR [rbp-4], 0      # x - 0 হিসাব করে flag বসাও
        jns     .L8                       # sign flag নেই (x ≥ 0) হলে else-এ লাফ
        mov     eax, -1                   # then অংশ
        jmp     .L9                       # else টপকে যাও
.L8:
        mov     eax, 1                    # else অংশ
.L9:
        pop     rbp
        ret

if (x < 0) লেখা হয়েছিল, কিন্তু listing-এ লাফটি হলো উল্টো শর্তে — “ঋণাত্মক নয় হলে else-এ যাও।” এটাই সাধারণ নিয়ম: শর্ত সত্য হলে কোড সোজা নিচে নামে, মিথ্যা হলে লাফ দিয়ে then অংশ টপকে যায়। পর্ব ১১-এর প্রতিটি if, পর্ব ১২-এর প্রতিটি লুপ মেশিনে শুধু cmp আর কয়েকটি লাফ।

৫ · Stack, prologue আর epilogue — একটি ফাংশন কল ধাপে ধাপে

পর্ব ১৩-এ call stack-কে দেখেছিলেন একটি স্তূপ হিসেবে। মেশিনের স্তরে stack হলো মেমরির একটি সাধারণ অংশ, আর তার চূড়ার ঠিকানা থাকে rsp-এ। একটি অদ্ভুত কিন্তু গুরুত্বপূর্ণ তথ্য: x86-64-এ stack নিচের দিকে বাড়ে। push করলে rsp ৮ কমে, তারপর নতুন ঠিকানায় মান লেখা হয়; pop করলে মান পড়ে rsp ৮ বাড়ে।

প্রায় প্রতিটি -O0 ফাংশন একই ছাঁচে শুরু ও শেষ হয়। শুরুর অংশকে বলে prologue, শেষের অংশকে epilogue:

এবার main যখন area(6, 7) ডাকে, তখন কী ঘটে, ধাপে ধাপে দেখুন। ঠিকানাগুলো বোঝার জন্য বানানো ছোট উদাহরণ — আসল ঠিকানা অনেক বড়, আর ASLR-এর কারণে প্রতিবার আলাদা।

1main:   ...2        mov  esi, 73        mov  edi, 64        call area5        mov  DWORD PTR [rbp-4], eax67area:8        push rbp9        mov  rbp, rsp10        mov  DWORD PTR [rbp-4], edi11        mov  DWORD PTR [rbp-8], esi12        mov  eax, DWORD PTR [rbp-4]13        imul eax, DWORD PTR [rbp-8]14        pop  rbp15        ret

এই পুরো ঘটনা নিজের চোখে দেখার যন্ত্র হলো পর্ব ৩১-এর gdb. সেখানে next দিয়ে C-এর লাইন ধরে এগিয়েছিলেন; এখানে লাগবে instruction ধরে এগোনোর কমান্ড:

$ gcc -g -O0 area.c -o area
$ gdb ./area
(gdb) set disassembly-flavor intel    # Intel ধরনে দেখাও
(gdb) break area
(gdb) run
(gdb) disassemble                     # পুরো ফাংশন; => চিহ্ন দেখায় এখন কোন instruction
(gdb) info registers rdi rsi rsp rbp  # register-এর মান
(gdb) stepi                           # মাত্র এক instruction এগোও (সংক্ষেপে si)
(gdb) x/4gx $rsp                      # stack-এর চূড়া থেকে ৪টি ৮-বাইট ঘর hex-এ
(gdb) backtrace                       # কে কাকে ডেকেছে — frame-এর তালিকা

৬ · Frame-এর পর frame — main → f → g, রিকার্শন আর local-এর ঠিকানা

একটি ফাংশন আরেকটিকে ডাকলে নতুন frame পুরোনোটির নিচে বসে। ফাংশন ফিরলে rsp আবার ওপরে ওঠে, আর ছেড়ে আসা জায়গাটি খালি হয় — কিন্তু পুরোনো বাইট সেখানে পড়েই থাকে, যতক্ষণ না কেউ ওপরে লেখে। নিচের সরলীকৃত ছবিতে main → f → g, তারপর f → h দেখুন:

1void g(void) {2    int y = 2;3}4void h(void) {5    int z = 3;6}7void f(void) {8    int x = 1;9    g();10    h();11}12int main(void) {13    int m = 0;14    f();15    return m;16}

রিকার্শনের প্রতিটি ডাক = একটি নতুন frame

পর্ব ১৫-এর fact(5) মনে করুন। assembly-র চোখে প্রতিটি ডাক একটি পূর্ণ call: নতুন ফেরার ঠিকানা, নতুন সংরক্ষিত rbp, নতুন local-এর জায়গা। নিচের প্রোগ্রামটি গুনে দেখায় একসাথে সর্বোচ্চ কতগুলো frame stack-এ ছিল, আর gcc-head -O0-তে সেটি কত বাইট:

#include <stdio.h>

int depth = 0, max_depth = 0;

int fact(int n) {
    depth++;                                /* new frame */
    if (depth > max_depth) max_depth = depth;
    int r = (n <= 1) ? 1 : n * fact(n - 1);
    printf("%*sframe %d: n=%d returns %d\n", (depth - 1) * 2, "", depth, n, r);
    depth--;                                /* frame removed */
    return r;
}

int main(void) {
    int answer = fact(5);
    printf("fact(5) = %d\n", answer);
    printf("max frames on stack = %d\n", max_depth);
    printf("at gcc -O0 this fact frame = 48 bytes -> %d bytes\n", max_depth * 48);
    return 0;
}

Local-এর ঠিকানা ফেরত দেওয়া — compiler নিজেই কী করে

উপরের stepper-এর ধাপ ৫ ব্যাখ্যা করে কেন পর্ব ১৮-এর dangling pointer এত বিপজ্জনক: ফাংশন ফেরার পরে তার local-এর ঘর পরের কলের দখলে চলে যায়। মজার ব্যাপার হলো, আধুনিক GCC এই ভুল দেখলে শুধু সতর্কই করে না, ইচ্ছা করে ঠিকানার বদলে 0 ফেরত দেয়:

prog.c:3:12: warning: function returns address of local variable [-Wreturn-local-addr]
    3 |     return &y;

g:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 2      # y = 2
        mov     eax, 0                    # ঠিকানা নয় — NULL ফেরত!
        pop     rbp
        ret

অর্থাৎ *p পড়তে গেলে প্রোগ্রাম সাধারণত সাথে সাথে crash করবে — “চুপচাপ ভুল মান”-এর চেয়ে অনেক ভালো। কিন্তু pointer-টি একটু ঘুরিয়ে ফেরত দিলে compiler সবসময় ধরতে পারে না, আর তখন ঠিক stepper-এর ধাপ ৫ ঘটে। এটি undefined behavior; এখানে compiler সাহায্যকারী কিছু বেছে নিয়েছে, সবখানে নেবে এমন নিশ্চয়তা নেই।

৭ · Calling convention — কে কোন register-এ কী রাখবে, তার চুক্তি

আপনার main.c compile হলো GCC দিয়ে, আর printf আছে বহু বছর আগে অন্য কারো compile করা C library-তে। তবু দুটো একসাথে কাজ করে। কীভাবে? কারণ দুই পক্ষই একটি লিখিত চুক্তি মানে: argument কোথায় যাবে, ফল কোথায় আসবে, কোন register নষ্ট করা যাবে, stack কেমন থাকবে। এই চুক্তির নাম calling convention, আর এটি বড় চুক্তি ABI-র একটি অংশ।

Caller-saved বনাম callee-saved

ধরুন f একটি হিসাবের মাঝপথের মান rcx-এ রেখে g-কে ডাকল। g কি rcx ব্যবহার করতে পারবে? চুক্তি বলে: System V-এ rcx হলো caller-saved — g যা খুশি লিখতে পারে, তাই মানটি বাঁচানোর দায় f-এর (কলের আগে stack-এ রেখে দেওয়া)। কিন্তু rbx হলো callee-saved — g ব্যবহার করতে চাইলে শুরুতে পুরোনো মান push করবে, শেষে pop করে ফিরিয়ে দেবে। rbp-ও এই দলে; এজন্যই প্রতিটি prologue-এ push rbp আর epilogue-এ pop rbp.

১৬ বাইটের নিয়ম, red zone আর printf-এর আগে eax

• Stack alignment: System V-এ যেকোনো call-এর ঠিক আগে rsp ১৬-এর গুণিতক হতে হবে। call ৮ বাইটের ঠিকানা push করে, তাই ফাংশনে ঢোকার মুহূর্তে rsp থাকে ১৬-এর গুণিতক থেকে ৮ কম। এজন্যই অংশ ৮-এর -O2 main-এ দেখবেন sub rsp, 8 — কোনো local নেই, শুধু হিসাব মেলানোর জন্য। কারণ: SSE-এর কিছু instruction ১৬ বাইটে সাজানো মেমরি চায়, না পেলে crash.
• Red zone: যে ফাংশন আর কাউকে ডাকে না (leaf function), সে rsp-এর নিচের ১২৮ বাইট rsp না সরিয়েই ব্যবহার করতে পারে — অংশ ৫-এর area ঠিক তাই করেছে। OS-ও কথা দেয়, signal handler চালানোর সময় এই জায়গা নষ্ট করবে না। Linux kernel নিজে অবশ্য -mno-red-zone দিয়ে compile হয়, কারণ সেখানে interrupt যেকোনো মুহূর্তে stack ব্যবহার করতে পারে।
• Variadic কল: printf-এর মতো ফাংশন ডাকার আগে System V-এ al-এ বলে দিতে হয় কতগুলো দশমিক argument vector register-এ গেছে। এজন্য listing-এ call printf-এর ঠিক আগে mov eax, 0 বা xor eax, eax দেখবেন।

Windows কেন আলাদা, আর ARM64 কেমন

Windows x64-এ প্রথম চারটি argument register-এ যায়, কিন্তু caller তবুও stack-এ ৩২ বাইট (চারটি ৮-বাইট ঘর) ফাঁকা রাখে — shadow space. ডাকা ফাংশন চাইলে register-এর argument সেখানে নামিয়ে রাখতে পারে। ফলে একই C কোড Linux আর Windows-এ ভিন্ন assembly হয়, আর এক OS-এর জন্য লেখা হাতের assembly অন্য OS-এ বিনা পরিবর্তনে চলে না।

ফোন আর Apple Silicon-এর ARM64-এ নিয়ম আবার আলাদা, তবে ধারণা একই। godbolt-এ compiler হিসেবে “ARM64 gcc” বেছে -O2 দিলে area হয় মাত্র দুই লাইন:

area:
        mul     w0, w0, w1     # w0 = w0 * w1 (w = x-register-এর নিচের ৩২ বিট)
        ret                    # x30-এর ঠিকানায় ফেরো

যে ফাংশন অন্যকে ডাকে, ARM64-এ তার prologue সাধারণত stp x29, x30, [sp, -16]! — frame pointer আর link register একসাথে stack-এ। কারণ নিজের bl x30-কে মুছে দেবে। আর Apple-এর ARM64 platform-এ variadic argument সবসময় stack-এ যায়, register-এ নয়।

৮ · -O2 কী করে — একই কোড, সম্পূর্ণ অন্য চেহারা

এবার চালানো যায় এমন একটি প্রোগ্রাম নিই, আর তার main-এর assembly দুই optimization স্তরে পাশাপাশি রাখি:

#include <stdio.h>

int area(int w, int h) {
    return w * h;
}

int sum_to(int n) {
    int s = 0;
    for (int i = 1; i <= n; i++)
        s += i;
    return s;
}

int main(void) {
    int a = area(6, 7);
    int t = sum_to(100);
    printf("area = %d, sum = %d\n", a, t);
    return 0;
}

main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16                   # a আর t-এর জায়গা
        mov     esi, 7
        mov     edi, 6
        call    area                      # সত্যিকারের কল
        mov     DWORD PTR [rbp-4], eax    # a = ফল
        mov     edi, 100
        call    sum_to                    # ভেতরে ১০০ বার ঘোরা লুপ
        mov     DWORD PTR [rbp-8], eax    # t = ফল
        mov     edx, DWORD PTR [rbp-8]    # printf-এর ৩য় argument
        mov     eax, DWORD PTR [rbp-4]
        mov     esi, eax                  # ২য় argument
        mov     edi, OFFSET FLAT:.LC0     # ১ম argument: format string
        mov     eax, 0                    # variadic: vector register ০টি
        call    printf
        mov     eax, 0                    # return 0
        leave
        ret

main:
        sub     rsp, 8                    # শুধু ১৬ বাইটের হিসাব মেলাতে
        mov     edx, 5050                 # sum_to(100) — আগেই হিসাব করা!
        mov     esi, 42                   # area(6, 7)  — আগেই হিসাব করা!
        xor     eax, eax                  # eax = 0 (mov-এর চেয়ে ছোট নির্দেশ)
        mov     edi, OFFSET FLAT:.LC0
        call    printf
        xor     eax, eax                  # return 0
        add     rsp, 8
        ret

এখানে দুটি optimization একসাথে কাজ করেছে। প্রথমে inlining: compiler area আর sum_to-এর দেহ main-এর ভেতরে বসিয়ে দিল। তারপর constant folding: সব মান যেহেতু আগে থেকেই জানা, হিসাবটাই compile-এর সময় সেরে ফেলল। আর rbp দিয়ে frame বানানোর প্রথাও উধাও — -O2-তে GCC rbp-কে সাধারণ register হিসেবে ব্যবহার করে। নিচের stepper-এ পুরো রূপান্তরটি ধাপে ধাপে দেখুন:

int sum_to(int n) {
    int s = 0;
    for (int i = 1; i <= n; i++)
        s += i;
    return s;
}

.L12:
        mov  eax, DWORD PTR [rbp-8]    # i মেমরি থেকে
        add  DWORD PTR [rbp-4], eax    # s += i, মেমরিতে
        add  DWORD PTR [rbp-8], 1      # i++, মেমরিতে
.L11:
        mov  eax, DWORD PTR [rbp-8]
        cmp  eax, DWORD PTR [rbp-20]   # i <= n ?
        jle  .L12

.L13:
        lea  edx, [rdx+1+rax*2]      # s += i + (i+1)
        add  eax, 2                    # i += 2
        cmp  eax, ecx
        jne  .L13
.L11:
        mov  eax, edx                  # ফল = s
        ret

main:
        sub  rsp, 8
        mov  edx, 5050
        mov  esi, 42
        xor  eax, eax
        mov  edi, OFFSET FLAT:.LC0
        call printf

.L6:
        movdqu  xmm2, XMMWORD PTR [rax]   # ১৬ বাইট = ৪টি int একসাথে
        add     rax, 16
        paddd   xmm0, xmm2              # ৪টি যোগ এক নির্দেশে
        cmp     rax, rdx
        jne     .L6

Optimizer আর undefined behavior

পর্ব ০৩-এ শুনেছিলেন, UB-ওয়ালা কোড -O0-তে “ঠিক” চলে, -O2-তে অদ্ভুত আচরণ করে। কারণ -O2-তে compiler ধরে নেয় আপনার কোডে UB নেই, আর সেই ভরসায় লুপ বদলায়, শর্ত বাদ দেয়। একটি signed overflow বা array-র সীমার বাইরে পড়া থাকলে সেই অনুমান ভেঙে পড়ে — পর্ব ৪৮-এ বাস্তব উদাহরণ দেখবেন।

একটি সুন্দর উদাহরণ two's complement থেকে: অংশ ৪-এর sign ফাংশন -O2-তে কোনো লাফ ছাড়াই হয়ে যায়:

sign:
        mov     eax, edi
        sar     eax, 31       # চিহ্নের বিট সব জায়গায় ছড়াও: x < 0 হলে -1 (সব ১), নইলে 0
        or      eax, 1        # -1 | 1 = -1,  0 | 1 = 1
        ret

volatile — optimizer-কে থামানোর একমাত্র কথা

পর্ব ৪৫-এ দেখেছিলেন, volatile বলে “এই মান পেছন থেকে বদলাতে পারে।” এখন তার অর্থ assembly-র ভাষায় বলা যায়: optimizer উপরের মতো মান register-এ রেখে দিতে বা হিসাব আগেই সেরে ফেলতে পারবে না — প্রতিটি পড়া ও লেখা সত্যিকারের mov হয়ে মেমরিতে যাবে, আর বাদ পড়বে না। Memory-mapped I/O-তে, যেখানে একটি “মেমরি ঠিকানা” আসলে কোনো যন্ত্রের রেজিস্টার, এটাই দরকার — পর্ব ৫৪-এ হাতেনাতে দেখবেন। কিন্তু মনে রাখুন, volatile কোনো lock বা memory barrier নির্দেশ বসায় না; thread-এর সমস্যা এটি সারায় না।

Inline assembly — খুব কম, খুব সাবধানে

কখনো কখনো C থেকে সরাসরি একটি বিশেষ instruction চালানো দরকার হয় — যেমন CPU-র cycle গোনার rdtsc. GCC আর Clang এর জন্য দেয় inline assembly (GCC extended asm). একটি সরল উদাহরণ, দুটি সংখ্যা যোগ:

long add_asm(long a, long b) {
    long r = a;
    __asm__("addq %1, %0"      /* AT&T: r = r + b              */
            : "+r"(r)          /* output: r পড়াও হবে, লেখাও হবে */
            : "r"(b)           /* input: b যেকোনো register-এ     */
            : "cc");           /* flag বদলায় — compiler-কে জানাও */
    return r;
}

এখানে instruction-এর লেখা AT&T ধরনে, কারণ GCC ডিফল্টভাবে assembly AT&T-তেই লেখে। ফাঁদগুলো বড়: এই কোড MSVC-তে চলবে না (x64 MSVC inline asm সমর্থনই করে না), ARM-এ চলবে না, আর constraint ("+r", "cc") ভুল দিলে compiler আপনার অজান্তে অন্য ভ্যারিয়েবলের register নষ্ট করবে। তাই আগে খুঁজুন compiler-এর তৈরি builtin বা intrinsic আছে কি না — যেমন rdtsc-এর জন্য __rdtsc(). সেগুলো compiler বোঝে, আর ভুলের সুযোগ কম।

৯ · Stack buffer overflow — return address কেন ঝুঁকিতে, আর প্রতিরক্ষা

এখন আপনি জানেন stack-এ কী কী পাশাপাশি থাকে: local array, সংরক্ষিত rbp, আর ফেরার ঠিকানা। array ছোট ঠিকানায়, ফেরার ঠিকানা বড় ঠিকানায়। কিন্তু strcpy বা লুপ array-তে লেখে ছোট থেকে বড় ঠিকানার দিকে। অর্থাৎ array-র সীমা পেরিয়ে লিখতে থাকলে লেখাটি ঠিক return address-এর দিকেই এগোয়। পর্ব ১৯ আর ৪৮-এর buffer overflow এই কারণেই এত গুরুতর: ফেরার ঠিকানা বদলে গেলে ret প্রোগ্রামকে অন্য কোথাও নিয়ে যায়।

এই অংশের উদ্দেশ্য সম্পূর্ণ প্রতিরক্ষামূলক: বোঝা যে কেন bounds check আর hardening flag জরুরি। নিচের ফাংশনটি -fstack-protector-strong দিয়ে compile করা; listing-টি আসল:

# void greet(const char *name) { char buf[16]; strcpy(buf, name); puts(buf); }
greet:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 48
        mov     QWORD PTR [rbp-40], rdi   # name
        mov     rax, QWORD PTR fs:40      # গোপন canary মান আনো
        mov     QWORD PTR [rbp-8], rax    # buf আর ফেরার ঠিকানার মাঝে রাখো
        xor     eax, eax                  # register থেকে মানটি মুছে দাও
        ...                               # strcpy(buf = [rbp-32], name); puts(buf)
        mov     rax, QWORD PTR [rbp-8]    # ফেরার আগে canary আবার পড়ো
        sub     rax, QWORD PTR fs:40      # আসলটির সাথে মেলাও
        je      .L5                       # মিললে স্বাভাবিকভাবে ফেরো
        call    __stack_chk_fail          # না মিললে: প্রোগ্রাম বন্ধ
.L5:
        leave
        ret

1void greet(const char *name) {2    char buf[16];  /* + canary */3    strcpy(buf, name);4    puts(buf);5}   /* canary যাচাই, তারপর ret */

প্রতিরক্ষার স্তর

১০ · AI-এর যুগে — assembly পড়তে AI, আর তার ফাঁদ

Godbolt-এর আউটপুট AI-কে দিয়ে “লাইন ধরে বুঝিয়ে দাও” বলা assembly শেখার দ্রুত একটি পথ। কিন্তু assembly-তে একটি অক্ষরের ভুলেও অর্থ উল্টে যায়, আর AI-এর ভুল সহজে চোখে পড়ে না।

AI-এর দেওয়া assembly বা ব্যাখ্যা হাতে পেলে — চেকলিস্ট

• Listing-টি কোন compiler, কোন flag, কোন OS-এর — নিশ্চিত হয়েছি (একই C কোড ভিন্ন ABI-তে ভিন্ন assembly)
• Syntax চিনেছি: % আর $ থাকলে AT&T (উৎস আগে), না থাকলে Intel (গন্তব্য আগে)
• Argument register আর ফলের register অংশ ৭-এর টেবিলের সাথে মিলিয়েছি
• AI-এর ব্যাখ্যার অন্তত একটি দাবি নিজে যাচাই করেছি — godbolt-এ flag বদলে বা gdb-তে stepi দিয়ে register দেখে
• Inline asm হলে: constraint আর clobber ঠিক আছে কি না দেখেছি, -O0 ও -O2 দুটোতেই চালিয়েছি, আর আগে builtin/intrinsic খুঁজেছি