[lldb] Add some vector operations to the IRInterpreter

dsandersllvm · dsandersllvm · commit be4ddf49a230 · 2025-09-02T20:10:50.000-07:00
This allows the debugger to evaluate expressions without requiring the
expression to be CodeGen'd and executed on the target. This should be more
efficient for many existing targets but is necessary for targets which are
not yet able to evaluate on the target.

As far as I know most targets have a vector memory layout that matches the
IR element order. Most little endian targets choose to use a little endian
element order, and two out of the three big endian targets I know of
(MIPS MSA and ARM NEON) choose to use little endian element order even
when the elements are big endian which matches LLVM-IR's order. The third
is PowerPC Altivec which has the highest indexed element first for
big-endian mode.

I've attempted to implement the correct element ordering on the relevant
operations but I don't really have a means to test the case where the
element order doesn't match LLVM-IR's element order so I've chosen to have
a guard against element order mismatches to ensure that this change can't
break expression evaluation on those targets.
diff --git a/lldb/include/lldb/Core/Architecture.h b/lldb/include/lldb/Core/Architecture.h
@@ -129,6 +129,17 @@ class Architecture : public PluginInterface {
                                        RegisterContext &reg_context) const {
     return false;
   }
+
+  // Get the vector element order for this architecture. This determines how
+  // vector elements are indexed. This matters in a few places such as reading/
+  // writing LLVM-IR values to/from target memory. Some architectures use
+  // little-endian element ordering where element 0 is at the lowest address
+  // even when the architecture is otherwise big-endian (e.g. MIPS MSA, ARM
+  // NEON), but some architectures like PowerPC may use big-endian element
+  // ordering where element 0 is at the highest address.
+  virtual lldb::ByteOrder GetVectorElementOrder() const {
+    return lldb::eByteOrderLittle;
+  }
 };
 
 } // namespace lldb_private
