contrib/llvm/tools/lldb/source/Expression/IRInterpreter.cpp

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