contrib/llvm/tools/lldb/source/Target/ObjCLanguageRuntime.cpp

   1 //===-- ObjCLanguageRuntime.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 #include "clang/AST/Type.h"
  10
  11 #include "lldb/Core/Log.h"
  12 #include "lldb/Core/MappedHash.h"
  13 #include "lldb/Core/Module.h"
  14 #include "lldb/Core/PluginManager.h"
  15 #include "lldb/Core/Timer.h"
  16 #include "lldb/Core/ValueObject.h"
  17 #include "lldb/Symbol/ClangASTContext.h"
  18 #include "lldb/Symbol/Type.h"
  19 #include "lldb/Symbol/TypeList.h"
  20 #include "lldb/Target/ObjCLanguageRuntime.h"
  21 #include "lldb/Target/Target.h"
  22
  23 #include "llvm/ADT/StringRef.h"
  24
  25 using namespace lldb;
  26 using namespace lldb_private;
  27
  28 //----------------------------------------------------------------------
  29 // Destructor
  30 //----------------------------------------------------------------------
  31 ObjCLanguageRuntime::~ObjCLanguageRuntime()
  32 {
  33 }
  34
  35 ObjCLanguageRuntime::ObjCLanguageRuntime (Process *process) :
  36     LanguageRuntime (process),
  37     m_has_new_literals_and_indexing (eLazyBoolCalculate),
  38     m_isa_to_descriptor(),
  39     m_isa_to_descriptor_stop_id (UINT32_MAX)
  40 {
  41
  42 }
  43
  44 bool
  45 ObjCLanguageRuntime::AddClass (ObjCISA isa, const ClassDescriptorSP &descriptor_sp, const char *class_name)
  46 {
  47     if (isa != 0)
  48     {
  49         m_isa_to_descriptor[isa] = descriptor_sp;
  50         // class_name is assumed to be valid
  51         m_hash_to_isa_map.insert(std::make_pair(MappedHash::HashStringUsingDJB(class_name), isa));
  52         return true;
  53     }
  54     return false;
  55 }
  56
  57 void
  58 ObjCLanguageRuntime::AddToMethodCache (lldb::addr_t class_addr, lldb::addr_t selector, lldb::addr_t impl_addr)
  59 {
  60     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
  61     if (log)
  62     {
  63         log->Printf ("Caching: class 0x%" PRIx64 " selector 0x%" PRIx64 " implementation 0x%" PRIx64 ".", class_addr, selector, impl_addr);
  64     }
  65     m_impl_cache.insert (std::pair<ClassAndSel,lldb::addr_t> (ClassAndSel(class_addr, selector), impl_addr));
  66 }
  67
  68 lldb::addr_t
  69 ObjCLanguageRuntime::LookupInMethodCache (lldb::addr_t class_addr, lldb::addr_t selector)
  70 {
  71     MsgImplMap::iterator pos, end = m_impl_cache.end();
  72     pos = m_impl_cache.find (ClassAndSel(class_addr, selector));
  73     if (pos != end)
  74         return (*pos).second;
  75     return LLDB_INVALID_ADDRESS;
  76 }
  77
  78
  79 lldb::TypeSP
  80 ObjCLanguageRuntime::LookupInCompleteClassCache (ConstString &name)
  81 {
  82     CompleteClassMap::iterator complete_class_iter = m_complete_class_cache.find(name);
  83
  84     if (complete_class_iter != m_complete_class_cache.end())
  85     {
  86         // Check the weak pointer to make sure the type hasn't been unloaded
  87         TypeSP complete_type_sp (complete_class_iter->second.lock());
  88
  89         if (complete_type_sp)
  90             return complete_type_sp;
  91         else
  92             m_complete_class_cache.erase(name);
  93     }
  94
  95     if (m_negative_complete_class_cache.count(name) > 0)
  96         return TypeSP();
  97
  98     const ModuleList &modules = m_process->GetTarget().GetImages();
  99
 100     SymbolContextList sc_list;
 101     const size_t matching_symbols = modules.FindSymbolsWithNameAndType (name,
 102                                                                         eSymbolTypeObjCClass,
 103                                                                         sc_list);
 104
 105     if (matching_symbols)
 106     {
 107         SymbolContext sc;
 108
 109         sc_list.GetContextAtIndex(0, sc);
 110
 111         ModuleSP module_sp(sc.module_sp);
 112
 113         if (!module_sp)
 114             return TypeSP();
 115
 116         const SymbolContext null_sc;
 117         const bool exact_match = true;
 118         const uint32_t max_matches = UINT32_MAX;
 119         TypeList types;
 120
 121         const uint32_t num_types = module_sp->FindTypes (null_sc,
 122                                                          name,
 123                                                          exact_match,
 124                                                          max_matches,
 125                                                          types);
 126
 127         if (num_types)
 128         {
 129             uint32_t i;
 130             for (i = 0; i < num_types; ++i)
 131             {
 132                 TypeSP type_sp (types.GetTypeAtIndex(i));
 133
 134                 if (type_sp->GetClangForwardType().IsObjCObjectOrInterfaceType())
 135                 {
 136                     if (type_sp->IsCompleteObjCClass())
 137                     {
 138                         m_complete_class_cache[name] = type_sp;
 139                         return type_sp;
 140                     }
 141                 }
 142             }
 143         }
 144     }
 145     m_negative_complete_class_cache.insert(name);
 146     return TypeSP();
 147 }
 148
 149 size_t
 150 ObjCLanguageRuntime::GetByteOffsetForIvar (ClangASTType &parent_qual_type, const char *ivar_name)
 151 {
 152     return LLDB_INVALID_IVAR_OFFSET;
 153 }
 154
 155 void
 156 ObjCLanguageRuntime::MethodName::Clear()
 157 {
 158     m_full.Clear();
 159     m_class.Clear();
 160     m_category.Clear();
 161     m_selector.Clear();
 162     m_type = eTypeUnspecified;
 163     m_category_is_valid = false;
 164 }
 165
 166 //bool
 167 //ObjCLanguageRuntime::MethodName::SetName (const char *name, bool strict)
 168 //{
 169 //    Clear();
 170 //    if (name && name[0])
 171 //    {
 172 //        // If "strict" is true. then the method must be specified with a
 173 //        // '+' or '-' at the beginning. If "strict" is false, then the '+'
 174 //        // or '-' can be omitted
 175 //        bool valid_prefix = false;
 176 //
 177 //        if (name[0] == '+' || name[0] == '-')
 178 //        {
 179 //            valid_prefix = name[1] == '[';
 180 //        }
 181 //        else if (!strict)
 182 //        {
 183 //            // "strict" is false, the name just needs to start with '['
 184 //            valid_prefix = name[0] == '[';
 185 //        }
 186 //
 187 //        if (valid_prefix)
 188 //        {
 189 //            static RegularExpression g_regex("^([-+]?)\\[([A-Za-z_][A-Za-z_0-9]*)(\\([A-Za-z_][A-Za-z_0-9]*\\))? ([A-Za-z_][A-Za-z_0-9:]*)\\]$");
 190 //            llvm::StringRef matches[4];
 191 //            // Since we are using a global regular expression, we must use the threadsafe version of execute
 192 //            if (g_regex.ExecuteThreadSafe(name, matches, 4))
 193 //            {
 194 //                m_full.SetCString(name);
 195 //                if (matches[0].empty())
 196 //                    m_type = eTypeUnspecified;
 197 //                else if (matches[0][0] == '+')
 198 //                    m_type = eTypeClassMethod;
 199 //                else
 200 //                    m_type = eTypeInstanceMethod;
 201 //                m_class.SetString(matches[1]);
 202 //                m_selector.SetString(matches[3]);
 203 //                if (!matches[2].empty())
 204 //                    m_category.SetString(matches[2]);
 205 //            }
 206 //        }
 207 //    }
 208 //    return IsValid(strict);
 209 //}
 210
 211 bool
 212 ObjCLanguageRuntime::MethodName::SetName (const char *name, bool strict)
 213 {
 214     Clear();
 215     if (name && name[0])
 216     {
 217         // If "strict" is true. then the method must be specified with a
 218         // '+' or '-' at the beginning. If "strict" is false, then the '+'
 219         // or '-' can be omitted
 220         bool valid_prefix = false;
 221
 222         if (name[0] == '+' || name[0] == '-')
 223         {
 224             valid_prefix = name[1] == '[';
 225             if (name[0] == '+')
 226                 m_type = eTypeClassMethod;
 227             else
 228                 m_type = eTypeInstanceMethod;
 229         }
 230         else if (!strict)
 231         {
 232             // "strict" is false, the name just needs to start with '['
 233             valid_prefix = name[0] == '[';
 234         }
 235
 236         if (valid_prefix)
 237         {
 238             int name_len = strlen (name);
 239             // Objective C methods must have at least:
 240             //      "-[" or "+[" prefix
 241             //      One character for a class name
 242             //      One character for the space between the class name
 243             //      One character for the method name
 244             //      "]" suffix
 245             if (name_len >= (5 + (strict ? 1 : 0)) && name[name_len - 1] == ']')
 246             {
 247                 m_full.SetCStringWithLength(name, name_len);
 248             }
 249         }
 250     }
 251     return IsValid(strict);
 252 }
 253
 254 const ConstString &
 255 ObjCLanguageRuntime::MethodName::GetClassName ()
 256 {
 257     if (!m_class)
 258     {
 259         if (IsValid(false))
 260         {
 261             const char *full = m_full.GetCString();
 262             const char *class_start = (full[0] == '[' ? full + 1 : full + 2);
 263             const char *paren_pos = strchr (class_start, '(');
 264             if (paren_pos)
 265             {
 266                 m_class.SetCStringWithLength (class_start, paren_pos - class_start);
 267             }
 268             else
 269             {
 270                 // No '(' was found in the full name, we can definitively say
 271                 // that our category was valid (and empty).
 272                 m_category_is_valid = true;
 273                 const char *space_pos = strchr (full, ' ');
 274                 if (space_pos)
 275                 {
 276                     m_class.SetCStringWithLength (class_start, space_pos - class_start);
 277                     if (!m_class_category)
 278                     {
 279                         // No category in name, so we can also fill in the m_class_category
 280                         m_class_category = m_class;
 281                     }
 282                 }
 283             }
 284         }
 285     }
 286     return m_class;
 287 }
 288
 289 const ConstString &
 290 ObjCLanguageRuntime::MethodName::GetClassNameWithCategory ()
 291 {
 292     if (!m_class_category)
 293     {
 294         if (IsValid(false))
 295         {
 296             const char *full = m_full.GetCString();
 297             const char *class_start = (full[0] == '[' ? full + 1 : full + 2);
 298             const char *space_pos = strchr (full, ' ');
 299             if (space_pos)
 300             {
 301                 m_class_category.SetCStringWithLength (class_start, space_pos - class_start);
 302                 // If m_class hasn't been filled in and the class with category doesn't
 303                 // contain a '(', then we can also fill in the m_class
 304                 if (!m_class && strchr (m_class_category.GetCString(), '(') == NULL)
 305                 {
 306                     m_class = m_class_category;
 307                     // No '(' was found in the full name, we can definitively say
 308                     // that our category was valid (and empty).
 309                     m_category_is_valid = true;
 310
 311                 }
 312             }
 313         }
 314     }
 315     return m_class_category;
 316 }
 317
 318 const ConstString &
 319 ObjCLanguageRuntime::MethodName::GetSelector ()
 320 {
 321     if (!m_selector)
 322     {
 323         if (IsValid(false))
 324         {
 325             const char *full = m_full.GetCString();
 326             const char *space_pos = strchr (full, ' ');
 327             if (space_pos)
 328             {
 329                 ++space_pos; // skip the space
 330                 m_selector.SetCStringWithLength (space_pos, m_full.GetLength() - (space_pos - full) - 1);
 331             }
 332         }
 333     }
 334     return m_selector;
 335 }
 336
 337 const ConstString &
 338 ObjCLanguageRuntime::MethodName::GetCategory ()
 339 {
 340     if (!m_category_is_valid && !m_category)
 341     {
 342         if (IsValid(false))
 343         {
 344             m_category_is_valid = true;
 345             const char *full = m_full.GetCString();
 346             const char *class_start = (full[0] == '[' ? full + 1 : full + 2);
 347             const char *open_paren_pos = strchr (class_start, '(');
 348             if (open_paren_pos)
 349             {
 350                 ++open_paren_pos; // Skip the open paren
 351                 const char *close_paren_pos = strchr (open_paren_pos, ')');
 352                 if (close_paren_pos)
 353                     m_category.SetCStringWithLength (open_paren_pos, close_paren_pos - open_paren_pos);
 354             }
 355         }
 356     }
 357     return m_category;
 358 }
 359
 360 ConstString
 361 ObjCLanguageRuntime::MethodName::GetFullNameWithoutCategory (bool empty_if_no_category)
 362 {
 363     if (IsValid(false))
 364     {
 365         if (HasCategory())
 366         {
 367             StreamString strm;
 368             if (m_type == eTypeClassMethod)
 369                 strm.PutChar('+');
 370             else if (m_type == eTypeInstanceMethod)
 371                 strm.PutChar('-');
 372             strm.Printf("[%s %s]", GetClassName().GetCString(), GetSelector().GetCString());
 373             return ConstString(strm.GetString().c_str());
 374         }
 375
 376         if (!empty_if_no_category)
 377         {
 378             // Just return the full name since it doesn't have a category
 379             return GetFullName();
 380         }
 381     }
 382     return ConstString();
 383 }
 384
 385 size_t
 386 ObjCLanguageRuntime::MethodName::GetFullNames (std::vector<ConstString> &names, bool append)
 387 {
 388     if (!append)
 389         names.clear();
 390     if (IsValid(false))
 391     {
 392         StreamString strm;
 393         const bool is_class_method = m_type == eTypeClassMethod;
 394         const bool is_instance_method = m_type == eTypeInstanceMethod;
 395         const ConstString &category = GetCategory();
 396         if (is_class_method || is_instance_method)
 397         {
 398             names.push_back (m_full);
 399             if (category)
 400             {
 401                 strm.Printf("%c[%s %s]",
 402                             is_class_method ? '+' : '-',
 403                             GetClassName().GetCString(),
 404                             GetSelector().GetCString());
 405                 names.push_back(ConstString(strm.GetString().c_str()));
 406             }
 407         }
 408         else
 409         {
 410             const ConstString &class_name = GetClassName();
 411             const ConstString &selector = GetSelector();
 412             strm.Printf("+[%s %s]", class_name.GetCString(), selector.GetCString());
 413             names.push_back(ConstString(strm.GetString().c_str()));
 414             strm.Clear();
 415             strm.Printf("-[%s %s]", class_name.GetCString(), selector.GetCString());
 416             names.push_back(ConstString(strm.GetString().c_str()));
 417             strm.Clear();
 418             if (category)
 419             {
 420                 strm.Printf("+[%s(%s) %s]", class_name.GetCString(), category.GetCString(), selector.GetCString());
 421                 names.push_back(ConstString(strm.GetString().c_str()));
 422                 strm.Clear();
 423                 strm.Printf("-[%s(%s) %s]", class_name.GetCString(), category.GetCString(), selector.GetCString());
 424                 names.push_back(ConstString(strm.GetString().c_str()));
 425             }
 426         }
 427     }
 428     return names.size();
 429 }
 430
 431
 432 bool
 433 ObjCLanguageRuntime::ClassDescriptor::IsPointerValid (lldb::addr_t value,
 434                                                       uint32_t ptr_size,
 435                                                       bool allow_NULLs,
 436                                                       bool allow_tagged,
 437                                                       bool check_version_specific) const
 438 {
 439     if (!value)
 440         return allow_NULLs;
 441     if ( (value % 2) == 1  && allow_tagged)
 442         return true;
 443     if ((value % ptr_size) == 0)
 444         return (check_version_specific ? CheckPointer(value,ptr_size) : true);
 445     else
 446         return false;
 447 }
 448
 449 ObjCLanguageRuntime::ObjCISA
 450 ObjCLanguageRuntime::GetISA(const ConstString &name)
 451 {
 452     ISAToDescriptorIterator pos = GetDescriptorIterator (name);
 453     if (pos != m_isa_to_descriptor.end())
 454         return pos->first;
 455     return 0;
 456 }
 457
 458 ObjCLanguageRuntime::ISAToDescriptorIterator
 459 ObjCLanguageRuntime::GetDescriptorIterator (const ConstString &name)
 460 {
 461     ISAToDescriptorIterator end = m_isa_to_descriptor.end();
 462
 463     if (name)
 464     {
 465         UpdateISAToDescriptorMap();
 466         if (m_hash_to_isa_map.empty())
 467         {
 468             // No name hashes were provided, we need to just linearly power through the
 469             // names and find a match
 470             for (ISAToDescriptorIterator pos = m_isa_to_descriptor.begin(); pos != end; ++pos)
 471             {
 472                 if (pos->second->GetClassName() == name)
 473                     return pos;
 474             }
 475         }
 476         else
 477         {
 478             // Name hashes were provided, so use them to efficiently lookup name to isa/descriptor
 479             const uint32_t name_hash = MappedHash::HashStringUsingDJB (name.GetCString());
 480             std::pair <HashToISAIterator, HashToISAIterator> range = m_hash_to_isa_map.equal_range(name_hash);
 481             for (HashToISAIterator range_pos = range.first; range_pos != range.second; ++range_pos)
 482             {
 483                 ISAToDescriptorIterator pos = m_isa_to_descriptor.find (range_pos->second);
 484                 if (pos != m_isa_to_descriptor.end())
 485                 {
 486                     if (pos->second->GetClassName() == name)
 487                         return pos;
 488                 }
 489             }
 490         }
 491     }
 492     return end;
 493 }
 494
 495
 496 ObjCLanguageRuntime::ObjCISA
 497 ObjCLanguageRuntime::GetParentClass(ObjCLanguageRuntime::ObjCISA isa)
 498 {
 499     ClassDescriptorSP objc_class_sp (GetClassDescriptorFromISA(isa));
 500     if (objc_class_sp)
 501     {
 502         ClassDescriptorSP objc_super_class_sp (objc_class_sp->GetSuperclass());
 503         if (objc_super_class_sp)
 504             return objc_super_class_sp->GetISA();
 505     }
 506     return 0;
 507 }
 508
 509 ConstString
 510 ObjCLanguageRuntime::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa)
 511 {
 512     ClassDescriptorSP objc_class_sp (GetNonKVOClassDescriptor(isa));
 513     if (objc_class_sp)
 514         return objc_class_sp->GetClassName();
 515     return ConstString();
 516 }
 517
 518 ObjCLanguageRuntime::ClassDescriptorSP
 519 ObjCLanguageRuntime::GetClassDescriptorFromClassName (const ConstString &class_name)
 520 {
 521     ISAToDescriptorIterator pos = GetDescriptorIterator (class_name);
 522     if (pos != m_isa_to_descriptor.end())
 523         return pos->second;
 524     return ClassDescriptorSP();
 525
 526 }
 527
 528 ObjCLanguageRuntime::ClassDescriptorSP
 529 ObjCLanguageRuntime::GetClassDescriptor (ValueObject& valobj)
 530 {
 531     ClassDescriptorSP objc_class_sp;
 532     // if we get an invalid VO (which might still happen when playing around
 533     // with pointers returned by the expression parser, don't consider this
 534     // a valid ObjC object)
 535     if (valobj.GetClangType().IsValid())
 536     {
 537         addr_t isa_pointer = valobj.GetPointerValue();
 538         if (isa_pointer != LLDB_INVALID_ADDRESS)
 539         {
 540             ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
 541
 542             Process *process = exe_ctx.GetProcessPtr();
 543             if (process)
 544             {
 545                 Error error;
 546                 ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error);
 547                 if (isa != LLDB_INVALID_ADDRESS)
 548                     objc_class_sp = GetClassDescriptorFromISA (isa);
 549             }
 550         }
 551     }
 552     return objc_class_sp;
 553 }
 554
 555 ObjCLanguageRuntime::ClassDescriptorSP
 556 ObjCLanguageRuntime::GetNonKVOClassDescriptor (ValueObject& valobj)
 557 {
 558     ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp (GetClassDescriptor (valobj));
 559     if (objc_class_sp)
 560     {
 561         if (!objc_class_sp->IsKVO())
 562             return objc_class_sp;
 563
 564         ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass());
 565         if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid())
 566             return non_kvo_objc_class_sp;
 567     }
 568     return ClassDescriptorSP();
 569 }
 570
 571
 572 ObjCLanguageRuntime::ClassDescriptorSP
 573 ObjCLanguageRuntime::GetClassDescriptorFromISA (ObjCISA isa)
 574 {
 575     if (isa)
 576     {
 577         UpdateISAToDescriptorMap();
 578         ObjCLanguageRuntime::ISAToDescriptorIterator pos = m_isa_to_descriptor.find(isa);
 579         if (pos != m_isa_to_descriptor.end())
 580             return pos->second;
 581     }
 582     return ClassDescriptorSP();
 583 }
 584
 585 ObjCLanguageRuntime::ClassDescriptorSP
 586 ObjCLanguageRuntime::GetNonKVOClassDescriptor (ObjCISA isa)
 587 {
 588     if (isa)
 589     {
 590         ClassDescriptorSP objc_class_sp = GetClassDescriptorFromISA (isa);
 591         if (objc_class_sp && objc_class_sp->IsValid())
 592         {
 593             if (!objc_class_sp->IsKVO())
 594                 return objc_class_sp;
 595
 596             ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass());
 597             if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid())
 598                 return non_kvo_objc_class_sp;
 599         }
 600     }
 601     return ClassDescriptorSP();
 602 }
 603
 604
 605