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/Type.h"
  16 #include "lldb/Symbol/Variable.h"
  17 #include "lldb/Symbol/VariableList.h"
  18 #include "lldb/Target/ExecutionContext.h"
  19 #include "lldb/Target/Process.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     // No section, we just return the offset since it is the value in this case
 285     return m_offset;
 286 }
 287
 288 addr_t
 289 Address::GetLoadAddress (Target *target) const
 290 {
 291     SectionSP section_sp (GetSection());
 292     if (!section_sp)
 293     {
 294         // No section, we just return the offset since it is the value in this case
 295         return m_offset;
 296     }
 297
 298     if (target)
 299     {
 300         addr_t sect_load_addr = section_sp->GetLoadBaseAddress (target);
 301
 302         if (sect_load_addr != LLDB_INVALID_ADDRESS)
 303         {
 304             // We have a valid file range, so we can return the file based
 305             // address by adding the file base address to our offset
 306             return sect_load_addr + m_offset;
 307         }
 308     }
 309     // The section isn't resolved or no process was supplied so we can't
 310     // return a valid file address.
 311     return LLDB_INVALID_ADDRESS;
 312 }
 313
 314 addr_t
 315 Address::GetCallableLoadAddress (Target *target, bool is_indirect) const
 316 {
 317     if (is_indirect && target) {
 318         ProcessSP processSP = target->GetProcessSP();
 319         Error error;
 320         if (processSP.get())
 321             return processSP->ResolveIndirectFunction(this, error);
 322     }
 323
 324     addr_t code_addr = GetLoadAddress (target);
 325
 326     if (target)
 327         return target->GetCallableLoadAddress (code_addr, GetAddressClass());
 328     return code_addr;
 329 }
 330
 331 bool
 332 Address::SetCallableLoadAddress (lldb::addr_t load_addr, Target *target)
 333 {
 334     if (SetLoadAddress (load_addr, target))
 335     {
 336         if (target)
 337             m_offset = target->GetCallableLoadAddress(m_offset, GetAddressClass());
 338         return true;
 339     }
 340     return false;
 341 }
 342
 343 addr_t
 344 Address::GetOpcodeLoadAddress (Target *target) const
 345 {
 346     addr_t code_addr = GetLoadAddress (target);
 347     if (code_addr != LLDB_INVALID_ADDRESS)
 348         code_addr = target->GetOpcodeLoadAddress (code_addr, GetAddressClass());
 349     return code_addr;
 350 }
 351
 352 bool
 353 Address::SetOpcodeLoadAddress (lldb::addr_t load_addr, Target *target)
 354 {
 355     if (SetLoadAddress (load_addr, target))
 356     {
 357         if (target)
 358             m_offset = target->GetOpcodeLoadAddress (m_offset, GetAddressClass());
 359         return true;
 360     }
 361     return false;
 362 }
 363
 364 bool
 365 Address::Dump (Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style, uint32_t addr_size) const
 366 {
 367     // If the section was NULL, only load address is going to work unless we are
 368     // trying to deref a pointer
 369     SectionSP section_sp (GetSection());
 370     if (!section_sp && style != DumpStyleResolvedPointerDescription)
 371         style = DumpStyleLoadAddress;
 372
 373     ExecutionContext exe_ctx (exe_scope);
 374     Target *target = exe_ctx.GetTargetPtr();
 375     // If addr_byte_size is UINT32_MAX, then determine the correct address
 376     // byte size for the process or default to the size of addr_t
 377     if (addr_size == UINT32_MAX)
 378     {
 379         if (target)
 380             addr_size = target->GetArchitecture().GetAddressByteSize ();
 381         else
 382             addr_size = sizeof(addr_t);
 383     }
 384
 385     Address so_addr;
 386     switch (style)
 387     {
 388     case DumpStyleInvalid:
 389         return false;
 390
 391     case DumpStyleSectionNameOffset:
 392         if (section_sp)
 393         {
 394             section_sp->DumpName(s);
 395             s->Printf (" + %" PRIu64, m_offset.load());
 396         }
 397         else
 398         {
 399             s->Address(m_offset, addr_size);
 400         }
 401         break;
 402
 403     case DumpStyleSectionPointerOffset:
 404         s->Printf("(Section *)%p + ", section_sp.get());
 405         s->Address(m_offset, addr_size);
 406         break;
 407
 408     case DumpStyleModuleWithFileAddress:
 409         if (section_sp)
 410             s->Printf("%s[", section_sp->GetModule()->GetFileSpec().GetFilename().AsCString());
 411         // Fall through
 412     case DumpStyleFileAddress:
 413         {
 414             addr_t file_addr = GetFileAddress();
 415             if (file_addr == LLDB_INVALID_ADDRESS)
 416             {
 417                 if (fallback_style != DumpStyleInvalid)
 418                     return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 419                 return false;
 420             }
 421             s->Address (file_addr, addr_size);
 422             if (style == DumpStyleModuleWithFileAddress && section_sp)
 423                 s->PutChar(']');
 424         }
 425         break;
 426
 427     case DumpStyleLoadAddress:
 428         {
 429             addr_t load_addr = GetLoadAddress (target);
 430             if (load_addr == LLDB_INVALID_ADDRESS)
 431             {
 432                 if (fallback_style != DumpStyleInvalid)
 433                     return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 434                 return false;
 435             }
 436             s->Address (load_addr, addr_size);
 437         }
 438         break;
 439
 440     case DumpStyleResolvedDescription:
 441     case DumpStyleResolvedDescriptionNoModule:
 442         if (IsSectionOffset())
 443         {
 444             uint32_t pointer_size = 4;
 445             ModuleSP module_sp (GetModule());
 446             if (target)
 447                 pointer_size = target->GetArchitecture().GetAddressByteSize();
 448             else if (module_sp)
 449                 pointer_size = module_sp->GetArchitecture().GetAddressByteSize();
 450
 451             bool showed_info = false;
 452             if (section_sp)
 453             {
 454                 SectionType sect_type = section_sp->GetType();
 455                 switch (sect_type)
 456                 {
 457                 case eSectionTypeData:
 458                     if (module_sp)
 459                     {
 460                         SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
 461                         if (sym_vendor)
 462                         {
 463                             Symtab *symtab = sym_vendor->GetSymtab();
 464                             if (symtab)
 465                             {
 466                                 const addr_t file_Addr = GetFileAddress();
 467                                 Symbol *symbol = symtab->FindSymbolContainingFileAddress (file_Addr);
 468                                 if (symbol)
 469                                 {
 470                                     const char *symbol_name = symbol->GetName().AsCString();
 471                                     if (symbol_name)
 472                                     {
 473                                         s->PutCString(symbol_name);
 474                                         addr_t delta = file_Addr - symbol->GetAddress().GetFileAddress();
 475                                         if (delta)
 476                                             s->Printf(" + %" PRIu64, delta);
 477                                         showed_info = true;
 478                                     }
 479                                 }
 480                             }
 481                         }
 482                     }
 483                     break;
 484
 485                 case eSectionTypeDataCString:
 486                     // Read the C string from memory and display it
 487                     showed_info = true;
 488                     ReadCStringFromMemory (exe_scope, *this, s);
 489                     break;
 490
 491                 case eSectionTypeDataCStringPointers:
 492                     {
 493                         if (ReadAddress (exe_scope, *this, pointer_size, so_addr))
 494                         {
 495 #if VERBOSE_OUTPUT
 496                             s->PutCString("(char *)");
 497                             so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 498                             s->PutCString(": ");
 499 #endif
 500                             showed_info = true;
 501                             ReadCStringFromMemory (exe_scope, so_addr, s);
 502                         }
 503                     }
 504                     break;
 505
 506                 case eSectionTypeDataObjCMessageRefs:
 507                     {
 508                         if (ReadAddress (exe_scope, *this, pointer_size, so_addr))
 509                         {
 510                             if (target && so_addr.IsSectionOffset())
 511                             {
 512                                 SymbolContext func_sc;
 513                                 target->GetImages().ResolveSymbolContextForAddress (so_addr,
 514                                                                                              eSymbolContextEverything,
 515                                                                                              func_sc);
 516                                 if (func_sc.function || func_sc.symbol)
 517                                 {
 518                                     showed_info = true;
 519 #if VERBOSE_OUTPUT
 520                                     s->PutCString ("(objc_msgref *) -> { (func*)");
 521                                     so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 522 #else
 523                                     s->PutCString ("{ ");
 524 #endif
 525                                     Address cstr_addr(*this);
 526                                     cstr_addr.SetOffset(cstr_addr.GetOffset() + pointer_size);
 527                                     func_sc.DumpStopContext(s, exe_scope, so_addr, true, true, false);
 528                                     if (ReadAddress (exe_scope, cstr_addr, pointer_size, so_addr))
 529                                     {
 530 #if VERBOSE_OUTPUT
 531                                         s->PutCString("), (char *)");
 532                                         so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 533                                         s->PutCString(" (");
 534 #else
 535                                         s->PutCString(", ");
 536 #endif
 537                                         ReadCStringFromMemory (exe_scope, so_addr, s);
 538                                     }
 539 #if VERBOSE_OUTPUT
 540                                     s->PutCString(") }");
 541 #else
 542                                     s->PutCString(" }");
 543 #endif
 544                                 }
 545                             }
 546                         }
 547                     }
 548                     break;
 549
 550                 case eSectionTypeDataObjCCFStrings:
 551                     {
 552                         Address cfstring_data_addr(*this);
 553                         cfstring_data_addr.SetOffset(cfstring_data_addr.GetOffset() + (2 * pointer_size));
 554                         if (ReadAddress (exe_scope, cfstring_data_addr, pointer_size, so_addr))
 555                         {
 556 #if VERBOSE_OUTPUT
 557                             s->PutCString("(CFString *) ");
 558                             cfstring_data_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 559                             s->PutCString(" -> @");
 560 #else
 561                             s->PutChar('@');
 562 #endif
 563                             if (so_addr.Dump(s, exe_scope, DumpStyleResolvedDescription))
 564                                 showed_info = true;
 565                         }
 566                     }
 567                     break;
 568
 569                 case eSectionTypeData4:
 570                     // Read the 4 byte data and display it
 571                     showed_info = true;
 572                     s->PutCString("(uint32_t) ");
 573                     DumpUInt (exe_scope, *this, 4, s);
 574                     break;
 575
 576                 case eSectionTypeData8:
 577                     // Read the 8 byte data and display it
 578                     showed_info = true;
 579                     s->PutCString("(uint64_t) ");
 580                     DumpUInt (exe_scope, *this, 8, s);
 581                     break;
 582
 583                 case eSectionTypeData16:
 584                     // Read the 16 byte data and display it
 585                     showed_info = true;
 586                     s->PutCString("(uint128_t) ");
 587                     DumpUInt (exe_scope, *this, 16, s);
 588                     break;
 589
 590                 case eSectionTypeDataPointers:
 591                     // Read the pointer data and display it
 592                     {
 593                         if (ReadAddress (exe_scope, *this, pointer_size, so_addr))
 594                         {
 595                             s->PutCString ("(void *)");
 596                             so_addr.Dump(s, exe_scope, DumpStyleLoadAddress, DumpStyleFileAddress);
 597
 598                             showed_info = true;
 599                             if (so_addr.IsSectionOffset())
 600                             {
 601                                 SymbolContext pointer_sc;
 602                                 if (target)
 603                                 {
 604                                     target->GetImages().ResolveSymbolContextForAddress (so_addr,
 605                                                                                                  eSymbolContextEverything,
 606                                                                                                  pointer_sc);
 607                                     if (pointer_sc.function || pointer_sc.symbol)
 608                                     {
 609                                         s->PutCString(": ");
 610                                         pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false, false);
 611                                     }
 612                                 }
 613                             }
 614                         }
 615                     }
 616                     break;
 617
 618                 default:
 619                     break;
 620                 }
 621             }
 622
 623             if (!showed_info)
 624             {
 625                 if (module_sp)
 626                 {
 627                     SymbolContext sc;
 628                     module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextEverything, sc);
 629                     if (sc.function || sc.symbol)
 630                     {
 631                         bool show_stop_context = true;
 632                         const bool show_module = (style == DumpStyleResolvedDescription);
 633                         const bool show_fullpaths = false;
 634                         const bool show_inlined_frames = true;
 635                         if (sc.function == NULL && sc.symbol != NULL)
 636                         {
 637                             // If we have just a symbol make sure it is in the right section
 638                             if (sc.symbol->ValueIsAddress())
 639                             {
 640                                 if (sc.symbol->GetAddress().GetSection() != GetSection())
 641                                 {
 642                                     // don't show the module if the symbol is a trampoline symbol
 643                                     show_stop_context = false;
 644                                 }
 645                             }
 646                         }
 647                         if (show_stop_context)
 648                         {
 649                             // We have a function or a symbol from the same
 650                             // sections as this address.
 651                             sc.DumpStopContext (s,
 652                                                 exe_scope,
 653                                                 *this,
 654                                                 show_fullpaths,
 655                                                 show_module,
 656                                                 show_inlined_frames);
 657                         }
 658                         else
 659                         {
 660                             // We found a symbol but it was in a different
 661                             // section so it isn't the symbol we should be
 662                             // showing, just show the section name + offset
 663                             Dump (s, exe_scope, DumpStyleSectionNameOffset);
 664                         }
 665                     }
 666                 }
 667             }
 668         }
 669         else
 670         {
 671             if (fallback_style != DumpStyleInvalid)
 672                 return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 673             return false;
 674         }
 675         break;
 676
 677     case DumpStyleDetailedSymbolContext:
 678         if (IsSectionOffset())
 679         {
 680             ModuleSP module_sp (GetModule());
 681             if (module_sp)
 682             {
 683                 SymbolContext sc;
 684                 module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextEverything, sc);
 685                 if (sc.symbol)
 686                 {
 687                     // If we have just a symbol make sure it is in the same section
 688                     // as our address. If it isn't, then we might have just found
 689                     // the last symbol that came before the address that we are
 690                     // looking up that has nothing to do with our address lookup.
 691                     if (sc.symbol->ValueIsAddress() && sc.symbol->GetAddress().GetSection() != GetSection())
 692                         sc.symbol = NULL;
 693                 }
 694                 sc.GetDescription(s, eDescriptionLevelBrief, target);
 695
 696                 if (sc.block)
 697                 {
 698                     bool can_create = true;
 699                     bool get_parent_variables = true;
 700                     bool stop_if_block_is_inlined_function = false;
 701                     VariableList variable_list;
 702                     sc.block->AppendVariables (can_create,
 703                                                get_parent_variables,
 704                                                stop_if_block_is_inlined_function,
 705                                                &variable_list);
 706
 707                     const size_t num_variables = variable_list.GetSize();
 708                     for (size_t var_idx = 0; var_idx < num_variables; ++var_idx)
 709                     {
 710                         Variable *var = variable_list.GetVariableAtIndex (var_idx).get();
 711                         if (var && var->LocationIsValidForAddress (*this))
 712                         {
 713                             s->Indent();
 714                             s->Printf ("   Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\", type= \"%s\", location =",
 715                                        var->GetID(),
 716                                        var->GetName().GetCString(),
 717                                        var->GetType()->GetName().GetCString());
 718                             var->DumpLocationForAddress(s, *this);
 719                             s->PutCString(", decl = ");
 720                             var->GetDeclaration().DumpStopContext(s, false);
 721                             s->EOL();
 722                         }
 723                     }
 724                 }
 725             }
 726         }
 727         else
 728         {
 729             if (fallback_style != DumpStyleInvalid)
 730                 return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 731             return false;
 732         }
 733         break;
 734     case DumpStyleResolvedPointerDescription:
 735         {
 736             Process *process = exe_ctx.GetProcessPtr();
 737             if (process)
 738             {
 739                 addr_t load_addr = GetLoadAddress (target);
 740                 if (load_addr != LLDB_INVALID_ADDRESS)
 741                 {
 742                     Error memory_error;
 743                     addr_t dereferenced_load_addr = process->ReadPointerFromMemory(load_addr, memory_error);
 744                     if (dereferenced_load_addr != LLDB_INVALID_ADDRESS)
 745                     {
 746                         Address dereferenced_addr;
 747                         if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr, target))
 748                         {
 749                             StreamString strm;
 750                             if (dereferenced_addr.Dump (&strm, exe_scope, DumpStyleResolvedDescription, DumpStyleInvalid, addr_size))
 751                             {
 752                                 s->Address (dereferenced_load_addr, addr_size, " -> ", " ");
 753                                 s->Write(strm.GetData(), strm.GetSize());
 754                                 return true;
 755                             }
 756                         }
 757                     }
 758                 }
 759             }
 760             if (fallback_style != DumpStyleInvalid)
 761                 return Dump (s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
 762             return false;
 763         }
 764         break;
 765     }
 766
 767     return true;
 768 }
 769
 770 uint32_t
 771 Address::CalculateSymbolContext (SymbolContext *sc, uint32_t resolve_scope) const
 772 {
 773     sc->Clear(false);
 774     // Absolute addresses don't have enough information to reconstruct even their target.
 775
 776     SectionSP section_sp (GetSection());
 777     if (section_sp)
 778     {
 779         ModuleSP module_sp (section_sp->GetModule());
 780         if (module_sp)
 781         {
 782             sc->module_sp = module_sp;
 783             if (sc->module_sp)
 784                 return sc->module_sp->ResolveSymbolContextForAddress (*this, resolve_scope, *sc);
 785         }
 786     }
 787     return 0;
 788 }
 789
 790 ModuleSP
 791 Address::CalculateSymbolContextModule () const
 792 {
 793     SectionSP section_sp (GetSection());
 794     if (section_sp)
 795         return section_sp->GetModule();
 796     return ModuleSP();
 797 }
 798
 799 CompileUnit *
 800 Address::CalculateSymbolContextCompileUnit () const
 801 {
 802     SectionSP section_sp (GetSection());
 803     if (section_sp)
 804     {
 805         SymbolContext sc;
 806         sc.module_sp = section_sp->GetModule();
 807         if (sc.module_sp)
 808         {
 809             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextCompUnit, sc);
 810             return sc.comp_unit;
 811         }
 812     }
 813     return NULL;
 814 }
 815
 816 Function *
 817 Address::CalculateSymbolContextFunction () const
 818 {
 819     SectionSP section_sp (GetSection());
 820     if (section_sp)
 821     {
 822         SymbolContext sc;
 823         sc.module_sp = section_sp->GetModule();
 824         if (sc.module_sp)
 825         {
 826             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextFunction, sc);
 827             return sc.function;
 828         }
 829     }
 830     return NULL;
 831 }
 832
 833 Block *
 834 Address::CalculateSymbolContextBlock () const
 835 {
 836     SectionSP section_sp (GetSection());
 837     if (section_sp)
 838     {
 839         SymbolContext sc;
 840         sc.module_sp = section_sp->GetModule();
 841         if (sc.module_sp)
 842         {
 843             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextBlock, sc);
 844             return sc.block;
 845         }
 846     }
 847     return NULL;
 848 }
 849
 850 Symbol *
 851 Address::CalculateSymbolContextSymbol () const
 852 {
 853     SectionSP section_sp (GetSection());
 854     if (section_sp)
 855     {
 856         SymbolContext sc;
 857         sc.module_sp = section_sp->GetModule();
 858         if (sc.module_sp)
 859         {
 860             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextSymbol, sc);
 861             return sc.symbol;
 862         }
 863     }
 864     return NULL;
 865 }
 866
 867 bool
 868 Address::CalculateSymbolContextLineEntry (LineEntry &line_entry) const
 869 {
 870     SectionSP section_sp (GetSection());
 871     if (section_sp)
 872     {
 873         SymbolContext sc;
 874         sc.module_sp = section_sp->GetModule();
 875         if (sc.module_sp)
 876         {
 877             sc.module_sp->ResolveSymbolContextForAddress (*this, eSymbolContextLineEntry, sc);
 878             if (sc.line_entry.IsValid())
 879             {
 880                 line_entry = sc.line_entry;
 881                 return true;
 882             }
 883         }
 884     }
 885     line_entry.Clear();
 886     return false;
 887 }
 888
 889 int
 890 Address::CompareFileAddress (const Address& a, const Address& b)
 891 {
 892     addr_t a_file_addr = a.GetFileAddress();
 893     addr_t b_file_addr = b.GetFileAddress();
 894     if (a_file_addr < b_file_addr)
 895         return -1;
 896     if (a_file_addr > b_file_addr)
 897         return +1;
 898     return 0;
 899 }
 900
 901
 902 int
 903 Address::CompareLoadAddress (const Address& a, const Address& b, Target *target)
 904 {
 905     assert (target != NULL);
 906     addr_t a_load_addr = a.GetLoadAddress (target);
 907     addr_t b_load_addr = b.GetLoadAddress (target);
 908     if (a_load_addr < b_load_addr)
 909         return -1;
 910     if (a_load_addr > b_load_addr)
 911         return +1;
 912     return 0;
 913 }
 914
 915 int
 916 Address::CompareModulePointerAndOffset (const Address& a, const Address& b)
 917 {
 918     ModuleSP a_module_sp (a.GetModule());
 919     ModuleSP b_module_sp (b.GetModule());
 920     Module *a_module = a_module_sp.get();
 921     Module *b_module = b_module_sp.get();
 922     if (a_module < b_module)
 923         return -1;
 924     if (a_module > b_module)
 925         return +1;
 926     // Modules are the same, just compare the file address since they should
 927     // be unique
 928     addr_t a_file_addr = a.GetFileAddress();
 929     addr_t b_file_addr = b.GetFileAddress();
 930     if (a_file_addr < b_file_addr)
 931         return -1;
 932     if (a_file_addr > b_file_addr)
 933         return +1;
 934     return 0;
 935 }
 936
 937
 938 size_t
 939 Address::MemorySize () const
 940 {
 941     // Noting special for the memory size of a single Address object,
 942     // it is just the size of itself.
 943     return sizeof(Address);
 944 }
 945
 946
 947 //----------------------------------------------------------------------
 948 // NOTE: Be careful using this operator. It can correctly compare two
 949 // addresses from the same Module correctly. It can't compare two
 950 // addresses from different modules in any meaningful way, but it will
 951 // compare the module pointers.
 952 //
 953 // To sum things up:
 954 // - works great for addresses within the same module
 955 // - it works for addresses across multiple modules, but don't expect the
 956 //   address results to make much sense
 957 //
 958 // This basically lets Address objects be used in ordered collection
 959 // classes.
 960 //----------------------------------------------------------------------
 961
 962 bool
 963 lldb_private::operator< (const Address& lhs, const Address& rhs)
 964 {
 965     ModuleSP lhs_module_sp (lhs.GetModule());
 966     ModuleSP rhs_module_sp (rhs.GetModule());
 967     Module *lhs_module = lhs_module_sp.get();
 968     Module *rhs_module = rhs_module_sp.get();
 969     if (lhs_module == rhs_module)
 970     {
 971         // Addresses are in the same module, just compare the file addresses
 972         return lhs.GetFileAddress() < rhs.GetFileAddress();
 973     }
 974     else
 975     {
 976         // The addresses are from different modules, just use the module
 977         // pointer value to get consistent ordering
 978         return lhs_module < rhs_module;
 979     }
 980 }
 981
 982 bool
 983 lldb_private::operator> (const Address& lhs, const Address& rhs)
 984 {
 985     ModuleSP lhs_module_sp (lhs.GetModule());
 986     ModuleSP rhs_module_sp (rhs.GetModule());
 987     Module *lhs_module = lhs_module_sp.get();
 988     Module *rhs_module = rhs_module_sp.get();
 989     if (lhs_module == rhs_module)
 990     {
 991         // Addresses are in the same module, just compare the file addresses
 992         return lhs.GetFileAddress() > rhs.GetFileAddress();
 993     }
 994     else
 995     {
 996         // The addresses are from different modules, just use the module
 997         // pointer value to get consistent ordering
 998         return lhs_module > rhs_module;
 999     }
1000 }
1001
1002
1003 // The operator == checks for exact equality only (same section, same offset)
1004 bool
1005 lldb_private::operator== (const Address& a, const Address& rhs)
1006 {
1007     return  a.GetOffset()  == rhs.GetOffset() &&
1008             a.GetSection() == rhs.GetSection();
1009 }
1010 // The operator != checks for exact inequality only (differing section, or
1011 // different offset)
1012 bool
1013 lldb_private::operator!= (const Address& a, const Address& rhs)
1014 {
1015     return  a.GetOffset()  != rhs.GetOffset() ||
1016             a.GetSection() != rhs.GetSection();
1017 }
1018
1019 AddressClass
1020 Address::GetAddressClass () const
1021 {
1022     ModuleSP module_sp (GetModule());
1023     if (module_sp)
1024     {
1025         ObjectFile *obj_file = module_sp->GetObjectFile();
1026         if (obj_file)
1027         {
1028             // Give the symbol vendor a chance to add to the unified section list.
1029             module_sp->GetSymbolVendor();
1030             return obj_file->GetAddressClass (GetFileAddress());
1031         }
1032     }
1033     return eAddressClassUnknown;
1034 }
1035
1036 bool
1037 Address::SetLoadAddress (lldb::addr_t load_addr, Target *target)
1038 {
1039     if (target && target->GetSectionLoadList().ResolveLoadAddress(load_addr, *this))
1040         return true;
1041     m_section_wp.reset();
1042     m_offset = load_addr;
1043     return false;
1044 }
1045