Compiler Output পড়া — -O0 বনাম -O2

-O0 output — সম্পূর্ণ, লাইন বাই লাইন

gcc -O0 -S sum.c চালালে বাস্তবে যা পাওয়া যায় (x86-64, System V, arr আসে %rdi-তে, n আসে %esi-তে):

sum_array:
        pushq   %rbp
        movq    %rsp, %rbp
        movq    %rdi, -24(%rbp)
        movl    %esi, -28(%rbp)
        movl    $0, -4(%rbp)
        movl    $0, -8(%rbp)
        jmp     .L2
.L3:
        movl    -8(%rbp), %eax
        cltq
        leaq    0(,%rax,4), %rdx
        movq    -24(%rbp), %rax
        addq    %rdx, %rax
        movl    (%rax), %eax
        addl    %eax, -4(%rbp)
        addl    $1, -8(%rbp)
.L2:
        movl    -8(%rbp), %eax
        cmpl    -28(%rbp), %eax
        jl      .L3
        movl    -4(%rbp), %eax
        popq    %rbp
        ret

পুরো ২১ লাইন একটা তিন-লাইনের loop-এর জন্য। কেন এত verbose?

প্রতিটা variable-এর জন্য একটা fixed stack slot

movq    %rdi, -24(%rbp)     # arr   → স্ট্যাক frame-এর একটা fixed জায়গা
movl    %esi, -28(%rbp)     # n     → আরেকটা fixed জায়গা
movl    $0, -4(%rbp)        # total → আরেকটা
movl    $0, -8(%rbp)        # i     → আরেকটা

ফাংশন প্যারামিটার System V convention অনুযায়ী register-এ আসে (%rdi, %esi), কিন্তু -O0 সাথে সাথে সেগুলো স্ট্যাকে কপি করে দেয়। এমনকি total আর i, যাদের কোনো caller নেই — সরাসরি $0$ দিয়ে initialize হচ্ছে সরাসরি স্ট্যাক memory-তে, কোনো register হয়ে না।

কেন। -O0-এ কম্পাইলার ধরে নেয় প্রতিটা C variable-এর একটাই, স্থায়ী “ঠিকানা” থাকবে সম্পূর্ণ function জুড়ে — একটা register না, কারণ register allocation নিজেই একটা optimization pass যা -O0-এ বন্ধ। এই সিদ্ধান্তের একটা সরাসরি সুবিধা আছে যা নিচে “debugging” অংশে ব্যাখ্যা হবে।

প্রতিটা array access সম্পূর্ণ পুনরায় গণনা

Loop body-র প্রথম চার লাইন লক্ষ্য করুন:

movl    -8(%rbp), %eax      # eax = i          (স্ট্যাক থেকে আবার পড়া)
cltq                         # rax = sign-extend(eax)
leaq    0(,%rax,4), %rdx    # rdx = i * 4
movq    -24(%rbp), %rax     # rax = arr        (স্ট্যাক থেকে আবার পড়া)
addq    %rdx, %rax          # rax = arr + i*4
movl    (%rax), %eax        # eax = *(arr+i*4) = arr[i]

গত লেসনে (addressing-and-pointers) আমরা দেখেছিলাম arr[i] একটা একক instruction-এ (movl (%rdi,%rax,4), %eax) SIB byte দিয়ে এনকোড হতে পারে — base, index, scale সবই memory operand-এর ভেতর। কিন্তু এখানে -O0 সেই সুযোগ ব্যবহার করেনি — প্রতিটা sub-expression (i পড়া, sign-extend করা, ×4 করা, arr পড়া, যোগ করা, dereference করা) আলাদা আলাদা instruction-এ, প্রতিটা মধ্যবর্তী ফলাফল register-এ বসিয়ে।

Loop-এর গঠন — condition-first, তবু test নিচে

        movl    $0, -8(%rbp)   # i = 0
        jmp     .L2             # সরাসরি condition check-এ লাফ
.L3:
        ; ... body ...
        addl    $1, -8(%rbp)   # i++
