如何无需遍历函数直接遍历程序中的所有基本块？

Absolutely! You don’t have to stick to nested function-then-basic-block iteration—many common IR frameworks and static analysis toolchains let you iterate directly over all basic blocks in a program, no function nesting required. The approach depends on which tool you’re using, so let’s break down the options for popular platforms:

• LLVM
  LLVM doesn’t ship with a native global basic block iterator out of the box, but it’s trivial to wrap the nested iteration logic into a reusable range or helper. For example, you can create a custom range adapter that flattens all basic blocks across every function in a module:

  #include <llvm/IR/Module.h>
  #include <llvm/ADT/STLExtras.h>
  
  auto allBasicBlocks(llvm::Module &Mod) {
    return llvm::make_range(
      llvm::map_range(Mod, [](llvm::Function &Func) {
        return llvm::make_range(Func);
      })
    );
  }
  
  // Usage is clean and looks like a standalone iterator:
  for (auto &BB : allBasicBlocks(myModule)) {
    // Process your basic block here
    errs() << "BB Name: " << BB.getName() << "\n";
  }
  

  Alternatively, you can use LLVM's for_each utility to hide the nesting entirely:

  llvm::for_each(myModule, [](llvm::Function &Func) {
    llvm::for_each(Func, [](llvm::BasicBlock &BB) {
      // Process BB
    });
  });
  

• GCC/GIMPLE
  In GCC's plugin API, you can traverse all functions via the all_functions linked list, but you can wrap this with basic block iteration to create a "global" BB loop. For example, using GCC's built-in macros:

  // A wrapper macro to iterate all BBs across all functions
  #define FOR_EACH_BB_IN_PROGRAM(BB) \
    FOR_EACH_FUNCTION(FN) \
      FOR_EACH_BB_FN(BB, FN)
  
  // Usage
  basic_block *BB;
  FOR_EACH_BB_IN_PROGRAM(BB) {
    // Work with BB
  }
  

  This macro abstracts away the nested loops, giving you a flat iteration experience.

• Custom Static Analysis Tools
  If you're building your own tool from scratch, you can simply maintain a global list or vector of basic blocks as you parse the program. Every time you encounter a basic block (regardless of which function it's in), add it to this list. Later, you can iterate directly over the list with zero nesting—perfect for use cases where you don't care about function boundaries.

• Clang AST
  For Clang's abstract syntax tree (AST), you can use a RecursiveASTVisitor to collect all basic block-related nodes (like CompoundStmt or IfStmt bodies) across all function declarations. You can extend the visitor to populate a global list of these blocks, then iterate over the list directly once parsing is complete.

The key takeaway here is that even if a framework doesn't provide a native standalone basic block iterator, you can always encapsulate the nested traversal logic into a helper, macro, or range adapter that feels like a dedicated iterator. This keeps your code clean and focused on processing blocks, rather than worrying about function hierarchy.

内容的提问来源于stack exchange，提问作者Diana Vazquez Romo