1 //===-- CommandObjectDisassemble.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 "CommandObjectDisassemble.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 #include "lldb/Core/AddressRange.h" 17 #include "lldb/Interpreter/Args.h" 18 #include "lldb/Interpreter/CommandCompletions.h" 19 #include "lldb/Interpreter/CommandInterpreter.h" 20 #include "lldb/Interpreter/CommandReturnObject.h" 21 #include "lldb/Core/Disassembler.h" 22 #include "lldb/Interpreter/Options.h" 23 #include "lldb/Core/SourceManager.h" 24 #include "lldb/Target/StackFrame.h" 25 #include "lldb/Symbol/Symbol.h" 26 #include "lldb/Target/Process.h" 27 #include "lldb/Target/Target.h" 28 29 #define DEFAULT_DISASM_BYTE_SIZE 32 30 #define DEFAULT_DISASM_NUM_INS 4 31 32 using namespace lldb; 33 using namespace lldb_private; 34 35 CommandObjectDisassemble::CommandOptions::CommandOptions (CommandInterpreter &interpreter) : 36 Options(interpreter), 37 num_lines_context(0), 38 num_instructions (0), 39 func_name(), 40 cur_function (false), 41 start_addr(), 42 end_addr (), 43 at_pc (false), 44 frame_line (false), 45 plugin_name (), 46 arch(), 47 some_location_specified (false) 48 { 49 OptionParsingStarting(); 50 } 51 52 CommandObjectDisassemble::CommandOptions::~CommandOptions () 53 { 54 } 55 56 Error 57 CommandObjectDisassemble::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg) 58 { 59 Error error; 60 61 char short_option = (char) m_getopt_table[option_idx].val; 62 63 bool success; 64 65 switch (short_option) 66 { 67 case 'm': 68 show_mixed = true; 69 break; 70 71 case 'C': 72 num_lines_context = Args::StringToUInt32(option_arg, 0, 0, &success); 73 if (!success) 74 error.SetErrorStringWithFormat ("invalid num context lines string: \"%s\"", option_arg); 75 break; 76 77 case 'c': 78 num_instructions = Args::StringToUInt32(option_arg, 0, 0, &success); 79 if (!success) 80 error.SetErrorStringWithFormat ("invalid num of instructions string: \"%s\"", option_arg); 81 break; 82 83 case 'b': 84 show_bytes = true; 85 break; 86 87 case 's': 88 start_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS, 0); 89 if (start_addr == LLDB_INVALID_ADDRESS) 90 start_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS, 16); 91 92 if (start_addr == LLDB_INVALID_ADDRESS) 93 error.SetErrorStringWithFormat ("invalid start address string '%s'", option_arg); 94 some_location_specified = true; 95 break; 96 case 'e': 97 end_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS, 0); 98 if (end_addr == LLDB_INVALID_ADDRESS) 99 end_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS, 16); 100 101 if (end_addr == LLDB_INVALID_ADDRESS) 102 error.SetErrorStringWithFormat ("invalid end address string '%s'", option_arg); 103 break; 104 some_location_specified = true; 105 case 'n': 106 func_name.assign (option_arg); 107 some_location_specified = true; 108 break; 109 110 case 'p': 111 at_pc = true; 112 some_location_specified = true; 113 break; 114 115 case 'l': 116 frame_line = true; 117 // Disassemble the current source line kind of implies showing mixed 118 // source code context. 119 show_mixed = true; 120 some_location_specified = true; 121 break; 122 123 case 'P': 124 plugin_name.assign (option_arg); 125 break; 126 127 case 'r': 128 raw = true; 129 break; 130 131 case 'f': 132 cur_function = true; 133 some_location_specified = true; 134 break; 135 136 case 'a': 137 if (!arch.SetTriple (option_arg, m_interpreter.GetPlatform (true).get())) 138 arch.SetTriple (option_arg); 139 break; 140 141 default: 142 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option); 143 break; 144 } 145 146 return error; 147 } 148 149 void 150 CommandObjectDisassemble::CommandOptions::OptionParsingStarting () 151 { 152 show_mixed = false; 153 show_bytes = false; 154 num_lines_context = 0; 155 num_instructions = 0; 156 func_name.clear(); 157 cur_function = false; 158 at_pc = false; 159 frame_line = false; 160 start_addr = LLDB_INVALID_ADDRESS; 161 end_addr = LLDB_INVALID_ADDRESS; 162 raw = false; 163 plugin_name.clear(); 164 arch.Clear(); 165 some_location_specified = false; 166 } 167 168 Error 169 CommandObjectDisassemble::CommandOptions::OptionParsingFinished () 170 { 171 if (!some_location_specified) 172 at_pc = true; 173 return Error(); 174 175 } 176 177 const OptionDefinition* 178 CommandObjectDisassemble::CommandOptions::GetDefinitions () 179 { 180 return g_option_table; 181 } 182 183 OptionDefinition 184 CommandObjectDisassemble::CommandOptions::g_option_table[] = 185 { 186 { LLDB_OPT_SET_ALL , false , "bytes", 'b', no_argument , NULL, 0, eArgTypeNone, "Show opcode bytes when disassembling."}, 187 { LLDB_OPT_SET_ALL , false , "context", 'C', required_argument , NULL, 0, eArgTypeNumLines, "Number of context lines of source to show."}, 188 { LLDB_OPT_SET_ALL , false , "mixed", 'm', no_argument , NULL, 0, eArgTypeNone, "Enable mixed source and assembly display."}, 189 { LLDB_OPT_SET_ALL , false , "raw", 'r', no_argument , NULL, 0, eArgTypeNone, "Print raw disassembly with no symbol information."}, 190 { LLDB_OPT_SET_ALL , false , "plugin", 'P', required_argument , NULL, 0, eArgTypePlugin, "Name of the disassembler plugin you want to use."}, 191 { LLDB_OPT_SET_ALL , false , "arch", 'a', required_argument , NULL, 0, eArgTypeArchitecture,"Specify the architecture to use from cross disassembly."}, 192 { LLDB_OPT_SET_1 | 193 LLDB_OPT_SET_2 , true , "start-address" , 's', required_argument , NULL, 0, eArgTypeStartAddress,"Address at which to start disassembling."}, 194 { LLDB_OPT_SET_1 , false , "end-address" , 'e', required_argument , NULL, 0, eArgTypeEndAddress, "Address at which to end disassembling."}, 195 { LLDB_OPT_SET_2 | 196 LLDB_OPT_SET_3 | 197 LLDB_OPT_SET_4 | 198 LLDB_OPT_SET_5 , false , "count", 'c', required_argument , NULL, 0, eArgTypeNumLines, "Number of instructions to display."}, 199 { LLDB_OPT_SET_3 , false , "name", 'n', required_argument , NULL, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Disassemble entire contents of the given function name."}, 200 { LLDB_OPT_SET_4 , false , "frame", 'f', no_argument , NULL, 0, eArgTypeNone, "Disassemble from the start of the current frame's function."}, 201 { LLDB_OPT_SET_5 , false , "pc", 'p', no_argument , NULL, 0, eArgTypeNone, "Disassemble around the current pc."}, 202 { LLDB_OPT_SET_6 , false , "line", 'l', no_argument , NULL, 0, eArgTypeNone, "Disassemble the current frame's current source line instructions if there debug line table information, else disasemble around the pc."}, 203 { 0 , false , NULL, 0, 0 , NULL, 0, eArgTypeNone, NULL } 204 }; 205 206 207 208 //------------------------------------------------------------------------- 209 // CommandObjectDisassemble 210 //------------------------------------------------------------------------- 211 212 CommandObjectDisassemble::CommandObjectDisassemble (CommandInterpreter &interpreter) : 213 CommandObject (interpreter, 214 "disassemble", 215 "Disassemble bytes in the current function, or elsewhere in the executable program as specified by the user.", 216 "disassemble [<cmd-options>]"), 217 m_options (interpreter) 218 { 219 } 220 221 CommandObjectDisassemble::~CommandObjectDisassemble() 222 { 223 } 224 225 bool 226 CommandObjectDisassemble::Execute 227 ( 228 Args& command, 229 CommandReturnObject &result 230 ) 231 { 232 Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); 233 if (target == NULL) 234 { 235 result.AppendError ("invalid target, create a debug target using the 'target create' command"); 236 result.SetStatus (eReturnStatusFailed); 237 return false; 238 } 239 if (!m_options.arch.IsValid()) 240 m_options.arch = target->GetArchitecture(); 241 242 if (!m_options.arch.IsValid()) 243 { 244 result.AppendError ("use the --arch option or set the target architecure to disassemble"); 245 result.SetStatus (eReturnStatusFailed); 246 return false; 247 } 248 249 const char *plugin_name = m_options.GetPluginName (); 250 Disassembler *disassembler = Disassembler::FindPlugin(m_options.arch, plugin_name); 251 252 if (disassembler == NULL) 253 { 254 if (plugin_name) 255 result.AppendErrorWithFormat ("Unable to find Disassembler plug-in named '%s' that supports the '%s' architecture.\n", 256 plugin_name, 257 m_options.arch.GetArchitectureName()); 258 else 259 result.AppendErrorWithFormat ("Unable to find Disassembler plug-in for the '%s' architecture.\n", 260 m_options.arch.GetArchitectureName()); 261 result.SetStatus (eReturnStatusFailed); 262 return false; 263 } 264 265 result.SetStatus (eReturnStatusSuccessFinishResult); 266 267 if (command.GetArgumentCount() != 0) 268 { 269 result.AppendErrorWithFormat ("\"disassemble\" arguments are specified as options.\n"); 270 GetOptions()->GenerateOptionUsage (result.GetErrorStream(), this); 271 result.SetStatus (eReturnStatusFailed); 272 return false; 273 } 274 275 if (m_options.show_mixed && m_options.num_lines_context == 0) 276 m_options.num_lines_context = 1; 277 278 ExecutionContext exe_ctx(m_interpreter.GetExecutionContext()); 279 // Always show the PC in the disassembly 280 uint32_t options = Disassembler::eOptionMarkPCAddress; 281 282 // Mark the source line for the current PC only if we are doing mixed source and assembly 283 if (m_options.show_mixed) 284 options |= Disassembler::eOptionMarkPCSourceLine; 285 286 if (m_options.show_bytes) 287 options |= Disassembler::eOptionShowBytes; 288 289 if (m_options.raw) 290 options |= Disassembler::eOptionRawOuput; 291 292 if (!m_options.func_name.empty()) 293 { 294 ConstString name(m_options.func_name.c_str()); 295 296 if (Disassembler::Disassemble (m_interpreter.GetDebugger(), 297 m_options.arch, 298 plugin_name, 299 exe_ctx, 300 name, 301 NULL, // Module * 302 m_options.num_instructions, 303 m_options.show_mixed ? m_options.num_lines_context : 0, 304 options, 305 result.GetOutputStream())) 306 { 307 result.SetStatus (eReturnStatusSuccessFinishResult); 308 } 309 else 310 { 311 result.AppendErrorWithFormat ("Unable to find symbol with name '%s'.\n", name.GetCString()); 312 result.SetStatus (eReturnStatusFailed); 313 } 314 } 315 else 316 { 317 AddressRange range; 318 StackFrame *frame = exe_ctx.GetFramePtr(); 319 if (m_options.frame_line) 320 { 321 if (frame == NULL) 322 { 323 result.AppendError ("Cannot disassemble around the current line without a selected frame.\n"); 324 result.SetStatus (eReturnStatusFailed); 325 return false; 326 } 327 LineEntry pc_line_entry (frame->GetSymbolContext(eSymbolContextLineEntry).line_entry); 328 if (pc_line_entry.IsValid()) 329 { 330 range = pc_line_entry.range; 331 } 332 else 333 { 334 m_options.at_pc = true; // No line entry, so just disassemble around the current pc 335 m_options.show_mixed = false; 336 } 337 } 338 else if (m_options.cur_function) 339 { 340 if (frame == NULL) 341 { 342 result.AppendError ("Cannot disassemble around the current function without a selected frame.\n"); 343 result.SetStatus (eReturnStatusFailed); 344 return false; 345 } 346 Symbol *symbol = frame->GetSymbolContext(eSymbolContextSymbol).symbol; 347 if (symbol) 348 { 349 range.GetBaseAddress() = symbol->GetAddress(); 350 range.SetByteSize(symbol->GetByteSize()); 351 } 352 } 353 354 // Did the "m_options.frame_line" find a valid range already? If so 355 // skip the rest... 356 if (range.GetByteSize() == 0) 357 { 358 if (m_options.at_pc) 359 { 360 if (frame == NULL) 361 { 362 result.AppendError ("Cannot disassemble around the current PC without a selected frame.\n"); 363 result.SetStatus (eReturnStatusFailed); 364 return false; 365 } 366 range.GetBaseAddress() = frame->GetFrameCodeAddress(); 367 if (m_options.num_instructions == 0) 368 { 369 // Disassembling at the PC always disassembles some number of instructions (not the whole function). 370 m_options.num_instructions = DEFAULT_DISASM_NUM_INS; 371 } 372 } 373 else 374 { 375 range.GetBaseAddress().SetOffset (m_options.start_addr); 376 if (range.GetBaseAddress().IsValid()) 377 { 378 if (m_options.end_addr != LLDB_INVALID_ADDRESS) 379 { 380 if (m_options.end_addr <= m_options.start_addr) 381 { 382 result.AppendErrorWithFormat ("End address before start address.\n"); 383 result.SetStatus (eReturnStatusFailed); 384 return false; 385 } 386 range.SetByteSize (m_options.end_addr - m_options.start_addr); 387 } 388 } 389 } 390 } 391 392 if (m_options.num_instructions != 0) 393 { 394 if (!range.GetBaseAddress().IsValid()) 395 { 396 // The default action is to disassemble the current frame function. 397 if (frame) 398 { 399 SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); 400 if (sc.function) 401 range.GetBaseAddress() = sc.function->GetAddressRange().GetBaseAddress(); 402 else if (sc.symbol && sc.symbol->ValueIsAddress()) 403 range.GetBaseAddress() = sc.symbol->GetAddress(); 404 else 405 range.GetBaseAddress() = frame->GetFrameCodeAddress(); 406 } 407 408 if (!range.GetBaseAddress().IsValid()) 409 { 410 result.AppendError ("invalid frame"); 411 result.SetStatus (eReturnStatusFailed); 412 return false; 413 } 414 } 415 416 if (Disassembler::Disassemble (m_interpreter.GetDebugger(), 417 m_options.arch, 418 plugin_name, 419 exe_ctx, 420 range.GetBaseAddress(), 421 m_options.num_instructions, 422 m_options.show_mixed ? m_options.num_lines_context : 0, 423 options, 424 result.GetOutputStream())) 425 { 426 result.SetStatus (eReturnStatusSuccessFinishResult); 427 } 428 else 429 { 430 result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8llx.\n", m_options.start_addr); 431 result.SetStatus (eReturnStatusFailed); 432 } 433 } 434 else 435 { 436 if (!range.GetBaseAddress().IsValid()) 437 { 438 // The default action is to disassemble the current frame function. 439 if (frame) 440 { 441 SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); 442 if (sc.function) 443 range = sc.function->GetAddressRange(); 444 else if (sc.symbol && sc.symbol->ValueIsAddress()) 445 { 446 range.GetBaseAddress() = sc.symbol->GetAddress(); 447 range.SetByteSize (sc.symbol->GetByteSize()); 448 } 449 else 450 range.GetBaseAddress() = frame->GetFrameCodeAddress(); 451 } 452 else 453 { 454 result.AppendError ("invalid frame"); 455 result.SetStatus (eReturnStatusFailed); 456 return false; 457 } 458 } 459 if (range.GetByteSize() == 0) 460 range.SetByteSize(DEFAULT_DISASM_BYTE_SIZE); 461 462 if (Disassembler::Disassemble (m_interpreter.GetDebugger(), 463 m_options.arch, 464 plugin_name, 465 exe_ctx, 466 range, 467 m_options.num_instructions, 468 m_options.show_mixed ? m_options.num_lines_context : 0, 469 options, 470 result.GetOutputStream())) 471 { 472 result.SetStatus (eReturnStatusSuccessFinishResult); 473 } 474 else 475 { 476 result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8llx.\n", m_options.start_addr); 477 result.SetStatus (eReturnStatusFailed); 478 } 479 } 480 } 481 482 return result.Succeeded(); 483 } 484