.L2:
        movl    -8(%rbp), %eax
        cmpl    -28(%rbp), %eax
        jl      .L3             # if i \< n, আবার body-তে

C-তে for loop condition-প্রথম (body চালানোর আগেই i \< n চেক হয়)। এখানে প্রথম jmp .L2 সেই semantics ধরে রাখে — body-তে না গিয়ে সরাসরি condition check-এ যায়। এরপর body-র শেষে পড়ে যায় .L2-তে, যেখানে condition আবার চেক হয়ে .L3-এ ফিরে যায় যদি সত্য হয়।

এই “condition একবার প্রথমে জাম্প করে, তারপর নিচে সবসময়” প্যাটার্নটা এমনকি -O0-এই দেখা যায় — এটা optimization না, এটা শুধু একটা uniform compilation strategy যা প্রতিটা loop-এই কম্পাইলার নিঃশর্তভাবে প্রয়োগ করে (control-flow-in-assembly লেসনের সেই “loop = condition

• backward jump” প্যাটার্নের একটা variant)।

-O2 output — একই function, সম্পূর্ণ ভিন্ন আকার

এখন একই sum.c, gcc -O2 -S:

sum_array:
        testl   %esi, %esi
        jle     .L4
        movl    %esi, %edx
        xorl    %eax, %eax
        xorl    %ecx, %ecx
.L3:
        addl    (%rdi,%rax,4), %ecx
        addq    $1, %rax
        cmpq    %rax, %rdx
        jne     .L3
        movl    %ecx, %eax
        ret
.L4:
        xorl    %eax, %eax
        ret

১৩ লাইন, কোনো স্ট্যাক অ্যাক্সেস নেই, কোনো %rbp ফ্রেম নেই। প্রতিটা পার্থক্য এক এক করে দেখি।

১. কোনো stack frame নেই

pushq %rbp / movq %rsp, %rbp / popq %rbp — সব উধাও। কেন? এই function-এ local variable-এর কোনো ঠিকানা কখনো নেওয়া হয় না (&total বা &i কোথাও ব্যবহৃত হয়নি), আর কোনো nested function call নেই যার জন্য একটা স্থিতিশীল frame pointer দরকার — তাই কম্পাইলার পুরো frame-setup-ই বাদ দিয়েছে। total আর i এখন শুধুই register-এর মান, কোনো memory ঠিকানা নেই — তাই frame pointer রাখার কোনো কারণ নেই।

২. n <= 0 কেসটা আলাদা করে ফেলা হলো

testl   %esi, %esi
jle     .L4

এটা মূল loop-এর আগেই — n যদি ০ বা negative হয়, সরাসরি .L4-এ লাফ দিয়ে ০ রিটার্ন করে, মূল loop-এ ঢোকেই না। C-এর for (i=0; i<n; i++)-এ এই কেসটা “loop body ০ বার চলে” হিসেবে স্বাভাবিকভাবেই হ্যান্ডেল হতো, কিন্তু এভাবে আলাদা করে ফেললে মূল loop-টাকে (নিচে) আরও সরল রাখা যায় — একটা edge-case check প্রতিটা iteration-এ বারবার না করে, একবারই, শুরুতে।

৩. Total ও i সম্পূর্ণ loop জুড়ে register-এ থাকে

xorl    %eax, %eax      # i = 0 (rax)
xorl    %ecx, %ecx      # total = 0 (ecx)
.L3:
        addl    (%rdi,%rax,4), %ecx   # total += arr[i]
        addq    $1, %rax               # i++

%rax (index/counter) আর %ecx (accumulator) — এই দুইটা register পুরো loop-এর জীবনভর একই জায়গায় থাকে। কোনো স্ট্যাক write/read নেই কোথাও loop-এর ভেতরে। এটাই register allocation-এর মূল কাজ — প্রতিটা frequently-used variable-কে একটা register-এ “বাঁধা” যতক্ষণ সম্ভব, memory access সম্পূর্ণ এড়িয়ে।

