lldb/source/Expression/IRInterpreter.cpp

   1 //===-- IRInterpreter.cpp -------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Expression/IRInterpreter.h"
  10 #include "lldb/Core/Debugger.h"
  11 #include "lldb/Core/Module.h"
  12 #include "lldb/Core/ModuleSpec.h"
  13 #include "lldb/Core/ValueObject.h"
  14 #include "lldb/Expression/DiagnosticManager.h"
  15 #include "lldb/Expression/IRExecutionUnit.h"
  16 #include "lldb/Expression/IRMemoryMap.h"
  17 #include "lldb/Utility/ConstString.h"
  18 #include "lldb/Utility/DataExtractor.h"
  19 #include "lldb/Utility/Endian.h"
  20 #include "lldb/Utility/LLDBLog.h"
  21 #include "lldb/Utility/Log.h"
  22 #include "lldb/Utility/Scalar.h"
  23 #include "lldb/Utility/Status.h"
  24 #include "lldb/Utility/StreamString.h"
  25
  26 #include "lldb/Target/ABI.h"
  27 #include "lldb/Target/ExecutionContext.h"
  28 #include "lldb/Target/Target.h"
  29 #include "lldb/Target/Thread.h"
  30 #include "lldb/Target/ThreadPlan.h"
  31 #include "lldb/Target/ThreadPlanCallFunctionUsingABI.h"
  32
  33 #include "llvm/IR/Constants.h"
  34 #include "llvm/IR/DataLayout.h"
  35 #include "llvm/IR/Function.h"
  36 #include "llvm/IR/Instructions.h"
  37 #include "llvm/IR/Intrinsics.h"
  38 #include "llvm/IR/LLVMContext.h"
  39 #include "llvm/IR/Module.h"
  40 #include "llvm/IR/Operator.h"
  41 #include "llvm/Support/raw_ostream.h"
  42
  43 #include <map>
  44
  45 using namespace llvm;
  46 using lldb_private::LLDBLog;
  47
  48 static std::string PrintValue(const Value *value, bool truncate = false) {
  49   std::string s;
  50   raw_string_ostream rso(s);
  51   value->print(rso);
  52   rso.flush();
  53   if (truncate)
  54     s.resize(s.length() - 1);
  55
  56   size_t offset;
  57   while ((offset = s.find('\n')) != s.npos)
  58     s.erase(offset, 1);
  59   while (s[0] == ' ' || s[0] == '\t')
  60     s.erase(0, 1);
  61
  62   return s;
  63 }
  64
  65 static std::string PrintType(const Type *type, bool truncate = false) {
  66   std::string s;
  67   raw_string_ostream rso(s);
  68   type->print(rso);
  69   rso.flush();
  70   if (truncate)
  71     s.resize(s.length() - 1);
  72   return s;
  73 }
  74
  75 static bool CanIgnoreCall(const CallInst *call) {
  76   const llvm::Function *called_function = call->getCalledFunction();
  77
  78   if (!called_function)
  79     return false;
  80
  81   if (called_function->isIntrinsic()) {
  82     switch (called_function->getIntrinsicID()) {
  83     default:
  84       break;
  85     case llvm::Intrinsic::dbg_declare:
  86     case llvm::Intrinsic::dbg_value:
  87       return true;
  88     }
  89   }
  90
  91   return false;
  92 }
  93
  94 class InterpreterStackFrame {
  95 public:
  96   typedef std::map<const Value *, lldb::addr_t> ValueMap;
  97
  98   ValueMap m_values;
  99   DataLayout &m_target_data;
 100   lldb_private::IRExecutionUnit &m_execution_unit;
 101   const BasicBlock *m_bb = nullptr;
 102   const BasicBlock *m_prev_bb = nullptr;
 103   BasicBlock::const_iterator m_ii;
 104   BasicBlock::const_iterator m_ie;
 105
 106   lldb::addr_t m_frame_process_address;
 107   size_t m_frame_size;
 108   lldb::addr_t m_stack_pointer;
 109
 110   lldb::ByteOrder m_byte_order;
 111   size_t m_addr_byte_size;
 112
 113   InterpreterStackFrame(DataLayout &target_data,
 114                         lldb_private::IRExecutionUnit &execution_unit,
 115                         lldb::addr_t stack_frame_bottom,
 116                         lldb::addr_t stack_frame_top)
 117       : m_target_data(target_data), m_execution_unit(execution_unit) {
 118     m_byte_order = (target_data.isLittleEndian() ? lldb::eByteOrderLittle
 119                                                  : lldb::eByteOrderBig);
 120     m_addr_byte_size = (target_data.getPointerSize(0));
 121
 122     m_frame_process_address = stack_frame_bottom;
 123     m_frame_size = stack_frame_top - stack_frame_bottom;
 124     m_stack_pointer = stack_frame_top;
 125   }
 126
 127   ~InterpreterStackFrame() = default;
 128
 129   void Jump(const BasicBlock *bb) {
 130     m_prev_bb = m_bb;
 131     m_bb = bb;
 132     m_ii = m_bb->begin();
 133     m_ie = m_bb->end();
 134   }
 135
 136   std::string SummarizeValue(const Value *value) {
 137     lldb_private::StreamString ss;
 138
 139     ss.Printf("%s", PrintValue(value).c_str());
 140
 141     ValueMap::iterator i = m_values.find(value);
 142
 143     if (i != m_values.end()) {
 144       lldb::addr_t addr = i->second;
 145
 146       ss.Printf(" 0x%llx", (unsigned long long)addr);
 147     }
 148
 149     return std::string(ss.GetString());
 150   }
 151
 152   bool AssignToMatchType(lldb_private::Scalar &scalar, llvm::APInt value,
 153                          Type *type) {
 154     size_t type_size = m_target_data.getTypeStoreSize(type);
 155
 156     if (type_size > 8)
 157       return false;
 158
 159     if (type_size != 1)
 160       type_size = PowerOf2Ceil(type_size);
 161
 162     scalar = value.zextOrTrunc(type_size * 8);
 163     return true;
 164   }
 165
 166   bool EvaluateValue(lldb_private::Scalar &scalar, const Value *value,
 167                      Module &module) {
 168     const Constant *constant = dyn_cast<Constant>(value);
 169
 170     if (constant) {
 171       if (constant->getValueID() == Value::ConstantFPVal) {
 172         if (auto *cfp = dyn_cast<ConstantFP>(constant)) {
 173           if (cfp->getType()->isDoubleTy())
 174             scalar = cfp->getValueAPF().convertToDouble();
 175           else if (cfp->getType()->isFloatTy())
 176             scalar = cfp->getValueAPF().convertToFloat();
 177           else
 178             return false;
 179           return true;
 180         }
 181         return false;
 182       }
 183       APInt value_apint;
 184
 185       if (!ResolveConstantValue(value_apint, constant))
 186         return false;
 187
 188       return AssignToMatchType(scalar, value_apint, value->getType());
 189     }
 190
 191     lldb::addr_t process_address = ResolveValue(value, module);
 192     size_t value_size = m_target_data.getTypeStoreSize(value->getType());
 193
 194     lldb_private::DataExtractor value_extractor;
 195     lldb_private::Status extract_error;
 196
 197     m_execution_unit.GetMemoryData(value_extractor, process_address,
 198                                    value_size, extract_error);
 199
 200     if (!extract_error.Success())
 201       return false;
 202
 203     lldb::offset_t offset = 0;
 204     if (value_size <= 8) {
 205       Type *ty = value->getType();
 206       if (ty->isDoubleTy()) {
 207         scalar = value_extractor.GetDouble(&offset);
 208         return true;
 209       } else if (ty->isFloatTy()) {
 210         scalar = value_extractor.GetFloat(&offset);
 211         return true;
 212       } else {
 213         uint64_t u64value = value_extractor.GetMaxU64(&offset, value_size);
 214         return AssignToMatchType(scalar, llvm::APInt(64, u64value),
 215                                  value->getType());
 216       }
 217     }
 218
 219     return false;
 220   }
 221
 222   bool AssignValue(const Value *value, lldb_private::Scalar scalar,
 223                    Module &module) {
 224     lldb::addr_t process_address = ResolveValue(value, module);
 225
 226     if (process_address == LLDB_INVALID_ADDRESS)
 227       return false;
 228
 229     lldb_private::Scalar cast_scalar;
 230     Type *vty = value->getType();
 231     if (vty->isFloatTy() || vty->isDoubleTy()) {
 232       cast_scalar = scalar;
 233     } else {
 234       scalar.MakeUnsigned();
 235       if (!AssignToMatchType(cast_scalar, scalar.UInt128(llvm::APInt()),
 236                              value->getType()))
 237         return false;
 238     }
 239
 240     size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType());
 241
 242     lldb_private::DataBufferHeap buf(value_byte_size, 0);
 243
 244     lldb_private::Status get_data_error;
 245
 246     if (!cast_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(),
 247                                      m_byte_order, get_data_error))
 248       return false;
 249
 250     lldb_private::Status write_error;
 251
 252     m_execution_unit.WriteMemory(process_address, buf.GetBytes(),
 253                                  buf.GetByteSize(), write_error);
 254
 255     return write_error.Success();
 256   }
 257
 258   bool ResolveConstantValue(APInt &value, const Constant *constant) {
 259     switch (constant->getValueID()) {
 260     default:
 261       break;
 262     case Value::FunctionVal:
 263       if (const Function *constant_func = dyn_cast<Function>(constant)) {
 264         lldb_private::ConstString name(constant_func->getName());
 265         bool missing_weak = false;
 266         lldb::addr_t addr = m_execution_unit.FindSymbol(name, missing_weak);
 267         if (addr == LLDB_INVALID_ADDRESS || missing_weak)
 268           return false;
 269         value = APInt(m_target_data.getPointerSizeInBits(), addr);
 270         return true;
 271       }
 272       break;
 273     case Value::ConstantIntVal:
 274       if (const ConstantInt *constant_int = dyn_cast<ConstantInt>(constant)) {
 275         value = constant_int->getValue();
 276         return true;
 277       }
 278       break;
 279     case Value::ConstantFPVal:
 280       if (const ConstantFP *constant_fp = dyn_cast<ConstantFP>(constant)) {
 281         value = constant_fp->getValueAPF().bitcastToAPInt();
 282         return true;
 283       }
 284       break;
 285     case Value::ConstantExprVal:
 286       if (const ConstantExpr *constant_expr =
 287               dyn_cast<ConstantExpr>(constant)) {
 288         switch (constant_expr->getOpcode()) {
 289         default:
 290           return false;
 291         case Instruction::IntToPtr:
 292         case Instruction::PtrToInt:
 293         case Instruction::BitCast:
 294           return ResolveConstantValue(value, constant_expr->getOperand(0));
 295         case Instruction::GetElementPtr: {
 296           ConstantExpr::const_op_iterator op_cursor = constant_expr->op_begin();
 297           ConstantExpr::const_op_iterator op_end = constant_expr->op_end();
 298
 299           Constant *base = dyn_cast<Constant>(*op_cursor);
 300
 301           if (!base)
 302             return false;
 303
 304           if (!ResolveConstantValue(value, base))
 305             return false;
 306
 307           op_cursor++;
 308
 309           if (op_cursor == op_end)
 310             return true; // no offset to apply!
 311
 312           SmallVector<Value *, 8> indices(op_cursor, op_end);
 313           Type *src_elem_ty =
 314               cast<GEPOperator>(constant_expr)->getSourceElementType();
 315
 316           // DataLayout::getIndexedOffsetInType assumes the indices are
 317           // instances of ConstantInt.
 318           uint64_t offset =
 319               m_target_data.getIndexedOffsetInType(src_elem_ty, indices);
 320
 321           const bool is_signed = true;
 322           value += APInt(value.getBitWidth(), offset, is_signed);
 323
 324           return true;
 325         }
 326         }
 327       }
 328       break;
 329     case Value::ConstantPointerNullVal:
 330       if (isa<ConstantPointerNull>(constant)) {
 331         value = APInt(m_target_data.getPointerSizeInBits(), 0);
 332         return true;
 333       }
 334       break;
 335     }
 336     return false;
 337   }
 338
 339   bool MakeArgument(const Argument *value, uint64_t address) {
 340     lldb::addr_t data_address = Malloc(value->getType());
 341
 342     if (data_address == LLDB_INVALID_ADDRESS)
 343       return false;
 344
 345     lldb_private::Status write_error;
 346
 347     m_execution_unit.WritePointerToMemory(data_address, address, write_error);
 348
 349     if (!write_error.Success()) {
 350       lldb_private::Status free_error;
 351       m_execution_unit.Free(data_address, free_error);
 352       return false;
 353     }
 354
 355     m_values[value] = data_address;
 356
 357     lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 358
 359     if (log) {
 360       LLDB_LOGF(log, "Made an allocation for argument %s",
 361                 PrintValue(value).c_str());
 362       LLDB_LOGF(log, "  Data region    : %llx", (unsigned long long)address);
 363       LLDB_LOGF(log, "  Ref region     : %llx",
 364                 (unsigned long long)data_address);
 365     }
 366
 367     return true;
 368   }
 369
 370   bool ResolveConstant(lldb::addr_t process_address, const Constant *constant) {
 371     APInt resolved_value;
 372
 373     if (!ResolveConstantValue(resolved_value, constant))
 374       return false;
 375
 376     size_t constant_size = m_target_data.getTypeStoreSize(constant->getType());
 377     lldb_private::DataBufferHeap buf(constant_size, 0);
 378
 379     lldb_private::Status get_data_error;
 380
 381     lldb_private::Scalar resolved_scalar(
 382         resolved_value.zextOrTrunc(llvm::NextPowerOf2(constant_size) * 8));
 383     if (!resolved_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(),
 384                                          m_byte_order, get_data_error))
 385       return false;
 386
 387     lldb_private::Status write_error;
 388
 389     m_execution_unit.WriteMemory(process_address, buf.GetBytes(),
 390                                  buf.GetByteSize(), write_error);
 391
 392     return write_error.Success();
 393   }
 394
 395   lldb::addr_t Malloc(size_t size, uint8_t byte_alignment) {
 396     lldb::addr_t ret = m_stack_pointer;
 397
 398     ret -= size;
 399     ret -= (ret % byte_alignment);
 400
 401     if (ret < m_frame_process_address)
 402       return LLDB_INVALID_ADDRESS;
 403
 404     m_stack_pointer = ret;
 405     return ret;
 406   }
 407
 408   lldb::addr_t Malloc(llvm::Type *type) {
 409     lldb_private::Status alloc_error;
 410
 411     return Malloc(m_target_data.getTypeAllocSize(type),
 412                   m_target_data.getPrefTypeAlign(type).value());
 413   }
 414
 415   std::string PrintData(lldb::addr_t addr, llvm::Type *type) {
 416     size_t length = m_target_data.getTypeStoreSize(type);
 417
 418     lldb_private::DataBufferHeap buf(length, 0);
 419
 420     lldb_private::Status read_error;
 421
 422     m_execution_unit.ReadMemory(buf.GetBytes(), addr, length, read_error);
 423
 424     if (!read_error.Success())
 425       return std::string("<couldn't read data>");
 426
 427     lldb_private::StreamString ss;
 428
 429     for (size_t i = 0; i < length; i++) {
 430       if ((!(i & 0xf)) && i)
 431         ss.Printf("%02hhx - ", buf.GetBytes()[i]);
 432       else
 433         ss.Printf("%02hhx ", buf.GetBytes()[i]);
 434     }
 435
 436     return std::string(ss.GetString());
 437   }
 438
 439   lldb::addr_t ResolveValue(const Value *value, Module &module) {
 440     ValueMap::iterator i = m_values.find(value);
 441
 442     if (i != m_values.end())
 443       return i->second;
 444
 445     // Fall back and allocate space [allocation type Alloca]
 446
 447     lldb::addr_t data_address = Malloc(value->getType());
 448
 449     if (const Constant *constant = dyn_cast<Constant>(value)) {
 450       if (!ResolveConstant(data_address, constant)) {
 451         lldb_private::Status free_error;
 452         m_execution_unit.Free(data_address, free_error);
 453         return LLDB_INVALID_ADDRESS;
 454       }
 455     }
 456
 457     m_values[value] = data_address;
 458     return data_address;
 459   }
 460 };
 461
 462 static const char *unsupported_opcode_error =
 463     "Interpreter doesn't handle one of the expression's opcodes";
 464 static const char *unsupported_operand_error =
 465     "Interpreter doesn't handle one of the expression's operands";
 466 static const char *interpreter_internal_error =
 467     "Interpreter encountered an internal error";
 468 static const char *interrupt_error =
 469     "Interrupted while interpreting expression";
 470 static const char *bad_value_error =
 471     "Interpreter couldn't resolve a value during execution";
 472 static const char *memory_allocation_error =
 473     "Interpreter couldn't allocate memory";
 474 static const char *memory_write_error = "Interpreter couldn't write to memory";
 475 static const char *memory_read_error = "Interpreter couldn't read from memory";
 476 static const char *timeout_error =
 477     "Reached timeout while interpreting expression";
 478 static const char *too_many_functions_error =
 479     "Interpreter doesn't handle modules with multiple function bodies.";
 480
 481 static bool CanResolveConstant(llvm::Constant *constant) {
 482   switch (constant->getValueID()) {
 483   default:
 484     return false;
 485   case Value::ConstantIntVal:
 486   case Value::ConstantFPVal:
 487   case Value::FunctionVal:
 488     return true;
 489   case Value::ConstantExprVal:
 490     if (const ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant)) {
 491       switch (constant_expr->getOpcode()) {
 492       default:
 493         return false;
 494       case Instruction::IntToPtr:
 495       case Instruction::PtrToInt:
 496       case Instruction::BitCast:
 497         return CanResolveConstant(constant_expr->getOperand(0));
 498       case Instruction::GetElementPtr: {
 499         // Check that the base can be constant-resolved.
 500         ConstantExpr::const_op_iterator op_cursor = constant_expr->op_begin();
 501         Constant *base = dyn_cast<Constant>(*op_cursor);
 502         if (!base || !CanResolveConstant(base))
 503           return false;
 504
 505         // Check that all other operands are just ConstantInt.
 506         for (Value *op : make_range(constant_expr->op_begin() + 1,
 507                                     constant_expr->op_end())) {
 508           ConstantInt *constant_int = dyn_cast<ConstantInt>(op);
 509           if (!constant_int)
 510             return false;
 511         }
 512         return true;
 513       }
 514       }
 515     } else {
 516       return false;
 517     }
 518   case Value::ConstantPointerNullVal:
 519     return true;
 520   }
 521 }
 522
 523 bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
 524                                  lldb_private::Status &error,
 525                                  const bool support_function_calls) {
 526   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 527
 528   bool saw_function_with_body = false;
 529   for (Function &f : module) {
 530     if (f.begin() != f.end()) {
 531       if (saw_function_with_body) {
 532         LLDB_LOGF(log, "More than one function in the module has a body");
 533         error.SetErrorToGenericError();
 534         error.SetErrorString(too_many_functions_error);
 535         return false;
 536       }
 537       saw_function_with_body = true;
 538       LLDB_LOGF(log, "Saw function with body: %s", f.getName().str().c_str());
 539     }
 540   }
 541
 542   for (BasicBlock &bb : function) {
 543     for (Instruction &ii : bb) {
 544       switch (ii.getOpcode()) {
 545       default: {
 546         LLDB_LOGF(log, "Unsupported instruction: %s", PrintValue(&ii).c_str());
 547         error.SetErrorToGenericError();
 548         error.SetErrorString(unsupported_opcode_error);
 549         return false;
 550       }
 551       case Instruction::Add:
 552       case Instruction::Alloca:
 553       case Instruction::BitCast:
 554       case Instruction::Br:
 555       case Instruction::PHI:
 556         break;
 557       case Instruction::Call: {
 558         CallInst *call_inst = dyn_cast<CallInst>(&ii);
 559
 560         if (!call_inst) {
 561           error.SetErrorToGenericError();
 562           error.SetErrorString(interpreter_internal_error);
 563           return false;
 564         }
 565
 566         if (!CanIgnoreCall(call_inst) && !support_function_calls) {
 567           LLDB_LOGF(log, "Unsupported instruction: %s",
 568                     PrintValue(&ii).c_str());
 569           error.SetErrorToGenericError();
 570           error.SetErrorString(unsupported_opcode_error);
 571           return false;
 572         }
 573       } break;
 574       case Instruction::GetElementPtr:
 575         break;
 576       case Instruction::FCmp:
 577       case Instruction::ICmp: {
 578         CmpInst *cmp_inst = dyn_cast<CmpInst>(&ii);
 579
 580         if (!cmp_inst) {
 581           error.SetErrorToGenericError();
 582           error.SetErrorString(interpreter_internal_error);
 583           return false;
 584         }
 585
 586         switch (cmp_inst->getPredicate()) {
 587         default: {
 588           LLDB_LOGF(log, "Unsupported ICmp predicate: %s",
 589                     PrintValue(&ii).c_str());
 590
 591           error.SetErrorToGenericError();
 592           error.SetErrorString(unsupported_opcode_error);
 593           return false;
 594         }
 595         case CmpInst::FCMP_OEQ:
 596         case CmpInst::ICMP_EQ:
 597         case CmpInst::FCMP_UNE:
 598         case CmpInst::ICMP_NE:
 599         case CmpInst::FCMP_OGT:
 600         case CmpInst::ICMP_UGT:
 601         case CmpInst::FCMP_OGE:
 602         case CmpInst::ICMP_UGE:
 603         case CmpInst::FCMP_OLT:
 604         case CmpInst::ICMP_ULT:
 605         case CmpInst::FCMP_OLE:
 606         case CmpInst::ICMP_ULE:
 607         case CmpInst::ICMP_SGT:
 608         case CmpInst::ICMP_SGE:
 609         case CmpInst::ICMP_SLT:
 610         case CmpInst::ICMP_SLE:
 611           break;
 612         }
 613       } break;
 614       case Instruction::And:
 615       case Instruction::AShr:
 616       case Instruction::IntToPtr:
 617       case Instruction::PtrToInt:
 618       case Instruction::Load:
 619       case Instruction::LShr:
 620       case Instruction::Mul:
 621       case Instruction::Or:
 622       case Instruction::Ret:
 623       case Instruction::SDiv:
 624       case Instruction::SExt:
 625       case Instruction::Shl:
 626       case Instruction::SRem:
 627       case Instruction::Store:
 628       case Instruction::Sub:
 629       case Instruction::Trunc:
 630       case Instruction::UDiv:
 631       case Instruction::URem:
 632       case Instruction::Xor:
 633       case Instruction::ZExt:
 634         break;
 635       case Instruction::FAdd:
 636       case Instruction::FSub:
 637       case Instruction::FMul:
 638       case Instruction::FDiv:
 639         break;
 640       }
 641
 642       for (unsigned oi = 0, oe = ii.getNumOperands(); oi != oe; ++oi) {
 643         Value *operand = ii.getOperand(oi);
 644         Type *operand_type = operand->getType();
 645
 646         switch (operand_type->getTypeID()) {
 647         default:
 648           break;
 649         case Type::FixedVectorTyID:
 650         case Type::ScalableVectorTyID: {
 651           LLDB_LOGF(log, "Unsupported operand type: %s",
 652                     PrintType(operand_type).c_str());
 653           error.SetErrorString(unsupported_operand_error);
 654           return false;
 655         }
 656         }
 657
 658         // The IR interpreter currently doesn't know about
 659         // 128-bit integers. As they're not that frequent,
 660         // we can just fall back to the JIT rather than
 661         // choking.
 662         if (operand_type->getPrimitiveSizeInBits() > 64) {
 663           LLDB_LOGF(log, "Unsupported operand type: %s",
 664                     PrintType(operand_type).c_str());
 665           error.SetErrorString(unsupported_operand_error);
 666           return false;
 667         }
 668
 669         if (Constant *constant = llvm::dyn_cast<Constant>(operand)) {
 670           if (!CanResolveConstant(constant)) {
 671             LLDB_LOGF(log, "Unsupported constant: %s",
 672                       PrintValue(constant).c_str());
 673             error.SetErrorString(unsupported_operand_error);
 674             return false;
 675           }
 676         }
 677       }
 678     }
 679   }
 680
 681   return true;
 682 }
 683
 684 bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
 685                               llvm::ArrayRef<lldb::addr_t> args,
 686                               lldb_private::IRExecutionUnit &execution_unit,
 687                               lldb_private::Status &error,
 688                               lldb::addr_t stack_frame_bottom,
 689                               lldb::addr_t stack_frame_top,
 690                               lldb_private::ExecutionContext &exe_ctx,
 691                               lldb_private::Timeout<std::micro> timeout) {
 692   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 693
 694   if (log) {
 695     std::string s;
 696     raw_string_ostream oss(s);
 697
 698     module.print(oss, nullptr);
 699
 700     oss.flush();
 701
 702     LLDB_LOGF(log, "Module as passed in to IRInterpreter::Interpret: \n\"%s\"",
 703               s.c_str());
 704   }
 705
 706   DataLayout data_layout(&module);
 707
 708   InterpreterStackFrame frame(data_layout, execution_unit, stack_frame_bottom,
 709                               stack_frame_top);
 710
 711   if (frame.m_frame_process_address == LLDB_INVALID_ADDRESS) {
 712     error.SetErrorString("Couldn't allocate stack frame");
 713   }
 714
 715   int arg_index = 0;
 716
 717   for (llvm::Function::arg_iterator ai = function.arg_begin(),
 718                                     ae = function.arg_end();
 719        ai != ae; ++ai, ++arg_index) {
 720     if (args.size() <= static_cast<size_t>(arg_index)) {
 721       error.SetErrorString("Not enough arguments passed in to function");
 722       return false;
 723     }
 724
 725     lldb::addr_t ptr = args[arg_index];
 726
 727     frame.MakeArgument(&*ai, ptr);
 728   }
 729
 730   frame.Jump(&function.front());
 731
 732   lldb_private::Process *process = exe_ctx.GetProcessPtr();
 733   lldb_private::Target *target = exe_ctx.GetTargetPtr();
 734
 735   using clock = std::chrono::steady_clock;
 736
 737   // Compute the time at which the timeout has been exceeded.
 738   std::optional<clock::time_point> end_time;
 739   if (timeout && timeout->count() > 0)
 740     end_time = clock::now() + *timeout;
 741
 742   while (frame.m_ii != frame.m_ie) {
 743     // Timeout reached: stop interpreting.
 744     if (end_time && clock::now() >= *end_time) {
 745       error.SetErrorToGenericError();
 746       error.SetErrorString(timeout_error);
 747       return false;
 748     }
 749
 750     // If we have access to the debugger we can honor an interrupt request.
 751     if (target) {
 752       if (INTERRUPT_REQUESTED(target->GetDebugger(),
 753                               "Interrupted in IR interpreting.")) {
 754         error.SetErrorToGenericError();
 755         error.SetErrorString(interrupt_error);
 756         return false;
 757       }
 758     }
 759
 760     const Instruction *inst = &*frame.m_ii;
 761
 762     LLDB_LOGF(log, "Interpreting %s", PrintValue(inst).c_str());
 763
 764     switch (inst->getOpcode()) {
 765     default:
 766       break;
 767
 768     case Instruction::Add:
 769     case Instruction::Sub:
 770     case Instruction::Mul:
 771     case Instruction::SDiv:
 772     case Instruction::UDiv:
 773     case Instruction::SRem:
 774     case Instruction::URem:
 775     case Instruction::Shl:
 776     case Instruction::LShr:
 777     case Instruction::AShr:
 778     case Instruction::And:
 779     case Instruction::Or:
 780     case Instruction::Xor:
 781     case Instruction::FAdd:
 782     case Instruction::FSub:
 783     case Instruction::FMul:
 784     case Instruction::FDiv: {
 785       const BinaryOperator *bin_op = dyn_cast<BinaryOperator>(inst);
 786
 787       if (!bin_op) {
 788         LLDB_LOGF(
 789             log,
 790             "getOpcode() returns %s, but instruction is not a BinaryOperator",
 791             inst->getOpcodeName());
 792         error.SetErrorToGenericError();
 793         error.SetErrorString(interpreter_internal_error);
 794         return false;
 795       }
 796
 797       Value *lhs = inst->getOperand(0);
 798       Value *rhs = inst->getOperand(1);
 799
 800       lldb_private::Scalar L;
 801       lldb_private::Scalar R;
 802
 803       if (!frame.EvaluateValue(L, lhs, module)) {
 804         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(lhs).c_str());
 805         error.SetErrorToGenericError();
 806         error.SetErrorString(bad_value_error);
 807         return false;
 808       }
 809
 810       if (!frame.EvaluateValue(R, rhs, module)) {
 811         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(rhs).c_str());
 812         error.SetErrorToGenericError();
 813         error.SetErrorString(bad_value_error);
 814         return false;
 815       }
 816
 817       lldb_private::Scalar result;
 818
 819       switch (inst->getOpcode()) {
 820       default:
 821         break;
 822       case Instruction::Add:
 823       case Instruction::FAdd:
 824         result = L + R;
 825         break;
 826       case Instruction::Mul:
 827       case Instruction::FMul:
 828         result = L * R;
 829         break;
 830       case Instruction::Sub:
 831       case Instruction::FSub:
 832         result = L - R;
 833         break;
 834       case Instruction::SDiv:
 835         L.MakeSigned();
 836         R.MakeSigned();
 837         result = L / R;
 838         break;
 839       case Instruction::UDiv:
 840         L.MakeUnsigned();
 841         R.MakeUnsigned();
 842         result = L / R;
 843         break;
 844       case Instruction::FDiv:
 845         result = L / R;
 846         break;
 847       case Instruction::SRem:
 848         L.MakeSigned();
 849         R.MakeSigned();
 850         result = L % R;
 851         break;
 852       case Instruction::URem:
 853         L.MakeUnsigned();
 854         R.MakeUnsigned();
 855         result = L % R;
 856         break;
 857       case Instruction::Shl:
 858         result = L << R;
 859         break;
 860       case Instruction::AShr:
 861         result = L >> R;
 862         break;
 863       case Instruction::LShr:
 864         result = L;
 865         result.ShiftRightLogical(R);
 866         break;
 867       case Instruction::And:
 868         result = L & R;
 869         break;
 870       case Instruction::Or:
 871         result = L | R;
 872         break;
 873       case Instruction::Xor:
 874         result = L ^ R;
 875         break;
 876       }
 877
 878       frame.AssignValue(inst, result, module);
 879
 880       if (log) {
 881         LLDB_LOGF(log, "Interpreted a %s", inst->getOpcodeName());
 882         LLDB_LOGF(log, "  L : %s", frame.SummarizeValue(lhs).c_str());
 883         LLDB_LOGF(log, "  R : %s", frame.SummarizeValue(rhs).c_str());
 884         LLDB_LOGF(log, "  = : %s", frame.SummarizeValue(inst).c_str());
 885       }
 886     } break;
 887     case Instruction::Alloca: {
 888       const AllocaInst *alloca_inst = cast<AllocaInst>(inst);
 889
 890       if (alloca_inst->isArrayAllocation()) {
 891         LLDB_LOGF(log,
 892                   "AllocaInsts are not handled if isArrayAllocation() is true");
 893         error.SetErrorToGenericError();
 894         error.SetErrorString(unsupported_opcode_error);
 895         return false;
 896       }
 897
 898       // The semantics of Alloca are:
 899       //   Create a region R of virtual memory of type T, backed by a data
 900       //   buffer
 901       //   Create a region P of virtual memory of type T*, backed by a data
 902       //   buffer
 903       //   Write the virtual address of R into P
 904
 905       Type *T = alloca_inst->getAllocatedType();
 906       Type *Tptr = alloca_inst->getType();
 907
 908       lldb::addr_t R = frame.Malloc(T);
 909
 910       if (R == LLDB_INVALID_ADDRESS) {
 911         LLDB_LOGF(log, "Couldn't allocate memory for an AllocaInst");
 912         error.SetErrorToGenericError();
 913         error.SetErrorString(memory_allocation_error);
 914         return false;
 915       }
 916
 917       lldb::addr_t P = frame.Malloc(Tptr);
 918
 919       if (P == LLDB_INVALID_ADDRESS) {
 920         LLDB_LOGF(log,
 921                   "Couldn't allocate the result pointer for an AllocaInst");
 922         error.SetErrorToGenericError();
 923         error.SetErrorString(memory_allocation_error);
 924         return false;
 925       }
 926
 927       lldb_private::Status write_error;
 928
 929       execution_unit.WritePointerToMemory(P, R, write_error);
 930
 931       if (!write_error.Success()) {
 932         LLDB_LOGF(log, "Couldn't write the result pointer for an AllocaInst");
 933         error.SetErrorToGenericError();
 934         error.SetErrorString(memory_write_error);
 935         lldb_private::Status free_error;
 936         execution_unit.Free(P, free_error);
 937         execution_unit.Free(R, free_error);
 938         return false;
 939       }
 940
 941       frame.m_values[alloca_inst] = P;
 942
 943       if (log) {
 944         LLDB_LOGF(log, "Interpreted an AllocaInst");
 945         LLDB_LOGF(log, "  R : 0x%" PRIx64, R);
 946         LLDB_LOGF(log, "  P : 0x%" PRIx64, P);
 947       }
 948     } break;
 949     case Instruction::BitCast:
 950     case Instruction::ZExt: {
 951       const CastInst *cast_inst = cast<CastInst>(inst);
 952
 953       Value *source = cast_inst->getOperand(0);
 954
 955       lldb_private::Scalar S;
 956
 957       if (!frame.EvaluateValue(S, source, module)) {
 958         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(source).c_str());
 959         error.SetErrorToGenericError();
 960         error.SetErrorString(bad_value_error);
 961         return false;
 962       }
 963
 964       frame.AssignValue(inst, S, module);
 965     } break;
 966     case Instruction::SExt: {
 967       const CastInst *cast_inst = cast<CastInst>(inst);
 968
 969       Value *source = cast_inst->getOperand(0);
 970
 971       lldb_private::Scalar S;
 972
 973       if (!frame.EvaluateValue(S, source, module)) {
 974         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(source).c_str());
 975         error.SetErrorToGenericError();
 976         error.SetErrorString(bad_value_error);
 977         return false;
 978       }
 979
 980       S.MakeSigned();
 981
 982       lldb_private::Scalar S_signextend(S.SLongLong());
 983
 984       frame.AssignValue(inst, S_signextend, module);
 985     } break;
 986     case Instruction::Br: {
 987       const BranchInst *br_inst = cast<BranchInst>(inst);
 988
 989       if (br_inst->isConditional()) {
 990         Value *condition = br_inst->getCondition();
 991
 992         lldb_private::Scalar C;
 993
 994         if (!frame.EvaluateValue(C, condition, module)) {
 995           LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(condition).c_str());
 996           error.SetErrorToGenericError();
 997           error.SetErrorString(bad_value_error);
 998           return false;
 999         }
1000
1001         if (!C.IsZero())
1002           frame.Jump(br_inst->getSuccessor(0));
1003         else
1004           frame.Jump(br_inst->getSuccessor(1));
1005
1006         if (log) {
1007           LLDB_LOGF(log, "Interpreted a BrInst with a condition");
1008           LLDB_LOGF(log, "  cond : %s",
1009                     frame.SummarizeValue(condition).c_str());
1010         }
1011       } else {
1012         frame.Jump(br_inst->getSuccessor(0));
1013
1014         if (log) {
1015           LLDB_LOGF(log, "Interpreted a BrInst with no condition");
1016         }
1017       }
1018     }
1019       continue;
1020     case Instruction::PHI: {
1021       const PHINode *phi_inst = cast<PHINode>(inst);
1022       if (!frame.m_prev_bb) {
1023         LLDB_LOGF(log,
1024                   "Encountered PHI node without having jumped from another "
1025                   "basic block");
1026         error.SetErrorToGenericError();
1027         error.SetErrorString(interpreter_internal_error);
1028         return false;
1029       }
1030
1031       Value *value = phi_inst->getIncomingValueForBlock(frame.m_prev_bb);
1032       lldb_private::Scalar result;
1033       if (!frame.EvaluateValue(result, value, module)) {
1034         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(value).c_str());
1035         error.SetErrorToGenericError();
1036         error.SetErrorString(bad_value_error);
1037         return false;
1038       }
1039       frame.AssignValue(inst, result, module);
1040
1041       if (log) {
1042         LLDB_LOGF(log, "Interpreted a %s", inst->getOpcodeName());
1043         LLDB_LOGF(log, "  Incoming value : %s",
1044                   frame.SummarizeValue(value).c_str());
1045       }
1046     } break;
1047     case Instruction::GetElementPtr: {
1048       const GetElementPtrInst *gep_inst = cast<GetElementPtrInst>(inst);
1049
1050       const Value *pointer_operand = gep_inst->getPointerOperand();
1051       Type *src_elem_ty = gep_inst->getSourceElementType();
1052
1053       lldb_private::Scalar P;
1054
1055       if (!frame.EvaluateValue(P, pointer_operand, module)) {
1056         LLDB_LOGF(log, "Couldn't evaluate %s",
1057                   PrintValue(pointer_operand).c_str());
1058         error.SetErrorToGenericError();
1059         error.SetErrorString(bad_value_error);
1060         return false;
1061       }
1062
1063       typedef SmallVector<Value *, 8> IndexVector;
1064       typedef IndexVector::iterator IndexIterator;
1065
1066       SmallVector<Value *, 8> indices(gep_inst->idx_begin(),
1067                                       gep_inst->idx_end());
1068
1069       SmallVector<Value *, 8> const_indices;
1070
1071       for (IndexIterator ii = indices.begin(), ie = indices.end(); ii != ie;
1072            ++ii) {
1073         ConstantInt *constant_index = dyn_cast<ConstantInt>(*ii);
1074
1075         if (!constant_index) {
1076           lldb_private::Scalar I;
1077
1078           if (!frame.EvaluateValue(I, *ii, module)) {
1079             LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(*ii).c_str());
1080             error.SetErrorToGenericError();
1081             error.SetErrorString(bad_value_error);
1082             return false;
1083           }
1084
1085           LLDB_LOGF(log, "Evaluated constant index %s as %llu",
1086                     PrintValue(*ii).c_str(), I.ULongLong(LLDB_INVALID_ADDRESS));
1087
1088           constant_index = cast<ConstantInt>(ConstantInt::get(
1089               (*ii)->getType(), I.ULongLong(LLDB_INVALID_ADDRESS)));
1090         }
1091
1092         const_indices.push_back(constant_index);
1093       }
1094
1095       uint64_t offset =
1096           data_layout.getIndexedOffsetInType(src_elem_ty, const_indices);
1097
1098       lldb_private::Scalar Poffset = P + offset;
1099
1100       frame.AssignValue(inst, Poffset, module);
1101
1102       if (log) {
1103         LLDB_LOGF(log, "Interpreted a GetElementPtrInst");
1104         LLDB_LOGF(log, "  P       : %s",
1105                   frame.SummarizeValue(pointer_operand).c_str());
1106         LLDB_LOGF(log, "  Poffset : %s", frame.SummarizeValue(inst).c_str());
1107       }
1108     } break;
1109     case Instruction::FCmp:
1110     case Instruction::ICmp: {
1111       const CmpInst *icmp_inst = cast<CmpInst>(inst);
1112
1113       CmpInst::Predicate predicate = icmp_inst->getPredicate();
1114
1115       Value *lhs = inst->getOperand(0);
1116       Value *rhs = inst->getOperand(1);
1117
1118       lldb_private::Scalar L;
1119       lldb_private::Scalar R;
1120
1121       if (!frame.EvaluateValue(L, lhs, module)) {
1122         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(lhs).c_str());
1123         error.SetErrorToGenericError();
1124         error.SetErrorString(bad_value_error);
1125         return false;
1126       }
1127
1128       if (!frame.EvaluateValue(R, rhs, module)) {
1129         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(rhs).c_str());
1130         error.SetErrorToGenericError();
1131         error.SetErrorString(bad_value_error);
1132         return false;
1133       }
1134
1135       lldb_private::Scalar result;
1136
1137       switch (predicate) {
1138       default:
1139         return false;
1140       case CmpInst::ICMP_EQ:
1141       case CmpInst::FCMP_OEQ:
1142         result = (L == R);
1143         break;
1144       case CmpInst::ICMP_NE:
1145       case CmpInst::FCMP_UNE:
1146         result = (L != R);
1147         break;
1148       case CmpInst::ICMP_UGT:
1149         L.MakeUnsigned();
1150         R.MakeUnsigned();
1151         result = (L > R);
1152         break;
1153       case CmpInst::ICMP_UGE:
1154         L.MakeUnsigned();
1155         R.MakeUnsigned();
1156         result = (L >= R);
1157         break;
1158       case CmpInst::FCMP_OGE:
1159         result = (L >= R);
1160         break;
1161       case CmpInst::FCMP_OGT:
1162         result = (L > R);
1163         break;
1164       case CmpInst::ICMP_ULT:
1165         L.MakeUnsigned();
1166         R.MakeUnsigned();
1167         result = (L < R);
1168         break;
1169       case CmpInst::FCMP_OLT:
1170         result = (L < R);
1171         break;
1172       case CmpInst::ICMP_ULE:
1173         L.MakeUnsigned();
1174         R.MakeUnsigned();
1175         result = (L <= R);
1176         break;
1177       case CmpInst::FCMP_OLE:
1178         result = (L <= R);
1179         break;
1180       case CmpInst::ICMP_SGT:
1181         L.MakeSigned();
1182         R.MakeSigned();
1183         result = (L > R);
1184         break;
1185       case CmpInst::ICMP_SGE:
1186         L.MakeSigned();
1187         R.MakeSigned();
1188         result = (L >= R);
1189         break;
1190       case CmpInst::ICMP_SLT:
1191         L.MakeSigned();
1192         R.MakeSigned();
1193         result = (L < R);
1194         break;
1195       case CmpInst::ICMP_SLE:
1196         L.MakeSigned();
1197         R.MakeSigned();
1198         result = (L <= R);
1199         break;
1200       }
1201
1202       frame.AssignValue(inst, result, module);
1203
1204       if (log) {
1205         LLDB_LOGF(log, "Interpreted an ICmpInst");
1206         LLDB_LOGF(log, "  L : %s", frame.SummarizeValue(lhs).c_str());
1207         LLDB_LOGF(log, "  R : %s", frame.SummarizeValue(rhs).c_str());
1208         LLDB_LOGF(log, "  = : %s", frame.SummarizeValue(inst).c_str());
1209       }
1210     } break;
1211     case Instruction::IntToPtr: {
1212       const IntToPtrInst *int_to_ptr_inst = cast<IntToPtrInst>(inst);
1213
1214       Value *src_operand = int_to_ptr_inst->getOperand(0);
1215
1216       lldb_private::Scalar I;
1217
1218       if (!frame.EvaluateValue(I, src_operand, module)) {
1219         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
1220         error.SetErrorToGenericError();
1221         error.SetErrorString(bad_value_error);
1222         return false;
1223       }
1224
1225       frame.AssignValue(inst, I, module);
1226
1227       if (log) {
1228         LLDB_LOGF(log, "Interpreted an IntToPtr");
1229         LLDB_LOGF(log, "  Src : %s", frame.SummarizeValue(src_operand).c_str());
1230         LLDB_LOGF(log, "  =   : %s", frame.SummarizeValue(inst).c_str());
1231       }
1232     } break;
1233     case Instruction::PtrToInt: {
1234       const PtrToIntInst *ptr_to_int_inst = cast<PtrToIntInst>(inst);
1235
1236       Value *src_operand = ptr_to_int_inst->getOperand(0);
1237
1238       lldb_private::Scalar I;
1239
1240       if (!frame.EvaluateValue(I, src_operand, module)) {
1241         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
1242         error.SetErrorToGenericError();
1243         error.SetErrorString(bad_value_error);
1244         return false;
1245       }
1246
1247       frame.AssignValue(inst, I, module);
1248
1249       if (log) {
1250         LLDB_LOGF(log, "Interpreted a PtrToInt");
1251         LLDB_LOGF(log, "  Src : %s", frame.SummarizeValue(src_operand).c_str());
1252         LLDB_LOGF(log, "  =   : %s", frame.SummarizeValue(inst).c_str());
1253       }
1254     } break;
1255     case Instruction::Trunc: {
1256       const TruncInst *trunc_inst = cast<TruncInst>(inst);
1257
1258       Value *src_operand = trunc_inst->getOperand(0);
1259
1260       lldb_private::Scalar I;
1261
1262       if (!frame.EvaluateValue(I, src_operand, module)) {
1263         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
1264         error.SetErrorToGenericError();
1265         error.SetErrorString(bad_value_error);
1266         return false;
1267       }
1268
1269       frame.AssignValue(inst, I, module);
1270
1271       if (log) {
1272         LLDB_LOGF(log, "Interpreted a Trunc");
1273         LLDB_LOGF(log, "  Src : %s", frame.SummarizeValue(src_operand).c_str());
1274         LLDB_LOGF(log, "  =   : %s", frame.SummarizeValue(inst).c_str());
1275       }
1276     } break;
1277     case Instruction::Load: {
1278       const LoadInst *load_inst = cast<LoadInst>(inst);
1279
1280       // The semantics of Load are:
1281       //   Create a region D that will contain the loaded data
1282       //   Resolve the region P containing a pointer
1283       //   Dereference P to get the region R that the data should be loaded from
1284       //   Transfer a unit of type type(D) from R to D
1285
1286       const Value *pointer_operand = load_inst->getPointerOperand();
1287
1288       lldb::addr_t D = frame.ResolveValue(load_inst, module);
1289       lldb::addr_t P = frame.ResolveValue(pointer_operand, module);
1290
1291       if (D == LLDB_INVALID_ADDRESS) {
1292         LLDB_LOGF(log, "LoadInst's value doesn't resolve to anything");
1293         error.SetErrorToGenericError();
1294         error.SetErrorString(bad_value_error);
1295         return false;
1296       }
1297
1298       if (P == LLDB_INVALID_ADDRESS) {
1299         LLDB_LOGF(log, "LoadInst's pointer doesn't resolve to anything");
1300         error.SetErrorToGenericError();
1301         error.SetErrorString(bad_value_error);
1302         return false;
1303       }
1304
1305       lldb::addr_t R;
1306       lldb_private::Status read_error;
1307       execution_unit.ReadPointerFromMemory(&R, P, read_error);
1308
1309       if (!read_error.Success()) {
1310         LLDB_LOGF(log, "Couldn't read the address to be loaded for a LoadInst");
1311         error.SetErrorToGenericError();
1312         error.SetErrorString(memory_read_error);
1313         return false;
1314       }
1315
1316       Type *target_ty = load_inst->getType();
1317       size_t target_size = data_layout.getTypeStoreSize(target_ty);
1318       lldb_private::DataBufferHeap buffer(target_size, 0);
1319
1320       read_error.Clear();
1321       execution_unit.ReadMemory(buffer.GetBytes(), R, buffer.GetByteSize(),
1322                                 read_error);
1323       if (!read_error.Success()) {
1324         LLDB_LOGF(log, "Couldn't read from a region on behalf of a LoadInst");
1325         error.SetErrorToGenericError();
1326         error.SetErrorString(memory_read_error);
1327         return false;
1328       }
1329
1330       lldb_private::Status write_error;
1331       execution_unit.WriteMemory(D, buffer.GetBytes(), buffer.GetByteSize(),
1332                                  write_error);
1333       if (!write_error.Success()) {
1334         LLDB_LOGF(log, "Couldn't write to a region on behalf of a LoadInst");
1335         error.SetErrorToGenericError();
1336         error.SetErrorString(memory_write_error);
1337         return false;
1338       }
1339
1340       if (log) {
1341         LLDB_LOGF(log, "Interpreted a LoadInst");
1342         LLDB_LOGF(log, "  P : 0x%" PRIx64, P);
1343         LLDB_LOGF(log, "  R : 0x%" PRIx64, R);
1344         LLDB_LOGF(log, "  D : 0x%" PRIx64, D);
1345       }
1346     } break;
1347     case Instruction::Ret: {
1348       return true;
1349     }
1350     case Instruction::Store: {
1351       const StoreInst *store_inst = cast<StoreInst>(inst);
1352
1353       // The semantics of Store are:
1354       //   Resolve the region D containing the data to be stored
1355       //   Resolve the region P containing a pointer
1356       //   Dereference P to get the region R that the data should be stored in
1357       //   Transfer a unit of type type(D) from D to R
1358
1359       const Value *value_operand = store_inst->getValueOperand();
1360       const Value *pointer_operand = store_inst->getPointerOperand();
1361
1362       lldb::addr_t D = frame.ResolveValue(value_operand, module);
1363       lldb::addr_t P = frame.ResolveValue(pointer_operand, module);
1364
1365       if (D == LLDB_INVALID_ADDRESS) {
1366         LLDB_LOGF(log, "StoreInst's value doesn't resolve to anything");
1367         error.SetErrorToGenericError();
1368         error.SetErrorString(bad_value_error);
1369         return false;
1370       }
1371
1372       if (P == LLDB_INVALID_ADDRESS) {
1373         LLDB_LOGF(log, "StoreInst's pointer doesn't resolve to anything");
1374         error.SetErrorToGenericError();
1375         error.SetErrorString(bad_value_error);
1376         return false;
1377       }
1378
1379       lldb::addr_t R;
1380       lldb_private::Status read_error;
1381       execution_unit.ReadPointerFromMemory(&R, P, read_error);
1382
1383       if (!read_error.Success()) {
1384         LLDB_LOGF(log, "Couldn't read the address to be loaded for a LoadInst");
1385         error.SetErrorToGenericError();
1386         error.SetErrorString(memory_read_error);
1387         return false;
1388       }
1389
1390       Type *target_ty = value_operand->getType();
1391       size_t target_size = data_layout.getTypeStoreSize(target_ty);
1392       lldb_private::DataBufferHeap buffer(target_size, 0);
1393
1394       read_error.Clear();
1395       execution_unit.ReadMemory(buffer.GetBytes(), D, buffer.GetByteSize(),
1396                                 read_error);
1397       if (!read_error.Success()) {
1398         LLDB_LOGF(log, "Couldn't read from a region on behalf of a StoreInst");
1399         error.SetErrorToGenericError();
1400         error.SetErrorString(memory_read_error);
1401         return false;
1402       }
1403
1404       lldb_private::Status write_error;
1405       execution_unit.WriteMemory(R, buffer.GetBytes(), buffer.GetByteSize(),
1406                                  write_error);
1407       if (!write_error.Success()) {
1408         LLDB_LOGF(log, "Couldn't write to a region on behalf of a StoreInst");
1409         error.SetErrorToGenericError();
1410         error.SetErrorString(memory_write_error);
1411         return false;
1412       }
1413
1414       if (log) {
1415         LLDB_LOGF(log, "Interpreted a StoreInst");
1416         LLDB_LOGF(log, "  D : 0x%" PRIx64, D);
1417         LLDB_LOGF(log, "  P : 0x%" PRIx64, P);
1418         LLDB_LOGF(log, "  R : 0x%" PRIx64, R);
1419       }
1420     } break;
1421     case Instruction::Call: {
1422       const CallInst *call_inst = cast<CallInst>(inst);
1423
1424       if (CanIgnoreCall(call_inst))
1425         break;
1426
1427       // Get the return type
1428       llvm::Type *returnType = call_inst->getType();
1429       if (returnType == nullptr) {
1430         error.SetErrorToGenericError();
1431         error.SetErrorString("unable to access return type");
1432         return false;
1433       }
1434
1435       // Work with void, integer and pointer return types
1436       if (!returnType->isVoidTy() && !returnType->isIntegerTy() &&
1437           !returnType->isPointerTy()) {
1438         error.SetErrorToGenericError();
1439         error.SetErrorString("return type is not supported");
1440         return false;
1441       }
1442
1443       // Check we can actually get a thread
1444       if (exe_ctx.GetThreadPtr() == nullptr) {
1445         error.SetErrorToGenericError();
1446         error.SetErrorString("unable to acquire thread");
1447         return false;
1448       }
1449
1450       // Make sure we have a valid process
1451       if (!process) {
1452         error.SetErrorToGenericError();
1453         error.SetErrorString("unable to get the process");
1454         return false;
1455       }
1456
1457       // Find the address of the callee function
1458       lldb_private::Scalar I;
1459       const llvm::Value *val = call_inst->getCalledOperand();
1460
1461       if (!frame.EvaluateValue(I, val, module)) {
1462         error.SetErrorToGenericError();
1463         error.SetErrorString("unable to get address of function");
1464         return false;
1465       }
1466       lldb_private::Address funcAddr(I.ULongLong(LLDB_INVALID_ADDRESS));
1467
1468       lldb_private::DiagnosticManager diagnostics;
1469       lldb_private::EvaluateExpressionOptions options;
1470
1471       llvm::FunctionType *prototype = call_inst->getFunctionType();
1472
1473       // Find number of arguments
1474       const int numArgs = call_inst->arg_size();
1475
1476       // We work with a fixed array of 16 arguments which is our upper limit
1477       static lldb_private::ABI::CallArgument rawArgs[16];
1478       if (numArgs >= 16) {
1479         error.SetErrorToGenericError();
1480         error.SetErrorString("function takes too many arguments");
1481         return false;
1482       }
1483
1484       // Push all function arguments to the argument list that will be passed
1485       // to the call function thread plan
1486       for (int i = 0; i < numArgs; i++) {
1487         // Get details of this argument
1488         llvm::Value *arg_op = call_inst->getArgOperand(i);
1489         llvm::Type *arg_ty = arg_op->getType();
1490
1491         // Ensure that this argument is an supported type
1492         if (!arg_ty->isIntegerTy() && !arg_ty->isPointerTy()) {
1493           error.SetErrorToGenericError();
1494           error.SetErrorStringWithFormat("argument %d must be integer type", i);
1495           return false;
1496         }
1497
1498         // Extract the arguments value
1499         lldb_private::Scalar tmp_op = 0;
1500         if (!frame.EvaluateValue(tmp_op, arg_op, module)) {
1501           error.SetErrorToGenericError();
1502           error.SetErrorStringWithFormat("unable to evaluate argument %d", i);
1503           return false;
1504         }
1505
1506         // Check if this is a string literal or constant string pointer
1507         if (arg_ty->isPointerTy()) {
1508           lldb::addr_t addr = tmp_op.ULongLong();
1509           size_t dataSize = 0;
1510
1511           bool Success = execution_unit.GetAllocSize(addr, dataSize);
1512           (void)Success;
1513           assert(Success &&
1514                  "unable to locate host data for transfer to device");
1515           // Create the required buffer
1516           rawArgs[i].size = dataSize;
1517           rawArgs[i].data_up.reset(new uint8_t[dataSize + 1]);
1518
1519           // Read string from host memory
1520           execution_unit.ReadMemory(rawArgs[i].data_up.get(), addr, dataSize,
1521                                     error);
1522           assert(!error.Fail() &&
1523                  "we have failed to read the string from memory");
1524
1525           // Add null terminator
1526           rawArgs[i].data_up[dataSize] = '\0';
1527           rawArgs[i].type = lldb_private::ABI::CallArgument::HostPointer;
1528         } else /* if ( arg_ty->isPointerTy() ) */
1529         {
1530           rawArgs[i].type = lldb_private::ABI::CallArgument::TargetValue;
1531           // Get argument size in bytes
1532           rawArgs[i].size = arg_ty->getIntegerBitWidth() / 8;
1533           // Push value into argument list for thread plan
1534           rawArgs[i].value = tmp_op.ULongLong();
1535         }
1536       }
1537
1538       // Pack the arguments into an llvm::array
1539       llvm::ArrayRef<lldb_private::ABI::CallArgument> args(rawArgs, numArgs);
1540
1541       // Setup a thread plan to call the target function
1542       lldb::ThreadPlanSP call_plan_sp(
1543           new lldb_private::ThreadPlanCallFunctionUsingABI(
1544               exe_ctx.GetThreadRef(), funcAddr, *prototype, *returnType, args,
1545               options));
1546
1547       // Check if the plan is valid
1548       lldb_private::StreamString ss;
1549       if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) {
1550         error.SetErrorToGenericError();
1551         error.SetErrorStringWithFormat(
1552             "unable to make ThreadPlanCallFunctionUsingABI for 0x%llx",
1553             I.ULongLong());
1554         return false;
1555       }
1556
1557       process->SetRunningUserExpression(true);
1558
1559       // Execute the actual function call thread plan
1560       lldb::ExpressionResults res =
1561           process->RunThreadPlan(exe_ctx, call_plan_sp, options, diagnostics);
1562
1563       // Check that the thread plan completed successfully
1564       if (res != lldb::ExpressionResults::eExpressionCompleted) {
1565         error.SetErrorToGenericError();
1566         error.SetErrorString("ThreadPlanCallFunctionUsingABI failed");
1567         return false;
1568       }
1569
1570       process->SetRunningUserExpression(false);
1571
1572       // Void return type
1573       if (returnType->isVoidTy()) {
1574         // Cant assign to void types, so we leave the frame untouched
1575       } else
1576           // Integer or pointer return type
1577           if (returnType->isIntegerTy() || returnType->isPointerTy()) {
1578         // Get the encapsulated return value
1579         lldb::ValueObjectSP retVal = call_plan_sp.get()->GetReturnValueObject();
1580
1581         lldb_private::Scalar returnVal = -1;
1582         lldb_private::ValueObject *vobj = retVal.get();
1583
1584         // Check if the return value is valid
1585         if (vobj == nullptr || !retVal) {
1586           error.SetErrorToGenericError();
1587           error.SetErrorString("unable to get the return value");
1588           return false;
1589         }
1590
1591         // Extract the return value as a integer
1592         lldb_private::Value &value = vobj->GetValue();
1593         returnVal = value.GetScalar();
1594
1595         // Push the return value as the result
1596         frame.AssignValue(inst, returnVal, module);
1597       }
1598     } break;
1599     }
1600
1601     ++frame.m_ii;
1602   }
1603
1604   return false;
1605 }