1 //===-- Disassembler.cpp --------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Core/Disassembler.h" 10 11 #include "lldb/Core/AddressRange.h" 12 #include "lldb/Core/Debugger.h" 13 #include "lldb/Core/EmulateInstruction.h" 14 #include "lldb/Core/Mangled.h" 15 #include "lldb/Core/Module.h" 16 #include "lldb/Core/ModuleList.h" 17 #include "lldb/Core/PluginManager.h" 18 #include "lldb/Core/SourceManager.h" 19 #include "lldb/Host/FileSystem.h" 20 #include "lldb/Interpreter/OptionValue.h" 21 #include "lldb/Interpreter/OptionValueArray.h" 22 #include "lldb/Interpreter/OptionValueDictionary.h" 23 #include "lldb/Interpreter/OptionValueRegex.h" 24 #include "lldb/Interpreter/OptionValueString.h" 25 #include "lldb/Interpreter/OptionValueUInt64.h" 26 #include "lldb/Symbol/Function.h" 27 #include "lldb/Symbol/Symbol.h" 28 #include "lldb/Symbol/SymbolContext.h" 29 #include "lldb/Target/ExecutionContext.h" 30 #include "lldb/Target/SectionLoadList.h" 31 #include "lldb/Target/StackFrame.h" 32 #include "lldb/Target/Target.h" 33 #include "lldb/Target/Thread.h" 34 #include "lldb/Utility/DataBufferHeap.h" 35 #include "lldb/Utility/DataExtractor.h" 36 #include "lldb/Utility/RegularExpression.h" 37 #include "lldb/Utility/Status.h" 38 #include "lldb/Utility/Stream.h" 39 #include "lldb/Utility/StreamString.h" 40 #include "lldb/Utility/Timer.h" 41 #include "lldb/lldb-private-enumerations.h" 42 #include "lldb/lldb-private-interfaces.h" 43 #include "lldb/lldb-private-types.h" 44 #include "llvm/Support/Compiler.h" 45 #include "llvm/TargetParser/Triple.h" 46 47 #include <cstdint> 48 #include <cstring> 49 #include <utility> 50 51 #include <cassert> 52 53 #define DEFAULT_DISASM_BYTE_SIZE 32 54 55 using namespace lldb; 56 using namespace lldb_private; 57 58 DisassemblerSP Disassembler::FindPlugin(const ArchSpec &arch, 59 const char *flavor, const char *cpu, 60 const char *features, 61 const char *plugin_name) { 62 LLDB_SCOPED_TIMERF("Disassembler::FindPlugin (arch = %s, plugin_name = %s)", 63 arch.GetArchitectureName(), plugin_name); 64 65 DisassemblerCreateInstance create_callback = nullptr; 66 67 if (plugin_name) { 68 create_callback = 69 PluginManager::GetDisassemblerCreateCallbackForPluginName(plugin_name); 70 if (create_callback) { 71 if (auto disasm_sp = create_callback(arch, flavor, cpu, features)) 72 return disasm_sp; 73 } 74 } else { 75 for (uint32_t idx = 0; 76 (create_callback = PluginManager::GetDisassemblerCreateCallbackAtIndex( 77 idx)) != nullptr; 78 ++idx) { 79 if (auto disasm_sp = create_callback(arch, flavor, cpu, features)) 80 return disasm_sp; 81 } 82 } 83 return DisassemblerSP(); 84 } 85 86 DisassemblerSP Disassembler::FindPluginForTarget( 87 const Target &target, const ArchSpec &arch, const char *flavor, 88 const char *cpu, const char *features, const char *plugin_name) { 89 if (!flavor) { 90 // FIXME - we don't have the mechanism in place to do per-architecture 91 // settings. But since we know that for now we only support flavors on x86 92 // & x86_64, 93 if (arch.GetTriple().getArch() == llvm::Triple::x86 || 94 arch.GetTriple().getArch() == llvm::Triple::x86_64) 95 flavor = target.GetDisassemblyFlavor(); 96 } 97 if (!cpu) 98 cpu = target.GetDisassemblyCPU(); 99 if (!features) 100 features = target.GetDisassemblyFeatures(); 101 102 return FindPlugin(arch, flavor, cpu, features, plugin_name); 103 } 104 105 static Address ResolveAddress(Target &target, const Address &addr) { 106 if (!addr.IsSectionOffset()) { 107 Address resolved_addr; 108 // If we weren't passed in a section offset address range, try and resolve 109 // it to something 110 bool is_resolved = target.GetSectionLoadList().IsEmpty() 111 ? target.GetImages().ResolveFileAddress( 112 addr.GetOffset(), resolved_addr) 113 : target.GetSectionLoadList().ResolveLoadAddress( 114 addr.GetOffset(), resolved_addr); 115 116 // We weren't able to resolve the address, just treat it as a raw address 117 if (is_resolved && resolved_addr.IsValid()) 118 return resolved_addr; 119 } 120 return addr; 121 } 122 123 lldb::DisassemblerSP Disassembler::DisassembleRange( 124 const ArchSpec &arch, const char *plugin_name, const char *flavor, 125 const char *cpu, const char *features, Target &target, 126 const AddressRange &range, bool force_live_memory) { 127 if (range.GetByteSize() <= 0) 128 return {}; 129 130 if (!range.GetBaseAddress().IsValid()) 131 return {}; 132 133 lldb::DisassemblerSP disasm_sp = Disassembler::FindPluginForTarget( 134 target, arch, flavor, cpu, features, plugin_name); 135 136 if (!disasm_sp) 137 return {}; 138 139 const size_t bytes_disassembled = disasm_sp->ParseInstructions( 140 target, range.GetBaseAddress(), {Limit::Bytes, range.GetByteSize()}, 141 nullptr, force_live_memory); 142 if (bytes_disassembled == 0) 143 return {}; 144 145 return disasm_sp; 146 } 147 148 lldb::DisassemblerSP 149 Disassembler::DisassembleBytes(const ArchSpec &arch, const char *plugin_name, 150 const char *flavor, const char *cpu, 151 const char *features, const Address &start, 152 const void *src, size_t src_len, 153 uint32_t num_instructions, bool data_from_file) { 154 if (!src) 155 return {}; 156 157 lldb::DisassemblerSP disasm_sp = 158 Disassembler::FindPlugin(arch, flavor, cpu, features, plugin_name); 159 160 if (!disasm_sp) 161 return {}; 162 163 DataExtractor data(src, src_len, arch.GetByteOrder(), 164 arch.GetAddressByteSize()); 165 166 (void)disasm_sp->DecodeInstructions(start, data, 0, num_instructions, false, 167 data_from_file); 168 return disasm_sp; 169 } 170 171 bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch, 172 const char *plugin_name, const char *flavor, 173 const char *cpu, const char *features, 174 const ExecutionContext &exe_ctx, 175 const Address &address, Limit limit, 176 bool mixed_source_and_assembly, 177 uint32_t num_mixed_context_lines, 178 uint32_t options, Stream &strm) { 179 if (!exe_ctx.GetTargetPtr()) 180 return false; 181 182 lldb::DisassemblerSP disasm_sp(Disassembler::FindPluginForTarget( 183 exe_ctx.GetTargetRef(), arch, flavor, cpu, features, plugin_name)); 184 if (!disasm_sp) 185 return false; 186 187 const bool force_live_memory = true; 188 size_t bytes_disassembled = disasm_sp->ParseInstructions( 189 exe_ctx.GetTargetRef(), address, limit, &strm, force_live_memory); 190 if (bytes_disassembled == 0) 191 return false; 192 193 disasm_sp->PrintInstructions(debugger, arch, exe_ctx, 194 mixed_source_and_assembly, 195 num_mixed_context_lines, options, strm); 196 return true; 197 } 198 199 Disassembler::SourceLine 200 Disassembler::GetFunctionDeclLineEntry(const SymbolContext &sc) { 201 if (!sc.function) 202 return {}; 203 204 if (!sc.line_entry.IsValid()) 205 return {}; 206 207 LineEntry prologue_end_line = sc.line_entry; 208 SupportFileSP func_decl_file_sp; 209 uint32_t func_decl_line; 210 sc.function->GetStartLineSourceInfo(func_decl_file_sp, func_decl_line); 211 212 if (!func_decl_file_sp) 213 return {}; 214 if (!func_decl_file_sp->Equal(*prologue_end_line.file_sp, 215 SupportFile::eEqualFileSpecAndChecksumIfSet) && 216 !func_decl_file_sp->Equal(*prologue_end_line.original_file_sp, 217 SupportFile::eEqualFileSpecAndChecksumIfSet)) 218 return {}; 219 220 SourceLine decl_line; 221 decl_line.file = func_decl_file_sp->GetSpecOnly(); 222 decl_line.line = func_decl_line; 223 // TODO: Do we care about column on these entries? If so, we need to plumb 224 // that through GetStartLineSourceInfo. 225 decl_line.column = 0; 226 return decl_line; 227 } 228 229 void Disassembler::AddLineToSourceLineTables( 230 SourceLine &line, 231 std::map<FileSpec, std::set<uint32_t>> &source_lines_seen) { 232 if (line.IsValid()) { 233 auto source_lines_seen_pos = source_lines_seen.find(line.file); 234 if (source_lines_seen_pos == source_lines_seen.end()) { 235 std::set<uint32_t> lines; 236 lines.insert(line.line); 237 source_lines_seen.emplace(line.file, lines); 238 } else { 239 source_lines_seen_pos->second.insert(line.line); 240 } 241 } 242 } 243 244 bool Disassembler::ElideMixedSourceAndDisassemblyLine( 245 const ExecutionContext &exe_ctx, const SymbolContext &sc, 246 SourceLine &line) { 247 248 // TODO: should we also check target.process.thread.step-avoid-libraries ? 249 250 const RegularExpression *avoid_regex = nullptr; 251 252 // Skip any line #0 entries - they are implementation details 253 if (line.line == 0) 254 return true; 255 256 ThreadSP thread_sp = exe_ctx.GetThreadSP(); 257 if (thread_sp) { 258 avoid_regex = thread_sp->GetSymbolsToAvoidRegexp(); 259 } else { 260 TargetSP target_sp = exe_ctx.GetTargetSP(); 261 if (target_sp) { 262 Status error; 263 OptionValueSP value_sp = target_sp->GetDebugger().GetPropertyValue( 264 &exe_ctx, "target.process.thread.step-avoid-regexp", error); 265 if (value_sp && value_sp->GetType() == OptionValue::eTypeRegex) { 266 OptionValueRegex *re = value_sp->GetAsRegex(); 267 if (re) { 268 avoid_regex = re->GetCurrentValue(); 269 } 270 } 271 } 272 } 273 if (avoid_regex && sc.symbol != nullptr) { 274 const char *function_name = 275 sc.GetFunctionName(Mangled::ePreferDemangledWithoutArguments) 276 .GetCString(); 277 if (function_name && avoid_regex->Execute(function_name)) { 278 // skip this source line 279 return true; 280 } 281 } 282 // don't skip this source line 283 return false; 284 } 285 286 void Disassembler::PrintInstructions(Debugger &debugger, const ArchSpec &arch, 287 const ExecutionContext &exe_ctx, 288 bool mixed_source_and_assembly, 289 uint32_t num_mixed_context_lines, 290 uint32_t options, Stream &strm) { 291 // We got some things disassembled... 292 size_t num_instructions_found = GetInstructionList().GetSize(); 293 294 const uint32_t max_opcode_byte_size = 295 GetInstructionList().GetMaxOpcocdeByteSize(); 296 SymbolContext sc; 297 SymbolContext prev_sc; 298 AddressRange current_source_line_range; 299 const Address *pc_addr_ptr = nullptr; 300 StackFrame *frame = exe_ctx.GetFramePtr(); 301 302 TargetSP target_sp(exe_ctx.GetTargetSP()); 303 SourceManager &source_manager = 304 target_sp ? target_sp->GetSourceManager() : debugger.GetSourceManager(); 305 306 if (frame) { 307 pc_addr_ptr = &frame->GetFrameCodeAddress(); 308 } 309 const uint32_t scope = 310 eSymbolContextLineEntry | eSymbolContextFunction | eSymbolContextSymbol; 311 const bool use_inline_block_range = false; 312 313 const FormatEntity::Entry *disassembly_format = nullptr; 314 FormatEntity::Entry format; 315 if (exe_ctx.HasTargetScope()) { 316 disassembly_format = 317 exe_ctx.GetTargetRef().GetDebugger().GetDisassemblyFormat(); 318 } else { 319 FormatEntity::Parse("${addr}: ", format); 320 disassembly_format = &format; 321 } 322 323 // First pass: step through the list of instructions, find how long the 324 // initial addresses strings are, insert padding in the second pass so the 325 // opcodes all line up nicely. 326 327 // Also build up the source line mapping if this is mixed source & assembly 328 // mode. Calculate the source line for each assembly instruction (eliding 329 // inlined functions which the user wants to skip). 330 331 std::map<FileSpec, std::set<uint32_t>> source_lines_seen; 332 Symbol *previous_symbol = nullptr; 333 334 size_t address_text_size = 0; 335 for (size_t i = 0; i < num_instructions_found; ++i) { 336 Instruction *inst = GetInstructionList().GetInstructionAtIndex(i).get(); 337 if (inst) { 338 const Address &addr = inst->GetAddress(); 339 ModuleSP module_sp(addr.GetModule()); 340 if (module_sp) { 341 const SymbolContextItem resolve_mask = eSymbolContextFunction | 342 eSymbolContextSymbol | 343 eSymbolContextLineEntry; 344 uint32_t resolved_mask = 345 module_sp->ResolveSymbolContextForAddress(addr, resolve_mask, sc); 346 if (resolved_mask) { 347 StreamString strmstr; 348 Debugger::FormatDisassemblerAddress(disassembly_format, &sc, nullptr, 349 &exe_ctx, &addr, strmstr); 350 size_t cur_line = strmstr.GetSizeOfLastLine(); 351 if (cur_line > address_text_size) 352 address_text_size = cur_line; 353 354 // Add entries to our "source_lines_seen" map+set which list which 355 // sources lines occur in this disassembly session. We will print 356 // lines of context around a source line, but we don't want to print 357 // a source line that has a line table entry of its own - we'll leave 358 // that source line to be printed when it actually occurs in the 359 // disassembly. 360 361 if (mixed_source_and_assembly && sc.line_entry.IsValid()) { 362 if (sc.symbol != previous_symbol) { 363 SourceLine decl_line = GetFunctionDeclLineEntry(sc); 364 if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, decl_line)) 365 AddLineToSourceLineTables(decl_line, source_lines_seen); 366 } 367 if (sc.line_entry.IsValid()) { 368 SourceLine this_line; 369 this_line.file = sc.line_entry.GetFile(); 370 this_line.line = sc.line_entry.line; 371 this_line.column = sc.line_entry.column; 372 if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, this_line)) 373 AddLineToSourceLineTables(this_line, source_lines_seen); 374 } 375 } 376 } 377 sc.Clear(false); 378 } 379 } 380 } 381 382 previous_symbol = nullptr; 383 SourceLine previous_line; 384 for (size_t i = 0; i < num_instructions_found; ++i) { 385 Instruction *inst = GetInstructionList().GetInstructionAtIndex(i).get(); 386 387 if (inst) { 388 const Address &addr = inst->GetAddress(); 389 const bool inst_is_at_pc = pc_addr_ptr && addr == *pc_addr_ptr; 390 SourceLinesToDisplay source_lines_to_display; 391 392 prev_sc = sc; 393 394 ModuleSP module_sp(addr.GetModule()); 395 if (module_sp) { 396 uint32_t resolved_mask = module_sp->ResolveSymbolContextForAddress( 397 addr, eSymbolContextEverything, sc); 398 if (resolved_mask) { 399 if (mixed_source_and_assembly) { 400 401 // If we've started a new function (non-inlined), print all of the 402 // source lines from the function declaration until the first line 403 // table entry - typically the opening curly brace of the function. 404 if (previous_symbol != sc.symbol) { 405 // The default disassembly format puts an extra blank line 406 // between functions - so when we're displaying the source 407 // context for a function, we don't want to add a blank line 408 // after the source context or we'll end up with two of them. 409 if (previous_symbol != nullptr) 410 source_lines_to_display.print_source_context_end_eol = false; 411 412 previous_symbol = sc.symbol; 413 if (sc.function && sc.line_entry.IsValid()) { 414 LineEntry prologue_end_line = sc.line_entry; 415 if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, 416 prologue_end_line)) { 417 SupportFileSP func_decl_file_sp; 418 uint32_t func_decl_line; 419 sc.function->GetStartLineSourceInfo(func_decl_file_sp, 420 func_decl_line); 421 if (func_decl_file_sp && 422 (func_decl_file_sp->Equal( 423 *prologue_end_line.file_sp, 424 SupportFile::eEqualFileSpecAndChecksumIfSet) || 425 func_decl_file_sp->Equal( 426 *prologue_end_line.original_file_sp, 427 SupportFile::eEqualFileSpecAndChecksumIfSet))) { 428 // Add all the lines between the function declaration and 429 // the first non-prologue source line to the list of lines 430 // to print. 431 for (uint32_t lineno = func_decl_line; 432 lineno <= prologue_end_line.line; lineno++) { 433 SourceLine this_line; 434 this_line.file = func_decl_file_sp->GetSpecOnly(); 435 this_line.line = lineno; 436 source_lines_to_display.lines.push_back(this_line); 437 } 438 // Mark the last line as the "current" one. Usually this 439 // is the open curly brace. 440 if (source_lines_to_display.lines.size() > 0) 441 source_lines_to_display.current_source_line = 442 source_lines_to_display.lines.size() - 1; 443 } 444 } 445 } 446 sc.GetAddressRange(scope, 0, use_inline_block_range, 447 current_source_line_range); 448 } 449 450 // If we've left a previous source line's address range, print a 451 // new source line 452 if (!current_source_line_range.ContainsFileAddress(addr)) { 453 sc.GetAddressRange(scope, 0, use_inline_block_range, 454 current_source_line_range); 455 456 if (sc != prev_sc && sc.comp_unit && sc.line_entry.IsValid()) { 457 SourceLine this_line; 458 this_line.file = sc.line_entry.GetFile(); 459 this_line.line = sc.line_entry.line; 460 461 if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, 462 this_line)) { 463 // Only print this source line if it is different from the 464 // last source line we printed. There may have been inlined 465 // functions between these lines that we elided, resulting in 466 // the same line being printed twice in a row for a 467 // contiguous block of assembly instructions. 468 if (this_line != previous_line) { 469 470 std::vector<uint32_t> previous_lines; 471 for (uint32_t i = 0; 472 i < num_mixed_context_lines && 473 (this_line.line - num_mixed_context_lines) > 0; 474 i++) { 475 uint32_t line = 476 this_line.line - num_mixed_context_lines + i; 477 auto pos = source_lines_seen.find(this_line.file); 478 if (pos != source_lines_seen.end()) { 479 if (pos->second.count(line) == 1) { 480 previous_lines.clear(); 481 } else { 482 previous_lines.push_back(line); 483 } 484 } 485 } 486 for (size_t i = 0; i < previous_lines.size(); i++) { 487 SourceLine previous_line; 488 previous_line.file = this_line.file; 489 previous_line.line = previous_lines[i]; 490 auto pos = source_lines_seen.find(previous_line.file); 491 if (pos != source_lines_seen.end()) { 492 pos->second.insert(previous_line.line); 493 } 494 source_lines_to_display.lines.push_back(previous_line); 495 } 496 497 source_lines_to_display.lines.push_back(this_line); 498 source_lines_to_display.current_source_line = 499 source_lines_to_display.lines.size() - 1; 500 501 for (uint32_t i = 0; i < num_mixed_context_lines; i++) { 502 SourceLine next_line; 503 next_line.file = this_line.file; 504 next_line.line = this_line.line + i + 1; 505 auto pos = source_lines_seen.find(next_line.file); 506 if (pos != source_lines_seen.end()) { 507 if (pos->second.count(next_line.line) == 1) 508 break; 509 pos->second.insert(next_line.line); 510 } 511 source_lines_to_display.lines.push_back(next_line); 512 } 513 } 514 previous_line = this_line; 515 } 516 } 517 } 518 } 519 } else { 520 sc.Clear(true); 521 } 522 } 523 524 if (source_lines_to_display.lines.size() > 0) { 525 strm.EOL(); 526 for (size_t idx = 0; idx < source_lines_to_display.lines.size(); 527 idx++) { 528 SourceLine ln = source_lines_to_display.lines[idx]; 529 const char *line_highlight = ""; 530 if (inst_is_at_pc && (options & eOptionMarkPCSourceLine)) { 531 line_highlight = "->"; 532 } else if (idx == source_lines_to_display.current_source_line) { 533 line_highlight = "**"; 534 } 535 source_manager.DisplaySourceLinesWithLineNumbers( 536 std::make_shared<SupportFile>(ln.file), ln.line, ln.column, 0, 0, 537 line_highlight, &strm); 538 } 539 if (source_lines_to_display.print_source_context_end_eol) 540 strm.EOL(); 541 } 542 543 const bool show_bytes = (options & eOptionShowBytes) != 0; 544 const bool show_control_flow_kind = 545 (options & eOptionShowControlFlowKind) != 0; 546 inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, 547 show_control_flow_kind, &exe_ctx, &sc, &prev_sc, nullptr, 548 address_text_size); 549 strm.EOL(); 550 } else { 551 break; 552 } 553 } 554 } 555 556 bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch, 557 StackFrame &frame, Stream &strm) { 558 AddressRange range; 559 SymbolContext sc( 560 frame.GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); 561 if (sc.function) { 562 range = sc.function->GetAddressRange(); 563 } else if (sc.symbol && sc.symbol->ValueIsAddress()) { 564 range.GetBaseAddress() = sc.symbol->GetAddressRef(); 565 range.SetByteSize(sc.symbol->GetByteSize()); 566 } else { 567 range.GetBaseAddress() = frame.GetFrameCodeAddress(); 568 } 569 570 if (range.GetBaseAddress().IsValid() && range.GetByteSize() == 0) 571 range.SetByteSize(DEFAULT_DISASM_BYTE_SIZE); 572 573 Disassembler::Limit limit = {Disassembler::Limit::Bytes, 574 range.GetByteSize()}; 575 if (limit.value == 0) 576 limit.value = DEFAULT_DISASM_BYTE_SIZE; 577 578 return Disassemble(debugger, arch, nullptr, nullptr, nullptr, nullptr, 579 frame, range.GetBaseAddress(), limit, false, 0, 0, strm); 580 } 581 582 Instruction::Instruction(const Address &address, AddressClass addr_class) 583 : m_address(address), m_address_class(addr_class), m_opcode(), 584 m_calculated_strings(false) {} 585 586 Instruction::~Instruction() = default; 587 588 AddressClass Instruction::GetAddressClass() { 589 if (m_address_class == AddressClass::eInvalid) 590 m_address_class = m_address.GetAddressClass(); 591 return m_address_class; 592 } 593 594 const char *Instruction::GetNameForInstructionControlFlowKind( 595 lldb::InstructionControlFlowKind instruction_control_flow_kind) { 596 switch (instruction_control_flow_kind) { 597 case eInstructionControlFlowKindUnknown: 598 return "unknown"; 599 case eInstructionControlFlowKindOther: 600 return "other"; 601 case eInstructionControlFlowKindCall: 602 return "call"; 603 case eInstructionControlFlowKindReturn: 604 return "return"; 605 case eInstructionControlFlowKindJump: 606 return "jump"; 607 case eInstructionControlFlowKindCondJump: 608 return "cond jump"; 609 case eInstructionControlFlowKindFarCall: 610 return "far call"; 611 case eInstructionControlFlowKindFarReturn: 612 return "far return"; 613 case eInstructionControlFlowKindFarJump: 614 return "far jump"; 615 } 616 llvm_unreachable("Fully covered switch above!"); 617 } 618 619 void Instruction::Dump(lldb_private::Stream *s, uint32_t max_opcode_byte_size, 620 bool show_address, bool show_bytes, 621 bool show_control_flow_kind, 622 const ExecutionContext *exe_ctx, 623 const SymbolContext *sym_ctx, 624 const SymbolContext *prev_sym_ctx, 625 const FormatEntity::Entry *disassembly_addr_format, 626 size_t max_address_text_size) { 627 size_t opcode_column_width = 7; 628 const size_t operand_column_width = 25; 629 630 CalculateMnemonicOperandsAndCommentIfNeeded(exe_ctx); 631 632 StreamString ss; 633 634 if (show_address) { 635 Debugger::FormatDisassemblerAddress(disassembly_addr_format, sym_ctx, 636 prev_sym_ctx, exe_ctx, &m_address, ss); 637 ss.FillLastLineToColumn(max_address_text_size, ' '); 638 } 639 640 if (show_bytes) { 641 if (m_opcode.GetType() == Opcode::eTypeBytes) { 642 // x86_64 and i386 are the only ones that use bytes right now so pad out 643 // the byte dump to be able to always show 15 bytes (3 chars each) plus a 644 // space 645 if (max_opcode_byte_size > 0) 646 m_opcode.Dump(&ss, max_opcode_byte_size * 3 + 1); 647 else 648 m_opcode.Dump(&ss, 15 * 3 + 1); 649 } else { 650 // Else, we have ARM or MIPS which can show up to a uint32_t 0x00000000 651 // (10 spaces) plus two for padding... 652 if (max_opcode_byte_size > 0) 653 m_opcode.Dump(&ss, max_opcode_byte_size * 3 + 1); 654 else 655 m_opcode.Dump(&ss, 12); 656 } 657 } 658 659 if (show_control_flow_kind) { 660 lldb::InstructionControlFlowKind instruction_control_flow_kind = 661 GetControlFlowKind(exe_ctx); 662 ss.Printf("%-12s", GetNameForInstructionControlFlowKind( 663 instruction_control_flow_kind)); 664 } 665 666 bool show_color = false; 667 if (exe_ctx) { 668 if (TargetSP target_sp = exe_ctx->GetTargetSP()) { 669 show_color = target_sp->GetDebugger().GetUseColor(); 670 } 671 } 672 const size_t opcode_pos = ss.GetSizeOfLastLine(); 673 const std::string &opcode_name = 674 show_color ? m_markup_opcode_name : m_opcode_name; 675 const std::string &mnemonics = show_color ? m_markup_mnemonics : m_mnemonics; 676 677 // The default opcode size of 7 characters is plenty for most architectures 678 // but some like arm can pull out the occasional vqrshrun.s16. We won't get 679 // consistent column spacing in these cases, unfortunately. Also note that we 680 // need to directly use m_opcode_name here (instead of opcode_name) so we 681 // don't include color codes as characters. 682 if (m_opcode_name.length() >= opcode_column_width) { 683 opcode_column_width = m_opcode_name.length() + 1; 684 } 685 686 ss.PutCString(opcode_name); 687 ss.FillLastLineToColumn(opcode_pos + opcode_column_width, ' '); 688 ss.PutCString(mnemonics); 689 690 if (!m_comment.empty()) { 691 ss.FillLastLineToColumn( 692 opcode_pos + opcode_column_width + operand_column_width, ' '); 693 ss.PutCString(" ; "); 694 ss.PutCString(m_comment); 695 } 696 s->PutCString(ss.GetString()); 697 } 698 699 bool Instruction::DumpEmulation(const ArchSpec &arch) { 700 std::unique_ptr<EmulateInstruction> insn_emulator_up( 701 EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr)); 702 if (insn_emulator_up) { 703 insn_emulator_up->SetInstruction(GetOpcode(), GetAddress(), nullptr); 704 return insn_emulator_up->EvaluateInstruction(0); 705 } 706 707 return false; 708 } 709 710 bool Instruction::CanSetBreakpoint () { 711 return !HasDelaySlot(); 712 } 713 714 bool Instruction::HasDelaySlot() { 715 // Default is false. 716 return false; 717 } 718 719 OptionValueSP Instruction::ReadArray(FILE *in_file, Stream &out_stream, 720 OptionValue::Type data_type) { 721 bool done = false; 722 char buffer[1024]; 723 724 auto option_value_sp = std::make_shared<OptionValueArray>(1u << data_type); 725 726 int idx = 0; 727 while (!done) { 728 if (!fgets(buffer, 1023, in_file)) { 729 out_stream.Printf( 730 "Instruction::ReadArray: Error reading file (fgets).\n"); 731 option_value_sp.reset(); 732 return option_value_sp; 733 } 734 735 std::string line(buffer); 736 737 size_t len = line.size(); 738 if (line[len - 1] == '\n') { 739 line[len - 1] = '\0'; 740 line.resize(len - 1); 741 } 742 743 if ((line.size() == 1) && line[0] == ']') { 744 done = true; 745 line.clear(); 746 } 747 748 if (!line.empty()) { 749 std::string value; 750 static RegularExpression g_reg_exp( 751 llvm::StringRef("^[ \t]*([^ \t]+)[ \t]*$")); 752 llvm::SmallVector<llvm::StringRef, 2> matches; 753 if (g_reg_exp.Execute(line, &matches)) 754 value = matches[1].str(); 755 else 756 value = line; 757 758 OptionValueSP data_value_sp; 759 switch (data_type) { 760 case OptionValue::eTypeUInt64: 761 data_value_sp = std::make_shared<OptionValueUInt64>(0, 0); 762 data_value_sp->SetValueFromString(value); 763 break; 764 // Other types can be added later as needed. 765 default: 766 data_value_sp = std::make_shared<OptionValueString>(value.c_str(), ""); 767 break; 768 } 769 770 option_value_sp->GetAsArray()->InsertValue(idx, data_value_sp); 771 ++idx; 772 } 773 } 774 775 return option_value_sp; 776 } 777 778 OptionValueSP Instruction::ReadDictionary(FILE *in_file, Stream &out_stream) { 779 bool done = false; 780 char buffer[1024]; 781 782 auto option_value_sp = std::make_shared<OptionValueDictionary>(); 783 static constexpr llvm::StringLiteral encoding_key("data_encoding"); 784 OptionValue::Type data_type = OptionValue::eTypeInvalid; 785 786 while (!done) { 787 // Read the next line in the file 788 if (!fgets(buffer, 1023, in_file)) { 789 out_stream.Printf( 790 "Instruction::ReadDictionary: Error reading file (fgets).\n"); 791 option_value_sp.reset(); 792 return option_value_sp; 793 } 794 795 // Check to see if the line contains the end-of-dictionary marker ("}") 796 std::string line(buffer); 797 798 size_t len = line.size(); 799 if (line[len - 1] == '\n') { 800 line[len - 1] = '\0'; 801 line.resize(len - 1); 802 } 803 804 if ((line.size() == 1) && (line[0] == '}')) { 805 done = true; 806 line.clear(); 807 } 808 809 // Try to find a key-value pair in the current line and add it to the 810 // dictionary. 811 if (!line.empty()) { 812 static RegularExpression g_reg_exp(llvm::StringRef( 813 "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*=[ \t]*(.*)[ \t]*$")); 814 815 llvm::SmallVector<llvm::StringRef, 3> matches; 816 817 bool reg_exp_success = g_reg_exp.Execute(line, &matches); 818 std::string key; 819 std::string value; 820 if (reg_exp_success) { 821 key = matches[1].str(); 822 value = matches[2].str(); 823 } else { 824 out_stream.Printf("Instruction::ReadDictionary: Failure executing " 825 "regular expression.\n"); 826 option_value_sp.reset(); 827 return option_value_sp; 828 } 829 830 // Check value to see if it's the start of an array or dictionary. 831 832 lldb::OptionValueSP value_sp; 833 assert(value.empty() == false); 834 assert(key.empty() == false); 835 836 if (value[0] == '{') { 837 assert(value.size() == 1); 838 // value is a dictionary 839 value_sp = ReadDictionary(in_file, out_stream); 840 if (!value_sp) { 841 option_value_sp.reset(); 842 return option_value_sp; 843 } 844 } else if (value[0] == '[') { 845 assert(value.size() == 1); 846 // value is an array 847 value_sp = ReadArray(in_file, out_stream, data_type); 848 if (!value_sp) { 849 option_value_sp.reset(); 850 return option_value_sp; 851 } 852 // We've used the data_type to read an array; re-set the type to 853 // Invalid 854 data_type = OptionValue::eTypeInvalid; 855 } else if ((value[0] == '0') && (value[1] == 'x')) { 856 value_sp = std::make_shared<OptionValueUInt64>(0, 0); 857 value_sp->SetValueFromString(value); 858 } else { 859 size_t len = value.size(); 860 if ((value[0] == '"') && (value[len - 1] == '"')) 861 value = value.substr(1, len - 2); 862 value_sp = std::make_shared<OptionValueString>(value.c_str(), ""); 863 } 864 865 if (key == encoding_key) { 866 // A 'data_encoding=..." is NOT a normal key-value pair; it is meta-data 867 // indicating the data type of an upcoming array (usually the next bit 868 // of data to be read in). 869 if (llvm::StringRef(value) == "uint32_t") 870 data_type = OptionValue::eTypeUInt64; 871 } else 872 option_value_sp->GetAsDictionary()->SetValueForKey(key, value_sp, 873 false); 874 } 875 } 876 877 return option_value_sp; 878 } 879 880 bool Instruction::TestEmulation(Stream &out_stream, const char *file_name) { 881 if (!file_name) { 882 out_stream.Printf("Instruction::TestEmulation: Missing file_name."); 883 return false; 884 } 885 FILE *test_file = FileSystem::Instance().Fopen(file_name, "r"); 886 if (!test_file) { 887 out_stream.Printf( 888 "Instruction::TestEmulation: Attempt to open test file failed."); 889 return false; 890 } 891 892 char buffer[256]; 893 if (!fgets(buffer, 255, test_file)) { 894 out_stream.Printf( 895 "Instruction::TestEmulation: Error reading first line of test file.\n"); 896 fclose(test_file); 897 return false; 898 } 899 900 if (strncmp(buffer, "InstructionEmulationState={", 27) != 0) { 901 out_stream.Printf("Instructin::TestEmulation: Test file does not contain " 902 "emulation state dictionary\n"); 903 fclose(test_file); 904 return false; 905 } 906 907 // Read all the test information from the test file into an 908 // OptionValueDictionary. 909 910 OptionValueSP data_dictionary_sp(ReadDictionary(test_file, out_stream)); 911 if (!data_dictionary_sp) { 912 out_stream.Printf( 913 "Instruction::TestEmulation: Error reading Dictionary Object.\n"); 914 fclose(test_file); 915 return false; 916 } 917 918 fclose(test_file); 919 920 OptionValueDictionary *data_dictionary = 921 data_dictionary_sp->GetAsDictionary(); 922 static constexpr llvm::StringLiteral description_key("assembly_string"); 923 static constexpr llvm::StringLiteral triple_key("triple"); 924 925 OptionValueSP value_sp = data_dictionary->GetValueForKey(description_key); 926 927 if (!value_sp) { 928 out_stream.Printf("Instruction::TestEmulation: Test file does not " 929 "contain description string.\n"); 930 return false; 931 } 932 933 SetDescription(value_sp->GetValueAs<llvm::StringRef>().value_or("")); 934 935 value_sp = data_dictionary->GetValueForKey(triple_key); 936 if (!value_sp) { 937 out_stream.Printf( 938 "Instruction::TestEmulation: Test file does not contain triple.\n"); 939 return false; 940 } 941 942 ArchSpec arch; 943 arch.SetTriple( 944 llvm::Triple(value_sp->GetValueAs<llvm::StringRef>().value_or(""))); 945 946 bool success = false; 947 std::unique_ptr<EmulateInstruction> insn_emulator_up( 948 EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr)); 949 if (insn_emulator_up) 950 success = 951 insn_emulator_up->TestEmulation(out_stream, arch, data_dictionary); 952 953 if (success) 954 out_stream.Printf("Emulation test succeeded."); 955 else 956 out_stream.Printf("Emulation test failed."); 957 958 return success; 959 } 960 961 bool Instruction::Emulate( 962 const ArchSpec &arch, uint32_t evaluate_options, void *baton, 963 EmulateInstruction::ReadMemoryCallback read_mem_callback, 964 EmulateInstruction::WriteMemoryCallback write_mem_callback, 965 EmulateInstruction::ReadRegisterCallback read_reg_callback, 966 EmulateInstruction::WriteRegisterCallback write_reg_callback) { 967 std::unique_ptr<EmulateInstruction> insn_emulator_up( 968 EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr)); 969 if (insn_emulator_up) { 970 insn_emulator_up->SetBaton(baton); 971 insn_emulator_up->SetCallbacks(read_mem_callback, write_mem_callback, 972 read_reg_callback, write_reg_callback); 973 insn_emulator_up->SetInstruction(GetOpcode(), GetAddress(), nullptr); 974 return insn_emulator_up->EvaluateInstruction(evaluate_options); 975 } 976 977 return false; 978 } 979 980 uint32_t Instruction::GetData(DataExtractor &data) { 981 return m_opcode.GetData(data); 982 } 983 984 InstructionList::InstructionList() : m_instructions() {} 985 986 InstructionList::~InstructionList() = default; 987 988 size_t InstructionList::GetSize() const { return m_instructions.size(); } 989 990 uint32_t InstructionList::GetMaxOpcocdeByteSize() const { 991 uint32_t max_inst_size = 0; 992 collection::const_iterator pos, end; 993 for (pos = m_instructions.begin(), end = m_instructions.end(); pos != end; 994 ++pos) { 995 uint32_t inst_size = (*pos)->GetOpcode().GetByteSize(); 996 if (max_inst_size < inst_size) 997 max_inst_size = inst_size; 998 } 999 return max_inst_size; 1000 } 1001 1002 InstructionSP InstructionList::GetInstructionAtIndex(size_t idx) const { 1003 InstructionSP inst_sp; 1004 if (idx < m_instructions.size()) 1005 inst_sp = m_instructions[idx]; 1006 return inst_sp; 1007 } 1008 1009 InstructionSP InstructionList::GetInstructionAtAddress(const Address &address) { 1010 uint32_t index = GetIndexOfInstructionAtAddress(address); 1011 if (index != UINT32_MAX) 1012 return GetInstructionAtIndex(index); 1013 return nullptr; 1014 } 1015 1016 void InstructionList::Dump(Stream *s, bool show_address, bool show_bytes, 1017 bool show_control_flow_kind, 1018 const ExecutionContext *exe_ctx) { 1019 const uint32_t max_opcode_byte_size = GetMaxOpcocdeByteSize(); 1020 collection::const_iterator pos, begin, end; 1021 1022 const FormatEntity::Entry *disassembly_format = nullptr; 1023 FormatEntity::Entry format; 1024 if (exe_ctx && exe_ctx->HasTargetScope()) { 1025 disassembly_format = 1026 exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat(); 1027 } else { 1028 FormatEntity::Parse("${addr}: ", format); 1029 disassembly_format = &format; 1030 } 1031 1032 for (begin = m_instructions.begin(), end = m_instructions.end(), pos = begin; 1033 pos != end; ++pos) { 1034 if (pos != begin) 1035 s->EOL(); 1036 (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, 1037 show_control_flow_kind, exe_ctx, nullptr, nullptr, 1038 disassembly_format, 0); 1039 } 1040 } 1041 1042 void InstructionList::Clear() { m_instructions.clear(); } 1043 1044 void InstructionList::Append(lldb::InstructionSP &inst_sp) { 1045 if (inst_sp) 1046 m_instructions.push_back(inst_sp); 1047 } 1048 1049 uint32_t 1050 InstructionList::GetIndexOfNextBranchInstruction(uint32_t start, 1051 bool ignore_calls, 1052 bool *found_calls) const { 1053 size_t num_instructions = m_instructions.size(); 1054 1055 uint32_t next_branch = UINT32_MAX; 1056 1057 if (found_calls) 1058 *found_calls = false; 1059 for (size_t i = start; i < num_instructions; i++) { 1060 if (m_instructions[i]->DoesBranch()) { 1061 if (ignore_calls && m_instructions[i]->IsCall()) { 1062 if (found_calls) 1063 *found_calls = true; 1064 continue; 1065 } 1066 next_branch = i; 1067 break; 1068 } 1069 } 1070 1071 return next_branch; 1072 } 1073 1074 uint32_t 1075 InstructionList::GetIndexOfInstructionAtAddress(const Address &address) { 1076 size_t num_instructions = m_instructions.size(); 1077 uint32_t index = UINT32_MAX; 1078 for (size_t i = 0; i < num_instructions; i++) { 1079 if (m_instructions[i]->GetAddress() == address) { 1080 index = i; 1081 break; 1082 } 1083 } 1084 return index; 1085 } 1086 1087 uint32_t 1088 InstructionList::GetIndexOfInstructionAtLoadAddress(lldb::addr_t load_addr, 1089 Target &target) { 1090 Address address; 1091 address.SetLoadAddress(load_addr, &target); 1092 return GetIndexOfInstructionAtAddress(address); 1093 } 1094 1095 size_t Disassembler::ParseInstructions(Target &target, Address start, 1096 Limit limit, Stream *error_strm_ptr, 1097 bool force_live_memory) { 1098 m_instruction_list.Clear(); 1099 1100 if (!start.IsValid()) 1101 return 0; 1102 1103 start = ResolveAddress(target, start); 1104 1105 addr_t byte_size = limit.value; 1106 if (limit.kind == Limit::Instructions) 1107 byte_size *= m_arch.GetMaximumOpcodeByteSize(); 1108 auto data_sp = std::make_shared<DataBufferHeap>(byte_size, '\0'); 1109 1110 Status error; 1111 lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; 1112 const size_t bytes_read = 1113 target.ReadMemory(start, data_sp->GetBytes(), data_sp->GetByteSize(), 1114 error, force_live_memory, &load_addr); 1115 const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; 1116 1117 if (bytes_read == 0) { 1118 if (error_strm_ptr) { 1119 if (const char *error_cstr = error.AsCString()) 1120 error_strm_ptr->Printf("error: %s\n", error_cstr); 1121 } 1122 return 0; 1123 } 1124 1125 if (bytes_read != data_sp->GetByteSize()) 1126 data_sp->SetByteSize(bytes_read); 1127 DataExtractor data(data_sp, m_arch.GetByteOrder(), 1128 m_arch.GetAddressByteSize()); 1129 return DecodeInstructions(start, data, 0, 1130 limit.kind == Limit::Instructions ? limit.value 1131 : UINT32_MAX, 1132 false, data_from_file); 1133 } 1134 1135 // Disassembler copy constructor 1136 Disassembler::Disassembler(const ArchSpec &arch, const char *flavor) 1137 : m_arch(arch), m_instruction_list(), m_flavor() { 1138 if (flavor == nullptr) 1139 m_flavor.assign("default"); 1140 else 1141 m_flavor.assign(flavor); 1142 1143 // If this is an arm variant that can only include thumb (T16, T32) 1144 // instructions, force the arch triple to be "thumbv.." instead of "armv..." 1145 if (arch.IsAlwaysThumbInstructions()) { 1146 std::string thumb_arch_name(arch.GetTriple().getArchName().str()); 1147 // Replace "arm" with "thumb" so we get all thumb variants correct 1148 if (thumb_arch_name.size() > 3) { 1149 thumb_arch_name.erase(0, 3); 1150 thumb_arch_name.insert(0, "thumb"); 1151 } 1152 m_arch.SetTriple(thumb_arch_name.c_str()); 1153 } 1154 } 1155 1156 Disassembler::~Disassembler() = default; 1157 1158 InstructionList &Disassembler::GetInstructionList() { 1159 return m_instruction_list; 1160 } 1161 1162 const InstructionList &Disassembler::GetInstructionList() const { 1163 return m_instruction_list; 1164 } 1165 1166 // Class PseudoInstruction 1167 1168 PseudoInstruction::PseudoInstruction() 1169 : Instruction(Address(), AddressClass::eUnknown), m_description() {} 1170 1171 PseudoInstruction::~PseudoInstruction() = default; 1172 1173 bool PseudoInstruction::DoesBranch() { 1174 // This is NOT a valid question for a pseudo instruction. 1175 return false; 1176 } 1177 1178 bool PseudoInstruction::HasDelaySlot() { 1179 // This is NOT a valid question for a pseudo instruction. 1180 return false; 1181 } 1182 1183 bool PseudoInstruction::IsLoad() { return false; } 1184 1185 bool PseudoInstruction::IsAuthenticated() { return false; } 1186 1187 size_t PseudoInstruction::Decode(const lldb_private::Disassembler &disassembler, 1188 const lldb_private::DataExtractor &data, 1189 lldb::offset_t data_offset) { 1190 return m_opcode.GetByteSize(); 1191 } 1192 1193 void PseudoInstruction::SetOpcode(size_t opcode_size, void *opcode_data) { 1194 if (!opcode_data) 1195 return; 1196 1197 switch (opcode_size) { 1198 case 8: { 1199 uint8_t value8 = *((uint8_t *)opcode_data); 1200 m_opcode.SetOpcode8(value8, eByteOrderInvalid); 1201 break; 1202 } 1203 case 16: { 1204 uint16_t value16 = *((uint16_t *)opcode_data); 1205 m_opcode.SetOpcode16(value16, eByteOrderInvalid); 1206 break; 1207 } 1208 case 32: { 1209 uint32_t value32 = *((uint32_t *)opcode_data); 1210 m_opcode.SetOpcode32(value32, eByteOrderInvalid); 1211 break; 1212 } 1213 case 64: { 1214 uint64_t value64 = *((uint64_t *)opcode_data); 1215 m_opcode.SetOpcode64(value64, eByteOrderInvalid); 1216 break; 1217 } 1218 default: 1219 break; 1220 } 1221 } 1222 1223 void PseudoInstruction::SetDescription(llvm::StringRef description) { 1224 m_description = std::string(description); 1225 } 1226 1227 Instruction::Operand Instruction::Operand::BuildRegister(ConstString &r) { 1228 Operand ret; 1229 ret.m_type = Type::Register; 1230 ret.m_register = r; 1231 return ret; 1232 } 1233 1234 Instruction::Operand Instruction::Operand::BuildImmediate(lldb::addr_t imm, 1235 bool neg) { 1236 Operand ret; 1237 ret.m_type = Type::Immediate; 1238 ret.m_immediate = imm; 1239 ret.m_negative = neg; 1240 return ret; 1241 } 1242 1243 Instruction::Operand Instruction::Operand::BuildImmediate(int64_t imm) { 1244 Operand ret; 1245 ret.m_type = Type::Immediate; 1246 if (imm < 0) { 1247 ret.m_immediate = -imm; 1248 ret.m_negative = true; 1249 } else { 1250 ret.m_immediate = imm; 1251 ret.m_negative = false; 1252 } 1253 return ret; 1254 } 1255 1256 Instruction::Operand 1257 Instruction::Operand::BuildDereference(const Operand &ref) { 1258 Operand ret; 1259 ret.m_type = Type::Dereference; 1260 ret.m_children = {ref}; 1261 return ret; 1262 } 1263 1264 Instruction::Operand Instruction::Operand::BuildSum(const Operand &lhs, 1265 const Operand &rhs) { 1266 Operand ret; 1267 ret.m_type = Type::Sum; 1268 ret.m_children = {lhs, rhs}; 1269 return ret; 1270 } 1271 1272 Instruction::Operand Instruction::Operand::BuildProduct(const Operand &lhs, 1273 const Operand &rhs) { 1274 Operand ret; 1275 ret.m_type = Type::Product; 1276 ret.m_children = {lhs, rhs}; 1277 return ret; 1278 } 1279 1280 std::function<bool(const Instruction::Operand &)> 1281 lldb_private::OperandMatchers::MatchBinaryOp( 1282 std::function<bool(const Instruction::Operand &)> base, 1283 std::function<bool(const Instruction::Operand &)> left, 1284 std::function<bool(const Instruction::Operand &)> right) { 1285 return [base, left, right](const Instruction::Operand &op) -> bool { 1286 return (base(op) && op.m_children.size() == 2 && 1287 ((left(op.m_children[0]) && right(op.m_children[1])) || 1288 (left(op.m_children[1]) && right(op.m_children[0])))); 1289 }; 1290 } 1291 1292 std::function<bool(const Instruction::Operand &)> 1293 lldb_private::OperandMatchers::MatchUnaryOp( 1294 std::function<bool(const Instruction::Operand &)> base, 1295 std::function<bool(const Instruction::Operand &)> child) { 1296 return [base, child](const Instruction::Operand &op) -> bool { 1297 return (base(op) && op.m_children.size() == 1 && child(op.m_children[0])); 1298 }; 1299 } 1300 1301 std::function<bool(const Instruction::Operand &)> 1302 lldb_private::OperandMatchers::MatchRegOp(const RegisterInfo &info) { 1303 return [&info](const Instruction::Operand &op) { 1304 return (op.m_type == Instruction::Operand::Type::Register && 1305 (op.m_register == ConstString(info.name) || 1306 op.m_register == ConstString(info.alt_name))); 1307 }; 1308 } 1309 1310 std::function<bool(const Instruction::Operand &)> 1311 lldb_private::OperandMatchers::FetchRegOp(ConstString ®) { 1312 return [®](const Instruction::Operand &op) { 1313 if (op.m_type != Instruction::Operand::Type::Register) { 1314 return false; 1315 } 1316 reg = op.m_register; 1317 return true; 1318 }; 1319 } 1320 1321 std::function<bool(const Instruction::Operand &)> 1322 lldb_private::OperandMatchers::MatchImmOp(int64_t imm) { 1323 return [imm](const Instruction::Operand &op) { 1324 return (op.m_type == Instruction::Operand::Type::Immediate && 1325 ((op.m_negative && op.m_immediate == (uint64_t)-imm) || 1326 (!op.m_negative && op.m_immediate == (uint64_t)imm))); 1327 }; 1328 } 1329 1330 std::function<bool(const Instruction::Operand &)> 1331 lldb_private::OperandMatchers::FetchImmOp(int64_t &imm) { 1332 return [&imm](const Instruction::Operand &op) { 1333 if (op.m_type != Instruction::Operand::Type::Immediate) { 1334 return false; 1335 } 1336 if (op.m_negative) { 1337 imm = -((int64_t)op.m_immediate); 1338 } else { 1339 imm = ((int64_t)op.m_immediate); 1340 } 1341 return true; 1342 }; 1343 } 1344 1345 std::function<bool(const Instruction::Operand &)> 1346 lldb_private::OperandMatchers::MatchOpType(Instruction::Operand::Type type) { 1347 return [type](const Instruction::Operand &op) { return op.m_type == type; }; 1348 } 1349