contrib/llvm/tools/lldb/source/Symbol/UnwindPlan.cpp

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