contrib/llvm/tools/lldb/source/API/SBSection.cpp

   1 //===-- SBSection.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/API/SBSection.h"
  11 #include "lldb/API/SBStream.h"
  12 #include "lldb/API/SBTarget.h"
  13 #include "lldb/Core/Module.h"
  14 #include "lldb/Core/Section.h"
  15 #include "lldb/Symbol/ObjectFile.h"
  16 #include "lldb/Utility/DataBuffer.h"
  17 #include "lldb/Utility/DataBufferLLVM.h"
  18 #include "lldb/Utility/DataExtractor.h"
  19 #include "lldb/Utility/Log.h"
  20 #include "lldb/Utility/StreamString.h"
  21
  22 using namespace lldb;
  23 using namespace lldb_private;
  24
  25 SBSection::SBSection() : m_opaque_wp() {}
  26
  27 SBSection::SBSection(const SBSection &rhs) : m_opaque_wp(rhs.m_opaque_wp) {}
  28
  29 SBSection::SBSection(const lldb::SectionSP &section_sp)
  30     : m_opaque_wp() // Don't init with section_sp otherwise this will throw if
  31                     // section_sp doesn't contain a valid Section *
  32 {
  33   if (section_sp)
  34     m_opaque_wp = section_sp;
  35 }
  36
  37 const SBSection &SBSection::operator=(const SBSection &rhs) {
  38   m_opaque_wp = rhs.m_opaque_wp;
  39   return *this;
  40 }
  41
  42 SBSection::~SBSection() {}
  43
  44 bool SBSection::IsValid() const {
  45   SectionSP section_sp(GetSP());
  46   return section_sp && section_sp->GetModule().get() != NULL;
  47 }
  48
  49 const char *SBSection::GetName() {
  50   SectionSP section_sp(GetSP());
  51   if (section_sp)
  52     return section_sp->GetName().GetCString();
  53   return NULL;
  54 }
  55
  56 lldb::SBSection SBSection::GetParent() {
  57   lldb::SBSection sb_section;
  58   SectionSP section_sp(GetSP());
  59   if (section_sp) {
  60     SectionSP parent_section_sp(section_sp->GetParent());
  61     if (parent_section_sp)
  62       sb_section.SetSP(parent_section_sp);
  63   }
  64   return sb_section;
  65 }
  66
  67 lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
  68   lldb::SBSection sb_section;
  69   if (sect_name) {
  70     SectionSP section_sp(GetSP());
  71     if (section_sp) {
  72       ConstString const_sect_name(sect_name);
  73       sb_section.SetSP(
  74           section_sp->GetChildren().FindSectionByName(const_sect_name));
  75     }
  76   }
  77   return sb_section;
  78 }
  79
  80 size_t SBSection::GetNumSubSections() {
  81   SectionSP section_sp(GetSP());
  82   if (section_sp)
  83     return section_sp->GetChildren().GetSize();
  84   return 0;
  85 }
  86
  87 lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) {
  88   lldb::SBSection sb_section;
  89   SectionSP section_sp(GetSP());
  90   if (section_sp)
  91     sb_section.SetSP(section_sp->GetChildren().GetSectionAtIndex(idx));
  92   return sb_section;
  93 }
  94
  95 lldb::SectionSP SBSection::GetSP() const { return m_opaque_wp.lock(); }
  96
  97 void SBSection::SetSP(const lldb::SectionSP &section_sp) {
  98   m_opaque_wp = section_sp;
  99 }
 100
 101 lldb::addr_t SBSection::GetFileAddress() {
 102   lldb::addr_t file_addr = LLDB_INVALID_ADDRESS;
 103   SectionSP section_sp(GetSP());
 104   if (section_sp)
 105     return section_sp->GetFileAddress();
 106   return file_addr;
 107 }
 108
 109 lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
 110   TargetSP target_sp(sb_target.GetSP());
 111   if (target_sp) {
 112     SectionSP section_sp(GetSP());
 113     if (section_sp)
 114       return section_sp->GetLoadBaseAddress(target_sp.get());
 115   }
 116   return LLDB_INVALID_ADDRESS;
 117 }
 118
 119 lldb::addr_t SBSection::GetByteSize() {
 120   SectionSP section_sp(GetSP());
 121   if (section_sp)
 122     return section_sp->GetByteSize();
 123   return 0;
 124 }
 125
 126 uint64_t SBSection::GetFileOffset() {
 127   SectionSP section_sp(GetSP());
 128   if (section_sp) {
 129     ModuleSP module_sp(section_sp->GetModule());
 130     if (module_sp) {
 131       ObjectFile *objfile = module_sp->GetObjectFile();
 132       if (objfile)
 133         return objfile->GetFileOffset() + section_sp->GetFileOffset();
 134     }
 135   }
 136   return UINT64_MAX;
 137 }
 138
 139 uint64_t SBSection::GetFileByteSize() {
 140   SectionSP section_sp(GetSP());
 141   if (section_sp)
 142     return section_sp->GetFileSize();
 143   return 0;
 144 }
 145
 146 SBData SBSection::GetSectionData() { return GetSectionData(0, UINT64_MAX); }
 147
 148 SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
 149   SBData sb_data;
 150   SectionSP section_sp(GetSP());
 151   if (section_sp) {
 152     const uint64_t sect_file_size = section_sp->GetFileSize();
 153     if (sect_file_size > 0) {
 154       ModuleSP module_sp(section_sp->GetModule());
 155       if (module_sp) {
 156         ObjectFile *objfile = module_sp->GetObjectFile();
 157         if (objfile) {
 158           const uint64_t sect_file_offset =
 159               objfile->GetFileOffset() + section_sp->GetFileOffset();
 160           const uint64_t file_offset = sect_file_offset + offset;
 161           uint64_t file_size = size;
 162           if (file_size == UINT64_MAX) {
 163             file_size = section_sp->GetByteSize();
 164             if (file_size > offset)
 165               file_size -= offset;
 166             else
 167               file_size = 0;
 168           }
 169           auto data_buffer_sp = DataBufferLLVM::CreateSliceFromPath(
 170               objfile->GetFileSpec().GetPath(), file_size, file_offset);
 171           if (data_buffer_sp && data_buffer_sp->GetByteSize() > 0) {
 172             DataExtractorSP data_extractor_sp(
 173                 new DataExtractor(data_buffer_sp, objfile->GetByteOrder(),
 174                                   objfile->GetAddressByteSize()));
 175
 176             sb_data.SetOpaque(data_extractor_sp);
 177           }
 178         }
 179       }
 180     }
 181   }
 182   return sb_data;
 183 }
 184
 185 SectionType SBSection::GetSectionType() {
 186   SectionSP section_sp(GetSP());
 187   if (section_sp.get())
 188     return section_sp->GetType();
 189   return eSectionTypeInvalid;
 190 }
 191
 192 uint32_t
 193 SBSection::GetPermissions() const
 194 {
 195     SectionSP section_sp(GetSP());
 196     if (section_sp)
 197         return section_sp->GetPermissions();
 198     return 0;
 199 }
 200
 201 uint32_t SBSection::GetTargetByteSize() {
 202   SectionSP section_sp(GetSP());
 203   if (section_sp.get())
 204     return section_sp->GetTargetByteSize();
 205   return 0;
 206 }
 207
 208 bool SBSection::operator==(const SBSection &rhs) {
 209   SectionSP lhs_section_sp(GetSP());
 210   SectionSP rhs_section_sp(rhs.GetSP());
 211   if (lhs_section_sp && rhs_section_sp)
 212     return lhs_section_sp == rhs_section_sp;
 213   return false;
 214 }
 215
 216 bool SBSection::operator!=(const SBSection &rhs) {
 217   SectionSP lhs_section_sp(GetSP());
 218   SectionSP rhs_section_sp(rhs.GetSP());
 219   return lhs_section_sp != rhs_section_sp;
 220 }
 221
 222 bool SBSection::GetDescription(SBStream &description) {
 223   Stream &strm = description.ref();
 224
 225   SectionSP section_sp(GetSP());
 226   if (section_sp) {
 227     const addr_t file_addr = section_sp->GetFileAddress();
 228     strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 ") ", file_addr,
 229                 file_addr + section_sp->GetByteSize());
 230     section_sp->DumpName(&strm);
 231   } else {
 232     strm.PutCString("No value");
 233   }
 234
 235   return true;
 236 }