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) 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 m_row_list.insert(it, row_sp); 351 } 352 353 UnwindPlan::RowSP 354 UnwindPlan::GetRowForFunctionOffset (int offset) const 355 { 356 RowSP row; 357 if (!m_row_list.empty()) 358 { 359 if (offset == -1) 360 row = m_row_list.back(); 361 else 362 { 363 collection::const_iterator pos, end = m_row_list.end(); 364 for (pos = m_row_list.begin(); pos != end; ++pos) 365 { 366 if ((*pos)->GetOffset() <= static_cast<lldb::offset_t>(offset)) 367 row = *pos; 368 else 369 break; 370 } 371 } 372 } 373 return row; 374 } 375 376 bool 377 UnwindPlan::IsValidRowIndex (uint32_t idx) const 378 { 379 return idx < m_row_list.size(); 380 } 381 382 const UnwindPlan::RowSP 383 UnwindPlan::GetRowAtIndex (uint32_t idx) const 384 { 385 // You must call IsValidRowIndex(idx) first before calling this!!! 386 assert (idx < m_row_list.size()); 387 return m_row_list[idx]; 388 } 389 390 const UnwindPlan::RowSP 391 UnwindPlan::GetLastRow () const 392 { 393 // You must call GetRowCount() first to make sure there is at least one row 394 assert (!m_row_list.empty()); 395 return m_row_list.back(); 396 } 397 398 int 399 UnwindPlan::GetRowCount () const 400 { 401 return m_row_list.size (); 402 } 403 404 void 405 UnwindPlan::SetPlanValidAddressRange (const AddressRange& range) 406 { 407 if (range.GetBaseAddress().IsValid() && range.GetByteSize() != 0) 408 m_plan_valid_address_range = range; 409 } 410 411 bool 412 UnwindPlan::PlanValidAtAddress (Address addr) 413 { 414 // If this UnwindPlan has no rows, it is an invalid UnwindPlan. 415 if (GetRowCount() == 0) 416 { 417 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND)); 418 if (log) 419 { 420 StreamString s; 421 if (addr.Dump (&s, nullptr, Address::DumpStyleSectionNameOffset)) 422 { 423 log->Printf ("UnwindPlan is invalid -- no unwind rows for UnwindPlan '%s' at address %s", 424 m_source_name.GetCString(), s.GetData()); 425 } 426 else 427 { 428 log->Printf ("UnwindPlan is invalid -- no unwind rows for UnwindPlan '%s'", 429 m_source_name.GetCString()); 430 } 431 } 432 return false; 433 } 434 435 // If the 0th Row of unwind instructions is missing, or if it doesn't provide 436 // a register to use to find the Canonical Frame Address, this is not a valid UnwindPlan. 437 if (GetRowAtIndex(0).get() == nullptr || 438 GetRowAtIndex(0)->GetCFAValue().GetValueType() == Row::CFAValue::unspecified) 439 { 440 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND)); 441 if (log) 442 { 443 StreamString s; 444 if (addr.Dump (&s, nullptr, Address::DumpStyleSectionNameOffset)) 445 { 446 log->Printf ("UnwindPlan is invalid -- no CFA register defined in row 0 for UnwindPlan '%s' at address %s", 447 m_source_name.GetCString(), s.GetData()); 448 } 449 else 450 { 451 log->Printf ("UnwindPlan is invalid -- no CFA register defined in row 0 for UnwindPlan '%s'", 452 m_source_name.GetCString()); 453 } 454 } 455 return false; 456 } 457 458 if (!m_plan_valid_address_range.GetBaseAddress().IsValid() || m_plan_valid_address_range.GetByteSize() == 0) 459 return true; 460 461 if (!addr.IsValid()) 462 return true; 463 464 if (m_plan_valid_address_range.ContainsFileAddress (addr)) 465 return true; 466 467 return false; 468 } 469 470 void 471 UnwindPlan::Dump (Stream& s, Thread *thread, lldb::addr_t base_addr) const 472 { 473 if (!m_source_name.IsEmpty()) 474 { 475 s.Printf ("This UnwindPlan originally sourced from %s\n", m_source_name.GetCString()); 476 } 477 if (m_lsda_address.IsValid() && m_personality_func_addr.IsValid()) 478 { 479 TargetSP target_sp(thread->CalculateTarget()); 480 addr_t lsda_load_addr = m_lsda_address.GetLoadAddress (target_sp.get()); 481 addr_t personality_func_load_addr = m_personality_func_addr.GetLoadAddress (target_sp.get()); 482 483 if (lsda_load_addr != LLDB_INVALID_ADDRESS && personality_func_load_addr != LLDB_INVALID_ADDRESS) 484 { 485 s.Printf("LSDA address 0x%" PRIx64 ", personality routine is at address 0x%" PRIx64 "\n", 486 lsda_load_addr, personality_func_load_addr); 487 } 488 } 489 s.Printf ("This UnwindPlan is sourced from the compiler: "); 490 switch (m_plan_is_sourced_from_compiler) 491 { 492 case eLazyBoolYes: 493 s.Printf ("yes.\n"); 494 break; 495 case eLazyBoolNo: 496 s.Printf ("no.\n"); 497 break; 498 case eLazyBoolCalculate: 499 s.Printf ("not specified.\n"); 500 break; 501 } 502 s.Printf ("This UnwindPlan is valid at all instruction locations: "); 503 switch (m_plan_is_valid_at_all_instruction_locations) 504 { 505 case eLazyBoolYes: 506 s.Printf ("yes.\n"); 507 break; 508 case eLazyBoolNo: 509 s.Printf ("no.\n"); 510 break; 511 case eLazyBoolCalculate: 512 s.Printf ("not specified.\n"); 513 break; 514 } 515 if (m_plan_valid_address_range.GetBaseAddress().IsValid() && m_plan_valid_address_range.GetByteSize() > 0) 516 { 517 s.PutCString ("Address range of this UnwindPlan: "); 518 TargetSP target_sp(thread->CalculateTarget()); 519 m_plan_valid_address_range.Dump (&s, target_sp.get(), Address::DumpStyleSectionNameOffset); 520 s.EOL(); 521 } 522 collection::const_iterator pos, begin = m_row_list.begin(), end = m_row_list.end(); 523 for (pos = begin; pos != end; ++pos) 524 { 525 s.Printf ("row[%u]: ", (uint32_t)std::distance (begin, pos)); 526 (*pos)->Dump(s, this, thread, base_addr); 527 } 528 } 529 530 void 531 UnwindPlan::SetSourceName (const char *source) 532 { 533 m_source_name = ConstString (source); 534 } 535 536 ConstString 537 UnwindPlan::GetSourceName () const 538 { 539 return m_source_name; 540 } 541 542 const RegisterInfo * 543 UnwindPlan::GetRegisterInfo (Thread* thread, uint32_t unwind_reg) const 544 { 545 if (thread) 546 { 547 RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 548 if (reg_ctx) 549 { 550 uint32_t reg; 551 if (m_register_kind == eRegisterKindLLDB) 552 reg = unwind_reg; 553 else 554 reg = reg_ctx->ConvertRegisterKindToRegisterNumber (m_register_kind, unwind_reg); 555 if (reg != LLDB_INVALID_REGNUM) 556 return reg_ctx->GetRegisterInfoAtIndex (reg); 557 } 558 } 559 return nullptr; 560 } 561 562