1 //===-- Disassembler.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/lldb-python.h" 11 12 #include "lldb/Core/Disassembler.h" 13 14 // C Includes 15 // C++ Includes 16 // Other libraries and framework includes 17 // Project includes 18 #include "lldb/lldb-private.h" 19 #include "lldb/Core/Error.h" 20 #include "lldb/Core/DataBufferHeap.h" 21 #include "lldb/Core/DataExtractor.h" 22 #include "lldb/Core/Debugger.h" 23 #include "lldb/Core/EmulateInstruction.h" 24 #include "lldb/Core/Module.h" 25 #include "lldb/Core/PluginManager.h" 26 #include "lldb/Core/RegularExpression.h" 27 #include "lldb/Core/Timer.h" 28 #include "lldb/Interpreter/OptionValue.h" 29 #include "lldb/Interpreter/OptionValueArray.h" 30 #include "lldb/Interpreter/OptionValueDictionary.h" 31 #include "lldb/Interpreter/OptionValueString.h" 32 #include "lldb/Interpreter/OptionValueUInt64.h" 33 #include "lldb/Symbol/ClangNamespaceDecl.h" 34 #include "lldb/Symbol/Function.h" 35 #include "lldb/Symbol/ObjectFile.h" 36 #include "lldb/Target/ExecutionContext.h" 37 #include "lldb/Target/Process.h" 38 #include "lldb/Target/StackFrame.h" 39 #include "lldb/Target/Target.h" 40 41 #define DEFAULT_DISASM_BYTE_SIZE 32 42 43 using namespace lldb; 44 using namespace lldb_private; 45 46 47 DisassemblerSP 48 Disassembler::FindPlugin (const ArchSpec &arch, const char *flavor, const char *plugin_name) 49 { 50 Timer scoped_timer (__PRETTY_FUNCTION__, 51 "Disassembler::FindPlugin (arch = %s, plugin_name = %s)", 52 arch.GetArchitectureName(), 53 plugin_name); 54 55 DisassemblerCreateInstance create_callback = NULL; 56 57 if (plugin_name) 58 { 59 ConstString const_plugin_name (plugin_name); 60 create_callback = PluginManager::GetDisassemblerCreateCallbackForPluginName (const_plugin_name); 61 if (create_callback) 62 { 63 DisassemblerSP disassembler_sp(create_callback(arch, flavor)); 64 65 if (disassembler_sp.get()) 66 return disassembler_sp; 67 } 68 } 69 else 70 { 71 for (uint32_t idx = 0; (create_callback = PluginManager::GetDisassemblerCreateCallbackAtIndex(idx)) != NULL; ++idx) 72 { 73 DisassemblerSP disassembler_sp(create_callback(arch, flavor)); 74 75 if (disassembler_sp.get()) 76 return disassembler_sp; 77 } 78 } 79 return DisassemblerSP(); 80 } 81 82 DisassemblerSP 83 Disassembler::FindPluginForTarget(const TargetSP target_sp, const ArchSpec &arch, const char *flavor, const char *plugin_name) 84 { 85 if (target_sp && flavor == NULL) 86 { 87 // FIXME - we don't have the mechanism in place to do per-architecture settings. But since we know that for now 88 // we only support flavors on x86 & x86_64, 89 if (arch.GetTriple().getArch() == llvm::Triple::x86 90 || arch.GetTriple().getArch() == llvm::Triple::x86_64) 91 flavor = target_sp->GetDisassemblyFlavor(); 92 } 93 return FindPlugin(arch, flavor, plugin_name); 94 } 95 96 97 static void 98 ResolveAddress (const ExecutionContext &exe_ctx, 99 const Address &addr, 100 Address &resolved_addr) 101 { 102 if (!addr.IsSectionOffset()) 103 { 104 // If we weren't passed in a section offset address range, 105 // try and resolve it to something 106 Target *target = exe_ctx.GetTargetPtr(); 107 if (target) 108 { 109 if (target->GetSectionLoadList().IsEmpty()) 110 { 111 target->GetImages().ResolveFileAddress (addr.GetOffset(), resolved_addr); 112 } 113 else 114 { 115 target->GetSectionLoadList().ResolveLoadAddress (addr.GetOffset(), resolved_addr); 116 } 117 // We weren't able to resolve the address, just treat it as a 118 // raw address 119 if (resolved_addr.IsValid()) 120 return; 121 } 122 } 123 resolved_addr = addr; 124 } 125 126 size_t 127 Disassembler::Disassemble 128 ( 129 Debugger &debugger, 130 const ArchSpec &arch, 131 const char *plugin_name, 132 const char *flavor, 133 const ExecutionContext &exe_ctx, 134 SymbolContextList &sc_list, 135 uint32_t num_instructions, 136 uint32_t num_mixed_context_lines, 137 uint32_t options, 138 Stream &strm 139 ) 140 { 141 size_t success_count = 0; 142 const size_t count = sc_list.GetSize(); 143 SymbolContext sc; 144 AddressRange range; 145 const uint32_t scope = eSymbolContextBlock | eSymbolContextFunction | eSymbolContextSymbol; 146 const bool use_inline_block_range = true; 147 for (size_t i=0; i<count; ++i) 148 { 149 if (sc_list.GetContextAtIndex(i, sc) == false) 150 break; 151 for (uint32_t range_idx = 0; sc.GetAddressRange(scope, range_idx, use_inline_block_range, range); ++range_idx) 152 { 153 if (Disassemble (debugger, 154 arch, 155 plugin_name, 156 flavor, 157 exe_ctx, 158 range, 159 num_instructions, 160 num_mixed_context_lines, 161 options, 162 strm)) 163 { 164 ++success_count; 165 strm.EOL(); 166 } 167 } 168 } 169 return success_count; 170 } 171 172 bool 173 Disassembler::Disassemble 174 ( 175 Debugger &debugger, 176 const ArchSpec &arch, 177 const char *plugin_name, 178 const char *flavor, 179 const ExecutionContext &exe_ctx, 180 const ConstString &name, 181 Module *module, 182 uint32_t num_instructions, 183 uint32_t num_mixed_context_lines, 184 uint32_t options, 185 Stream &strm 186 ) 187 { 188 SymbolContextList sc_list; 189 if (name) 190 { 191 const bool include_symbols = true; 192 const bool include_inlines = true; 193 if (module) 194 { 195 module->FindFunctions (name, 196 NULL, 197 eFunctionNameTypeAuto, 198 include_symbols, 199 include_inlines, 200 true, 201 sc_list); 202 } 203 else if (exe_ctx.GetTargetPtr()) 204 { 205 exe_ctx.GetTargetPtr()->GetImages().FindFunctions (name, 206 eFunctionNameTypeAuto, 207 include_symbols, 208 include_inlines, 209 false, 210 sc_list); 211 } 212 } 213 214 if (sc_list.GetSize ()) 215 { 216 return Disassemble (debugger, 217 arch, 218 plugin_name, 219 flavor, 220 exe_ctx, 221 sc_list, 222 num_instructions, 223 num_mixed_context_lines, 224 options, 225 strm); 226 } 227 return false; 228 } 229 230 231 lldb::DisassemblerSP 232 Disassembler::DisassembleRange 233 ( 234 const ArchSpec &arch, 235 const char *plugin_name, 236 const char *flavor, 237 const ExecutionContext &exe_ctx, 238 const AddressRange &range 239 ) 240 { 241 lldb::DisassemblerSP disasm_sp; 242 if (range.GetByteSize() > 0 && range.GetBaseAddress().IsValid()) 243 { 244 disasm_sp = Disassembler::FindPluginForTarget(exe_ctx.GetTargetSP(), arch, flavor, plugin_name); 245 246 if (disasm_sp) 247 { 248 const bool prefer_file_cache = false; 249 size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx, range, NULL, prefer_file_cache); 250 if (bytes_disassembled == 0) 251 disasm_sp.reset(); 252 } 253 } 254 return disasm_sp; 255 } 256 257 lldb::DisassemblerSP 258 Disassembler::DisassembleBytes (const ArchSpec &arch, 259 const char *plugin_name, 260 const char *flavor, 261 const Address &start, 262 const void *src, 263 size_t src_len, 264 uint32_t num_instructions, 265 bool data_from_file) 266 { 267 lldb::DisassemblerSP disasm_sp; 268 269 if (src) 270 { 271 disasm_sp = Disassembler::FindPlugin(arch, flavor, plugin_name); 272 273 if (disasm_sp) 274 { 275 DataExtractor data(src, src_len, arch.GetByteOrder(), arch.GetAddressByteSize()); 276 277 (void)disasm_sp->DecodeInstructions (start, 278 data, 279 0, 280 num_instructions, 281 false, 282 data_from_file); 283 } 284 } 285 286 return disasm_sp; 287 } 288 289 290 bool 291 Disassembler::Disassemble 292 ( 293 Debugger &debugger, 294 const ArchSpec &arch, 295 const char *plugin_name, 296 const char *flavor, 297 const ExecutionContext &exe_ctx, 298 const AddressRange &disasm_range, 299 uint32_t num_instructions, 300 uint32_t num_mixed_context_lines, 301 uint32_t options, 302 Stream &strm 303 ) 304 { 305 if (disasm_range.GetByteSize()) 306 { 307 lldb::DisassemblerSP disasm_sp (Disassembler::FindPluginForTarget(exe_ctx.GetTargetSP(), arch, flavor, plugin_name)); 308 309 if (disasm_sp.get()) 310 { 311 AddressRange range; 312 ResolveAddress (exe_ctx, disasm_range.GetBaseAddress(), range.GetBaseAddress()); 313 range.SetByteSize (disasm_range.GetByteSize()); 314 const bool prefer_file_cache = false; 315 size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx, range, &strm, prefer_file_cache); 316 if (bytes_disassembled == 0) 317 return false; 318 319 bool result = PrintInstructions (disasm_sp.get(), 320 debugger, 321 arch, 322 exe_ctx, 323 num_instructions, 324 num_mixed_context_lines, 325 options, 326 strm); 327 328 // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions. 329 // I'll fix that but for now, just clear the list and it will go away nicely. 330 disasm_sp->GetInstructionList().Clear(); 331 return result; 332 } 333 } 334 return false; 335 } 336 337 bool 338 Disassembler::Disassemble 339 ( 340 Debugger &debugger, 341 const ArchSpec &arch, 342 const char *plugin_name, 343 const char *flavor, 344 const ExecutionContext &exe_ctx, 345 const Address &start_address, 346 uint32_t num_instructions, 347 uint32_t num_mixed_context_lines, 348 uint32_t options, 349 Stream &strm 350 ) 351 { 352 if (num_instructions > 0) 353 { 354 lldb::DisassemblerSP disasm_sp (Disassembler::FindPluginForTarget(exe_ctx.GetTargetSP(), 355 arch, 356 flavor, 357 plugin_name)); 358 if (disasm_sp.get()) 359 { 360 Address addr; 361 ResolveAddress (exe_ctx, start_address, addr); 362 const bool prefer_file_cache = false; 363 size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx, 364 addr, 365 num_instructions, 366 prefer_file_cache); 367 if (bytes_disassembled == 0) 368 return false; 369 bool result = PrintInstructions (disasm_sp.get(), 370 debugger, 371 arch, 372 exe_ctx, 373 num_instructions, 374 num_mixed_context_lines, 375 options, 376 strm); 377 378 // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions. 379 // I'll fix that but for now, just clear the list and it will go away nicely. 380 disasm_sp->GetInstructionList().Clear(); 381 return result; 382 } 383 } 384 return false; 385 } 386 387 bool 388 Disassembler::PrintInstructions 389 ( 390 Disassembler *disasm_ptr, 391 Debugger &debugger, 392 const ArchSpec &arch, 393 const ExecutionContext &exe_ctx, 394 uint32_t num_instructions, 395 uint32_t num_mixed_context_lines, 396 uint32_t options, 397 Stream &strm 398 ) 399 { 400 // We got some things disassembled... 401 size_t num_instructions_found = disasm_ptr->GetInstructionList().GetSize(); 402 403 if (num_instructions > 0 && num_instructions < num_instructions_found) 404 num_instructions_found = num_instructions; 405 406 const uint32_t max_opcode_byte_size = disasm_ptr->GetInstructionList().GetMaxOpcocdeByteSize (); 407 uint32_t offset = 0; 408 SymbolContext sc; 409 SymbolContext prev_sc; 410 AddressRange sc_range; 411 const Address *pc_addr_ptr = NULL; 412 ExecutionContextScope *exe_scope = exe_ctx.GetBestExecutionContextScope(); 413 StackFrame *frame = exe_ctx.GetFramePtr(); 414 415 TargetSP target_sp (exe_ctx.GetTargetSP()); 416 SourceManager &source_manager = target_sp ? target_sp->GetSourceManager() : debugger.GetSourceManager(); 417 418 if (frame) 419 pc_addr_ptr = &frame->GetFrameCodeAddress(); 420 const uint32_t scope = eSymbolContextLineEntry | eSymbolContextFunction | eSymbolContextSymbol; 421 const bool use_inline_block_range = false; 422 for (size_t i=0; i<num_instructions_found; ++i) 423 { 424 Instruction *inst = disasm_ptr->GetInstructionList().GetInstructionAtIndex (i).get(); 425 if (inst) 426 { 427 const Address &addr = inst->GetAddress(); 428 const bool inst_is_at_pc = pc_addr_ptr && addr == *pc_addr_ptr; 429 430 prev_sc = sc; 431 432 ModuleSP module_sp (addr.GetModule()); 433 if (module_sp) 434 { 435 uint32_t resolved_mask = module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything, sc); 436 if (resolved_mask) 437 { 438 if (num_mixed_context_lines) 439 { 440 if (!sc_range.ContainsFileAddress (addr)) 441 { 442 sc.GetAddressRange (scope, 0, use_inline_block_range, sc_range); 443 444 if (sc != prev_sc) 445 { 446 if (offset != 0) 447 strm.EOL(); 448 449 sc.DumpStopContext(&strm, exe_ctx.GetProcessPtr(), addr, false, true, false); 450 strm.EOL(); 451 452 if (sc.comp_unit && sc.line_entry.IsValid()) 453 { 454 source_manager.DisplaySourceLinesWithLineNumbers (sc.line_entry.file, 455 sc.line_entry.line, 456 num_mixed_context_lines, 457 num_mixed_context_lines, 458 ((inst_is_at_pc && (options & eOptionMarkPCSourceLine)) ? "->" : ""), 459 &strm); 460 } 461 } 462 } 463 } 464 else if ((sc.function || sc.symbol) && (sc.function != prev_sc.function || sc.symbol != prev_sc.symbol)) 465 { 466 if (prev_sc.function || prev_sc.symbol) 467 strm.EOL(); 468 469 bool show_fullpaths = false; 470 bool show_module = true; 471 bool show_inlined_frames = true; 472 sc.DumpStopContext (&strm, 473 exe_scope, 474 addr, 475 show_fullpaths, 476 show_module, 477 show_inlined_frames); 478 479 strm << ":\n"; 480 } 481 } 482 else 483 { 484 sc.Clear(true); 485 } 486 } 487 488 if ((options & eOptionMarkPCAddress) && pc_addr_ptr) 489 { 490 strm.PutCString(inst_is_at_pc ? "-> " : " "); 491 } 492 const bool show_bytes = (options & eOptionShowBytes) != 0; 493 inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx); 494 strm.EOL(); 495 } 496 else 497 { 498 break; 499 } 500 } 501 502 return true; 503 } 504 505 506 bool 507 Disassembler::Disassemble 508 ( 509 Debugger &debugger, 510 const ArchSpec &arch, 511 const char *plugin_name, 512 const char *flavor, 513 const ExecutionContext &exe_ctx, 514 uint32_t num_instructions, 515 uint32_t num_mixed_context_lines, 516 uint32_t options, 517 Stream &strm 518 ) 519 { 520 AddressRange range; 521 StackFrame *frame = exe_ctx.GetFramePtr(); 522 if (frame) 523 { 524 SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); 525 if (sc.function) 526 { 527 range = sc.function->GetAddressRange(); 528 } 529 else if (sc.symbol && sc.symbol->ValueIsAddress()) 530 { 531 range.GetBaseAddress() = sc.symbol->GetAddress(); 532 range.SetByteSize (sc.symbol->GetByteSize()); 533 } 534 else 535 { 536 range.GetBaseAddress() = frame->GetFrameCodeAddress(); 537 } 538 539 if (range.GetBaseAddress().IsValid() && range.GetByteSize() == 0) 540 range.SetByteSize (DEFAULT_DISASM_BYTE_SIZE); 541 } 542 543 return Disassemble (debugger, 544 arch, 545 plugin_name, 546 flavor, 547 exe_ctx, 548 range, 549 num_instructions, 550 num_mixed_context_lines, 551 options, 552 strm); 553 } 554 555 Instruction::Instruction(const Address &address, AddressClass addr_class) : 556 m_address (address), 557 m_address_class (addr_class), 558 m_opcode(), 559 m_calculated_strings(false) 560 { 561 } 562 563 Instruction::~Instruction() 564 { 565 } 566 567 AddressClass 568 Instruction::GetAddressClass () 569 { 570 if (m_address_class == eAddressClassInvalid) 571 m_address_class = m_address.GetAddressClass(); 572 return m_address_class; 573 } 574 575 void 576 Instruction::Dump (lldb_private::Stream *s, 577 uint32_t max_opcode_byte_size, 578 bool show_address, 579 bool show_bytes, 580 const ExecutionContext* exe_ctx) 581 { 582 size_t opcode_column_width = 7; 583 const size_t operand_column_width = 25; 584 585 CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx); 586 587 StreamString ss; 588 589 if (show_address) 590 { 591 m_address.Dump(&ss, 592 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL, 593 Address::DumpStyleLoadAddress, 594 Address::DumpStyleModuleWithFileAddress, 595 0); 596 597 ss.PutCString(": "); 598 } 599 600 if (show_bytes) 601 { 602 if (m_opcode.GetType() == Opcode::eTypeBytes) 603 { 604 // x86_64 and i386 are the only ones that use bytes right now so 605 // pad out the byte dump to be able to always show 15 bytes (3 chars each) 606 // plus a space 607 if (max_opcode_byte_size > 0) 608 m_opcode.Dump (&ss, max_opcode_byte_size * 3 + 1); 609 else 610 m_opcode.Dump (&ss, 15 * 3 + 1); 611 } 612 else 613 { 614 // Else, we have ARM which can show up to a uint32_t 0x00000000 (10 spaces) 615 // plus two for padding... 616 if (max_opcode_byte_size > 0) 617 m_opcode.Dump (&ss, max_opcode_byte_size * 3 + 1); 618 else 619 m_opcode.Dump (&ss, 12); 620 } 621 } 622 623 const size_t opcode_pos = ss.GetSize(); 624 625 // The default opcode size of 7 characters is plenty for most architectures 626 // but some like arm can pull out the occasional vqrshrun.s16. We won't get 627 // consistent column spacing in these cases, unfortunately. 628 if (m_opcode_name.length() >= opcode_column_width) 629 { 630 opcode_column_width = m_opcode_name.length() + 1; 631 } 632 633 ss.PutCString (m_opcode_name.c_str()); 634 ss.FillLastLineToColumn (opcode_pos + opcode_column_width, ' '); 635 ss.PutCString (m_mnemonics.c_str()); 636 637 if (!m_comment.empty()) 638 { 639 ss.FillLastLineToColumn (opcode_pos + opcode_column_width + operand_column_width, ' '); 640 ss.PutCString (" ; "); 641 ss.PutCString (m_comment.c_str()); 642 } 643 s->Write (ss.GetData(), ss.GetSize()); 644 } 645 646 bool 647 Instruction::DumpEmulation (const ArchSpec &arch) 648 { 649 std::unique_ptr<EmulateInstruction> insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL)); 650 if (insn_emulator_ap.get()) 651 { 652 insn_emulator_ap->SetInstruction (GetOpcode(), GetAddress(), NULL); 653 return insn_emulator_ap->EvaluateInstruction (0); 654 } 655 656 return false; 657 } 658 659 OptionValueSP 660 Instruction::ReadArray (FILE *in_file, Stream *out_stream, OptionValue::Type data_type) 661 { 662 bool done = false; 663 char buffer[1024]; 664 665 OptionValueSP option_value_sp (new OptionValueArray (1u << data_type)); 666 667 int idx = 0; 668 while (!done) 669 { 670 if (!fgets (buffer, 1023, in_file)) 671 { 672 out_stream->Printf ("Instruction::ReadArray: Error reading file (fgets).\n"); 673 option_value_sp.reset (); 674 return option_value_sp; 675 } 676 677 std::string line (buffer); 678 679 size_t len = line.size(); 680 if (line[len-1] == '\n') 681 { 682 line[len-1] = '\0'; 683 line.resize (len-1); 684 } 685 686 if ((line.size() == 1) && line[0] == ']') 687 { 688 done = true; 689 line.clear(); 690 } 691 692 if (line.size() > 0) 693 { 694 std::string value; 695 static RegularExpression g_reg_exp ("^[ \t]*([^ \t]+)[ \t]*$"); 696 RegularExpression::Match regex_match(1); 697 bool reg_exp_success = g_reg_exp.Execute (line.c_str(), ®ex_match); 698 if (reg_exp_success) 699 regex_match.GetMatchAtIndex (line.c_str(), 1, value); 700 else 701 value = line; 702 703 OptionValueSP data_value_sp; 704 switch (data_type) 705 { 706 case OptionValue::eTypeUInt64: 707 data_value_sp.reset (new OptionValueUInt64 (0, 0)); 708 data_value_sp->SetValueFromCString (value.c_str()); 709 break; 710 // Other types can be added later as needed. 711 default: 712 data_value_sp.reset (new OptionValueString (value.c_str(), "")); 713 break; 714 } 715 716 option_value_sp->GetAsArray()->InsertValue (idx, data_value_sp); 717 ++idx; 718 } 719 } 720 721 return option_value_sp; 722 } 723 724 OptionValueSP 725 Instruction::ReadDictionary (FILE *in_file, Stream *out_stream) 726 { 727 bool done = false; 728 char buffer[1024]; 729 730 OptionValueSP option_value_sp (new OptionValueDictionary()); 731 static ConstString encoding_key ("data_encoding"); 732 OptionValue::Type data_type = OptionValue::eTypeInvalid; 733 734 735 while (!done) 736 { 737 // Read the next line in the file 738 if (!fgets (buffer, 1023, in_file)) 739 { 740 out_stream->Printf ("Instruction::ReadDictionary: Error reading file (fgets).\n"); 741 option_value_sp.reset (); 742 return option_value_sp; 743 } 744 745 // Check to see if the line contains the end-of-dictionary marker ("}") 746 std::string line (buffer); 747 748 size_t len = line.size(); 749 if (line[len-1] == '\n') 750 { 751 line[len-1] = '\0'; 752 line.resize (len-1); 753 } 754 755 if ((line.size() == 1) && (line[0] == '}')) 756 { 757 done = true; 758 line.clear(); 759 } 760 761 // Try to find a key-value pair in the current line and add it to the dictionary. 762 if (line.size() > 0) 763 { 764 static RegularExpression g_reg_exp ("^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*=[ \t]*(.*)[ \t]*$"); 765 RegularExpression::Match regex_match(2); 766 767 bool reg_exp_success = g_reg_exp.Execute (line.c_str(), ®ex_match); 768 std::string key; 769 std::string value; 770 if (reg_exp_success) 771 { 772 regex_match.GetMatchAtIndex (line.c_str(), 1, key); 773 regex_match.GetMatchAtIndex (line.c_str(), 2, value); 774 } 775 else 776 { 777 out_stream->Printf ("Instruction::ReadDictionary: Failure executing regular expression.\n"); 778 option_value_sp.reset(); 779 return option_value_sp; 780 } 781 782 ConstString const_key (key.c_str()); 783 // Check value to see if it's the start of an array or dictionary. 784 785 lldb::OptionValueSP value_sp; 786 assert (value.empty() == false); 787 assert (key.empty() == false); 788 789 if (value[0] == '{') 790 { 791 assert (value.size() == 1); 792 // value is a dictionary 793 value_sp = ReadDictionary (in_file, out_stream); 794 if (value_sp.get() == NULL) 795 { 796 option_value_sp.reset (); 797 return option_value_sp; 798 } 799 } 800 else if (value[0] == '[') 801 { 802 assert (value.size() == 1); 803 // value is an array 804 value_sp = ReadArray (in_file, out_stream, data_type); 805 if (value_sp.get() == NULL) 806 { 807 option_value_sp.reset (); 808 return option_value_sp; 809 } 810 // We've used the data_type to read an array; re-set the type to Invalid 811 data_type = OptionValue::eTypeInvalid; 812 } 813 else if ((value[0] == '0') && (value[1] == 'x')) 814 { 815 value_sp.reset (new OptionValueUInt64 (0, 0)); 816 value_sp->SetValueFromCString (value.c_str()); 817 } 818 else 819 { 820 size_t len = value.size(); 821 if ((value[0] == '"') && (value[len-1] == '"')) 822 value = value.substr (1, len-2); 823 value_sp.reset (new OptionValueString (value.c_str(), "")); 824 } 825 826 827 828 if (const_key == encoding_key) 829 { 830 // A 'data_encoding=..." is NOT a normal key-value pair; it is meta-data indicating the 831 // data type of an upcoming array (usually the next bit of data to be read in). 832 if (strcmp (value.c_str(), "uint32_t") == 0) 833 data_type = OptionValue::eTypeUInt64; 834 } 835 else 836 option_value_sp->GetAsDictionary()->SetValueForKey (const_key, value_sp, false); 837 } 838 } 839 840 return option_value_sp; 841 } 842 843 bool 844 Instruction::TestEmulation (Stream *out_stream, const char *file_name) 845 { 846 if (!out_stream) 847 return false; 848 849 if (!file_name) 850 { 851 out_stream->Printf ("Instruction::TestEmulation: Missing file_name."); 852 return false; 853 } 854 855 FILE *test_file = fopen (file_name, "r"); 856 if (!test_file) 857 { 858 out_stream->Printf ("Instruction::TestEmulation: Attempt to open test file failed."); 859 return false; 860 } 861 862 char buffer[256]; 863 if (!fgets (buffer, 255, test_file)) 864 { 865 out_stream->Printf ("Instruction::TestEmulation: Error reading first line of test file.\n"); 866 fclose (test_file); 867 return false; 868 } 869 870 if (strncmp (buffer, "InstructionEmulationState={", 27) != 0) 871 { 872 out_stream->Printf ("Instructin::TestEmulation: Test file does not contain emulation state dictionary\n"); 873 fclose (test_file); 874 return false; 875 } 876 877 // Read all the test information from the test file into an OptionValueDictionary. 878 879 OptionValueSP data_dictionary_sp (ReadDictionary (test_file, out_stream)); 880 if (data_dictionary_sp.get() == NULL) 881 { 882 out_stream->Printf ("Instruction::TestEmulation: Error reading Dictionary Object.\n"); 883 fclose (test_file); 884 return false; 885 } 886 887 fclose (test_file); 888 889 OptionValueDictionary *data_dictionary = data_dictionary_sp->GetAsDictionary(); 890 static ConstString description_key ("assembly_string"); 891 static ConstString triple_key ("triple"); 892 893 OptionValueSP value_sp = data_dictionary->GetValueForKey (description_key); 894 895 if (value_sp.get() == NULL) 896 { 897 out_stream->Printf ("Instruction::TestEmulation: Test file does not contain description string.\n"); 898 return false; 899 } 900 901 SetDescription (value_sp->GetStringValue()); 902 903 904 value_sp = data_dictionary->GetValueForKey (triple_key); 905 if (value_sp.get() == NULL) 906 { 907 out_stream->Printf ("Instruction::TestEmulation: Test file does not contain triple.\n"); 908 return false; 909 } 910 911 ArchSpec arch; 912 arch.SetTriple (llvm::Triple (value_sp->GetStringValue())); 913 914 bool success = false; 915 std::unique_ptr<EmulateInstruction> insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL)); 916 if (insn_emulator_ap.get()) 917 success = insn_emulator_ap->TestEmulation (out_stream, arch, data_dictionary); 918 919 if (success) 920 out_stream->Printf ("Emulation test succeeded."); 921 else 922 out_stream->Printf ("Emulation test failed."); 923 924 return success; 925 } 926 927 bool 928 Instruction::Emulate (const ArchSpec &arch, 929 uint32_t evaluate_options, 930 void *baton, 931 EmulateInstruction::ReadMemoryCallback read_mem_callback, 932 EmulateInstruction::WriteMemoryCallback write_mem_callback, 933 EmulateInstruction::ReadRegisterCallback read_reg_callback, 934 EmulateInstruction::WriteRegisterCallback write_reg_callback) 935 { 936 std::unique_ptr<EmulateInstruction> insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL)); 937 if (insn_emulator_ap.get()) 938 { 939 insn_emulator_ap->SetBaton (baton); 940 insn_emulator_ap->SetCallbacks (read_mem_callback, write_mem_callback, read_reg_callback, write_reg_callback); 941 insn_emulator_ap->SetInstruction (GetOpcode(), GetAddress(), NULL); 942 return insn_emulator_ap->EvaluateInstruction (evaluate_options); 943 } 944 945 return false; 946 } 947 948 949 uint32_t 950 Instruction::GetData (DataExtractor &data) 951 { 952 return m_opcode.GetData(data); 953 } 954 955 InstructionList::InstructionList() : 956 m_instructions() 957 { 958 } 959 960 InstructionList::~InstructionList() 961 { 962 } 963 964 size_t 965 InstructionList::GetSize() const 966 { 967 return m_instructions.size(); 968 } 969 970 uint32_t 971 InstructionList::GetMaxOpcocdeByteSize () const 972 { 973 uint32_t max_inst_size = 0; 974 collection::const_iterator pos, end; 975 for (pos = m_instructions.begin(), end = m_instructions.end(); 976 pos != end; 977 ++pos) 978 { 979 uint32_t inst_size = (*pos)->GetOpcode().GetByteSize(); 980 if (max_inst_size < inst_size) 981 max_inst_size = inst_size; 982 } 983 return max_inst_size; 984 } 985 986 987 988 InstructionSP 989 InstructionList::GetInstructionAtIndex (size_t idx) const 990 { 991 InstructionSP inst_sp; 992 if (idx < m_instructions.size()) 993 inst_sp = m_instructions[idx]; 994 return inst_sp; 995 } 996 997 void 998 InstructionList::Dump (Stream *s, 999 bool show_address, 1000 bool show_bytes, 1001 const ExecutionContext* exe_ctx) 1002 { 1003 const uint32_t max_opcode_byte_size = GetMaxOpcocdeByteSize(); 1004 collection::const_iterator pos, begin, end; 1005 for (begin = m_instructions.begin(), end = m_instructions.end(), pos = begin; 1006 pos != end; 1007 ++pos) 1008 { 1009 if (pos != begin) 1010 s->EOL(); 1011 (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx); 1012 } 1013 } 1014 1015 1016 void 1017 InstructionList::Clear() 1018 { 1019 m_instructions.clear(); 1020 } 1021 1022 void 1023 InstructionList::Append (lldb::InstructionSP &inst_sp) 1024 { 1025 if (inst_sp) 1026 m_instructions.push_back(inst_sp); 1027 } 1028 1029 uint32_t 1030 InstructionList::GetIndexOfNextBranchInstruction(uint32_t start) const 1031 { 1032 size_t num_instructions = m_instructions.size(); 1033 1034 uint32_t next_branch = UINT32_MAX; 1035 for (size_t i = start; i < num_instructions; i++) 1036 { 1037 if (m_instructions[i]->DoesBranch()) 1038 { 1039 next_branch = i; 1040 break; 1041 } 1042 } 1043 return next_branch; 1044 } 1045 1046 uint32_t 1047 InstructionList::GetIndexOfInstructionAtLoadAddress (lldb::addr_t load_addr, Target &target) 1048 { 1049 Address address; 1050 address.SetLoadAddress(load_addr, &target); 1051 size_t num_instructions = m_instructions.size(); 1052 uint32_t index = UINT32_MAX; 1053 for (size_t i = 0; i < num_instructions; i++) 1054 { 1055 if (m_instructions[i]->GetAddress() == address) 1056 { 1057 index = i; 1058 break; 1059 } 1060 } 1061 return index; 1062 } 1063 1064 size_t 1065 Disassembler::ParseInstructions (const ExecutionContext *exe_ctx, 1066 const AddressRange &range, 1067 Stream *error_strm_ptr, 1068 bool prefer_file_cache) 1069 { 1070 if (exe_ctx) 1071 { 1072 Target *target = exe_ctx->GetTargetPtr(); 1073 const addr_t byte_size = range.GetByteSize(); 1074 if (target == NULL || byte_size == 0 || !range.GetBaseAddress().IsValid()) 1075 return 0; 1076 1077 DataBufferHeap *heap_buffer = new DataBufferHeap (byte_size, '\0'); 1078 DataBufferSP data_sp(heap_buffer); 1079 1080 Error error; 1081 lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; 1082 const size_t bytes_read = target->ReadMemory (range.GetBaseAddress(), 1083 prefer_file_cache, 1084 heap_buffer->GetBytes(), 1085 heap_buffer->GetByteSize(), 1086 error, 1087 &load_addr); 1088 1089 if (bytes_read > 0) 1090 { 1091 if (bytes_read != heap_buffer->GetByteSize()) 1092 heap_buffer->SetByteSize (bytes_read); 1093 DataExtractor data (data_sp, 1094 m_arch.GetByteOrder(), 1095 m_arch.GetAddressByteSize()); 1096 const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; 1097 return DecodeInstructions (range.GetBaseAddress(), data, 0, UINT32_MAX, false, data_from_file); 1098 } 1099 else if (error_strm_ptr) 1100 { 1101 const char *error_cstr = error.AsCString(); 1102 if (error_cstr) 1103 { 1104 error_strm_ptr->Printf("error: %s\n", error_cstr); 1105 } 1106 } 1107 } 1108 else if (error_strm_ptr) 1109 { 1110 error_strm_ptr->PutCString("error: invalid execution context\n"); 1111 } 1112 return 0; 1113 } 1114 1115 size_t 1116 Disassembler::ParseInstructions (const ExecutionContext *exe_ctx, 1117 const Address &start, 1118 uint32_t num_instructions, 1119 bool prefer_file_cache) 1120 { 1121 m_instruction_list.Clear(); 1122 1123 if (exe_ctx == NULL || num_instructions == 0 || !start.IsValid()) 1124 return 0; 1125 1126 Target *target = exe_ctx->GetTargetPtr(); 1127 // Calculate the max buffer size we will need in order to disassemble 1128 const addr_t byte_size = num_instructions * m_arch.GetMaximumOpcodeByteSize(); 1129 1130 if (target == NULL || byte_size == 0) 1131 return 0; 1132 1133 DataBufferHeap *heap_buffer = new DataBufferHeap (byte_size, '\0'); 1134 DataBufferSP data_sp (heap_buffer); 1135 1136 Error error; 1137 lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; 1138 const size_t bytes_read = target->ReadMemory (start, 1139 prefer_file_cache, 1140 heap_buffer->GetBytes(), 1141 byte_size, 1142 error, 1143 &load_addr); 1144 1145 const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; 1146 1147 if (bytes_read == 0) 1148 return 0; 1149 DataExtractor data (data_sp, 1150 m_arch.GetByteOrder(), 1151 m_arch.GetAddressByteSize()); 1152 1153 const bool append_instructions = true; 1154 DecodeInstructions (start, 1155 data, 1156 0, 1157 num_instructions, 1158 append_instructions, 1159 data_from_file); 1160 1161 return m_instruction_list.GetSize(); 1162 } 1163 1164 //---------------------------------------------------------------------- 1165 // Disassembler copy constructor 1166 //---------------------------------------------------------------------- 1167 Disassembler::Disassembler(const ArchSpec& arch, const char *flavor) : 1168 m_arch (arch), 1169 m_instruction_list(), 1170 m_base_addr(LLDB_INVALID_ADDRESS), 1171 m_flavor () 1172 { 1173 if (flavor == NULL) 1174 m_flavor.assign("default"); 1175 else 1176 m_flavor.assign(flavor); 1177 } 1178 1179 //---------------------------------------------------------------------- 1180 // Destructor 1181 //---------------------------------------------------------------------- 1182 Disassembler::~Disassembler() 1183 { 1184 } 1185 1186 InstructionList & 1187 Disassembler::GetInstructionList () 1188 { 1189 return m_instruction_list; 1190 } 1191 1192 const InstructionList & 1193 Disassembler::GetInstructionList () const 1194 { 1195 return m_instruction_list; 1196 } 1197 1198 //---------------------------------------------------------------------- 1199 // Class PseudoInstruction 1200 //---------------------------------------------------------------------- 1201 PseudoInstruction::PseudoInstruction () : 1202 Instruction (Address(), eAddressClassUnknown), 1203 m_description () 1204 { 1205 } 1206 1207 PseudoInstruction::~PseudoInstruction () 1208 { 1209 } 1210 1211 bool 1212 PseudoInstruction::DoesBranch () 1213 { 1214 // This is NOT a valid question for a pseudo instruction. 1215 return false; 1216 } 1217 1218 size_t 1219 PseudoInstruction::Decode (const lldb_private::Disassembler &disassembler, 1220 const lldb_private::DataExtractor &data, 1221 lldb::offset_t data_offset) 1222 { 1223 return m_opcode.GetByteSize(); 1224 } 1225 1226 1227 void 1228 PseudoInstruction::SetOpcode (size_t opcode_size, void *opcode_data) 1229 { 1230 if (!opcode_data) 1231 return; 1232 1233 switch (opcode_size) 1234 { 1235 case 8: 1236 { 1237 uint8_t value8 = *((uint8_t *) opcode_data); 1238 m_opcode.SetOpcode8 (value8); 1239 break; 1240 } 1241 case 16: 1242 { 1243 uint16_t value16 = *((uint16_t *) opcode_data); 1244 m_opcode.SetOpcode16 (value16); 1245 break; 1246 } 1247 case 32: 1248 { 1249 uint32_t value32 = *((uint32_t *) opcode_data); 1250 m_opcode.SetOpcode32 (value32); 1251 break; 1252 } 1253 case 64: 1254 { 1255 uint64_t value64 = *((uint64_t *) opcode_data); 1256 m_opcode.SetOpcode64 (value64); 1257 break; 1258 } 1259 default: 1260 break; 1261 } 1262 } 1263 1264 void 1265 PseudoInstruction::SetDescription (const char *description) 1266 { 1267 if (description && strlen (description) > 0) 1268 m_description = description; 1269 } 1270
