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