--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/elf4rom/src/dwarfmanager.cpp Fri Jan 15 09:07:44 2010 +0000
@@ -0,0 +1,436 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <iostream>
+#include <iomanip>
+
+#include "dwarfmanager.h"
+#include "inputfile.h"
+#include "outputfile.h"
+#include "filefragment.h"
+
+void DwarfSectionManager::AddSection(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr){
+ if (iRomDetails->iTrace){
+ cout << " " << GetSectionName() << " - DWARF\n";
+ }
+
+ FileShdrPair aFileShdrPair(aXIPFileDetails, aShdr);
+ iFileShdrList.push_back(aFileShdrPair);
+}
+
+void DwarfSectionManager::SetupSection(){
+ if (!iFileShdrList.empty()){
+ ElfSectionElfData * aDwarfSectionData = new ElfSectionElfData(*this);
+ Elf32_Shdr aDwarfShdr;
+ aDwarfShdr.sh_name = 0; // for now.
+ aDwarfShdr.sh_type = SHT_PROGBITS;
+ aDwarfShdr.sh_flags = 0;
+ aDwarfShdr.sh_addr = 0;
+ aDwarfShdr.sh_offset = 0; // for now
+ aDwarfShdr.sh_size = 0; // for now.
+ aDwarfShdr.sh_link = 0;
+ aDwarfShdr.sh_info = 0;
+ aDwarfShdr.sh_addralign = 4;
+ aDwarfShdr.sh_entsize = sizeof(Elf32_Sym);
+
+ ElfSection aDwarfSection(aDwarfSectionData, GetSectionName().c_str(), aDwarfShdr);
+ iElfSectionManager.AddSection(aDwarfSection);
+ }
+}
+
+Dwarf_Unsigned DwarfSectionManager::DecodeUnsignedLeb128(Dwarf_Byte_Ptr leb128, size_t & leb128_length){
+ Dwarf_Ubyte byte;
+ Dwarf_Word word_number;
+ Dwarf_Unsigned number;
+ Dwarf_Sword shift;
+ Dwarf_Sword byte_length;
+
+ /* The following unrolls-the-loop for the first few bytes and
+ unpacks into 32 bits to make this as fast as possible.
+ word_number is assumed big enough that the shift has a defined
+ result. */
+ if ((*leb128 & 0x80) == 0) {
+ leb128_length = 1;
+ return *leb128;
+ } else if ((*(leb128 + 1) & 0x80) == 0) {
+ leb128_length = 2;
+
+ word_number = *leb128 & 0x7f;
+ word_number |= (*(leb128 + 1) & 0x7f) << 7;
+ return word_number;
+ } else if ((*(leb128 + 2) & 0x80) == 0) {
+ leb128_length = 3;
+
+ word_number = *leb128 & 0x7f;
+ word_number |= (*(leb128 + 1) & 0x7f) << 7;
+ word_number |= (*(leb128 + 2) & 0x7f) << 14;
+ return word_number;
+ } else if ((*(leb128 + 3) & 0x80) == 0) {
+ leb128_length = 4;
+
+ word_number = *leb128 & 0x7f;
+ word_number |= (*(leb128 + 1) & 0x7f) << 7;
+ word_number |= (*(leb128 + 2) & 0x7f) << 14;
+ word_number |= (*(leb128 + 3) & 0x7f) << 21;
+ return word_number;
+ }
+
+ /* The rest handles long numbers Because the 'number' may be larger
+ than the default int/unsigned, we must cast the 'byte' before
+ the shift for the shift to have a defined result. */
+ number = 0;
+ shift = 0;
+ byte_length = 1;
+ byte = *(leb128);
+ for (;;) {
+ number |= ((Dwarf_Unsigned) (byte & 0x7f)) << shift;
+
+ if ((byte & 0x80) == 0) {
+ leb128_length = byte_length;
+ return number;
+ }
+ shift += 7;
+
+ byte_length++;
+ ++leb128;
+ byte = *leb128;
+ }
+}
+
+#define BITSINBYTE 8
+Dwarf_Signed DwarfSectionManager::DecodeSignedLeb128(Dwarf_Byte_Ptr leb128, size_t & leb128_length){
+ Dwarf_Signed number = 0;
+ Dwarf_Bool sign = 0;
+ Dwarf_Word shift = 0;
+ Dwarf_Ubyte byte = *leb128;
+ Dwarf_Word byte_length = 1;
+
+ /* byte_length being the number of bytes of data absorbed so far in
+ turning the leb into a Dwarf_Signed. */
+
+ for (;;) {
+ sign = byte & 0x40;
+ number |= ((Dwarf_Signed) ((byte & 0x7f))) << shift;
+ shift += 7;
+
+ if ((byte & 0x80) == 0) {
+ break;
+ }
+ ++leb128;
+ byte = *leb128;
+ byte_length++;
+ }
+
+ if ((shift < sizeof(Dwarf_Signed) * BITSINBYTE) && sign) {
+ number |= -((Dwarf_Signed) 1 << shift);
+ }
+
+ leb128_length = byte_length;
+ return number;
+}
+
+Dwarf_Byte_Ptr DwarfSectionManager::GetSectionData(FileShdrPair & aPair){
+
+ InputFile in(aPair.iXIPFileDetails.iElfFile);
+ in.SetOffset(aPair.iShdr.sh_offset);
+ return (Dwarf_Byte_Ptr)in.GetData(aPair.iShdr.sh_size);
+}
+
+void DwarfConcatenatedSectionManager::GetFileFragmentData(FileFragmentData & aFileFragmentData ){
+ ConcatenateData();
+ if (iRomDetails->iTrace){
+ cout << "\nGenerating DWARF section " << GetSectionName() << " size = "
+ << dec << Size() << " bytes\n";
+ }
+ FileShdrList::iterator e = iFileShdrList.end();
+ for (FileShdrList::iterator i = iFileShdrList.begin(); i < e; i++){
+ if (iRomDetails->iTrace){
+ cout << " " << i->iXIPFileDetails.iElfFile << " " << dec << i->iShdr.sh_size << " bytes\n" << flush;
+ }
+ ProcessSection(*i);
+ }
+ SetFileFragmentData(aFileFragmentData, iSize, reinterpret_cast<char *>(iData));
+}
+
+void DwarfConcatenatedSectionManager::ConcatenateData(){
+ if (iData == NULL) {
+ size_t sectionSize = Size();
+ iData = new Dwarf_Ubyte[sectionSize];
+ Dwarf_Byte_Ptr p = iData;
+ FileShdrList::iterator e = iFileShdrList.end();
+ for (FileShdrList::iterator i = iFileShdrList.begin(); i < e; i++){
+ size_t off = p - iData;
+ size_t soff = GetSectionOffset(i->iXIPFileDetails.iElfFile);
+ if (off >= sectionSize)
+ assert(off < sectionSize);
+ if (off != soff)
+ assert(off == soff);
+ size_t n = i->iShdr.sh_size;
+ Dwarf_Byte_Ptr contrib = GetSectionData(*i);
+ memcpy(p, contrib, n);
+ p += n;
+ delete [] contrib;
+ }
+ }
+}
+
+size_t DwarfConcatenatedSectionManager::Size(){
+ if (iSizeValid)
+ return iSize;
+ //cerr << "Size for " << GetSectionName() << "\n";
+ size_t offset = 0;
+ FileShdrList::iterator e = iFileShdrList.end();
+ for (FileShdrList::iterator i = iFileShdrList.begin(); i != e; i++){
+ //cerr << "offset = 0x" << offset << "\t";
+ SetSectionOffset(i->iXIPFileDetails.iElfFile, offset);
+ size_t size = i->iShdr.sh_size;
+ //cerr << "section size for " << i->iXIPFileDetails.iElfFile << " 0x" << size << "\n";
+ SetSectionSize(i->iXIPFileDetails.iElfFile, size);
+ size_t newOffset = offset + size;
+ if (newOffset < offset){
+ cerr << "Error: The combined section " << GetSectionName()
+ << " requires translation from 32 to 64 bit Dwarf which is not currently supported.\n"
+ << "Exclude the following files (or their equivalent in terms of their contribution to Dwarf):\n";
+ for (; i != e; i++){
+ cerr << i->iXIPFileDetails.iE32File << "\n";
+ }
+ exit(EXIT_FAILURE);
+ }
+ offset = newOffset;
+ }
+ //cerr << "Size = 0x" << offset << "\n";
+ iSizeValid = true;
+ return iSize = offset;
+}
+
+void DwarfConcatenatedSectionManager::ProcessSection(FileShdrPair & aPair){
+ Dwarf_Byte_Ptr start = GetSection(aPair.iXIPFileDetails.iElfFile);
+ Dwarf_Byte_Ptr end = start + aPair.iShdr.sh_size;
+ ProcessSection(aPair, start, end);
+}
+
+void DwarfConcatenatedSectionManager::SetSectionOffset(PathName & aPathName, size_t aOffset) {
+ iPathNameSectionOffsetMap[aPathName] = aOffset;
+}
+
+void DwarfConcatenatedSectionManager::InitOffsetMap(){
+ Size(); // forces the map to be set up if it hasn't been already
+}
+
+size_t DwarfConcatenatedSectionManager::GetSectionOffset(PathName & aPathName){
+ if (!iSizeValid) // if the size is valid then so must be the offsets.
+ InitOffsetMap();
+ return iPathNameSectionOffsetMap[aPathName];
+}
+
+void DwarfConcatenatedSectionManager::SetSectionSize(PathName & aPathName, size_t aSize) {
+ iPathNameSectionSizeMap[aPathName] = aSize;
+}
+
+size_t DwarfConcatenatedSectionManager::GetSectionSize(PathName & aPathName){
+ if (!iSizeValid) // if the size is valid then so must be the offsets.
+ InitOffsetMap();
+ return iPathNameSectionSizeMap[aPathName];
+}
+
+Dwarf_Byte_Ptr DwarfConcatenatedSectionManager::GetSection(PathName & aPathName){
+ ConcatenateData();
+ size_t offset = GetSectionOffset(aPathName);
+ return iData + offset;
+}
+
+class ElfSectionFragmentedDwarfData : public ElfSectionElfData {
+public:
+ ElfSectionFragmentedDwarfData(FileFragmentOwner & aSource) :
+ ElfSectionElfData(aSource)
+ {}
+
+ ElfSectionFragmentedDwarfData(const ElfSectionElfData & aData) :
+ ElfSectionElfData(aData)
+ {}
+
+ // ElfSection protocol
+ virtual ElfSectionFragmentedDwarfData * Clone(){
+ return new ElfSectionFragmentedDwarfData(*this);
+ }
+
+ virtual void AddData(OutputFile & aOutputFile){
+ return;
+ }
+};
+
+class DwarfSectionFragment : public FileFragmentOwner {
+public:
+ DwarfSectionFragment(DwarfFragmentedSectionManager & aSource,
+ FileShdrPair & aPair):
+ iSource(aSource),
+ iPair(aPair),
+ iData(NULL)
+ {}
+
+ // Bitwise copy is OK so don't need to write our own copy ctor etc.
+
+ // The FileFragmentOwner protocol
+ virtual void GetFileFragmentData(FileFragmentData & aFileFragmentData );
+ virtual size_t Size();
+ virtual void DeleteFileFragmentData();
+
+private:
+ DwarfSectionFragment();
+
+private:
+ DwarfFragmentedSectionManager & iSource;
+ FileShdrPair & iPair;
+ Dwarf_Byte_Ptr iData;
+};
+
+void DwarfSectionFragment::GetFileFragmentData(FileFragmentData & aFileFragmentData ){
+ iSource.ProcessSection(iPair, iData);
+ SetFileFragmentData(aFileFragmentData, Size(), reinterpret_cast<char *>(iData));
+}
+
+size_t DwarfSectionFragment::Size(){
+ return iPair.iShdr.sh_size;
+}
+
+void DwarfSectionFragment::DeleteFileFragmentData(){
+ delete [] iData;
+ //
+ delete this;
+}
+
+void DwarfFragmentedSectionManager::SetupSection(){
+ if (!iFileShdrList.empty()){
+ ElfSectionFragmentedDwarfData * aDwarfSectionData = new ElfSectionFragmentedDwarfData(*this);
+ Elf32_Shdr aDwarfShdr;
+ aDwarfShdr.sh_name = 0; // for now.
+ aDwarfShdr.sh_type = SHT_PROGBITS;
+ aDwarfShdr.sh_flags = 0;
+ aDwarfShdr.sh_addr = 0;
+ aDwarfShdr.sh_offset = 0; // for now
+ aDwarfShdr.sh_size = 0; // for now.
+ aDwarfShdr.sh_link = 0;
+ aDwarfShdr.sh_info = 0;
+ aDwarfShdr.sh_addralign = 4;
+ aDwarfShdr.sh_entsize = sizeof(Elf32_Sym);
+
+ // aDwarfSectionData will ask the secton manager (i.e. its source) for the offset of the section.
+ // So we better record it here. We assume that it is the current size of the output file.
+ // As long as we are single threaded and all the fragments get added consecutively as below
+ // this is a safe assumption.
+ SetOffset(iDwarfManager.GetOutputFile().Size());
+
+ ElfSection aDwarfSection(aDwarfSectionData, GetSectionName().c_str(), aDwarfShdr);
+ iElfSectionManager.AddSection(aDwarfSection);
+
+ for (FileShdrList::iterator i = iFileShdrList.begin(); i < iFileShdrList.end(); i++ ){
+ DwarfSectionFragment * aFrag = new DwarfSectionFragment(*this, *i);
+ aFrag->AddData(iDwarfManager.GetOutputFile());
+ }
+ }
+}
+
+// NB the section itself doesn't write any data
+// The FileFragmentOwner protocol
+
+void DwarfFragmentedSectionManager::GetFileFragmentData(FileFragmentData & aFileFragmentData ){
+ SetFileFragmentData(aFileFragmentData, 0, reinterpret_cast<char *>(NULL));
+}
+
+// This should never get called
+void DwarfFragmentedSectionManager::ConcatenateData(){
+ assert(1 == 0);
+ return;
+}
+
+void DwarfFragmentedSectionManager::ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr & aData){
+ if (iInitialTraceMessage & iRomDetails->iTrace){
+ cout << "\nGenerating DWARF section " << GetSectionName() << " size = "
+ << dec << Size() << " bytes\n";
+ iInitialTraceMessage = false;
+ }
+ if (iRomDetails->iTrace){
+ cout << " " << aPair.iXIPFileDetails.iElfFile << " size = "
+ << dec << aPair.iShdr.sh_size << "\n" << flush;
+ }
+ Dwarf_Byte_Ptr start = GetSectionData(aPair);
+ aData = start;
+ Dwarf_Byte_Ptr end = start + aPair.iShdr.sh_size;
+ ProcessSection(aPair, start, end);
+}
+
+#if 0
+// This should never get called
+void DwarfFragmentedSectionManager::ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end){
+ assert(1 == 0);
+ return;
+}
+#endif
+
+const string DwarfMacinfoManager::iMacinfoSectionName(".debug_macinfo");
+const string DwarfStrManager::iStrSectionName(".debug_str");
+
+
+void DwarfManager::AddSection(XIPFileDetails & aXIPFileDetails, string aSectionName, Elf32_Shdr * aShdr){
+ if (iDwarfAbbrevManager.GetSectionName() == aSectionName)
+ iDwarfAbbrevManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfArangesManager.GetSectionName() == aSectionName)
+ iDwarfArangesManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfFrameManager.GetSectionName() == aSectionName)
+ iDwarfFrameManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfInfoManager.GetSectionName() == aSectionName)
+ iDwarfInfoManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfLineManager.GetSectionName() == aSectionName)
+ iDwarfLineManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfLocManager.GetSectionName() == aSectionName)
+ iDwarfLocManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfMacinfoManager.GetSectionName() == aSectionName)
+ iDwarfMacinfoManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfPubnamesManager.GetSectionName() == aSectionName)
+ iDwarfPubnamesManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfPubtypesManager.GetSectionName() == aSectionName)
+ iDwarfPubtypesManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfRangesManager.GetSectionName() == aSectionName)
+ iDwarfRangesManager.AddSection(aXIPFileDetails, aShdr);
+ else if (iDwarfStrManager.GetSectionName() == aSectionName)
+ iDwarfStrManager.AddSection(aXIPFileDetails, aShdr);
+#if 0
+ else
+ cerr << "Warning: unrecognised debug section name " << aSectionName << " ignored\n";
+#endif
+}
+
+void DwarfManager::SetupSections(){
+ // The order here is important for fix up
+ // first the purely concatenated 'leaf' sections
+ // See the diagram on p.182 of the Dwarf 3 spec
+ // to understand the 'dependenices'
+ iDwarfAbbrevManager.SetupSection();
+ iDwarfFrameManager.SetupSection();
+ iDwarfPubnamesManager.SetupSection();
+ iDwarfPubtypesManager.SetupSection();
+ iDwarfArangesManager.SetupSection();
+ iDwarfMacinfoManager.SetupSection();
+
+ iDwarfInfoManager.SetupSection();
+ iDwarfLineManager.SetupSection();
+ iDwarfLocManager.SetupSection();
+
+ iDwarfRangesManager.SetupSection();
+ iDwarfStrManager.SetupSection();
+}