1 //===-- EmulateInstruction.h ------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Core/EmulateInstruction.h"
11 
12 #include "lldb/Core/Address.h"
13 #include "lldb/Core/DataExtractor.h"
14 #include "lldb/Core/Error.h"
15 #include "lldb/Core/PluginManager.h"
16 #include "lldb/Core/RegisterValue.h"
17 #include "lldb/Core/StreamFile.h"
18 #include "lldb/Core/StreamString.h"
19 #include "lldb/Host/Endian.h"
20 #include "lldb/Symbol/UnwindPlan.h"
21 #include "lldb/Target/Process.h"
22 #include "lldb/Target/RegisterContext.h"
23 #include "lldb/Target/Target.h"
24 #include "lldb/Target/Thread.h"
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 
29 EmulateInstruction*
30 EmulateInstruction::FindPlugin (const ArchSpec &arch, InstructionType supported_inst_type, const char *plugin_name)
31 {
32     EmulateInstructionCreateInstance create_callback = NULL;
33     if (plugin_name)
34     {
35         create_callback  = PluginManager::GetEmulateInstructionCreateCallbackForPluginName (plugin_name);
36         if (create_callback)
37         {
38            	EmulateInstruction *emulate_insn_ptr = create_callback(arch, supported_inst_type);
39             if (emulate_insn_ptr)
40                 return emulate_insn_ptr;
41         }
42     }
43     else
44     {
45         for (uint32_t idx = 0; (create_callback = PluginManager::GetEmulateInstructionCreateCallbackAtIndex(idx)) != NULL; ++idx)
46         {
47             EmulateInstruction *emulate_insn_ptr = create_callback(arch, supported_inst_type);
48             if (emulate_insn_ptr)
49                 return emulate_insn_ptr;
50         }
51     }
52     return NULL;
53 }
54 
55 EmulateInstruction::EmulateInstruction (const ArchSpec &arch) :
56     m_arch (arch),
57     m_baton (NULL),
58     m_read_mem_callback (&ReadMemoryDefault),
59     m_write_mem_callback (&WriteMemoryDefault),
60     m_read_reg_callback (&ReadRegisterDefault),
61     m_write_reg_callback (&WriteRegisterDefault),
62     m_addr (LLDB_INVALID_ADDRESS)
63 {
64     ::memset (&m_opcode, 0, sizeof (m_opcode));
65 }
66 
67 
68 bool
69 EmulateInstruction::ReadRegister (const RegisterInfo *reg_info, RegisterValue& reg_value)
70 {
71     if (m_read_reg_callback)
72         return m_read_reg_callback (this, m_baton, reg_info, reg_value);
73     return false;
74 }
75 
76 bool
77 EmulateInstruction::ReadRegister (uint32_t reg_kind, uint32_t reg_num, RegisterValue& reg_value)
78 {
79     RegisterInfo reg_info;
80     if (GetRegisterInfo(reg_kind, reg_num, reg_info))
81         return ReadRegister (&reg_info, reg_value);
82     return false;
83 }
84 
85 uint64_t
86 EmulateInstruction::ReadRegisterUnsigned (uint32_t reg_kind,
87                                           uint32_t reg_num,
88                                           uint64_t fail_value,
89                                           bool *success_ptr)
90 {
91     RegisterValue reg_value;
92     if (ReadRegister (reg_kind, reg_num, reg_value))
93         return reg_value.GetAsUInt64(fail_value, success_ptr);
94     if (success_ptr)
95         *success_ptr = false;
96     return fail_value;
97 }
98 
99 uint64_t
100 EmulateInstruction::ReadRegisterUnsigned (const RegisterInfo *reg_info,
101                                           uint64_t fail_value,
102                                           bool *success_ptr)
103 {
104     RegisterValue reg_value;
105     if (ReadRegister (reg_info, reg_value))
106         return reg_value.GetAsUInt64(fail_value, success_ptr);
107     if (success_ptr)
108         *success_ptr = false;
109     return fail_value;
110 }
111 
112 bool
113 EmulateInstruction::WriteRegister (const Context &context,
114                                    const RegisterInfo *reg_info,
115                                    const RegisterValue& reg_value)
116 {
117     if (m_write_reg_callback)
118         return m_write_reg_callback (this, m_baton, context, reg_info, reg_value);
119     return false;
120 }
121 
122 bool
123 EmulateInstruction::WriteRegister (const Context &context,
124                                    uint32_t reg_kind,
125                                    uint32_t reg_num,
126                                    const RegisterValue& reg_value)
127 {
128     RegisterInfo reg_info;
129     if (GetRegisterInfo(reg_kind, reg_num, reg_info))
130         return WriteRegister (context, &reg_info, reg_value);
131     return false;
132 }
133 
134 
135 bool
136 EmulateInstruction::WriteRegisterUnsigned (const Context &context,
137                                            uint32_t reg_kind,
138                                            uint32_t reg_num,
139                                            uint64_t uint_value)
140 {
141 
142     RegisterInfo reg_info;
143     if (GetRegisterInfo(reg_kind, reg_num, reg_info))
144     {
145         RegisterValue reg_value;
146         if (reg_value.SetUInt(uint_value, reg_info.byte_size))
147             return WriteRegister (context, &reg_info, reg_value);
148     }
149     return false;
150 }
151 
152 bool
153 EmulateInstruction::WriteRegisterUnsigned (const Context &context,
154                                            const RegisterInfo *reg_info,
155                                            uint64_t uint_value)
156 {
157 
158     if (reg_info)
159     {
160         RegisterValue reg_value;
161         if (reg_value.SetUInt(uint_value, reg_info->byte_size))
162                 return WriteRegister (context, reg_info, reg_value);
163     }
164     return false;
165 }
166 
167 size_t
168 EmulateInstruction::ReadMemory (const Context &context,
169                                 lldb::addr_t addr,
170                                 void *dst,
171                                 size_t dst_len)
172 {
173     if (m_read_mem_callback)
174         return m_read_mem_callback (this, m_baton, context, addr, dst, dst_len) == dst_len;
175     return false;
176 }
177 
178 uint64_t
179 EmulateInstruction::ReadMemoryUnsigned (const Context &context, lldb::addr_t addr, size_t byte_size, uint64_t fail_value, bool *success_ptr)
180 {
181     uint64_t uval64 = 0;
182     bool success = false;
183     if (byte_size <= 8)
184     {
185         uint8_t buf[sizeof(uint64_t)];
186         size_t bytes_read = m_read_mem_callback (this, m_baton, context, addr, buf, byte_size);
187         if (bytes_read == byte_size)
188         {
189             uint32_t offset = 0;
190             DataExtractor data (buf, byte_size, GetByteOrder(), GetAddressByteSize());
191             uval64 = data.GetMaxU64 (&offset, byte_size);
192             success = true;
193         }
194     }
195 
196     if (success_ptr)
197         *success_ptr = success;
198 
199     if (!success)
200         uval64 = fail_value;
201     return uval64;
202 }
203 
204 
205 bool
206 EmulateInstruction::WriteMemoryUnsigned (const Context &context,
207                                          lldb::addr_t addr,
208                                          uint64_t uval,
209                                          size_t uval_byte_size)
210 {
211     StreamString strm(Stream::eBinary, GetAddressByteSize(), GetByteOrder());
212     strm.PutMaxHex64 (uval, uval_byte_size);
213 
214     size_t bytes_written = m_write_mem_callback (this, m_baton, context, addr, strm.GetData(), uval_byte_size);
215     if (bytes_written == uval_byte_size)
216         return true;
217     return false;
218 }
219 
220 bool
221 EmulateInstruction::WriteMemory (const Context &context,
222                                  lldb::addr_t addr,
223                                  const void *src,
224                                  size_t src_len)
225 {
226     if (m_write_mem_callback)
227         return m_write_mem_callback (this, m_baton, context, addr, src, src_len) == src_len;
228     return false;
229 }
230 
231 
232 void
233 EmulateInstruction::SetBaton (void *baton)
234 {
235     m_baton = baton;
236 }
237 
238 void
239 EmulateInstruction::SetCallbacks (ReadMemoryCallback read_mem_callback,
240                                   WriteMemoryCallback write_mem_callback,
241                                   ReadRegisterCallback read_reg_callback,
242                                   WriteRegisterCallback write_reg_callback)
243 {
244     m_read_mem_callback = read_mem_callback;
245     m_write_mem_callback = write_mem_callback;
246     m_read_reg_callback = read_reg_callback;
247     m_write_reg_callback = write_reg_callback;
248 }
249 
250 void
251 EmulateInstruction::SetReadMemCallback (ReadMemoryCallback read_mem_callback)
252 {
253     m_read_mem_callback = read_mem_callback;
254 }
255 
256 
257 void
258 EmulateInstruction::SetWriteMemCallback (WriteMemoryCallback write_mem_callback)
259 {
260     m_write_mem_callback = write_mem_callback;
261 }
262 
263 
264 void
265 EmulateInstruction::SetReadRegCallback (ReadRegisterCallback read_reg_callback)
266 {
267     m_read_reg_callback = read_reg_callback;
268 }
269 
270 
271 void
272 EmulateInstruction::SetWriteRegCallback (WriteRegisterCallback write_reg_callback)
273 {
274     m_write_reg_callback = write_reg_callback;
275 }
276 
277 
278 
279 //
280 //  Read & Write Memory and Registers callback functions.
281 //
282 
283 size_t
284 EmulateInstruction::ReadMemoryFrame (EmulateInstruction *instruction,
285                                      void *baton,
286                                      const Context &context,
287                                      lldb::addr_t addr,
288                                      void *dst,
289                                      size_t dst_len)
290 {
291     if (!baton || dst == NULL || dst_len == 0)
292         return 0;
293 
294     StackFrame *frame = (StackFrame *) baton;
295 
296     ProcessSP process_sp (frame->CalculateProcess());
297     if (process_sp)
298     {
299         Error error;
300         return process_sp->ReadMemory (addr, dst, dst_len, error);
301     }
302     return 0;
303 }
304 
305 size_t
306 EmulateInstruction::WriteMemoryFrame (EmulateInstruction *instruction,
307                                       void *baton,
308                                       const Context &context,
309                                       lldb::addr_t addr,
310                                       const void *src,
311                                       size_t src_len)
312 {
313     if (!baton || src == NULL || src_len == 0)
314         return 0;
315 
316     StackFrame *frame = (StackFrame *) baton;
317 
318     ProcessSP process_sp (frame->CalculateProcess());
319     if (process_sp)
320     {
321         Error error;
322         return process_sp->WriteMemory (addr, src, src_len, error);
323     }
324 
325     return 0;
326 }
327 
328 bool
329 EmulateInstruction::ReadRegisterFrame  (EmulateInstruction *instruction,
330                                         void *baton,
331                                         const RegisterInfo *reg_info,
332                                         RegisterValue &reg_value)
333 {
334     if (!baton)
335         return false;
336 
337     StackFrame *frame = (StackFrame *) baton;
338     return frame->GetRegisterContext()->ReadRegister (reg_info, reg_value);
339 }
340 
341 bool
342 EmulateInstruction::WriteRegisterFrame (EmulateInstruction *instruction,
343                                         void *baton,
344                                         const Context &context,
345                                         const RegisterInfo *reg_info,
346                                         const RegisterValue &reg_value)
347 {
348     if (!baton)
349         return false;
350 
351     StackFrame *frame = (StackFrame *) baton;
352     return frame->GetRegisterContext()->WriteRegister (reg_info, reg_value);
353 }
354 
355 size_t
356 EmulateInstruction::ReadMemoryDefault (EmulateInstruction *instruction,
357                                        void *baton,
358                                        const Context &context,
359                                        lldb::addr_t addr,
360                                        void *dst,
361                                        size_t length)
362 {
363     StreamFile strm (stdout, false);
364     strm.Printf ("    Read from Memory (address = 0x%llx, length = %llu, context = ", addr, (uint64_t)length);
365     context.Dump (strm, instruction);
366     strm.EOL();
367     *((uint64_t *) dst) = 0xdeadbeef;
368     return length;
369 }
370 
371 size_t
372 EmulateInstruction::WriteMemoryDefault (EmulateInstruction *instruction,
373                                         void *baton,
374                                         const Context &context,
375                                         lldb::addr_t addr,
376                                         const void *dst,
377                                         size_t length)
378 {
379     StreamFile strm (stdout, false);
380     strm.Printf ("    Write to Memory (address = 0x%llx, length = %llu, context = ", addr, (uint64_t)length);
381     context.Dump (strm, instruction);
382     strm.EOL();
383     return length;
384 }
385 
386 bool
387 EmulateInstruction::ReadRegisterDefault  (EmulateInstruction *instruction,
388                                           void *baton,
389                                           const RegisterInfo *reg_info,
390                                           RegisterValue &reg_value)
391 {
392     StreamFile strm (stdout, false);
393     strm.Printf ("  Read Register (%s)\n", reg_info->name);
394     uint32_t reg_kind, reg_num;
395     if (GetBestRegisterKindAndNumber (reg_info, reg_kind, reg_num))
396         reg_value.SetUInt64((uint64_t)reg_kind << 24 | reg_num);
397     else
398         reg_value.SetUInt64(0);
399 
400     return true;
401 }
402 
403 bool
404 EmulateInstruction::WriteRegisterDefault (EmulateInstruction *instruction,
405                                           void *baton,
406                                           const Context &context,
407                                           const RegisterInfo *reg_info,
408                                           const RegisterValue &reg_value)
409 {
410     StreamFile strm (stdout, false);
411     strm.Printf ("    Write to Register (name = %s, value = " , reg_info->name);
412     reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
413     strm.PutCString (", context = ");
414     context.Dump (strm, instruction);
415     strm.EOL();
416     return true;
417 }
418 
419 void
420 EmulateInstruction::Context::Dump (Stream &strm,
421                                    EmulateInstruction *instruction) const
422 {
423     switch (type)
424     {
425         case eContextReadOpcode:
426             strm.PutCString ("reading opcode");
427             break;
428 
429         case eContextImmediate:
430             strm.PutCString ("immediate");
431             break;
432 
433         case eContextPushRegisterOnStack:
434             strm.PutCString ("push register");
435             break;
436 
437         case eContextPopRegisterOffStack:
438             strm.PutCString ("pop register");
439             break;
440 
441         case eContextAdjustStackPointer:
442             strm.PutCString ("adjust sp");
443             break;
444 
445         case eContextSetFramePointer:
446             strm.PutCString ("set frame pointer");
447             break;
448 
449         case eContextAdjustBaseRegister:
450             strm.PutCString ("adjusting (writing value back to) a base register");
451             break;
452 
453         case eContextRegisterPlusOffset:
454             strm.PutCString ("register + offset");
455             break;
456 
457         case eContextRegisterStore:
458             strm.PutCString ("store register");
459             break;
460 
461         case eContextRegisterLoad:
462             strm.PutCString ("load register");
463             break;
464 
465         case eContextRelativeBranchImmediate:
466             strm.PutCString ("relative branch immediate");
467             break;
468 
469         case eContextAbsoluteBranchRegister:
470             strm.PutCString ("absolute branch register");
471             break;
472 
473         case eContextSupervisorCall:
474             strm.PutCString ("supervisor call");
475             break;
476 
477         case eContextTableBranchReadMemory:
478             strm.PutCString ("table branch read memory");
479             break;
480 
481         case eContextWriteRegisterRandomBits:
482             strm.PutCString ("write random bits to a register");
483             break;
484 
485         case eContextWriteMemoryRandomBits:
486             strm.PutCString ("write random bits to a memory address");
487             break;
488 
489         case eContextArithmetic:
490             strm.PutCString ("arithmetic");
491             break;
492 
493         case eContextReturnFromException:
494             strm.PutCString ("return from exception");
495             break;
496 
497         default:
498             strm.PutCString ("unrecognized context.");
499             break;
500     }
501 
502     switch (info_type)
503     {
504     case eInfoTypeRegisterPlusOffset:
505         {
506             strm.Printf (" (reg_plus_offset = %s%+lld)",
507                          info.RegisterPlusOffset.reg.name,
508                          info.RegisterPlusOffset.signed_offset);
509         }
510         break;
511 
512     case eInfoTypeRegisterPlusIndirectOffset:
513         {
514             strm.Printf (" (reg_plus_reg = %s + %s)",
515                          info.RegisterPlusIndirectOffset.base_reg.name,
516                          info.RegisterPlusIndirectOffset.offset_reg.name);
517         }
518         break;
519 
520     case eInfoTypeRegisterToRegisterPlusOffset:
521         {
522             strm.Printf (" (base_and_imm_offset = %s%+lld, data_reg = %s)",
523                          info.RegisterToRegisterPlusOffset.base_reg.name,
524                          info.RegisterToRegisterPlusOffset.offset,
525                          info.RegisterToRegisterPlusOffset.data_reg.name);
526         }
527         break;
528 
529     case eInfoTypeRegisterToRegisterPlusIndirectOffset:
530         {
531             strm.Printf (" (base_and_reg_offset = %s + %s, data_reg = %s)",
532                          info.RegisterToRegisterPlusIndirectOffset.base_reg.name,
533                          info.RegisterToRegisterPlusIndirectOffset.offset_reg.name,
534                          info.RegisterToRegisterPlusIndirectOffset.data_reg.name);
535         }
536         break;
537 
538     case eInfoTypeRegisterRegisterOperands:
539         {
540             strm.Printf (" (register to register binary op: %s and %s)",
541                          info.RegisterRegisterOperands.operand1.name,
542                          info.RegisterRegisterOperands.operand2.name);
543         }
544         break;
545 
546     case eInfoTypeOffset:
547         strm.Printf (" (signed_offset = %+lld)", info.signed_offset);
548         break;
549 
550     case eInfoTypeRegister:
551         strm.Printf (" (reg = %s)", info.reg.name);
552         break;
553 
554     case eInfoTypeImmediate:
555         strm.Printf (" (unsigned_immediate = %llu (0x%16.16llx))",
556                      info.unsigned_immediate,
557                      info.unsigned_immediate);
558         break;
559 
560     case eInfoTypeImmediateSigned:
561         strm.Printf (" (signed_immediate = %+lld (0x%16.16llx))",
562                      info.signed_immediate,
563                      info.signed_immediate);
564         break;
565 
566     case eInfoTypeAddress:
567         strm.Printf (" (address = 0x%llx)", info.address);
568         break;
569 
570     case eInfoTypeISAAndImmediate:
571         strm.Printf (" (isa = %u, unsigned_immediate = %u (0x%8.8x))",
572                      info.ISAAndImmediate.isa,
573                      info.ISAAndImmediate.unsigned_data32,
574                      info.ISAAndImmediate.unsigned_data32);
575         break;
576 
577     case eInfoTypeISAAndImmediateSigned:
578         strm.Printf (" (isa = %u, signed_immediate = %i (0x%8.8x))",
579                      info.ISAAndImmediateSigned.isa,
580                      info.ISAAndImmediateSigned.signed_data32,
581                      info.ISAAndImmediateSigned.signed_data32);
582         break;
583 
584     case eInfoTypeISA:
585         strm.Printf (" (isa = %u)", info.isa);
586         break;
587 
588     case eInfoTypeNoArgs:
589         break;
590 
591     default:
592         strm.Printf (" (unknown <info_type>)");
593         break;
594     }
595 }
596 
597 bool
598 EmulateInstruction::SetInstruction (const Opcode &opcode, const Address &inst_addr, Target *target)
599 {
600     m_opcode = opcode;
601     m_addr = LLDB_INVALID_ADDRESS;
602     if (inst_addr.IsValid())
603     {
604         if (target)
605             m_addr = inst_addr.GetLoadAddress (target);
606         if (m_addr == LLDB_INVALID_ADDRESS)
607             m_addr = inst_addr.GetFileAddress ();
608     }
609     return true;
610 }
611 
612 bool
613 EmulateInstruction::GetBestRegisterKindAndNumber (const RegisterInfo *reg_info,
614                                                   uint32_t &reg_kind,
615                                                   uint32_t &reg_num)
616 {
617     // Generic and DWARF should be the two most popular register kinds when
618     // emulating instructions since they are the most platform agnostic...
619     reg_num = reg_info->kinds[eRegisterKindGeneric];
620     if (reg_num != LLDB_INVALID_REGNUM)
621     {
622         reg_kind = eRegisterKindGeneric;
623         return true;
624     }
625 
626     reg_num = reg_info->kinds[eRegisterKindDWARF];
627     if (reg_num != LLDB_INVALID_REGNUM)
628     {
629         reg_kind = eRegisterKindDWARF;
630         return true;
631     }
632 
633     reg_num = reg_info->kinds[eRegisterKindLLDB];
634     if (reg_num != LLDB_INVALID_REGNUM)
635     {
636         reg_kind = eRegisterKindLLDB;
637         return true;
638     }
639 
640     reg_num = reg_info->kinds[eRegisterKindGCC];
641     if (reg_num != LLDB_INVALID_REGNUM)
642     {
643         reg_kind = eRegisterKindGCC;
644         return true;
645     }
646 
647     reg_num = reg_info->kinds[eRegisterKindGDB];
648     if (reg_num != LLDB_INVALID_REGNUM)
649     {
650         reg_kind = eRegisterKindGDB;
651         return true;
652     }
653     return false;
654 }
655 
656 uint32_t
657 EmulateInstruction::GetInternalRegisterNumber (RegisterContext *reg_ctx, const RegisterInfo &reg_info)
658 {
659     uint32_t reg_kind, reg_num;
660     if (reg_ctx && GetBestRegisterKindAndNumber (&reg_info, reg_kind, reg_num))
661         return reg_ctx->ConvertRegisterKindToRegisterNumber (reg_kind, reg_num);
662     return LLDB_INVALID_REGNUM;
663 }
664 
665 
666 bool
667 EmulateInstruction::CreateFunctionEntryUnwind (UnwindPlan &unwind_plan)
668 {
669     unwind_plan.Clear();
670     return false;
671 }
672 
673 
674