LLVM技术问询：快速校验.ll文件一致性与编写差异量化Pass的可行性

1. Fastest Way to Check if Two .ll Files Are Identical #

First off, speed here depends on whether you need to ignore trivial, semantically irrelevant differences (like comment placement, instruction ordering, or auto-generated symbol names) or just do a raw byte-for-byte check.

• Raw, fastest check (no normalization): If you’re 100% sure the files were generated in exactly the same way with no irrelevant variations, use cmp directly:

  cmp file1.ll file2.ll
  

  cmp stops at the first byte mismatch and returns an exit code (0 = identical, non-zero = different) — it’s way faster than diff for just verifying equality.

• Normalized check (handles irrelevant differences): Most of the time, .ll files can have minor variations that don’t change semantics. For this, use LLVM’s built-in llvm-canonicalize to standardize both files first, then compare:

  # Canonicalize both files to eliminate irrelevant differences
  llvm-canonicalize file1.ll -o file1_canon.ll
  llvm-canonicalize file2.ll -o file2_canon.ll
  
  # Compare the canonicalized versions
  cmp file1_canon.ll file2_canon.ll
  

  llvm-canonicalize reorders instructions, standardizes symbol names, and strips non-essential metadata, so you’re comparing the semantic essence of the IR rather than surface-level syntax.

2. Can an LLVM Pass Check .ll File Consistency & Output Quantified Differences? #

Absolutely! An LLVM Pass is a perfect tool for this, especially if you want to go beyond a simple "same/different" result and measure how different the two modules are quantitatively.

Here’s how to approach it:

Step 1: Build a Pass to Collect Module/Function Features #

Write a ModulePass that traverses the IR and collects structured, comparable metrics. For example:

• Total number of functions, basic blocks, and instructions
• Hash values for each function’s instruction sequence (to detect structural changes)
• Global variable count, types, and initial value hashes
• Call graph structure (e.g., number of unique function calls)

In your runOnModule method, iterate through functions, basic blocks, and instructions to tally these metrics, then serialize them to a file (like JSON or a custom binary format) or store them in a structured data object.

Step 2: Compare Features Between Two Modules #

Run the pass on both .ll files to generate their feature sets, then write a small driver tool (or extend the pass itself) to:

• Compare each metric pair (e.g., abs(total_instructions_1 - total_instructions_2))
• Sum up differences to create a single "difference score" (e.g., total instruction difference + number of mismatched function hashes + global variable count difference)
• Output specific details (e.g., "3 functions have different instruction sequences; total instruction count differs by 12")

Example Quantification Ideas #

• Simple numerical score: Sum the absolute differences of key metrics (function count, instruction count, global var count).
• Structural similarity score: Use hash comparisons (e.g., percentage of functions with matching instruction hashes).
• Semantic difference hints: If you want to go deeper, detect changes in function signatures, constant values, or control flow structure.

Just note: If you need to check semantic equivalence (i.e., do the two IR modules behave the same when executed?), that’s far more complex (requiring formal verification or symbolic execution). But for structural difference quantification, an LLVM Pass works beautifully.

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