This is my code: #include "llvm/IR/LegacyPassManager.h" #include "llvm/Passes/PassPlugin.h" #include "llvm/Passes/PassBuilder.h" #include "llvm/IR/PassManager.h" #include "llvm/IR/Instructions.h" #include "llvm/ADT/BitVector.h" #include <unordered_map> #include <queue> using namespace std; using namespace llvm; namespace { struct LivenessInfo { BitVector liveIn; BitVector liveOut; }; // This method implements what the pass does void visitor(Function &F){ string func_name = "main"; errs() << "Liveness analysis for function: " << F.getName() << "\n"; // Process each basic block in the function and initialize the live-out and live-in sets unordered_map<BasicBlock*, LivenessInfo> blockInfo; BitVector initialLiveOut(F.arg_size() + F.getBasicBlockList().size(), false); for (auto& basic_block : F) { LivenessInfo info; info.liveOut = initialLiveOut; info.liveIn.resize(F.arg_size() + F.getBasicBlockList().size(), false); // initialize live-in set to empty blockInfo[&basic_block] = info; } // Creates a worklist of basic blocks to process, starting with the exit block queue<BasicBlock*> worklist; auto exitBlock = &F.back(); auto& exitInfo = blockInfo[exitBlock]; worklist.push(exitBlock); exitInfo.liveOut = BitVector(initialLiveOut.size(), false); // initialize live-out set for exit block to empty // Compute the live-out set for each basic block while (!worklist.empty()) { auto block = worklist.front(); worklist.pop(); // Compute the live-out set by taking the union of the live-in sets of successors auto& info = blockInfo[block]; for (auto it = succ_begin(block); it != succ_end(block); ++it) { auto& succInfo = blockInfo[*it]; info.liveOut |= succInfo.liveIn; } // Compute the live-in set based on the live-out set and the instructions in the block BitVector liveIn(info.liveOut); for (auto it = block->rbegin(); it != block->rend(); ++it) { auto inst = &*it; // Remove variables defined by the instruction from the live-in set if (auto store = dyn_cast<StoreInst>(inst)) { auto var = store->getPointerOperand(); size_t varIndex = F.arg_size() + var->getName().substr(1).getAsInteger(10, varIndex); liveIn.reset(varIndex); } // Add variables used by the instruction to the live-in set for (auto op = inst->op_begin(); op != inst->op_end(); ++op) { if (auto var = dyn_cast<Instruction>(*op)) { size_t varIndex = F.arg_size() + var->getName().substr(1).getAsInteger(10, varIndex); liveIn.set(varIndex); } } } // Update the live-in set for the current block info.liveIn = liveIn; // Add the predecessors of the block to the worklist, if not already processed for (auto it = pred_begin(block); it != pred_end(block); ++it) { auto predBlock = *it; if (blockInfo[predBlock].liveOut != liveIn) { worklist.push(predBlock); } } } // Print the live-in and live-out sets for each basic block for (auto& basic_block : F) { errs() << "-----" << basic_block.getName() << "-----" << "\n"; auto& info = blockInfo[&basic_block]; errs() << "UEVAR: "; for (int i = 0; i < F.arg_size(); i++) { if (inf.

