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