// MyAnalysis.h
#ifndef LLVM_TRANSFORMS_MYANALYSIS_H
#define LLVM_TRANSFORMS_MYANALYSIS_H

#include "llvm/IR/PassManager.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"

namespace llvm {

// 分析结果
struct MyAnalysisInfo {
    unsigned InstCount;
    unsigned BBCount;
    unsigned ArgCount;
    bool HasLoops;
};

// 分析 Pass
class MyAnalysis : public AnalysisInfoMixin<MyAnalysis> {
    friend AnalysisInfoMixin<MyAnalysis>;
    static AnalysisKey Key;

public:
    using Result = MyAnalysisInfo;

    Result run(Function &F, FunctionAnalysisManager &AM);
};

} // namespace llvm

#endif

// MyAnalysis.cpp
#include "MyAnalysis.h"
#include "llvm/IR/Instructions.h"

namespace llvm {

AnalysisKey MyAnalysis::Key;

MyAnalysis::Result MyAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
    MyAnalysisInfo Info;
    Info.InstCount = 0;
    Info.BBCount = 0;
    Info.ArgCount = F.arg_size();
    Info.HasLoops = false;

    for (auto &BB : F) {
        Info.BBCount++;
        for (auto &I : BB) {
            Info.InstCount++;
        }
    }

    // 简单检测循环（有回边）
    for (auto &BB : F) {
        Instruction *Terminator = BB.getTerminator();
        for (unsigned i = 0; i < Terminator->getNumSuccessors(); i++) {
            BasicBlock *Succ = Terminator->getSuccessor(i);
            // 如果后继支配当前块，说明有循环
            // (简化实现，实际应使用 LoopInfo)
            if (&BB >= Succ) {
                Info.HasLoops = true;
            }
        }
    }

    outs() << "=== MyAnalysis: " << F.getName() << " ===\n"
           << "  指令数: " << Info.InstCount << "\n"
           << "  基本块: " << Info.BBCount << "\n"
           << "  参数数: " << Info.ArgCount << "\n"
           << "  有循环: " << (Info.HasLoops ? "是" : "否") << "\n";

    return Info;
}

} // namespace llvm

// MyTransform.h
#ifndef LLVM_TRANSFORMS_MYTRANSFORM_H
#define LLVM_TRANSFORMS_MYTRANSFORM_H

#include "llvm/IR/PassManager.h"

namespace llvm {

class MyTransformPass : public PassInfoMixin<MyTransformPass> {
public:
    PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
    static bool isRequired() { return true; }
};

} // namespace llvm

#endif

// MyTransform.cpp
#include "MyTransform.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Constants.h"
#include "llvm/Transforms/Utils/Local.h"

namespace llvm {

PreservedAnalyses MyTransformPass::run(Function &F, FunctionAnalysisManager &AM) {
    bool Changed = false;

    for (auto &BB : F) {
        // 示例：消除冗余的 add x, 0
        for (auto II = BB.begin(); II != BB.end(); ) {
            Instruction &I = *II++;

            if (auto *BO = dyn_cast<BinaryOperator>(&I)) {
                if (BO->getOpcode() == Instruction::Add) {
                    // 检查是否是 add x, 0
                    if (auto *C = dyn_cast<ConstantInt>(BO->getOperand(1))) {
                        if (C->isZero()) {
                            // 用 x 替换 add x, 0
                            BO->replaceAllUsesWith(BO->getOperand(0));
                            BO->eraseFromParent();
                            Changed = true;
                        }
                    }
                }
            }
        }
    }

    if (!Changed)
        return PreservedAnalyses::all();

    // 告诉 PassManager 我们修改了 IR
    PreservedAnalyses PA;
    PA.preserve<DominatorTreeAnalysis>();  // 保留支配树
    PA.preserve<LoopAnalysis>();           // 保留循环信息
    return PA;
}

} // namespace llvm

// 在 opt 工具中注册（通常不需要手动做）

// 方式一：通过 PassBuilder 插件
// my_plugin.cpp
#include "llvm/Passes/PassBuilder.h"
#include "llvm/Passes/PassPlugin.h"

using namespace llvm;

// 注册分析 Pass
PassPluginLibraryInfo getMyPluginInfo() {
    return {
        LLVM_PLUGIN_API_VERSION,
        "MyPlugin",
        LLVM_VERSION_STRING,
        [](PassBuilder &PB) {
            PB.registerAnalysisRegistrationCallback(
                [](FunctionAnalysisManager &FAM) {
                    FAM.registerPass([&] { return MyAnalysis(); });
                });

            PB.registerPipelineParsingCallback(
                [](StringRef Name, FunctionPassManager &FPM,
                   ArrayRef<PassBuilder::PipelineElement>) {
                    if (Name == "my-transform") {
                        FPM.addPass(MyTransformPass());
                        return true;
                    }
                    return false;
                });
        }
    };
}

extern "C" LLVM_ATTRIBUTE_WEAK ::llvm::PassPluginLibraryInfo llvmGetPassPluginInfo() {
    return getMyPluginInfo();
}

# 编译为共享库
clang -shared -fPIC -o libmyplugin.so my_plugin.cpp \
    $(llvm-config --cxxflags --ldflags --libs)

# 使用插件
opt -load-pass-plugin=./libmyplugin.so \
    -passes='my-transform' input.ll -o output.ll

// Legacy Function Pass 示例（仅供参考）
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"

namespace llvm {

class MyLegacyPass : public FunctionPass {
public:
    static char ID;
    MyLegacyPass() : FunctionPass(ID) {}

    bool runOnFunction(Function &F) override {
        bool Changed = false;
        // ... 优化逻辑 ...
        return Changed;
    }
};

char MyLegacyPass::ID = 0;
static RegisterPass<MyLegacyPass> X("my-pass", "My Legacy Pass");

} // namespace llvm

