1 //===-- CommandObjectDisassemble.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 "CommandObjectDisassemble.h" 10 #include "lldb/Core/AddressRange.h" 11 #include "lldb/Core/Disassembler.h" 12 #include "lldb/Core/Module.h" 13 #include "lldb/Host/OptionParser.h" 14 #include "lldb/Interpreter/CommandInterpreter.h" 15 #include "lldb/Interpreter/CommandReturnObject.h" 16 #include "lldb/Interpreter/OptionArgParser.h" 17 #include "lldb/Interpreter/Options.h" 18 #include "lldb/Symbol/Function.h" 19 #include "lldb/Symbol/Symbol.h" 20 #include "lldb/Target/SectionLoadList.h" 21 #include "lldb/Target/StackFrame.h" 22 #include "lldb/Target/Target.h" 23 24 static constexpr unsigned default_disasm_byte_size = 32; 25 static constexpr unsigned default_disasm_num_ins = 4; 26 27 using namespace lldb; 28 using namespace lldb_private; 29 30 #define LLDB_OPTIONS_disassemble 31 #include "CommandOptions.inc" 32 33 CommandObjectDisassemble::CommandOptions::CommandOptions() { 34 OptionParsingStarting(nullptr); 35 } 36 37 CommandObjectDisassemble::CommandOptions::~CommandOptions() = default; 38 39 Status CommandObjectDisassemble::CommandOptions::SetOptionValue( 40 uint32_t option_idx, llvm::StringRef option_arg, 41 ExecutionContext *execution_context) { 42 Status error; 43 44 const int short_option = m_getopt_table[option_idx].val; 45 46 switch (short_option) { 47 case 'm': 48 show_mixed = true; 49 break; 50 51 case 'C': 52 if (option_arg.getAsInteger(0, num_lines_context)) 53 error.SetErrorStringWithFormat("invalid num context lines string: \"%s\"", 54 option_arg.str().c_str()); 55 break; 56 57 case 'c': 58 if (option_arg.getAsInteger(0, num_instructions)) 59 error.SetErrorStringWithFormat( 60 "invalid num of instructions string: \"%s\"", 61 option_arg.str().c_str()); 62 break; 63 64 case 'b': 65 show_bytes = true; 66 break; 67 68 case 's': { 69 start_addr = OptionArgParser::ToAddress(execution_context, option_arg, 70 LLDB_INVALID_ADDRESS, &error); 71 if (start_addr != LLDB_INVALID_ADDRESS) 72 some_location_specified = true; 73 } break; 74 case 'e': { 75 end_addr = OptionArgParser::ToAddress(execution_context, option_arg, 76 LLDB_INVALID_ADDRESS, &error); 77 if (end_addr != LLDB_INVALID_ADDRESS) 78 some_location_specified = true; 79 } break; 80 81 case 'n': 82 func_name.assign(std::string(option_arg)); 83 some_location_specified = true; 84 break; 85 86 case 'p': 87 at_pc = true; 88 some_location_specified = true; 89 break; 90 91 case 'l': 92 frame_line = true; 93 // Disassemble the current source line kind of implies showing mixed source 94 // code context. 95 show_mixed = true; 96 some_location_specified = true; 97 break; 98 99 case 'P': 100 plugin_name.assign(std::string(option_arg)); 101 break; 102 103 case 'F': { 104 TargetSP target_sp = 105 execution_context ? execution_context->GetTargetSP() : TargetSP(); 106 if (target_sp && (target_sp->GetArchitecture().GetTriple().getArch() == 107 llvm::Triple::x86 || 108 target_sp->GetArchitecture().GetTriple().getArch() == 109 llvm::Triple::x86_64)) { 110 flavor_string.assign(std::string(option_arg)); 111 } else 112 error.SetErrorStringWithFormat("Disassembler flavors are currently only " 113 "supported for x86 and x86_64 targets."); 114 break; 115 } 116 117 case 'r': 118 raw = true; 119 break; 120 121 case 'f': 122 current_function = true; 123 some_location_specified = true; 124 break; 125 126 case 'A': 127 if (execution_context) { 128 const auto &target_sp = execution_context->GetTargetSP(); 129 auto platform_ptr = target_sp ? target_sp->GetPlatform().get() : nullptr; 130 arch = Platform::GetAugmentedArchSpec(platform_ptr, option_arg); 131 } 132 break; 133 134 case 'a': { 135 symbol_containing_addr = OptionArgParser::ToAddress( 136 execution_context, option_arg, LLDB_INVALID_ADDRESS, &error); 137 if (symbol_containing_addr != LLDB_INVALID_ADDRESS) { 138 some_location_specified = true; 139 } 140 } break; 141 142 case '\x01': 143 force = true; 144 break; 145 146 default: 147 llvm_unreachable("Unimplemented option"); 148 } 149 150 return error; 151 } 152 153 void CommandObjectDisassemble::CommandOptions::OptionParsingStarting( 154 ExecutionContext *execution_context) { 155 show_mixed = false; 156 show_bytes = false; 157 num_lines_context = 0; 158 num_instructions = 0; 159 func_name.clear(); 160 current_function = false; 161 at_pc = false; 162 frame_line = false; 163 start_addr = LLDB_INVALID_ADDRESS; 164 end_addr = LLDB_INVALID_ADDRESS; 165 symbol_containing_addr = LLDB_INVALID_ADDRESS; 166 raw = false; 167 plugin_name.clear(); 168 169 Target *target = 170 execution_context ? execution_context->GetTargetPtr() : nullptr; 171 172 // This is a hack till we get the ability to specify features based on 173 // architecture. For now GetDisassemblyFlavor is really only valid for x86 174 // (and for the llvm assembler plugin, but I'm papering over that since that 175 // is the only disassembler plugin we have... 176 if (target) { 177 if (target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86 || 178 target->GetArchitecture().GetTriple().getArch() == 179 llvm::Triple::x86_64) { 180 flavor_string.assign(target->GetDisassemblyFlavor()); 181 } else 182 flavor_string.assign("default"); 183 184 } else 185 flavor_string.assign("default"); 186 187 arch.Clear(); 188 some_location_specified = false; 189 force = false; 190 } 191 192 Status CommandObjectDisassemble::CommandOptions::OptionParsingFinished( 193 ExecutionContext *execution_context) { 194 if (!some_location_specified) 195 current_function = true; 196 return Status(); 197 } 198 199 llvm::ArrayRef<OptionDefinition> 200 CommandObjectDisassemble::CommandOptions::GetDefinitions() { 201 return llvm::makeArrayRef(g_disassemble_options); 202 } 203 204 // CommandObjectDisassemble 205 206 CommandObjectDisassemble::CommandObjectDisassemble( 207 CommandInterpreter &interpreter) 208 : CommandObjectParsed( 209 interpreter, "disassemble", 210 "Disassemble specified instructions in the current target. " 211 "Defaults to the current function for the current thread and " 212 "stack frame.", 213 "disassemble [<cmd-options>]", eCommandRequiresTarget), 214 m_options() {} 215 216 CommandObjectDisassemble::~CommandObjectDisassemble() = default; 217 218 llvm::Error CommandObjectDisassemble::CheckRangeSize(const AddressRange &range, 219 llvm::StringRef what) { 220 if (m_options.num_instructions > 0 || m_options.force || 221 range.GetByteSize() < GetDebugger().GetStopDisassemblyMaxSize()) 222 return llvm::Error::success(); 223 StreamString msg; 224 msg << "Not disassembling " << what << " because it is very large "; 225 range.Dump(&msg, &GetSelectedTarget(), Address::DumpStyleLoadAddress, 226 Address::DumpStyleFileAddress); 227 msg << ". To disassemble specify an instruction count limit, start/stop " 228 "addresses or use the --force option."; 229 return llvm::createStringError(llvm::inconvertibleErrorCode(), 230 msg.GetString()); 231 } 232 233 llvm::Expected<std::vector<AddressRange>> 234 CommandObjectDisassemble::GetContainingAddressRanges() { 235 std::vector<AddressRange> ranges; 236 const auto &get_range = [&](Address addr) { 237 ModuleSP module_sp(addr.GetModule()); 238 SymbolContext sc; 239 bool resolve_tail_call_address = true; 240 addr.GetModule()->ResolveSymbolContextForAddress( 241 addr, eSymbolContextEverything, sc, resolve_tail_call_address); 242 if (sc.function || sc.symbol) { 243 AddressRange range; 244 sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0, 245 false, range); 246 ranges.push_back(range); 247 } 248 }; 249 250 Target &target = GetSelectedTarget(); 251 if (!target.GetSectionLoadList().IsEmpty()) { 252 Address symbol_containing_address; 253 if (target.GetSectionLoadList().ResolveLoadAddress( 254 m_options.symbol_containing_addr, symbol_containing_address)) { 255 get_range(symbol_containing_address); 256 } 257 } else { 258 for (lldb::ModuleSP module_sp : target.GetImages().Modules()) { 259 Address file_address; 260 if (module_sp->ResolveFileAddress(m_options.symbol_containing_addr, 261 file_address)) { 262 get_range(file_address); 263 } 264 } 265 } 266 267 if (ranges.empty()) { 268 return llvm::createStringError( 269 llvm::inconvertibleErrorCode(), 270 "Could not find function bounds for address 0x%" PRIx64, 271 m_options.symbol_containing_addr); 272 } 273 274 if (llvm::Error err = CheckRangeSize(ranges[0], "the function")) 275 return std::move(err); 276 return ranges; 277 } 278 279 llvm::Expected<std::vector<AddressRange>> 280 CommandObjectDisassemble::GetCurrentFunctionRanges() { 281 StackFrame *frame = m_exe_ctx.GetFramePtr(); 282 if (!frame) { 283 return llvm::createStringError(llvm::inconvertibleErrorCode(), 284 "Cannot disassemble around the current " 285 "function without a selected frame.\n"); 286 } 287 SymbolContext sc( 288 frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); 289 AddressRange range; 290 if (sc.function) 291 range = sc.function->GetAddressRange(); 292 else if (sc.symbol && sc.symbol->ValueIsAddress()) { 293 range = {sc.symbol->GetAddress(), sc.symbol->GetByteSize()}; 294 } else 295 range = {frame->GetFrameCodeAddress(), default_disasm_byte_size}; 296 297 if (llvm::Error err = CheckRangeSize(range, "the current function")) 298 return std::move(err); 299 return std::vector<AddressRange>{range}; 300 } 301 302 llvm::Expected<std::vector<AddressRange>> 303 CommandObjectDisassemble::GetCurrentLineRanges() { 304 StackFrame *frame = m_exe_ctx.GetFramePtr(); 305 if (!frame) { 306 return llvm::createStringError(llvm::inconvertibleErrorCode(), 307 "Cannot disassemble around the current " 308 "line without a selected frame.\n"); 309 } 310 311 LineEntry pc_line_entry( 312 frame->GetSymbolContext(eSymbolContextLineEntry).line_entry); 313 if (pc_line_entry.IsValid()) 314 return std::vector<AddressRange>{pc_line_entry.range}; 315 316 // No line entry, so just disassemble around the current pc 317 m_options.show_mixed = false; 318 return GetPCRanges(); 319 } 320 321 llvm::Expected<std::vector<AddressRange>> 322 CommandObjectDisassemble::GetNameRanges(CommandReturnObject &result) { 323 ConstString name(m_options.func_name.c_str()); 324 325 ModuleFunctionSearchOptions function_options; 326 function_options.include_symbols = true; 327 function_options.include_inlines = true; 328 329 // Find functions matching the given name. 330 SymbolContextList sc_list; 331 GetSelectedTarget().GetImages().FindFunctions(name, eFunctionNameTypeAuto, 332 function_options, sc_list); 333 334 std::vector<AddressRange> ranges; 335 llvm::Error range_errs = llvm::Error::success(); 336 AddressRange range; 337 const uint32_t scope = 338 eSymbolContextBlock | eSymbolContextFunction | eSymbolContextSymbol; 339 const bool use_inline_block_range = true; 340 for (SymbolContext sc : sc_list.SymbolContexts()) { 341 for (uint32_t range_idx = 0; 342 sc.GetAddressRange(scope, range_idx, use_inline_block_range, range); 343 ++range_idx) { 344 if (llvm::Error err = CheckRangeSize(range, "a range")) 345 range_errs = joinErrors(std::move(range_errs), std::move(err)); 346 else 347 ranges.push_back(range); 348 } 349 } 350 if (ranges.empty()) { 351 if (range_errs) 352 return std::move(range_errs); 353 return llvm::createStringError(llvm::inconvertibleErrorCode(), 354 "Unable to find symbol with name '%s'.\n", 355 name.GetCString()); 356 } 357 if (range_errs) 358 result.AppendWarning(toString(std::move(range_errs))); 359 return ranges; 360 } 361 362 llvm::Expected<std::vector<AddressRange>> 363 CommandObjectDisassemble::GetPCRanges() { 364 StackFrame *frame = m_exe_ctx.GetFramePtr(); 365 if (!frame) { 366 return llvm::createStringError(llvm::inconvertibleErrorCode(), 367 "Cannot disassemble around the current " 368 "PC without a selected frame.\n"); 369 } 370 371 if (m_options.num_instructions == 0) { 372 // Disassembling at the PC always disassembles some number of 373 // instructions (not the whole function). 374 m_options.num_instructions = default_disasm_num_ins; 375 } 376 return std::vector<AddressRange>{{frame->GetFrameCodeAddress(), 0}}; 377 } 378 379 llvm::Expected<std::vector<AddressRange>> 380 CommandObjectDisassemble::GetStartEndAddressRanges() { 381 addr_t size = 0; 382 if (m_options.end_addr != LLDB_INVALID_ADDRESS) { 383 if (m_options.end_addr <= m_options.start_addr) { 384 return llvm::createStringError(llvm::inconvertibleErrorCode(), 385 "End address before start address."); 386 } 387 size = m_options.end_addr - m_options.start_addr; 388 } 389 return std::vector<AddressRange>{{Address(m_options.start_addr), size}}; 390 } 391 392 llvm::Expected<std::vector<AddressRange>> 393 CommandObjectDisassemble::GetRangesForSelectedMode( 394 CommandReturnObject &result) { 395 if (m_options.symbol_containing_addr != LLDB_INVALID_ADDRESS) 396 return CommandObjectDisassemble::GetContainingAddressRanges(); 397 if (m_options.current_function) 398 return CommandObjectDisassemble::GetCurrentFunctionRanges(); 399 if (m_options.frame_line) 400 return CommandObjectDisassemble::GetCurrentLineRanges(); 401 if (!m_options.func_name.empty()) 402 return CommandObjectDisassemble::GetNameRanges(result); 403 if (m_options.start_addr != LLDB_INVALID_ADDRESS) 404 return CommandObjectDisassemble::GetStartEndAddressRanges(); 405 return CommandObjectDisassemble::GetPCRanges(); 406 } 407 408 bool CommandObjectDisassemble::DoExecute(Args &command, 409 CommandReturnObject &result) { 410 Target *target = &GetSelectedTarget(); 411 412 if (!m_options.arch.IsValid()) 413 m_options.arch = target->GetArchitecture(); 414 415 if (!m_options.arch.IsValid()) { 416 result.AppendError( 417 "use the --arch option or set the target architecture to disassemble"); 418 return false; 419 } 420 421 const char *plugin_name = m_options.GetPluginName(); 422 const char *flavor_string = m_options.GetFlavorString(); 423 424 DisassemblerSP disassembler = 425 Disassembler::FindPlugin(m_options.arch, flavor_string, plugin_name); 426 427 if (!disassembler) { 428 if (plugin_name) { 429 result.AppendErrorWithFormat( 430 "Unable to find Disassembler plug-in named '%s' that supports the " 431 "'%s' architecture.\n", 432 plugin_name, m_options.arch.GetArchitectureName()); 433 } else 434 result.AppendErrorWithFormat( 435 "Unable to find Disassembler plug-in for the '%s' architecture.\n", 436 m_options.arch.GetArchitectureName()); 437 return false; 438 } else if (flavor_string != nullptr && !disassembler->FlavorValidForArchSpec( 439 m_options.arch, flavor_string)) 440 result.AppendWarningWithFormat( 441 "invalid disassembler flavor \"%s\", using default.\n", flavor_string); 442 443 result.SetStatus(eReturnStatusSuccessFinishResult); 444 445 if (!command.empty()) { 446 result.AppendErrorWithFormat( 447 "\"disassemble\" arguments are specified as options.\n"); 448 const int terminal_width = 449 GetCommandInterpreter().GetDebugger().GetTerminalWidth(); 450 GetOptions()->GenerateOptionUsage(result.GetErrorStream(), this, 451 terminal_width); 452 return false; 453 } 454 455 if (m_options.show_mixed && m_options.num_lines_context == 0) 456 m_options.num_lines_context = 2; 457 458 // Always show the PC in the disassembly 459 uint32_t options = Disassembler::eOptionMarkPCAddress; 460 461 // Mark the source line for the current PC only if we are doing mixed source 462 // and assembly 463 if (m_options.show_mixed) 464 options |= Disassembler::eOptionMarkPCSourceLine; 465 466 if (m_options.show_bytes) 467 options |= Disassembler::eOptionShowBytes; 468 469 if (m_options.raw) 470 options |= Disassembler::eOptionRawOuput; 471 472 llvm::Expected<std::vector<AddressRange>> ranges = 473 GetRangesForSelectedMode(result); 474 if (!ranges) { 475 result.AppendError(toString(ranges.takeError())); 476 return result.Succeeded(); 477 } 478 479 bool print_sc_header = ranges->size() > 1; 480 for (AddressRange cur_range : *ranges) { 481 Disassembler::Limit limit; 482 if (m_options.num_instructions == 0) { 483 limit = {Disassembler::Limit::Bytes, cur_range.GetByteSize()}; 484 if (limit.value == 0) 485 limit.value = default_disasm_byte_size; 486 } else { 487 limit = {Disassembler::Limit::Instructions, m_options.num_instructions}; 488 } 489 if (Disassembler::Disassemble( 490 GetDebugger(), m_options.arch, plugin_name, flavor_string, 491 m_exe_ctx, cur_range.GetBaseAddress(), limit, m_options.show_mixed, 492 m_options.show_mixed ? m_options.num_lines_context : 0, options, 493 result.GetOutputStream())) { 494 result.SetStatus(eReturnStatusSuccessFinishResult); 495 } else { 496 if (m_options.symbol_containing_addr != LLDB_INVALID_ADDRESS) { 497 result.AppendErrorWithFormat( 498 "Failed to disassemble memory in function at 0x%8.8" PRIx64 ".\n", 499 m_options.symbol_containing_addr); 500 } else { 501 result.AppendErrorWithFormat( 502 "Failed to disassemble memory at 0x%8.8" PRIx64 ".\n", 503 cur_range.GetBaseAddress().GetLoadAddress(target)); 504 } 505 } 506 if (print_sc_header) 507 result.GetOutputStream() << "\n"; 508 } 509 510 return result.Succeeded(); 511 } 512