diff --git a/lldb/include/lldb/Expression/IRInterpreter.h b/lldb/include/lldb/Expression/IRInterpreter.h
@@ -37,7 +37,8 @@ class IRInterpreter {
 public:
   static bool CanInterpret(llvm::Module &module, llvm::Function &function,
                            lldb_private::Status &error,
-                           const bool support_function_calls);
+                           const bool support_function_calls,
+                           lldb_private::ExecutionContext &exe_ctx);
 
   static bool Interpret(llvm::Module &module, llvm::Function &function,
                         llvm::ArrayRef<lldb::addr_t> args,
diff --git a/lldb/source/Expression/IRInterpreter.cpp b/lldb/source/Expression/IRInterpreter.cpp
@@ -70,6 +70,18 @@ static std::string PrintType(const Type *type, bool truncate = false) {
   return s;
 }
 
+static bool
+MemoryMatchesIRElementOrder(lldb_private::ExecutionContext &exe_ctx) {
+  lldb::TargetSP target_sp = exe_ctx.GetTargetSP();
+  if (target_sp) {
+    const auto *arch_plugin = target_sp->GetArchitecturePlugin();
+    if (arch_plugin) {
+      return arch_plugin->GetVectorElementOrder() == lldb::eByteOrderLittle;
+    }
+  }
+  return true; // Default to little-endian (matches IR)
+}
+
 static bool CanIgnoreCall(const CallInst *call) {
   const llvm::Function *called_function = call->getCalledFunction();
 
@@ -124,6 +136,17 @@ class InterpreterStackFrame {
 
   ~InterpreterStackFrame() = default;
 
+  bool MemoryMatchesIRElementOrder() {
+    lldb::TargetSP target_sp = m_execution_unit.GetTarget();
+    if (target_sp) {
+      const auto *arch_plugin = target_sp->GetArchitecturePlugin();
+      if (arch_plugin) {
+        return arch_plugin->GetVectorElementOrder() == lldb::eByteOrderLittle;
+      }
+    }
+    return true;
+  }
+
   void Jump(const BasicBlock *bb) {
     m_prev_bb = m_bb;
     m_bb = bb;
@@ -367,7 +390,65 @@ class InterpreterStackFrame {
     return true;
   }
 
+  bool ResolveVectorConstant(lldb::addr_t process_address,
+                             const Constant *constant) {
+    auto *vector_type = dyn_cast<FixedVectorType>(constant->getType());
+    if (!vector_type)
+      return false;
+
+    Type *element_type = vector_type->getElementType();
+    unsigned num_elements = vector_type->getNumElements();
+    size_t element_size = m_target_data.getTypeStoreSize(element_type);
+    size_t total_size = element_size * num_elements;
+    bool reverse_elements = !MemoryMatchesIRElementOrder();
+
+    lldb_private::DataBufferHeap buf(total_size, 0);
+    uint8_t *data_ptr = buf.GetBytes();
+
+    if (isa<ConstantAggregateZero>(constant)) {
+      // Zero initializer - buffer is already zeroed, just write it
+      lldb_private::Status write_error;
+      m_execution_unit.WriteMemory(process_address, buf.GetBytes(),
+                                   buf.GetByteSize(), write_error);
+      return write_error.Success();
+    }
+
+    if (const ConstantDataVector *cdv =
+            dyn_cast<ConstantDataVector>(constant)) {
+      for (unsigned i = 0; i < num_elements; ++i) {
+        const Constant *element = cdv->getElementAsConstant(i);
+        APInt element_value;
+        if (!ResolveConstantValue(element_value, element))
+          return false;
+
+        // Calculate target offset based on element ordering
+        unsigned target_index = !reverse_elements ? i : (num_elements - 1 - i);
+        size_t offset = target_index * element_size;
+
+        lldb_private::Scalar element_scalar(
+            element_value.zextOrTrunc(element_size * 8));
+        lldb_private::Status get_data_error;
+        if (!element_scalar.GetAsMemoryData(data_ptr + offset, element_size,
+                                            m_byte_order, get_data_error))
+          return false;
+      }
+      lldb_private::Status write_error;
+      m_execution_unit.WriteMemory(process_address, buf.GetBytes(),
+                                   buf.GetByteSize(), write_error);
+
+      return write_error.Success();
+    }
+
+    return false;
+  }
+
   bool ResolveConstant(lldb::addr_t process_address, const Constant *constant) {
+    // Handle vector constants specially since they can't be represented as a
+    // single APInt
+    if (constant->getType()->isVectorTy()) {
+      return ResolveVectorConstant(process_address, constant);
+    }
+
     APInt resolved_value;
 
     if (!ResolveConstantValue(resolved_value, constant))
@@ -484,8 +565,13 @@ static bool CanResolveConstant(llvm::Constant *constant) {
     return false;
   case Value::ConstantIntVal:
   case Value::ConstantFPVal:
+    return true;
+  case Value::ConstantDataVectorVal:
   case Value::FunctionVal:
     return true;
+  case Value::ConstantAggregateZeroVal:
+    // Zero initializers can be resolved
+    return true;
   case Value::ConstantExprVal:
     if (const ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant)) {
       switch (constant_expr->getOpcode()) {
@@ -522,7 +608,8 @@ static bool CanResolveConstant(llvm::Constant *constant) {
 
 bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
                                  lldb_private::Status &error,
-                                 const bool support_function_calls) {
+                                 const bool support_function_calls,
+                                 lldb_private::ExecutionContext &exe_ctx) {
   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 
   bool saw_function_with_body = false;
@@ -551,6 +638,7 @@ bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
       case Instruction::BitCast:
       case Instruction::Br:
       case Instruction::PHI:
+      case Instruction::ExtractElement:
         break;
       case Instruction::Call: {
         CallInst *call_inst = dyn_cast<CallInst>(&ii);
@@ -644,7 +732,25 @@ bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
         switch (operand_type->getTypeID()) {
         default:
           break;
-        case Type::FixedVectorTyID:
+        case Type::FixedVectorTyID: {
+          // If the element order is big-endian (highest index first) then it
+          // doesn't match LLVM-IR and must be transformed to correctly transfer
+          // between LLVM-IR and memory. This might not be fully implemented so
+          // decline to interpret this case.
+          if (exe_ctx.GetTargetPtr()) {
+            const auto *arch_plugin =
+                exe_ctx.GetTargetRef().GetArchitecturePlugin();
+            if (arch_plugin &&
+                arch_plugin->GetVectorElementOrder() == lldb::eByteOrderBig) {
+              LLDB_LOGF(log, "Unsupported big-endian vector element ordering");
+              error = lldb_private::Status::FromErrorString(
+                  "IR interpreter doesn't support big-endian vector element "
+                  "ordering");
+              return false;
+            }
+          }
+          break;
+        }
         case Type::ScalableVectorTyID: {
           LLDB_LOGF(log, "Unsupported operand type: %s",
                     PrintType(operand_type).c_str());
@@ -657,8 +763,9 @@ bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
         // The IR interpreter currently doesn't know about
         // 128-bit integers. As they're not that frequent,
         // we can just fall back to the JIT rather than
-        // choking.
-        if (operand_type->getPrimitiveSizeInBits() > 64) {
+        // choking. However, allow vectors since we handle them above.
+        if (operand_type->getPrimitiveSizeInBits() > 64 &&
+            !operand_type->isVectorTy()) {
           LLDB_LOGF(log, "Unsupported operand type: %s",
                     PrintType(operand_type).c_str());
           error =
@@ -1567,6 +1674,100 @@ bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
         frame.AssignValue(inst, returnVal, module);
       }
     } break;
+    case Instruction::ExtractElement: {
+      const ExtractElementInst *extract_inst = cast<ExtractElementInst>(inst);
+
+      // Get the vector and index operands
+      const Value *vector_operand = extract_inst->getVectorOperand();
+      const Value *index_operand = extract_inst->getIndexOperand();
+
+      // Get the vector address
+      lldb::addr_t vector_addr = frame.ResolveValue(vector_operand, module);
+
+      if (vector_addr == LLDB_INVALID_ADDRESS) {
+        LLDB_LOGF(log, "ExtractElement's vector doesn't resolve to anything");
+        error = lldb_private::Status::FromErrorString(bad_value_error);
+        return false;
+      }
+
+      // Evaluate the index
+      lldb_private::Scalar index_scalar;
+      if (!frame.EvaluateValue(index_scalar, index_operand, module)) {
+        LLDB_LOGF(log, "Couldn't evaluate index %s",
+                  PrintValue(index_operand).c_str());
+        error = lldb_private::Status::FromErrorString(bad_value_error);
+        return false;
+      }
+
+      uint64_t index = index_scalar.ULongLong();
+
+      // Get the vector type information
+      auto *vector_type = dyn_cast<FixedVectorType>(vector_operand->getType());
+      if (!vector_type) {
+        LLDB_LOGF(log, "ExtractElement instruction doesn't have a fixed vector "
+                       "operand type");
+        error =
+            lldb_private::Status::FromErrorString(interpreter_internal_error);
+        return false;
+      }
+
+      unsigned num_elements = vector_type->getNumElements();
+      if (index >= num_elements) {
+        LLDB_LOGF(log,
+                  "ExtractElement index %llu is out of bounds for vector with "
+                  "%u elements",
+                  (unsigned long long)index, num_elements);
+        error = lldb_private::Status::FromErrorString(bad_value_error);
+        return false;
+      }
+
+      Type *element_type = vector_type->getElementType();
+      size_t element_size = data_layout.getTypeStoreSize(element_type);
+
+      // Handle target-specific vector element ordering
+      bool reverse_elements = !MemoryMatchesIRElementOrder(exe_ctx);
+      uint64_t target_index =
+          reverse_elements ? (num_elements - 1 - index) : index;
+      size_t element_offset = target_index * element_size;
+
+      // Allocate space for the result element
+      lldb::addr_t result_addr = frame.ResolveValue(extract_inst, module);
+      if (result_addr == LLDB_INVALID_ADDRESS) {
+        LLDB_LOGF(log, "ExtractElement's result doesn't resolve to anything");
+        error = lldb_private::Status::FromErrorString(bad_value_error);
+        return false;
+      }
+
+      // Read the element from the vector
+      lldb_private::DataBufferHeap element_buffer(element_size, 0);
+      lldb_private::Status read_error;
+      execution_unit.ReadMemory(element_buffer.GetBytes(),
+                                vector_addr + element_offset, element_size,
+                                read_error);
+      if (!read_error.Success()) {
+        LLDB_LOGF(log, "Couldn't read element data for ExtractElement");
+        error = lldb_private::Status::FromErrorString(memory_read_error);
+        return false;
+      }
+
+      // Write the element to the result location
+      lldb_private::Status write_error;
+      execution_unit.WriteMemory(result_addr, element_buffer.GetBytes(),
+                                 element_size, write_error);
+      if (!write_error.Success()) {
+        LLDB_LOGF(log, "Couldn't write result for ExtractElement");
+        error = lldb_private::Status::FromErrorString(memory_write_error);
+        return false;
+      }
+
+      if (log) {
+        LLDB_LOGF(log, "Interpreted an ExtractElement");
+        LLDB_LOGF(log, "  Vector: 0x%" PRIx64, vector_addr);
+        LLDB_LOGF(log, "  Index: %llu", (unsigned long long)index);
+        LLDB_LOGF(log, "  Element offset: %zu", element_offset);
+        LLDB_LOGF(log, "  Result: 0x%" PRIx64, result_addr);
+      }
+    } break;
     }
 
     ++frame.m_ii;
diff --git a/lldb/source/Plugins/Architecture/PPC64/ArchitecturePPC64.cpp b/lldb/source/Plugins/Architecture/PPC64/ArchitecturePPC64.cpp
@@ -35,7 +35,8 @@ void ArchitecturePPC64::Terminate() {
 std::unique_ptr<Architecture> ArchitecturePPC64::Create(const ArchSpec &arch) {
   if (arch.GetTriple().isPPC64() &&
       arch.GetTriple().getObjectFormat() == llvm::Triple::ObjectFormatType::ELF)
-    return std::unique_ptr<Architecture>(new ArchitecturePPC64());
+    return std::unique_ptr<Architecture>(
+        new ArchitecturePPC64(arch.GetByteOrder()));
   return nullptr;
 }
 
@@ -60,3 +61,7 @@ void ArchitecturePPC64::AdjustBreakpointAddress(const Symbol &func,
 
   addr.SetOffset(addr.GetOffset() + loffs);
 }
+
+lldb::ByteOrder ArchitecturePPC64::GetVectorElementOrder() const {
+  return m_vector_element_order;
+}
diff --git a/lldb/source/Plugins/Architecture/PPC64/ArchitecturePPC64.h b/lldb/source/Plugins/Architecture/PPC64/ArchitecturePPC64.h
@@ -30,9 +30,14 @@ class ArchitecturePPC64 : public Architecture {
   void AdjustBreakpointAddress(const Symbol &func,
                                Address &addr) const override;
 
+  lldb::ByteOrder GetVectorElementOrder() const override;
+
 private:
   static std::unique_ptr<Architecture> Create(const ArchSpec &arch);
-  ArchitecturePPC64() = default;
+  ArchitecturePPC64(lldb::ByteOrder vector_element_order)
+      : m_vector_element_order(vector_element_order) {}
+
+  lldb::ByteOrder m_vector_element_order;
 };
 
 } // namespace lldb_private
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
@@ -1523,7 +1523,7 @@ lldb_private::Status ClangExpressionParser::DoPrepareForExecution(
           !process ? false : process->CanInterpretFunctionCalls();
       can_interpret = IRInterpreter::CanInterpret(
           *execution_unit_sp->GetModule(), *execution_unit_sp->GetFunction(),
-          interpret_error, interpret_function_calls);
+          interpret_error, interpret_function_calls, exe_ctx);
 
       if (!can_interpret && execution_policy == eExecutionPolicyNever) {
         err = Status::FromErrorStringWithFormat(
diff --git a/lldb/test/API/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py b/lldb/test/API/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py
