|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * |
|
5 * This program is free software: you can redistribute it and/or modify |
|
6 * it under the terms of the GNU Lesser General Public License as published by |
|
7 * the Free Software Foundation, either version 3 of the License, or |
|
8 * (at your option) any later version. |
|
9 * |
|
10 * This program is distributed in the hope that it will be useful, |
|
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
13 * GNU Lesser General Public License for more details. |
|
14 * |
|
15 * You should have received a copy of the GNU Lesser General Public License |
|
16 * along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
17 */ |
|
18 |
|
19 #ifndef DWARFMANAGER_H_ |
|
20 #define DWARFMANAGER_H_ |
|
21 |
|
22 #include <vector> |
|
23 #include <map> |
|
24 #include <string> |
|
25 #include <libelf.h> |
|
26 |
|
27 #include "dwarfdefs.h" |
|
28 #include "dwarf.h" |
|
29 #include "defs.h" |
|
30 #include "filefragment.h" |
|
31 #include "romdetails.h" |
|
32 #include "elfsectionmanager.h" |
|
33 |
|
34 using namespace std; |
|
35 |
|
36 class FileShdrPair { |
|
37 public: |
|
38 FileShdrPair(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr): |
|
39 iXIPFileDetails(aXIPFileDetails), |
|
40 iShdr(*aShdr) |
|
41 {} |
|
42 FileShdrPair & FileShdrPair::operator=(const FileShdrPair & aFileShdrPair) { |
|
43 iXIPFileDetails = aFileShdrPair.iXIPFileDetails; |
|
44 iShdr = aFileShdrPair.iShdr; |
|
45 return *this; |
|
46 } |
|
47 |
|
48 FileShdrPair::FileShdrPair(const FileShdrPair &aFileShdrPair): |
|
49 iXIPFileDetails(aFileShdrPair.iXIPFileDetails), |
|
50 iShdr(aFileShdrPair.iShdr) |
|
51 {} |
|
52 |
|
53 XIPFileDetails & iXIPFileDetails; |
|
54 Elf32_Shdr iShdr; |
|
55 }; |
|
56 |
|
57 typedef std::vector<FileShdrPair> FileShdrList; |
|
58 |
|
59 void EditLocationExpression (Dwarf_Byte_Ptr data, |
|
60 unsigned int pointer_size, |
|
61 unsigned long length, |
|
62 FileShdrPair & aPair); |
|
63 class DwarfManager; |
|
64 |
|
65 class DwarfSectionManager : public FileFragmentOwner { |
|
66 public: |
|
67 DwarfSectionManager(ElfSectionManager & aElfSectionManager, |
|
68 DwarfManager & aDwarfManager, |
|
69 const string & aName, |
|
70 RomDetails * aRomDetails): |
|
71 iElfSectionManager(aElfSectionManager), |
|
72 iDwarfManager(aDwarfManager), |
|
73 iSectionName(aName), |
|
74 iSizeValid(false), |
|
75 iSize(0), |
|
76 iData(NULL), |
|
77 iRomDetails(aRomDetails) |
|
78 {} |
|
79 |
|
80 virtual ~DwarfSectionManager() { |
|
81 iFileShdrList.clear(); |
|
82 } |
|
83 |
|
84 // The FileFragmentOwner protocol |
|
85 virtual void DeleteFileFragmentData(){ |
|
86 if (iData) { |
|
87 Dwarf_Byte_Ptr d = iData; |
|
88 iData = NULL; |
|
89 delete [] d; |
|
90 } |
|
91 } |
|
92 |
|
93 virtual void AddSection(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr); |
|
94 virtual void SetupSection(); |
|
95 const string & GetSectionName() { return iSectionName; } |
|
96 virtual Dwarf_Byte_Ptr GetSectionData(FileShdrPair & aPair); |
|
97 |
|
98 |
|
99 |
|
100 // LEB decoding |
|
101 // Leb128 decoding used by all Dwarf section managers (potentially) |
|
102 // TODO could get rid of LEB macros and define as inline functions. |
|
103 #define DECODE_ULEB128(v,p,n) \ |
|
104 Dwarf_Word v = DwarfSectionManager::DecodeUnsignedLeb128(p, n);\ |
|
105 p += n; |
|
106 #define ULEB128(p,n) \ |
|
107 DwarfSectionManager::DecodeUnsignedLeb128(p, n);\ |
|
108 p += n; |
|
109 static Dwarf_Unsigned DecodeUnsignedLeb128(Dwarf_Byte_Ptr leb128, size_t & leb128_length); |
|
110 #define DECODE_SLEB128(v,p,n) \ |
|
111 Dwarf_Word v = DwarfSectionManager::DecodeSignedLeb128(p, n);\ |
|
112 p += n; |
|
113 #define SLEB128(p,n) \ |
|
114 DwarfSectionManager::DecodeSignedLeb128(p, n);\ |
|
115 p += n; |
|
116 static Dwarf_Signed DecodeSignedLeb128(Dwarf_Byte_Ptr leb128, size_t & leb128_length); |
|
117 |
|
118 private: |
|
119 // Don't want one of these to be copied |
|
120 DwarfSectionManager(const DwarfSectionManager & aDwarfSectionManager); |
|
121 |
|
122 DwarfSectionManager & operator=(const DwarfSectionManager & aDwarfSectionManager); |
|
123 protected: |
|
124 |
|
125 virtual Dwarf_Byte_Ptr GetData(){ return iData; } |
|
126 virtual void SetData(Dwarf_Byte_Ptr data) { iData = data; } |
|
127 |
|
128 size_t CheckNewOffset(size_t base, size_t offset){ |
|
129 const Dwarf_Off limit = 0xfffffff0ul; |
|
130 Dwarf_Off newOffset = base + offset; |
|
131 if (newOffset >= limit) { |
|
132 cerr << "Error: cannot support transition from 32 to 64 bit offsets\n"; |
|
133 exit(EXIT_FAILURE); |
|
134 } |
|
135 return (size_t)newOffset; |
|
136 } |
|
137 |
|
138 protected: |
|
139 ElfSectionManager & iElfSectionManager; |
|
140 DwarfManager & iDwarfManager; |
|
141 FileShdrList iFileShdrList; |
|
142 const string iSectionName; |
|
143 bool iSizeValid; |
|
144 size_t iSize; |
|
145 Dwarf_Byte_Ptr iData; |
|
146 RomDetails * iRomDetails; |
|
147 }; |
|
148 |
|
149 class DwarfConcatenatedSectionManager : public DwarfSectionManager { |
|
150 public: |
|
151 DwarfConcatenatedSectionManager(ElfSectionManager & aElfSectionManager, |
|
152 DwarfManager & aDwarfManager, |
|
153 const string & aName, |
|
154 RomDetails * aRomDetails): |
|
155 DwarfSectionManager(aElfSectionManager, |
|
156 aDwarfManager, |
|
157 aName, |
|
158 aRomDetails) |
|
159 {} |
|
160 |
|
161 // The FileFragmentOwner protocol |
|
162 virtual void GetFileFragmentData(FileFragmentData & aFileFragmentData ); |
|
163 virtual size_t Size(); |
|
164 |
|
165 virtual void ConcatenateData(); |
|
166 virtual void ProcessSection(FileShdrPair & aPair); |
|
167 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end){}; |
|
168 |
|
169 // Concatenated section protocol |
|
170 virtual void SetSectionOffset(PathName & aPathName, size_t aOffset); |
|
171 virtual void InitOffsetMap(); |
|
172 virtual size_t GetSectionOffset(PathName & aPathName); |
|
173 virtual void SetSectionSize(PathName & aPathName, size_t aSize); |
|
174 virtual size_t GetSectionSize(PathName & aPathName); |
|
175 |
|
176 Dwarf_Byte_Ptr GetSection(PathName & aPathName); |
|
177 |
|
178 protected: |
|
179 typedef std::map<PathName, size_t> PathNameSectionOffsetMap; |
|
180 PathNameSectionOffsetMap iPathNameSectionOffsetMap; |
|
181 PathNameSectionOffsetMap iPathNameSectionSizeMap; |
|
182 |
|
183 |
|
184 }; |
|
185 |
|
186 class DwarfFragmentedSectionManager : public DwarfConcatenatedSectionManager { |
|
187 public: |
|
188 DwarfFragmentedSectionManager(ElfSectionManager & aElfSectionManager, |
|
189 DwarfManager & aDwarfManager, |
|
190 const string & aName, |
|
191 RomDetails * aRomDetails): |
|
192 DwarfConcatenatedSectionManager(aElfSectionManager, |
|
193 aDwarfManager, |
|
194 aName, |
|
195 aRomDetails), |
|
196 iInitialTraceMessage(true) |
|
197 {} |
|
198 |
|
199 // Override the method of setting up the section |
|
200 virtual void SetupSection(); |
|
201 |
|
202 // The FileFragmentOwner protocol |
|
203 virtual void GetFileFragmentData(FileFragmentData & aFileFragmentData ); |
|
204 //virtual size_t Size(); |
|
205 |
|
206 virtual void ConcatenateData(); |
|
207 |
|
208 void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr & aData); |
|
209 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end) = 0; |
|
210 |
|
211 private: |
|
212 bool iInitialTraceMessage; |
|
213 |
|
214 }; |
|
215 |
|
216 class DebugAbbrevAttrForm { |
|
217 public: |
|
218 DebugAbbrevAttrForm(): |
|
219 iAttr(0), |
|
220 iForm(0) |
|
221 {} |
|
222 DebugAbbrevAttrForm(Dwarf_Half a, Dwarf_Half f): |
|
223 iAttr(a), |
|
224 iForm(f) |
|
225 {} |
|
226 Dwarf_Half iAttr; |
|
227 Dwarf_Half iForm; |
|
228 }; |
|
229 |
|
230 class DebugAbbrev { |
|
231 public: |
|
232 DebugAbbrev(): |
|
233 iCode(0), |
|
234 iTag(0), |
|
235 iCount(0), |
|
236 iRaw(NULL), |
|
237 iParsed(NULL) |
|
238 {} |
|
239 DebugAbbrev(Dwarf_Unsigned c, Dwarf_Unsigned t, size_t n, Dwarf_Byte_Ptr r, DebugAbbrevAttrForm * p): |
|
240 iCode(c), |
|
241 iTag(t), |
|
242 iCount(n), |
|
243 iRaw(r), |
|
244 iParsed(p) |
|
245 {} |
|
246 DebugAbbrev & operator=(const DebugAbbrev & aDebugAbbrev){ |
|
247 iCode = aDebugAbbrev.iCode; |
|
248 iTag = aDebugAbbrev.iTag; |
|
249 iCount = aDebugAbbrev.iCount; |
|
250 iRaw = aDebugAbbrev.iRaw; |
|
251 iParsed = aDebugAbbrev.iParsed; |
|
252 return *this; |
|
253 } |
|
254 |
|
255 DebugAbbrev(const DebugAbbrev & aDebugAbbrev){ |
|
256 *this = aDebugAbbrev; |
|
257 } |
|
258 |
|
259 void Destroy(){ |
|
260 if (iParsed){ |
|
261 DebugAbbrevAttrForm * d = iParsed; |
|
262 iParsed = NULL; |
|
263 delete [] d; |
|
264 } |
|
265 } |
|
266 #if 0 |
|
267 // can't have default dtor do anything until and unless we prevent iParsed getting deleted |
|
268 // whenever the class is copied in STL containers. |
|
269 ~DebugAbbrev(){ |
|
270 if (iParsed){ |
|
271 DebugAbbrevAttrForm * d = iParsed; |
|
272 iParsed = NULL; |
|
273 delete [] d; |
|
274 } |
|
275 } |
|
276 #endif |
|
277 Dwarf_Unsigned iCode; |
|
278 Dwarf_Unsigned iTag; |
|
279 size_t iCount; |
|
280 Dwarf_Byte_Ptr iRaw; |
|
281 DebugAbbrevAttrForm * iParsed; |
|
282 }; |
|
283 |
|
284 class InfoContext { |
|
285 private: |
|
286 typedef std::map<Dwarf_Word, DebugAbbrev> AbbrevMap; |
|
287 class AbbrevMapEntry { |
|
288 public: |
|
289 AbbrevMapEntry(): |
|
290 iCursor(NULL), |
|
291 iMap(NULL) |
|
292 {} |
|
293 AbbrevMapEntry(Dwarf_Byte_Ptr c, AbbrevMap * m): |
|
294 iCursor(c), |
|
295 iMap(m) |
|
296 {} |
|
297 Dwarf_Byte_Ptr iCursor; |
|
298 AbbrevMap * iMap; |
|
299 }; |
|
300 typedef std::map<Uint32, AbbrevMapEntry> AbbrevOffsetMap; |
|
301 |
|
302 public: |
|
303 InfoContext(): |
|
304 iContextValid(false), |
|
305 iSectionStart(NULL), |
|
306 iSectionEnd(NULL), |
|
307 iSectionOffset(0), |
|
308 // this is an invalid offset for 32 bit dwarf |
|
309 // and will trigger the right behaviour in SetAbbrevOffset |
|
310 // when called from Init |
|
311 iAbbrevOffset(0xffffffff), |
|
312 |
|
313 iAbbrevMapEntry(NULL, NULL) |
|
314 { |
|
315 //ClearMap(); |
|
316 } |
|
317 ~InfoContext(){ |
|
318 Reset(); |
|
319 } |
|
320 void Init(Dwarf_Byte_Ptr s, Dwarf_Byte_Ptr e, size_t o){ |
|
321 iSectionStart = s; |
|
322 iSectionEnd = e; |
|
323 iSectionOffset = o; |
|
324 //ClearMap(); |
|
325 iContextValid = true; |
|
326 SetAbbrevOffset(0); |
|
327 } |
|
328 void Reset(){ |
|
329 iContextValid = false; |
|
330 iSectionStart = iSectionEnd = NULL; |
|
331 iSectionOffset = 0; |
|
332 iAbbrevOffset = 0xffffffff; |
|
333 ClearMap(); |
|
334 } |
|
335 void ClearMap() { |
|
336 for (AbbrevOffsetMap::iterator i = iMap.begin(); i != iMap.end(); i++){ |
|
337 AbbrevMap::iterator e = i->second.iMap->end(); |
|
338 for (AbbrevMap::iterator b = i->second.iMap->begin(); b != e; b++){ |
|
339 b->second.Destroy(); |
|
340 } |
|
341 i->second.iMap->clear(); |
|
342 } |
|
343 iMap.clear(); |
|
344 } |
|
345 size_t GetSectionOffset(){ return iSectionOffset; } |
|
346 |
|
347 void SetAbbrevOffset(size_t offset); |
|
348 |
|
349 DebugAbbrev & GetAbbrev(Dwarf_Word aCode); |
|
350 DebugAbbrev & FindAbbrev(Dwarf_Word aCode); |
|
351 |
|
352 bool iContextValid; |
|
353 Dwarf_Byte_Ptr iSectionStart; |
|
354 Dwarf_Byte_Ptr iSectionEnd; |
|
355 size_t iSectionOffset; |
|
356 size_t iAbbrevOffset; |
|
357 AbbrevMapEntry iAbbrevMapEntry; |
|
358 AbbrevOffsetMap iMap; |
|
359 }; |
|
360 |
|
361 class DwarfAbbrevManager : public DwarfConcatenatedSectionManager { |
|
362 public: |
|
363 DwarfAbbrevManager(ElfSectionManager & aElfSectionManager, |
|
364 DwarfManager & aDwarfManager, |
|
365 RomDetails * aRomDetails): |
|
366 DwarfConcatenatedSectionManager(aElfSectionManager, |
|
367 aDwarfManager, |
|
368 iAbbrevSectionName, |
|
369 aRomDetails) |
|
370 {} |
|
371 |
|
372 // we might need to hang onto this after its been written to file |
|
373 virtual void DeleteFileFragmentData(){} |
|
374 |
|
375 void StartContext(PathName & aName); |
|
376 void EndContext(); |
|
377 void SetContextAbbrevOffset(Uint32 offset); |
|
378 size_t GetContextSectionOffset(); |
|
379 |
|
380 DebugAbbrev & GetAbbrev(Dwarf_Word aCode); |
|
381 private: |
|
382 static const string iAbbrevSectionName; |
|
383 InfoContext iInfoContext; |
|
384 |
|
385 }; |
|
386 |
|
387 class DwarfMacinfoManager : public DwarfFragmentedSectionManager { |
|
388 public: |
|
389 DwarfMacinfoManager(ElfSectionManager & aElfSectionManager, |
|
390 DwarfManager & aDwarfManager, |
|
391 RomDetails * aRomDetails): |
|
392 DwarfFragmentedSectionManager(aElfSectionManager, |
|
393 aDwarfManager, |
|
394 iMacinfoSectionName, |
|
395 aRomDetails) |
|
396 {} |
|
397 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end){}; |
|
398 |
|
399 private: |
|
400 |
|
401 static const string iMacinfoSectionName; |
|
402 }; |
|
403 |
|
404 //class DwarfInfoManager : public DwarfConcatenatedSectionManager { |
|
405 class DwarfInfoManager : public DwarfFragmentedSectionManager { |
|
406 public: |
|
407 DwarfInfoManager(ElfSectionManager & aElfSectionManager, |
|
408 DwarfManager & aDwarfManager, |
|
409 DwarfAbbrevManager & aDwarfAbbrevManager, |
|
410 DwarfMacinfoManager & aDwarfMacinfoManager, |
|
411 RomDetails * aRomDetails): |
|
412 DwarfFragmentedSectionManager(aElfSectionManager, |
|
413 aDwarfManager, |
|
414 iInfoSectionName, |
|
415 aRomDetails), |
|
416 iDwarfAbbrevManager(aDwarfAbbrevManager), |
|
417 iDwarfMacinfoManager(aDwarfMacinfoManager), |
|
418 iAddressSize(4), |
|
419 iLocalLength(0) |
|
420 {} |
|
421 |
|
422 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end); |
|
423 |
|
424 size_t GetPointerSize() { return iAddressSize; } |
|
425 |
|
426 private: |
|
427 Dwarf_Byte_Ptr ProcessCU(FileShdrPair & aPair, Dwarf_Byte_Ptr s, Dwarf_Byte_Ptr e); |
|
428 Dwarf_Byte_Ptr ProcessDIE(FileShdrPair & aPair, Dwarf_Byte_Ptr s, Dwarf_Byte_Ptr e); |
|
429 |
|
430 typedef Dwarf_Byte_Ptr (*InfoEditFn)(DwarfInfoManager&, Dwarf_Byte_Ptr, Dwarf_Half,FileShdrPair & aPair); |
|
431 |
|
432 #define DECLARE_INFO_EDIT_FN(name)static Dwarf_Byte_Ptr name(DwarfInfoManager& aManager, \ |
|
433 Dwarf_Byte_Ptr aPtr, \ |
|
434 Dwarf_Half aForm, \ |
|
435 FileShdrPair & aPair) |
|
436 DECLARE_INFO_EDIT_FN(DefaultInfoEditFn); |
|
437 DECLARE_INFO_EDIT_FN(ErrorInfoEditFn); |
|
438 DECLARE_INFO_EDIT_FN(InfoEditAddress); |
|
439 DECLARE_INFO_EDIT_FN(InfoEditLinePtr); |
|
440 DECLARE_INFO_EDIT_FN(InfoEditLocListPtr); |
|
441 DECLARE_INFO_EDIT_FN(InfoEditLocExpr); |
|
442 DECLARE_INFO_EDIT_FN(InfoEditMacInfoPtr); |
|
443 DECLARE_INFO_EDIT_FN(InfoEditRangeListPtr); |
|
444 DECLARE_INFO_EDIT_FN(InfoEditString); |
|
445 DECLARE_INFO_EDIT_FN(InfoEditReference); |
|
446 DECLARE_INFO_EDIT_FN(InfoEditTrampoline); |
|
447 |
|
448 size_t SizeOfDieValue(Dwarf_Half aForm, Dwarf_Byte_Ptr aPtr); |
|
449 |
|
450 private: |
|
451 static const string iInfoSectionName; |
|
452 DwarfAbbrevManager & iDwarfAbbrevManager; |
|
453 DwarfMacinfoManager & iDwarfMacinfoManager; |
|
454 static InfoEditFn iInfoEditFn[]; |
|
455 |
|
456 size_t iAddressSize; |
|
457 size_t iLocalLength; |
|
458 }; |
|
459 |
|
460 class DwarfFrameManager : public DwarfFragmentedSectionManager { |
|
461 public: |
|
462 DwarfFrameManager(ElfSectionManager & aElfSectionManager, |
|
463 DwarfManager & aDwarfManager, |
|
464 RomDetails * aRomDetails): |
|
465 DwarfFragmentedSectionManager(aElfSectionManager, |
|
466 aDwarfManager, |
|
467 iFrameSectionName, |
|
468 aRomDetails) |
|
469 {} |
|
470 |
|
471 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end); |
|
472 |
|
473 private: |
|
474 typedef std::map<Dwarf_Byte_Ptr, Dwarf_Ubyte> CiePtrEncodingMap; |
|
475 typedef std::map<Dwarf_Byte_Ptr, size_t> CieAugmentationMap; |
|
476 |
|
477 static const string iFrameSectionName; |
|
478 }; |
|
479 |
|
480 class DwarfLineManager : public DwarfFragmentedSectionManager { |
|
481 public: |
|
482 DwarfLineManager(ElfSectionManager & aElfSectionManager, |
|
483 DwarfManager & aDwarfManager, |
|
484 DwarfInfoManager & aDwarfInfoManager, |
|
485 RomDetails * aRomDetails): |
|
486 DwarfFragmentedSectionManager(aElfSectionManager, |
|
487 aDwarfManager, |
|
488 iLineSectionName, |
|
489 aRomDetails), |
|
490 iDwarfInfoManager(aDwarfInfoManager) |
|
491 {} |
|
492 |
|
493 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end); |
|
494 |
|
495 private: |
|
496 DwarfInfoManager & iDwarfInfoManager; |
|
497 |
|
498 static const string iLineSectionName; |
|
499 }; |
|
500 |
|
501 class DwarfLocManager : public DwarfFragmentedSectionManager { |
|
502 public: |
|
503 DwarfLocManager(ElfSectionManager & aElfSectionManager, |
|
504 DwarfManager & aDwarfManager, |
|
505 DwarfInfoManager & aDwarfInfoManager, |
|
506 RomDetails * aRomDetails): |
|
507 DwarfFragmentedSectionManager(aElfSectionManager, |
|
508 aDwarfManager, |
|
509 iLocSectionName, |
|
510 aRomDetails), |
|
511 iDwarfInfoManager(aDwarfInfoManager) |
|
512 {} |
|
513 |
|
514 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end); |
|
515 |
|
516 private: |
|
517 DwarfInfoManager & iDwarfInfoManager; |
|
518 |
|
519 static const string iLocSectionName; |
|
520 }; |
|
521 |
|
522 class DwarfNameManager : public DwarfFragmentedSectionManager { |
|
523 public: |
|
524 DwarfNameManager(ElfSectionManager & aElfSectionManager, |
|
525 DwarfManager & aDwarfManager, |
|
526 const string & aName, |
|
527 DwarfInfoManager & aDwarfInfoManager, |
|
528 RomDetails * aRomDetails): |
|
529 DwarfFragmentedSectionManager(aElfSectionManager, |
|
530 aDwarfManager, |
|
531 aName, |
|
532 aRomDetails), |
|
533 iDwarfInfoManager(aDwarfInfoManager) |
|
534 {} |
|
535 |
|
536 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end); |
|
537 |
|
538 protected: |
|
539 DwarfInfoManager & iDwarfInfoManager; |
|
540 }; |
|
541 |
|
542 class DwarfPubnamesManager : public DwarfNameManager { |
|
543 public: |
|
544 DwarfPubnamesManager(ElfSectionManager & aElfSectionManager, |
|
545 DwarfManager & aDwarfManager, |
|
546 DwarfInfoManager & aDwarfInfoManager, |
|
547 RomDetails * aRomDetails): |
|
548 DwarfNameManager(aElfSectionManager, |
|
549 aDwarfManager, |
|
550 iPubnamesSectionName, |
|
551 aDwarfInfoManager, |
|
552 aRomDetails) |
|
553 {} |
|
554 |
|
555 private: |
|
556 static const string iPubnamesSectionName; |
|
557 }; |
|
558 |
|
559 class DwarfPubtypesManager : public DwarfNameManager { |
|
560 public: |
|
561 DwarfPubtypesManager(ElfSectionManager & aElfSectionManager, |
|
562 DwarfManager & aDwarfManager, |
|
563 DwarfInfoManager & aDwarfInfoManager, |
|
564 RomDetails * aRomDetails): |
|
565 DwarfNameManager(aElfSectionManager, |
|
566 aDwarfManager, |
|
567 iPubtypesSectionName, |
|
568 aDwarfInfoManager, |
|
569 aRomDetails) |
|
570 {} |
|
571 |
|
572 private: |
|
573 static const string iPubtypesSectionName; |
|
574 }; |
|
575 |
|
576 class DwarfArangesManager : public DwarfFragmentedSectionManager { |
|
577 public: |
|
578 DwarfArangesManager(ElfSectionManager & aElfSectionManager, |
|
579 DwarfManager & aDwarfManager, |
|
580 DwarfInfoManager & aDwarfInfoManager, |
|
581 RomDetails * aRomDetails): |
|
582 DwarfFragmentedSectionManager(aElfSectionManager, |
|
583 aDwarfManager, |
|
584 iArangesSectionName, |
|
585 aRomDetails), |
|
586 iDwarfInfoManager(aDwarfInfoManager) |
|
587 {} |
|
588 |
|
589 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end); |
|
590 |
|
591 private: |
|
592 DwarfInfoManager & iDwarfInfoManager; |
|
593 |
|
594 static const string iArangesSectionName; |
|
595 }; |
|
596 |
|
597 |
|
598 class DwarfRangesManager : public DwarfFragmentedSectionManager { |
|
599 public: |
|
600 DwarfRangesManager(ElfSectionManager & aElfSectionManager, |
|
601 DwarfManager & aDwarfManager, |
|
602 DwarfInfoManager & aDwarfInfoManager, |
|
603 RomDetails * aRomDetails): |
|
604 DwarfFragmentedSectionManager(aElfSectionManager, |
|
605 aDwarfManager, |
|
606 iRangesSectionName, |
|
607 aRomDetails), |
|
608 iDwarfInfoManager(aDwarfInfoManager) |
|
609 {} |
|
610 |
|
611 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end); |
|
612 |
|
613 private: |
|
614 DwarfInfoManager & iDwarfInfoManager; |
|
615 |
|
616 static const string iRangesSectionName; |
|
617 }; |
|
618 |
|
619 class DwarfStrManager : public DwarfFragmentedSectionManager { |
|
620 public: |
|
621 DwarfStrManager(ElfSectionManager & aElfSectionManager, |
|
622 DwarfManager & aDwarfManager, |
|
623 RomDetails * aRomDetails): |
|
624 DwarfFragmentedSectionManager(aElfSectionManager, |
|
625 aDwarfManager, |
|
626 iStrSectionName, |
|
627 aRomDetails) |
|
628 {} |
|
629 |
|
630 virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end){}; |
|
631 |
|
632 private: |
|
633 static const string iStrSectionName; |
|
634 }; |
|
635 |
|
636 class DwarfManager { |
|
637 public: |
|
638 DwarfManager(ElfSectionManager & aElfSectionManager, |
|
639 RomDetails * aRomDetails, |
|
640 OutputFile & aOutputFile): |
|
641 iDwarfAbbrevManager(aElfSectionManager, *this, aRomDetails), |
|
642 iDwarfFrameManager(aElfSectionManager, *this, aRomDetails), |
|
643 iDwarfMacinfoManager(aElfSectionManager, *this, aRomDetails), |
|
644 iDwarfInfoManager(aElfSectionManager, *this, iDwarfAbbrevManager, iDwarfMacinfoManager, aRomDetails), |
|
645 iDwarfLineManager(aElfSectionManager, *this, iDwarfInfoManager, aRomDetails), |
|
646 iDwarfLocManager(aElfSectionManager, *this, iDwarfInfoManager, aRomDetails), |
|
647 iDwarfPubnamesManager(aElfSectionManager, *this, iDwarfInfoManager, aRomDetails), |
|
648 iDwarfPubtypesManager(aElfSectionManager, *this, iDwarfInfoManager, aRomDetails), |
|
649 iDwarfArangesManager(aElfSectionManager, *this,iDwarfInfoManager, aRomDetails), |
|
650 iDwarfRangesManager(aElfSectionManager, *this,iDwarfInfoManager, aRomDetails), |
|
651 iDwarfStrManager(aElfSectionManager, *this, aRomDetails), |
|
652 iRomDetails(aRomDetails), |
|
653 iOutputFile(aOutputFile) |
|
654 {} |
|
655 |
|
656 size_t GetLineSectionOffset(PathName & pname){ |
|
657 return iDwarfLineManager.GetSectionOffset(pname); |
|
658 } |
|
659 size_t GetLocListSectionOffset(PathName & pname){ |
|
660 return iDwarfLocManager.GetSectionOffset(pname); |
|
661 } |
|
662 size_t GetMacInfoSectionOffset(PathName & pname){ |
|
663 return iDwarfMacinfoManager.GetSectionOffset(pname); |
|
664 } |
|
665 size_t GetRangesSectionOffset(PathName & pname){ |
|
666 return iDwarfRangesManager.GetSectionOffset(pname); |
|
667 } |
|
668 size_t GetStrSectionOffset(PathName & pname){ |
|
669 return iDwarfStrManager.GetSectionOffset(pname); |
|
670 } |
|
671 |
|
672 OutputFile & GetOutputFile() { return iOutputFile; } |
|
673 |
|
674 void AddSection(XIPFileDetails & aXIPFileDetails, string aSectionName, Elf32_Shdr * aShdr); |
|
675 void SetupSections(); |
|
676 |
|
677 private: |
|
678 // Don't want one of these to be copied |
|
679 DwarfManager(const DwarfManager & aDwarfManager); |
|
680 |
|
681 DwarfManager & operator=(const DwarfManager & aDwarfManager); |
|
682 |
|
683 private: |
|
684 DwarfAbbrevManager iDwarfAbbrevManager; |
|
685 DwarfFrameManager iDwarfFrameManager; |
|
686 DwarfMacinfoManager iDwarfMacinfoManager; |
|
687 DwarfInfoManager iDwarfInfoManager; |
|
688 DwarfLineManager iDwarfLineManager; |
|
689 DwarfLocManager iDwarfLocManager; |
|
690 DwarfPubnamesManager iDwarfPubnamesManager; |
|
691 DwarfPubtypesManager iDwarfPubtypesManager; |
|
692 DwarfArangesManager iDwarfArangesManager; |
|
693 DwarfRangesManager iDwarfRangesManager; |
|
694 DwarfStrManager iDwarfStrManager; |
|
695 RomDetails * iRomDetails; |
|
696 OutputFile & iOutputFile; |
|
697 }; |
|
698 |
|
699 #endif /*DWARFMANAGER_H_*/ |