# 使用旧 PM（需要显式禁用新 PM）
opt -enable-new-pm=0 -load ./libmy.so -my-pass input.ll -o output.ll

PreservedAnalyses MyPass::run(Function &F, FunctionAnalysisManager &AM) {
    // 获取分析结果
    auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
    auto &LI = AM.getResult<LoopAnalysis>(F);
    auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);

    // 使用支配树
    BasicBlock *Entry = &F.getEntryBlock();
    for (auto &BB : F) {
        if (DT.dominates(Entry, &BB)) {
            outs() << BB.getName() << " 被 entry 支配\n";
        }
    }

    // 使用循环信息
    for (Loop *L : LI) {
        outs() << "循环: " << L->getHeader()->getName() 
               << " 深度: " << L->getLoopDepth() << "\n";
        
        // 获取循环边界
        if (auto *BTC = SE.getBackedgeTakenCount(L)) {
            outs() << "  回边执行次数: ";
            BTC->print(outs());
            outs() << "\n";
        }
    }

    return PreservedAnalyses::all();
}

PreservedAnalyses MyPass::run(Function &F, FunctionAnalysisManager &AM) {
    // 场景一：什么都没变
    return PreservedAnalyses::all();

    // 场景二：全都变了（需要重新计算所有分析）
    return PreservedAnalyses::none();

    // 场景三：保留部分分析
    PreservedAnalyses PA;
    PA.preserve<DominatorTreeAnalysis>();  // 保留支配树
    PA.preserve<LoopAnalysis>();           // 保留循环信息
    PA.preserveSet<CFGAnalyses>();         // 保留所有 CFG 相关分析
    return PA;
}

# 运行单个 Pass
opt -passes='instcombine' input.ll -o output.ll

# 运行多个 Pass（按顺序）
opt -passes='simplifycfg,instcombine,gvn' input.ll -o output.ll

# 使用优化级别
opt -passes='default<O2>' input.ll -o output.ll

# 嵌套 Pass
opt -passes='function(instcombine)' input.ll -o output.ll
opt -passes='module(function(instcombine,simplifycfg))' input.ll -o output.ll

# 查看 Pass 流水线
opt -passes='default<O2>' -print-pipeline-passes input.ll -o /dev/null

# 列出所有可用 Pass
opt --list-passes

# 调试 Pass
opt -passes='instcombine' -debug input.ll -o /dev/null
opt -passes='instcombine' -print-after-all input.ll -o /dev/null

// 获取支配树
auto &DT = AM.getResult<DominatorTreeAnalysis>(F);

// 查询支配关系
bool Dom = DT.dominates(BB1, BB2);  // BB1 支配 BB2？

// 获取最近公共支配者
BasicBlock *NCD = DT.findNearestCommonDominator(BB1, BB2);

// 获取直接支配者
BasicBlock *IDom = DT.getNode(&BB)->getIDom()->getBlock();

auto &LI = AM.getResult<LoopAnalysis>(F);

// 遍历所有顶层循环
for (Loop *TopL : LI) {
    outs() << "顶层循环: " << TopL->getHeader()->getName() << "\n";
    
    // 遍历子循环
    for (Loop *SubL : TopL->getSubLoops()) {
        outs() << "  子循环: " << SubL->getHeader()->getName()
               << " 深度: " << SubL->getLoopDepth() << "\n";
    }
    
    // 获取循环的基本块
    for (BasicBlock *BB : TopL->getBlocks()) {
        outs() << "  块: " << BB->getName() << "\n";
    }
    
    // 获取循环入口（header）
    BasicBlock *Header = TopL->getHeader();
    
    // 获取预入口（preheader）
    BasicBlock *Preheader = TopL->getLoopPreheader();
    
    // 获取回边
    SmallVector<BasicBlock*, 4> Latches;
    TopL->getLoopLatches(Latches);
    
    // 获取出口
    SmallVector<BasicBlock*, 4> ExitBlocks;
    TopL->getExitBlocks(ExitBlocks);
}

auto &AA = AM.getResult<AAManager>(F);

// 查询两个指针是否可能别名
auto Result = AA.alias(
    MemoryLocation::getBeforeOrAfter(Ptr1),
    MemoryLocation::getBeforeOrAfter(Ptr2)
);

// 结果类型
switch (Result) {
    case AliasResult::NoAlias:
        outs() << "两个指针不别名\n";
        break;
    case AliasResult::MayAlias:
        outs() << "两个指针可能别名\n";
        break;
    case AliasResult::MustAlias:
        outs() << "两个指针一定别名\n";
        break;
    case AliasResult::PartialAlias:
        outs() << "两个指针部分别名\n";
        break;
}

# 查看 Pass 前后的 IR
opt -passes='instcombine' -print-before-all -print-after-all input.ll -o /dev/null 2>&1

# 只打印特定 Pass 前后的 IR
opt -passes='instcombine' -print-before=instcombine -print-after=instcombine input.ll -o /dev/null 2>&1

# 启用调试输出
opt -passes='instcombine' -debug input.ll -o /dev/null 2>&1

# 打印统计信息
opt -passes='instcombine' -stats input.ll -o /dev/null 2>&1

# 验证 IR
opt -passes='verify' input.ll -o /dev/null
opt -passes='instcombine' -verify-each input.ll -o output.ll

# 打印循环信息
opt -passes='print<loops>' -disable-output input.ll 2>&1

# 打印支配树
opt -passes='print<domtree>' -disable-output input.ll 2>&1

# 打印 ScalarEvolution
opt -passes='print<scalar-evolution>' -disable-output input.ll 2>&1

# 打印别名分析
opt -passes='print<aa>' -disable-output input.ll 2>&1