1 //===-- RegisterContextKDP_arm64.cpp ------------------------------*- C++
2 //-*-===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10 
11 #include "RegisterContextKDP_arm64.h"
12 
13 // C Includes
14 // C++ Includes
15 // Other libraries and framework includes
16 // Project includes
17 #include "ProcessKDP.h"
18 #include "ThreadKDP.h"
19 
20 using namespace lldb;
21 using namespace lldb_private;
22 
23 RegisterContextKDP_arm64::RegisterContextKDP_arm64(ThreadKDP &thread,
24                                                    uint32_t concrete_frame_idx)
25     : RegisterContextDarwin_arm64(thread, concrete_frame_idx),
26       m_kdp_thread(thread) {}
27 
28 RegisterContextKDP_arm64::~RegisterContextKDP_arm64() {}
29 
30 int RegisterContextKDP_arm64::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
31   ProcessSP process_sp(CalculateProcess());
32   if (process_sp) {
33     Error error;
34     if (static_cast<ProcessKDP *>(process_sp.get())
35             ->GetCommunication()
36             .SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr),
37                                       error)) {
38       if (error.Success())
39         return 0;
40     }
41   }
42   return -1;
43 }
44 
45 int RegisterContextKDP_arm64::DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) {
46   ProcessSP process_sp(CalculateProcess());
47   if (process_sp) {
48     Error error;
49     if (static_cast<ProcessKDP *>(process_sp.get())
50             ->GetCommunication()
51             .SendRequestReadRegisters(tid, FPURegSet, &fpu, sizeof(fpu),
52                                       error)) {
53       if (error.Success())
54         return 0;
55     }
56   }
57   return -1;
58 }
59 
60 int RegisterContextKDP_arm64::DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) {
61   ProcessSP process_sp(CalculateProcess());
62   if (process_sp) {
63     Error error;
64     if (static_cast<ProcessKDP *>(process_sp.get())
65             ->GetCommunication()
66             .SendRequestReadRegisters(tid, EXCRegSet, &exc, sizeof(exc),
67                                       error)) {
68       if (error.Success())
69         return 0;
70     }
71   }
72   return -1;
73 }
74 
75 int RegisterContextKDP_arm64::DoReadDBG(lldb::tid_t tid, int flavor, DBG &dbg) {
76   ProcessSP process_sp(CalculateProcess());
77   if (process_sp) {
78     Error error;
79     if (static_cast<ProcessKDP *>(process_sp.get())
80             ->GetCommunication()
81             .SendRequestReadRegisters(tid, DBGRegSet, &dbg, sizeof(dbg),
82                                       error)) {
83       if (error.Success())
84         return 0;
85     }
86   }
87   return -1;
88 }
89 
90 int RegisterContextKDP_arm64::DoWriteGPR(lldb::tid_t tid, int flavor,
91                                          const GPR &gpr) {
92   ProcessSP process_sp(CalculateProcess());
93   if (process_sp) {
94     Error error;
95     if (static_cast<ProcessKDP *>(process_sp.get())
96             ->GetCommunication()
97             .SendRequestWriteRegisters(tid, GPRRegSet, &gpr, sizeof(gpr),
98                                        error)) {
99       if (error.Success())
100         return 0;
101     }
102   }
103   return -1;
104 }
105 
106 int RegisterContextKDP_arm64::DoWriteFPU(lldb::tid_t tid, int flavor,
107                                          const FPU &fpu) {
108   ProcessSP process_sp(CalculateProcess());
109   if (process_sp) {
110     Error error;
111     if (static_cast<ProcessKDP *>(process_sp.get())
112             ->GetCommunication()
113             .SendRequestWriteRegisters(tid, FPURegSet, &fpu, sizeof(fpu),
114                                        error)) {
115       if (error.Success())
116         return 0;
117     }
118   }
119   return -1;
120 }
121 
122 int RegisterContextKDP_arm64::DoWriteEXC(lldb::tid_t tid, int flavor,
123                                          const EXC &exc) {
124   ProcessSP process_sp(CalculateProcess());
125   if (process_sp) {
126     Error error;
127     if (static_cast<ProcessKDP *>(process_sp.get())
128             ->GetCommunication()
129             .SendRequestWriteRegisters(tid, EXCRegSet, &exc, sizeof(exc),
130                                        error)) {
131       if (error.Success())
132         return 0;
133     }
134   }
135   return -1;
136 }
137 
138 int RegisterContextKDP_arm64::DoWriteDBG(lldb::tid_t tid, int flavor,
139                                          const DBG &dbg) {
140   ProcessSP process_sp(CalculateProcess());
141   if (process_sp) {
142     Error error;
143     if (static_cast<ProcessKDP *>(process_sp.get())
144             ->GetCommunication()
145             .SendRequestWriteRegisters(tid, DBGRegSet, &dbg, sizeof(dbg),
146                                        error)) {
147       if (error.Success())
148         return 0;
149     }
150   }
151   return -1;
152 }
153