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