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                 s.Printf ("CFA%+d", m_location.offset);
98                 if (m_type == atCFAPlusOffset)
99                     s.PutChar(']');
100             }
101             break;
102 
103         case inOtherRegister:
104             {
105                 const RegisterInfo *other_reg_info = nullptr;
106                 if (unwind_plan)
107                     other_reg_info = unwind_plan->GetRegisterInfo (thread, m_location.reg_num);
108                 if (other_reg_info)
109                     s.Printf ("=%s", other_reg_info->name);
110                 else
111                     s.Printf ("=reg(%u)", m_location.reg_num);
112             }
113             break;
114 
115         case atDWARFExpression:
116         case isDWARFExpression:
117             {
118                 s.PutChar('=');
119                 if (m_type == atDWARFExpression)
120                     s.PutCString("[dwarf-expr]");
121                 else
122                     s.PutCString("dwarf-expr");
123             }
124             break;
125 
126     }
127 }
128 
129 static void
130 DumpRegisterName (Stream &s, const UnwindPlan* unwind_plan, Thread *thread, uint32_t reg_num) {
131     const RegisterInfo *reg_info = unwind_plan->GetRegisterInfo (thread, reg_num);
132     if (reg_info)
133         s.PutCString (reg_info->name);
134     else
135         s.Printf ("reg(%u)", reg_num);
136 }
137 
138 bool
139 UnwindPlan::Row::CFAValue::operator == (const UnwindPlan::Row::CFAValue& rhs) const
140 {
141     if (m_type == rhs.m_type)
142     {
143         switch (m_type)
144         {
145             case unspecified:
146                 return true;
147 
148             case isRegisterPlusOffset:
149                 return m_value.reg.offset == rhs.m_value.reg.offset;
150 
151             case isRegisterDereferenced:
152                 return m_value.reg.reg_num == rhs.m_value.reg.reg_num;
153 
154             case isDWARFExpression:
155                 if (m_value.expr.length == rhs.m_value.expr.length)
156                     return !memcmp (m_value.expr.opcodes, rhs.m_value.expr.opcodes, m_value.expr.length);
157                 break;
158         }
159     }
160     return false;
161 }
162 
163 void
164 UnwindPlan::Row::CFAValue::Dump(Stream &s, const UnwindPlan* unwind_plan, Thread* thread) const
165 {
166     switch(m_type) {
167     case isRegisterPlusOffset:
168         DumpRegisterName(s, unwind_plan, thread, m_value.reg.reg_num);
169         s.Printf ("%+3d", m_value.reg.offset);
170         break;
171     case isRegisterDereferenced:
172         s.PutChar ('[');
173         DumpRegisterName(s, unwind_plan, thread, m_value.reg.reg_num);
174         s.PutChar (']');
175         break;
176     case isDWARFExpression:
177         s.PutCString ("dwarf-expr");
178         break;
179     default:
180         s.PutCString ("unspecified");
181         break;
182     }
183 }
184 
185 void
186 UnwindPlan::Row::Clear ()
187 {
188     m_cfa_value.SetUnspecified();
189     m_offset = 0;
190     m_register_locations.clear();
191 }
192 
193 void
194 UnwindPlan::Row::Dump (Stream& s, const UnwindPlan* unwind_plan, Thread* thread, addr_t base_addr) const
195 {
196     if (base_addr != LLDB_INVALID_ADDRESS)
197         s.Printf ("0x%16.16" PRIx64 ": CFA=", base_addr + GetOffset());
198     else
199         s.Printf ("%4" PRId64 ": CFA=", GetOffset());
200 
201     m_cfa_value.Dump(s, unwind_plan, thread);
202     s.Printf(" => ");
203     for (collection::const_iterator idx = m_register_locations.begin (); idx != m_register_locations.end (); ++idx)
204     {
205         DumpRegisterName(s, unwind_plan, thread, idx->first);
206         const bool verbose = false;
207         idx->second.Dump(s, unwind_plan, this, thread, verbose);
208         s.PutChar (' ');
209     }
210     s.EOL();
211 }
212 
213 UnwindPlan::Row::Row() :
214     m_offset (0),
215     m_cfa_value (),
216     m_register_locations ()
217 {
218 }
219 
220 bool
221 UnwindPlan::Row::GetRegisterInfo (uint32_t reg_num, UnwindPlan::Row::RegisterLocation& register_location) const
222 {
223     collection::const_iterator pos = m_register_locations.find(reg_num);
224     if (pos != m_register_locations.end())
225     {
226         register_location = pos->second;
227         return true;
228     }
229     return false;
230 }
231 
232 void
233 UnwindPlan::Row::RemoveRegisterInfo (uint32_t reg_num)
234 {
235     collection::const_iterator pos = m_register_locations.find(reg_num);
236     if (pos != m_register_locations.end())
237     {
238         m_register_locations.erase(pos);
239     }
240 }
241 
242 void
243 UnwindPlan::Row::SetRegisterInfo (uint32_t reg_num, const UnwindPlan::Row::RegisterLocation register_location)
244 {
245     m_register_locations[reg_num] = register_location;
246 }
247 
248 bool
249 UnwindPlan::Row::SetRegisterLocationToAtCFAPlusOffset (uint32_t reg_num, int32_t offset, bool can_replace)
250 {
251     if (!can_replace && m_register_locations.find(reg_num) != m_register_locations.end())
252         return false;
253     RegisterLocation reg_loc;
254     reg_loc.SetAtCFAPlusOffset(offset);
255     m_register_locations[reg_num] = reg_loc;
256     return true;
257 }
258 
259 bool
260 UnwindPlan::Row::SetRegisterLocationToIsCFAPlusOffset (uint32_t reg_num, int32_t offset, bool can_replace)
261 {
262     if (!can_replace && m_register_locations.find(reg_num) != m_register_locations.end())
263         return false;
264     RegisterLocation reg_loc;
265     reg_loc.SetIsCFAPlusOffset(offset);
266     m_register_locations[reg_num] = reg_loc;
267     return true;
268 }
269 
270 bool
271 UnwindPlan::Row::SetRegisterLocationToUndefined (uint32_t reg_num, bool can_replace, bool can_replace_only_if_unspecified)
272 {
273     collection::iterator pos = m_register_locations.find(reg_num);
274     collection::iterator end = m_register_locations.end();
275 
276     if (pos != end)
277     {
278         if (!can_replace)
279             return false;
280         if (can_replace_only_if_unspecified && !pos->second.IsUnspecified())
281             return false;
282     }
283     RegisterLocation reg_loc;
284     reg_loc.SetUndefined();
285     m_register_locations[reg_num] = reg_loc;
286     return true;
287 }
288 
289 bool
290 UnwindPlan::Row::SetRegisterLocationToUnspecified (uint32_t reg_num, bool can_replace)
291 {
292     if (!can_replace && m_register_locations.find(reg_num) != m_register_locations.end())
293         return false;
294     RegisterLocation reg_loc;
295     reg_loc.SetUnspecified();
296     m_register_locations[reg_num] = reg_loc;
297     return true;
298 }
299 
300 bool
301 UnwindPlan::Row::SetRegisterLocationToRegister (uint32_t reg_num,
302                                                 uint32_t other_reg_num,
303                                                 bool can_replace)
304 {
305     if (!can_replace && m_register_locations.find(reg_num) != m_register_locations.end())
306         return false;
307     RegisterLocation reg_loc;
308     reg_loc.SetInRegister(other_reg_num);
309     m_register_locations[reg_num] = reg_loc;
310     return true;
311 }
312 
313 bool
314 UnwindPlan::Row::SetRegisterLocationToSame (uint32_t reg_num, bool must_replace)
315 {
316     if (must_replace && m_register_locations.find(reg_num) == m_register_locations.end())
317         return false;
318     RegisterLocation reg_loc;
319     reg_loc.SetSame();
320     m_register_locations[reg_num] = reg_loc;
321     return true;
322 }
323 
324 bool
325 UnwindPlan::Row::operator == (const UnwindPlan::Row& rhs) const
326 {
327     return m_offset == rhs.m_offset && m_cfa_value == rhs.m_cfa_value &&
328         m_register_locations == rhs.m_register_locations;
329 }
330 
331 void
332 UnwindPlan::AppendRow (const UnwindPlan::RowSP &row_sp)
333 {
334     if (m_row_list.empty() || m_row_list.back()->GetOffset() != row_sp->GetOffset())
335         m_row_list.push_back(row_sp);
336     else
337         m_row_list.back() = row_sp;
338 }
339 
340 void
341 UnwindPlan::InsertRow (const UnwindPlan::RowSP &row_sp, bool replace_existing)
342 {
343     collection::iterator it = m_row_list.begin();
344     while (it != m_row_list.end()) {
345         RowSP row = *it;
346         if (row->GetOffset() >= row_sp->GetOffset())
347             break;
348         it++;
349     }
350     if (it == m_row_list.end() || (*it)->GetOffset() != row_sp->GetOffset())
351         m_row_list.insert(it, row_sp);
352     else if (replace_existing)
353         *it = row_sp;
354 }
355 
356 UnwindPlan::RowSP
357 UnwindPlan::GetRowForFunctionOffset (int offset) const
358 {
359     RowSP row;
360     if (!m_row_list.empty())
361     {
362         if (offset == -1)
363             row = m_row_list.back();
364         else
365         {
366             collection::const_iterator pos, end = m_row_list.end();
367             for (pos = m_row_list.begin(); pos != end; ++pos)
368             {
369                 if ((*pos)->GetOffset() <= static_cast<lldb::offset_t>(offset))
370                     row = *pos;
371                 else
372                     break;
373             }
374         }
375     }
376     return row;
377 }
378 
379 bool
380 UnwindPlan::IsValidRowIndex (uint32_t idx) const
381 {
382     return idx < m_row_list.size();
383 }
384 
385 const UnwindPlan::RowSP
386 UnwindPlan::GetRowAtIndex (uint32_t idx) const
387 {
388     if (idx < m_row_list.size())
389         return m_row_list[idx];
390     else
391     {
392         Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
393         if (log)
394             log->Printf ("error: UnwindPlan::GetRowAtIndex(idx = %u) invalid index (number rows is %u)", idx, (uint32_t)m_row_list.size());
395         return UnwindPlan::RowSP();
396     }
397 }
398 
399 const UnwindPlan::RowSP
400 UnwindPlan::GetLastRow () const
401 {
402     if (m_row_list.empty())
403     {
404         Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
405         if (log)
406             log->Printf ("UnwindPlan::GetLastRow() when rows are empty");
407         return UnwindPlan::RowSP();
408     }
409     return m_row_list.back();
410 }
411 
412 int
413 UnwindPlan::GetRowCount () const
414 {
415     return m_row_list.size ();
416 }
417 
418 void
419 UnwindPlan::SetPlanValidAddressRange (const AddressRange& range)
420 {
421    if (range.GetBaseAddress().IsValid() && range.GetByteSize() != 0)
422        m_plan_valid_address_range = range;
423 }
424 
425 bool
426 UnwindPlan::PlanValidAtAddress (Address addr)
427 {
428     // If this UnwindPlan has no rows, it is an invalid UnwindPlan.
429     if (GetRowCount() == 0)
430     {
431         Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
432         if (log)
433         {
434             StreamString s;
435             if (addr.Dump (&s, nullptr, Address::DumpStyleSectionNameOffset))
436             {
437                 log->Printf ("UnwindPlan is invalid -- no unwind rows for UnwindPlan '%s' at address %s",
438                              m_source_name.GetCString(), s.GetData());
439             }
440             else
441             {
442                 log->Printf ("UnwindPlan is invalid -- no unwind rows for UnwindPlan '%s'",
443                              m_source_name.GetCString());
444             }
445         }
446         return false;
447     }
448 
449     // If the 0th Row of unwind instructions is missing, or if it doesn't provide
450     // a register to use to find the Canonical Frame Address, this is not a valid UnwindPlan.
451     if (GetRowAtIndex(0).get() == nullptr ||
452             GetRowAtIndex(0)->GetCFAValue().GetValueType() == Row::CFAValue::unspecified)
453     {
454         Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
455         if (log)
456         {
457             StreamString s;
458             if (addr.Dump (&s, nullptr, Address::DumpStyleSectionNameOffset))
459             {
460                 log->Printf ("UnwindPlan is invalid -- no CFA register defined in row 0 for UnwindPlan '%s' at address %s",
461                              m_source_name.GetCString(), s.GetData());
462             }
463             else
464             {
465                 log->Printf ("UnwindPlan is invalid -- no CFA register defined in row 0 for UnwindPlan '%s'",
466                              m_source_name.GetCString());
467             }
468         }
469         return false;
470     }
471 
472     if (!m_plan_valid_address_range.GetBaseAddress().IsValid() || m_plan_valid_address_range.GetByteSize() == 0)
473         return true;
474 
475     if (!addr.IsValid())
476         return true;
477 
478     if (m_plan_valid_address_range.ContainsFileAddress (addr))
479         return true;
480 
481     return false;
482 }
483 
484 void
485 UnwindPlan::Dump (Stream& s, Thread *thread, lldb::addr_t base_addr) const
486 {
487     if (!m_source_name.IsEmpty())
488     {
489         s.Printf ("This UnwindPlan originally sourced from %s\n", m_source_name.GetCString());
490     }
491     if (m_lsda_address.IsValid() && m_personality_func_addr.IsValid())
492     {
493         TargetSP target_sp(thread->CalculateTarget());
494         addr_t lsda_load_addr = m_lsda_address.GetLoadAddress (target_sp.get());
495         addr_t personality_func_load_addr = m_personality_func_addr.GetLoadAddress (target_sp.get());
496 
497         if (lsda_load_addr != LLDB_INVALID_ADDRESS && personality_func_load_addr != LLDB_INVALID_ADDRESS)
498         {
499             s.Printf("LSDA address 0x%" PRIx64 ", personality routine is at address 0x%" PRIx64 "\n",
500                      lsda_load_addr, personality_func_load_addr);
501         }
502     }
503     s.Printf ("This UnwindPlan is sourced from the compiler: ");
504     switch (m_plan_is_sourced_from_compiler)
505     {
506         case eLazyBoolYes:
507             s.Printf ("yes.\n");
508             break;
509         case eLazyBoolNo:
510             s.Printf ("no.\n");
511             break;
512         case eLazyBoolCalculate:
513             s.Printf ("not specified.\n");
514             break;
515     }
516     s.Printf ("This UnwindPlan is valid at all instruction locations: ");
517     switch (m_plan_is_valid_at_all_instruction_locations)
518     {
519         case eLazyBoolYes:
520             s.Printf ("yes.\n");
521             break;
522         case eLazyBoolNo:
523             s.Printf ("no.\n");
524             break;
525         case eLazyBoolCalculate:
526             s.Printf ("not specified.\n");
527             break;
528     }
529     if (m_plan_valid_address_range.GetBaseAddress().IsValid() && m_plan_valid_address_range.GetByteSize() > 0)
530     {
531         s.PutCString ("Address range of this UnwindPlan: ");
532         TargetSP target_sp(thread->CalculateTarget());
533         m_plan_valid_address_range.Dump (&s, target_sp.get(), Address::DumpStyleSectionNameOffset);
534         s.EOL();
535     }
536     collection::const_iterator pos, begin = m_row_list.begin(), end = m_row_list.end();
537     for (pos = begin; pos != end; ++pos)
538     {
539         s.Printf ("row[%u]: ", (uint32_t)std::distance (begin, pos));
540         (*pos)->Dump(s, this, thread, base_addr);
541     }
542 }
543 
544 void
545 UnwindPlan::SetSourceName (const char *source)
546 {
547     m_source_name = ConstString (source);
548 }
549 
550 ConstString
551 UnwindPlan::GetSourceName () const
552 {
553     return m_source_name;
554 }
555 
556 const RegisterInfo *
557 UnwindPlan::GetRegisterInfo (Thread* thread, uint32_t unwind_reg) const
558 {
559     if (thread)
560     {
561         RegisterContext *reg_ctx = thread->GetRegisterContext().get();
562         if (reg_ctx)
563         {
564             uint32_t reg;
565             if (m_register_kind == eRegisterKindLLDB)
566                 reg = unwind_reg;
567             else
568                 reg = reg_ctx->ConvertRegisterKindToRegisterNumber (m_register_kind, unwind_reg);
569             if (reg != LLDB_INVALID_REGNUM)
570                 return reg_ctx->GetRegisterInfoAtIndex (reg);
571         }
572     }
573     return nullptr;
574 }
575 
576