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