৪. Load আর add একটা instruction-এ fuse হয়ে গেছে

addl    (%rdi,%rax,4), %ecx

-O0-এ এই একই কাজ লেগেছিল ছয়টা instruction (arr[i] পড়তে) + একটা addl (যোগ করতে) = সাত। এখানে একটা instruction — x86-64-এর ALU instruction-গুলোর একটা operand সরাসরি memory হতে পারে (গত লেসনের addressing mode, এখানে source operand হিসেবে ব্যবহৃত)। CPU নিজেই memory থেকে পড়ে, %ecx-এর সাথে যোগ করে, %ecx-এ ফেরত লেখে — সব এক instruction fetch/decode-এ।

৫. i কখনো sign-extend করতে হয়নি

-O0-এ cltq (sign-extend) প্রতিটা iteration-এ লাগত, কারণ i একটা ৩২-বিট int হিসেবে স্ট্যাকে বসানো ছিল, প্রতিবার আবার পড়ে ৬৪-বিটে বদলাতে হতো। -O2-এ কম্পাইলার লক্ষ্য করেছে — i শুধু 0 থেকে গুণে গুণে বাড়ে, আর সরাসরি একটা ৬৪-বিট register-এ (%rax) রাখা যায় শুরু থেকেই, কোনো ৩২-বিট আকারে বাঁধা না রেখে। ফলে sign-extension-এর প্রয়োজনই আর নেই — এটা একটা classic strength reduction/induction variable optimization।

৬. Return value-এর জন্য একটা শেষ কপি

movl    %ecx, %eax
ret

x86-64 System V-তে return value যেতেই হবে %eax-এ, কিন্তু accumulator রাখা হয়েছিল %ecx-এ (কারণ %eax/%rax ইতিমধ্যে index-এর জন্য ব্যবহৃত হচ্ছিল লুপের ভেতর) — তাই শেষে একটা movl লাগলো। এটাই একমাত্র জায়গা যেখানে register allocator-এর সিদ্ধান্তের একটা ছোট “দাম” দেখা যাচ্ছে — সম্পূর্ণ বিনামূল্যে optimization হয় না, প্রতিটা সিদ্ধান্তে trade-off থাকে।

বোনাস — -O3-এ কী হতে পারে

-O2 GCC-তে loop vectorization (-ftree-vectorize) সক্রিয় করে না — এটা -O3-এর অংশ (Clang-এ নিয়ম ভিন্ন, সেখানে -O2-ই vectorize করতে পারে)। এই function যদি -O3-এ কম্পাইল করা হয়, computer-architecture module-এর SIMD লেসনের ধারণাগুলো সরাসরি চোখে পড়বে — কোরের অংশ:

        pxor    %xmm0, %xmm0
.L6:
        movdqu  (%rdi,%rax,4), %xmm1
        addq    $4, %rax
        paddd   %xmm1, %xmm0
        cmpq    %rax, %rdx
        jne     .L6
        movdqa  %xmm0, %xmm1
        psrldq  $8, %xmm1
        paddd   %xmm1, %xmm0
        movdqa  %xmm0, %xmm1
        psrldq  $4, %xmm1
        paddd   %xmm1, %xmm0
        movd    %xmm0, %eax

movdqu/paddd — একটা instruction চারটা int একসাথে যোগ করছে (SIMD, ১২৮-বিট %xmm0 register)। শেষের তিনটা psrldq/paddd জোড়া horizontal reduction — চার-উপাদানের vector-কে একটা scalar-এ নামানো (shift করে অর্ধেক নিজের সাথে যোগ, দুইবার)।

এই লেসনের মূল ফোকাস -O0 বনাম -O2-ই থাকবে, কারণ সেই পার্থক্যটাই সবচেয়ে সাধারণ ও শেখার জন্য সবচেয়ে স্পষ্ট। Vectorization একটা সম্পূর্ণ আলাদা মাত্রার optimization — SIMD লেসনে এটা বিস্তারিত।