GCC - Clang flags — optimization (-O0 to -O3, -Os), warnings (-Wall, -Wextra), sanitizers

5.3.11 · Coding › Build Systems & Toolchain

WHY do flags exist at all?

Flag student ka lever hai invariant pe: same observable program behaviour, different machine code. Optimization tabhi legal hai kyunki C/C++ standard kehta hai compiler kuch bhi kar sakta hai jab tak wo ek correct program ka "as-if" observable behaviour preserve kare. Agar aapke program mein undefined behaviour (UB) hai, toh wo contract void ho jaata hai — aur -O2 use "miscompile" kar sakta hai. Yahi deep reason hai ki sanitizers exist karte hain.

Optimization levels: -O0 to -O3, -Os

Deriving why `-O0` is slow — from first principles

Consider int s=0; for(int i=0;i<n;i++) s+=a[i];

Worked example What

-O0 literally emits (conceptually)

; each iteration:
load i from stack        ; i is NOT in a register at -O0
compare i, n
jump-if-ge end
load a-base from stack
compute a-base + i*4
load a[i] from memory
load s from stack
add s, a[i]
store s to stack         ; write back every iteration
...

Ye step kyun? -O0 pe compiler s aur i ko memory mein rakhta hai taaki ek debugger unhe kisi bhi breakpoint pe read/modify kar sake. Har iteration load+store traffic ka cost pay karta hai.

Figure — GCC - Clang flags — optimization (-O0 to -O3, -Os), warnings (-Wall, -Wextra), sanitizers

Warnings: -Wall and -Wextra

Worked example A real catch

unsigned n = 5;
if (n - 10 < 0) puts("neg");   // never prints!

Kyun? n-10 unsigned hai; 5u - 10u wrap hokar ek bada positive number ban jaata hai, isliye < 0 hamesha false hota hai. -Wall (-Wsign-compare/-Wtype-limits ke zariye) ise flag karta hai. Fix: signed types use karo ya if ((int)n - 10 < 0).

Sanitizers: -fsanitize=...

Worked example ASan catching a heap overflow

int *p = malloc(4 * sizeof(int)); // valid: p[0..3]
p[4] = 1;                         // OOB write

Compile: clang -fsanitize=address -g overflow.c Run → heap-buffer-overflow ... WRITE of size 4 ... 0 bytes after. Ye step kyun? p[4] poisoned redzone mein land karta hai; instrumented store shadow memory check karta hai aur exact line ke saath abort karta hai.

Common Mistakes (Steel-manned)

Putting it together (the 80/20 recipes)

Flashcards

Agar koi -O flag nahi diya toh default optimization level kya hoga?

-O0 (no optimization).

Recommended production default optimization level kaunsa hai?

-O2.

-O3 kyun -O2 se slow ho sakta hai?

Aggressive inlining/vectorization code badhaata hai aur instruction cache thrash kar sakta hai; optimization "bets" hamesha pay off nahi karti.

-Os kiske liye optimize karta hai?

Binary size ke liye (-O2 jaisa minus size-bloating passes).

Kya -Wall saari warnings enable karta hai?

Nahi — ye ek common-bug subset hai; fuller coverage ke liye -Wall -Wextra (plus others) use karo.

-Werror kya karta hai?

Warnings ko errors mein promote karta hai taaki build fail ho.

Ek program "-O0 pe kaam karta hai lekin -O2 pe crash karta hai" aisa kyun hota hai?

Almost hamesha undefined behaviour ki wajah se; optimizer legally assume karta hai UB kabhi nahi hota. Sanitizers se detect karo.

AddressSanitizer overflows kaise detect karta hai?

Shadow memory + allocations ke aas-paas poisoned redzones; har load/store shadow byte check karta hai.

ASan roughly kitna runtime cost add karta hai?

~2× slow, ~3× zyada memory.

Sabse saste default bug net ke liye kaunse do sanitizers use karo?

-fsanitize=address aur -fsanitize=undefined.

Sanitizers ko -O3 ki jagah -O1 -g pe kyun compile karo?

-O3 us UB ko optimize away kar sakta hai jo tum pakadna chahte ho; -g aur -O1 reports readable rakhte hain aur fast bhi hote hain.

Kya -fsanitize=address link time pe bhi pass karna zaroori hai?

Haan — ye ek runtime library pull karta hai.

-Og ka matlab kya hai?

Debugging ke liye optimize karo: -O0 se faster jab ki debug info usable bhi rakhe.

Optimizer ko machine code freely change karne dene wala legal principle kaunsa hai?

"As-if" rule: sirf ek correct program ka observable behaviour preserve karo.

Recall Feynman: explain to a 12-year-old

Socho tumne ek Lego castle banane ke instructions likhe. -O0 tumhare steps exactly follow karta hai, chahe silly kyun na ho, isliye check karna easy hai lekin slow hai. -O2/-O3 ek clever builder hai jo waste move skip karta hai taaki jaldi khatam ho — lekin sirf isliye kyunki tumhare instructions sensible the. Warnings ek dost hai jo tumhare shoulder pe padhte hue kehta hai "hey, tum ek piece bhool gaye." Sanitizers ek referee hai jo tumhare Lego pile ke aas-paas floor ko invisible "no-step" paint se paint karta hai; jaise hi tum bahar kadam rakhte ho, alarm bajta hai aur exactly dikhata hai kahan. Clever builder trust karta hai ki tum kabhi boundary se bahar nahi jaate — isliye agar jaao, cheezein weirdly break hoti hain. Referee tumhe karte hue pakad leta hai.

Connections

Compilation Pipeline (preprocess-compile-assemble-link)
Undefined Behaviour in C/C++
Makefiles and CFLAGS/LDFLAGS
CPU Caches and Instruction Cache
SIMD and Auto-Vectorization
Debugging with GDB and -g
Continuous Integration pipelines