1 //===-- NSDictionary.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/lldb-python.h" 11 12 #include "lldb/DataFormatters/CXXFormatterFunctions.h" 13 14 #include "lldb/Core/DataBufferHeap.h" 15 #include "lldb/Core/Error.h" 16 #include "lldb/Core/Stream.h" 17 #include "lldb/Core/ValueObject.h" 18 #include "lldb/Core/ValueObjectConstResult.h" 19 #include "lldb/Host/Endian.h" 20 #include "lldb/Symbol/ClangASTContext.h" 21 #include "lldb/Target/ObjCLanguageRuntime.h" 22 #include "lldb/Target/Target.h" 23 24 #include "clang/AST/DeclCXX.h" 25 26 using namespace lldb; 27 using namespace lldb_private; 28 using namespace lldb_private::formatters; 29 30 static ClangASTType 31 GetLLDBNSPairType (TargetSP target_sp) 32 { 33 ClangASTType clang_type; 34 35 ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext(); 36 37 if (target_ast_context) 38 { 39 clang::ASTContext *ast = target_ast_context->getASTContext(); 40 41 if (ast) 42 { 43 const char* type_name = "__lldb_autogen_nspair"; 44 45 clang::IdentifierInfo &myIdent = ast->Idents.get(type_name); 46 clang::DeclarationName myName = ast->DeclarationNames.getIdentifier(&myIdent); 47 48 clang::DeclContext::lookup_const_result result = ast->getTranslationUnitDecl()->lookup(myName); 49 50 for (clang::NamedDecl *named_decl : result) 51 { 52 if (const clang::CXXRecordDecl *record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(named_decl)) 53 { 54 clang_type.SetClangType(ast, clang::QualType(record_decl->getTypeForDecl(), 0)); 55 break; 56 } 57 else 58 { 59 // somebody else (the user?) has defined a type with the magic name already - fail!!! 60 return clang_type; 61 } 62 } 63 64 if (!clang_type) 65 { 66 clang_type = target_ast_context->CreateRecordType(NULL, lldb::eAccessPublic, type_name, clang::TTK_Struct, lldb::eLanguageTypeC); 67 68 if (clang_type) 69 { 70 clang_type.StartTagDeclarationDefinition(); 71 ClangASTType id_clang_type = target_ast_context->GetBasicType (eBasicTypeObjCID); 72 clang_type.AddFieldToRecordType("key", id_clang_type, lldb::eAccessPublic, 0); 73 clang_type.AddFieldToRecordType("value", id_clang_type, lldb::eAccessPublic, 0); 74 clang_type.CompleteTagDeclarationDefinition(); 75 } 76 } 77 } 78 } 79 return clang_type; 80 } 81 82 template<bool name_entries> 83 bool 84 lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream) 85 { 86 ProcessSP process_sp = valobj.GetProcessSP(); 87 if (!process_sp) 88 return false; 89 90 ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); 91 92 if (!runtime) 93 return false; 94 95 ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj)); 96 97 if (!descriptor.get() || !descriptor->IsValid()) 98 return false; 99 100 uint32_t ptr_size = process_sp->GetAddressByteSize(); 101 bool is_64bit = (ptr_size == 8); 102 103 lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0); 104 105 if (!valobj_addr) 106 return false; 107 108 uint64_t value = 0; 109 110 const char* class_name = descriptor->GetClassName().GetCString(); 111 112 if (!class_name || !*class_name) 113 return false; 114 115 if (!strcmp(class_name,"__NSDictionaryI")) 116 { 117 Error error; 118 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); 119 if (error.Fail()) 120 return false; 121 value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U); 122 } 123 else if (!strcmp(class_name,"__NSDictionaryM")) 124 { 125 Error error; 126 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error); 127 if (error.Fail()) 128 return false; 129 value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U); 130 } 131 /*else if (!strcmp(class_name,"__NSCFDictionary")) 132 { 133 Error error; 134 value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + (is_64bit ? 20 : 12), 4, 0, error); 135 if (error.Fail()) 136 return false; 137 if (is_64bit) 138 value &= ~0x0f1f000000000000UL; 139 }*/ 140 else 141 { 142 if (!ExtractValueFromObjCExpression(valobj, "int", "count", value)) 143 return false; 144 } 145 146 stream.Printf("%s%" PRIu64 " %s%s", 147 (name_entries ? "@\"" : ""), 148 value, 149 (name_entries ? (value == 1 ? "entry" : "entries") : (value == 1 ? "key/value pair" : "key/value pairs")), 150 (name_entries ? "\"" : "")); 151 return true; 152 } 153 154 SyntheticChildrenFrontEnd* lldb_private::formatters::NSDictionarySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) 155 { 156 157 lldb::ProcessSP process_sp (valobj_sp->GetProcessSP()); 158 if (!process_sp) 159 return NULL; 160 ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC); 161 if (!runtime) 162 return NULL; 163 164 if (!valobj_sp->IsPointerType()) 165 { 166 Error error; 167 valobj_sp = valobj_sp->AddressOf(error); 168 if (error.Fail() || !valobj_sp) 169 return NULL; 170 } 171 172 ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get())); 173 174 if (!descriptor.get() || !descriptor->IsValid()) 175 return NULL; 176 177 const char* class_name = descriptor->GetClassName().GetCString(); 178 179 if (!class_name || !*class_name) 180 return NULL; 181 182 if (!strcmp(class_name,"__NSDictionaryI")) 183 { 184 return (new NSDictionaryISyntheticFrontEnd(valobj_sp)); 185 } 186 else if (!strcmp(class_name,"__NSDictionaryM")) 187 { 188 return (new NSDictionaryMSyntheticFrontEnd(valobj_sp)); 189 } 190 else 191 { 192 return (new NSDictionaryCodeRunningSyntheticFrontEnd(valobj_sp)); 193 } 194 } 195 196 lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : 197 SyntheticChildrenFrontEnd(*valobj_sp.get()) 198 {} 199 200 size_t 201 lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::CalculateNumChildren () 202 { 203 uint64_t count = 0; 204 if (ExtractValueFromObjCExpression(m_backend, "int", "count", count)) 205 return count; 206 return 0; 207 } 208 209 lldb::ValueObjectSP 210 lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx) 211 { 212 StreamString idx_name; 213 idx_name.Printf("[%zu]",idx); 214 StreamString key_fetcher_expr; 215 key_fetcher_expr.Printf("(id)[(NSArray*)[(id)0x%" PRIx64 " allKeys] objectAtIndex:%zu]",m_backend.GetPointerValue(),idx); 216 StreamString value_fetcher_expr; 217 value_fetcher_expr.Printf("(id)[(id)0x%" PRIx64 " objectForKey:(%s)]",m_backend.GetPointerValue(),key_fetcher_expr.GetData()); 218 StreamString object_fetcher_expr; 219 object_fetcher_expr.Printf("struct __lldb_autogen_nspair { id key; id value; } _lldb_valgen_item; _lldb_valgen_item.key = %s; _lldb_valgen_item.value = %s; _lldb_valgen_item;",key_fetcher_expr.GetData(),value_fetcher_expr.GetData()); 220 lldb::ValueObjectSP child_sp; 221 m_backend.GetTargetSP()->EvaluateExpression(object_fetcher_expr.GetData(), m_backend.GetFrameSP().get(), child_sp, 222 EvaluateExpressionOptions().SetKeepInMemory(true)); 223 if (child_sp) 224 child_sp->SetName(ConstString(idx_name.GetData())); 225 return child_sp; 226 } 227 228 bool 229 lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::Update() 230 { 231 return false; 232 } 233 234 bool 235 lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::MightHaveChildren () 236 { 237 return true; 238 } 239 240 size_t 241 lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) 242 { 243 return 0; 244 } 245 246 lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::~NSDictionaryCodeRunningSyntheticFrontEnd () 247 {} 248 249 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : 250 SyntheticChildrenFrontEnd(*valobj_sp.get()), 251 m_exe_ctx_ref(), 252 m_ptr_size(8), 253 m_order(lldb::eByteOrderInvalid), 254 m_data_32(NULL), 255 m_data_64(NULL), 256 m_pair_type() 257 { 258 } 259 260 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::~NSDictionaryISyntheticFrontEnd () 261 { 262 delete m_data_32; 263 m_data_32 = NULL; 264 delete m_data_64; 265 m_data_64 = NULL; 266 } 267 268 size_t 269 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) 270 { 271 const char* item_name = name.GetCString(); 272 uint32_t idx = ExtractIndexFromString(item_name); 273 if (idx < UINT32_MAX && idx >= CalculateNumChildren()) 274 return UINT32_MAX; 275 return idx; 276 } 277 278 size_t 279 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::CalculateNumChildren () 280 { 281 if (!m_data_32 && !m_data_64) 282 return 0; 283 return (m_data_32 ? m_data_32->_used : m_data_64->_used); 284 } 285 286 bool 287 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::Update() 288 { 289 m_children.clear(); 290 delete m_data_32; 291 m_data_32 = NULL; 292 delete m_data_64; 293 m_data_64 = NULL; 294 m_ptr_size = 0; 295 ValueObjectSP valobj_sp = m_backend.GetSP(); 296 if (!valobj_sp) 297 return false; 298 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); 299 Error error; 300 error.Clear(); 301 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); 302 if (!process_sp) 303 return false; 304 m_ptr_size = process_sp->GetAddressByteSize(); 305 m_order = process_sp->GetByteOrder(); 306 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; 307 if (m_ptr_size == 4) 308 { 309 m_data_32 = new DataDescriptor_32(); 310 process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error); 311 } 312 else 313 { 314 m_data_64 = new DataDescriptor_64(); 315 process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error); 316 } 317 if (error.Fail()) 318 return false; 319 m_data_ptr = data_location + m_ptr_size; 320 return false; 321 } 322 323 bool 324 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::MightHaveChildren () 325 { 326 return true; 327 } 328 329 lldb::ValueObjectSP 330 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex (size_t idx) 331 { 332 uint32_t num_children = CalculateNumChildren(); 333 334 if (idx >= num_children) 335 return lldb::ValueObjectSP(); 336 337 if (m_children.empty()) 338 { 339 // do the scan phase 340 lldb::addr_t key_at_idx = 0, val_at_idx = 0; 341 342 uint32_t tries = 0; 343 uint32_t test_idx = 0; 344 345 while(tries < num_children) 346 { 347 key_at_idx = m_data_ptr + (2*test_idx * m_ptr_size); 348 val_at_idx = key_at_idx + m_ptr_size; 349 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); 350 if (!process_sp) 351 return lldb::ValueObjectSP(); 352 Error error; 353 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error); 354 if (error.Fail()) 355 return lldb::ValueObjectSP(); 356 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error); 357 if (error.Fail()) 358 return lldb::ValueObjectSP(); 359 360 test_idx++; 361 362 if (!key_at_idx || !val_at_idx) 363 continue; 364 tries++; 365 366 DictionaryItemDescriptor descriptor = {key_at_idx,val_at_idx,lldb::ValueObjectSP()}; 367 368 m_children.push_back(descriptor); 369 } 370 } 371 372 if (idx >= m_children.size()) // should never happen 373 return lldb::ValueObjectSP(); 374 375 DictionaryItemDescriptor &dict_item = m_children[idx]; 376 if (!dict_item.valobj_sp) 377 { 378 if (!m_pair_type.IsValid()) 379 { 380 TargetSP target_sp(m_backend.GetTargetSP()); 381 if (!target_sp) 382 return ValueObjectSP(); 383 m_pair_type = GetLLDBNSPairType(target_sp); 384 } 385 if (!m_pair_type.IsValid()) 386 return ValueObjectSP(); 387 388 DataBufferSP buffer_sp(new DataBufferHeap(2*m_ptr_size,0)); 389 390 if (m_ptr_size == 8) 391 { 392 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes(); 393 *data_ptr = dict_item.key_ptr; 394 *(data_ptr+1) = dict_item.val_ptr; 395 } 396 else 397 { 398 uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes(); 399 *data_ptr = dict_item.key_ptr; 400 *(data_ptr+1) = dict_item.val_ptr; 401 } 402 403 StreamString idx_name; 404 idx_name.Printf("[%zu]",idx); 405 DataExtractor data(buffer_sp, m_order, m_ptr_size); 406 dict_item.valobj_sp = ValueObject::CreateValueObjectFromData(idx_name.GetData(), data, m_exe_ctx_ref, m_pair_type); 407 } 408 return dict_item.valobj_sp; 409 } 410 411 lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : 412 SyntheticChildrenFrontEnd(*valobj_sp.get()), 413 m_exe_ctx_ref(), 414 m_ptr_size(8), 415 m_order(lldb::eByteOrderInvalid), 416 m_data_32(NULL), 417 m_data_64(NULL), 418 m_pair_type() 419 { 420 } 421 422 lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd () 423 { 424 delete m_data_32; 425 m_data_32 = NULL; 426 delete m_data_64; 427 m_data_64 = NULL; 428 } 429 430 size_t 431 lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) 432 { 433 const char* item_name = name.GetCString(); 434 uint32_t idx = ExtractIndexFromString(item_name); 435 if (idx < UINT32_MAX && idx >= CalculateNumChildren()) 436 return UINT32_MAX; 437 return idx; 438 } 439 440 size_t 441 lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::CalculateNumChildren () 442 { 443 if (!m_data_32 && !m_data_64) 444 return 0; 445 return (m_data_32 ? m_data_32->_used : m_data_64->_used); 446 } 447 448 bool 449 lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::Update() 450 { 451 m_children.clear(); 452 ValueObjectSP valobj_sp = m_backend.GetSP(); 453 m_ptr_size = 0; 454 delete m_data_32; 455 m_data_32 = NULL; 456 delete m_data_64; 457 m_data_64 = NULL; 458 if (!valobj_sp) 459 return false; 460 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); 461 Error error; 462 error.Clear(); 463 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); 464 if (!process_sp) 465 return false; 466 m_ptr_size = process_sp->GetAddressByteSize(); 467 m_order = process_sp->GetByteOrder(); 468 uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size; 469 if (m_ptr_size == 4) 470 { 471 m_data_32 = new DataDescriptor_32(); 472 process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error); 473 } 474 else 475 { 476 m_data_64 = new DataDescriptor_64(); 477 process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error); 478 } 479 if (error.Fail()) 480 return false; 481 return false; 482 } 483 484 bool 485 lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::MightHaveChildren () 486 { 487 return true; 488 } 489 490 lldb::ValueObjectSP 491 lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::GetChildAtIndex (size_t idx) 492 { 493 lldb::addr_t m_keys_ptr = (m_data_32 ? m_data_32->_keys_addr : m_data_64->_keys_addr); 494 lldb::addr_t m_values_ptr = (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr); 495 496 uint32_t num_children = CalculateNumChildren(); 497 498 if (idx >= num_children) 499 return lldb::ValueObjectSP(); 500 501 if (m_children.empty()) 502 { 503 // do the scan phase 504 lldb::addr_t key_at_idx = 0, val_at_idx = 0; 505 506 uint32_t tries = 0; 507 uint32_t test_idx = 0; 508 509 while(tries < num_children) 510 { 511 key_at_idx = m_keys_ptr + (test_idx * m_ptr_size); 512 val_at_idx = m_values_ptr + (test_idx * m_ptr_size);; 513 ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); 514 if (!process_sp) 515 return lldb::ValueObjectSP(); 516 Error error; 517 key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error); 518 if (error.Fail()) 519 return lldb::ValueObjectSP(); 520 val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error); 521 if (error.Fail()) 522 return lldb::ValueObjectSP(); 523 524 test_idx++; 525 526 if (!key_at_idx || !val_at_idx) 527 continue; 528 tries++; 529 530 DictionaryItemDescriptor descriptor = {key_at_idx,val_at_idx,lldb::ValueObjectSP()}; 531 532 m_children.push_back(descriptor); 533 } 534 } 535 536 if (idx >= m_children.size()) // should never happen 537 return lldb::ValueObjectSP(); 538 539 DictionaryItemDescriptor &dict_item = m_children[idx]; 540 if (!dict_item.valobj_sp) 541 { 542 if (!m_pair_type.IsValid()) 543 { 544 TargetSP target_sp(m_backend.GetTargetSP()); 545 if (!target_sp) 546 return ValueObjectSP(); 547 m_pair_type = GetLLDBNSPairType(target_sp); 548 } 549 if (!m_pair_type.IsValid()) 550 return ValueObjectSP(); 551 552 DataBufferSP buffer_sp(new DataBufferHeap(2*m_ptr_size,0)); 553 554 if (m_ptr_size == 8) 555 { 556 uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes(); 557 *data_ptr = dict_item.key_ptr; 558 *(data_ptr+1) = dict_item.val_ptr; 559 } 560 else 561 { 562 uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes(); 563 *data_ptr = dict_item.key_ptr; 564 *(data_ptr+1) = dict_item.val_ptr; 565 } 566 567 StreamString idx_name; 568 idx_name.Printf("[%zu]",idx); 569 DataExtractor data(buffer_sp, m_order, m_ptr_size); 570 dict_item.valobj_sp = ValueObject::CreateValueObjectFromData(idx_name.GetData(), data, m_exe_ctx_ref, m_pair_type); 571 } 572 return dict_item.valobj_sp; 573 } 574 575 template bool 576 lldb_private::formatters::NSDictionarySummaryProvider<true> (ValueObject&, Stream&) ; 577 578 template bool 579 lldb_private::formatters::NSDictionarySummaryProvider<false> (ValueObject&, Stream&) ; 580