contrib/llvm/tools/lldb/source/Core/Address.cpp

   1 //===-- Address.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/Core/Address.h"
  11 #include "lldb/Core/Module.h"
  12 #include "lldb/Core/Section.h"
  13 #include "lldb/Symbol/Block.h"
  14 #include "lldb/Symbol/ObjectFile.h"
  15 #include "lldb/Symbol/Variable.h"
  16 #include "lldb/Symbol/VariableList.h"
  17 #include "lldb/Target/ExecutionContext.h"
  18 #include "lldb/Target/Process.h"
  19 #include "lldb/Target/SectionLoadList.h"
  20 #include "lldb/Target/Target.h"
  21 #include "lldb/Symbol/SymbolVendor.h"
  22
  23 #include "llvm/ADT/Triple.h"
  24
  25 using namespace lldb;
  26 using namespace lldb_private;
  27
  28 static size_t
  29 ReadBytes (ExecutionContextScope *exe_scope, const Address &address, void *dst, size_t dst_len)
  30 {
  31     if (exe_scope == NULL)
  32         return 0;
  33
  34     TargetSP target_sp (exe_scope->CalculateTarget());
  35     if (target_sp)
  36     {
  37         Error error;
  38         bool prefer_file_cache = false;
  39         return target_sp->ReadMemory (address, prefer_file_cache, dst, dst_len, error);
  40     }
  41     return 0;
  42 }
  43
  44 static bool
  45 GetByteOrderAndAddressSize (ExecutionContextScope *exe_scope, const Address &address, ByteOrder& byte_order, uint32_t& addr_size)
  46 {
  47     byte_order = eByteOrderInvalid;
  48     addr_size = 0;
  49     if (exe_scope == NULL)
  50         return false;
  51
  52     TargetSP target_sp (exe_scope->CalculateTarget());
  53     if (target_sp)
  54     {
  55         byte_order = target_sp->GetArchitecture().GetByteOrder();
  56         addr_size = target_sp->GetArchitecture().GetAddressByteSize();
  57     }
  58
  59     if (byte_order == eByteOrderInvalid || addr_size == 0)
  60     {
  61         ModuleSP module_sp (address.GetModule());
  62         if (module_sp)
  63         {
  64             byte_order = module_sp->GetArchitecture().GetByteOrder();
  65             addr_size = module_sp->GetArchitecture().GetAddressByteSize();
  66         }
  67     }
  68     return byte_order != eByteOrderInvalid && addr_size != 0;
  69 }
  70
  71 static uint64_t
  72 ReadUIntMax64 (ExecutionContextScope *exe_scope, const Address &address, uint32_t byte_size, bool &success)
  73 {
  74     uint64_t uval64 = 0;
  75     if (exe_scope == NULL || byte_size > sizeof(uint64_t))
  76     {
  77         success = false;
  78         return 0;
  79     }
  80     uint64_t buf = 0;
  81
  82     success = ReadBytes (exe_scope, address, &buf, byte_size) == byte_size;
  83     if (success)
  84     {
  85         ByteOrder byte_order = eByteOrderInvalid;
  86         uint32_t addr_size = 0;
  87         if (GetByteOrderAndAddressSize (exe_scope, address, byte_order, addr_size))
  88         {
  89             DataExtractor data (&buf, sizeof(buf), byte_order, addr_size);
  90             lldb::offset_t offset = 0;
  91             uval64 = data.GetU64(&offset);
  92         }
  93         else
  94             success = false;
  95     }
  96     return uval64;
  97 }
  98
  99 static bool
 100 ReadAddress (ExecutionContextScope *exe_scope, const Address &address, uint32_t pointer_size, Address &deref_so_addr)
 101 {
 102     if (exe_scope == NULL)
 103         return false;
 104
 105
 106     bool success = false;
 107     addr_t deref_addr = ReadUIntMax64 (exe_scope, address, pointer_size, success);
 108     if (success)
 109     {
 110         ExecutionContext exe_ctx;
 111         exe_scope->CalculateExecutionContext(exe_ctx);
 112         // If we have any sections that are loaded, try and resolve using the
 113         // section load list
 114         Target *target = exe_ctx.GetTargetPtr();
 115         if (target && !target->GetSectionLoadList().IsEmpty())
 116         {
 117             if (target->GetSectionLoadList().ResolveLoadAddress (deref_addr, deref_so_addr))
 118                 return true;
 119         }
 120         else
 121         {
 122             // If we were not running, yet able to read an integer, we must
 123             // have a module
 124             ModuleSP module_sp (address.GetModule());
 125
 126             assert (module_sp);
 127             if (module_sp->ResolveFileAddress(deref_addr, deref_so_addr))
 128                 return true;
 129         }
 130
 131         // We couldn't make "deref_addr" into a section offset value, but we were
 132         // able to read the address, so we return a section offset address with
 133         // no section and "deref_addr" as the offset (address).
 134         deref_so_addr.SetRawAddress(deref_addr);
 135         return true;
 136     }
 137     return false;
 138 }
 139
 140 static bool
 141 DumpUInt (ExecutionContextScope *exe_scope, const Address &address, uint32_t byte_size, Stream* strm)
 142 {
 143     if (exe_scope == NULL || byte_size == 0)
 144         return 0;
 145     std::vector<uint8_t> buf(byte_size, 0);
 146
 147     if (ReadBytes (exe_scope, address, &buf[0], buf.size()) == buf.size())
 148     {
 149         ByteOrder byte_order = eByteOrderInvalid;
 150         uint32_t addr_size = 0;
 151         if (GetByteOrderAndAddressSize (exe_scope, address, byte_order, addr_size))
 152         {
 153             DataExtractor data (&buf.front(), buf.size(), byte_order, addr_size);
 154
 155             data.Dump (strm,
 156                        0,                 // Start offset in "data"
 157                        eFormatHex,        // Print as characters
 158                        buf.size(),        // Size of item
 159                        1,                 // Items count
 160                        UINT32_MAX,        // num per line
 161                        LLDB_INVALID_ADDRESS,// base address
 162                        0,                 // bitfield bit size
 163                        0);                // bitfield bit offset
 164
 165             return true;
 166         }
 167     }
 168     return false;
 169 }
 170
 171
 172 static size_t
 173 ReadCStringFromMemory (ExecutionContextScope *exe_scope, const Address &address, Stream *strm)
 174 {
 175     if (exe_scope == NULL)
 176         return 0;
 177     const size_t k_buf_len = 256;
 178     char buf[k_buf_len+1];
 179     buf[k_buf_len] = '\0'; // NULL terminate
 180
 181     // Byte order and address size don't matter for C string dumping..
 182     DataExtractor data (buf, sizeof(buf), lldb::endian::InlHostByteOrder(), 4);
 183     size_t total_len = 0;
 184     size_t bytes_read;
 185     Address curr_address(address);
 186     strm->PutChar ('"');
 187     while ((bytes_read = ReadBytes (exe_scope, curr_address, buf, k_buf_len)) > 0)
 188     {
 189         size_t len = strlen(buf);
 190         if (len == 0)
 191             break;
 192         if (len > bytes_read)
 193             len = bytes_read;
 194
 195         data.Dump (strm,
 196                    0,                 // Start offset in "data"
 197                    eFormatChar,       // Print as characters
 198                    1,                 // Size of item (1 byte for a char!)
 199                    len,               // How many bytes to print?
 200                    UINT32_MAX,        // num per line
 201                    LLDB_INVALID_ADDRESS,// base address
 202                    0,                 // bitfield bit size
 203
 204                    0);                // bitfield bit offset
 205
 206         total_len += bytes_read;
 207
 208         if (len < k_buf_len)
 209             break;
 210         curr_address.SetOffset (curr_address.GetOffset() + bytes_read);
 211     }
 212     strm->PutChar ('"');
 213     return total_len;
 214 }
 215
 216 Address::Address (lldb::addr_t abs_addr) :
 217     m_section_wp (),
 218     m_offset (abs_addr)
 219 {
 220 }
 221
 222 Address::Address (addr_t address, const SectionList *section_list) :
 223     m_section_wp (),
 224     m_offset (LLDB_INVALID_ADDRESS)
 225 {
 226     ResolveAddressUsingFileSections(address, section_list);
 227 }
 228
 229 const Address&
 230 Address::operator= (const Address& rhs)
 231 {
 232     if (this != &rhs)
 233     {
 234         m_section_wp = rhs.m_section_wp;
 235         m_offset = rhs.m_offset.load();
 236     }
 237     return *this;
 238 }
 239
 240 bool
 241 Address::ResolveAddressUsingFileSections (addr_t file_addr, const SectionList *section_list)
 242 {
 243     if (section_list)
 244     {
 245         SectionSP section_sp (section_list->FindSectionContainingFileAddress(file_addr));
 246         m_section_wp = section_sp;
 247         if (section_sp)
 248         {
 249             assert( section_sp->ContainsFileAddress(file_addr) );
 250             m_offset = file_addr - section_sp->GetFileAddress();
 251             return true;    // Successfully transformed addr into a section offset address
 252         }
 253     }
 254     m_offset = file_addr;
 255     return false;       // Failed to resolve this address to a section offset value
 256 }
 257
 258 ModuleSP
 259 Address::GetModule () const
 260 {
 261     lldb::ModuleSP module_sp;
 262     SectionSP section_sp (GetSection());
 263     if (section_sp)
 264         module_sp = section_sp->GetModule();
 265     return module_sp;
 266 }
 267
 268 addr_t
 269 Address::GetFileAddress () const
 270 {
 271     SectionSP section_sp (GetSection());
 272     if (section_sp)
 273     {
 274         addr_t sect_file_addr = section_sp->GetFileAddress();
 275         if (sect_file_addr == LLDB_INVALID_ADDRESS)
 276         {
 277             // Section isn't resolved, we can't return a valid file address
 278             return LLDB_INVALID_ADDRESS;
 279         }
 280         // We have a valid file range, so we can return the file based
 281         // address by adding the file base address to our offset
 282         return sect_file_addr + m_offset;
 283     }
 284     else if (SectionWasDeletedPrivate())
 285     {
 286         // Used to have a valid section but it got deleted so the
 287         // offset doesn't mean anything without the section
 288         return LLDB_INVALID_ADDRESS;
 289     }
 290     // No section, we just return the offset since it is the value in this case
 291     return m_offset;
 292 }
 293
 294 addr_t
 295 Address::GetLoadAddress (Target *target) const
 296 {
 297     SectionSP section_sp (GetSection());
 298     if (section_sp)
 299     {
 300         if (target)
 301         {
 302             addr_t sect_load_addr = section_sp->GetLoadBaseAddress (target);
 303
 304             if (sect_load_addr != LLDB_INVALID_ADDRESS)
 305             {
 306                 // We have a valid file range, so we can return the file based
 307                 // address by adding the file base address to our offset
 308                 return sect_load_addr + m_offset;
 309             }
 310         }
 311     }
 312     else if (SectionWasDeletedPrivate())
 313     {
 314         // Used to have a valid section but it got deleted so the
 315         // offset doesn't mean anything without the section
 316         return LLDB_INVALID_ADDRESS;
 317     }
 318     else
 319     {
 320         // We don't have a section so the offset is the load address
 321         return m_offset;
 322     }
 323     // The section isn't resolved or an invalid target was passed in
 324     // so we can't return a valid load address.
 325     return LLDB_INVALID_ADDRESS;
 326 }
 327
 328 addr_t
 329 Address::GetCallableLoadAddress (Target *target, bool is_indirect) const
 330 {
 331     addr_t code_addr = LLDB_INVALID_ADDRESS;
 332
 333     if (is_indirect && target)
 334     {
 335         ProcessSP processSP = target->GetProcessSP();
 336         Error error;
 337         if (processSP.get())
 338         {
 339             code_addr = processSP->ResolveIndirectFunction(this, error);
 340             if (!error.Success())
 341                 code_addr = LLDB_INVALID_ADDRESS;
 342         }
 343     }
 344     else
 345     {
 346         code_addr = GetLoadAddress (target);
 347     }
 348
 349     if (code_addr == LLDB_INVALID_ADDRESS)
 350         return code_addr;
 351
 352     if (target)
 353         return target->GetCallableLoadAddress (code_addr, GetAddressClass());
 354     return code_addr;
 355 }
 356
 357 bool
 358 Address::SetCallableLoadAddress (lldb::addr_t load_addr, Target *target)
 359 {
 360     if (SetLoadAddress (load_addr, target))
 361     {
 362         if (target)
 363             m_offset = target->GetCallableLoadAddress(m_offset, GetAddressClass());
 364         return true;
 365     }
 366     return false;
 367 }
 368
 369 addr_t
 370 Address::GetOpcodeLoadAddress (Target *target) const
 371 {
 372     addr_t code_addr = GetLoadAddress (target);
 373     if (code_addr != LLDB_INVALID_ADDRESS)
 374         code_addr = target->GetOpcodeLoadAddress (code_addr, GetAddressClass());
 375     return code_addr;
 376 }
 377
 378 bool
 379 Address::SetOpcodeLoadAddress (lldb::addr_t load_addr, Target *target)
 380 {
 381     if (SetLoadAddress (load_addr, target))
 382     {
 383         if (target)
 384             m_offset = target->GetOpcodeLoadAddress (m_offset, GetAddressClass());
 385         return true;
 386     }
 387     return false;
 388 }
 389
 390 bool
 391 Address::Dump (Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style, uint32_t addr_size) const
 392 {
 393     // If the section was NULL, only load address is going to work unless we are
 394     // trying to deref a pointer
 395     SectionSP section_sp (GetSection());
 396     if (!section_sp && style != DumpStyleResolvedPointerDescription)
 397         style = DumpStyleLoadAddress;
 398
 399     ExecutionContext exe_ctx (exe_scope);
 400     Target *target = exe_ctx.GetTargetPtr();
 401     // If addr_byte_size is UINT32_MAX, then determine the correct address
 402     // byte size for the process or default to the size of addr_t
 403     if (addr_size == UINT32_MAX)
 404     {
 405         if (target)
 406             addr_size = target->GetArchitecture().GetAddressByteSize ();
 407         else
 408             addr_size = sizeof(addr_t);
 409     }
 410
 411     Address so_addr;
 412     switch (style)
 413     {
 414     case DumpStyleInvalid:
 415         return false;
 416
 417     case DumpStyleSectionNameOffset:
 418         if (section_sp)
 419         {
 420             section_sp->DumpName(s);
 421             s->Printf (" + %" PRIu64, m_offset.load());
 422         }
 423         else
 424         {
 425             s->Address(m_offset, addr_size);
 426         }
 427         break;
 428
 429     case DumpStyleSectionPointerOffset:
 430         s->Printf("(Section *)%p + ", static_cast<void*>(section_sp.get()));
 431         s->Address(m_offset, addr_size);
 432         break;
 433
 434     case DumpStyleModuleWithFileAddress:
 435         if (section_sp)
 436         {
 437             s->Printf("%s[", section_sp->GetModule()->GetFileSpec().GetFilename().AsCString("<Unknown>"));
 438         }
 439         // Fall through
 440     case DumpStyleFileAddress:
 441         {
 442             addr_t file_addr = GetFileAddress();
 443             if (file_addr == LLDB_INVALID_ADDRESS)
 444             {
 445                 if (fallback_style != DumpStyleInvalid)
 446                     return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 447                 return false;
 448             }
 449             s->Address (file_addr, addr_size);
 450             if (style == DumpStyleModuleWithFileAddress && section_sp)
 451                 s->PutChar(']');
 452         }
 453         break;
 454
 455     case DumpStyleLoadAddress:
 456         {
 457             addr_t load_addr = GetLoadAddress (target);
 458             if (load_addr == LLDB_INVALID_ADDRESS)
 459             {
 460                 if (fallback_style != DumpStyleInvalid)
 461                     return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 462                 return false;
 463             }
 464             s->Address (load_addr, addr_size);
 465         }
 466         break;
 467
 468     case DumpStyleResolvedDescription:
 469     case DumpStyleResolvedDescriptionNoModule:
 470     case DumpStyleResolvedDescriptionNoFunctionArguments:
 471         if (IsSectionOffset())
 472         {
 473             uint32_t pointer_size = 4;
 474             ModuleSP module_sp (GetModule());
 475             if (target)
 476                 pointer_size = target->GetArchitecture().GetAddressByteSize();
 477             else if (module_sp)
 478                 pointer_size = module_sp->GetArchitecture().GetAddressByteSize();
 479
 480             bool showed_info = false;
 481             if (section_sp)
 482             {
 483                 SectionType sect_type = section_sp->GetType();
 484                 switch (sect_type)
 485                 {
 486                 case eSectionTypeData:
 487                     if (module_sp)
 488                     {
 489                         SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
 490                         if (sym_vendor)
 491                         {
 492                             Symtab *symtab = sym_vendor->GetSymtab();
 493                             if (symtab)
 494                             {
 495                                 const addr_t file_Addr = GetFileAddress();
 496                                 Symbol *symbol = symtab->FindSymbolContainingFileAddress (file_Addr);
 497                                 if (symbol)
 498                                 {
 499                                     const char *symbol_name = symbol->GetName().AsCString();
 500                                     if (symbol_name)
 501                                     {
 502                                         s->PutCString(symbol_name);
 503                                         addr_t delta = file_Addr - symbol->GetAddress().GetFileAddress();
 504                                         if (delta)
 505                                             s->Printf(" + %" PRIu64, delta);
 506                                         showed_info = true;
 507                                     }
 508                                 }
 509                             }
 510                         }
 511                     }
 512                     break;
 513
 514                 case eSectionTypeDataCString:
 515                     // Read the C string from memory and display it
 516                     showed_info = true;
 517                     ReadCStringFromMemory (exe_scope, *this, s);
 518                     break;
 519
 520                 case eSectionTypeDataCStringPointers:
 521                     {
 522                         if (ReadAddress (exe_scope, *this, pointer_size, so_addr))
 523                         {
 524 #if VERBOSE_OUTPUT
 525                             s->PutCString("(char *)");
 526                             so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 527                             s->PutCString(": ");
 528 #endif
 529                             showed_info = true;
 530                             ReadCStringFromMemory (exe_scope, so_addr, s);
 531                         }
 532                     }
 533                     break;
 534
 535                 case eSectionTypeDataObjCMessageRefs:
 536                     {
 537                         if (ReadAddress (exe_scope, *this, pointer_size, so_addr))
 538                         {
 539                             if (target && so_addr.IsSectionOffset())
 540                             {
 541                                 SymbolContext func_sc;
 542                                 target->GetImages().ResolveSymbolContextForAddress (so_addr,
 543                                                                                              eSymbolContextEverything,
 544                                                                                              func_sc);
 545                                 if (func_sc.function || func_sc.symbol)
 546                                 {
 547                                     showed_info = true;
 548 #if VERBOSE_OUTPUT
 549                                     s->PutCString ("(objc_msgref *) -> { (func*)");
 550                                     so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 551 #else
 552                                     s->PutCString ("{ ");
 553 #endif
 554                                     Address cstr_addr(*this);
 555                                     cstr_addr.SetOffset(cstr_addr.GetOffset() + pointer_size);
 556                                     func_sc.DumpStopContext(s, exe_scope, so_addr, true, true, false, true);
 557                                     if (ReadAddress (exe_scope, cstr_addr, pointer_size, so_addr))
 558                                     {
 559 #if VERBOSE_OUTPUT
 560                                         s->PutCString("), (char *)");
 561                                         so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 562                                         s->PutCString(" (");
 563 #else
 564                                         s->PutCString(", ");
 565 #endif
 566                                         ReadCStringFromMemory (exe_scope, so_addr, s);
 567                                     }
 568 #if VERBOSE_OUTPUT
 569                                     s->PutCString(") }");
 570 #else
 571                                     s->PutCString(" }");
 572 #endif
 573                                 }
 574                             }
 575                         }
 576                     }
 577                     break;
 578
 579                 case eSectionTypeDataObjCCFStrings:
 580                     {
 581                         Address cfstring_data_addr(*this);
 582                         cfstring_data_addr.SetOffset(cfstring_data_addr.GetOffset() + (2 * pointer_size));
 583                         if (ReadAddress (exe_scope, cfstring_data_addr, pointer_size, so_addr))
 584                         {
 585 #if VERBOSE_OUTPUT
 586                             s->PutCString("(CFString *) ");
 587                             cfstring_data_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 588                             s->PutCString(" -> @");
 589 #else
 590                             s->PutChar('@');
 591 #endif
 592                             if (so_addr.Dump(s, exe_scope, DumpStyleResolvedDescription))
 593                                 showed_info = true;
 594                         }
 595                     }
 596                     break;
 597
 598                 case eSectionTypeData4:
 599                     // Read the 4 byte data and display it
 600                     showed_info = true;
 601                     s->PutCString("(uint32_t) ");
 602                     DumpUInt (exe_scope, *this, 4, s);
 603                     break;
 604
 605                 case eSectionTypeData8:
 606                     // Read the 8 byte data and display it
 607                     showed_info = true;
 608                     s->PutCString("(uint64_t) ");
 609                     DumpUInt (exe_scope, *this, 8, s);
 610                     break;
 611
 612                 case eSectionTypeData16:
 613                     // Read the 16 byte data and display it
 614                     showed_info = true;
 615                     s->PutCString("(uint128_t) ");
 616                     DumpUInt (exe_scope, *this, 16, s);
 617                     break;
 618
 619                 case eSectionTypeDataPointers:
 620                     // Read the pointer data and display it
 621                     {
 622                         if (ReadAddress (exe_scope, *this, pointer_size, so_addr))
 623                         {
 624                             s->PutCString ("(void *)");
 625                             so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 626
 627                             showed_info = true;
 628                             if (so_addr.IsSectionOffset())
 629                             {
 630                                 SymbolContext pointer_sc;
 631                                 if (target)
 632                                 {
 633                                     target->GetImages().ResolveSymbolContextForAddress (so_addr,
 634                                                                                                  eSymbolContextEverything,
 635                                                                                                  pointer_sc);
 636                                     if (pointer_sc.function || pointer_sc.symbol)
 637                                     {
 638                                         s->PutCString(": ");
 639                                         pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false, false, true);
 640                                     }
 641                                 }
 642                             }
 643                         }
 644                     }
 645                     break;
 646
 647                 default:
 648                     break;
 649                 }
 650             }
 651
 652             if (!showed_info)
 653             {
 654                 if (module_sp)
 655                 {
 656                     SymbolContext sc;
 657                     module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextEverything, sc);
 658                     if (sc.function || sc.symbol)
 659                     {
 660                         bool show_stop_context = true;
 661                         const bool show_module = (style == DumpStyleResolvedDescription);
 662                         const bool show_fullpaths = false;
 663                         const bool show_inlined_frames = true;
 664                         const bool show_function_arguments = (style != DumpStyleResolvedDescriptionNoFunctionArguments);
 665                         if (sc.function == NULL && sc.symbol != NULL)
 666                         {
 667                             // If we have just a symbol make sure it is in the right section
 668                             if (sc.symbol->ValueIsAddress())
 669                             {
 670                                 if (sc.symbol->GetAddress().GetSection() != GetSection())
 671                                 {
 672                                     // don't show the module if the symbol is a trampoline symbol
 673                                     show_stop_context = false;
 674                                 }
 675                             }
 676                         }
 677                         if (show_stop_context)
 678                         {
 679                             // We have a function or a symbol from the same
 680                             // sections as this address.
 681                             sc.DumpStopContext (s,
 682                                                 exe_scope,
 683                                                 *this,
 684                                                 show_fullpaths,
 685                                                 show_module,
 686                                                 show_inlined_frames,
 687                                                 show_function_arguments);
 688                         }
 689                         else
 690                         {
 691                             // We found a symbol but it was in a different
 692                             // section so it isn't the symbol we should be
 693                             // showing, just show the section name + offset
 694                             Dump (s, exe_scope, DumpStyleSectionNameOffset);
 695                         }
 696                     }
 697                 }
 698             }
 699         }
 700         else
 701         {
 702             if (fallback_style != DumpStyleInvalid)
 703                 return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 704             return false;
 705         }
 706         break;
 707
 708     case DumpStyleDetailedSymbolContext:
 709         if (IsSectionOffset())
 710         {
 711             ModuleSP module_sp (GetModule());
 712             if (module_sp)
 713             {
 714                 SymbolContext sc;
 715                 module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextEverything, sc);
 716                 if (sc.symbol)
 717                 {
 718                     // If we have just a symbol make sure it is in the same section
 719                     // as our address. If it isn't, then we might have just found
 720                     // the last symbol that came before the address that we are
 721                     // looking up that has nothing to do with our address lookup.
 722                     if (sc.symbol->ValueIsAddress() && sc.symbol->GetAddress().GetSection() != GetSection())
 723                         sc.symbol = NULL;
 724                 }
 725                 sc.GetDescription(s, eDescriptionLevelBrief, target);
 726
 727                 if (sc.block)
 728                 {
 729                     bool can_create = true;
 730                     bool get_parent_variables = true;
 731                     bool stop_if_block_is_inlined_function = false;
 732                     VariableList variable_list;
 733                     sc.block->AppendVariables (can_create,
 734                                                get_parent_variables,
 735                                                stop_if_block_is_inlined_function,
 736                                                &variable_list);
 737
 738                     const size_t num_variables = variable_list.GetSize();
 739                     for (size_t var_idx = 0; var_idx < num_variables; ++var_idx)
 740                     {
 741                         Variable *var = variable_list.GetVariableAtIndex (var_idx).get();
 742                         if (var && var->LocationIsValidForAddress (*this))
 743                         {
 744                             s->Indent();
 745                             s->Printf ("   Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\", type= \"%s\", location =",
 746                                        var->GetID(),
 747                                        var->GetName().GetCString(),
 748                                        var->GetType()->GetName().GetCString());
 749                             var->DumpLocationForAddress(s, *this);
 750                             s->PutCString(", decl = ");
 751                             var->GetDeclaration().DumpStopContext(s, false);
 752                             s->EOL();
 753                         }
 754                     }
 755                 }
 756             }
 757         }
 758         else
 759         {
 760             if (fallback_style != DumpStyleInvalid)
 761                 return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 762             return false;
 763         }
 764         break;
 765     case DumpStyleResolvedPointerDescription:
 766         {
 767             Process *process = exe_ctx.GetProcessPtr();
 768             if (process)
 769             {
 770                 addr_t load_addr = GetLoadAddress (target);
 771                 if (load_addr != LLDB_INVALID_ADDRESS)
 772                 {
 773                     Error memory_error;
 774                     addr_t dereferenced_load_addr = process->ReadPointerFromMemory(load_addr, memory_error);
 775                     if (dereferenced_load_addr != LLDB_INVALID_ADDRESS)
 776                     {
 777                         Address dereferenced_addr;
 778                         if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr, target))
 779                         {
 780                             StreamString strm;
 781                             if (dereferenced_addr.Dump (&strm, exe_scope, DumpStyleResolvedDescription, DumpStyleInvalid, addr_size))
 782                             {
 783                                 s->Address (dereferenced_load_addr, addr_size, " -> ", " ");
 784                                 s->Write(strm.GetData(), strm.GetSize());
 785                                 return true;
 786                             }
 787                         }
 788                     }
 789                 }
 790             }
 791             if (fallback_style != DumpStyleInvalid)
 792                 return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 793             return false;
 794         }
 795         break;
 796     }
 797
 798     return true;
 799 }
 800
 801 bool
 802 Address::SectionWasDeleted() const
 803 {
 804     if (GetSection())
 805         return false;
 806     return SectionWasDeletedPrivate();
 807 }
 808
 809 bool
 810 Address::SectionWasDeletedPrivate() const
 811 {
 812     lldb::SectionWP empty_section_wp;
 813
 814     // If either call to "std::weak_ptr::owner_before(...) value returns true, this
 815     // indicates that m_section_wp once contained (possibly still does) a reference
 816     // to a valid shared pointer. This helps us know if we had a valid reference to
 817     // a section which is now invalid because the module it was in was unloaded/deleted,
 818     // or if the address doesn't have a valid reference to a section.
 819     return empty_section_wp.owner_before(m_section_wp) || m_section_wp.owner_before(empty_section_wp);
 820 }
 821
 822 uint32_t
 823 Address::CalculateSymbolContext (SymbolContext *sc, uint32_t resolve_scope) const
 824 {
 825     sc->Clear(false);
 826     // Absolute addresses don't have enough information to reconstruct even their target.
 827
 828     SectionSP section_sp (GetSection());
 829     if (section_sp)
 830     {
 831         ModuleSP module_sp (section_sp->GetModule());
 832         if (module_sp)
 833         {
 834             sc->module_sp = module_sp;
 835             if (sc->module_sp)
 836                 return sc->module_sp->ResolveSymbolContextForAddress (*this, resolve_scope, *sc);
 837         }
 838     }
 839     return 0;
 840 }
 841
 842 ModuleSP
 843 Address::CalculateSymbolContextModule () const
 844 {
 845     SectionSP section_sp (GetSection());
 846     if (section_sp)
 847         return section_sp->GetModule();
 848     return ModuleSP();
 849 }
 850
 851 CompileUnit *
 852 Address::CalculateSymbolContextCompileUnit () const
 853 {
 854     SectionSP section_sp (GetSection());
 855     if (section_sp)
 856     {
 857         SymbolContext sc;
 858         sc.module_sp = section_sp->GetModule();
 859         if (sc.module_sp)
 860         {
 861             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextCompUnit, sc);
 862             return sc.comp_unit;
 863         }
 864     }
 865     return NULL;
 866 }
 867
 868 Function *
 869 Address::CalculateSymbolContextFunction () const
 870 {
 871     SectionSP section_sp (GetSection());
 872     if (section_sp)
 873     {
 874         SymbolContext sc;
 875         sc.module_sp = section_sp->GetModule();
 876         if (sc.module_sp)
 877         {
 878             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextFunction, sc);
 879             return sc.function;
 880         }
 881     }
 882     return NULL;
 883 }
 884
 885 Block *
 886 Address::CalculateSymbolContextBlock () const
 887 {
 888     SectionSP section_sp (GetSection());
 889     if (section_sp)
 890     {
 891         SymbolContext sc;
 892         sc.module_sp = section_sp->GetModule();
 893         if (sc.module_sp)
 894         {
 895             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextBlock, sc);
 896             return sc.block;
 897         }
 898     }
 899     return NULL;
 900 }
 901
 902 Symbol *
 903 Address::CalculateSymbolContextSymbol () const
 904 {
 905     SectionSP section_sp (GetSection());
 906     if (section_sp)
 907     {
 908         SymbolContext sc;
 909         sc.module_sp = section_sp->GetModule();
 910         if (sc.module_sp)
 911         {
 912             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextSymbol, sc);
 913             return sc.symbol;
 914         }
 915     }
 916     return NULL;
 917 }
 918
 919 bool
 920 Address::CalculateSymbolContextLineEntry (LineEntry &line_entry) const
 921 {
 922     SectionSP section_sp (GetSection());
 923     if (section_sp)
 924     {
 925         SymbolContext sc;
 926         sc.module_sp = section_sp->GetModule();
 927         if (sc.module_sp)
 928         {
 929             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextLineEntry, sc);
 930             if (sc.line_entry.IsValid())
 931             {
 932                 line_entry = sc.line_entry;
 933                 return true;
 934             }
 935         }
 936     }
 937     line_entry.Clear();
 938     return false;
 939 }
 940
 941 int
 942 Address::CompareFileAddress (const Address& a, const Address& b)
 943 {
 944     addr_t a_file_addr = a.GetFileAddress();
 945     addr_t b_file_addr = b.GetFileAddress();
 946     if (a_file_addr < b_file_addr)
 947         return -1;
 948     if (a_file_addr > b_file_addr)
 949         return +1;
 950     return 0;
 951 }
 952
 953
 954 int
 955 Address::CompareLoadAddress (const Address& a, const Address& b, Target *target)
 956 {
 957     assert (target != NULL);
 958     addr_t a_load_addr = a.GetLoadAddress (target);
 959     addr_t b_load_addr = b.GetLoadAddress (target);
 960     if (a_load_addr < b_load_addr)
 961         return -1;
 962     if (a_load_addr > b_load_addr)
 963         return +1;
 964     return 0;
 965 }
 966
 967 int
 968 Address::CompareModulePointerAndOffset (const Address& a, const Address& b)
 969 {
 970     ModuleSP a_module_sp (a.GetModule());
 971     ModuleSP b_module_sp (b.GetModule());
 972     Module *a_module = a_module_sp.get();
 973     Module *b_module = b_module_sp.get();
 974     if (a_module < b_module)
 975         return -1;
 976     if (a_module > b_module)
 977         return +1;
 978     // Modules are the same, just compare the file address since they should
 979     // be unique
 980     addr_t a_file_addr = a.GetFileAddress();
 981     addr_t b_file_addr = b.GetFileAddress();
 982     if (a_file_addr < b_file_addr)
 983         return -1;
 984     if (a_file_addr > b_file_addr)
 985         return +1;
 986     return 0;
 987 }
 988
 989
 990 size_t
 991 Address::MemorySize () const
 992 {
 993     // Noting special for the memory size of a single Address object,
 994     // it is just the size of itself.
 995     return sizeof(Address);
 996 }
 997
 998
 999 //----------------------------------------------------------------------
