1254721Semaste//===-- IRInterpreter.cpp ---------------------------------------*- C++ -*-===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste 10254721Semaste#include "lldb/Core/DataExtractor.h" 11254721Semaste#include "lldb/Core/Error.h" 12254721Semaste#include "lldb/Core/Log.h" 13254721Semaste#include "lldb/Core/Scalar.h" 14254721Semaste#include "lldb/Core/StreamString.h" 15254721Semaste#include "lldb/Expression/IRMemoryMap.h" 16254721Semaste#include "lldb/Expression/IRInterpreter.h" 17263363Semaste#include "lldb/Host/Endian.h" 18254721Semaste 19254721Semaste#include "llvm/IR/Constants.h" 20254721Semaste#include "llvm/IR/DataLayout.h" 21254721Semaste#include "llvm/IR/Function.h" 22254721Semaste#include "llvm/IR/Instructions.h" 23254721Semaste#include "llvm/IR/Module.h" 24254721Semaste#include "llvm/Support/raw_ostream.h" 25254721Semaste 26254721Semaste#include <map> 27254721Semaste 28254721Semasteusing namespace llvm; 29254721Semaste 30254721Semastestatic std::string 31254721SemastePrintValue(const Value *value, bool truncate = false) 32254721Semaste{ 33254721Semaste std::string s; 34254721Semaste raw_string_ostream rso(s); 35254721Semaste value->print(rso); 36254721Semaste rso.flush(); 37254721Semaste if (truncate) 38254721Semaste s.resize(s.length() - 1); 39254721Semaste 40254721Semaste size_t offset; 41254721Semaste while ((offset = s.find('\n')) != s.npos) 42254721Semaste s.erase(offset, 1); 43254721Semaste while (s[0] == ' ' || s[0] == '\t') 44254721Semaste s.erase(0, 1); 45254721Semaste 46254721Semaste return s; 47254721Semaste} 48254721Semaste 49254721Semastestatic std::string 50254721SemastePrintType(const Type *type, bool truncate = false) 51254721Semaste{ 52254721Semaste std::string s; 53254721Semaste raw_string_ostream rso(s); 54254721Semaste type->print(rso); 55254721Semaste rso.flush(); 56254721Semaste if (truncate) 57254721Semaste s.resize(s.length() - 1); 58254721Semaste return s; 59254721Semaste} 60254721Semaste 61254721Semasteclass InterpreterStackFrame 62254721Semaste{ 63254721Semastepublic: 64254721Semaste typedef std::map <const Value*, lldb::addr_t> ValueMap; 65254721Semaste 66254721Semaste ValueMap m_values; 67254721Semaste DataLayout &m_target_data; 68254721Semaste lldb_private::IRMemoryMap &m_memory_map; 69254721Semaste const BasicBlock *m_bb; 70254721Semaste BasicBlock::const_iterator m_ii; 71254721Semaste BasicBlock::const_iterator m_ie; 72254721Semaste 73254721Semaste lldb::addr_t m_frame_process_address; 74254721Semaste size_t m_frame_size; 75254721Semaste lldb::addr_t m_stack_pointer; 76254721Semaste 77254721Semaste lldb::ByteOrder m_byte_order; 78254721Semaste size_t m_addr_byte_size; 79254721Semaste 80254721Semaste InterpreterStackFrame (DataLayout &target_data, 81254721Semaste lldb_private::IRMemoryMap &memory_map, 82254721Semaste lldb::addr_t stack_frame_bottom, 83254721Semaste lldb::addr_t stack_frame_top) : 84254721Semaste m_target_data (target_data), 85254721Semaste m_memory_map (memory_map) 86254721Semaste { 87254721Semaste m_byte_order = (target_data.isLittleEndian() ? lldb::eByteOrderLittle : lldb::eByteOrderBig); 88254721Semaste m_addr_byte_size = (target_data.getPointerSize(0)); 89254721Semaste 90254721Semaste m_frame_process_address = stack_frame_bottom; 91254721Semaste m_frame_size = stack_frame_top - stack_frame_bottom; 92254721Semaste m_stack_pointer = stack_frame_top; 93254721Semaste } 94254721Semaste 95254721Semaste ~InterpreterStackFrame () 96254721Semaste { 97254721Semaste } 98254721Semaste 99254721Semaste void Jump (const BasicBlock *bb) 100254721Semaste { 101254721Semaste m_bb = bb; 102254721Semaste m_ii = m_bb->begin(); 103254721Semaste m_ie = m_bb->end(); 104254721Semaste } 105254721Semaste 106254721Semaste std::string SummarizeValue (const Value *value) 107254721Semaste { 108254721Semaste lldb_private::StreamString ss; 109254721Semaste 110254721Semaste ss.Printf("%s", PrintValue(value).c_str()); 111254721Semaste 112254721Semaste ValueMap::iterator i = m_values.find(value); 113254721Semaste 114254721Semaste if (i != m_values.end()) 115254721Semaste { 116254721Semaste lldb::addr_t addr = i->second; 117254721Semaste 118254721Semaste ss.Printf(" 0x%llx", (unsigned long long)addr); 119254721Semaste } 120254721Semaste 121254721Semaste return ss.GetString(); 122254721Semaste } 123254721Semaste 124254721Semaste bool AssignToMatchType (lldb_private::Scalar &scalar, uint64_t u64value, Type *type) 125254721Semaste { 126254721Semaste size_t type_size = m_target_data.getTypeStoreSize(type); 127254721Semaste 128254721Semaste switch (type_size) 129254721Semaste { 130254721Semaste case 1: 131254721Semaste scalar = (uint8_t)u64value; 132254721Semaste break; 133254721Semaste case 2: 134254721Semaste scalar = (uint16_t)u64value; 135254721Semaste break; 136254721Semaste case 4: 137254721Semaste scalar = (uint32_t)u64value; 138254721Semaste break; 139254721Semaste case 8: 140254721Semaste scalar = (uint64_t)u64value; 141254721Semaste break; 142254721Semaste default: 143254721Semaste return false; 144254721Semaste } 145254721Semaste 146254721Semaste return true; 147254721Semaste } 148254721Semaste 149254721Semaste bool EvaluateValue (lldb_private::Scalar &scalar, const Value *value, Module &module) 150254721Semaste { 151254721Semaste const Constant *constant = dyn_cast<Constant>(value); 152254721Semaste 153254721Semaste if (constant) 154254721Semaste { 155254721Semaste APInt value_apint; 156254721Semaste 157254721Semaste if (!ResolveConstantValue(value_apint, constant)) 158254721Semaste return false; 159254721Semaste 160254721Semaste return AssignToMatchType(scalar, value_apint.getLimitedValue(), value->getType()); 161254721Semaste } 162254721Semaste else 163254721Semaste { 164254721Semaste lldb::addr_t process_address = ResolveValue(value, module); 165254721Semaste size_t value_size = m_target_data.getTypeStoreSize(value->getType()); 166254721Semaste 167254721Semaste lldb_private::DataExtractor value_extractor; 168254721Semaste lldb_private::Error extract_error; 169254721Semaste 170254721Semaste m_memory_map.GetMemoryData(value_extractor, process_address, value_size, extract_error); 171254721Semaste 172254721Semaste if (!extract_error.Success()) 173254721Semaste return false; 174254721Semaste 175254721Semaste lldb::offset_t offset = 0; 176254721Semaste if (value_size == 1 || value_size == 2 || value_size == 4 || value_size == 8) 177254721Semaste { 178254721Semaste uint64_t u64value = value_extractor.GetMaxU64(&offset, value_size); 179254721Semaste return AssignToMatchType(scalar, u64value, value->getType()); 180254721Semaste } 181254721Semaste } 182254721Semaste 183254721Semaste return false; 184254721Semaste } 185254721Semaste 186254721Semaste bool AssignValue (const Value *value, lldb_private::Scalar &scalar, Module &module) 187254721Semaste { 188254721Semaste lldb::addr_t process_address = ResolveValue (value, module); 189254721Semaste 190254721Semaste if (process_address == LLDB_INVALID_ADDRESS) 191254721Semaste return false; 192254721Semaste 193254721Semaste lldb_private::Scalar cast_scalar; 194254721Semaste 195254721Semaste if (!AssignToMatchType(cast_scalar, scalar.GetRawBits64(0), value->getType())) 196254721Semaste return false; 197254721Semaste 198254721Semaste size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType()); 199254721Semaste 200254721Semaste lldb_private::DataBufferHeap buf(value_byte_size, 0); 201254721Semaste 202254721Semaste lldb_private::Error get_data_error; 203254721Semaste 204254721Semaste if (!cast_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(), m_byte_order, get_data_error)) 205254721Semaste return false; 206254721Semaste 207254721Semaste lldb_private::Error write_error; 208254721Semaste 209254721Semaste m_memory_map.WriteMemory(process_address, buf.GetBytes(), buf.GetByteSize(), write_error); 210254721Semaste 211254721Semaste return write_error.Success(); 212254721Semaste } 213254721Semaste 214254721Semaste bool ResolveConstantValue (APInt &value, const Constant *constant) 215254721Semaste { 216254721Semaste switch (constant->getValueID()) 217254721Semaste { 218254721Semaste default: 219254721Semaste break; 220254721Semaste case Value::ConstantIntVal: 221254721Semaste if (const ConstantInt *constant_int = dyn_cast<ConstantInt>(constant)) 222254721Semaste { 223254721Semaste value = constant_int->getValue(); 224254721Semaste return true; 225254721Semaste } 226254721Semaste break; 227254721Semaste case Value::ConstantFPVal: 228254721Semaste if (const ConstantFP *constant_fp = dyn_cast<ConstantFP>(constant)) 229254721Semaste { 230254721Semaste value = constant_fp->getValueAPF().bitcastToAPInt(); 231254721Semaste return true; 232254721Semaste } 233254721Semaste break; 234254721Semaste case Value::ConstantExprVal: 235254721Semaste if (const ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant)) 236254721Semaste { 237254721Semaste switch (constant_expr->getOpcode()) 238254721Semaste { 239254721Semaste default: 240254721Semaste return false; 241254721Semaste case Instruction::IntToPtr: 242254721Semaste case Instruction::PtrToInt: 243254721Semaste case Instruction::BitCast: 244254721Semaste return ResolveConstantValue(value, constant_expr->getOperand(0)); 245254721Semaste case Instruction::GetElementPtr: 246254721Semaste { 247254721Semaste ConstantExpr::const_op_iterator op_cursor = constant_expr->op_begin(); 248254721Semaste ConstantExpr::const_op_iterator op_end = constant_expr->op_end(); 249254721Semaste 250254721Semaste Constant *base = dyn_cast<Constant>(*op_cursor); 251254721Semaste 252254721Semaste if (!base) 253254721Semaste return false; 254254721Semaste 255254721Semaste if (!ResolveConstantValue(value, base)) 256254721Semaste return false; 257254721Semaste 258254721Semaste op_cursor++; 259254721Semaste 260254721Semaste if (op_cursor == op_end) 261254721Semaste return true; // no offset to apply! 262254721Semaste 263254721Semaste SmallVector <Value *, 8> indices (op_cursor, op_end); 264254721Semaste 265254721Semaste uint64_t offset = m_target_data.getIndexedOffset(base->getType(), indices); 266254721Semaste 267254721Semaste const bool is_signed = true; 268254721Semaste value += APInt(value.getBitWidth(), offset, is_signed); 269254721Semaste 270254721Semaste return true; 271254721Semaste } 272254721Semaste } 273254721Semaste } 274254721Semaste break; 275254721Semaste case Value::ConstantPointerNullVal: 276254721Semaste if (isa<ConstantPointerNull>(constant)) 277254721Semaste { 278254721Semaste value = APInt(m_target_data.getPointerSizeInBits(), 0); 279254721Semaste return true; 280254721Semaste } 281254721Semaste break; 282254721Semaste } 283254721Semaste return false; 284254721Semaste } 285254721Semaste 286254721Semaste bool MakeArgument(const Argument *value, uint64_t address) 287254721Semaste { 288254721Semaste lldb::addr_t data_address = Malloc(value->getType()); 289254721Semaste 290254721Semaste if (data_address == LLDB_INVALID_ADDRESS) 291254721Semaste return false; 292254721Semaste 293254721Semaste lldb_private::Error write_error; 294254721Semaste 295254721Semaste m_memory_map.WritePointerToMemory(data_address, address, write_error); 296254721Semaste 297254721Semaste if (!write_error.Success()) 298254721Semaste { 299254721Semaste lldb_private::Error free_error; 300254721Semaste m_memory_map.Free(data_address, free_error); 301254721Semaste return false; 302254721Semaste } 303254721Semaste 304254721Semaste m_values[value] = data_address; 305254721Semaste 306254721Semaste lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 307254721Semaste 308254721Semaste if (log) 309254721Semaste { 310254721Semaste log->Printf("Made an allocation for argument %s", PrintValue(value).c_str()); 311254721Semaste log->Printf(" Data region : %llx", (unsigned long long)address); 312254721Semaste log->Printf(" Ref region : %llx", (unsigned long long)data_address); 313254721Semaste } 314254721Semaste 315254721Semaste return true; 316254721Semaste } 317254721Semaste 318254721Semaste bool ResolveConstant (lldb::addr_t process_address, const Constant *constant) 319254721Semaste { 320254721Semaste APInt resolved_value; 321254721Semaste 322254721Semaste if (!ResolveConstantValue(resolved_value, constant)) 323254721Semaste return false; 324254721Semaste 325263363Semaste lldb_private::StreamString buffer (lldb_private::Stream::eBinary, 326263363Semaste m_memory_map.GetAddressByteSize(), 327263363Semaste m_memory_map.GetByteOrder()); 328263363Semaste 329254721Semaste size_t constant_size = m_target_data.getTypeStoreSize(constant->getType()); 330254721Semaste 331263363Semaste const uint64_t *raw_data = resolved_value.getRawData(); 332263363Semaste 333263363Semaste buffer.PutRawBytes(raw_data, constant_size, lldb::endian::InlHostByteOrder()); 334263363Semaste 335254721Semaste lldb_private::Error write_error; 336254721Semaste 337263363Semaste m_memory_map.WriteMemory(process_address, (const uint8_t*)buffer.GetData(), constant_size, write_error); 338254721Semaste 339254721Semaste return write_error.Success(); 340254721Semaste } 341254721Semaste 342254721Semaste lldb::addr_t Malloc (size_t size, uint8_t byte_alignment) 343254721Semaste { 344254721Semaste lldb::addr_t ret = m_stack_pointer; 345254721Semaste 346254721Semaste ret -= size; 347254721Semaste ret -= (ret % byte_alignment); 348254721Semaste 349254721Semaste if (ret < m_frame_process_address) 350254721Semaste return LLDB_INVALID_ADDRESS; 351254721Semaste 352254721Semaste m_stack_pointer = ret; 353254721Semaste return ret; 354254721Semaste } 355254721Semaste 356254721Semaste lldb::addr_t MallocPointer () 357254721Semaste { 358254721Semaste return Malloc(m_target_data.getPointerSize(), m_target_data.getPointerPrefAlignment()); 359254721Semaste } 360254721Semaste 361254721Semaste lldb::addr_t Malloc (llvm::Type *type) 362254721Semaste { 363254721Semaste lldb_private::Error alloc_error; 364254721Semaste 365254721Semaste return Malloc(m_target_data.getTypeAllocSize(type), m_target_data.getPrefTypeAlignment(type)); 366254721Semaste } 367254721Semaste 368254721Semaste std::string PrintData (lldb::addr_t addr, llvm::Type *type) 369254721Semaste { 370254721Semaste size_t length = m_target_data.getTypeStoreSize(type); 371254721Semaste 372254721Semaste lldb_private::DataBufferHeap buf(length, 0); 373254721Semaste 374254721Semaste lldb_private::Error read_error; 375254721Semaste 376254721Semaste m_memory_map.ReadMemory(buf.GetBytes(), addr, length, read_error); 377254721Semaste 378254721Semaste if (!read_error.Success()) 379254721Semaste return std::string("<couldn't read data>"); 380254721Semaste 381254721Semaste lldb_private::StreamString ss; 382254721Semaste 383254721Semaste for (size_t i = 0; i < length; i++) 384254721Semaste { 385254721Semaste if ((!(i & 0xf)) && i) 386254721Semaste ss.Printf("%02hhx - ", buf.GetBytes()[i]); 387254721Semaste else 388254721Semaste ss.Printf("%02hhx ", buf.GetBytes()[i]); 389254721Semaste } 390254721Semaste 391254721Semaste return ss.GetString(); 392254721Semaste } 393254721Semaste 394254721Semaste lldb::addr_t ResolveValue (const Value *value, Module &module) 395254721Semaste { 396254721Semaste ValueMap::iterator i = m_values.find(value); 397254721Semaste 398254721Semaste if (i != m_values.end()) 399254721Semaste return i->second; 400254721Semaste 401254721Semaste // Fall back and allocate space [allocation type Alloca] 402254721Semaste 403254721Semaste lldb::addr_t data_address = Malloc(value->getType()); 404254721Semaste 405254721Semaste if (const Constant *constant = dyn_cast<Constant>(value)) 406254721Semaste { 407254721Semaste if (!ResolveConstant (data_address, constant)) 408254721Semaste { 409254721Semaste lldb_private::Error free_error; 410254721Semaste m_memory_map.Free(data_address, free_error); 411254721Semaste return LLDB_INVALID_ADDRESS; 412254721Semaste } 413254721Semaste } 414254721Semaste 415254721Semaste m_values[value] = data_address; 416254721Semaste return data_address; 417254721Semaste } 418254721Semaste}; 419254721Semaste 420254721Semastestatic const char *unsupported_opcode_error = "Interpreter doesn't handle one of the expression's opcodes"; 421254721Semastestatic const char *unsupported_operand_error = "Interpreter doesn't handle one of the expression's operands"; 422254721Semaste//static const char *interpreter_initialization_error = "Interpreter couldn't be initialized"; 423254721Semastestatic const char *interpreter_internal_error = "Interpreter encountered an internal error"; 424254721Semastestatic const char *bad_value_error = "Interpreter couldn't resolve a value during execution"; 425254721Semastestatic const char *memory_allocation_error = "Interpreter couldn't allocate memory"; 426254721Semastestatic const char *memory_write_error = "Interpreter couldn't write to memory"; 427254721Semastestatic const char *memory_read_error = "Interpreter couldn't read from memory"; 428254721Semastestatic const char *infinite_loop_error = "Interpreter ran for too many cycles"; 429254721Semaste//static const char *bad_result_error = "Result of expression is in bad memory"; 430254721Semaste 431254721Semastebool 432254721SemasteIRInterpreter::CanInterpret (llvm::Module &module, 433254721Semaste llvm::Function &function, 434254721Semaste lldb_private::Error &error) 435254721Semaste{ 436254721Semaste lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 437254721Semaste 438254721Semaste bool saw_function_with_body = false; 439254721Semaste 440254721Semaste for (Module::iterator fi = module.begin(), fe = module.end(); 441254721Semaste fi != fe; 442254721Semaste ++fi) 443254721Semaste { 444254721Semaste if (fi->begin() != fi->end()) 445254721Semaste { 446254721Semaste if (saw_function_with_body) 447254721Semaste return false; 448254721Semaste saw_function_with_body = true; 449254721Semaste } 450254721Semaste } 451254721Semaste 452254721Semaste for (Function::iterator bbi = function.begin(), bbe = function.end(); 453254721Semaste bbi != bbe; 454254721Semaste ++bbi) 455254721Semaste { 456254721Semaste for (BasicBlock::iterator ii = bbi->begin(), ie = bbi->end(); 457254721Semaste ii != ie; 458254721Semaste ++ii) 459254721Semaste { 460254721Semaste switch (ii->getOpcode()) 461254721Semaste { 462254721Semaste default: 463254721Semaste { 464254721Semaste if (log) 465254721Semaste log->Printf("Unsupported instruction: %s", PrintValue(ii).c_str()); 466254721Semaste error.SetErrorToGenericError(); 467254721Semaste error.SetErrorString(unsupported_opcode_error); 468254721Semaste return false; 469254721Semaste } 470254721Semaste case Instruction::Add: 471254721Semaste case Instruction::Alloca: 472254721Semaste case Instruction::BitCast: 473254721Semaste case Instruction::Br: 474254721Semaste case Instruction::GetElementPtr: 475254721Semaste break; 476254721Semaste case Instruction::ICmp: 477254721Semaste { 478254721Semaste ICmpInst *icmp_inst = dyn_cast<ICmpInst>(ii); 479254721Semaste 480254721Semaste if (!icmp_inst) 481254721Semaste { 482254721Semaste error.SetErrorToGenericError(); 483254721Semaste error.SetErrorString(interpreter_internal_error); 484254721Semaste return false; 485254721Semaste } 486254721Semaste 487254721Semaste switch (icmp_inst->getPredicate()) 488254721Semaste { 489254721Semaste default: 490254721Semaste { 491254721Semaste if (log) 492254721Semaste log->Printf("Unsupported ICmp predicate: %s", PrintValue(ii).c_str()); 493254721Semaste 494254721Semaste error.SetErrorToGenericError(); 495254721Semaste error.SetErrorString(unsupported_opcode_error); 496254721Semaste return false; 497254721Semaste } 498254721Semaste case CmpInst::ICMP_EQ: 499254721Semaste case CmpInst::ICMP_NE: 500254721Semaste case CmpInst::ICMP_UGT: 501254721Semaste case CmpInst::ICMP_UGE: 502254721Semaste case CmpInst::ICMP_ULT: 503254721Semaste case CmpInst::ICMP_ULE: 504254721Semaste case CmpInst::ICMP_SGT: 505254721Semaste case CmpInst::ICMP_SGE: 506254721Semaste case CmpInst::ICMP_SLT: 507254721Semaste case CmpInst::ICMP_SLE: 508254721Semaste break; 509254721Semaste } 510254721Semaste } 511254721Semaste break; 512254721Semaste case Instruction::And: 513254721Semaste case Instruction::AShr: 514254721Semaste case Instruction::IntToPtr: 515254721Semaste case Instruction::PtrToInt: 516254721Semaste case Instruction::Load: 517254721Semaste case Instruction::LShr: 518254721Semaste case Instruction::Mul: 519254721Semaste case Instruction::Or: 520254721Semaste case Instruction::Ret: 521254721Semaste case Instruction::SDiv: 522254721Semaste case Instruction::SExt: 523254721Semaste case Instruction::Shl: 524254721Semaste case Instruction::SRem: 525254721Semaste case Instruction::Store: 526254721Semaste case Instruction::Sub: 527263363Semaste case Instruction::Trunc: 528254721Semaste case Instruction::UDiv: 529254721Semaste case Instruction::URem: 530254721Semaste case Instruction::Xor: 531254721Semaste case Instruction::ZExt: 532254721Semaste break; 533254721Semaste } 534254721Semaste 535254721Semaste for (int oi = 0, oe = ii->getNumOperands(); 536254721Semaste oi != oe; 537254721Semaste ++oi) 538254721Semaste { 539254721Semaste Value *operand = ii->getOperand(oi); 540254721Semaste Type *operand_type = operand->getType(); 541254721Semaste 542254721Semaste switch (operand_type->getTypeID()) 543254721Semaste { 544254721Semaste default: 545254721Semaste break; 546254721Semaste case Type::VectorTyID: 547254721Semaste { 548254721Semaste if (log) 549254721Semaste log->Printf("Unsupported operand type: %s", PrintType(operand_type).c_str()); 550254721Semaste error.SetErrorString(unsupported_operand_error); 551254721Semaste return false; 552254721Semaste } 553254721Semaste } 554254721Semaste } 555254721Semaste } 556254721Semaste 557254721Semaste } 558254721Semaste 559254721Semaste return true;} 560254721Semaste 561254721Semastebool 562254721SemasteIRInterpreter::Interpret (llvm::Module &module, 563254721Semaste llvm::Function &function, 564254721Semaste llvm::ArrayRef<lldb::addr_t> args, 565254721Semaste lldb_private::IRMemoryMap &memory_map, 566254721Semaste lldb_private::Error &error, 567254721Semaste lldb::addr_t stack_frame_bottom, 568254721Semaste lldb::addr_t stack_frame_top) 569254721Semaste{ 570254721Semaste lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 571254721Semaste 572254721Semaste if (log) 573254721Semaste { 574254721Semaste std::string s; 575254721Semaste raw_string_ostream oss(s); 576254721Semaste 577254721Semaste module.print(oss, NULL); 578254721Semaste 579254721Semaste oss.flush(); 580254721Semaste 581254721Semaste log->Printf("Module as passed in to IRInterpreter::Interpret: \n\"%s\"", s.c_str()); 582254721Semaste } 583254721Semaste 584254721Semaste DataLayout data_layout(&module); 585254721Semaste 586254721Semaste InterpreterStackFrame frame(data_layout, memory_map, stack_frame_bottom, stack_frame_top); 587254721Semaste 588254721Semaste if (frame.m_frame_process_address == LLDB_INVALID_ADDRESS) 589254721Semaste { 590254721Semaste error.SetErrorString("Couldn't allocate stack frame"); 591254721Semaste } 592254721Semaste 593254721Semaste int arg_index = 0; 594254721Semaste 595254721Semaste for (llvm::Function::arg_iterator ai = function.arg_begin(), ae = function.arg_end(); 596254721Semaste ai != ae; 597254721Semaste ++ai, ++arg_index) 598254721Semaste { 599254721Semaste if (args.size() < arg_index) 600254721Semaste { 601254721Semaste error.SetErrorString ("Not enough arguments passed in to function"); 602254721Semaste return false; 603254721Semaste } 604254721Semaste 605254721Semaste lldb::addr_t ptr = args[arg_index]; 606254721Semaste 607254721Semaste frame.MakeArgument(ai, ptr); 608254721Semaste } 609254721Semaste 610254721Semaste uint32_t num_insts = 0; 611254721Semaste 612254721Semaste frame.Jump(function.begin()); 613254721Semaste 614254721Semaste while (frame.m_ii != frame.m_ie && (++num_insts < 4096)) 615254721Semaste { 616254721Semaste const Instruction *inst = frame.m_ii; 617254721Semaste 618254721Semaste if (log) 619254721Semaste log->Printf("Interpreting %s", PrintValue(inst).c_str()); 620254721Semaste 621254721Semaste switch (inst->getOpcode()) 622254721Semaste { 623254721Semaste default: 624254721Semaste break; 625254721Semaste case Instruction::Add: 626254721Semaste case Instruction::Sub: 627254721Semaste case Instruction::Mul: 628254721Semaste case Instruction::SDiv: 629254721Semaste case Instruction::UDiv: 630254721Semaste case Instruction::SRem: 631254721Semaste case Instruction::URem: 632254721Semaste case Instruction::Shl: 633254721Semaste case Instruction::LShr: 634254721Semaste case Instruction::AShr: 635254721Semaste case Instruction::And: 636254721Semaste case Instruction::Or: 637254721Semaste case Instruction::Xor: 638254721Semaste { 639254721Semaste const BinaryOperator *bin_op = dyn_cast<BinaryOperator>(inst); 640254721Semaste 641254721Semaste if (!bin_op) 642254721Semaste { 643254721Semaste if (log) 644254721Semaste log->Printf("getOpcode() returns %s, but instruction is not a BinaryOperator", inst->getOpcodeName()); 645254721Semaste error.SetErrorToGenericError(); 646254721Semaste error.SetErrorString(interpreter_internal_error); 647254721Semaste return false; 648254721Semaste } 649254721Semaste 650254721Semaste Value *lhs = inst->getOperand(0); 651254721Semaste Value *rhs = inst->getOperand(1); 652254721Semaste 653254721Semaste lldb_private::Scalar L; 654254721Semaste lldb_private::Scalar R; 655254721Semaste 656254721Semaste if (!frame.EvaluateValue(L, lhs, module)) 657254721Semaste { 658254721Semaste if (log) 659254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(lhs).c_str()); 660254721Semaste error.SetErrorToGenericError(); 661254721Semaste error.SetErrorString(bad_value_error); 662254721Semaste return false; 663254721Semaste } 664254721Semaste 665254721Semaste if (!frame.EvaluateValue(R, rhs, module)) 666254721Semaste { 667254721Semaste if (log) 668254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(rhs).c_str()); 669254721Semaste error.SetErrorToGenericError(); 670254721Semaste error.SetErrorString(bad_value_error); 671254721Semaste return false; 672254721Semaste } 673254721Semaste 674254721Semaste lldb_private::Scalar result; 675254721Semaste 676254721Semaste switch (inst->getOpcode()) 677254721Semaste { 678254721Semaste default: 679254721Semaste break; 680254721Semaste case Instruction::Add: 681254721Semaste result = L + R; 682254721Semaste break; 683254721Semaste case Instruction::Mul: 684254721Semaste result = L * R; 685254721Semaste break; 686254721Semaste case Instruction::Sub: 687254721Semaste result = L - R; 688254721Semaste break; 689254721Semaste case Instruction::SDiv: 690254721Semaste L.MakeSigned(); 691254721Semaste R.MakeSigned(); 692254721Semaste result = L / R; 693254721Semaste break; 694254721Semaste case Instruction::UDiv: 695254721Semaste result = L.GetRawBits64(0) / R.GetRawBits64(1); 696254721Semaste break; 697254721Semaste case Instruction::SRem: 698254721Semaste L.MakeSigned(); 699254721Semaste R.MakeSigned(); 700254721Semaste result = L % R; 701254721Semaste break; 702254721Semaste case Instruction::URem: 703254721Semaste result = L.GetRawBits64(0) % R.GetRawBits64(1); 704254721Semaste break; 705254721Semaste case Instruction::Shl: 706254721Semaste result = L << R; 707254721Semaste break; 708254721Semaste case Instruction::AShr: 709254721Semaste result = L >> R; 710254721Semaste break; 711254721Semaste case Instruction::LShr: 712254721Semaste result = L; 713254721Semaste result.ShiftRightLogical(R); 714254721Semaste break; 715254721Semaste case Instruction::And: 716254721Semaste result = L & R; 717254721Semaste break; 718254721Semaste case Instruction::Or: 719254721Semaste result = L | R; 720254721Semaste break; 721254721Semaste case Instruction::Xor: 722254721Semaste result = L ^ R; 723254721Semaste break; 724254721Semaste } 725254721Semaste 726254721Semaste frame.AssignValue(inst, result, module); 727254721Semaste 728254721Semaste if (log) 729254721Semaste { 730254721Semaste log->Printf("Interpreted a %s", inst->getOpcodeName()); 731254721Semaste log->Printf(" L : %s", frame.SummarizeValue(lhs).c_str()); 732254721Semaste log->Printf(" R : %s", frame.SummarizeValue(rhs).c_str()); 733254721Semaste log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 734254721Semaste } 735254721Semaste } 736254721Semaste break; 737254721Semaste case Instruction::Alloca: 738254721Semaste { 739254721Semaste const AllocaInst *alloca_inst = dyn_cast<AllocaInst>(inst); 740254721Semaste 741254721Semaste if (!alloca_inst) 742254721Semaste { 743254721Semaste if (log) 744254721Semaste log->Printf("getOpcode() returns Alloca, but instruction is not an AllocaInst"); 745254721Semaste error.SetErrorToGenericError(); 746254721Semaste error.SetErrorString(interpreter_internal_error); 747254721Semaste return false; 748254721Semaste } 749254721Semaste 750254721Semaste if (alloca_inst->isArrayAllocation()) 751254721Semaste { 752254721Semaste if (log) 753254721Semaste log->Printf("AllocaInsts are not handled if isArrayAllocation() is true"); 754254721Semaste error.SetErrorToGenericError(); 755254721Semaste error.SetErrorString(unsupported_opcode_error); 756254721Semaste return false; 757254721Semaste } 758254721Semaste 759254721Semaste // The semantics of Alloca are: 760254721Semaste // Create a region R of virtual memory of type T, backed by a data buffer 761254721Semaste // Create a region P of virtual memory of type T*, backed by a data buffer 762254721Semaste // Write the virtual address of R into P 763254721Semaste 764254721Semaste Type *T = alloca_inst->getAllocatedType(); 765254721Semaste Type *Tptr = alloca_inst->getType(); 766254721Semaste 767254721Semaste lldb::addr_t R = frame.Malloc(T); 768254721Semaste 769254721Semaste if (R == LLDB_INVALID_ADDRESS) 770254721Semaste { 771254721Semaste if (log) 772254721Semaste log->Printf("Couldn't allocate memory for an AllocaInst"); 773254721Semaste error.SetErrorToGenericError(); 774254721Semaste error.SetErrorString(memory_allocation_error); 775254721Semaste return false; 776254721Semaste } 777254721Semaste 778254721Semaste lldb::addr_t P = frame.Malloc(Tptr); 779254721Semaste 780254721Semaste if (P == LLDB_INVALID_ADDRESS) 781254721Semaste { 782254721Semaste if (log) 783254721Semaste log->Printf("Couldn't allocate the result pointer for an AllocaInst"); 784254721Semaste error.SetErrorToGenericError(); 785254721Semaste error.SetErrorString(memory_allocation_error); 786254721Semaste return false; 787254721Semaste } 788254721Semaste 789254721Semaste lldb_private::Error write_error; 790254721Semaste 791254721Semaste memory_map.WritePointerToMemory(P, R, write_error); 792254721Semaste 793254721Semaste if (!write_error.Success()) 794254721Semaste { 795254721Semaste if (log) 796254721Semaste log->Printf("Couldn't write the result pointer for an AllocaInst"); 797254721Semaste error.SetErrorToGenericError(); 798254721Semaste error.SetErrorString(memory_write_error); 799254721Semaste lldb_private::Error free_error; 800254721Semaste memory_map.Free(P, free_error); 801254721Semaste memory_map.Free(R, free_error); 802254721Semaste return false; 803254721Semaste } 804254721Semaste 805254721Semaste frame.m_values[alloca_inst] = P; 806254721Semaste 807254721Semaste if (log) 808254721Semaste { 809254721Semaste log->Printf("Interpreted an AllocaInst"); 810254721Semaste log->Printf(" R : 0x%" PRIx64, R); 811254721Semaste log->Printf(" P : 0x%" PRIx64, P); 812254721Semaste } 813254721Semaste } 814254721Semaste break; 815254721Semaste case Instruction::BitCast: 816254721Semaste case Instruction::ZExt: 817254721Semaste { 818254721Semaste const CastInst *cast_inst = dyn_cast<CastInst>(inst); 819254721Semaste 820254721Semaste if (!cast_inst) 821254721Semaste { 822254721Semaste if (log) 823254721Semaste log->Printf("getOpcode() returns %s, but instruction is not a BitCastInst", cast_inst->getOpcodeName()); 824254721Semaste error.SetErrorToGenericError(); 825254721Semaste error.SetErrorString(interpreter_internal_error); 826254721Semaste return false; 827254721Semaste } 828254721Semaste 829254721Semaste Value *source = cast_inst->getOperand(0); 830254721Semaste 831254721Semaste lldb_private::Scalar S; 832254721Semaste 833254721Semaste if (!frame.EvaluateValue(S, source, module)) 834254721Semaste { 835254721Semaste if (log) 836254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(source).c_str()); 837254721Semaste error.SetErrorToGenericError(); 838254721Semaste error.SetErrorString(bad_value_error); 839254721Semaste return false; 840254721Semaste } 841254721Semaste 842254721Semaste frame.AssignValue(inst, S, module); 843254721Semaste } 844254721Semaste break; 845254721Semaste case Instruction::SExt: 846254721Semaste { 847254721Semaste const CastInst *cast_inst = dyn_cast<CastInst>(inst); 848254721Semaste 849254721Semaste if (!cast_inst) 850254721Semaste { 851254721Semaste if (log) 852254721Semaste log->Printf("getOpcode() returns %s, but instruction is not a BitCastInst", cast_inst->getOpcodeName()); 853254721Semaste error.SetErrorToGenericError(); 854254721Semaste error.SetErrorString(interpreter_internal_error); 855254721Semaste return false; 856254721Semaste } 857254721Semaste 858254721Semaste Value *source = cast_inst->getOperand(0); 859254721Semaste 860254721Semaste lldb_private::Scalar S; 861254721Semaste 862254721Semaste if (!frame.EvaluateValue(S, source, module)) 863254721Semaste { 864254721Semaste if (log) 865254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(source).c_str()); 866254721Semaste error.SetErrorToGenericError(); 867254721Semaste error.SetErrorString(bad_value_error); 868254721Semaste return false; 869254721Semaste } 870254721Semaste 871254721Semaste S.MakeSigned(); 872254721Semaste 873254721Semaste lldb_private::Scalar S_signextend(S.SLongLong()); 874254721Semaste 875254721Semaste frame.AssignValue(inst, S_signextend, module); 876254721Semaste } 877254721Semaste break; 878254721Semaste case Instruction::Br: 879254721Semaste { 880254721Semaste const BranchInst *br_inst = dyn_cast<BranchInst>(inst); 881254721Semaste 882254721Semaste if (!br_inst) 883254721Semaste { 884254721Semaste if (log) 885254721Semaste log->Printf("getOpcode() returns Br, but instruction is not a BranchInst"); 886254721Semaste error.SetErrorToGenericError(); 887254721Semaste error.SetErrorString(interpreter_internal_error); 888254721Semaste return false; 889254721Semaste } 890254721Semaste 891254721Semaste if (br_inst->isConditional()) 892254721Semaste { 893254721Semaste Value *condition = br_inst->getCondition(); 894254721Semaste 895254721Semaste lldb_private::Scalar C; 896254721Semaste 897254721Semaste if (!frame.EvaluateValue(C, condition, module)) 898254721Semaste { 899254721Semaste if (log) 900254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(condition).c_str()); 901254721Semaste error.SetErrorToGenericError(); 902254721Semaste error.SetErrorString(bad_value_error); 903254721Semaste return false; 904254721Semaste } 905254721Semaste 906254721Semaste if (C.GetRawBits64(0)) 907254721Semaste frame.Jump(br_inst->getSuccessor(0)); 908254721Semaste else 909254721Semaste frame.Jump(br_inst->getSuccessor(1)); 910254721Semaste 911254721Semaste if (log) 912254721Semaste { 913254721Semaste log->Printf("Interpreted a BrInst with a condition"); 914254721Semaste log->Printf(" cond : %s", frame.SummarizeValue(condition).c_str()); 915254721Semaste } 916254721Semaste } 917254721Semaste else 918254721Semaste { 919254721Semaste frame.Jump(br_inst->getSuccessor(0)); 920254721Semaste 921254721Semaste if (log) 922254721Semaste { 923254721Semaste log->Printf("Interpreted a BrInst with no condition"); 924254721Semaste } 925254721Semaste } 926254721Semaste } 927254721Semaste continue; 928254721Semaste case Instruction::GetElementPtr: 929254721Semaste { 930254721Semaste const GetElementPtrInst *gep_inst = dyn_cast<GetElementPtrInst>(inst); 931254721Semaste 932254721Semaste if (!gep_inst) 933254721Semaste { 934254721Semaste if (log) 935254721Semaste log->Printf("getOpcode() returns GetElementPtr, but instruction is not a GetElementPtrInst"); 936254721Semaste error.SetErrorToGenericError(); 937254721Semaste error.SetErrorString(interpreter_internal_error); 938254721Semaste return false; 939254721Semaste } 940254721Semaste 941254721Semaste const Value *pointer_operand = gep_inst->getPointerOperand(); 942254721Semaste Type *pointer_type = pointer_operand->getType(); 943254721Semaste 944254721Semaste lldb_private::Scalar P; 945254721Semaste 946254721Semaste if (!frame.EvaluateValue(P, pointer_operand, module)) 947254721Semaste { 948254721Semaste if (log) 949254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(pointer_operand).c_str()); 950254721Semaste error.SetErrorToGenericError(); 951254721Semaste error.SetErrorString(bad_value_error); 952254721Semaste return false; 953254721Semaste } 954254721Semaste 955254721Semaste typedef SmallVector <Value *, 8> IndexVector; 956254721Semaste typedef IndexVector::iterator IndexIterator; 957254721Semaste 958254721Semaste SmallVector <Value *, 8> indices (gep_inst->idx_begin(), 959254721Semaste gep_inst->idx_end()); 960254721Semaste 961254721Semaste SmallVector <Value *, 8> const_indices; 962254721Semaste 963254721Semaste for (IndexIterator ii = indices.begin(), ie = indices.end(); 964254721Semaste ii != ie; 965254721Semaste ++ii) 966254721Semaste { 967254721Semaste ConstantInt *constant_index = dyn_cast<ConstantInt>(*ii); 968254721Semaste 969254721Semaste if (!constant_index) 970254721Semaste { 971254721Semaste lldb_private::Scalar I; 972254721Semaste 973254721Semaste if (!frame.EvaluateValue(I, *ii, module)) 974254721Semaste { 975254721Semaste if (log) 976254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(*ii).c_str()); 977254721Semaste error.SetErrorToGenericError(); 978254721Semaste error.SetErrorString(bad_value_error); 979254721Semaste return false; 980254721Semaste } 981254721Semaste 982254721Semaste if (log) 983254721Semaste log->Printf("Evaluated constant index %s as %llu", PrintValue(*ii).c_str(), I.ULongLong(LLDB_INVALID_ADDRESS)); 984254721Semaste 985254721Semaste constant_index = cast<ConstantInt>(ConstantInt::get((*ii)->getType(), I.ULongLong(LLDB_INVALID_ADDRESS))); 986254721Semaste } 987254721Semaste 988254721Semaste const_indices.push_back(constant_index); 989254721Semaste } 990254721Semaste 991254721Semaste uint64_t offset = data_layout.getIndexedOffset(pointer_type, const_indices); 992254721Semaste 993254721Semaste lldb_private::Scalar Poffset = P + offset; 994254721Semaste 995254721Semaste frame.AssignValue(inst, Poffset, module); 996254721Semaste 997254721Semaste if (log) 998254721Semaste { 999254721Semaste log->Printf("Interpreted a GetElementPtrInst"); 1000254721Semaste log->Printf(" P : %s", frame.SummarizeValue(pointer_operand).c_str()); 1001254721Semaste log->Printf(" Poffset : %s", frame.SummarizeValue(inst).c_str()); 1002254721Semaste } 1003254721Semaste } 1004254721Semaste break; 1005254721Semaste case Instruction::ICmp: 1006254721Semaste { 1007254721Semaste const ICmpInst *icmp_inst = dyn_cast<ICmpInst>(inst); 1008254721Semaste 1009254721Semaste if (!icmp_inst) 1010254721Semaste { 1011254721Semaste if (log) 1012254721Semaste log->Printf("getOpcode() returns ICmp, but instruction is not an ICmpInst"); 1013254721Semaste error.SetErrorToGenericError(); 1014254721Semaste error.SetErrorString(interpreter_internal_error); 1015254721Semaste return false; 1016254721Semaste } 1017254721Semaste 1018254721Semaste CmpInst::Predicate predicate = icmp_inst->getPredicate(); 1019254721Semaste 1020254721Semaste Value *lhs = inst->getOperand(0); 1021254721Semaste Value *rhs = inst->getOperand(1); 1022254721Semaste 1023254721Semaste lldb_private::Scalar L; 1024254721Semaste lldb_private::Scalar R; 1025254721Semaste 1026254721Semaste if (!frame.EvaluateValue(L, lhs, module)) 1027254721Semaste { 1028254721Semaste if (log) 1029254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(lhs).c_str()); 1030254721Semaste error.SetErrorToGenericError(); 1031254721Semaste error.SetErrorString(bad_value_error); 1032254721Semaste return false; 1033254721Semaste } 1034254721Semaste 1035254721Semaste if (!frame.EvaluateValue(R, rhs, module)) 1036254721Semaste { 1037254721Semaste if (log) 1038254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(rhs).c_str()); 1039254721Semaste error.SetErrorToGenericError(); 1040254721Semaste error.SetErrorString(bad_value_error); 1041254721Semaste return false; 1042254721Semaste } 1043254721Semaste 1044254721Semaste lldb_private::Scalar result; 1045254721Semaste 1046254721Semaste switch (predicate) 1047254721Semaste { 1048254721Semaste default: 1049254721Semaste return false; 1050254721Semaste case CmpInst::ICMP_EQ: 1051254721Semaste result = (L == R); 1052254721Semaste break; 1053254721Semaste case CmpInst::ICMP_NE: 1054254721Semaste result = (L != R); 1055254721Semaste break; 1056254721Semaste case CmpInst::ICMP_UGT: 1057254721Semaste result = (L.GetRawBits64(0) > R.GetRawBits64(0)); 1058254721Semaste break; 1059254721Semaste case CmpInst::ICMP_UGE: 1060254721Semaste result = (L.GetRawBits64(0) >= R.GetRawBits64(0)); 1061254721Semaste break; 1062254721Semaste case CmpInst::ICMP_ULT: 1063254721Semaste result = (L.GetRawBits64(0) < R.GetRawBits64(0)); 1064254721Semaste break; 1065254721Semaste case CmpInst::ICMP_ULE: 1066254721Semaste result = (L.GetRawBits64(0) <= R.GetRawBits64(0)); 1067254721Semaste break; 1068254721Semaste case CmpInst::ICMP_SGT: 1069254721Semaste L.MakeSigned(); 1070254721Semaste R.MakeSigned(); 1071254721Semaste result = (L > R); 1072254721Semaste break; 1073254721Semaste case CmpInst::ICMP_SGE: 1074254721Semaste L.MakeSigned(); 1075254721Semaste R.MakeSigned(); 1076254721Semaste result = (L >= R); 1077254721Semaste break; 1078254721Semaste case CmpInst::ICMP_SLT: 1079254721Semaste L.MakeSigned(); 1080254721Semaste R.MakeSigned(); 1081254721Semaste result = (L < R); 1082254721Semaste break; 1083254721Semaste case CmpInst::ICMP_SLE: 1084254721Semaste L.MakeSigned(); 1085254721Semaste R.MakeSigned(); 1086254721Semaste result = (L <= R); 1087254721Semaste break; 1088254721Semaste } 1089254721Semaste 1090254721Semaste frame.AssignValue(inst, result, module); 1091254721Semaste 1092254721Semaste if (log) 1093254721Semaste { 1094254721Semaste log->Printf("Interpreted an ICmpInst"); 1095254721Semaste log->Printf(" L : %s", frame.SummarizeValue(lhs).c_str()); 1096254721Semaste log->Printf(" R : %s", frame.SummarizeValue(rhs).c_str()); 1097254721Semaste log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 1098254721Semaste } 1099254721Semaste } 1100254721Semaste break; 1101254721Semaste case Instruction::IntToPtr: 1102254721Semaste { 1103254721Semaste const IntToPtrInst *int_to_ptr_inst = dyn_cast<IntToPtrInst>(inst); 1104254721Semaste 1105254721Semaste if (!int_to_ptr_inst) 1106254721Semaste { 1107254721Semaste if (log) 1108254721Semaste log->Printf("getOpcode() returns IntToPtr, but instruction is not an IntToPtrInst"); 1109254721Semaste error.SetErrorToGenericError(); 1110254721Semaste error.SetErrorString(interpreter_internal_error); 1111254721Semaste return false; 1112254721Semaste } 1113254721Semaste 1114254721Semaste Value *src_operand = int_to_ptr_inst->getOperand(0); 1115254721Semaste 1116254721Semaste lldb_private::Scalar I; 1117254721Semaste 1118254721Semaste if (!frame.EvaluateValue(I, src_operand, module)) 1119254721Semaste { 1120254721Semaste if (log) 1121254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(src_operand).c_str()); 1122254721Semaste error.SetErrorToGenericError(); 1123254721Semaste error.SetErrorString(bad_value_error); 1124254721Semaste return false; 1125254721Semaste } 1126254721Semaste 1127254721Semaste frame.AssignValue(inst, I, module); 1128254721Semaste 1129254721Semaste if (log) 1130254721Semaste { 1131254721Semaste log->Printf("Interpreted an IntToPtr"); 1132254721Semaste log->Printf(" Src : %s", frame.SummarizeValue(src_operand).c_str()); 1133254721Semaste log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 1134254721Semaste } 1135254721Semaste } 1136254721Semaste break; 1137254721Semaste case Instruction::PtrToInt: 1138254721Semaste { 1139254721Semaste const PtrToIntInst *ptr_to_int_inst = dyn_cast<PtrToIntInst>(inst); 1140254721Semaste 1141254721Semaste if (!ptr_to_int_inst) 1142254721Semaste { 1143254721Semaste if (log) 1144254721Semaste log->Printf("getOpcode() returns PtrToInt, but instruction is not an PtrToIntInst"); 1145254721Semaste error.SetErrorToGenericError(); 1146254721Semaste error.SetErrorString(interpreter_internal_error); 1147254721Semaste return false; 1148254721Semaste } 1149254721Semaste 1150254721Semaste Value *src_operand = ptr_to_int_inst->getOperand(0); 1151254721Semaste 1152254721Semaste lldb_private::Scalar I; 1153254721Semaste 1154254721Semaste if (!frame.EvaluateValue(I, src_operand, module)) 1155254721Semaste { 1156254721Semaste if (log) 1157254721Semaste log->Printf("Couldn't evaluate %s", PrintValue(src_operand).c_str()); 1158254721Semaste error.SetErrorToGenericError(); 1159254721Semaste error.SetErrorString(bad_value_error); 1160254721Semaste return false; 1161254721Semaste } 1162254721Semaste 1163254721Semaste frame.AssignValue(inst, I, module); 1164254721Semaste 1165254721Semaste if (log) 1166254721Semaste { 1167254721Semaste log->Printf("Interpreted a PtrToInt"); 1168254721Semaste log->Printf(" Src : %s", frame.SummarizeValue(src_operand).c_str()); 1169254721Semaste log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 1170254721Semaste } 1171254721Semaste } 1172254721Semaste break; 1173263363Semaste case Instruction::Trunc: 1174263363Semaste { 1175263363Semaste const TruncInst *trunc_inst = dyn_cast<TruncInst>(inst); 1176263363Semaste 1177263363Semaste if (!trunc_inst) 1178263363Semaste { 1179263363Semaste if (log) 1180263363Semaste log->Printf("getOpcode() returns Trunc, but instruction is not a TruncInst"); 1181263363Semaste error.SetErrorToGenericError(); 1182263363Semaste error.SetErrorString(interpreter_internal_error); 1183263363Semaste return false; 1184263363Semaste } 1185263363Semaste 1186263363Semaste Value *src_operand = trunc_inst->getOperand(0); 1187263363Semaste 1188263363Semaste lldb_private::Scalar I; 1189263363Semaste 1190263363Semaste if (!frame.EvaluateValue(I, src_operand, module)) 1191263363Semaste { 1192263363Semaste if (log) 1193263363Semaste log->Printf("Couldn't evaluate %s", PrintValue(src_operand).c_str()); 1194263363Semaste error.SetErrorToGenericError(); 1195263363Semaste error.SetErrorString(bad_value_error); 1196263363Semaste return false; 1197263363Semaste } 1198263363Semaste 1199263363Semaste frame.AssignValue(inst, I, module); 1200263363Semaste 1201263363Semaste if (log) 1202263363Semaste { 1203263363Semaste log->Printf("Interpreted a Trunc"); 1204263363Semaste log->Printf(" Src : %s", frame.SummarizeValue(src_operand).c_str()); 1205263363Semaste log->Printf(" = : %s", frame.SummarizeValue(inst).c_str()); 1206263363Semaste } 1207263363Semaste } 1208263363Semaste break; 1209254721Semaste case Instruction::Load: 1210254721Semaste { 1211254721Semaste const LoadInst *load_inst = dyn_cast<LoadInst>(inst); 1212254721Semaste 1213254721Semaste if (!load_inst) 1214254721Semaste { 1215254721Semaste if (log) 1216254721Semaste log->Printf("getOpcode() returns Load, but instruction is not a LoadInst"); 1217254721Semaste error.SetErrorToGenericError(); 1218254721Semaste error.SetErrorString(interpreter_internal_error); 1219254721Semaste return false; 1220254721Semaste } 1221254721Semaste 1222254721Semaste // The semantics of Load are: 1223254721Semaste // Create a region D that will contain the loaded data 1224254721Semaste // Resolve the region P containing a pointer 1225254721Semaste // Dereference P to get the region R that the data should be loaded from 1226254721Semaste // Transfer a unit of type type(D) from R to D 1227254721Semaste 1228254721Semaste const Value *pointer_operand = load_inst->getPointerOperand(); 1229254721Semaste 1230254721Semaste Type *pointer_ty = pointer_operand->getType(); 1231254721Semaste PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty); 1232254721Semaste if (!pointer_ptr_ty) 1233254721Semaste { 1234254721Semaste if (log) 1235254721Semaste log->Printf("getPointerOperand()->getType() is not a PointerType"); 1236254721Semaste error.SetErrorToGenericError(); 1237254721Semaste error.SetErrorString(interpreter_internal_error); 1238254721Semaste return false; 1239254721Semaste } 1240254721Semaste Type *target_ty = pointer_ptr_ty->getElementType(); 1241254721Semaste 1242254721Semaste lldb::addr_t D = frame.ResolveValue(load_inst, module); 1243254721Semaste lldb::addr_t P = frame.ResolveValue(pointer_operand, module); 1244254721Semaste 1245254721Semaste if (D == LLDB_INVALID_ADDRESS) 1246254721Semaste { 1247254721Semaste if (log) 1248254721Semaste log->Printf("LoadInst's value doesn't resolve to anything"); 1249254721Semaste error.SetErrorToGenericError(); 1250254721Semaste error.SetErrorString(bad_value_error); 1251254721Semaste return false; 1252254721Semaste } 1253254721Semaste 1254254721Semaste if (P == LLDB_INVALID_ADDRESS) 1255254721Semaste { 1256254721Semaste if (log) 1257254721Semaste log->Printf("LoadInst's pointer doesn't resolve to anything"); 1258254721Semaste error.SetErrorToGenericError(); 1259254721Semaste error.SetErrorString(bad_value_error); 1260254721Semaste return false; 1261254721Semaste } 1262254721Semaste 1263254721Semaste lldb::addr_t R; 1264254721Semaste lldb_private::Error read_error; 1265254721Semaste memory_map.ReadPointerFromMemory(&R, P, read_error); 1266254721Semaste 1267254721Semaste if (!read_error.Success()) 1268254721Semaste { 1269254721Semaste if (log) 1270254721Semaste log->Printf("Couldn't read the address to be loaded for a LoadInst"); 1271254721Semaste error.SetErrorToGenericError(); 1272254721Semaste error.SetErrorString(memory_read_error); 1273254721Semaste return false; 1274254721Semaste } 1275254721Semaste 1276254721Semaste size_t target_size = data_layout.getTypeStoreSize(target_ty); 1277254721Semaste lldb_private::DataBufferHeap buffer(target_size, 0); 1278254721Semaste 1279254721Semaste read_error.Clear(); 1280254721Semaste memory_map.ReadMemory(buffer.GetBytes(), R, buffer.GetByteSize(), read_error); 1281254721Semaste if (!read_error.Success()) 1282254721Semaste { 1283254721Semaste if (log) 1284254721Semaste log->Printf("Couldn't read from a region on behalf of a LoadInst"); 1285254721Semaste error.SetErrorToGenericError(); 1286254721Semaste error.SetErrorString(memory_read_error); 1287254721Semaste return false; 1288254721Semaste } 1289254721Semaste 1290254721Semaste lldb_private::Error write_error; 1291254721Semaste memory_map.WriteMemory(D, buffer.GetBytes(), buffer.GetByteSize(), write_error); 1292254721Semaste if (!write_error.Success()) 1293254721Semaste { 1294254721Semaste if (log) 1295254721Semaste log->Printf("Couldn't write to a region on behalf of a LoadInst"); 1296254721Semaste error.SetErrorToGenericError(); 1297254721Semaste error.SetErrorString(memory_read_error); 1298254721Semaste return false; 1299254721Semaste } 1300254721Semaste 1301254721Semaste if (log) 1302254721Semaste { 1303254721Semaste log->Printf("Interpreted a LoadInst"); 1304254721Semaste log->Printf(" P : 0x%" PRIx64, P); 1305254721Semaste log->Printf(" R : 0x%" PRIx64, R); 1306254721Semaste log->Printf(" D : 0x%" PRIx64, D); 1307254721Semaste } 1308254721Semaste } 1309254721Semaste break; 1310254721Semaste case Instruction::Ret: 1311254721Semaste { 1312254721Semaste return true; 1313254721Semaste } 1314254721Semaste case Instruction::Store: 1315254721Semaste { 1316254721Semaste const StoreInst *store_inst = dyn_cast<StoreInst>(inst); 1317254721Semaste 1318254721Semaste if (!store_inst) 1319254721Semaste { 1320254721Semaste if (log) 1321254721Semaste log->Printf("getOpcode() returns Store, but instruction is not a StoreInst"); 1322254721Semaste error.SetErrorToGenericError(); 1323254721Semaste error.SetErrorString(interpreter_internal_error); 1324254721Semaste return false; 1325254721Semaste } 1326254721Semaste 1327254721Semaste // The semantics of Store are: 1328254721Semaste // Resolve the region D containing the data to be stored 1329254721Semaste // Resolve the region P containing a pointer 1330254721Semaste // Dereference P to get the region R that the data should be stored in 1331254721Semaste // Transfer a unit of type type(D) from D to R 1332254721Semaste 1333254721Semaste const Value *value_operand = store_inst->getValueOperand(); 1334254721Semaste const Value *pointer_operand = store_inst->getPointerOperand(); 1335254721Semaste 1336254721Semaste Type *pointer_ty = pointer_operand->getType(); 1337254721Semaste PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty); 1338254721Semaste if (!pointer_ptr_ty) 1339254721Semaste return false; 1340254721Semaste Type *target_ty = pointer_ptr_ty->getElementType(); 1341254721Semaste 1342254721Semaste lldb::addr_t D = frame.ResolveValue(value_operand, module); 1343254721Semaste lldb::addr_t P = frame.ResolveValue(pointer_operand, module); 1344254721Semaste 1345254721Semaste if (D == LLDB_INVALID_ADDRESS) 1346254721Semaste { 1347254721Semaste if (log) 1348254721Semaste log->Printf("StoreInst's value doesn't resolve to anything"); 1349254721Semaste error.SetErrorToGenericError(); 1350254721Semaste error.SetErrorString(bad_value_error); 1351254721Semaste return false; 1352254721Semaste } 1353254721Semaste 1354254721Semaste if (P == LLDB_INVALID_ADDRESS) 1355254721Semaste { 1356254721Semaste if (log) 1357254721Semaste log->Printf("StoreInst's pointer doesn't resolve to anything"); 1358254721Semaste error.SetErrorToGenericError(); 1359254721Semaste error.SetErrorString(bad_value_error); 1360254721Semaste return false; 1361254721Semaste } 1362254721Semaste 1363254721Semaste lldb::addr_t R; 1364254721Semaste lldb_private::Error read_error; 1365254721Semaste memory_map.ReadPointerFromMemory(&R, P, read_error); 1366254721Semaste 1367254721Semaste if (!read_error.Success()) 1368254721Semaste { 1369254721Semaste if (log) 1370254721Semaste log->Printf("Couldn't read the address to be loaded for a LoadInst"); 1371254721Semaste error.SetErrorToGenericError(); 1372254721Semaste error.SetErrorString(memory_read_error); 1373254721Semaste return false; 1374254721Semaste } 1375254721Semaste 1376254721Semaste size_t target_size = data_layout.getTypeStoreSize(target_ty); 1377254721Semaste lldb_private::DataBufferHeap buffer(target_size, 0); 1378254721Semaste 1379254721Semaste read_error.Clear(); 1380254721Semaste memory_map.ReadMemory(buffer.GetBytes(), D, buffer.GetByteSize(), read_error); 1381254721Semaste if (!read_error.Success()) 1382254721Semaste { 1383254721Semaste if (log) 1384254721Semaste log->Printf("Couldn't read from a region on behalf of a StoreInst"); 1385254721Semaste error.SetErrorToGenericError(); 1386254721Semaste error.SetErrorString(memory_read_error); 1387254721Semaste return false; 1388254721Semaste } 1389254721Semaste 1390254721Semaste lldb_private::Error write_error; 1391254721Semaste memory_map.WriteMemory(R, buffer.GetBytes(), buffer.GetByteSize(), write_error); 1392254721Semaste if (!write_error.Success()) 1393254721Semaste { 1394254721Semaste if (log) 1395254721Semaste log->Printf("Couldn't write to a region on behalf of a StoreInst"); 1396254721Semaste error.SetErrorToGenericError(); 1397254721Semaste error.SetErrorString(memory_write_error); 1398254721Semaste return false; 1399254721Semaste } 1400254721Semaste 1401254721Semaste if (log) 1402254721Semaste { 1403254721Semaste log->Printf("Interpreted a StoreInst"); 1404254721Semaste log->Printf(" D : 0x%" PRIx64, D); 1405254721Semaste log->Printf(" P : 0x%" PRIx64, P); 1406254721Semaste log->Printf(" R : 0x%" PRIx64, R); 1407254721Semaste } 1408254721Semaste } 1409254721Semaste break; 1410254721Semaste } 1411254721Semaste 1412254721Semaste ++frame.m_ii; 1413254721Semaste } 1414254721Semaste 1415254721Semaste if (num_insts >= 4096) 1416254721Semaste { 1417254721Semaste error.SetErrorToGenericError(); 1418254721Semaste error.SetErrorString(infinite_loop_error); 1419254721Semaste return false; 1420254721Semaste } 1421254721Semaste 1422254721Semaste return false; 1423254721Semaste} 1424