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