Bug Summary

File:tools/lldb/source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_powerpc.cpp
Location:line 223, column 17
Description:Value stored to 'src' is never read

Annotated Source Code

1//===-- RegisterContextPOSIXProcessMonitor_powerpc.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/Target/Thread.h"
11#include "lldb/Core/RegisterValue.h"
12
13#include "RegisterContextPOSIX_powerpc.h"
14#include "ProcessPOSIX.h"
15#include "RegisterContextPOSIXProcessMonitor_powerpc.h"
16#include "ProcessMonitor.h"
17
18using namespace lldb_private;
19using namespace lldb;
20
21#define REG_CONTEXT_SIZE(GetGPRSize()) (GetGPRSize())
22
23RegisterContextPOSIXProcessMonitor_powerpc::RegisterContextPOSIXProcessMonitor_powerpc(Thread &thread,
24 uint32_t concrete_frame_idx,
25 lldb_private::RegisterInfoInterface *register_info)
26 : RegisterContextPOSIX_powerpc(thread, concrete_frame_idx, register_info)
27{
28}
29
30ProcessMonitor &
31RegisterContextPOSIXProcessMonitor_powerpc::GetMonitor()
32{
33 ProcessSP base = CalculateProcess();
34 ProcessPOSIX *process = static_cast<ProcessPOSIX*>(base.get());
35 return process->GetMonitor();
36}
37
38bool
39RegisterContextPOSIXProcessMonitor_powerpc::ReadGPR()
40{
41 ProcessMonitor &monitor = GetMonitor();
42 return monitor.ReadGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
43}
44
45bool
46RegisterContextPOSIXProcessMonitor_powerpc::ReadFPR()
47{
48 // XXX not yet implemented
49 return false;
50}
51
52bool
53RegisterContextPOSIXProcessMonitor_powerpc::WriteGPR()
54{
55 ProcessMonitor &monitor = GetMonitor();
56 return monitor.WriteGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
57}
58
59bool
60RegisterContextPOSIXProcessMonitor_powerpc::WriteFPR()
61{
62 // XXX not yet implemented
63 return false;
64}
65
66bool
67RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(const unsigned reg,
68 RegisterValue &value)
69{
70 ProcessMonitor &monitor = GetMonitor();
71 return monitor.ReadRegisterValue(m_thread.GetID(),
72 GetRegisterOffset(reg),
73 GetRegisterName(reg),
74 GetRegisterSize(reg),
75 value);
76}
77
78bool
79RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(const unsigned reg,
80 const RegisterValue &value)
81{
82 unsigned reg_to_write = reg;
83 RegisterValue value_to_write = value;
84
85 // Check if this is a subregister of a full register.
86 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
87 if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM(4294967295U)))
88 {
89 RegisterValue full_value;
90 uint32_t full_reg = reg_info->invalidate_regs[0];
91 const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
92
93 // Read the full register.
94 if (ReadRegister(full_reg_info, full_value))
95 {
96 Error error;
97 ByteOrder byte_order = GetByteOrder();
98 uint8_t dst[RegisterValue::kMaxRegisterByteSize];
99
100 // Get the bytes for the full register.
101 const uint32_t dest_size = full_value.GetAsMemoryData (full_reg_info,
102 dst,
103 sizeof(dst),
104 byte_order,
105 error);
106 if (error.Success() && dest_size)
107 {
108 uint8_t src[RegisterValue::kMaxRegisterByteSize];
109
110 // Get the bytes for the source data.
111 const uint32_t src_size = value.GetAsMemoryData (reg_info, src, sizeof(src), byte_order, error);
112 if (error.Success() && src_size && (src_size < dest_size))
113 {
114 // Copy the src bytes to the destination.
115 memcpy (dst + (reg_info->byte_offset & 0x1), src, src_size);
116 // Set this full register as the value to write.
117 value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
118 value_to_write.SetType(full_reg_info);
119 reg_to_write = full_reg;
120 }
121 }
122 }
123 }
124
125 ProcessMonitor &monitor = GetMonitor();
126 // Account for the fact that 32-bit targets on powerpc64 really use 64-bit
127 // registers in ptrace, but expose here 32-bit registers with a higher
128 // offset.
129 uint64_t offset = GetRegisterOffset(reg_to_write);
130 offset &= ~(sizeof(uintptr_t) - 1);
131 return monitor.WriteRegisterValue(m_thread.GetID(),
132 offset,
133 GetRegisterName(reg_to_write),
134 value_to_write);
135}
136
137bool
138RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value)
139{
140 if (!reg_info)
141 return false;
142
143 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
144
145 if (IsFPR(reg))
146 {
147 if (!ReadFPR())
148 return false;
149 }
150 else
151 {
152 uint32_t full_reg = reg;
153 bool is_subreg = reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM(4294967295U));
154
155 if (is_subreg)
156 {
157 // Read the full aligned 64-bit register.
158 full_reg = reg_info->invalidate_regs[0];
159 }
160
161 bool success = ReadRegister(full_reg, value);
162
163 if (success)
164 {
165 // If our read was not aligned (for ah,bh,ch,dh), shift our returned value one byte to the right.
166 if (is_subreg && (reg_info->byte_offset & 0x1))
167 value.SetUInt64(value.GetAsUInt64() >> 8);
168
169 // If our return byte size was greater than the return value reg size, then
170 // use the type specified by reg_info rather than the uint64_t default
171 if (value.GetByteSize() > reg_info->byte_size)
172 value.SetType(reg_info);
173 }
174 return success;
175 }
176
177 return false;
178}
179
180bool
181RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &value)
182{
183 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
184
185 if (IsGPR(reg))
186 return WriteRegister(reg, value);
187
188 return false;
189}
190
191bool
192RegisterContextPOSIXProcessMonitor_powerpc::ReadAllRegisterValues(DataBufferSP &data_sp)
193{
194 bool success = false;
195 data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE(GetGPRSize()), 0));
196 if (data_sp && ReadGPR () && ReadFPR ())
197 {
198 uint8_t *dst = data_sp->GetBytes();
199 success = dst != 0;
200
201 if (success)
202 {
203 ::memcpy (dst, &m_gpr_powerpc, GetGPRSize());
204 dst += GetGPRSize();
205 }
206 }
207 return success;
208}
209
210bool
211RegisterContextPOSIXProcessMonitor_powerpc::WriteAllRegisterValues(const DataBufferSP &data_sp)
212{
213 bool success = false;
214 if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE(GetGPRSize()))
215 {
216 uint8_t *src = data_sp->GetBytes();
217 if (src)
218 {
219 ::memcpy (&m_gpr_powerpc, src, GetGPRSize());
220
221 if (WriteGPR())
222 {
223 src += GetGPRSize();
Value stored to 'src' is never read
224 }
225 }
226 }
227 return success;
228}
229
230uint32_t
231RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpoint(addr_t addr, size_t size,
232 bool read, bool write)
233{
234 const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
235 uint32_t hw_index;
236
237 for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index)
238 {
239 if (IsWatchpointVacant(hw_index))
240 return SetHardwareWatchpointWithIndex(addr, size,
241 read, write,
242 hw_index);
243 }
244
245 return LLDB_INVALID_INDEX32(4294967295U);
246}
247
248bool
249RegisterContextPOSIXProcessMonitor_powerpc::ClearHardwareWatchpoint(uint32_t hw_index)
250{
251 return false;
252}
253
254bool
255RegisterContextPOSIXProcessMonitor_powerpc::HardwareSingleStep(bool enable)
256{
257 return false;
258}
259
260bool
261RegisterContextPOSIXProcessMonitor_powerpc::UpdateAfterBreakpoint()
262{
263 lldb::addr_t pc;
264
265 if ((pc = GetPC()) == LLDB_INVALID_ADDRESS(18446744073709551615UL))
266 return false;
267
268 return true;
269}
270
271unsigned
272RegisterContextPOSIXProcessMonitor_powerpc::GetRegisterIndexFromOffset(unsigned offset)
273{
274 unsigned reg;
275 for (reg = 0; reg < k_num_registers_powerpc; reg++)
276 {
277 if (GetRegisterInfo()[reg].byte_offset == offset)
278 break;
279 }
280 assert(reg < k_num_registers_powerpc && "Invalid register offset.")((reg < k_num_registers_powerpc && "Invalid register offset."
) ? static_cast<void> (0) : __assert_fail ("reg < k_num_registers_powerpc && \"Invalid register offset.\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn227765/tools/lldb/source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_powerpc.cpp"
, 280, __PRETTY_FUNCTION__));
281 return reg;
282}
283
284bool
285RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointHit(uint32_t hw_index)
286{
287 return false;
288}
289
290bool
291RegisterContextPOSIXProcessMonitor_powerpc::ClearWatchpointHits()
292{
293 return false;
294}
295
296addr_t
297RegisterContextPOSIXProcessMonitor_powerpc::GetWatchpointAddress(uint32_t hw_index)
298{
299 return LLDB_INVALID_ADDRESS(18446744073709551615UL);
300}
301
302bool
303RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointVacant(uint32_t hw_index)
304{
305 return false;
306}
307
308bool
309RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpointWithIndex(addr_t addr, size_t size,
310 bool read, bool write,
311 uint32_t hw_index)
312{
313 return false;
314}
315
316uint32_t
317RegisterContextPOSIXProcessMonitor_powerpc::NumSupportedHardwareWatchpoints()
318{
319 return 0;
320}
321