1 //===-- DisassemblerLLVMC.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 "DisassemblerLLVMC.h"
10
11 #include "llvm-c/Disassembler.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/MC/MCAsmInfo.h"
14 #include "llvm/MC/MCContext.h"
15 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
16 #include "llvm/MC/MCDisassembler/MCExternalSymbolizer.h"
17 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
18 #include "llvm/MC/MCInst.h"
19 #include "llvm/MC/MCInstPrinter.h"
20 #include "llvm/MC/MCInstrInfo.h"
21 #include "llvm/MC/MCRegisterInfo.h"
22 #include "llvm/MC/MCSubtargetInfo.h"
23 #include "llvm/MC/MCTargetOptions.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/ScopedPrinter.h"
26 #include "llvm/Support/TargetRegistry.h"
27 #include "llvm/Support/TargetSelect.h"
28
29 #include "lldb/Core/Address.h"
30 #include "lldb/Core/Module.h"
31 #include "lldb/Symbol/SymbolContext.h"
32 #include "lldb/Target/ExecutionContext.h"
33 #include "lldb/Target/Process.h"
34 #include "lldb/Target/RegisterContext.h"
35 #include "lldb/Target/SectionLoadList.h"
36 #include "lldb/Target/StackFrame.h"
37 #include "lldb/Target/Target.h"
38 #include "lldb/Utility/DataExtractor.h"
39 #include "lldb/Utility/Log.h"
40 #include "lldb/Utility/RegularExpression.h"
41 #include "lldb/Utility/Stream.h"
42
43 using namespace lldb;
44 using namespace lldb_private;
45
46 class DisassemblerLLVMC::MCDisasmInstance {
47 public:
48 static std::unique_ptr<MCDisasmInstance>
49 Create(const char *triple, const char *cpu, const char *features_str,
50 unsigned flavor, DisassemblerLLVMC &owner);
51
52 ~MCDisasmInstance() = default;
53
54 uint64_t GetMCInst(const uint8_t *opcode_data, size_t opcode_data_len,
55 lldb::addr_t pc, llvm::MCInst &mc_inst) const;
56 void PrintMCInst(llvm::MCInst &mc_inst, std::string &inst_string,
57 std::string &comments_string);
58 void SetStyle(bool use_hex_immed, HexImmediateStyle hex_style);
59 bool CanBranch(llvm::MCInst &mc_inst) const;
60 bool HasDelaySlot(llvm::MCInst &mc_inst) const;
61 bool IsCall(llvm::MCInst &mc_inst) const;
62
63 private:
64 MCDisasmInstance(std::unique_ptr<llvm::MCInstrInfo> &&instr_info_up,
65 std::unique_ptr<llvm::MCRegisterInfo> &®_info_up,
66 std::unique_ptr<llvm::MCSubtargetInfo> &&subtarget_info_up,
67 std::unique_ptr<llvm::MCAsmInfo> &&asm_info_up,
68 std::unique_ptr<llvm::MCContext> &&context_up,
69 std::unique_ptr<llvm::MCDisassembler> &&disasm_up,
70 std::unique_ptr<llvm::MCInstPrinter> &&instr_printer_up);
71
72 std::unique_ptr<llvm::MCInstrInfo> m_instr_info_up;
73 std::unique_ptr<llvm::MCRegisterInfo> m_reg_info_up;
74 std::unique_ptr<llvm::MCSubtargetInfo> m_subtarget_info_up;
75 std::unique_ptr<llvm::MCAsmInfo> m_asm_info_up;
76 std::unique_ptr<llvm::MCContext> m_context_up;
77 std::unique_ptr<llvm::MCDisassembler> m_disasm_up;
78 std::unique_ptr<llvm::MCInstPrinter> m_instr_printer_up;
79 };
80
81 class InstructionLLVMC : public lldb_private::Instruction {
82 public:
InstructionLLVMC(DisassemblerLLVMC & disasm,const lldb_private::Address & address,AddressClass addr_class)83 InstructionLLVMC(DisassemblerLLVMC &disasm,
84 const lldb_private::Address &address,
85 AddressClass addr_class)
86 : Instruction(address, addr_class),
87 m_disasm_wp(std::static_pointer_cast<DisassemblerLLVMC>(
88 disasm.shared_from_this())),
89 m_does_branch(eLazyBoolCalculate), m_has_delay_slot(eLazyBoolCalculate),
90 m_is_call(eLazyBoolCalculate), m_is_valid(false),
91 m_using_file_addr(false) {}
92
93 ~InstructionLLVMC() override = default;
94
DoesBranch()95 bool DoesBranch() override {
96 if (m_does_branch == eLazyBoolCalculate) {
97 DisassemblerScope disasm(*this);
98 if (disasm) {
99 DataExtractor data;
100 if (m_opcode.GetData(data)) {
101 bool is_alternate_isa;
102 lldb::addr_t pc = m_address.GetFileAddress();
103
104 DisassemblerLLVMC::MCDisasmInstance *mc_disasm_ptr =
105 GetDisasmToUse(is_alternate_isa, disasm);
106 const uint8_t *opcode_data = data.GetDataStart();
107 const size_t opcode_data_len = data.GetByteSize();
108 llvm::MCInst inst;
109 const size_t inst_size =
110 mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
111 // Be conservative, if we didn't understand the instruction, say it
112 // might branch...
113 if (inst_size == 0)
114 m_does_branch = eLazyBoolYes;
115 else {
116 const bool can_branch = mc_disasm_ptr->CanBranch(inst);
117 if (can_branch)
118 m_does_branch = eLazyBoolYes;
119 else
120 m_does_branch = eLazyBoolNo;
121 }
122 }
123 }
124 }
125 return m_does_branch == eLazyBoolYes;
126 }
127
HasDelaySlot()128 bool HasDelaySlot() override {
129 if (m_has_delay_slot == eLazyBoolCalculate) {
130 DisassemblerScope disasm(*this);
131 if (disasm) {
132 DataExtractor data;
133 if (m_opcode.GetData(data)) {
134 bool is_alternate_isa;
135 lldb::addr_t pc = m_address.GetFileAddress();
136
137 DisassemblerLLVMC::MCDisasmInstance *mc_disasm_ptr =
138 GetDisasmToUse(is_alternate_isa, disasm);
139 const uint8_t *opcode_data = data.GetDataStart();
140 const size_t opcode_data_len = data.GetByteSize();
141 llvm::MCInst inst;
142 const size_t inst_size =
143 mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
144 // if we didn't understand the instruction, say it doesn't have a
145 // delay slot...
146 if (inst_size == 0)
147 m_has_delay_slot = eLazyBoolNo;
148 else {
149 const bool has_delay_slot = mc_disasm_ptr->HasDelaySlot(inst);
150 if (has_delay_slot)
151 m_has_delay_slot = eLazyBoolYes;
152 else
153 m_has_delay_slot = eLazyBoolNo;
154 }
155 }
156 }
157 }
158 return m_has_delay_slot == eLazyBoolYes;
159 }
160
GetDisasmToUse(bool & is_alternate_isa)161 DisassemblerLLVMC::MCDisasmInstance *GetDisasmToUse(bool &is_alternate_isa) {
162 DisassemblerScope disasm(*this);
163 return GetDisasmToUse(is_alternate_isa, disasm);
164 }
165
Decode(const lldb_private::Disassembler & disassembler,const lldb_private::DataExtractor & data,lldb::offset_t data_offset)166 size_t Decode(const lldb_private::Disassembler &disassembler,
167 const lldb_private::DataExtractor &data,
168 lldb::offset_t data_offset) override {
169 // All we have to do is read the opcode which can be easy for some
170 // architectures
171 bool got_op = false;
172 DisassemblerScope disasm(*this);
173 if (disasm) {
174 const ArchSpec &arch = disasm->GetArchitecture();
175 const lldb::ByteOrder byte_order = data.GetByteOrder();
176
177 const uint32_t min_op_byte_size = arch.GetMinimumOpcodeByteSize();
178 const uint32_t max_op_byte_size = arch.GetMaximumOpcodeByteSize();
179 if (min_op_byte_size == max_op_byte_size) {
180 // Fixed size instructions, just read that amount of data.
181 if (!data.ValidOffsetForDataOfSize(data_offset, min_op_byte_size))
182 return false;
183
184 switch (min_op_byte_size) {
185 case 1:
186 m_opcode.SetOpcode8(data.GetU8(&data_offset), byte_order);
187 got_op = true;
188 break;
189
190 case 2:
191 m_opcode.SetOpcode16(data.GetU16(&data_offset), byte_order);
192 got_op = true;
193 break;
194
195 case 4:
196 m_opcode.SetOpcode32(data.GetU32(&data_offset), byte_order);
197 got_op = true;
198 break;
199
200 case 8:
201 m_opcode.SetOpcode64(data.GetU64(&data_offset), byte_order);
202 got_op = true;
203 break;
204
205 default:
206 m_opcode.SetOpcodeBytes(data.PeekData(data_offset, min_op_byte_size),
207 min_op_byte_size);
208 got_op = true;
209 break;
210 }
211 }
212 if (!got_op) {
213 bool is_alternate_isa = false;
214 DisassemblerLLVMC::MCDisasmInstance *mc_disasm_ptr =
215 GetDisasmToUse(is_alternate_isa, disasm);
216
217 const llvm::Triple::ArchType machine = arch.GetMachine();
218 if (machine == llvm::Triple::arm || machine == llvm::Triple::thumb) {
219 if (machine == llvm::Triple::thumb || is_alternate_isa) {
220 uint32_t thumb_opcode = data.GetU16(&data_offset);
221 if ((thumb_opcode & 0xe000) != 0xe000 ||
222 ((thumb_opcode & 0x1800u) == 0)) {
223 m_opcode.SetOpcode16(thumb_opcode, byte_order);
224 m_is_valid = true;
225 } else {
226 thumb_opcode <<= 16;
227 thumb_opcode |= data.GetU16(&data_offset);
228 m_opcode.SetOpcode16_2(thumb_opcode, byte_order);
229 m_is_valid = true;
230 }
231 } else {
232 m_opcode.SetOpcode32(data.GetU32(&data_offset), byte_order);
233 m_is_valid = true;
234 }
235 } else {
236 // The opcode isn't evenly sized, so we need to actually use the llvm
237 // disassembler to parse it and get the size.
238 uint8_t *opcode_data =
239 const_cast<uint8_t *>(data.PeekData(data_offset, 1));
240 const size_t opcode_data_len = data.BytesLeft(data_offset);
241 const addr_t pc = m_address.GetFileAddress();
242 llvm::MCInst inst;
243
244 const size_t inst_size =
245 mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
246 if (inst_size == 0)
247 m_opcode.Clear();
248 else {
249 m_opcode.SetOpcodeBytes(opcode_data, inst_size);
250 m_is_valid = true;
251 }
252 }
253 }
254 return m_opcode.GetByteSize();
255 }
256 return 0;
257 }
258
AppendComment(std::string & description)259 void AppendComment(std::string &description) {
260 if (m_comment.empty())
261 m_comment.swap(description);
262 else {
263 m_comment.append(", ");
264 m_comment.append(description);
265 }
266 }
267
CalculateMnemonicOperandsAndComment(const lldb_private::ExecutionContext * exe_ctx)268 void CalculateMnemonicOperandsAndComment(
269 const lldb_private::ExecutionContext *exe_ctx) override {
270 DataExtractor data;
271 const AddressClass address_class = GetAddressClass();
272
273 if (m_opcode.GetData(data)) {
274 std::string out_string;
275 std::string comment_string;
276
277 DisassemblerScope disasm(*this, exe_ctx);
278 if (disasm) {
279 DisassemblerLLVMC::MCDisasmInstance *mc_disasm_ptr;
280
281 if (address_class == AddressClass::eCodeAlternateISA)
282 mc_disasm_ptr = disasm->m_alternate_disasm_up.get();
283 else
284 mc_disasm_ptr = disasm->m_disasm_up.get();
285
286 lldb::addr_t pc = m_address.GetFileAddress();
287 m_using_file_addr = true;
288
289 const bool data_from_file = disasm->m_data_from_file;
290 bool use_hex_immediates = true;
291 Disassembler::HexImmediateStyle hex_style = Disassembler::eHexStyleC;
292
293 if (exe_ctx) {
294 Target *target = exe_ctx->GetTargetPtr();
295 if (target) {
296 use_hex_immediates = target->GetUseHexImmediates();
297 hex_style = target->GetHexImmediateStyle();
298
299 if (!data_from_file) {
300 const lldb::addr_t load_addr = m_address.GetLoadAddress(target);
301 if (load_addr != LLDB_INVALID_ADDRESS) {
302 pc = load_addr;
303 m_using_file_addr = false;
304 }
305 }
306 }
307 }
308
309 const uint8_t *opcode_data = data.GetDataStart();
310 const size_t opcode_data_len = data.GetByteSize();
311 llvm::MCInst inst;
312 size_t inst_size =
313 mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
314
315 if (inst_size > 0) {
316 mc_disasm_ptr->SetStyle(use_hex_immediates, hex_style);
317 mc_disasm_ptr->PrintMCInst(inst, out_string, comment_string);
318
319 if (!comment_string.empty()) {
320 AppendComment(comment_string);
321 }
322 }
323
324 if (inst_size == 0) {
325 m_comment.assign("unknown opcode");
326 inst_size = m_opcode.GetByteSize();
327 StreamString mnemonic_strm;
328 lldb::offset_t offset = 0;
329 lldb::ByteOrder byte_order = data.GetByteOrder();
330 switch (inst_size) {
331 case 1: {
332 const uint8_t uval8 = data.GetU8(&offset);
333 m_opcode.SetOpcode8(uval8, byte_order);
334 m_opcode_name.assign(".byte");
335 mnemonic_strm.Printf("0x%2.2x", uval8);
336 } break;
337 case 2: {
338 const uint16_t uval16 = data.GetU16(&offset);
339 m_opcode.SetOpcode16(uval16, byte_order);
340 m_opcode_name.assign(".short");
341 mnemonic_strm.Printf("0x%4.4x", uval16);
342 } break;
343 case 4: {
344 const uint32_t uval32 = data.GetU32(&offset);
345 m_opcode.SetOpcode32(uval32, byte_order);
346 m_opcode_name.assign(".long");
347 mnemonic_strm.Printf("0x%8.8x", uval32);
348 } break;
349 case 8: {
350 const uint64_t uval64 = data.GetU64(&offset);
351 m_opcode.SetOpcode64(uval64, byte_order);
352 m_opcode_name.assign(".quad");
353 mnemonic_strm.Printf("0x%16.16" PRIx64, uval64);
354 } break;
355 default:
356 if (inst_size == 0)
357 return;
358 else {
359 const uint8_t *bytes = data.PeekData(offset, inst_size);
360 if (bytes == nullptr)
361 return;
362 m_opcode_name.assign(".byte");
363 m_opcode.SetOpcodeBytes(bytes, inst_size);
364 mnemonic_strm.Printf("0x%2.2x", bytes[0]);
365 for (uint32_t i = 1; i < inst_size; ++i)
366 mnemonic_strm.Printf(" 0x%2.2x", bytes[i]);
367 }
368 break;
369 }
370 m_mnemonics = mnemonic_strm.GetString();
371 return;
372 } else {
373 if (m_does_branch == eLazyBoolCalculate) {
374 const bool can_branch = mc_disasm_ptr->CanBranch(inst);
375 if (can_branch)
376 m_does_branch = eLazyBoolYes;
377 else
378 m_does_branch = eLazyBoolNo;
379 }
380 }
381
382 static RegularExpression s_regex(
383 llvm::StringRef("[ \t]*([^ ^\t]+)[ \t]*([^ ^\t].*)?"));
384
385 llvm::SmallVector<llvm::StringRef, 4> matches;
386 if (s_regex.Execute(out_string, &matches)) {
387 m_opcode_name = matches[1].str();
388 m_mnemonics = matches[2].str();
389 }
390 }
391 }
392 }
393
IsValid() const394 bool IsValid() const { return m_is_valid; }
395
UsingFileAddress() const396 bool UsingFileAddress() const { return m_using_file_addr; }
GetByteSize() const397 size_t GetByteSize() const { return m_opcode.GetByteSize(); }
398
399 /// Grants exclusive access to the disassembler and initializes it with the
400 /// given InstructionLLVMC and an optional ExecutionContext.
401 class DisassemblerScope {
402 std::shared_ptr<DisassemblerLLVMC> m_disasm;
403
404 public:
DisassemblerScope(InstructionLLVMC & i,const lldb_private::ExecutionContext * exe_ctx=nullptr)405 explicit DisassemblerScope(
406 InstructionLLVMC &i,
407 const lldb_private::ExecutionContext *exe_ctx = nullptr)
408 : m_disasm(i.m_disasm_wp.lock()) {
409 m_disasm->m_mutex.lock();
410 m_disasm->m_inst = &i;
411 m_disasm->m_exe_ctx = exe_ctx;
412 }
~DisassemblerScope()413 ~DisassemblerScope() { m_disasm->m_mutex.unlock(); }
414
415 /// Evaluates to true if this scope contains a valid disassembler.
operator bool() const416 operator bool() const { return static_cast<bool>(m_disasm); }
417
operator ->()418 std::shared_ptr<DisassemblerLLVMC> operator->() { return m_disasm; }
419 };
420
421 static llvm::StringRef::const_iterator
ConsumeWhitespace(llvm::StringRef::const_iterator osi,llvm::StringRef::const_iterator ose)422 ConsumeWhitespace(llvm::StringRef::const_iterator osi,
423 llvm::StringRef::const_iterator ose) {
424 while (osi != ose) {
425 switch (*osi) {
426 default:
427 return osi;
428 case ' ':
429 case '\t':
430 break;
431 }
432 ++osi;
433 }
434
435 return osi;
436 }
437
438 static std::pair<bool, llvm::StringRef::const_iterator>
ConsumeChar(llvm::StringRef::const_iterator osi,const char c,llvm::StringRef::const_iterator ose)439 ConsumeChar(llvm::StringRef::const_iterator osi, const char c,
440 llvm::StringRef::const_iterator ose) {
441 bool found = false;
442
443 osi = ConsumeWhitespace(osi, ose);
444 if (osi != ose && *osi == c) {
445 found = true;
446 ++osi;
447 }
448
449 return std::make_pair(found, osi);
450 }
451
452 static std::pair<Operand, llvm::StringRef::const_iterator>
ParseRegisterName(llvm::StringRef::const_iterator osi,llvm::StringRef::const_iterator ose)453 ParseRegisterName(llvm::StringRef::const_iterator osi,
454 llvm::StringRef::const_iterator ose) {
455 Operand ret;
456 ret.m_type = Operand::Type::Register;
457 std::string str;
458
459 osi = ConsumeWhitespace(osi, ose);
460
461 while (osi != ose) {
462 if (*osi >= '0' && *osi <= '9') {
463 if (str.empty()) {
464 return std::make_pair(Operand(), osi);
465 } else {
466 str.push_back(*osi);
467 }
468 } else if (*osi >= 'a' && *osi <= 'z') {
469 str.push_back(*osi);
470 } else {
471 switch (*osi) {
472 default:
473 if (str.empty()) {
474 return std::make_pair(Operand(), osi);
475 } else {
476 ret.m_register = ConstString(str);
477 return std::make_pair(ret, osi);
478 }
479 case '%':
480 if (!str.empty()) {
481 return std::make_pair(Operand(), osi);
482 }
483 break;
484 }
485 }
486 ++osi;
487 }
488
489 ret.m_register = ConstString(str);
490 return std::make_pair(ret, osi);
491 }
492
493 static std::pair<Operand, llvm::StringRef::const_iterator>
ParseImmediate(llvm::StringRef::const_iterator osi,llvm::StringRef::const_iterator ose)494 ParseImmediate(llvm::StringRef::const_iterator osi,
495 llvm::StringRef::const_iterator ose) {
496 Operand ret;
497 ret.m_type = Operand::Type::Immediate;
498 std::string str;
499 bool is_hex = false;
500
501 osi = ConsumeWhitespace(osi, ose);
502
503 while (osi != ose) {
504 if (*osi >= '0' && *osi <= '9') {
505 str.push_back(*osi);
506 } else if (*osi >= 'a' && *osi <= 'f') {
507 if (is_hex) {
508 str.push_back(*osi);
509 } else {
510 return std::make_pair(Operand(), osi);
511 }
512 } else {
513 switch (*osi) {
514 default:
515 if (str.empty()) {
516 return std::make_pair(Operand(), osi);
517 } else {
518 ret.m_immediate = strtoull(str.c_str(), nullptr, 0);
519 return std::make_pair(ret, osi);
520 }
521 case 'x':
522 if (!str.compare("0")) {
523 is_hex = true;
524 str.push_back(*osi);
525 } else {
526 return std::make_pair(Operand(), osi);
527 }
528 break;
529 case '#':
530 case '$':
531 if (!str.empty()) {
532 return std::make_pair(Operand(), osi);
533 }
534 break;
535 case '-':
536 if (str.empty()) {
537 ret.m_negative = true;
538 } else {
539 return std::make_pair(Operand(), osi);
540 }
541 }
542 }
543 ++osi;
544 }
545
546 ret.m_immediate = strtoull(str.c_str(), nullptr, 0);
547 return std::make_pair(ret, osi);
548 }
549
550 // -0x5(%rax,%rax,2)
551 static std::pair<Operand, llvm::StringRef::const_iterator>
ParseIntelIndexedAccess(llvm::StringRef::const_iterator osi,llvm::StringRef::const_iterator ose)552 ParseIntelIndexedAccess(llvm::StringRef::const_iterator osi,
553 llvm::StringRef::const_iterator ose) {
554 std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator =
555 ParseImmediate(osi, ose);
556 if (offset_and_iterator.first.IsValid()) {
557 osi = offset_and_iterator.second;
558 }
559
560 bool found = false;
561 std::tie(found, osi) = ConsumeChar(osi, '(', ose);
562 if (!found) {
563 return std::make_pair(Operand(), osi);
564 }
565
566 std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator =
567 ParseRegisterName(osi, ose);
568 if (base_and_iterator.first.IsValid()) {
569 osi = base_and_iterator.second;
570 } else {
571 return std::make_pair(Operand(), osi);
572 }
573
574 std::tie(found, osi) = ConsumeChar(osi, ',', ose);
575 if (!found) {
576 return std::make_pair(Operand(), osi);
577 }
578
579 std::pair<Operand, llvm::StringRef::const_iterator> index_and_iterator =
580 ParseRegisterName(osi, ose);
581 if (index_and_iterator.first.IsValid()) {
582 osi = index_and_iterator.second;
583 } else {
584 return std::make_pair(Operand(), osi);
585 }
586
587 std::tie(found, osi) = ConsumeChar(osi, ',', ose);
588 if (!found) {
589 return std::make_pair(Operand(), osi);
590 }
591
592 std::pair<Operand, llvm::StringRef::const_iterator>
593 multiplier_and_iterator = ParseImmediate(osi, ose);
594 if (index_and_iterator.first.IsValid()) {
595 osi = index_and_iterator.second;
596 } else {
597 return std::make_pair(Operand(), osi);
598 }
599
600 std::tie(found, osi) = ConsumeChar(osi, ')', ose);
601 if (!found) {
602 return std::make_pair(Operand(), osi);
603 }
604
605 Operand product;
606 product.m_type = Operand::Type::Product;
607 product.m_children.push_back(index_and_iterator.first);
608 product.m_children.push_back(multiplier_and_iterator.first);
609
610 Operand index;
611 index.m_type = Operand::Type::Sum;
612 index.m_children.push_back(base_and_iterator.first);
613 index.m_children.push_back(product);
614
615 if (offset_and_iterator.first.IsValid()) {
616 Operand offset;
617 offset.m_type = Operand::Type::Sum;
618 offset.m_children.push_back(offset_and_iterator.first);
619 offset.m_children.push_back(index);
620
621 Operand deref;
622 deref.m_type = Operand::Type::Dereference;
623 deref.m_children.push_back(offset);
624 return std::make_pair(deref, osi);
625 } else {
626 Operand deref;
627 deref.m_type = Operand::Type::Dereference;
628 deref.m_children.push_back(index);
629 return std::make_pair(deref, osi);
630 }
631 }
632
633 // -0x10(%rbp)
634 static std::pair<Operand, llvm::StringRef::const_iterator>
ParseIntelDerefAccess(llvm::StringRef::const_iterator osi,llvm::StringRef::const_iterator ose)635 ParseIntelDerefAccess(llvm::StringRef::const_iterator osi,
636 llvm::StringRef::const_iterator ose) {
637 std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator =
638 ParseImmediate(osi, ose);
639 if (offset_and_iterator.first.IsValid()) {
640 osi = offset_and_iterator.second;
641 }
642
643 bool found = false;
644 std::tie(found, osi) = ConsumeChar(osi, '(', ose);
645 if (!found) {
646 return std::make_pair(Operand(), osi);
647 }
648
649 std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator =
650 ParseRegisterName(osi, ose);
651 if (base_and_iterator.first.IsValid()) {
652 osi = base_and_iterator.second;
653 } else {
654 return std::make_pair(Operand(), osi);
655 }
656
657 std::tie(found, osi) = ConsumeChar(osi, ')', ose);
658 if (!found) {
659 return std::make_pair(Operand(), osi);
660 }
661
662 if (offset_and_iterator.first.IsValid()) {
663 Operand offset;
664 offset.m_type = Operand::Type::Sum;
665 offset.m_children.push_back(offset_and_iterator.first);
666 offset.m_children.push_back(base_and_iterator.first);
667
668 Operand deref;
669 deref.m_type = Operand::Type::Dereference;
670 deref.m_children.push_back(offset);
671 return std::make_pair(deref, osi);
672 } else {
673 Operand deref;
674 deref.m_type = Operand::Type::Dereference;
675 deref.m_children.push_back(base_and_iterator.first);
676 return std::make_pair(deref, osi);
677 }
678 }
679
680 // [sp, #8]!
681 static std::pair<Operand, llvm::StringRef::const_iterator>
ParseARMOffsetAccess(llvm::StringRef::const_iterator osi,llvm::StringRef::const_iterator ose)682 ParseARMOffsetAccess(llvm::StringRef::const_iterator osi,
683 llvm::StringRef::const_iterator ose) {
684 bool found = false;
685 std::tie(found, osi) = ConsumeChar(osi, '[', ose);
686 if (!found) {
687 return std::make_pair(Operand(), osi);
688 }
689
690 std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator =
691 ParseRegisterName(osi, ose);
692 if (base_and_iterator.first.IsValid()) {
693 osi = base_and_iterator.second;
694 } else {
695 return std::make_pair(Operand(), osi);
696 }
697
698 std::tie(found, osi) = ConsumeChar(osi, ',', ose);
699 if (!found) {
700 return std::make_pair(Operand(), osi);
701 }
702
703 std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator =
704 ParseImmediate(osi, ose);
705 if (offset_and_iterator.first.IsValid()) {
706 osi = offset_and_iterator.second;
707 }
708
709 std::tie(found, osi) = ConsumeChar(osi, ']', ose);
710 if (!found) {
711 return std::make_pair(Operand(), osi);
712 }
713
714 Operand offset;
715 offset.m_type = Operand::Type::Sum;
716 offset.m_children.push_back(offset_and_iterator.first);
717 offset.m_children.push_back(base_and_iterator.first);
718
719 Operand deref;
720 deref.m_type = Operand::Type::Dereference;
721 deref.m_children.push_back(offset);
722 return std::make_pair(deref, osi);
723 }
724
725 // [sp]
726 static std::pair<Operand, llvm::StringRef::const_iterator>
ParseARMDerefAccess(llvm::StringRef::const_iterator osi,llvm::StringRef::const_iterator ose)727 ParseARMDerefAccess(llvm::StringRef::const_iterator osi,
728 llvm::StringRef::const_iterator ose) {
729 bool found = false;
730 std::tie(found, osi) = ConsumeChar(osi, '[', ose);
731 if (!found) {
732 return std::make_pair(Operand(), osi);
733 }
734
735 std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator =
736 ParseRegisterName(osi, ose);
737 if (base_and_iterator.first.IsValid()) {
738 osi = base_and_iterator.second;
739 } else {
740 return std::make_pair(Operand(), osi);
741 }
742
743 std::tie(found, osi) = ConsumeChar(osi, ']', ose);
744 if (!found) {
745 return std::make_pair(Operand(), osi);
746 }
747
748 Operand deref;
749 deref.m_type = Operand::Type::Dereference;
750 deref.m_children.push_back(base_and_iterator.first);
751 return std::make_pair(deref, osi);
752 }
753
DumpOperand(const Operand & op,Stream & s)754 static void DumpOperand(const Operand &op, Stream &s) {
755 switch (op.m_type) {
756 case Operand::Type::Dereference:
757 s.PutCString("*");
758 DumpOperand(op.m_children[0], s);
759 break;
760 case Operand::Type::Immediate:
761 if (op.m_negative) {
762 s.PutCString("-");
763 }
764 s.PutCString(llvm::to_string(op.m_immediate));
765 break;
766 case Operand::Type::Invalid:
767 s.PutCString("Invalid");
768 break;
769 case Operand::Type::Product:
770 s.PutCString("(");
771 DumpOperand(op.m_children[0], s);
772 s.PutCString("*");
773 DumpOperand(op.m_children[1], s);
774 s.PutCString(")");
775 break;
776 case Operand::Type::Register:
777 s.PutCString(op.m_register.AsCString());
778 break;
779 case Operand::Type::Sum:
780 s.PutCString("(");
781 DumpOperand(op.m_children[0], s);
782 s.PutCString("+");
783 DumpOperand(op.m_children[1], s);
784 s.PutCString(")");
785 break;
786 }
787 }
788
ParseOperands(llvm::SmallVectorImpl<Instruction::Operand> & operands)789 bool ParseOperands(
790 llvm::SmallVectorImpl<Instruction::Operand> &operands) override {
791 const char *operands_string = GetOperands(nullptr);
792
793 if (!operands_string) {
794 return false;
795 }
796
797 llvm::StringRef operands_ref(operands_string);
798
799 llvm::StringRef::const_iterator osi = operands_ref.begin();
800 llvm::StringRef::const_iterator ose = operands_ref.end();
801
802 while (osi != ose) {
803 Operand operand;
804 llvm::StringRef::const_iterator iter;
805
806 if ((std::tie(operand, iter) = ParseIntelIndexedAccess(osi, ose),
807 operand.IsValid()) ||
808 (std::tie(operand, iter) = ParseIntelDerefAccess(osi, ose),
809 operand.IsValid()) ||
810 (std::tie(operand, iter) = ParseARMOffsetAccess(osi, ose),
811 operand.IsValid()) ||
812 (std::tie(operand, iter) = ParseARMDerefAccess(osi, ose),
813 operand.IsValid()) ||
814 (std::tie(operand, iter) = ParseRegisterName(osi, ose),
815 operand.IsValid()) ||
816 (std::tie(operand, iter) = ParseImmediate(osi, ose),
817 operand.IsValid())) {
818 osi = iter;
819 operands.push_back(operand);
820 } else {
821 return false;
822 }
823
824 std::pair<bool, llvm::StringRef::const_iterator> found_and_iter =
825 ConsumeChar(osi, ',', ose);
826 if (found_and_iter.first) {
827 osi = found_and_iter.second;
828 }
829
830 osi = ConsumeWhitespace(osi, ose);
831 }
832
833 DisassemblerSP disasm_sp = m_disasm_wp.lock();
834
835 if (disasm_sp && operands.size() > 1) {
836 // TODO tie this into the MC Disassembler's notion of clobbers.
837 switch (disasm_sp->GetArchitecture().GetMachine()) {
838 default:
839 break;
840 case llvm::Triple::x86:
841 case llvm::Triple::x86_64:
842 operands[operands.size() - 1].m_clobbered = true;
843 break;
844 case llvm::Triple::arm:
845 operands[0].m_clobbered = true;
846 break;
847 }
848 }
849
850 if (Log *log =
851 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)) {
852 StreamString ss;
853
854 ss.Printf("[%s] expands to %zu operands:\n", operands_string,
855 operands.size());
856 for (const Operand &operand : operands) {
857 ss.PutCString(" ");
858 DumpOperand(operand, ss);
859 ss.PutCString("\n");
860 }
861
862 log->PutString(ss.GetString());
863 }
864
865 return true;
866 }
867
IsCall()868 bool IsCall() override {
869 if (m_is_call == eLazyBoolCalculate) {
870 DisassemblerScope disasm(*this);
871 if (disasm) {
872 DataExtractor data;
873 if (m_opcode.GetData(data)) {
874 bool is_alternate_isa;
875 lldb::addr_t pc = m_address.GetFileAddress();
876
877 DisassemblerLLVMC::MCDisasmInstance *mc_disasm_ptr =
878 GetDisasmToUse(is_alternate_isa, disasm);
879 const uint8_t *opcode_data = data.GetDataStart();
880 const size_t opcode_data_len = data.GetByteSize();
881 llvm::MCInst inst;
882 const size_t inst_size =
883 mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
884 if (inst_size == 0) {
885 m_is_call = eLazyBoolNo;
886 } else {
887 if (mc_disasm_ptr->IsCall(inst))
888 m_is_call = eLazyBoolYes;
889 else
890 m_is_call = eLazyBoolNo;
891 }
892 }
893 }
894 }
895 return m_is_call == eLazyBoolYes;
896 }
897
898 protected:
899 std::weak_ptr<DisassemblerLLVMC> m_disasm_wp;
900 LazyBool m_does_branch;
901 LazyBool m_has_delay_slot;
902 LazyBool m_is_call;
903 bool m_is_valid;
904 bool m_using_file_addr;
905
906 private:
907 DisassemblerLLVMC::MCDisasmInstance *
GetDisasmToUse(bool & is_alternate_isa,DisassemblerScope & disasm)908 GetDisasmToUse(bool &is_alternate_isa, DisassemblerScope &disasm) {
909 is_alternate_isa = false;
910 if (disasm) {
911 if (disasm->m_alternate_disasm_up) {
912 const AddressClass address_class = GetAddressClass();
913
914 if (address_class == AddressClass::eCodeAlternateISA) {
915 is_alternate_isa = true;
916 return disasm->m_alternate_disasm_up.get();
917 }
918 }
919 return disasm->m_disasm_up.get();
920 }
921 return nullptr;
922 }
923 };
924
925 std::unique_ptr<DisassemblerLLVMC::MCDisasmInstance>
Create(const char * triple,const char * cpu,const char * features_str,unsigned flavor,DisassemblerLLVMC & owner)926 DisassemblerLLVMC::MCDisasmInstance::Create(const char *triple, const char *cpu,
927 const char *features_str,
928 unsigned flavor,
929 DisassemblerLLVMC &owner) {
930 using Instance = std::unique_ptr<DisassemblerLLVMC::MCDisasmInstance>;
931
932 std::string Status;
933 const llvm::Target *curr_target =
934 llvm::TargetRegistry::lookupTarget(triple, Status);
935 if (!curr_target)
936 return Instance();
937
938 std::unique_ptr<llvm::MCInstrInfo> instr_info_up(
939 curr_target->createMCInstrInfo());
940 if (!instr_info_up)
941 return Instance();
942
943 std::unique_ptr<llvm::MCRegisterInfo> reg_info_up(
944 curr_target->createMCRegInfo(triple));
945 if (!reg_info_up)
946 return Instance();
947
948 std::unique_ptr<llvm::MCSubtargetInfo> subtarget_info_up(
949 curr_target->createMCSubtargetInfo(triple, cpu, features_str));
950 if (!subtarget_info_up)
951 return Instance();
952
953 llvm::MCTargetOptions MCOptions;
954 std::unique_ptr<llvm::MCAsmInfo> asm_info_up(
955 curr_target->createMCAsmInfo(*reg_info_up, triple, MCOptions));
956 if (!asm_info_up)
957 return Instance();
958
959 std::unique_ptr<llvm::MCContext> context_up(
960 new llvm::MCContext(asm_info_up.get(), reg_info_up.get(), nullptr));
961 if (!context_up)
962 return Instance();
963
964 std::unique_ptr<llvm::MCDisassembler> disasm_up(
965 curr_target->createMCDisassembler(*subtarget_info_up, *context_up));
966 if (!disasm_up)
967 return Instance();
968
969 std::unique_ptr<llvm::MCRelocationInfo> rel_info_up(
970 curr_target->createMCRelocationInfo(triple, *context_up));
971 if (!rel_info_up)
972 return Instance();
973
974 std::unique_ptr<llvm::MCSymbolizer> symbolizer_up(
975 curr_target->createMCSymbolizer(
976 triple, nullptr, DisassemblerLLVMC::SymbolLookupCallback, &owner,
977 context_up.get(), std::move(rel_info_up)));
978 disasm_up->setSymbolizer(std::move(symbolizer_up));
979
980 unsigned asm_printer_variant =
981 flavor == ~0U ? asm_info_up->getAssemblerDialect() : flavor;
982
983 std::unique_ptr<llvm::MCInstPrinter> instr_printer_up(
984 curr_target->createMCInstPrinter(llvm::Triple{triple},
985 asm_printer_variant, *asm_info_up,
986 *instr_info_up, *reg_info_up));
987 if (!instr_printer_up)
988 return Instance();
989
990 return Instance(
991 new MCDisasmInstance(std::move(instr_info_up), std::move(reg_info_up),
992 std::move(subtarget_info_up), std::move(asm_info_up),
993 std::move(context_up), std::move(disasm_up),
994 std::move(instr_printer_up)));
995 }
996
MCDisasmInstance(std::unique_ptr<llvm::MCInstrInfo> && instr_info_up,std::unique_ptr<llvm::MCRegisterInfo> && reg_info_up,std::unique_ptr<llvm::MCSubtargetInfo> && subtarget_info_up,std::unique_ptr<llvm::MCAsmInfo> && asm_info_up,std::unique_ptr<llvm::MCContext> && context_up,std::unique_ptr<llvm::MCDisassembler> && disasm_up,std::unique_ptr<llvm::MCInstPrinter> && instr_printer_up)997 DisassemblerLLVMC::MCDisasmInstance::MCDisasmInstance(
998 std::unique_ptr<llvm::MCInstrInfo> &&instr_info_up,
999 std::unique_ptr<llvm::MCRegisterInfo> &®_info_up,
1000 std::unique_ptr<llvm::MCSubtargetInfo> &&subtarget_info_up,
1001 std::unique_ptr<llvm::MCAsmInfo> &&asm_info_up,
1002 std::unique_ptr<llvm::MCContext> &&context_up,
1003 std::unique_ptr<llvm::MCDisassembler> &&disasm_up,
1004 std::unique_ptr<llvm::MCInstPrinter> &&instr_printer_up)
1005 : m_instr_info_up(std::move(instr_info_up)),
1006 m_reg_info_up(std::move(reg_info_up)),
1007 m_subtarget_info_up(std::move(subtarget_info_up)),
1008 m_asm_info_up(std::move(asm_info_up)),
1009 m_context_up(std::move(context_up)), m_disasm_up(std::move(disasm_up)),
1010 m_instr_printer_up(std::move(instr_printer_up)) {
1011 assert(m_instr_info_up && m_reg_info_up && m_subtarget_info_up &&
1012 m_asm_info_up && m_context_up && m_disasm_up && m_instr_printer_up);
1013 }
1014
GetMCInst(const uint8_t * opcode_data,size_t opcode_data_len,lldb::addr_t pc,llvm::MCInst & mc_inst) const1015 uint64_t DisassemblerLLVMC::MCDisasmInstance::GetMCInst(
1016 const uint8_t *opcode_data, size_t opcode_data_len, lldb::addr_t pc,
1017 llvm::MCInst &mc_inst) const {
1018 llvm::ArrayRef<uint8_t> data(opcode_data, opcode_data_len);
1019 llvm::MCDisassembler::DecodeStatus status;
1020
1021 uint64_t new_inst_size;
1022 status = m_disasm_up->getInstruction(mc_inst, new_inst_size, data, pc,
1023 llvm::nulls());
1024 if (status == llvm::MCDisassembler::Success)
1025 return new_inst_size;
1026 else
1027 return 0;
1028 }
1029
PrintMCInst(llvm::MCInst & mc_inst,std::string & inst_string,std::string & comments_string)1030 void DisassemblerLLVMC::MCDisasmInstance::PrintMCInst(
1031 llvm::MCInst &mc_inst, std::string &inst_string,
1032 std::string &comments_string) {
1033 llvm::raw_string_ostream inst_stream(inst_string);
1034 llvm::raw_string_ostream comments_stream(comments_string);
1035
1036 m_instr_printer_up->setCommentStream(comments_stream);
1037 m_instr_printer_up->printInst(&mc_inst, 0, llvm::StringRef(),
1038 *m_subtarget_info_up, inst_stream);
1039 m_instr_printer_up->setCommentStream(llvm::nulls());
1040 comments_stream.flush();
1041
1042 static std::string g_newlines("\r\n");
1043
1044 for (size_t newline_pos = 0;
1045 (newline_pos = comments_string.find_first_of(g_newlines, newline_pos)) !=
1046 comments_string.npos;
1047 /**/) {
1048 comments_string.replace(comments_string.begin() + newline_pos,
1049 comments_string.begin() + newline_pos + 1, 1, ' ');
1050 }
1051 }
1052
SetStyle(bool use_hex_immed,HexImmediateStyle hex_style)1053 void DisassemblerLLVMC::MCDisasmInstance::SetStyle(
1054 bool use_hex_immed, HexImmediateStyle hex_style) {
1055 m_instr_printer_up->setPrintImmHex(use_hex_immed);
1056 switch (hex_style) {
1057 case eHexStyleC:
1058 m_instr_printer_up->setPrintHexStyle(llvm::HexStyle::C);
1059 break;
1060 case eHexStyleAsm:
1061 m_instr_printer_up->setPrintHexStyle(llvm::HexStyle::Asm);
1062 break;
1063 }
1064 }
1065
CanBranch(llvm::MCInst & mc_inst) const1066 bool DisassemblerLLVMC::MCDisasmInstance::CanBranch(
1067 llvm::MCInst &mc_inst) const {
1068 return m_instr_info_up->get(mc_inst.getOpcode())
1069 .mayAffectControlFlow(mc_inst, *m_reg_info_up);
1070 }
1071
HasDelaySlot(llvm::MCInst & mc_inst) const1072 bool DisassemblerLLVMC::MCDisasmInstance::HasDelaySlot(
1073 llvm::MCInst &mc_inst) const {
1074 return m_instr_info_up->get(mc_inst.getOpcode()).hasDelaySlot();
1075 }
1076
IsCall(llvm::MCInst & mc_inst) const1077 bool DisassemblerLLVMC::MCDisasmInstance::IsCall(llvm::MCInst &mc_inst) const {
1078 return m_instr_info_up->get(mc_inst.getOpcode()).isCall();
1079 }
1080
DisassemblerLLVMC(const ArchSpec & arch,const char * flavor_string)1081 DisassemblerLLVMC::DisassemblerLLVMC(const ArchSpec &arch,
1082 const char *flavor_string)
1083 : Disassembler(arch, flavor_string), m_exe_ctx(nullptr), m_inst(nullptr),
1084 m_data_from_file(false) {
1085 if (!FlavorValidForArchSpec(arch, m_flavor.c_str())) {
1086 m_flavor.assign("default");
1087 }
1088
1089 unsigned flavor = ~0U;
1090 llvm::Triple triple = arch.GetTriple();
1091
1092 // So far the only supported flavor is "intel" on x86. The base class will
1093 // set this correctly coming in.
1094 if (triple.getArch() == llvm::Triple::x86 ||
1095 triple.getArch() == llvm::Triple::x86_64) {
1096 if (m_flavor == "intel") {
1097 flavor = 1;
1098 } else if (m_flavor == "att") {
1099 flavor = 0;
1100 }
1101 }
1102
1103 ArchSpec thumb_arch(arch);
1104 if (triple.getArch() == llvm::Triple::arm) {
1105 std::string thumb_arch_name(thumb_arch.GetTriple().getArchName().str());
1106 // Replace "arm" with "thumb" so we get all thumb variants correct
1107 if (thumb_arch_name.size() > 3) {
1108 thumb_arch_name.erase(0, 3);
1109 thumb_arch_name.insert(0, "thumb");
1110 } else {
1111 thumb_arch_name = "thumbv8.2a";
1112 }
1113 thumb_arch.GetTriple().setArchName(llvm::StringRef(thumb_arch_name));
1114 }
1115
1116 // If no sub architecture specified then use the most recent arm architecture
1117 // so the disassembler will return all instruction. Without it we will see a
1118 // lot of unknow opcode in case the code uses instructions which are not
1119 // available in the oldest arm version (used when no sub architecture is
1120 // specified)
1121 if (triple.getArch() == llvm::Triple::arm &&
1122 triple.getSubArch() == llvm::Triple::NoSubArch)
1123 triple.setArchName("armv8.2a");
1124
1125 std::string features_str = "";
1126 const char *triple_str = triple.getTriple().c_str();
1127
1128 // ARM Cortex M0-M7 devices only execute thumb instructions
1129 if (arch.IsAlwaysThumbInstructions()) {
1130 triple_str = thumb_arch.GetTriple().getTriple().c_str();
1131 features_str += "+fp-armv8,";
1132 }
1133
1134 const char *cpu = "";
1135
1136 switch (arch.GetCore()) {
1137 case ArchSpec::eCore_mips32:
1138 case ArchSpec::eCore_mips32el:
1139 cpu = "mips32";
1140 break;
1141 case ArchSpec::eCore_mips32r2:
1142 case ArchSpec::eCore_mips32r2el:
1143 cpu = "mips32r2";
1144 break;
1145 case ArchSpec::eCore_mips32r3:
1146 case ArchSpec::eCore_mips32r3el:
1147 cpu = "mips32r3";
1148 break;
1149 case ArchSpec::eCore_mips32r5:
1150 case ArchSpec::eCore_mips32r5el:
1151 cpu = "mips32r5";
1152 break;
1153 case ArchSpec::eCore_mips32r6:
1154 case ArchSpec::eCore_mips32r6el:
1155 cpu = "mips32r6";
1156 break;
1157 case ArchSpec::eCore_mips64:
1158 case ArchSpec::eCore_mips64el:
1159 cpu = "mips64";
1160 break;
1161 case ArchSpec::eCore_mips64r2:
1162 case ArchSpec::eCore_mips64r2el:
1163 cpu = "mips64r2";
1164 break;
1165 case ArchSpec::eCore_mips64r3:
1166 case ArchSpec::eCore_mips64r3el:
1167 cpu = "mips64r3";
1168 break;
1169 case ArchSpec::eCore_mips64r5:
1170 case ArchSpec::eCore_mips64r5el:
1171 cpu = "mips64r5";
1172 break;
1173 case ArchSpec::eCore_mips64r6:
1174 case ArchSpec::eCore_mips64r6el:
1175 cpu = "mips64r6";
1176 break;
1177 default:
1178 cpu = "";
1179 break;
1180 }
1181
1182 if (arch.IsMIPS()) {
1183 uint32_t arch_flags = arch.GetFlags();
1184 if (arch_flags & ArchSpec::eMIPSAse_msa)
1185 features_str += "+msa,";
1186 if (arch_flags & ArchSpec::eMIPSAse_dsp)
1187 features_str += "+dsp,";
1188 if (arch_flags & ArchSpec::eMIPSAse_dspr2)
1189 features_str += "+dspr2,";
1190 }
1191
1192 // If any AArch64 variant, enable the ARMv8.5 ISA with SVE extensions so we
1193 // can disassemble newer instructions.
1194 if (triple.getArch() == llvm::Triple::aarch64 ||
1195 triple.getArch() == llvm::Triple::aarch64_32)
1196 features_str += "+v8.5a,+sve2";
1197
1198 if ((triple.getArch() == llvm::Triple::aarch64 ||
1199 triple.getArch() == llvm::Triple::aarch64_32)
1200 && triple.getVendor() == llvm::Triple::Apple) {
1201 cpu = "apple-latest";
1202 }
1203
1204 // We use m_disasm_up.get() to tell whether we are valid or not, so if this
1205 // isn't good for some reason, we won't be valid and FindPlugin will fail and
1206 // we won't get used.
1207 m_disasm_up = MCDisasmInstance::Create(triple_str, cpu, features_str.c_str(),
1208 flavor, *this);
1209
1210 llvm::Triple::ArchType llvm_arch = triple.getArch();
1211
1212 // For arm CPUs that can execute arm or thumb instructions, also create a
1213 // thumb instruction disassembler.
1214 if (llvm_arch == llvm::Triple::arm) {
1215 std::string thumb_triple(thumb_arch.GetTriple().getTriple());
1216 m_alternate_disasm_up =
1217 MCDisasmInstance::Create(thumb_triple.c_str(), "", features_str.c_str(),
1218 flavor, *this);
1219 if (!m_alternate_disasm_up)
1220 m_disasm_up.reset();
1221
1222 } else if (arch.IsMIPS()) {
1223 /* Create alternate disassembler for MIPS16 and microMIPS */
1224 uint32_t arch_flags = arch.GetFlags();
1225 if (arch_flags & ArchSpec::eMIPSAse_mips16)
1226 features_str += "+mips16,";
1227 else if (arch_flags & ArchSpec::eMIPSAse_micromips)
1228 features_str += "+micromips,";
1229
1230 m_alternate_disasm_up = MCDisasmInstance::Create(
1231 triple_str, cpu, features_str.c_str(), flavor, *this);
1232 if (!m_alternate_disasm_up)
1233 m_disasm_up.reset();
1234 }
1235 }
1236
1237 DisassemblerLLVMC::~DisassemblerLLVMC() = default;
1238
CreateInstance(const ArchSpec & arch,const char * flavor)1239 Disassembler *DisassemblerLLVMC::CreateInstance(const ArchSpec &arch,
1240 const char *flavor) {
1241 if (arch.GetTriple().getArch() != llvm::Triple::UnknownArch) {
1242 std::unique_ptr<DisassemblerLLVMC> disasm_up(
1243 new DisassemblerLLVMC(arch, flavor));
1244
1245 if (disasm_up.get() && disasm_up->IsValid())
1246 return disasm_up.release();
1247 }
1248 return nullptr;
1249 }
1250
DecodeInstructions(const Address & base_addr,const DataExtractor & data,lldb::offset_t data_offset,size_t num_instructions,bool append,bool data_from_file)1251 size_t DisassemblerLLVMC::DecodeInstructions(const Address &base_addr,
1252 const DataExtractor &data,
1253 lldb::offset_t data_offset,
1254 size_t num_instructions,
1255 bool append, bool data_from_file) {
1256 if (!append)
1257 m_instruction_list.Clear();
1258
1259 if (!IsValid())
1260 return 0;
1261
1262 m_data_from_file = data_from_file;
1263 uint32_t data_cursor = data_offset;
1264 const size_t data_byte_size = data.GetByteSize();
1265 uint32_t instructions_parsed = 0;
1266 Address inst_addr(base_addr);
1267
1268 while (data_cursor < data_byte_size &&
1269 instructions_parsed < num_instructions) {
1270
1271 AddressClass address_class = AddressClass::eCode;
1272
1273 if (m_alternate_disasm_up)
1274 address_class = inst_addr.GetAddressClass();
1275
1276 InstructionSP inst_sp(
1277 new InstructionLLVMC(*this, inst_addr, address_class));
1278
1279 if (!inst_sp)
1280 break;
1281
1282 uint32_t inst_size = inst_sp->Decode(*this, data, data_cursor);
1283
1284 if (inst_size == 0)
1285 break;
1286
1287 m_instruction_list.Append(inst_sp);
1288 data_cursor += inst_size;
1289 inst_addr.Slide(inst_size);
1290 instructions_parsed++;
1291 }
1292
1293 return data_cursor - data_offset;
1294 }
1295
Initialize()1296 void DisassemblerLLVMC::Initialize() {
1297 PluginManager::RegisterPlugin(GetPluginNameStatic(),
1298 "Disassembler that uses LLVM MC to disassemble "
1299 "i386, x86_64, ARM, and ARM64.",
1300 CreateInstance);
1301
1302 llvm::InitializeAllTargetInfos();
1303 llvm::InitializeAllTargetMCs();
1304 llvm::InitializeAllAsmParsers();
1305 llvm::InitializeAllDisassemblers();
1306 }
1307
Terminate()1308 void DisassemblerLLVMC::Terminate() {
1309 PluginManager::UnregisterPlugin(CreateInstance);
1310 }
1311
GetPluginNameStatic()1312 ConstString DisassemblerLLVMC::GetPluginNameStatic() {
1313 static ConstString g_name("llvm-mc");
1314 return g_name;
1315 }
1316
OpInfoCallback(void * disassembler,uint64_t pc,uint64_t offset,uint64_t size,int tag_type,void * tag_bug)1317 int DisassemblerLLVMC::OpInfoCallback(void *disassembler, uint64_t pc,
1318 uint64_t offset, uint64_t size,
1319 int tag_type, void *tag_bug) {
1320 return static_cast<DisassemblerLLVMC *>(disassembler)
1321 ->OpInfo(pc, offset, size, tag_type, tag_bug);
1322 }
1323
SymbolLookupCallback(void * disassembler,uint64_t value,uint64_t * type,uint64_t pc,const char ** name)1324 const char *DisassemblerLLVMC::SymbolLookupCallback(void *disassembler,
1325 uint64_t value,
1326 uint64_t *type, uint64_t pc,
1327 const char **name) {
1328 return static_cast<DisassemblerLLVMC *>(disassembler)
1329 ->SymbolLookup(value, type, pc, name);
1330 }
1331
FlavorValidForArchSpec(const lldb_private::ArchSpec & arch,const char * flavor)1332 bool DisassemblerLLVMC::FlavorValidForArchSpec(
1333 const lldb_private::ArchSpec &arch, const char *flavor) {
1334 llvm::Triple triple = arch.GetTriple();
1335 if (flavor == nullptr || strcmp(flavor, "default") == 0)
1336 return true;
1337
1338 if (triple.getArch() == llvm::Triple::x86 ||
1339 triple.getArch() == llvm::Triple::x86_64) {
1340 return strcmp(flavor, "intel") == 0 || strcmp(flavor, "att") == 0;
1341 } else
1342 return false;
1343 }
1344
IsValid() const1345 bool DisassemblerLLVMC::IsValid() const { return m_disasm_up.operator bool(); }
1346
OpInfo(uint64_t PC,uint64_t Offset,uint64_t Size,int tag_type,void * tag_bug)1347 int DisassemblerLLVMC::OpInfo(uint64_t PC, uint64_t Offset, uint64_t Size,
1348 int tag_type, void *tag_bug) {
1349 switch (tag_type) {
1350 default:
1351 break;
1352 case 1:
1353 memset(tag_bug, 0, sizeof(::LLVMOpInfo1));
1354 break;
1355 }
1356 return 0;
1357 }
1358
SymbolLookup(uint64_t value,uint64_t * type_ptr,uint64_t pc,const char ** name)1359 const char *DisassemblerLLVMC::SymbolLookup(uint64_t value, uint64_t *type_ptr,
1360 uint64_t pc, const char **name) {
1361 if (*type_ptr) {
1362 if (m_exe_ctx && m_inst) {
1363 // std::string remove_this_prior_to_checkin;
1364 Target *target = m_exe_ctx ? m_exe_ctx->GetTargetPtr() : nullptr;
1365 Address value_so_addr;
1366 Address pc_so_addr;
1367 if (m_inst->UsingFileAddress()) {
1368 ModuleSP module_sp(m_inst->GetAddress().GetModule());
1369 if (module_sp) {
1370 module_sp->ResolveFileAddress(value, value_so_addr);
1371 module_sp->ResolveFileAddress(pc, pc_so_addr);
1372 }
1373 } else if (target && !target->GetSectionLoadList().IsEmpty()) {
1374 target->GetSectionLoadList().ResolveLoadAddress(value, value_so_addr);
1375 target->GetSectionLoadList().ResolveLoadAddress(pc, pc_so_addr);
1376 }
1377
1378 SymbolContext sym_ctx;
1379 const SymbolContextItem resolve_scope =
1380 eSymbolContextFunction | eSymbolContextSymbol;
1381 if (pc_so_addr.IsValid() && pc_so_addr.GetModule()) {
1382 pc_so_addr.GetModule()->ResolveSymbolContextForAddress(
1383 pc_so_addr, resolve_scope, sym_ctx);
1384 }
1385
1386 if (value_so_addr.IsValid() && value_so_addr.GetSection()) {
1387 StreamString ss;
1388
1389 bool format_omitting_current_func_name = false;
1390 if (sym_ctx.symbol || sym_ctx.function) {
1391 AddressRange range;
1392 if (sym_ctx.GetAddressRange(resolve_scope, 0, false, range) &&
1393 range.GetBaseAddress().IsValid() &&
1394 range.ContainsLoadAddress(value_so_addr, target)) {
1395 format_omitting_current_func_name = true;
1396 }
1397 }
1398
1399 // If the "value" address (the target address we're symbolicating) is
1400 // inside the same SymbolContext as the current instruction pc
1401 // (pc_so_addr), don't print the full function name - just print it
1402 // with DumpStyleNoFunctionName style, e.g. "<+36>".
1403 if (format_omitting_current_func_name) {
1404 value_so_addr.Dump(&ss, target, Address::DumpStyleNoFunctionName,
1405 Address::DumpStyleSectionNameOffset);
1406 } else {
1407 value_so_addr.Dump(
1408 &ss, target,
1409 Address::DumpStyleResolvedDescriptionNoFunctionArguments,
1410 Address::DumpStyleSectionNameOffset);
1411 }
1412
1413 if (!ss.GetString().empty()) {
1414 // If Address::Dump returned a multi-line description, most commonly
1415 // seen when we have multiple levels of inlined functions at an
1416 // address, only show the first line.
1417 std::string str = ss.GetString();
1418 size_t first_eol_char = str.find_first_of("\r\n");
1419 if (first_eol_char != std::string::npos) {
1420 str.erase(first_eol_char);
1421 }
1422 m_inst->AppendComment(str);
1423 }
1424 }
1425 }
1426 }
1427
1428 *type_ptr = LLVMDisassembler_ReferenceType_InOut_None;
1429 *name = nullptr;
1430 return nullptr;
1431 }
1432
1433 // PluginInterface protocol
GetPluginName()1434 ConstString DisassemblerLLVMC::GetPluginName() { return GetPluginNameStatic(); }
1435
GetPluginVersion()1436 uint32_t DisassemblerLLVMC::GetPluginVersion() { return 1; }
1437