GlobalISel: Add tiny hot cache in IRTranslator::ValueToVRegInfo (NFC)

.gitignore

@@ -78,3 +78,7 @@ pythonenv*
 /clang/utils/analyzer/projects/*/RefScanBuildResults
 # automodapi puts generated documentation files here.
 /lldb/docs/python_api/
+
+DeepSeekCodeAnalyzer.py
+llvm-test-suite/
+linux/

SingleSource/UnitTests/Output/2002-04-17-PrintfChar.test.out

@@ -0,0 +1 @@
+'c' 'e'

code_analysis_report.txt

@@ -0,0 +1,254 @@
+好的，作为资深C++性能优化专家，我将对这份LLVM IRTranslator代码进行详细分析。
+
+## 1. 整体架构与复杂度分析
+
+### 算法复杂度分析
+- **最好情况**：O(n)，其中n是IR指令数量，每个指令被线性处理
+- **最坏情况**：O(n × m)，其中m是操作数数量，某些指令（如switch、shufflevector）可能产生复杂处理
+- **平均情况**：接近O(n)，大多数指令处理是常数时间
+
+### 内存访问模式
+- **VMap数据结构**：使用`DenseMap`存储value到vreg的映射，提供平均O(1)访问
+- **FrameIndices缓存**：对alloca指令的帧索引进行缓存，避免重复计算
+- **机器基本块预分配**：提前创建所有MachineBasicBlock，减少动态分配开销
+
+## 2. 关键性能瓶颈分析
+
+### 2.1 Value到VReg的映射查找
+```cpp
+ArrayRef<Register> IRTranslator::getOrCreateVRegs(const Value &Val) {
+  auto VRegsIt = VMap.findVRegs(Val);  // 频繁的查找操作
+  if (VRegsIt != VMap.vregs_end())
+    return *VRegsIt->second;
+  // ... 创建新vreg的逻辑
+}
+```
+**问题**：这是最频繁的操作，每个指令操作数都需要调用，可能成为瓶颈。
+
+### 2.2 大switch语句处理
+```cpp
+bool IRTranslator::translateSwitch(const User &U, MachineIRBuilder &MIB) {
+  // 处理大量case时复杂度可能达到O(n log n)或更差
+  CaseClusterVector Clusters;
+  Clusters.reserve(SI.getNumCases());
+  for (const auto &I : SI.cases()) {
+    // 每个case的处理
+  }
+  // 后续的排序和聚类操作
+  sortAndRangeify(Clusters);
+}
+```
+**问题**：大switch语句可能导致显著的性能开销。
+
+### 2.3 常量处理
+```cpp
+bool IRTranslator::translate(const Constant &C, Register Reg) {
+  // 多种常量类型的处理分支
+  if (auto CI = dyn_cast<ConstantInt>(&C)) {
+    // ...
+  } else if (auto CF = dyn_cast<ConstantFP>(&C)) {
+    // ...
+  } // 更多else if分支
+}
+```
+**问题**：长if-else链可能影响分支预测效率。
+
+## 3. 缓存友好性分析
+
+### 3.1 数据结构布局
+```cpp
+// ValueToVRegInfo内部结构可能不是缓存友好的
+struct ValueToVRegInfo {
+  DenseMap<const Value *, VRegListT *> VRegs;
+  DenseMap<const Value *, OffsetListT *> Offsets;
+};
+```
+**建议**：考虑将VRegs和Offsets合并到同一结构中，提高局部性。
+
+### 3.2 指令处理模式
+```cpp
+for (const Instruction &Inst : *BB) {
+  translateDbgInfo(Inst, *CurBuilder);  // 可能破坏指令处理的连续性
+  if (translate(Inst))                  // 虚函数调用开销
+    continue;
+}
+```
+**问题**：混合调试信息处理和实际翻译可能影响指令缓存效率。
+
+## 4. 并行化机会
+
+### 4.1 基本块级并行化
+```cpp
+// 当前是顺序处理
+ReversePostOrderTraversal<const Function *> RPOT(&F);
+for (const BasicBlock *BB : RPOT) {
+  // 顺序处理每个基本块
+}
+```
+**机会**：独立的基本块可以并行处理，但需要解决数据依赖问题。
+
+### 4.2 PHI节点处理
+```cpp
+void IRTranslator::finishPendingPhis() {
+  for (auto &Phi : PendingPHIs) {
+    // 逐个处理PHI节点
+  }
+}
+```
+**机会**：PHI节点处理可以批量进行，减少重复遍历。
+
+## 5. LLVM特定最佳实践问题
+
+### 5.1 频繁的MRI访问
+```cpp
+Register IRTranslator::getOrCreateVReg(const Value &Val) {
+  // 频繁调用MRI->createGenericVirtualRegister
+  return MRI->createGenericVirtualRegister(Ty);
+}
+```
+**问题**：MachineRegisterInfo的频繁访问可能成为瓶颈。
+
+### 5.2 调试信息处理
+```cpp
+void IRTranslator::translateDbgInfo(const Instruction &Inst,
+                                    MachineIRBuilder &MIRBuilder) {
+  for (DbgRecord &DR : Inst.getDbgRecordRange()) {
+    // 每条指令都处理调试信息
+  }
+}
+```
+**建议**：考虑在非调试构建中完全跳过调试信息处理。
+
+## 6. 具体重构建议和代码示例
+
+### 6.1 使用更高效的数据结构
+```cpp
+// 原代码
+auto VRegsIt = VMap.findVRegs(Val);
+if (VRegsIt != VMap.vregs_end())
+  return *VRegsIt->second;
+
+// 建议：使用带缓存的结果
+class IRTranslator {
+  using ValueVRegCache = DenseMap<const Value *, ArrayRef<Register>>;
+  ValueVRegCache VRegCache;  // 额外的缓存层
+
+  ArrayRef<Register> getOrCreateVRegsCached(const Value &Val) {
+    auto It = VRegCache.find(&Val);
+    if (It != VRegCache.end())
+      return It->second;
+
+    auto Result = getOrCreateVRegs(Val);
+    VRegCache.try_emplace(&Val, Result);
+    return Result;
+  }
+};
+```
+
+### 6.2 批量处理优化
+```cpp
+// 批量处理常量操作数
+void preloadConstants(const BasicBlock &BB) {
+  for (const Instruction &Inst : BB) {
+    for (const Use &Op : Inst.operands()) {
+      if (isa<Constant>(Op.get()))
+        getOrCreateVRegs(*Op.get());  // 预加载
+    }
+  }
+}
+```
+
+### 6.3 减少虚函数调用
+```cpp
+// 使用函数指针表替代switch-case
+using TranslateHandler = bool (IRTranslator::*)(const User &, MachineIRBuilder &);
+static const TranslateHandler Handlers[] = {
+  &IRTranslator::translateAdd,
+  &IRTranslator::translateSub,
+  // ... 其他处理函数
+};
+
+bool IRTranslator::translate(const Instruction &Inst) {
+  unsigned Opcode = Inst.getOpcode();
+  if (Opcode < array_lengthof(Handlers) && Handlers[Opcode]) {
+    return (this->*Handlers[Opcode])(Inst, *CurBuilder.get());
+  }
+  return false;
+}
+```
+
+### 6.4 内存访问优化
+```cpp
+// 优化getOrCreateVRegs的内存布局
+struct ValueVRegInfo {
+  SmallVector<Register, 1> VRegs;
+  SmallVector<uint64_t, 1> Offsets;
+  // 合并到一个结构中，提高缓存局部性
+};
+
+class ValueToVRegMap {
+  DenseMap<const Value *, ValueVRegInfo> Map;
+  // 单一数据结构，减少缓存缺失
+};
+```
+
+### 6.5 热点代码内联
+```cpp
+// 将高频调用的简单函数内联
+__attribute__((always_inline))
+Register getOrCreateVRegInline(const Value &Val) {
+  // 简单情况的快速路径
+  if (Val.getType()->isIntegerTy(32)) {
+    // 快速处理
+  }
+  // 回退到完整处理
+  return getOrCreateVRegs(Val)[0];
+}
+```
+
+## 7. 性能监控建议
+
+### 7.1 添加性能计数器
+```cpp
+class IRTranslator {
+  struct TranslationStats {
+    unsigned NumInstructions;
+    unsigned NumVRegLookups;
+    unsigned NumSlowPaths;
+    // ... 其他统计
+  } Stats;
+
+  void reportStats() {
+    if (EnableStats) {
+      dbgs() << "IRTranslator stats: " << Stats.NumInstructions 
+             << " instructions, " << Stats.NumVRegLookups 
+             << " vreg lookups\n";
+    }
+  }
+};
+```
+
+### 7.2 关键路径检测
+```cpp
+// 使用计时器识别热点
+#define TIME_SCOPE(Name) \
+  NamedRegionTimer Timer##Name(Name, "IRTranslator", "IRTranslator", \
+                               "IRTranslator", TimePassesIsEnabled)
+
+bool IRTranslator::translate(const Instruction &Inst) {
+  TIME_SCOPE("TranslateInstruction");
+  // ... 翻译逻辑
+}
+```
+
+## 总结
+
+这份IRTranslator代码在架构上是合理的，但存在一些可优化的性能热点：
+
+1. **Value到VReg的映射查找**是最大瓶颈，建议添加缓存层
+2. **大switch语句处理**需要优化算法复杂度
+3. **内存布局**可以进一步优化以提高缓存友好性
+4. **有条件地启用调试信息处理**以减少开销
+5. **考虑基本块级并行化**的机会
+
+通过上述优化建议，预计可以获得10-30%的性能提升，具体取决于目标代码的特征。建议优先处理Value映射查找的优化，因为这影响到每条指令的翻译过程。

commit.txt

@@ -0,0 +1,4 @@
+[RegAlloc] Add interval-set based register allocator skeleton
+
+This adds a prototype pass `-regalloc=intervals`, which uses IntervalSet
+instead of SegmentTree. Currently only handles trivial cases.

failed.list

@@ -0,0 +1,7 @@
+rv64-logs/SingleSource/UnitTests/SignlessTypes/cast-bug
+rv64-logs/SingleSource/UnitTests/SignlessTypes/ccc
+rv64-logs/SingleSource/UnitTests/testcase-Expr-1
+rv64-logs/SingleSource/UnitTests/testcase-ExprConstant-1
+rv64-logs/tools/fpcmp-target
+rv64-logs/tools/not
+rv64-logs/tools/timeit-target

hello.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main(void) {
+    printf("Hello, world!\n");
+    return 0;
+}