1 //===-- UnwindPlan.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 "lldb/Symbol/UnwindPlan.h"
11 
12 #include "lldb/Core/ConstString.h"
13 #include "lldb/Core/Log.h"
14 #include "lldb/Target/Process.h"
15 #include "lldb/Target/RegisterContext.h"
16 #include "lldb/Target/Thread.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 bool
22 UnwindPlan::Row::RegisterLocation::operator == (const UnwindPlan::Row::RegisterLocation& rhs) const
23 {
24     if (m_type == rhs.m_type)
25     {
26         switch (m_type)
27         {
28             case unspecified:
29             case undefined:
30             case same:
31                 return true;
32 
33             case atCFAPlusOffset:
34             case isCFAPlusOffset:
35                 return m_location.offset == rhs.m_location.offset;
36 
37             case inOtherRegister:
38                 return m_location.reg_num == rhs.m_location.reg_num;
39 
40             case atDWARFExpression:
41             case isDWARFExpression:
42                 if (m_location.expr.length == rhs.m_location.expr.length)
43                     return !memcmp (m_location.expr.opcodes, rhs.m_location.expr.opcodes, m_location.expr.length);
44                 break;
45         }
46     }
47     return false;
48 }
49 
50 // This function doesn't copy the dwarf expression bytes; they must remain in allocated
51 // memory for the lifespan of this UnwindPlan object.
52 void
53 UnwindPlan::Row::RegisterLocation::SetAtDWARFExpression (const uint8_t *opcodes, uint32_t len)
54 {
55     m_type = atDWARFExpression;
56     m_location.expr.opcodes = opcodes;
57     m_location.expr.length = len;
58 }
59 
60 // This function doesn't copy the dwarf expression bytes; they must remain in allocated
61 // memory for the lifespan of this UnwindPlan object.
62 void
63 UnwindPlan::Row::RegisterLocation::SetIsDWARFExpression (const uint8_t *opcodes, uint32_t len)
64 {
65     m_type = isDWARFExpression;
66     m_location.expr.opcodes = opcodes;
67     m_location.expr.length = len;
68 }
69 
70 void
71 UnwindPlan::Row::RegisterLocation::Dump (Stream &s, const UnwindPlan* unwind_plan, const UnwindPlan::Row* row, Thread* thread, bool verbose) const
72 {
73     switch (m_type)
74     {
75         case unspecified:
76             if (verbose)
77                 s.PutCString ("=<unspec>");
78             else
79                 s.PutCString ("=!");
80             break;
81         case undefined:
82             if (verbose)
83                 s.PutCString ("=<undef>");
84             else
85                 s.PutCString ("=?");
86             break;
87         case same:
88             s.PutCString ("= <same>");
89             break;
90 
91         case atCFAPlusOffset:
92         case isCFAPlusOffset:
93             {
94                 s.PutChar('=');
95                 if (m_type == atCFAPlusOffset)
96                     s.PutChar('[');
97                 if (verbose)
98                     s.Printf ("CFA%+d", m_location.offset);
99 
100                 if (unwind_plan && row)
101                 {
102                     const uint32_t cfa_reg = row->GetCFARegister();
103                     const RegisterInfo *cfa_reg_info = unwind_plan->GetRegisterInfo (thread, cfa_reg);
104                     const int32_t offset = row->GetCFAOffset() + m_location.offset;
105                     if (verbose)
106                     {
107                         if (cfa_reg_info)
108                             s.Printf (" (%s%+d)",  cfa_reg_info->name, offset);
109                         else
110                             s.Printf (" (reg(%u)%+d)",  cfa_reg, offset);
111                     }
112                     else
113                     {
114                         if (cfa_reg_info)
115                             s.Printf ("%s",  cfa_reg_info->name);
116                         else
117                             s.Printf ("reg(%u)",  cfa_reg);
118                         if (offset != 0)
119                             s.Printf ("%+d", offset);
120                     }
121                 }
122                 if (m_type == atCFAPlusOffset)
123                     s.PutChar(']');
124             }
125             break;
126 
127         case inOtherRegister:
128             {
129                 const RegisterInfo *other_reg_info = nullptr;
130                 if (unwind_plan)
131                     other_reg_info = unwind_plan->GetRegisterInfo (thread, m_location.reg_num);
132                 if (other_reg_info)
133                     s.Printf ("=%s", other_reg_info->name);
134                 else
135                     s.Printf ("=reg(%u)", m_location.reg_num);
136             }
137             break;
138 
139         case atDWARFExpression:
140         case isDWARFExpression:
141             {
142                 s.PutChar('=');
143                 if (m_type == atDWARFExpression)
144                     s.PutCString("[dwarf-expr]");
145                 else
146                     s.PutCString("dwarf-expr");
147             }
148             break;
149 
150     }
151 }
152 
153 void
154 UnwindPlan::Row::Clear ()
155 {
156     m_offset = 0;
157     m_cfa_reg_num = LLDB_INVALID_REGNUM;
158     m_cfa_offset = 0;
159     m_register_locations.clear();
160 }
161 
162 void
163 UnwindPlan::Row::Dump (Stream& s, const UnwindPlan* unwind_plan, Thread* thread, addr_t base_addr) const
164 {
165     const RegisterInfo *reg_info = unwind_plan->GetRegisterInfo (thread, GetCFARegister());
166 
167     if (base_addr != LLDB_INVALID_ADDRESS)
168         s.Printf ("0x%16.16" PRIx64 ": CFA=", base_addr + GetOffset());
169     else
170         s.Printf ("0x%8.8" PRIx64 ": CFA=", GetOffset());
171 
172     if (reg_info)
173         s.Printf ("%s", reg_info->name);
174     else
175         s.Printf ("reg(%u)", GetCFARegister());
176     s.Printf ("%+3d => ", GetCFAOffset ());
177     for (collection::const_iterator idx = m_register_locations.begin (); idx != m_register_locations.end (); ++idx)
178     {
179         reg_info = unwind_plan->GetRegisterInfo (thread, idx->first);
180         if (reg_info)
181             s.Printf ("%s", reg_info->name);
182         else
183             s.Printf ("reg(%u)", idx->first);
184         const bool verbose = false;
185         idx->second.Dump(s, unwind_plan, this, thread, verbose);
186         s.PutChar (' ');
187     }
188     s.EOL();
189 }
190 
191 UnwindPlan::Row::Row() :
192     m_offset(0),
193     m_cfa_reg_num(LLDB_INVALID_REGNUM),
194     m_cfa_offset(0),
195     m_register_locations()
196 {
197 }
198 
199 bool
200 UnwindPlan::Row::GetRegisterInfo (uint32_t reg_num, UnwindPlan::Row::RegisterLocation& register_location) const
201 {
202     collection::const_iterator pos = m_register_locations.find(reg_num);
203     if (pos != m_register_locations.end())
204     {
205         register_location = pos->second;
206         return true;
207     }
208     return false;
209 }
210 
211 void
212 UnwindPlan::Row::SetRegisterInfo (uint32_t reg_num, const UnwindPlan::Row::RegisterLocation register_location)
213 {
214     m_register_locations[reg_num] = register_location;
215 }
216 
217 bool
218 UnwindPlan::Row::SetRegisterLocationToAtCFAPlusOffset (uint32_t reg_num, int32_t offset, bool can_replace)
219 {
220     if (!can_replace && m_register_locations.find(reg_num) != m_register_locations.end())
221         return false;
222     RegisterLocation reg_loc;
223     reg_loc.SetAtCFAPlusOffset(offset);
224     m_register_locations[reg_num] = reg_loc;
225     return true;
226 }
227 
228 bool
229 UnwindPlan::Row::SetRegisterLocationToIsCFAPlusOffset (uint32_t reg_num, int32_t offset, bool can_replace)
230 {
231     if (!can_replace && m_register_locations.find(reg_num) != m_register_locations.end())
232         return false;
233     RegisterLocation reg_loc;
234     reg_loc.SetIsCFAPlusOffset(offset);
235     m_register_locations[reg_num] = reg_loc;
236     return true;
237 }
238 
239 bool
240 UnwindPlan::Row::SetRegisterLocationToUndefined (uint32_t reg_num, bool can_replace, bool can_replace_only_if_unspecified)
241 {
242     collection::iterator pos = m_register_locations.find(reg_num);
243     collection::iterator end = m_register_locations.end();
244 
245     if (pos != end)
246     {
247         if (!can_replace)
248             return false;
249         if (can_replace_only_if_unspecified && !pos->second.IsUnspecified())
250             return false;
251     }
252     RegisterLocation reg_loc;
253     reg_loc.SetUndefined();
254     m_register_locations[reg_num] = reg_loc;
255     return true;
256 }
257 
258 bool
259 UnwindPlan::Row::SetRegisterLocationToUnspecified (uint32_t reg_num, bool can_replace)
260 {
261     if (!can_replace && m_register_locations.find(reg_num) != m_register_locations.end())
262         return false;
263     RegisterLocation reg_loc;
264     reg_loc.SetUnspecified();
265     m_register_locations[reg_num] = reg_loc;
266     return true;
267 }
268 
269 bool
270 UnwindPlan::Row::SetRegisterLocationToRegister (uint32_t reg_num,
271                                                 uint32_t other_reg_num,
272                                                 bool can_replace)
273 {
274     if (!can_replace && m_register_locations.find(reg_num) != m_register_locations.end())
275         return false;
276     RegisterLocation reg_loc;
277     reg_loc.SetInRegister(other_reg_num);
278     m_register_locations[reg_num] = reg_loc;
279     return true;
280 }
281 
282 bool
283 UnwindPlan::Row::SetRegisterLocationToSame (uint32_t reg_num, bool must_replace)
284 {
285     if (must_replace && m_register_locations.find(reg_num) == m_register_locations.end())
286         return false;
287     RegisterLocation reg_loc;
288     reg_loc.SetSame();
289     m_register_locations[reg_num] = reg_loc;
290     return true;
291 }
292 
293 void
294 UnwindPlan::Row::SetCFARegister (uint32_t reg_num)
295 {
296     m_cfa_reg_num = reg_num;
297 }
298 
299 bool
300 UnwindPlan::Row::operator == (const UnwindPlan::Row& rhs) const
301 {
302     if (m_offset != rhs.m_offset || m_cfa_reg_num != rhs.m_cfa_reg_num || m_cfa_offset != rhs.m_cfa_offset)
303         return false;
304     return m_register_locations == rhs.m_register_locations;
305 }
306 
307 void
308 UnwindPlan::AppendRow (const UnwindPlan::RowSP &row_sp)
309 {
310     if (m_row_list.empty() || m_row_list.back()->GetOffset() != row_sp->GetOffset())
311         m_row_list.push_back(row_sp);
312     else
313         m_row_list.back() = row_sp;
314 }
315 
316 void
317 UnwindPlan::InsertRow (const UnwindPlan::RowSP &row_sp)
318 {
319     collection::iterator it = m_row_list.begin();
320     while (it != m_row_list.end()) {
321         RowSP row = *it;
322         if (row->GetOffset() > row_sp->GetOffset())
323             break;
324         it++;
325     }
326     m_row_list.insert(it, row_sp);
327 }
328 
329 UnwindPlan::RowSP
330 UnwindPlan::GetRowForFunctionOffset (int offset) const
331 {
332     RowSP row;
333     if (!m_row_list.empty())
334     {
335         if (offset == -1)
336             row = m_row_list.back();
337         else
338         {
339             collection::const_iterator pos, end = m_row_list.end();
340             for (pos = m_row_list.begin(); pos != end; ++pos)
341             {
342                 if ((*pos)->GetOffset() <= static_cast<lldb::offset_t>(offset))
343                     row = *pos;
344                 else
345                     break;
346             }
347         }
348     }
349     return row;
350 }
351 
352 bool
353 UnwindPlan::IsValidRowIndex (uint32_t idx) const
354 {
355     return idx < m_row_list.size();
356 }
357 
358 const UnwindPlan::RowSP
359 UnwindPlan::GetRowAtIndex (uint32_t idx) const
360 {
361     // You must call IsValidRowIndex(idx) first before calling this!!!
362     assert (idx < m_row_list.size());
363     return m_row_list[idx];
364 }
365 
366 const UnwindPlan::RowSP
367 UnwindPlan::GetLastRow () const
368 {
369     // You must call GetRowCount() first to make sure there is at least one row
370     assert (!m_row_list.empty());
371     return m_row_list.back();
372 }
373 
374 int
375 UnwindPlan::GetRowCount () const
376 {
377     return m_row_list.size ();
378 }
379 
380 void
381 UnwindPlan::SetPlanValidAddressRange (const AddressRange& range)
382 {
383    if (range.GetBaseAddress().IsValid() && range.GetByteSize() != 0)
384        m_plan_valid_address_range = range;
385 }
386 
387 bool
388 UnwindPlan::PlanValidAtAddress (Address addr)
389 {
390     // If this UnwindPlan has no rows, it is an invalid UnwindPlan.
391     if (GetRowCount() == 0)
392     {
393         Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
394         if (log)
395         {
396             StreamString s;
397             if (addr.Dump (&s, nullptr, Address::DumpStyleSectionNameOffset))
398             {
399                 log->Printf ("UnwindPlan is invalid -- no unwind rows for UnwindPlan '%s' at address %s",
400                              m_source_name.GetCString(), s.GetData());
401             }
402             else
403             {
404                 log->Printf ("UnwindPlan is invalid -- no unwind rows for UnwindPlan '%s'",
405                              m_source_name.GetCString());
406             }
407         }
408         return false;
409     }
410 
411     // If the 0th Row of unwind instructions is missing, or if it doesn't provide
412     // a register to use to find the Canonical Frame Address, this is not a valid UnwindPlan.
413     if (GetRowAtIndex(0).get() == nullptr || GetRowAtIndex(0)->GetCFARegister() == LLDB_INVALID_REGNUM)
414     {
415         Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
416         if (log)
417         {
418             StreamString s;
419             if (addr.Dump (&s, nullptr, Address::DumpStyleSectionNameOffset))
420             {
421                 log->Printf ("UnwindPlan is invalid -- no CFA register defined in row 0 for UnwindPlan '%s' at address %s",
422                              m_source_name.GetCString(), s.GetData());
423             }
424             else
425             {
426                 log->Printf ("UnwindPlan is invalid -- no CFA register defined in row 0 for UnwindPlan '%s'",
427                              m_source_name.GetCString());
428             }
429         }
430         return false;
431     }
432 
433     if (!m_plan_valid_address_range.GetBaseAddress().IsValid() || m_plan_valid_address_range.GetByteSize() == 0)
434         return true;
435 
436     if (!addr.IsValid())
437         return true;
438 
439     if (m_plan_valid_address_range.ContainsFileAddress (addr))
440         return true;
441 
442     return false;
443 }
444 
445 void
446 UnwindPlan::Dump (Stream& s, Thread *thread, lldb::addr_t base_addr) const
447 {
448     if (!m_source_name.IsEmpty())
449     {
450         s.Printf ("This UnwindPlan originally sourced from %s\n", m_source_name.GetCString());
451     }
452     if (m_plan_valid_address_range.GetBaseAddress().IsValid() && m_plan_valid_address_range.GetByteSize() > 0)
453     {
454         s.PutCString ("Address range of this UnwindPlan: ");
455         TargetSP target_sp(thread->CalculateTarget());
456         m_plan_valid_address_range.Dump (&s, target_sp.get(), Address::DumpStyleSectionNameOffset);
457         s.EOL();
458     }
459     collection::const_iterator pos, begin = m_row_list.begin(), end = m_row_list.end();
460     for (pos = begin; pos != end; ++pos)
461     {
462         s.Printf ("row[%u]: ", (uint32_t)std::distance (begin, pos));
463         (*pos)->Dump(s, this, thread, base_addr);
464     }
465 }
466 
467 void
468 UnwindPlan::SetSourceName (const char *source)
469 {
470     m_source_name = ConstString (source);
471 }
472 
473 ConstString
474 UnwindPlan::GetSourceName () const
475 {
476     return m_source_name;
477 }
478 
479 const RegisterInfo *
480 UnwindPlan::GetRegisterInfo (Thread* thread, uint32_t unwind_reg) const
481 {
482     if (thread)
483     {
484         RegisterContext *reg_ctx = thread->GetRegisterContext().get();
485         if (reg_ctx)
486         {
487             uint32_t reg;
488             if (m_register_kind == eRegisterKindLLDB)
489                 reg = unwind_reg;
490             else
491                 reg = reg_ctx->ConvertRegisterKindToRegisterNumber (m_register_kind, unwind_reg);
492             if (reg != LLDB_INVALID_REGNUM)
493                 return reg_ctx->GetRegisterInfoAtIndex (reg);
494         }
495     }
496     return nullptr;
497 }
498 
499