1 //===-- IRInterpreter.cpp ---------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/Core/DataExtractor.h" 11 #include "lldb/Core/Error.h" 12 #include "lldb/Core/Log.h" 13 #include "lldb/Core/Scalar.h" 14 #include "lldb/Core/StreamString.h" 15 #include "lldb/Expression/IRMemoryMap.h" 16 #include "lldb/Expression/IRInterpreter.h" 17 #include "lldb/Host/Endian.h" 18 19 #include "llvm/IR/Constants.h" 20 #include "llvm/IR/DataLayout.h" 21 #include "llvm/IR/Function.h" 22 #include "llvm/IR/Instructions.h" 23 #include "llvm/IR/Module.h" 24 #include "llvm/Support/raw_ostream.h" 25 26 #include <map> 27 28 using namespace llvm; 29 30 static std::string 31 PrintValue(const Value *value, bool truncate = false) 32 { 33 std::string s; 34 raw_string_ostream rso(s); 35 value->print(rso); 36 rso.flush(); 37 if (truncate) 38 s.resize(s.length() - 1); 39 40 size_t offset; 41 while ((offset = s.find('\n')) != s.npos) 42 s.erase(offset, 1); 43 while (s[0] == ' ' || s[0] == '\t') 44 s.erase(0, 1); 45 46 return s; 47 } 48 49 static std::string 50 PrintType(const Type *type, bool truncate = false) 51 { 52 std::string s; 53 raw_string_ostream rso(s); 54 type->print(rso); 55 rso.flush(); 56 if (truncate) 57 s.resize(s.length() - 1); 58 return s; 59 } 60 61 class InterpreterStackFrame 62 { 63 public: 64 typedef std::map <const Value*, lldb::addr_t> ValueMap; 65 66 ValueMap m_values; 67 DataLayout &m_target_data; 68 lldb_private::IRMemoryMap &m_memory_map; 69 const BasicBlock *m_bb; 70 BasicBlock::const_iterator m_ii; 71 BasicBlock::const_iterator m_ie; 72 73 lldb::addr_t m_frame_process_address; 74 size_t m_frame_size; 75 lldb::addr_t m_stack_pointer; 76 77 lldb::ByteOrder m_byte_order; 78 size_t m_addr_byte_size; 79 80 InterpreterStackFrame (DataLayout &target_data, 81 lldb_private::IRMemoryMap &memory_map, 82 lldb::addr_t stack_frame_bottom, 83 lldb::addr_t stack_frame_top) : 84 m_target_data (target_data), 85 m_memory_map (memory_map) 86 { 87 m_byte_order = (target_data.isLittleEndian() ? lldb::eByteOrderLittle : lldb::eByteOrderBig); 88 m_addr_byte_size = (target_data.getPointerSize(0)); 89 90 m_frame_process_address = stack_frame_bottom; 91 m_frame_size = stack_frame_top - stack_frame_bottom; 92 m_stack_pointer = stack_frame_top; 93 } 94 95 ~InterpreterStackFrame () 96 { 97 } 98 99 void Jump (const BasicBlock *bb) 100 { 101 m_bb = bb; 102 m_ii = m_bb->begin(); 103 m_ie = m_bb->end(); 104 } 105 106 std::string SummarizeValue (const Value *value) 107 { 108 lldb_private::StreamString ss; 109 110 ss.Printf("%s", PrintValue(value).c_str()); 111 112 ValueMap::iterator i = m_values.find(value); 113 114 if (i != m_values.end()) 115 { 116 lldb::addr_t addr = i->second; 117 118 ss.Printf(" 0x%llx", (unsigned long long)addr); 119 } 120 121 return ss.GetString(); 122 } 123 124 bool AssignToMatchType (lldb_private::Scalar &scalar, uint64_t u64value, Type *type) 125 { 126 size_t type_size = m_target_data.getTypeStoreSize(type); 127 128 switch (type_size) 129 { 130 case 1: 131 scalar = (uint8_t)u64value; 132 break; 133 case 2: 134 scalar = (uint16_t)u64value; 135 break; 136 case 4: 137 scalar = (uint32_t)u64value; 138 break; 139 case 8: 140 scalar = (uint64_t)u64value; 141 break; 142 default: 143 return false; 144 } 145 146 return true; 147 } 148 149 bool EvaluateValue (lldb_private::Scalar &scalar, const Value *value, Module &module) 150 { 151 const Constant *constant = dyn_cast<Constant>(value); 152 153 if (constant) 154 { 155 APInt value_apint; 156 157 if (!ResolveConstantValue(value_apint, constant)) 158 return false; 159 160 return AssignToMatchType(scalar, value_apint.getLimitedValue(), value->getType()); 161 } 162 else 163 { 164 lldb::addr_t process_address = ResolveValue(value, module); 165 size_t value_size = m_target_data.getTypeStoreSize(value->getType()); 166 167 lldb_private::DataExtractor value_extractor; 168 lldb_private::Error extract_error; 169 170 m_memory_map.GetMemoryData(value_extractor, process_address, value_size, extract_error); 171 172 if (!extract_error.Success()) 173 return false; 174 175 lldb::offset_t offset = 0; 176 if (value_size == 1 || value_size == 2 || value_size == 4 || value_size == 8) 177 { 178 uint64_t u64value = value_extractor.GetMaxU64(&offset, value_size); 179 return AssignToMatchType(scalar, u64value, value->getType()); 180 } 181 } 182 183 return false; 184 } 185 186 bool AssignValue (const Value *value, lldb_private::Scalar &scalar, Module &module) 187 { 188 lldb::addr_t process_address = ResolveValue (value, module); 189 190 if (process_address == LLDB_INVALID_ADDRESS) 191 return false; 192 193 lldb_private::Scalar cast_scalar; 194 195 if (!AssignToMatchType(cast_scalar, scalar.GetRawBits64(0), value->getType())) 196 return false; 197 198 size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType()); 199 200 lldb_private::DataBufferHeap buf(value_byte_size, 0); 201 202 lldb_private::Error get_data_error; 203 204 if (!cast_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(), m_byte_order, get_data_error)) 205 return false; 206 207 lldb_private::Error write_error; 208 209 m_memory_map.WriteMemory(process_address, buf.GetBytes(), buf.GetByteSize(), write_error); 210 211 return write_error.Success(); 212 } 213 214 bool ResolveConstantValue (APInt &value, const Constant *constant) 215 { 216 switch (constant->getValueID()) 217 { 218 default: 219 break; 220 case Value::ConstantIntVal: 221 if (const ConstantInt *constant_int = dyn_cast<ConstantInt>(constant)) 222 { 223 value = constant_int->getValue(); 224 return true; 225 } 226 break; 227 case Value::ConstantFPVal: 228 if (const ConstantFP *constant_fp = dyn_cast<ConstantFP>(constant)) 229 { 230 value = constant_fp->getValueAPF().bitcastToAPInt(); 231 return true; 232 } 233 break; 234 case Value::ConstantExprVal: 235 if (const ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant)) 236 { 237 switch (constant_expr->getOpcode()) 238 { 239 default: 240 return false; 241 case Instruction::IntToPtr: 242 case Instruction::PtrToInt: 243 case Instruction::BitCast: 244 return ResolveConstantValue(value, constant_expr->getOperand(0)); 245 case Instruction::GetElementPtr: 246 { 247 ConstantExpr::const_op_iterator op_cursor = constant_expr->op_begin(); 248 ConstantExpr::const_op_iterator op_end = constant_expr->op_end(); 249 250 Constant *base = dyn_cast<Constant>(*op_cursor); 251 252 if (!base) 253 return false; 254 255 if (!ResolveConstantValue(value, base)) 256 return false; 257 258 op_cursor++; 259 260 if (op_cursor == op_end) 261 return true; // no offset to apply! 262 263 SmallVector <Value *, 8> indices (op_cursor, op_end); 264 265 uint64_t offset = m_target_data.getIndexedOffset(base->getType(), indices); 266 267 const bool is_signed = true; 268 value += APInt(value.getBitWidth(), offset, is_signed); 269 270 return true; 271 } 272 } 273 } 274 break; 275 case Value::ConstantPointerNullVal: 276 if (isa<ConstantPointerNull>(constant)) 277 { 278 value = APInt(m_target_data.getPointerSizeInBits(), 0); 279 return true; 280 } 281 break; 282 } 283 return false; 284 } 285 286 bool MakeArgument(const Argument *value, uint64_t address) 287 { 288 lldb::addr_t data_address = Malloc(value->getType()); 289 290 if (data_address == LLDB_INVALID_ADDRESS) 291 return false; 292 293 lldb_private::Error write_error; 294 295 m_memory_map.WritePointerToMemory(data_address, address, write_error); 296 297 if (!write_error.Success()) 298 { 299 lldb_private::Error free_error; 300 m_memory_map.Free(data_address, free_error); 301 return false; 302 } 303 304 m_values[value] = data_address; 305 306 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 307 308 if (log) 309 { 310 log->Printf("Made an allocation for argument %s", PrintValue(value).c_str()); 311 log->Printf(" Data region : %llx", (unsigned long long)address); 312 log->Printf(" Ref region : %llx", (unsigned long long)data_address); 313 } 314 315 return true; 316 } 317 318 bool ResolveConstant (lldb::addr_t process_address, const Constant *constant) 319 { 320 APInt resolved_value; 321 322 if (!ResolveConstantValue(resolved_value, constant)) 323 return false; 324 325 lldb_private::StreamString buffer (lldb_private::Stream::eBinary, 326 m_memory_map.GetAddressByteSize(), 327 m_memory_map.GetByteOrder()); 328 329 size_t constant_size = m_target_data.getTypeStoreSize(constant->getType()); 330 331 const uint64_t *raw_data = resolved_value.getRawData(); 332 333 buffer.PutRawBytes(raw_data, constant_size, lldb::endian::InlHostByteOrder()); 334 335 lldb_private::Error write_error; 336 337 m_memory_map.WriteMemory(process_address, (const uint8_t*)buffer.GetData(), constant_size, write_error); 338 339 return write_error.Success(); 340 } 341 342 lldb::addr_t Malloc (size_t size, uint8_t byte_alignment) 343 { 344 lldb::addr_t ret = m_stack_pointer; 345 346 ret -= size; 347 ret -= (ret % byte_alignment); 348 349 if (ret < m_frame_process_address) 350 return LLDB_INVALID_ADDRESS; 351 352 m_stack_pointer = ret; 353 return ret; 354 } 355 356 lldb::addr_t MallocPointer () 357 { 358 return Malloc(m_target_data.getPointerSize(), m_target_data.getPointerPrefAlignment()); 359 } 360 361 lldb::addr_t Malloc (llvm::Type *type) 362 { 363 lldb_private::Error alloc_error; 364 365 return Malloc(m_target_data.getTypeAllocSize(type), m_target_data.getPrefTypeAlignment(type)); 366 } 367 368 std::string PrintData (lldb::addr_t addr, llvm::Type *type) 369 { 370 size_t length = m_target_data.getTypeStoreSize(type); 371 372 lldb_private::DataBufferHeap buf(length, 0); 373 374 lldb_private::Error read_error; 375 376 m_memory_map.ReadMemory(buf.GetBytes(), addr, length, read_error); 377 378 if (!read_error.Success()) 379 return std::string("<couldn't read data>"); 380 381 lldb_private::StreamString ss; 382 383 for (size_t i = 0; i < length; i++) 384 { 385 if ((!(i & 0xf)) && i) 386 ss.Printf("%02hhx - ", buf.GetBytes()[i]); 387 else 388 ss.Printf("%02hhx ", buf.GetBytes()[i]); 389 } 390 391 return ss.GetString(); 392 } 393 394 lldb::addr_t ResolveValue (const Value *value, Module &module) 395 { 396 ValueMap::iterator i = m_values.find(value); 397 398 if (i != m_values.end()) 399 return i->second; 400 401 // Fall back and allocate space [allocation type Alloca] 402 403 lldb::addr_t data_address = Malloc(value->getType()); 404 405 if (const Constant *constant = dyn_cast<Constant>(value)) 406 { 407 if (!ResolveConstant (data_address, constant)) 408 { 409 lldb_private::Error free_error; 410 m_memory_map.Free(data_address, free_error); 411 return LLDB_INVALID_ADDRESS; 412 } 413 } 414 415 m_values[value] = data_address; 416 return data_address; 417 } 418 }; 419 420 static const char *unsupported_opcode_error = "Interpreter doesn't handle one of the expression's opcodes"; 421 static const char *unsupported_operand_error = "Interpreter doesn't handle one of the expression's operands"; 422 //static const char *interpreter_initialization_error = "Interpreter couldn't be initialized"; 423 static const char *interpreter_internal_error = "Interpreter encountered an internal error"; 424 static const char *bad_value_error = "Interpreter couldn't resolve a value during execution"; 425 static const char *memory_allocation_error = "Interpreter couldn't allocate memory"; 426 static const char *memory_write_error = "Interpreter couldn't write to memory"; 427 static const char *memory_read_error = "Interpreter couldn't read from memory"; 428 static const char *infinite_loop_error = "Interpreter ran for too many cycles"; 429 //static const char *bad_result_error = "Result of expression is in bad memory"; 430 431 bool 432 IRInterpreter::CanInterpret (llvm::Module &module, 433 llvm::Function &function, 434 lldb_private::Error &error) 435 { 436 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 437 438 bool saw_function_with_body = false; 439 440 for (Module::iterator fi = module.begin(), fe = module.end(); 441 fi != fe; 442 ++fi) 443 { 444 if (fi->begin() != fi->end()) 445 { 446 if (saw_function_with_body) 447 return false; 448 saw_function_with_body = true; 449 } 450 } 451 452 for (Function::iterator bbi = function.begin(), bbe = function.end(); 453 bbi != bbe; 454 ++bbi) 455 { 456 for (BasicBlock::iterator ii = bbi->begin(), ie = bbi->end(); 457 ii != ie; 458 ++ii) 459 { 460 switch (ii->getOpcode()) 461 { 462 default: 463 { 464 if (log) 465 log->Printf("Unsupported instruction: %s", PrintValue(ii).c_str()); 466 error.SetErrorToGenericError(); 467 error.SetErrorString(unsupported_opcode_error); 468 return false; 469 } 470 case Instruction::Add: 471 case Instruction::Alloca: 472 case Instruction::BitCast: 473 case Instruction::Br: 474 case Instruction::GetElementPtr: 475 break; 476 case Instruction::ICmp: 477 { 478 ICmpInst *icmp_inst = dyn_cast<ICmpInst>(ii); 479 480 if (!icmp_inst) 481 { 482 error.SetErrorToGenericError(); 483 error.SetErrorString(interpreter_internal_error); 484 return false; 485 } 486 487 switch (icmp_inst->getPredicate()) 488 { 489 default: 490 { 491 if (log) 492 log->Printf("Unsupported ICmp predicate: %s", PrintValue(ii).c_str()); 493 494 error.SetErrorToGenericError(); 495 error.SetErrorString(unsupported_opcode_error); 496 return false; 497 } 498 case CmpInst::ICMP_EQ: 499 case CmpInst::ICMP_NE: 500 case CmpInst::ICMP_UGT: 501 case CmpInst::ICMP_UGE: 502 case CmpInst::ICMP_ULT: 503 case CmpInst::ICMP_ULE: 504 case CmpInst::ICMP_SGT: 505 case CmpInst::ICMP_SGE: 506 case CmpInst::ICMP_SLT: 507 case CmpInst::ICMP_SLE: 508 break; 509 } 510 } 511 break; 512 case Instruction::And: 513 case Instruction::AShr: 514 case Instruction::IntToPtr: 515 case Instruction::PtrToInt: 516 case Instruction::Load: 517 case Instruction::LShr: 518 case Instruction::Mul: 519 case Instruction::Or: 520 case Instruction::Ret: 521 case Instruction::SDiv: 522 case Instruction::SExt: 523 case Instruction::Shl: 524 case Instruction::SRem: 525 case Instruction::Store: 526 case Instruction::Sub: 527 case Instruction::Trunc: 528 case Instruction::UDiv: 529 case Instruction::URem: 530 case Instruction::Xor: 531 case Instruction::ZExt: 532 break; 533 } 534 535 for (int oi = 0, oe = ii->getNumOperands(); 536 oi != oe; 537 ++oi) 538 { 539 Value *operand = ii->getOperand(oi); 540 Type *operand_type = operand->getType(); 541 542 switch (operand_type->getTypeID()) 543 { 544 default: 545 break; 546 case Type::VectorTyID: 547 { 548 if (log) 549 log->Printf("Unsupported operand type: %s", PrintType(operand_type).c_str()); 550 error.SetErrorString(unsupported_operand_error); 551 return false; 552 } 553 } 554 } 555 } 556 557 } 558 559 return true;} 560 561 bool 562 IRInterpreter::Interpret (llvm::Module &module, 563 llvm::Function &function, 564 llvm::ArrayRef<lldb::addr_t> args, 565 lldb_private::IRMemoryMap &memory_map, 566 lldb_private::Error &error, 567 lldb::addr_t stack_frame_bottom, 568 lldb::addr_t stack_frame_top) 569 { 570 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 571 572 if (log) 573 { 574 std::string s; 575 raw_string_ostream oss(s); 576 577 module.print(oss, NULL); 578 579 oss.flush(); 580 581 log->Printf("Module as passed in to IRInterpreter::Interpret: \n\"%s\"", s.c_str()); 582 } 583 584 DataLayout data_layout(&module); 585 586 InterpreterStackFrame frame(data_layout, memory_map, stack_frame_bottom, stack_frame_top); 587 588 if (frame.m_frame_process_address == LLDB_INVALID_ADDRESS) 589 { 590 error.SetErrorString("Couldn't allocate stack frame"); 591 } 592 593 int arg_index = 0; 594 595 for (llvm::Function::arg_iterator ai = function.arg_begin(), ae = function.arg_end(); 596 ai != ae; 597 ++ai, ++arg_index) 598 { 599 if (args.size() < arg_index) 600 { 601 error.SetErrorString ("Not enough arguments passed in to function"); 602 return false; 603 } 604 605 lldb::addr_t ptr = args[arg_index]; 606 607 frame.MakeArgument(ai, ptr); 608 } 609 610 uint32_t num_insts = 0; 611 612 frame.Jump(function.begin()); 613 614 while (frame.m_ii != frame.m_ie && (++num_insts < 4096)) 615 { 616 const Instruction *inst = frame.m_ii; 617 618 if (log) 619 log->Printf("Interpreting %s", PrintValue(inst).c_str()); 620 621 switch (inst->getOpcode()) 622 { 623 default: 624 break; 625 case Instruction::Add: 626 case Instruction::Sub: 627 case Instruction::Mul: 628 case Instruction::SDiv: 629 case Instruction::UDiv: 630 case Instruction::SRem: 631 case Instruction::URem: 632 case Instruction::Shl: 633 case Instruction::LShr: 634 case Instruction::AShr: 635 case Instruction::And: 636 case Instruction::Or: 637 case Instruction::Xor: 638 { 639 const BinaryOperator *bin_op = dyn_cast<BinaryOperator>(inst); 640 641 if (!bin_op) 642 { 643 if (log) 644 log->Printf("getOpcode() returns %s, but instruction is not a BinaryOperator", inst->getOpcodeName()); 645 error.SetErrorToGenericError(); 646 error.SetErrorString(interpreter_internal_error); 647 return false; 648 } 649 650 Value *lhs = inst->getOperand(0); 651 Value *rhs = inst->getOperand(1); 652 653 lldb_private::Scalar L; 654 lldb_private::Scalar R; 655 656 if (!frame.EvaluateValue(L, lhs, module)) 657 { 658 if (log) 659 log->Printf("Couldn't evaluate %s", PrintValue(lhs).c_str()); 660 error.SetErrorToGenericError(); 661 error.SetErrorString(bad_value_error); 662 return false; 663 } 664 665 if (!frame.EvaluateValue(R, rhs, module)) 666 { 667 if (log) 668 log->Printf("Couldn't evaluate %s", PrintValue(rhs).c_str()); 669 error.SetErrorToGenericError(); 670 error.SetErrorString(bad_value_error); 671 return false; 672 } 673 674 lldb_private::Scalar result; 675 676 switch (inst->getOpcode()) 677 { 678 default: 679 break; 680 case Instruction::Add: 681 result = L + R; 682 break; 683 case Instruction::Mul: 684 result = L * R; 685 break; 686 case Instruction::Sub: 687 result = L - R; 688 break; 689 case Instruction::SDiv: 690 L.MakeSigned(); 691 R.MakeSigned(); 692 result = L / R; 693 break; 694 case Instruction::UDiv: 695 result = L.GetRawBits64(0) / R.GetRawBits64(1); 696 break; 697 case Instruction::SRem: 698 L.MakeSigned(); 699 R.MakeSigned(); 700 result = L % R; 701 break; 702 case Instruction::URem: 703 result = L.GetRawBits64(0) % R.GetRawBits64(1); 704 break; 705 case Instruction::Shl: 706 result = L << R; 707 break; 708 case Instruction::AShr: 709 result = L >> R; 710 break; 711 case Instruction::LShr: 712 result = L; 713 result.ShiftRightLogical(R); 714 break; 715 case Instruction::And: 716 result = L & R; 717 break; 718 case Instruction::Or: 719 result = L | R; 720 break; 721 case Instruction::Xor: 722 result = L ^ R; 723 break; 724 } 725 726 frame.AssignValue(inst, result, module); 727 728 if (log) 729 { 730 log->Printf("Interpreted a %s", inst->getOpcodeName()); 731 log->Printf(" L : %s", frame.SummarizeValue(lhs).c_str()); 732 log->Printf(" R : %s", frame.SummarizeValue(rhs).c_str()); 733 log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 734 } 735 } 736 break; 737 case Instruction::Alloca: 738 { 739 const AllocaInst *alloca_inst = dyn_cast<AllocaInst>(inst); 740 741 if (!alloca_inst) 742 { 743 if (log) 744 log->Printf("getOpcode() returns Alloca, but instruction is not an AllocaInst"); 745 error.SetErrorToGenericError(); 746 error.SetErrorString(interpreter_internal_error); 747 return false; 748 } 749 750 if (alloca_inst->isArrayAllocation()) 751 { 752 if (log) 753 log->Printf("AllocaInsts are not handled if isArrayAllocation() is true"); 754 error.SetErrorToGenericError(); 755 error.SetErrorString(unsupported_opcode_error); 756 return false; 757 } 758 759 // The semantics of Alloca are: 760 // Create a region R of virtual memory of type T, backed by a data buffer 761 // Create a region P of virtual memory of type T*, backed by a data buffer 762 // Write the virtual address of R into P 763 764 Type *T = alloca_inst->getAllocatedType(); 765 Type *Tptr = alloca_inst->getType(); 766 767 lldb::addr_t R = frame.Malloc(T); 768 769 if (R == LLDB_INVALID_ADDRESS) 770 { 771 if (log) 772 log->Printf("Couldn't allocate memory for an AllocaInst"); 773 error.SetErrorToGenericError(); 774 error.SetErrorString(memory_allocation_error); 775 return false; 776 } 777 778 lldb::addr_t P = frame.Malloc(Tptr); 779 780 if (P == LLDB_INVALID_ADDRESS) 781 { 782 if (log) 783 log->Printf("Couldn't allocate the result pointer for an AllocaInst"); 784 error.SetErrorToGenericError(); 785 error.SetErrorString(memory_allocation_error); 786 return false; 787 } 788 789 lldb_private::Error write_error; 790 791 memory_map.WritePointerToMemory(P, R, write_error); 792 793 if (!write_error.Success()) 794 { 795 if (log) 796 log->Printf("Couldn't write the result pointer for an AllocaInst"); 797 error.SetErrorToGenericError(); 798 error.SetErrorString(memory_write_error); 799 lldb_private::Error free_error; 800 memory_map.Free(P, free_error); 801 memory_map.Free(R, free_error); 802 return false; 803 } 804 805 frame.m_values[alloca_inst] = P; 806 807 if (log) 808 { 809 log->Printf("Interpreted an AllocaInst"); 810 log->Printf(" R : 0x%" PRIx64, R); 811 log->Printf(" P : 0x%" PRIx64, P); 812 } 813 } 814 break; 815 case Instruction::BitCast: 816 case Instruction::ZExt: 817 { 818 const CastInst *cast_inst = dyn_cast<CastInst>(inst); 819 820 if (!cast_inst) 821 { 822 if (log) 823 log->Printf("getOpcode() returns %s, but instruction is not a BitCastInst", cast_inst->getOpcodeName()); 824 error.SetErrorToGenericError(); 825 error.SetErrorString(interpreter_internal_error); 826 return false; 827 } 828 829 Value *source = cast_inst->getOperand(0); 830 831 lldb_private::Scalar S; 832 833 if (!frame.EvaluateValue(S, source, module)) 834 { 835 if (log) 836 log->Printf("Couldn't evaluate %s", PrintValue(source).c_str()); 837 error.SetErrorToGenericError(); 838 error.SetErrorString(bad_value_error); 839 return false; 840 } 841 842 frame.AssignValue(inst, S, module); 843 } 844 break; 845 case Instruction::SExt: 846 { 847 const CastInst *cast_inst = dyn_cast<CastInst>(inst); 848 849 if (!cast_inst) 850 { 851 if (log) 852 log->Printf("getOpcode() returns %s, but instruction is not a BitCastInst", cast_inst->getOpcodeName()); 853 error.SetErrorToGenericError(); 854 error.SetErrorString(interpreter_internal_error); 855 return false; 856 } 857 858 Value *source = cast_inst->getOperand(0); 859 860 lldb_private::Scalar S; 861 862 if (!frame.EvaluateValue(S, source, module)) 863 { 864 if (log) 865 log->Printf("Couldn't evaluate %s", PrintValue(source).c_str()); 866 error.SetErrorToGenericError(); 867 error.SetErrorString(bad_value_error); 868 return false; 869 } 870 871 S.MakeSigned(); 872 873 lldb_private::Scalar S_signextend(S.SLongLong()); 874 875 frame.AssignValue(inst, S_signextend, module); 876 } 877 break; 878 case Instruction::Br: 879 { 880 const BranchInst *br_inst = dyn_cast<BranchInst>(inst); 881 882 if (!br_inst) 883 { 884 if (log) 885 log->Printf("getOpcode() returns Br, but instruction is not a BranchInst"); 886 error.SetErrorToGenericError(); 887 error.SetErrorString(interpreter_internal_error); 888 return false; 889 } 890 891 if (br_inst->isConditional()) 892 { 893 Value *condition = br_inst->getCondition(); 894 895 lldb_private::Scalar C; 896 897 if (!frame.EvaluateValue(C, condition, module)) 898 { 899 if (log) 900 log->Printf("Couldn't evaluate %s", PrintValue(condition).c_str()); 901 error.SetErrorToGenericError(); 902 error.SetErrorString(bad_value_error); 903 return false; 904 } 905 906 if (C.GetRawBits64(0)) 907 frame.Jump(br_inst->getSuccessor(0)); 908 else 909 frame.Jump(br_inst->getSuccessor(1)); 910 911 if (log) 912 { 913 log->Printf("Interpreted a BrInst with a condition"); 914 log->Printf(" cond : %s", frame.SummarizeValue(condition).c_str()); 915 } 916 } 917 else 918 { 919 frame.Jump(br_inst->getSuccessor(0)); 920 921 if (log) 922 { 923 log->Printf("Interpreted a BrInst with no condition"); 924 } 925 } 926 } 927 continue; 928 case Instruction::GetElementPtr: 929 { 930 const GetElementPtrInst *gep_inst = dyn_cast<GetElementPtrInst>(inst); 931 932 if (!gep_inst) 933 { 934 if (log) 935 log->Printf("getOpcode() returns GetElementPtr, but instruction is not a GetElementPtrInst"); 936 error.SetErrorToGenericError(); 937 error.SetErrorString(interpreter_internal_error); 938 return false; 939 } 940 941 const Value *pointer_operand = gep_inst->getPointerOperand(); 942 Type *pointer_type = pointer_operand->getType(); 943 944 lldb_private::Scalar P; 945 946 if (!frame.EvaluateValue(P, pointer_operand, module)) 947 { 948 if (log) 949 log->Printf("Couldn't evaluate %s", PrintValue(pointer_operand).c_str()); 950 error.SetErrorToGenericError(); 951 error.SetErrorString(bad_value_error); 952 return false; 953 } 954 955 typedef SmallVector <Value *, 8> IndexVector; 956 typedef IndexVector::iterator IndexIterator; 957 958 SmallVector <Value *, 8> indices (gep_inst->idx_begin(), 959 gep_inst->idx_end()); 960 961 SmallVector <Value *, 8> const_indices; 962 963 for (IndexIterator ii = indices.begin(), ie = indices.end(); 964 ii != ie; 965 ++ii) 966 { 967 ConstantInt *constant_index = dyn_cast<ConstantInt>(*ii); 968 969 if (!constant_index) 970 { 971 lldb_private::Scalar I; 972 973 if (!frame.EvaluateValue(I, *ii, module)) 974 { 975 if (log) 976 log->Printf("Couldn't evaluate %s", PrintValue(*ii).c_str()); 977 error.SetErrorToGenericError(); 978 error.SetErrorString(bad_value_error); 979 return false; 980 } 981 982 if (log) 983 log->Printf("Evaluated constant index %s as %llu", PrintValue(*ii).c_str(), I.ULongLong(LLDB_INVALID_ADDRESS)); 984 985 constant_index = cast<ConstantInt>(ConstantInt::get((*ii)->getType(), I.ULongLong(LLDB_INVALID_ADDRESS))); 986 } 987 988 const_indices.push_back(constant_index); 989 } 990 991 uint64_t offset = data_layout.getIndexedOffset(pointer_type, const_indices); 992 993 lldb_private::Scalar Poffset = P + offset; 994 995 frame.AssignValue(inst, Poffset, module); 996 997 if (log) 998 { 999 log->Printf("Interpreted a GetElementPtrInst"); 1000 log->Printf(" P : %s", frame.SummarizeValue(pointer_operand).c_str()); 1001 log->Printf(" Poffset : %s", frame.SummarizeValue(inst).c_str()); 1002 } 1003 } 1004 break; 1005 case Instruction::ICmp: 1006 { 1007 const ICmpInst *icmp_inst = dyn_cast<ICmpInst>(inst); 1008 1009 if (!icmp_inst) 1010 { 1011 if (log) 1012 log->Printf("getOpcode() returns ICmp, but instruction is not an ICmpInst"); 1013 error.SetErrorToGenericError(); 1014 error.SetErrorString(interpreter_internal_error); 1015 return false; 1016 } 1017 1018 CmpInst::Predicate predicate = icmp_inst->getPredicate(); 1019 1020 Value *lhs = inst->getOperand(0); 1021 Value *rhs = inst->getOperand(1); 1022 1023 lldb_private::Scalar L; 1024 lldb_private::Scalar R; 1025 1026 if (!frame.EvaluateValue(L, lhs, module)) 1027 { 1028 if (log) 1029 log->Printf("Couldn't evaluate %s", PrintValue(lhs).c_str()); 1030 error.SetErrorToGenericError(); 1031 error.SetErrorString(bad_value_error); 1032 return false; 1033 } 1034 1035 if (!frame.EvaluateValue(R, rhs, module)) 1036 { 1037 if (log) 1038 log->Printf("Couldn't evaluate %s", PrintValue(rhs).c_str()); 1039 error.SetErrorToGenericError(); 1040 error.SetErrorString(bad_value_error); 1041 return false; 1042 } 1043 1044 lldb_private::Scalar result; 1045 1046 switch (predicate) 1047 { 1048 default: 1049 return false; 1050 case CmpInst::ICMP_EQ: 1051 result = (L == R); 1052 break; 1053 case CmpInst::ICMP_NE: 1054 result = (L != R); 1055 break; 1056 case CmpInst::ICMP_UGT: 1057 result = (L.GetRawBits64(0) > R.GetRawBits64(0)); 1058 break; 1059 case CmpInst::ICMP_UGE: 1060 result = (L.GetRawBits64(0) >= R.GetRawBits64(0)); 1061 break; 1062 case CmpInst::ICMP_ULT: 1063 result = (L.GetRawBits64(0) < R.GetRawBits64(0)); 1064 break; 1065 case CmpInst::ICMP_ULE: 1066 result = (L.GetRawBits64(0) <= R.GetRawBits64(0)); 1067 break; 1068 case CmpInst::ICMP_SGT: 1069 L.MakeSigned(); 1070 R.MakeSigned(); 1071 result = (L > R); 1072 break; 1073 case CmpInst::ICMP_SGE: 1074 L.MakeSigned(); 1075 R.MakeSigned(); 1076 result = (L >= R); 1077 break; 1078 case CmpInst::ICMP_SLT: 1079 L.MakeSigned(); 1080 R.MakeSigned(); 1081 result = (L < R); 1082 break; 1083 case CmpInst::ICMP_SLE: 1084 L.MakeSigned(); 1085 R.MakeSigned(); 1086 result = (L <= R); 1087 break; 1088 } 1089 1090 frame.AssignValue(inst, result, module); 1091 1092 if (log) 1093 { 1094 log->Printf("Interpreted an ICmpInst"); 1095 log->Printf(" L : %s", frame.SummarizeValue(lhs).c_str()); 1096 log->Printf(" R : %s", frame.SummarizeValue(rhs).c_str()); 1097 log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 1098 } 1099 } 1100 break; 1101 case Instruction::IntToPtr: 1102 { 1103 const IntToPtrInst *int_to_ptr_inst = dyn_cast<IntToPtrInst>(inst); 1104 1105 if (!int_to_ptr_inst) 1106 { 1107 if (log) 1108 log->Printf("getOpcode() returns IntToPtr, but instruction is not an IntToPtrInst"); 1109 error.SetErrorToGenericError(); 1110 error.SetErrorString(interpreter_internal_error); 1111 return false; 1112 } 1113 1114 Value *src_operand = int_to_ptr_inst->getOperand(0); 1115 1116 lldb_private::Scalar I; 1117 1118 if (!frame.EvaluateValue(I, src_operand, module)) 1119 { 1120 if (log) 1121 log->Printf("Couldn't evaluate %s", PrintValue(src_operand).c_str()); 1122 error.SetErrorToGenericError(); 1123 error.SetErrorString(bad_value_error); 1124 return false; 1125 } 1126 1127 frame.AssignValue(inst, I, module); 1128 1129 if (log) 1130 { 1131 log->Printf("Interpreted an IntToPtr"); 1132 log->Printf(" Src : %s", frame.SummarizeValue(src_operand).c_str()); 1133 log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 1134 } 1135 } 1136 break; 1137 case Instruction::PtrToInt: 1138 { 1139 const PtrToIntInst *ptr_to_int_inst = dyn_cast<PtrToIntInst>(inst); 1140 1141 if (!ptr_to_int_inst) 1142 { 1143 if (log) 1144 log->Printf("getOpcode() returns PtrToInt, but instruction is not an PtrToIntInst"); 1145 error.SetErrorToGenericError(); 1146 error.SetErrorString(interpreter_internal_error); 1147 return false; 1148 } 1149 1150 Value *src_operand = ptr_to_int_inst->getOperand(0); 1151 1152 lldb_private::Scalar I; 1153 1154 if (!frame.EvaluateValue(I, src_operand, module)) 1155 { 1156 if (log) 1157 log->Printf("Couldn't evaluate %s", PrintValue(src_operand).c_str()); 1158 error.SetErrorToGenericError(); 1159 error.SetErrorString(bad_value_error); 1160 return false; 1161 } 1162 1163 frame.AssignValue(inst, I, module); 1164 1165 if (log) 1166 { 1167 log->Printf("Interpreted a PtrToInt"); 1168 log->Printf(" Src : %s", frame.SummarizeValue(src_operand).c_str()); 1169 log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 1170 } 1171 } 1172 break; 1173 case Instruction::Trunc: 1174 { 1175 const TruncInst *trunc_inst = dyn_cast<TruncInst>(inst); 1176 1177 if (!trunc_inst) 1178 { 1179 if (log) 1180 log->Printf("getOpcode() returns Trunc, but instruction is not a TruncInst"); 1181 error.SetErrorToGenericError(); 1182 error.SetErrorString(interpreter_internal_error); 1183 return false; 1184 } 1185 1186 Value *src_operand = trunc_inst->getOperand(0); 1187 1188 lldb_private::Scalar I; 1189 1190 if (!frame.EvaluateValue(I, src_operand, module)) 1191 { 1192 if (log) 1193 log->Printf("Couldn't evaluate %s", PrintValue(src_operand).c_str()); 1194 error.SetErrorToGenericError(); 1195 error.SetErrorString(bad_value_error); 1196 return false; 1197 } 1198 1199 frame.AssignValue(inst, I, module); 1200 1201 if (log) 1202 { 1203 log->Printf("Interpreted a Trunc"); 1204 log->Printf(" Src : %s", frame.SummarizeValue(src_operand).c_str()); 1205 log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 1206 } 1207 } 1208 break; 1209 case Instruction::Load: 1210 { 1211 const LoadInst *load_inst = dyn_cast<LoadInst>(inst); 1212 1213 if (!load_inst) 1214 { 1215 if (log) 1216 log->Printf("getOpcode() returns Load, but instruction is not a LoadInst"); 1217 error.SetErrorToGenericError(); 1218 error.SetErrorString(interpreter_internal_error); 1219 return false; 1220 } 1221 1222 // The semantics of Load are: 1223 // Create a region D that will contain the loaded data 1224 // Resolve the region P containing a pointer 1225 // Dereference P to get the region R that the data should be loaded from 1226 // Transfer a unit of type type(D) from R to D 1227 1228 const Value *pointer_operand = load_inst->getPointerOperand(); 1229 1230 Type *pointer_ty = pointer_operand->getType(); 1231 PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty); 1232 if (!pointer_ptr_ty) 1233 { 1234 if (log) 1235 log->Printf("getPointerOperand()->getType() is not a PointerType"); 1236 error.SetErrorToGenericError(); 1237 error.SetErrorString(interpreter_internal_error); 1238 return false; 1239 } 1240 Type *target_ty = pointer_ptr_ty->getElementType(); 1241 1242 lldb::addr_t D = frame.ResolveValue(load_inst, module); 1243 lldb::addr_t P = frame.ResolveValue(pointer_operand, module); 1244 1245 if (D == LLDB_INVALID_ADDRESS) 1246 { 1247 if (log) 1248 log->Printf("LoadInst's value doesn't resolve to anything"); 1249 error.SetErrorToGenericError(); 1250 error.SetErrorString(bad_value_error); 1251 return false; 1252 } 1253 1254 if (P == LLDB_INVALID_ADDRESS) 1255 { 1256 if (log) 1257 log->Printf("LoadInst's pointer doesn't resolve to anything"); 1258 error.SetErrorToGenericError(); 1259 error.SetErrorString(bad_value_error); 1260 return false; 1261 } 1262 1263 lldb::addr_t R; 1264 lldb_private::Error read_error; 1265 memory_map.ReadPointerFromMemory(&R, P, read_error); 1266 1267 if (!read_error.Success()) 1268 { 1269 if (log) 1270 log->Printf("Couldn't read the address to be loaded for a LoadInst"); 1271 error.SetErrorToGenericError(); 1272 error.SetErrorString(memory_read_error); 1273 return false; 1274 } 1275 1276 size_t target_size = data_layout.getTypeStoreSize(target_ty); 1277 lldb_private::DataBufferHeap buffer(target_size, 0); 1278 1279 read_error.Clear(); 1280 memory_map.ReadMemory(buffer.GetBytes(), R, buffer.GetByteSize(), read_error); 1281 if (!read_error.Success()) 1282 { 1283 if (log) 1284 log->Printf("Couldn't read from a region on behalf of a LoadInst"); 1285 error.SetErrorToGenericError(); 1286 error.SetErrorString(memory_read_error); 1287 return false; 1288 } 1289 1290 lldb_private::Error write_error; 1291 memory_map.WriteMemory(D, buffer.GetBytes(), buffer.GetByteSize(), write_error); 1292 if (!write_error.Success()) 1293 { 1294 if (log) 1295 log->Printf("Couldn't write to a region on behalf of a LoadInst"); 1296 error.SetErrorToGenericError(); 1297 error.SetErrorString(memory_read_error); 1298 return false; 1299 } 1300 1301 if (log) 1302 { 1303 log->Printf("Interpreted a LoadInst"); 1304 log->Printf(" P : 0x%" PRIx64, P); 1305 log->Printf(" R : 0x%" PRIx64, R); 1306 log->Printf(" D : 0x%" PRIx64, D); 1307 } 1308 } 1309 break; 1310 case Instruction::Ret: 1311 { 1312 return true; 1313 } 1314 case Instruction::Store: 1315 { 1316 const StoreInst *store_inst = dyn_cast<StoreInst>(inst); 1317 1318 if (!store_inst) 1319 { 1320 if (log) 1321 log->Printf("getOpcode() returns Store, but instruction is not a StoreInst"); 1322 error.SetErrorToGenericError(); 1323 error.SetErrorString(interpreter_internal_error); 1324 return false; 1325 } 1326 1327 // The semantics of Store are: 1328 // Resolve the region D containing the data to be stored 1329 // Resolve the region P containing a pointer 1330 // Dereference P to get the region R that the data should be stored in 1331 // Transfer a unit of type type(D) from D to R 1332 1333 const Value *value_operand = store_inst->getValueOperand(); 1334 const Value *pointer_operand = store_inst->getPointerOperand(); 1335 1336 Type *pointer_ty = pointer_operand->getType(); 1337 PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty); 1338 if (!pointer_ptr_ty) 1339 return false; 1340 Type *target_ty = pointer_ptr_ty->getElementType(); 1341 1342 lldb::addr_t D = frame.ResolveValue(value_operand, module); 1343 lldb::addr_t P = frame.ResolveValue(pointer_operand, module); 1344 1345 if (D == LLDB_INVALID_ADDRESS) 1346 { 1347 if (log) 1348 log->Printf("StoreInst's value doesn't resolve to anything"); 1349 error.SetErrorToGenericError(); 1350 error.SetErrorString(bad_value_error); 1351 return false; 1352 } 1353 1354 if (P == LLDB_INVALID_ADDRESS) 1355 { 1356 if (log) 1357 log->Printf("StoreInst's pointer doesn't resolve to anything"); 1358 error.SetErrorToGenericError(); 1359 error.SetErrorString(bad_value_error); 1360 return false; 1361 } 1362 1363 lldb::addr_t R; 1364 lldb_private::Error read_error; 1365 memory_map.ReadPointerFromMemory(&R, P, read_error); 1366 1367 if (!read_error.Success()) 1368 { 1369 if (log) 1370 log->Printf("Couldn't read the address to be loaded for a LoadInst"); 1371 error.SetErrorToGenericError(); 1372 error.SetErrorString(memory_read_error); 1373 return false; 1374 } 1375 1376 size_t target_size = data_layout.getTypeStoreSize(target_ty); 1377 lldb_private::DataBufferHeap buffer(target_size, 0); 1378 1379 read_error.Clear(); 1380 memory_map.ReadMemory(buffer.GetBytes(), D, buffer.GetByteSize(), read_error); 1381 if (!read_error.Success()) 1382 { 1383 if (log) 1384 log->Printf("Couldn't read from a region on behalf of a StoreInst"); 1385 error.SetErrorToGenericError(); 1386 error.SetErrorString(memory_read_error); 1387 return false; 1388 } 1389 1390 lldb_private::Error write_error; 1391 memory_map.WriteMemory(R, buffer.GetBytes(), buffer.GetByteSize(), write_error); 1392 if (!write_error.Success()) 1393 { 1394 if (log) 1395 log->Printf("Couldn't write to a region on behalf of a StoreInst"); 1396 error.SetErrorToGenericError(); 1397 error.SetErrorString(memory_write_error); 1398 return false; 1399 } 1400 1401 if (log) 1402 { 1403 log->Printf("Interpreted a StoreInst"); 1404 log->Printf(" D : 0x%" PRIx64, D); 1405 log->Printf(" P : 0x%" PRIx64, P); 1406 log->Printf(" R : 0x%" PRIx64, R); 1407 } 1408 } 1409 break; 1410 } 1411 1412 ++frame.m_ii; 1413 } 1414 1415 if (num_insts >= 4096) 1416 { 1417 error.SetErrorToGenericError(); 1418 error.SetErrorString(infinite_loop_error); 1419 return false; 1420 } 1421 1422 return false; 1423 } 1424