DWARFExpression: Simplify class interface

[labath]

Summary

The DWARFExpression methods have a lot of arguments. This removes two of
them by removing the ability to slice the expression via two offset+size
parameters. This is a functionality that it is not always needed, and
when it is, we already have a different handy way of slicing a data
extractor which we can use instead.

include/lldb/Expression/DWARFExpression.h

public:
 
   DWARFExpression();
 
   /// Constructor
   ///
   /// \param[in] data
   ///     A data extractor configured to read the DWARF location expression's
   ///     bytecode.
-  ///
-  /// \param[in] data_offset
-  ///     The offset of the location expression in the extractor.
-  ///
-  /// \param[in] data_length
-  ///     The byte length of the location expression.
   DWARFExpression(lldb::ModuleSP module, const DataExtractor &data,
-                  const DWARFUnit *dwarf_cu, lldb::offset_t data_offset,
-                  lldb::offset_t data_length);
+                  const DWARFUnit *dwarf_cu);
 
   /// Destructor
   virtual ~DWARFExpression();
 
   /// Print the description of the expression to a stream
   ///
   /// \param[in] s
   ///     The stream to print to.
public:
   ///
   ///  \param[in] reg_ctx
   ///     An optional parameter which provides a RegisterContext for use
   ///     when evaluating the expression (i.e. for fetching register values).
   ///     Normally this will come from the ExecutionContext's StackFrame but
   ///     in the case where an expression needs to be evaluated while building
   ///     the stack frame list, this short-cut is available.
   ///
-  /// \param[in] offset
-  ///     The offset of the location expression in the data extractor.
-  ///
-  /// \param[in] length
-  ///     The length in bytes of the location expression.
-  ///
   /// \param[in] reg_set
   ///     The call-frame-info style register kind.
   ///
   /// \param[in] initial_value_ptr
   ///     A value to put on top of the interpreter stack before evaluating
   ///     the expression, if the expression is parametrized.  Can be NULL.
   ///
   /// \param[in] result
   ///     A value into which the result of evaluating the expression is
   ///     to be placed.
   ///
   /// \param[in] error_ptr
   ///     If non-NULL, used to report errors in expression evaluation.
   ///
   /// \return
   ///     True on success; false otherwise.  If error_ptr is non-NULL,
   ///     details of the failure are provided through it.
   static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
                        lldb::ModuleSP opcode_ctx, const DataExtractor &opcodes,
-                       const DWARFUnit *dwarf_cu, const lldb::offset_t offset,
-                       const lldb::offset_t length,
+                       const DWARFUnit *dwarf_cu,
                        const lldb::RegisterKind reg_set,
                        const Value *initial_value_ptr,
                        const Value *object_address_ptr, Value &result,
                        Status *error_ptr);
 
   bool GetExpressionData(DataExtractor &data) const {
     data = m_data;
     return data.GetByteSize() > 0;

source/Expression/DWARFExpression.cpp

 
 // DWARFExpression constructor
 DWARFExpression::DWARFExpression()
     : m_module_wp(), m_data(), m_dwarf_cu(nullptr),
       m_reg_kind(eRegisterKindDWARF), m_loclist_slide(LLDB_INVALID_ADDRESS) {}
 
 DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
                                  const DataExtractor &data,
-                                 const DWARFUnit *dwarf_cu,
-                                 lldb::offset_t data_offset,
-                                 lldb::offset_t data_length)
-    : m_module_wp(), m_data(data, data_offset, data_length),
-      m_dwarf_cu(dwarf_cu), m_reg_kind(eRegisterKindDWARF),
-      m_loclist_slide(LLDB_INVALID_ADDRESS) {
+                                 const DWARFUnit *dwarf_cu)
+    : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu),
+      m_reg_kind(eRegisterKindDWARF), m_loclist_slide(LLDB_INVALID_ADDRESS) {
   if (module_sp)
     m_module_wp = module_sp;
 }
 
 // Destructor
 DWARFExpression::~DWARFExpression() {}
 
 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
if (loclist_base_load_addr != LLDB_INVALID_ADDRESS) {
 
         lo_pc += curr_loclist_base_load_addr - m_loclist_slide;
         hi_pc += curr_loclist_base_load_addr - m_loclist_slide;
 
         uint16_t length = m_data.GetU16(&offset);
 
         if (length > 0 && lo_pc <= pc && pc < hi_pc) {
           return DWARFExpression::Evaluate(
-              exe_ctx, reg_ctx, module_sp, m_data, m_dwarf_cu, offset, length,
-              m_reg_kind, initial_value_ptr, object_address_ptr, result,
-              error_ptr);
+              exe_ctx, reg_ctx, module_sp,
+              DataExtractor(m_data, offset, length), m_dwarf_cu, m_reg_kind,
+              initial_value_ptr, object_address_ptr, result, error_ptr);
         }
         offset += length;
       }
     }
     if (error_ptr)
       error_ptr->SetErrorString("variable not available");
     return false;
   }
 
   // Not a location list, just a single expression.
