contrib/llvm/tools/lldb/include/lldb/Core/ModuleSpec.h

   1 //===-- ModuleSpec.h --------------------------------------------*- 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 #ifndef liblldb_ModuleSpec_h_
  11 #define liblldb_ModuleSpec_h_
  12
  13 #include "lldb/Core/ArchSpec.h"
  14 #include "lldb/Core/Stream.h"
  15 #include "lldb/Core/UUID.h"
  16 #include "lldb/Host/FileSpec.h"
  17 #include "lldb/Target/PathMappingList.h"
  18
  19 namespace lldb_private {
  20
  21 class ModuleSpec
  22 {
  23 public:
  24     ModuleSpec () :
  25         m_file (),
  26         m_platform_file (),
  27         m_symbol_file (),
  28         m_arch (),
  29         m_uuid (),
  30         m_object_name (),
  31         m_object_offset (0),
  32         m_object_mod_time (),
  33         m_source_mappings ()
  34     {
  35     }
  36
  37     ModuleSpec (const FileSpec &file_spec) :
  38         m_file (file_spec),
  39         m_platform_file (),
  40         m_symbol_file (),
  41         m_arch (),
  42         m_uuid (),
  43         m_object_name (),
  44         m_object_offset (0),
  45         m_object_mod_time (),
  46         m_source_mappings ()
  47     {
  48     }
  49
  50     ModuleSpec (const FileSpec &file_spec, const ArchSpec &arch) :
  51         m_file (file_spec),
  52         m_platform_file (),
  53         m_symbol_file (),
  54         m_arch (arch),
  55         m_uuid (),
  56         m_object_name (),
  57         m_object_offset (0),
  58         m_object_mod_time (),
  59         m_source_mappings ()
  60     {
  61     }
  62
  63     ModuleSpec (const ModuleSpec &rhs) :
  64         m_file (rhs.m_file),
  65         m_platform_file (rhs.m_platform_file),
  66         m_symbol_file (rhs.m_symbol_file),
  67         m_arch (rhs.m_arch),
  68         m_uuid (rhs.m_uuid),
  69         m_object_name (rhs.m_object_name),
  70         m_object_offset (rhs.m_object_offset),
  71         m_object_mod_time (rhs.m_object_mod_time),
  72         m_source_mappings (rhs.m_source_mappings)
  73     {
  74     }
  75
  76     ModuleSpec &
  77     operator = (const ModuleSpec &rhs)
  78     {
  79         if (this != &rhs)
  80         {
  81             m_file = rhs.m_file;
  82             m_platform_file = rhs.m_platform_file;
  83             m_symbol_file = rhs.m_symbol_file;
  84             m_arch = rhs.m_arch;
  85             m_uuid = rhs.m_uuid;
  86             m_object_name = rhs.m_object_name;
  87             m_object_offset = rhs.m_object_offset;
  88             m_object_mod_time = rhs.m_object_mod_time;
  89             m_source_mappings = rhs.m_source_mappings;
  90         }
  91         return *this;
  92     }
  93
  94     FileSpec *
  95     GetFileSpecPtr ()
  96     {
  97         if (m_file)
  98             return &m_file;
  99         return NULL;
 100     }
 101
 102     const FileSpec *
 103     GetFileSpecPtr () const
 104     {
 105         if (m_file)
 106             return &m_file;
 107         return NULL;
 108     }
 109
 110     FileSpec &
 111     GetFileSpec ()
 112     {
 113         return m_file;
 114     }
 115     const FileSpec &
 116     GetFileSpec () const
 117     {
 118         return m_file;
 119     }
 120
 121     FileSpec *
 122     GetPlatformFileSpecPtr ()
 123     {
 124         if (m_platform_file)
 125             return &m_platform_file;
 126         return NULL;
 127     }
 128
 129     const FileSpec *
 130     GetPlatformFileSpecPtr () const
 131     {
 132         if (m_platform_file)
 133             return &m_platform_file;
 134         return NULL;
 135     }
 136
 137     FileSpec &
 138     GetPlatformFileSpec ()
 139     {
 140         return m_platform_file;
 141     }
 142
 143     const FileSpec &
 144     GetPlatformFileSpec () const
 145     {
 146         return m_platform_file;
 147     }
 148
 149     FileSpec *
 150     GetSymbolFileSpecPtr ()
 151     {
 152         if (m_symbol_file)
 153             return &m_symbol_file;
 154         return NULL;
 155     }
 156
 157     const FileSpec *
 158     GetSymbolFileSpecPtr () const
 159     {
 160         if (m_symbol_file)
 161             return &m_symbol_file;
 162         return NULL;
 163     }
 164
 165     FileSpec &
 166     GetSymbolFileSpec ()
 167     {
 168         return m_symbol_file;
 169     }
 170
 171     const FileSpec &
 172     GetSymbolFileSpec () const
 173     {
 174         return m_symbol_file;
 175     }
 176
 177
 178     ArchSpec *
 179     GetArchitecturePtr ()
 180     {
 181         if (m_arch.IsValid())
 182             return &m_arch;
 183         return NULL;
 184     }
 185
 186     const ArchSpec *
 187     GetArchitecturePtr () const
 188     {
 189         if (m_arch.IsValid())
 190             return &m_arch;
 191         return NULL;
 192     }
 193
 194     ArchSpec &
 195     GetArchitecture ()
 196     {
 197         return m_arch;
 198     }
 199
 200     const ArchSpec &
 201     GetArchitecture () const
 202     {
 203         return m_arch;
 204     }
 205
 206     UUID *
 207     GetUUIDPtr ()
 208     {
 209         if (m_uuid.IsValid())
 210             return &m_uuid;
 211         return NULL;
 212     }
 213
 214     const UUID *
 215     GetUUIDPtr () const
 216     {
 217         if (m_uuid.IsValid())
 218             return &m_uuid;
 219         return NULL;
 220     }
 221
 222     UUID &
 223     GetUUID ()
 224     {
 225         return m_uuid;
 226     }
 227
 228     const UUID &
 229     GetUUID () const
 230     {
 231         return m_uuid;
 232     }
 233
 234     ConstString &
 235     GetObjectName ()
 236     {
 237         return m_object_name;
 238     }
 239
 240     const ConstString &
 241     GetObjectName () const
 242     {
 243         return m_object_name;
 244     }
 245
 246     uint64_t
 247     GetObjectOffset () const
 248     {
 249         return m_object_offset;
 250     }
 251
 252     void
 253     SetObjectOffset (uint64_t object_offset)
 254     {
 255         m_object_offset = object_offset;
 256     }
 257
 258     TimeValue &
 259     GetObjectModificationTime ()
 260     {
 261         return m_object_mod_time;
 262     }
 263
 264     const TimeValue &
 265     GetObjectModificationTime () const
 266     {
 267         return m_object_mod_time;
 268     }
 269
 270     PathMappingList &
 271     GetSourceMappingList () const
 272     {
 273         return m_source_mappings;
 274     }
 275
 276     void
 277     Clear ()
 278     {
 279         m_file.Clear();
 280         m_platform_file.Clear();
 281         m_symbol_file.Clear();
 282         m_arch.Clear();
 283         m_uuid.Clear();
 284         m_object_name.Clear();
 285         m_object_offset = 0;
 286         m_source_mappings.Clear(false);
 287         m_object_mod_time.Clear();
 288     }
 289
 290
 291     explicit operator bool () const
 292     {
 293         if (m_file)
 294             return true;
 295         if (m_platform_file)
 296             return true;
 297         if (m_symbol_file)
 298             return true;
 299         if (m_arch.IsValid())
 300             return true;
 301         if (m_uuid.IsValid())
 302             return true;
 303         if (m_object_name)
 304             return true;
 305         if (m_object_mod_time.IsValid())
 306             return true;
 307         return false;
 308     }
 309
 310     void
 311     Dump (Stream &strm)
 312     {
 313         bool dumped_something = false;
 314         if (m_file)
 315         {
 316             strm.PutCString("file = '");
 317             strm << m_file;
 318             strm.PutCString("'");
 319             dumped_something = true;
 320         }
 321         if (m_platform_file)
 322         {
 323             if (dumped_something)
 324                 strm.PutCString(", ");
 325             strm.PutCString("platform_file = '");
 326             strm << m_platform_file;
 327             strm.PutCString("'");
 328             dumped_something = true;
 329         }
 330         if (m_symbol_file)
 331         {
 332             if (dumped_something)
 333                 strm.PutCString(", ");
 334             strm.PutCString("symbol_file = '");
 335             strm << m_symbol_file;
 336             strm.PutCString("'");
 337             dumped_something = true;
 338         }
 339         if (m_arch.IsValid())
 340         {
 341             if (dumped_something)
 342                 strm.PutCString(", ");
 343             strm.Printf("arch = %s", m_arch.GetTriple().str().c_str());
 344             dumped_something = true;
 345         }
 346         if (m_uuid.IsValid())
 347         {
 348             if (dumped_something)
 349                 strm.PutCString(", ");
 350             strm.PutCString("uuid = ");
 351             m_uuid.Dump(&strm);
 352             dumped_something = true;
 353         }
 354         if (m_object_name)
 355         {
 356             if (dumped_something)
 357                 strm.PutCString(", ");
 358             strm.Printf("object_name = %s", m_object_name.GetCString());
 359             dumped_something = true;
 360         }
 361         if (m_object_offset > 0)
 362         {
 363             if (dumped_something)
 364                 strm.PutCString(", ");
 365             strm.Printf("object_offset = 0x%" PRIx64, m_object_offset);
 366             dumped_something = true;
 367         }
 368         if (m_object_mod_time.IsValid())
 369         {
 370             if (dumped_something)
 371                 strm.PutCString(", ");
 372             strm.Printf("object_mod_time = 0x%" PRIx64, m_object_mod_time.GetAsSecondsSinceJan1_1970());
 373             dumped_something = true;
 374         }
 375     }
 376
 377     bool
 378     Matches (const ModuleSpec &match_module_spec, bool exact_arch_match) const
 379     {
 380         if (match_module_spec.GetUUIDPtr() && match_module_spec.GetUUID() != GetUUID())
 381             return false;
 382         if (match_module_spec.GetObjectName() && match_module_spec.GetObjectName() != GetObjectName())
 383             return false;
 384         if (match_module_spec.GetFileSpecPtr())
 385         {
 386             const FileSpec &fspec = match_module_spec.GetFileSpec();
 387             if (!FileSpec::Equal(fspec, GetFileSpec(), fspec.GetDirectory().IsEmpty() == false))
 388                 return false;
 389         }
 390         if (match_module_spec.GetPlatformFileSpecPtr())
 391         {
 392             const FileSpec &fspec = match_module_spec.GetPlatformFileSpec();
 393             if (!FileSpec::Equal(fspec, GetPlatformFileSpec(), fspec.GetDirectory().IsEmpty() == false))
 394                 return false;
 395
 396         }
 397         if (match_module_spec.GetSymbolFileSpecPtr())
 398         {
 399             const FileSpec &fspec = match_module_spec.GetSymbolFileSpec();
 400             if (!FileSpec::Equal(fspec, GetSymbolFileSpec(), fspec.GetDirectory().IsEmpty() == false))
 401                 return false;
 402
 403         }
 404         if (match_module_spec.GetArchitecturePtr())
 405         {
 406             if (exact_arch_match)
 407             {
 408                 if (!GetArchitecture().IsExactMatch(match_module_spec.GetArchitecture()))
 409                     return false;
 410             }
 411             else
 412             {
 413                 if (!GetArchitecture().IsCompatibleMatch(match_module_spec.GetArchitecture()))
 414                     return false;
 415             }
 416         }
 417         return true;
 418     }
 419
 420 protected:
 421     FileSpec m_file;
 422     FileSpec m_platform_file;
 423     FileSpec m_symbol_file;
 424     ArchSpec m_arch;
 425     UUID m_uuid;
 426     ConstString m_object_name;
 427     uint64_t m_object_offset;
 428     TimeValue m_object_mod_time;
 429     mutable PathMappingList m_source_mappings;
 430 };
 431
 432 class ModuleSpecList
 433 {
 434 public:
 435     ModuleSpecList () :
 436         m_specs(),
 437         m_mutex(Mutex::eMutexTypeRecursive)
 438     {
 439     }
 440
 441     ModuleSpecList (const ModuleSpecList &rhs) :
 442         m_specs(),
 443         m_mutex(Mutex::eMutexTypeRecursive)
 444     {
 445         Mutex::Locker lhs_locker(m_mutex);
 446         Mutex::Locker rhs_locker(rhs.m_mutex);
 447         m_specs = rhs.m_specs;
 448     }
 449
 450     ~ModuleSpecList ()
 451     {
 452     }
 453
 454     ModuleSpecList &
 455     operator = (const ModuleSpecList &rhs)
 456     {
 457         if (this != &rhs)
 458         {
 459             Mutex::Locker lhs_locker(m_mutex);
 460             Mutex::Locker rhs_locker(rhs.m_mutex);
 461             m_specs = rhs.m_specs;
 462         }
 463         return *this;
 464     }
 465
 466     size_t
 467     GetSize() const
 468     {
 469         Mutex::Locker locker(m_mutex);
 470         return m_specs.size();
 471     }
 472
 473     void
 474     Clear ()
 475     {
 476         Mutex::Locker locker(m_mutex);
 477         m_specs.clear();
 478     }
 479
 480     void
 481     Append (const ModuleSpec &spec)
 482     {
 483         Mutex::Locker locker(m_mutex);
 484         m_specs.push_back (spec);
 485     }
 486
 487     void
 488     Append (const ModuleSpecList &rhs)
 489     {
 490         Mutex::Locker lhs_locker(m_mutex);
 491         Mutex::Locker rhs_locker(rhs.m_mutex);
 492         m_specs.insert(m_specs.end(), rhs.m_specs.begin(), rhs.m_specs.end());
 493     }
 494
 495     // The index "i" must be valid and this can't be used in
 496     // multi-threaded code as no mutex lock is taken.
 497     ModuleSpec &
 498     GetModuleSpecRefAtIndex (size_t i)
 499     {
 500         return m_specs[i];
 501     }
 502     bool
 503     GetModuleSpecAtIndex (size_t i, ModuleSpec &module_spec) const
 504     {
 505         Mutex::Locker locker(m_mutex);
 506         if (i < m_specs.size())
 507         {
 508             module_spec = m_specs[i];
 509             return true;
 510         }
 511         module_spec.Clear();
 512         return false;
 513     }
 514
 515
 516     bool
 517     FindMatchingModuleSpec (const ModuleSpec &module_spec, ModuleSpec &match_module_spec) const
 518     {
 519         Mutex::Locker locker(m_mutex);
 520         bool exact_arch_match = true;
 521         for (auto spec: m_specs)
 522         {
 523             if (spec.Matches(module_spec, exact_arch_match))
 524             {
 525                 match_module_spec = spec;
 526                 return true;
 527             }
 528         }
 529
 530         // If there was an architecture, retry with a compatible arch
 531         if (module_spec.GetArchitecturePtr())
 532         {
 533             exact_arch_match = false;
 534             for (auto spec: m_specs)
 535             {
 536                 if (spec.Matches(module_spec, exact_arch_match))
 537                 {
 538                     match_module_spec = spec;
 539                     return true;
 540                 }
 541             }
 542         }
 543         match_module_spec.Clear();
 544         return false;
 545     }
 546
 547     size_t
 548     FindMatchingModuleSpecs (const ModuleSpec &module_spec, ModuleSpecList &matching_list) const
 549     {
 550         Mutex::Locker locker(m_mutex);
 551         bool exact_arch_match = true;
 552         const size_t initial_match_count = matching_list.GetSize();
 553         for (auto spec: m_specs)
 554         {
 555             if (spec.Matches(module_spec, exact_arch_match))
 556                 matching_list.Append (spec);
 557         }
 558
 559         // If there was an architecture, retry with a compatible arch if no matches were found
 560         if (module_spec.GetArchitecturePtr() && (initial_match_count == matching_list.GetSize()))
 561         {
 562             exact_arch_match = false;
 563             for (auto spec: m_specs)
 564             {
 565                 if (spec.Matches(module_spec, exact_arch_match))
 566                     matching_list.Append (spec);
 567             }
 568         }
 569         return matching_list.GetSize() - initial_match_count;
 570     }
 571
 572     void
 573     Dump (Stream &strm)
 574     {
 575         Mutex::Locker locker(m_mutex);
 576         uint32_t idx = 0;
 577         for (auto spec: m_specs)
 578         {
 579             strm.Printf("[%u] ", idx);
 580             spec.Dump (strm);
 581             strm.EOL();
 582             ++idx;
 583         }
 584     }
 585
 586 protected:
 587     typedef std::vector<ModuleSpec> collection; ///< The module collection type.
 588     collection m_specs; ///< The collection of modules.
 589     mutable Mutex m_mutex;
 590 };
 591
 592 } // namespace lldb_private
 593
 594 #endif  // liblldb_ModuleSpec_h_