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 45using namespace llvm; 46using lldb_private::LLDBLog; 47 48static 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 65static 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 75static 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 94class InterpreterStackFrame { 95public: 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 462static const char *unsupported_opcode_error = 463 "Interpreter doesn't handle one of the expression's opcodes"; 464static const char *unsupported_operand_error = 465 "Interpreter doesn't handle one of the expression's operands"; 466static const char *interpreter_internal_error = 467 "Interpreter encountered an internal error"; 468static const char *interrupt_error = 469 "Interrupted while interpreting expression"; 470static const char *bad_value_error = 471 "Interpreter couldn't resolve a value during execution"; 472static const char *memory_allocation_error = 473 "Interpreter couldn't allocate memory"; 474static const char *memory_write_error = "Interpreter couldn't write to memory"; 475static const char *memory_read_error = "Interpreter couldn't read from memory"; 476static const char *timeout_error = 477 "Reached timeout while interpreting expression"; 478static const char *too_many_functions_error = 479 "Interpreter doesn't handle modules with multiple function bodies."; 480 481static 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 523bool 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 684bool 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 UNUSED_IF_ASSERT_DISABLED(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} 1606