1. This is my code:
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Passes/PassPlugin.h"
#include "llvm/Passes/PassBuilder.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/Instructions.h"
#include "llvm/ADT/BitVector.h"
#include <unordered_map>
#include <queue>
using namespace std;
using namespace llvm;
namespace {
struct LivenessInfo {
BitVector liveIn;
BitVector liveOut;
};
// This method implements what the pass does
void visitor(Function &F){

2. string func_name = "main";
errs() << "Liveness analysis for function: " << F.getName() << "n";
// Process each basic block in the function and initialize the live-out and live-in sets
unordered_map<BasicBlock*, LivenessInfo> blockInfo;
BitVector initialLiveOut(F.arg_size() + F.getBasicBlockList().size(), false);
for (auto& basic_block : F) {
LivenessInfo info;
info.liveOut = initialLiveOut;
info.liveIn.resize(F.arg_size() + F.getBasicBlockList().size(), false); // initialize live-in set to
empty
blockInfo[&basic_block] = info;
}
// Creates a worklist of basic blocks to process, starting with the exit block
queue<BasicBlock*> worklist;
auto exitBlock = &F.back();
auto& exitInfo = blockInfo[exitBlock];
worklist.push(exitBlock);
exitInfo.liveOut = BitVector(initialLiveOut.size(), false); // initialize live-out set for exit block to
empty
// Compute the live-out set for each basic block

3. while (!worklist.empty()) {
auto block = worklist.front();
worklist.pop();
// Compute the live-out set by taking the union of the live-in sets of successors
auto& info = blockInfo[block];
for (auto it = succ_begin(block); it != succ_end(block); ++it) {
auto& succInfo = blockInfo[*it];
info.liveOut |= succInfo.liveIn;
}
// Compute the live-in set based on the live-out set and the instructions in the block
BitVector liveIn(info.liveOut);
for (auto it = block->rbegin(); it != block->rend(); ++it) {
auto inst = &*it;
// Remove variables defined by the instruction from the live-in set
if (auto store = dyn_cast<StoreInst>(inst)) {
auto var = store->getPointerOperand();
size_t varIndex = F.arg_size() + var->getName().substr(1).getAsInteger(10, varIndex);
liveIn.reset(varIndex);
}
// Add variables used by the instruction to the live-in set
for (auto op = inst->op_begin(); op != inst->op_end(); ++op) {

4. if (auto var = dyn_cast<Instruction>(*op)) {
size_t varIndex = F.arg_size() + var->getName().substr(1).getAsInteger(10, varIndex);
liveIn.set(varIndex);
}
}
}
// Update the live-in set for the current block
info.liveIn = liveIn;
// Add the predecessors of the block to the worklist, if not already processed
for (auto it = pred_begin(block); it != pred_end(block); ++it) {
auto predBlock = *it;
if (blockInfo[predBlock].liveOut != liveIn) {
worklist.push(predBlock);
}
}
}
// Print the live-in and live-out sets for each basic block
for (auto& basic_block : F) {
errs() << "-----" << basic_block.getName() << "-----" << "n";
auto& info = blockInfo[&basic_block];
errs() << "UEVAR: ";

5. for (int i = 0; i < F.arg_size(); i++) {
if (info.liveIn[i]) {
auto arg = F.getArg(i);
errs() << arg->getName() << " ";
}
}
errs() << "nVARKILL: ";
for (int i = 0; i < F.arg_size(); i++) {
if (info.liveOut[i] && info.liveIn[i]) {
auto arg = F.getArg(i);
errs() << arg->getName() << " ";
}
}
errs() << "nLIVEOUT: ";
for (int i = 0; i < F.arg_size(); i++) {
if (info.liveOut[i]) {
auto arg = F.getArg(i);
errs() << arg->getName() << " ";
}
}
errs() << "n";
}
}

6. }
struct ValueNumberingPass : public PassInfoMixin<ValueNumberingPass> {
// The first argument of the run() function defines on what level
// of granularity your pass will run (e.g. Module, Function).
// The second argument is the corresponding AnalysisManager
// (e.g ModuleAnalysisManager, FunctionAnalysisManager)
PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
visitor(F);
return PreservedAnalyses::all();
}
static bool isRequired() { return true; }
};
//-----------------------------------------------------------------------------
// New PM Registration
//-----------------------------------------------------------------------------
extern "C" ::llvm::PassPluginLibraryInfo LLVM_ATTRIBUTE_WEAK
llvmGetPassPluginInfo() {
return {
LLVM_PLUGIN_API_VERSION, "ValueNumberingPass", LLVM_VERSION_STRING,
[](PassBuilder &PB) {

7. PB.registerPipelineParsingCallback(
[](StringRef Name, FunctionPassManager &FPM,
ArrayRef<PassBuilder::PipelineElement>) {
if (Name == "value-numbering") {
FPM.addPass(ValueNumberingPass());
return true;
}
return false;
});
}};
}
I am running the pass with this input file:
; ModuleID = 'test1.c'
source_filename = "test1.c"
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-
S128"
target triple = "x86_64-apple-macosx12.0.0"
; Function Attrs: noinline nounwind optnone ssp uwtable
define void @test() #0 {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4

8. %c = alloca i32, align 4
%e = alloca i32, align 4
%0 = load i32, i32* %b, align 4
%1 = load i32, i32* %c, align 4
%add = add nsw i32 %0, %1
store i32 %add, i32* %e, align 4
%2 = load i32, i32* %e, align 4
%cmp = icmp sgt i32 %2, 0
br i1 %cmp, label %if.then, label %if.else
if.then: ; preds = %entry
%3 = load i32, i32* %a, align 4
store i32 %3, i32* %e, align 4
br label %if.end
if.else: ; preds = %entry
%4 = load i32, i32* %b, align 4
%5 = load i32, i32* %c, align 4
%add1 = add nsw i32 %4, %5
store i32 %add1, i32* %a, align 4
br label %if.end
if.end: ; preds = %if.else, %if.then

9. %6 = load i32, i32* %e, align 4
%7 = load i32, i32* %c, align 4
%add2 = add nsw i32 %6, %7
store i32 %add2, i32* %a, align 4
ret void
}
attributes #0 = { noinline nounwind optnone ssp uwtable "frame-pointer"="all" "min-legal-
vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-
cpu"="penryn" "target-
features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "tune-
cpu"="generic" }
!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}
!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 7, !"PIC Level", i32 2}
!2 = !{i32 7, !"uwtable", i32 2}
!3 = !{i32 7, !"frame-pointer", i32 2}
!4 = !{!"Homebrew clang version 15.0.7"}
My output is this:
Liveness analysis for function: test
-----entry-----

10. UEVAR:
VARKILL:
LIVEOUT:
-----if.then-----
UEVAR:
VARKILL:
LIVEOUT:
-----if.else-----
UEVAR:
VARKILL:
LIVEOUT:
-----if.end-----
UEVAR:
VARKILL:
LIVEOUT:
Instead of this:
----- entry -----
UEVAR: b c
VARKILL: e
LIVEOUT: a b c e
----- if.then -----
UEVAR: a
VARKILL: e

11. LIVEOUT: c e
----- if.else -----
UEVAR: b c
VARKILL: a
LIVEOUT: c e
----- if.end -----
UEVAR: c e
VARKILL: a
LIVEOUT:
What Am I doing wrong?
----- entry -----
UEVAR: b c
VARKILL: e
LIVEOUT: a b c e
----- if.then -----
UEVAR: a
VARKILL: e
LIVEOUT: c e
----- if.else -----
UEVAR: b c
VARKILL: a
LIVEOUT: c e
----- if.end -----

12. UEVAR: c e
VARKILL: a
LIVEOUT: