coff.py

用python编写的能看TI CCS输出的coff格式out文件

# COFF Reader Ver 0.1
# by HYRY Studio, 2007/01/15
# http://hyry.dip.jp/blogt.py?lang=1

import struct
from binascii import hexlify

class Struct:
    def __init__(self, formats, name):
        self.formats = formats
        self.formatstr = self.getFormatStr()
        self.name = name
        
    def getFormatStr(self):
        formatstr = ""
        for format in self.formats:
            formatstr += format[1].split(",")[0]
        return formatstr
        
    def getSize(self):
        return struct.calcsize(self.formatstr)
        
    def feed(self, reader):
        try:
            string = reader.read(self.getSize())
            result = struct.unpack(self.formatstr, string)
        except:
            print self.getSize()
            print self.formatstr
            print len(string)
        for i, x in enumerate(result):
            if len(self.formats[i]) >=3 :
                x = self.formats[i][2](x)
            if self.formats[i][0]!="":
                setattr(self, self.formats[i][0], x)
            
    def __str__(self):
        stringlist = [self.name]
        for format in self.formats:
            name = format[0]
            if name == "": continue
            try:
                strformat = format[1].split(",")[1]
                value = getattr(self, name, None)
            except:
                strformat = "%s"
                value = str(getattr(self, name, None))
            stringlist.append( ("%s = "  + strformat) % (name, value))
        stringlist.append("")
        return "\n".join(stringlist)
        
class CoffFile:
    def __init__(self, filename):
        self.coffFileName = filename
        self.initStructs()
        
    def getStorageClass(self, flag):
        s = { 
            0:"No storage class",
            2:"External symbol",
            3:"Static",
            5:"External definition",
            6:"Label",
            7:"Undefined label",
            14:"Uninitialized static",
            104:"Used only by utility programs"
        }
        return s.get(flag, "Reserved")
        
    def getFileHeaderFlags( self, flag ):
        r = {}
        r["F_RELFLG"] = flag & 0x0001 != 0
        r["F_EXEC"] = flag & 0x0002 != 0
        r["F_LSYMS"] = flag & 0x0008 != 0
        r["F_LITTLE"] = flag & 0x0100 != 0
        r["F_SYMMERGE"] = flag & 0x1000 != 0
        return r
    
    def getSectionHeaderFlags( self, flag ):
        d0 = {
            0x0000:"STYP_REG",
            0x0001:"STYP_DSET",
            0x0002:"STYP_NOLOAD",
            0x0004:"STYP_GROUP",
            0x0008:"STYP_PAD",
        }
        d1 = {
            0x0010:"STYP_COPY",
            0x0020:"STYP_TEXT",
            0x0040:"STYP_DATA",
            0x0080:"STYP_BSS",
        }
        d2 = {
        
        }
        d3 = {
            0x4000:"STYP_CLINK"
        }
        
        return [
                d0.get(flag & 0x000f, hex(flag & 0x000f)), 
                d1.get(flag & 0x00f0, hex(flag & 0x00f0)),
                d2.get(flag & 0x0f00, hex(flag & 0x0f00)),
                d3.get(flag & 0xf000, hex(flag & 0xf000)),
               ]
    
    def getString( self, string ):
        StringTable = self.StringTable
        if string[0] == "\x00":
            start = struct.unpack("l", string[4:])[0]
            end = StringTable.find("\x00", start)
            return StringTable[start:end]
        else:
            return string.rstrip("\x00")
        
    def readFile( self, offset, readsize ):
        tmp = open(self.coffFileName, "rb")
        tmp.seek(offset)
        string = tmp.read(readsize)
        tmp.close()
        return string

    def initStructs(self):
        self.coffFileHeader = [
            ("versionID", "H"),
            ("sectionHeadersNumber", "H"),
            ("timeDateStamp", "l"),
            ("symbolTableStartAddress", "l"),
            ("symbolEntriesNumber", "l"),
            ("optionalHeaderBytes", "H"),
            ("flags", "H", self.getFileHeaderFlags),
            ("TargetID", "H")
        ]

        self.coffOptionalFileHeader = [
            ("magicNumber", "h"),
            ("versionStamp", "h"),
            ("executableCodeBytes", "l"),
            ("initializedSectionsBytes", "l"),
            ("uninitializedSectionsBytes", "l"),
            ("entryPoint", "l,0x%0x"),
            ("executableCodeBeginAddress", "l"),
            ("initializedDataBeginAddress", "l"),
        ]

        self.coffSectionHeader = [
            ("sectionName", "8s", self.getString),
            ("physicalAddress", "L,0x%0x"),
            ("virtualAddress", "L,0x%0x"),
            ("sectionBytes", "l,0x%0x"),
            ("rawDataPointer", "l,0x%0x"),
            ("relocationEntriesPointer", "l"),
            ("", "l"),
            ("relocationEntriesNumber", "L"),
            ("", "L"),
            ("flags", "L", self.getSectionHeaderFlags),
            ("", "h"),
            ("memoryPageNumber", "H")
        ]

        self.coffSymbolTableEntry = [
            ("symbolName", "8s", self.getString),
            ("symbolValue", "L,0x%0x"),
            ("sectionNumber", "h"),
            ("", "H"),
            ("storageClass", "b", self.getStorageClass),
            ("auxiliaryEntriesNumber", "b")
        ]

        self.coffRelocationInformation = [
            ("virtualAddress", "l,0x%0x"),
            ("symbolTableIndex", "L"),
            ("additionalByte", "H"),
            ("reloactionType", "H")
        ]

        self.coffAuxiliaryEntry = [
            ("sectionLength", "l"),
            ("relocationEntriesNumber", "H"),
            ("linenumberEntriesNumber", "H"),
            ("", "10s")
        ]
        
    def read(self):
        f = open(self.coffFileName,"rb")
        FileHeaderStruct = Struct( self.coffFileHeader , "File Header")
        FileHeaderStruct.feed( f )

        # read String Table in
        StringTableOffset = FileHeaderStruct.symbolTableStartAddress + Struct(self.coffSymbolTableEntry, "").getSize() * FileHeaderStruct.symbolEntriesNumber
        StringTable = self.readFile( StringTableOffset, -1)
        self.StringTable = StringTable
        
        # read symbol entries
        tmp = open(self.coffFileName, "rb")
        tmp.seek( FileHeaderStruct.symbolTableStartAddress )
        symbolNum = FileHeaderStruct.symbolEntriesNumber
        Symbols = []
        i = 0
        while i < symbolNum: 
            Symbol = Struct( self.coffSymbolTableEntry, "Symbol %d" % i )
            Symbol.feed( tmp )
            i += 1
            if Symbol.auxiliaryEntriesNumber == 1:
                Auxiliary = Struct( self.coffAuxiliaryEntry, "Auxiliary %d" % i)
                Auxiliary.feed( tmp )
                i += 1