Hey there! It sounds like you're hitting a tricky edge case where LLVM's loop unroll pass is fully expanding your loops instead of respecting your specified unroll factors (1-4) once your code gets more complex. Let's walk through the most likely culprits and fixes:

1. Double-Check Your Unroll Pass Parameters #

First off, make sure you're explicitly telling LLVM to use your desired unroll factor and disabling automatic full unrolling. The default behavior of the loop-unroll pass will sometimes fully unroll loops if it detects small, known iteration counts—especially in complex code where constant propagation might reveal loop bounds you didn't expect.

For older LLVM versions using the legacy pass manager, use these flags:

opt -loop-unroll -unroll-count=YOUR_FACTOR -unroll-allow-partial your_input.bc -o unrolled_output.bc

• -unroll-count=YOUR_FACTOR: Forces the pass to use your specified factor (1-4)
• -unroll-allow-partial: Lets the pass handle loops where iteration counts aren't perfectly divisible by your factor

For newer LLVM versions (14+) using the new pass manager, the syntax shifts slightly:

opt -passes="loop-unroll<unroll-count=YOUR_FACTOR,allow-partial=true>" your_input.bc -o unrolled_output.bc

If you skip the -unroll-count flag entirely, LLVM will make its own call about whether to fully unroll—this is probably what's happening with your complex code.

2. Verify LLVM's Loop Iteration Count Analysis #

LLVM's loop analysis pass might be detecting that your complex loop has a small, constant iteration count (even if it doesn't look that way to you!). When it sees a loop that runs, say, 3 times, it'll ignore your unroll factor and fully expand it automatically.

To check what LLVM thinks about your loop's iteration count, run:

opt -analyze -loop-info your_input.bc

Look for lines like Loop %loop has an estimated iteration count of 4—if that number is small (<= your max unroll factor), LLVM will prioritize full unrolling.

To override this, add the -unroll-max-count=YOUR_FACTOR flag to cap the maximum number of iterations LLVM will fully unroll:

opt -loop-unroll -unroll-count=YOUR_FACTOR -unroll-max-count=YOUR_FACTOR -unroll-allow-partial your_input.bc -o unrolled_output.bc

3. Check if Pre-Run Passes Are Prematurely Unrolling Loops #

You mentioned running "recommended passes" before the loop unroll step—some optimization passes (like those included in -O1/-O2) automatically include loop unrolling. If you compiled your bitcode with anything higher than -O0, or if your pre-run passes include something like -loop-unroll accidentally, your loops might already be fully expanded before you even run your targeted unroll step.

First, make sure you compile your initial bitcode without automatic optimizations:

clang -O0 -emit-llvm your_code.c -o your_input.bc

Then, review your pre-run passes to ensure none of them are triggering unrolling. For example, passes like -mem2reg, -instcombine, or -loop-simplify are safe, but avoid any pass with "unroll" in the name until your targeted step.

4. Standardize Complex Loop Structures #

Complex code often has messy loop control flow (nested loops, conditional exits inside loops, multiple back edges) that LLVM can't easily handle with standard unrolling. Instead of respecting your factor, it might fully unroll the loop to simplify the control flow.

Fix this by first running the -loop-simplify pass to normalize your loop structure into LLVM's preferred form:

opt -loop-simplify your_input.bc -o simplified_input.bc

Then run your loop unroll pass on the simplified bitcode—this gives the unroll pass a clean structure to work with, making it more likely to respect your specified factor.

5. Force Disable Full Unrolling as a Last Resort #

If all else fails, you can set an extremely high threshold for full unrolling, effectively disabling the behavior for your loops. Use the -unroll-full-threshold flag to set a number way larger than your loop's maximum iteration count:

opt -loop-unroll -unroll-count=YOUR_FACTOR -unroll-full-threshold=1000 -unroll-allow-partial your_input.bc -o unrolled_output.bc

This tells LLVM only to fully unroll loops that run 1000+ times—something your complex code is unlikely to have.

内容的提问来源于stack exchange，提问作者Farhad