1000 // NOTE: Be careful using this operator. It can correctly compare two
1001 // addresses from the same Module correctly. It can't compare two
1002 // addresses from different modules in any meaningful way, but it will
1003 // compare the module pointers.
1004 //
1005 // To sum things up:
1006 // - works great for addresses within the same module
1007 // - it works for addresses across multiple modules, but don't expect the
1008 //   address results to make much sense
1009 //
1010 // This basically lets Address objects be used in ordered collection
1011 // classes.
1012 //----------------------------------------------------------------------
1013
1014 bool
1015 lldb_private::operator< (const Address& lhs, const Address& rhs)
1016 {
1017     ModuleSP lhs_module_sp (lhs.GetModule());
1018     ModuleSP rhs_module_sp (rhs.GetModule());
1019     Module *lhs_module = lhs_module_sp.get();
1020     Module *rhs_module = rhs_module_sp.get();
1021     if (lhs_module == rhs_module)
1022     {
1023         // Addresses are in the same module, just compare the file addresses
1024         return lhs.GetFileAddress() < rhs.GetFileAddress();
1025     }
1026     else
1027     {
1028         // The addresses are from different modules, just use the module
1029         // pointer value to get consistent ordering
1030         return lhs_module < rhs_module;
1031     }
1032 }
1033
1034 bool
1035 lldb_private::operator> (const Address& lhs, const Address& rhs)
1036 {
1037     ModuleSP lhs_module_sp (lhs.GetModule());
1038     ModuleSP rhs_module_sp (rhs.GetModule());
1039     Module *lhs_module = lhs_module_sp.get();
1040     Module *rhs_module = rhs_module_sp.get();
1041     if (lhs_module == rhs_module)
1042     {
1043         // Addresses are in the same module, just compare the file addresses
1044         return lhs.GetFileAddress() > rhs.GetFileAddress();
1045     }
1046     else
1047     {
1048         // The addresses are from different modules, just use the module
1049         // pointer value to get consistent ordering
1050         return lhs_module > rhs_module;
1051     }
1052 }
1053
1054
1055 // The operator == checks for exact equality only (same section, same offset)
1056 bool
1057 lldb_private::operator== (const Address& a, const Address& rhs)
1058 {
1059     return  a.GetOffset()  == rhs.GetOffset() &&
1060             a.GetSection() == rhs.GetSection();
1061 }
1062 // The operator != checks for exact inequality only (differing section, or
1063 // different offset)
1064 bool
1065 lldb_private::operator!= (const Address& a, const Address& rhs)
1066 {
1067     return  a.GetOffset()  != rhs.GetOffset() ||
1068             a.GetSection() != rhs.GetSection();
1069 }
1070
1071 AddressClass
1072 Address::GetAddressClass () const
1073 {
1074     ModuleSP module_sp (GetModule());
1075     if (module_sp)
1076     {
1077         ObjectFile *obj_file = module_sp->GetObjectFile();
1078         if (obj_file)
1079         {
1080             // Give the symbol vendor a chance to add to the unified section list.
1081             module_sp->GetSymbolVendor();
1082             return obj_file->GetAddressClass (GetFileAddress());
1083         }
1084     }
1085     return eAddressClassUnknown;
1086 }
1087
1088 bool
1089 Address::SetLoadAddress (lldb::addr_t load_addr, Target *target)
1090 {
1091     if (target && target->GetSectionLoadList().ResolveLoadAddress(load_addr, *this))
1092         return true;
1093     m_section_wp.reset();
1094     m_offset = load_addr;
1095     return false;
1096 }
1097