关于LLVM UserOp1、UserOp2指令的使用方法咨询及UserOp1示例诉求

Hey there! Let me break down how to work with LLVM's UserOp1 and UserOp2 instructions, plus share a concrete example for UserOp1 since you mentioned struggling to find one.

First off, these are reserved, user-definable instructions in LLVM IR. They don’t have any built-in semantic meaning—you get to define exactly what they do. They’re designed for cases where none of LLVM’s standard instructions fit your custom logic, like implementing domain-specific operations or experimenting with new optimizations.

Both UserOp1 and UserOp2 work identically; the only difference is their name, so you can use them to distinguish between separate custom operations if needed.

Let’s walk through a full example, from writing LLVM IR that uses UserOp1 to creating a pass that lowers it to standard LLVM instructions.

Step 1: LLVM IR with UserOp1 #

First, here’s how you’d declare and use UserOp1 in your IR. Note that you need to declare it as an intrinsic-like function with a name following the pattern llvm.userop1.<return-type>:

; Sample IR demonstrating UserOp1
define i32 @custom_calculation(i32 %x, i32 %y) {
entry:
  ; Call UserOp1 with two i32 arguments, expect an i32 result
  %res = call i32 @llvm.userop1.i32(i32 %x, i32 %y)
  ret i32 %res
}

; Required declaration for the UserOp1 intrinsic
declare i32 @llvm.userop1.i32(i32, i32)

Step 2: Lowering UserOp1 with a LLVM Pass #

Since LLVM doesn’t know what UserOp1 does, you need to process it in a pass to convert it to standard instructions (or handle it in code generation if you’re targeting specific hardware). Here’s a simple C++ pass that replaces UserOp1 with an addition operation:

#include "llvm/IR/Function.h"
#include "llvm/Pass.h"
#include "llvm/IR/Instructions.h"
#include "llvm/Support/raw_ostream.h"

using namespace llvm;

namespace {
struct UserOp1LoweringPass : public FunctionPass {
  static char ID;
  UserOp1LoweringPass() : FunctionPass(ID) {}

  bool runOnFunction(Function &F) override {
    bool Modified = false;
    // Iterate over basic blocks and instructions (use early_inc to avoid iterator invalidation)
    for (BasicBlock &BB : F) {
      for (Instruction &I : llvm::make_early_inc_range(BB)) {
        if (auto *Call = dyn_cast<CallInst>(&I)) {
          Function *Callee = Call->getCalledFunction();
          // Check if this is a UserOp1 call
          if (Callee && Callee->getName().startswith("llvm.userop1.")) {
            // Extract the two arguments passed to UserOp1
            Value *Arg1 = Call->getArgOperand(0);
            Value *Arg2 = Call->getArgOperand(1);
            // Create an add instruction to replace UserOp1
            Instruction *AddInst = BinaryOperator::Create(Instruction::Add, Arg1, Arg2, "userop1_add");
            AddInst->insertBefore(&I);
            // Replace all uses of the UserOp1 call with the add result
            Call->replaceAllUsesWith(AddInst);
            // Erase the original UserOp1 call
            Call->eraseFromParent();
            Modified = true;
          }
        }
      }
    }
    return Modified;
  }
};
} // namespace

char UserOp1LoweringPass::ID = 0;
static RegisterPass<UserOp1LoweringPass> X("lower-userop1", "Lower UserOp1 to standard add instruction");

After running this pass, the UserOp1 call in our IR will be replaced with a regular add instruction.

UserOp2 works exactly the same way—just replace userop1 with userop2 in the IR declaration and pass logic. For example, you could use UserOp2 to represent a multiplication operation, keeping it separate from UserOp1’s addition logic.

• Always declare the intrinsic: LLVM will throw an error if you use UserOp1/UserOp2 without declaring the corresponding function.
• Define clear semantics: Document exactly what your custom op does—since there’s no built-in meaning, your team (or future you) will need this context.
• Handle in code generation if needed: If you want to emit machine code directly for UserOp1/UserOp2 (instead of lowering to standard instructions), you’ll need to add support in your LLVM backend (e.g., using TableGen to define the instruction mapping).

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