-  return DWARFExpression::Evaluate(
-      exe_ctx, reg_ctx, module_sp, m_data, m_dwarf_cu, 0, m_data.GetByteSize(),
-      m_reg_kind, initial_value_ptr, object_address_ptr, result, error_ptr);
+  return DWARFExpression::Evaluate(exe_ctx, reg_ctx, module_sp, m_data,
+                                   m_dwarf_cu, m_reg_kind, initial_value_ptr,
+                                   object_address_ptr, result, error_ptr);
 }
 
 bool DWARFExpression::Evaluate(
     ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
     lldb::ModuleSP module_sp, const DataExtractor &opcodes,
-    const DWARFUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
-    const lldb::offset_t opcodes_length, const lldb::RegisterKind reg_kind,
+    const DWARFUnit *dwarf_cu, const lldb::RegisterKind reg_kind,
     const Value *initial_value_ptr, const Value *object_address_ptr,
     Value &result, Status *error_ptr) {
 
-  if (opcodes_length == 0) {
+  if (opcodes.GetByteSize() == 0) {
     if (error_ptr)
       error_ptr->SetErrorString(
           "no location, value may have been optimized out");
     return false;
   }
   std::vector<Value> stack;
 
   Process *process = nullptr;
   StackFrame *frame = nullptr;
 
   if (exe_ctx) {
     process = exe_ctx->GetProcessPtr();
     frame = exe_ctx->GetFramePtr();
   }
   if (reg_ctx == nullptr && frame)
     reg_ctx = frame->GetRegisterContext().get();
 
   if (initial_value_ptr)
     stack.push_back(*initial_value_ptr);
 
-  lldb::offset_t offset = opcodes_offset;
-  const lldb::offset_t end_offset = opcodes_offset + opcodes_length;
+  lldb::offset_t offset = 0;
   Value tmp;
   uint32_t reg_num;
 
   /// Insertion point for evaluating multi-piece expression.␓
   uint64_t op_piece_offset = 0;
   Value pieces; // Used for DW_OP_piece
 
-  // Make sure all of the data is available in opcodes.
-  if (!opcodes.ValidOffsetForDataOfSize(opcodes_offset, opcodes_length)) {
-    if (error_ptr)
-      error_ptr->SetErrorString(
-          "invalid offset and/or length for opcodes buffer.");
-    return false;
-  }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  while (opcodes.ValidOffset(offset) && offset < end_offset) {
+  while (opcodes.ValidOffset(offset)) {
     const lldb::offset_t op_offset = offset;
     const uint8_t op = opcodes.GetU8(&offset);
 
     if (log && log->GetVerbose()) {
       size_t count = stack.size();
       LLDB_LOGF(log, "Stack before operation has %" PRIu64 " values:",
                 (uint64_t)count);
       for (size_t i = 0; i < count; ++i) {
while (opcodes.ValidOffset(offset)) {
     // OPERANDS: int16_t
     // DESCRIPTION:  An unconditional branch. Its single operand is a 2-byte
     // signed integer constant. The 2-byte constant is the number of bytes of
     // the DWARF expression to skip forward or backward from the current
     // operation, beginning after the 2-byte constant.
     case DW_OP_skip: {
       int16_t skip_offset = (int16_t)opcodes.GetU16(&offset);
       lldb::offset_t new_offset = offset + skip_offset;
-      if (new_offset >= opcodes_offset && new_offset < end_offset)
+      if (opcodes.ValidOffset(new_offset))
         offset = new_offset;
       else {
         if (error_ptr)
           error_ptr->SetErrorString("Invalid opcode offset in DW_OP_skip.");
         return false;
       }
     } break;
 
case DW_OP_bra:
         return false;
       } else {
         tmp = stack.back();
         stack.pop_back();
         int16_t bra_offset = (int16_t)opcodes.GetU16(&offset);
         Scalar zero(0);
         if (tmp.ResolveValue(exe_ctx) != zero) {
           lldb::offset_t new_offset = offset + bra_offset;
-          if (new_offset >= opcodes_offset && new_offset < end_offset)
+          if (opcodes.ValidOffset(new_offset))
             offset = new_offset;
           else {
             if (error_ptr)
               error_ptr->SetErrorString("Invalid opcode offset in DW_OP_bra.");
             return false;
           }
         }
       }

source/Plugins/Process/Utility/RegisterContextLLDB.cpp

RegisterContextLLDB::SavedLocationForRegister(
 
   if (unwindplan_regloc.IsDWARFExpression() ||
       unwindplan_regloc.IsAtDWARFExpression()) {
     DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
                             unwindplan_regloc.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
-    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr, 0,
-                              unwindplan_regloc.GetDWARFExpressionLength());
+    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr);
     dwarfexpr.SetRegisterKind(unwindplan_registerkind);
     Value cfa_val = Scalar(m_cfa);
     cfa_val.SetValueType(Value::eValueTypeLoadAddress);
     Value result;
     Status error;
     if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result,
                            &error)) {
       addr_t val;
bool RegisterContextLLDB::ReadFrameAddress(
   case UnwindPlan::Row::FAValue::isDWARFExpression: {
     ExecutionContext exe_ctx(m_thread.shared_from_this());
     Process *process = exe_ctx.GetProcessPtr();
     DataExtractor dwarfdata(fa.GetDWARFExpressionBytes(),
                             fa.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
-    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr, 0,
-                              fa.GetDWARFExpressionLength());
+    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr);
     dwarfexpr.SetRegisterKind(row_register_kind);
     Value result;
     Status error;
     if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
                            &error)) {
       address = result.GetScalar().ULongLong();
 
       UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64,

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

case DW_TAG_APPLE_property: {
                 Value memberOffset(0);
                 const DWARFDataExtractor &debug_info_data = die.GetData();
                 uint32_t block_length = form_value.Unsigned();
                 uint32_t block_offset =
                     form_value.BlockData() - debug_info_data.GetDataStart();
                 if (DWARFExpression::Evaluate(
                         nullptr, // ExecutionContext *
                         nullptr, // RegisterContext *
-                        module_sp, debug_info_data, die.GetCU(), block_offset,
-                        block_length, eRegisterKindDWARF, &initialValue,
-                        nullptr, memberOffset, nullptr)) {
+                        module_sp,
+                        DataExtractor(debug_info_data, block_offset,
+                                      block_length),
+                        die.GetCU(), eRegisterKindDWARF, &initialValue, nullptr,
+                        memberOffset, nullptr)) {
                   member_byte_offset =
                       memberOffset.ResolveValue(nullptr).UInt();
                 }
               } else {
                 // With DWARF 3 and later, if the value is an integer constant,
                 // this form value is the offset in bytes from the beginning of
                 // the containing entity.
                 member_byte_offset = form_value.Unsigned();
case DW_TAG_inheritance: {
             case DW_AT_data_member_location:
               if (form_value.BlockData()) {
                 Value initialValue(0);
                 Value memberOffset(0);
                 const DWARFDataExtractor &debug_info_data = die.GetData();
                 uint32_t block_length = form_value.Unsigned();
                 uint32_t block_offset =
                     form_value.BlockData() - debug_info_data.GetDataStart();
-                if (DWARFExpression::Evaluate(nullptr, nullptr, module_sp,
-                                              debug_info_data, die.GetCU(),
-                                              block_offset, block_length,
-                                              eRegisterKindDWARF, &initialValue,
-                                              nullptr, memberOffset, nullptr)) {
+                if (DWARFExpression::Evaluate(
+                        nullptr, nullptr, module_sp,
+                        DataExtractor(debug_info_data, block_offset,
+                                      block_length),
+                        die.GetCU(), eRegisterKindDWARF, &initialValue, nullptr,
+                        memberOffset, nullptr)) {
                   member_byte_offset =
                       memberOffset.ResolveValue(nullptr).UInt();
                 }
               } else {
                 // With DWARF 3 and later, if the value is an integer constant,
                 // this form value is the offset in bytes from the beginning of
                 // the containing entity.
                 member_byte_offset = form_value.Unsigned();

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

for (uint32_t i = 0; i < numAttributes; ++i) {
           break;
 
         case DW_AT_frame_base:
           if (frame_base) {
             if (form_value.BlockData()) {
               uint32_t block_offset =
                   form_value.BlockData() - data.GetDataStart();
               uint32_t block_length = form_value.Unsigned();
-              *frame_base = DWARFExpression(module, data, cu,
-                                            block_offset, block_length);
+              *frame_base = DWARFExpression(
+                  module, DataExtractor(data, block_offset, block_length), cu);
             } else {
               const DWARFDataExtractor &debug_loc_data = dwarf.DebugLocData();
               const dw_offset_t debug_loc_offset = form_value.Unsigned();
 
               size_t loc_list_length = DWARFExpression::LocationListSize(
                   cu, debug_loc_data, debug_loc_offset);
               if (loc_list_length > 0) {
-                *frame_base =
-                    DWARFExpression(module, debug_loc_data, cu,
-                                    debug_loc_offset, loc_list_length);
+                *frame_base = DWARFExpression(module,
+                                              DataExtractor(debug_loc_data,
+                                                            debug_loc_offset,
+                                                            loc_list_length),
+                                              cu);
                 if (lo_pc != LLDB_INVALID_ADDRESS) {
                   assert(lo_pc >= cu->GetBaseAddress());
                   frame_base->SetLocationListSlide(lo_pc -
                                                    cu->GetBaseAddress());
                 } else {
                   set_frame_base_loclist_addr = true;
                 }
               }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (num_attributes > 0) {
               // The constant value will be either a block, a data value or a
               // string.
               auto debug_info_data = die.GetData();
               if (DWARFFormValue::IsBlockForm(form_value.Form())) {
                 // Retrieve the value as a block expression.
                 uint32_t block_offset =
                     form_value.BlockData() - debug_info_data.GetDataStart();
                 uint32_t block_length = form_value.Unsigned();
-                location = DWARFExpression(module, debug_info_data, die.GetCU(),
-                                           block_offset, block_length);
+                location = DWARFExpression(
+                    module,
+                    DataExtractor(debug_info_data, block_offset, block_length),
+                    die.GetCU());
               } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                 // Retrieve the value as a data expression.
                 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                 if (auto data_length = form_value.GetFixedSize())
-                  location =
-                      DWARFExpression(module, debug_info_data, die.GetCU(),
-                                      data_offset, *data_length);
+                  location = DWARFExpression(
+                      module,
+                      DataExtractor(debug_info_data, data_offset, *data_length),
+                      die.GetCU());
                 else {
                   const uint8_t *data_pointer = form_value.BlockData();
                   if (data_pointer) {
                     form_value.Unsigned();
                   } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                     // we need to get the byte size of the type later after we
                     // create the variable
                     const_value = form_value;
                   }
                 }
               } else {
                 // Retrieve the value as a string expression.
                 if (form_value.Form() == DW_FORM_strp) {
                   uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                   if (auto data_length = form_value.GetFixedSize())
-                    location =
-                        DWARFExpression(module, debug_info_data, die.GetCU(),
-                                        data_offset, *data_length);
+                    location = DWARFExpression(module,
+                                               DataExtractor(debug_info_data,
+                                                             data_offset,
+                                                             *data_length),
+                                               die.GetCU());
                 } else {
                   const char *str = form_value.AsCString();
                   uint32_t string_offset =
                       str - (const char *)debug_info_data.GetDataStart();
                   uint32_t string_length = strlen(str) + 1;
-                  location =
-                      DWARFExpression(module, debug_info_data, die.GetCU(),
-                                      string_offset, string_length);
+                  location = DWARFExpression(module,
+                                             DataExtractor(debug_info_data,
+                                                           string_offset,
+                                                           string_length),
+                                             die.GetCU());
                 }
               }
             }
             break;
           case DW_AT_location: {
             location_is_const_value_data = false;
             has_explicit_location = true;
             if (DWARFFormValue::IsBlockForm(form_value.Form())) {
               auto data = die.GetData();
 
               uint32_t block_offset =
                   form_value.BlockData() - data.GetDataStart();
               uint32_t block_length = form_value.Unsigned();
-              location = DWARFExpression(module, data, die.GetCU(),
-                                         block_offset, block_length);
+              location = DWARFExpression(
+                  module, DataExtractor(data, block_offset, block_length),
+                  die.GetCU());
             } else {
               const DWARFDataExtractor &debug_loc_data = DebugLocData();
               const dw_offset_t debug_loc_offset = form_value.Unsigned();
 
               size_t loc_list_length = DWARFExpression::LocationListSize(
                   die.GetCU(), debug_loc_data, debug_loc_offset);
               if (loc_list_length > 0) {
-                location = DWARFExpression(module, debug_loc_data, die.GetCU(),
-                                           debug_loc_offset, loc_list_length);
+                location = DWARFExpression(module,
+                                           DataExtractor(debug_loc_data,
+                                                         debug_loc_offset,
+                                                         loc_list_length),
+                                           die.GetCU());
                 assert(func_low_pc != LLDB_INVALID_ADDRESS);
                 location.SetLocationListSlide(
                     func_low_pc -
                     attributes.CompileUnitAtIndex(i)->GetBaseAddress());
               }
             }
           } break;
           case DW_AT_specification:

source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp

static DWARFExpression MakeLocationExpressionInternal(lldb::ModuleSP module,
   StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order);
 
   if (!writer(stream, register_kind))
     return DWARFExpression();
 
   DataBufferSP buffer =
       std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());
   DataExtractor extractor(buffer, byte_order, address_size, byte_size);
-  DWARFExpression result(module, extractor, nullptr, 0, buffer->GetByteSize());
+  DWARFExpression result(module, extractor, nullptr);
   result.SetRegisterKind(register_kind);
 
   return result;
 }
 
 static DWARFExpression MakeRegisterBasedLocationExpressionInternal(
     llvm::codeview::RegisterId reg, llvm::Optional<int32_t> relative_offset,
     lldb::ModuleSP module) {
DWARFExpression lldb_private::npdb::MakeConstantLocationExpression(
   } else {
     Value.U = constant.getZExtValue();
   }
 
   bytes = llvm::makeArrayRef(reinterpret_cast<const uint8_t *>(&Value), 8)
               .take_front(size);
   buffer->CopyData(bytes.data(), size);
   DataExtractor extractor(buffer, lldb::eByteOrderLittle, address_size);
-  DWARFExpression result(nullptr, extractor, nullptr, 0, size);
+  DWARFExpression result(nullptr, extractor, nullptr);
   return result;
 }

source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp

DWARFExpression ConvertPDBLocationToDWARFExpression(
   }
   default:
     return DWARFExpression();
   }
 
   DataBufferSP buffer =
       std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());
   DataExtractor extractor(buffer, byte_order, address_size, byte_size);
-  DWARFExpression result(module, extractor, nullptr, 0, buffer->GetByteSize());
+  DWARFExpression result(module, extractor, nullptr);
   result.SetRegisterKind(register_kind);
 
   return result;
 }

source/Target/RegisterContext.cpp

RegisterContext::UpdateDynamicRegisterSize(const lldb_private::ArchSpec &arch,
   int expr_result;
   uint32_t addr_size = arch.GetAddressByteSize();
   const uint8_t *dwarf_opcode_ptr = reg_info->dynamic_size_dwarf_expr_bytes;
   const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
 
   DataExtractor dwarf_data(dwarf_opcode_ptr, dwarf_opcode_len,
                            arch.GetByteOrder(), addr_size);
   ModuleSP opcode_ctx;
-  DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, nullptr, 0,
-                             dwarf_opcode_len);
+  DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, nullptr);
   Value result;
   Status error;
-  const lldb::offset_t offset = 0;
   if (dwarf_expr.Evaluate(&exe_ctx, this, opcode_ctx, dwarf_data, nullptr,
-                          offset, dwarf_opcode_len, eRegisterKindDWARF, nullptr,
-                          nullptr, result, &error)) {
+                          eRegisterKindDWARF, nullptr, nullptr, result,
+                          &error)) {
     expr_result = result.GetScalar().SInt(-1);
     switch (expr_result) {
     case 0:
       return 4;
     case 1:
       return 8;
     default:
       return reg_info->byte_size;

unittests/Expression/DWARFExpressionTest.cpp

 static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr) {
   DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle,
                           /*addr_size*/ 4);
 
   Value result;
   Status status;
   if (!DWARFExpression::Evaluate(
           /*exe_ctx*/ nullptr, /*reg_ctx*/ nullptr, /*opcode_ctx*/ nullptr,
-          extractor, /*dwarf_cu*/ nullptr, /*offset*/ 0, expr.size(),
-          lldb::eRegisterKindLLDB, /*initial_value_ptr*/ nullptr,
+          extractor, /*dwarf_cu*/ nullptr, lldb::eRegisterKindLLDB,
+          /*initial_value_ptr*/ nullptr,
           /*object_address_ptr*/ nullptr, result, &status))
     return status.ToError();
 
   return result.GetScalar();
 }
 
 TEST(DWARFExpression, DW_OP_pick) {
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 0}),
                        llvm::HasValue(0));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 1}),
                        llvm::HasValue(1));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 2}),
                        llvm::Failed());
 }