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