BaseTools: Eot - Remove FvImage file
authorCarsey, Jaben <jaben.carsey@intel.com>
Mon, 16 Apr 2018 17:48:22 +0000 (01:48 +0800)
committerYonghong Zhu <yonghong.zhu@intel.com>
Wed, 18 Apr 2018 14:15:34 +0000 (22:15 +0800)
move the single used class from FvImage to Eot
delete the FvImage file
remove FvImage from makefile

Cc: Liming Gao <liming.gao@intel.com>
Cc: Yonghong Zhu <yonghong.zhu@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Jaben Carsey <jaben.carsey@intel.com>
Reviewed-by: Yonghong Zhu <yonghong.zhu@intel.com>
BaseTools/Source/Python/Eot/Eot.py
BaseTools/Source/Python/Eot/FvImage.py [deleted file]
BaseTools/Source/Python/Makefile

index 96c3396..15de822 100644 (file)
@@ -1,7 +1,7 @@
 ## @file\r
 # This file is used to be the main entrance of EOT tool\r
 #\r
-# Copyright (c) 2008 - 2014, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR>\r
 # This program and the accompanying materials\r
 # are licensed and made available under the terms and conditions of the BSD License\r
 # which accompanies this distribution.  The full text of the license may be found at\r
@@ -24,13 +24,35 @@ from Common.Misc import GuidStructureStringToGuidString
 from InfParserLite import *\r
 import c\r
 import Database\r
-from FvImage import *\r
 from array import array\r
 from Report import Report\r
 from Common.BuildVersion import gBUILD_VERSION\r
 from Parser import ConvertGuid\r
 from Common.LongFilePathSupport import OpenLongFilePath as open\r
 \r
+## MultipleFv() class\r
+#\r
+#  A class for Multiple FV\r
+#\r
+class MultipleFv(FirmwareVolume):\r
+    def __init__(self, FvList):\r
+        FirmwareVolume.__init__(self)\r
+        self.BasicInfo = []\r
+        for FvPath in FvList:\r
+            FvName = os.path.splitext(os.path.split(FvPath)[1])[0]\r
+            Fd = open(FvPath, 'rb')\r
+            Buf = array('B')\r
+            try:\r
+                Buf.fromfile(Fd, os.path.getsize(FvPath))\r
+            except EOFError:\r
+                pass\r
+\r
+            Fv = FirmwareVolume(FvName)\r
+            Fv.frombuffer(Buf, 0, len(Buf))\r
+\r
+            self.BasicInfo.append([Fv.Name, Fv.FileSystemGuid, Fv.Size])\r
+            self.FfsDict.append(Fv.FfsDict)    \r
+\r
 ## Class Eot\r
 #\r
 # This class is used to define Eot main entrance\r
diff --git a/BaseTools/Source/Python/Eot/FvImage.py b/BaseTools/Source/Python/Eot/FvImage.py
deleted file mode 100644 (file)
index 39c31d7..0000000
+++ /dev/null
@@ -1,1434 +0,0 @@
-## @file\r
-# Parse FV image\r
-#\r
-# Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR>\r
-# This program and the accompanying materials\r
-# are licensed and made available under the terms and conditions of the BSD License\r
-# which accompanies this distribution.  The full text of the license may be found at\r
-# http://opensource.org/licenses/bsd-license.php\r
-#\r
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-#\r
-\r
-## Import Modules\r
-#\r
-import Common.LongFilePathOs as os\r
-import re\r
-import sys\r
-import uuid\r
-import struct\r
-import codecs\r
-import copy\r
-\r
-from UserDict import IterableUserDict\r
-from cStringIO import StringIO\r
-from array import array\r
-from Common.LongFilePathSupport import OpenLongFilePath as open\r
-from CommonDataClass import *\r
-from Common.Misc import sdict, GuidStructureStringToGuidString\r
-\r
-import Common.EdkLogger as EdkLogger\r
-\r
-import EotGlobalData\r
-\r
-# Global definiton\r
-gFfsPrintTitle  = "%-36s  %-21s %8s %8s %8s  %-4s %-36s" % ("GUID", "TYPE", "OFFSET", "SIZE", "FREE", "ALIGN", "NAME")\r
-gFfsPrintFormat = "%36s  %-21s %8X %8X %8X  %4s %-36s"\r
-gGuidStringFormat = "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X"\r
-gPeiAprioriFileNameGuid = '1b45cc0a-156a-428a-af62-49864da0e6e6'\r
-gAprioriGuid = 'fc510ee7-ffdc-11d4-bd41-0080c73c8881'\r
-gIndention = -4\r
-\r
-## Image() class\r
-#\r
-#  A class for Image\r
-#\r
-class Image(array):\r
-    _HEADER_ = struct.Struct("")\r
-    _HEADER_SIZE_ = _HEADER_.size\r
-\r
-    def __new__(cls, *args, **kwargs):\r
-        return array.__new__(cls, 'B')\r
-\r
-    def __init__(m, ID=None):\r
-        if ID is None:\r
-            m._ID_ = str(uuid.uuid1()).upper()\r
-        else:\r
-            m._ID_ = ID\r
-        m._BUF_ = None\r
-        m._LEN_ = None\r
-        m._OFF_ = None\r
-\r
-        m._SubImages = sdict() # {offset: Image()}\r
-\r
-        array.__init__(m, 'B')\r
-\r
-    def __repr__(m):\r
-        return m._ID_\r
-\r
-    def __len__(m):\r
-        Len = array.__len__(m)\r
-        for Offset in m._SubImages:\r
-            Len += len(m._SubImages[Offset])\r
-        return Len\r
-\r
-    def _Unpack(m):\r
-        m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_])\r
-        return len(m)\r
-\r
-    def _Pack(m, PadByte=0xFF):\r
-        raise NotImplementedError\r
-\r
-    def frombuffer(m, Buffer, Offset=0, Size=None):\r
-        m._BUF_ = Buffer\r
-        m._OFF_ = Offset\r
-        # we may need the Size information in advance if it's given\r
-        m._LEN_ = Size\r
-        m._LEN_ = m._Unpack()\r
-\r
-    def empty(m):\r
-        del m[0:]\r
-\r
-    def GetField(m, FieldStruct, Offset=0):\r
-        return FieldStruct.unpack_from(m, Offset)\r
-\r
-    def SetField(m, FieldStruct, Offset, *args):\r
-        # check if there's enough space\r
-        Size = FieldStruct.size\r
-        if Size > len(m):\r
-            m.extend([0] * (Size - len(m)))\r
-        FieldStruct.pack_into(m, Offset, *args)\r
-\r
-    def _SetData(m, Data):\r
-        if len(m) < m._HEADER_SIZE_:\r
-            m.extend([0] * (m._HEADER_SIZE_ - len(m)))\r
-        else:\r
-            del m[m._HEADER_SIZE_:]\r
-        m.extend(Data)\r
-\r
-    def _GetData(m):\r
-        if len(m) > m._HEADER_SIZE_:\r
-            return m[m._HEADER_SIZE_:]\r
-        return None\r
-\r
-    Data = property(_GetData, _SetData)\r
-\r
-## FirmwareVolume() class\r
-#\r
-#  A class for Firmware Volume\r
-#\r
-class FirmwareVolume(Image):\r
-    # Read FvLength, Attributes, HeaderLength, Checksum\r
-    _HEADER_ = struct.Struct("16x 1I2H8B 1Q 4x 1I 1H 1H")\r
-    _HEADER_SIZE_ = _HEADER_.size\r
-\r
-    _FfsGuid = "8C8CE578-8A3D-4F1C-9935-896185C32DD3"\r
-\r
-    _GUID_      = struct.Struct("16x 1I2H8B")\r
-    _LENGTH_    = struct.Struct("16x 16x 1Q")\r
-    _SIG_       = struct.Struct("16x 16x 8x 1I")\r
-    _ATTR_      = struct.Struct("16x 16x 8x 4x 1I")\r
-    _HLEN_      = struct.Struct("16x 16x 8x 4x 4x 1H")\r
-    _CHECKSUM_  = struct.Struct("16x 16x 8x 4x 4x 2x 1H")\r
-\r
-    def __init__(self, Name=''):\r
-        Image.__init__(self)\r
-        self.Name = Name\r
-        self.FfsDict = sdict()\r
-        self.OrderedFfsDict = sdict()\r
-        self.UnDispatchedFfsDict = sdict()\r
-        self.ProtocolList = sdict()\r
-\r
-    def CheckArchProtocol(self):\r
-        for Item in EotGlobalData.gArchProtocolGuids:\r
-            if Item.lower() not in EotGlobalData.gProtocolList:\r
-\r
-                return False\r
-\r
-        return True\r
-\r
-    def ParseDepex(self, Depex, Type):\r
-        List = None\r
-        if Type == 'Ppi':\r
-            List = EotGlobalData.gPpiList\r
-        if Type == 'Protocol':\r
-            List = EotGlobalData.gProtocolList\r
-        DepexStack = []\r
-        DepexList = []\r
-        DepexString = ''\r
-        FileDepex = None\r
-        CouldBeLoaded = True\r
-        for Index in range(0, len(Depex.Expression)):\r
-            Item = Depex.Expression[Index]\r
-            if Item == 0x00:\r
-                Index = Index + 1\r
-                Guid = gGuidStringFormat % Depex.Expression[Index]\r
-                if Guid in self.OrderedFfsDict and Depex.Expression[Index + 1] == 0x08:\r
-                    return (True, 'BEFORE %s' % Guid, [Guid, 'BEFORE'])\r
-            elif Item == 0x01:\r
-                Index = Index + 1\r
-                Guid = gGuidStringFormat % Depex.Expression[Index]\r
-                if Guid in self.OrderedFfsDict and Depex.Expression[Index + 1] == 0x08:\r
-                    return (True, 'AFTER %s' % Guid, [Guid, 'AFTER'])\r
-            elif Item == 0x02:\r
-                Index = Index + 1\r
-                Guid = gGuidStringFormat % Depex.Expression[Index]\r
-                if Guid.lower() in List:\r
-                    DepexStack.append(True)\r
-                    DepexList.append(Guid)\r
-                else:\r
-                    DepexStack.append(False)\r
-                    DepexList.append(Guid)\r
-                continue\r
-            elif Item == 0x03 or Item == 0x04:\r
-                DepexStack.append(eval(str(DepexStack.pop()) + ' ' + Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexStack.pop())))\r
-                DepexList.append(str(DepexList.pop()) + ' ' + Depex._OPCODE_STRING_[Item].upper() + ' ' + str(DepexList.pop()))\r
-            elif Item == 0x05:\r
-                DepexStack.append(eval(Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexStack.pop())))\r
-                DepexList.append(Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexList.pop()))\r
-            elif Item == 0x06:\r
-                DepexStack.append(True)\r
-                DepexList.append('TRUE')\r
-                DepexString = DepexString + 'TRUE' + ' '\r
-            elif Item == 0x07:\r
-                DepexStack.append(False)\r
-                DepexList.append('False')\r
-                DepexString = DepexString + 'FALSE' + ' '\r
-            elif Item == 0x08:\r
-                if Index != len(Depex.Expression) - 1:\r
-                    CouldBeLoaded = False\r
-                else:\r
-                    CouldBeLoaded = DepexStack.pop()\r
-            else:\r
-                CouldBeLoaded = False\r
-        if DepexList != []:\r
-            DepexString = DepexList[0].strip()\r
-        return (CouldBeLoaded, DepexString, FileDepex)\r
-\r
-    def Dispatch(self, Db = None):\r
-        if Db is None:\r
-            return False\r
-        self.UnDispatchedFfsDict = copy.copy(self.FfsDict)\r
-        # Find PeiCore, DexCore, PeiPriori, DxePriori first\r
-        FfsSecCoreGuid = None\r
-        FfsPeiCoreGuid = None\r
-        FfsDxeCoreGuid = None\r
-        FfsPeiPrioriGuid = None\r
-        FfsDxePrioriGuid = None\r
-        for FfsID in self.UnDispatchedFfsDict:\r
-            Ffs = self.UnDispatchedFfsDict[FfsID]\r
-            if Ffs.Type == 0x03:\r
-                FfsSecCoreGuid = FfsID\r
-                continue\r
-            if Ffs.Type == 0x04:\r
-                FfsPeiCoreGuid = FfsID\r
-                continue\r
-            if Ffs.Type == 0x05:\r
-                FfsDxeCoreGuid = FfsID\r
-                continue\r
-            if Ffs.Guid.lower() == gPeiAprioriFileNameGuid:\r
-                FfsPeiPrioriGuid = FfsID\r
-                continue\r
-            if Ffs.Guid.lower() == gAprioriGuid:\r
-                FfsDxePrioriGuid = FfsID\r
-                continue\r
-\r
-        # Parse SEC_CORE first\r
-        if FfsSecCoreGuid is not None:\r
-            self.OrderedFfsDict[FfsSecCoreGuid] = self.UnDispatchedFfsDict.pop(FfsSecCoreGuid)\r
-            self.LoadPpi(Db, FfsSecCoreGuid)\r
-\r
-        # Parse PEI first\r
-        if FfsPeiCoreGuid is not None:\r
-            self.OrderedFfsDict[FfsPeiCoreGuid] = self.UnDispatchedFfsDict.pop(FfsPeiCoreGuid)\r
-            self.LoadPpi(Db, FfsPeiCoreGuid)\r
-            if FfsPeiPrioriGuid is not None:\r
-                # Load PEIM described in priori file\r
-                FfsPeiPriori = self.UnDispatchedFfsDict.pop(FfsPeiPrioriGuid)\r
-                if len(FfsPeiPriori.Sections) == 1:\r
-                    Section = FfsPeiPriori.Sections.popitem()[1]\r
-                    if Section.Type == 0x19:\r
-                        GuidStruct = struct.Struct('1I2H8B')\r
-                        Start = 4\r
-                        while len(Section) > Start:\r
-                            Guid = GuidStruct.unpack_from(Section[Start : Start + 16])\r
-                            GuidString = gGuidStringFormat % Guid\r
-                            Start = Start + 16\r
-                            if GuidString in self.UnDispatchedFfsDict:\r
-                                self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString)\r
-                                self.LoadPpi(Db, GuidString)\r
-\r
-        self.DisPatchPei(Db)\r
-\r
-        # Parse DXE then\r
-        if FfsDxeCoreGuid is not None:\r
-            self.OrderedFfsDict[FfsDxeCoreGuid] = self.UnDispatchedFfsDict.pop(FfsDxeCoreGuid)\r
-            self.LoadProtocol(Db, FfsDxeCoreGuid)\r
-            if FfsDxePrioriGuid is not None:\r
-                # Load PEIM described in priori file\r
-                FfsDxePriori = self.UnDispatchedFfsDict.pop(FfsDxePrioriGuid)\r
-                if len(FfsDxePriori.Sections) == 1:\r
-                    Section = FfsDxePriori.Sections.popitem()[1]\r
-                    if Section.Type == 0x19:\r
-                        GuidStruct = struct.Struct('1I2H8B')\r
-                        Start = 4\r
-                        while len(Section) > Start:\r
-                            Guid = GuidStruct.unpack_from(Section[Start : Start + 16])\r
-                            GuidString = gGuidStringFormat % Guid\r
-                            Start = Start + 16\r
-                            if GuidString in self.UnDispatchedFfsDict:\r
-                                self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString)\r
-                                self.LoadProtocol(Db, GuidString)\r
-\r
-        self.DisPatchDxe(Db)\r
-\r
-    def LoadProtocol(self, Db, ModuleGuid):\r
-        SqlCommand = """select GuidValue from Report\r
-                        where SourceFileFullPath in\r
-                        (select Value1 from Inf where BelongsToFile =\r
-                        (select BelongsToFile from Inf\r
-                        where Value1 = 'FILE_GUID' and Value2 like '%s' and Model = %s)\r
-                        and Model = %s)\r
-                        and ItemType = 'Protocol' and ItemMode = 'Produced'""" \\r
-                        % (ModuleGuid, 5001, 3007)\r
-        RecordSet = Db.TblReport.Exec(SqlCommand)\r
-        for Record in RecordSet:\r
-            SqlCommand = """select Value2 from Inf where BelongsToFile =\r
-                            (select DISTINCT BelongsToFile from Inf\r
-                            where Value1 =\r
-                            (select SourceFileFullPath from Report\r
-                            where GuidValue like '%s' and ItemMode = 'Callback'))\r
-                            and Value1 = 'FILE_GUID'""" % Record[0]\r
-            CallBackSet = Db.TblReport.Exec(SqlCommand)\r
-            if CallBackSet != []:\r
-                EotGlobalData.gProtocolList[Record[0].lower()] = ModuleGuid\r
-            else:\r
-                EotGlobalData.gProtocolList[Record[0].lower()] = ModuleGuid\r
-\r
-    def LoadPpi(self, Db, ModuleGuid):\r
-        SqlCommand = """select GuidValue from Report\r
-                        where SourceFileFullPath in\r
-                        (select Value1 from Inf where BelongsToFile =\r
-                        (select BelongsToFile from Inf\r
-                        where Value1 = 'FILE_GUID' and Value2 like '%s' and Model = %s)\r
-                        and Model = %s)\r
-                        and ItemType = 'Ppi' and ItemMode = 'Produced'""" \\r
-                        % (ModuleGuid, 5001, 3007)\r
-        RecordSet = Db.TblReport.Exec(SqlCommand)\r
-        for Record in RecordSet:\r
-            EotGlobalData.gPpiList[Record[0].lower()] = ModuleGuid\r
-\r
-    def DisPatchDxe(self, Db):\r
-        IsInstalled = False\r
-        ScheduleList = sdict()\r
-        for FfsID in self.UnDispatchedFfsDict:\r
-            CouldBeLoaded = False\r
-            DepexString = ''\r
-            FileDepex = None\r
-            Ffs = self.UnDispatchedFfsDict[FfsID]\r
-            if Ffs.Type == 0x07:\r
-                # Get Depex\r
-                IsFoundDepex = False\r
-                for Section in Ffs.Sections.values():\r
-                    # Find Depex\r
-                    if Section.Type == 0x13:\r
-                        IsFoundDepex = True\r
-                        CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(Section._SubImages[4], 'Protocol')\r
-                        break\r
-                    if Section.Type == 0x01:\r
-                        CompressSections = Section._SubImages[4]\r
-                        for CompressSection in CompressSections.Sections:\r
-                            if CompressSection.Type == 0x13:\r
-                                IsFoundDepex = True\r
-                                CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(CompressSection._SubImages[4], 'Protocol')\r
-                                break\r
-                            if CompressSection.Type == 0x02:\r
-                                NewSections = CompressSection._SubImages[4]\r
-                                for NewSection in NewSections.Sections:\r
-                                    if NewSection.Type == 0x13:\r
-                                        IsFoundDepex = True\r
-                                        CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(NewSection._SubImages[4], 'Protocol')\r
-                                        break\r
-\r
-                # Not find Depex\r
-                if not IsFoundDepex:\r
-                    CouldBeLoaded = self.CheckArchProtocol()\r
-                    DepexString = ''\r
-                    FileDepex = None\r
-\r
-                # Append New Ffs\r
-                if CouldBeLoaded:\r
-                    IsInstalled = True\r
-                    NewFfs = self.UnDispatchedFfsDict.pop(FfsID)\r
-                    NewFfs.Depex = DepexString\r
-                    if FileDepex is not None:\r
-                        ScheduleList.insert(FileDepex[1], FfsID, NewFfs, FileDepex[0])\r
-                    else:\r
-                        ScheduleList[FfsID] = NewFfs\r
-                else:\r
-                    self.UnDispatchedFfsDict[FfsID].Depex = DepexString\r
-\r
-        for FfsID in ScheduleList:\r
-            NewFfs = ScheduleList.pop(FfsID)\r
-            FfsName = 'UnKnown'\r
-            self.OrderedFfsDict[FfsID] = NewFfs\r
-            self.LoadProtocol(Db, FfsID)\r
-\r
-            SqlCommand = """select Value2 from Inf\r
-                            where BelongsToFile = (select BelongsToFile from Inf where Value1 = 'FILE_GUID' and lower(Value2) = lower('%s') and Model = %s)\r
-                            and Model = %s and Value1='BASE_NAME'""" % (FfsID, 5001, 5001)\r
-            RecordSet = Db.TblReport.Exec(SqlCommand)\r
-            if RecordSet != []:\r
-                FfsName = RecordSet[0][0]\r
-\r
-        if IsInstalled:\r
-            self.DisPatchDxe(Db)\r
-\r
-    def DisPatchPei(self, Db):\r
-        IsInstalled = False\r
-        for FfsID in self.UnDispatchedFfsDict:\r
-            CouldBeLoaded = True\r
-            DepexString = ''\r
-            FileDepex = None\r
-            Ffs = self.UnDispatchedFfsDict[FfsID]\r
-            if Ffs.Type == 0x06 or Ffs.Type == 0x08:\r
-                # Get Depex\r
-                for Section in Ffs.Sections.values():\r
-                    if Section.Type == 0x1B:\r
-                        CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(Section._SubImages[4], 'Ppi')\r
-                        break\r
-\r
-                    if Section.Type == 0x01:\r
-                        CompressSections = Section._SubImages[4]\r
-                        for CompressSection in CompressSections.Sections:\r
-                            if CompressSection.Type == 0x1B:\r
-                                CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(CompressSection._SubImages[4], 'Ppi')\r
-                                break\r
-                            if CompressSection.Type == 0x02:\r
-                                NewSections = CompressSection._SubImages[4]\r
-                                for NewSection in NewSections.Sections:\r
-                                    if NewSection.Type == 0x1B:\r
-                                        CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(NewSection._SubImages[4], 'Ppi')\r
-                                        break\r
-\r
-                # Append New Ffs\r
-                if CouldBeLoaded:\r
-                    IsInstalled = True\r
-                    NewFfs = self.UnDispatchedFfsDict.pop(FfsID)\r
-                    NewFfs.Depex = DepexString\r
-                    self.OrderedFfsDict[FfsID] = NewFfs\r
-                    self.LoadPpi(Db, FfsID)\r
-                else:\r
-                    self.UnDispatchedFfsDict[FfsID].Depex = DepexString\r
-\r
-        if IsInstalled:\r
-            self.DisPatchPei(Db)\r
-\r
-\r
-    def __str__(self):\r
-        global gIndention\r
-        gIndention += 4\r
-        FvInfo = '\n' + ' ' * gIndention\r
-        FvInfo +=  "[FV:%s] file_system=%s size=%x checksum=%s\n" % (self.Name, self.FileSystemGuid, self.Size, self.Checksum)\r
-        FfsInfo = "\n".join([str(self.FfsDict[FfsId]) for FfsId in self.FfsDict])\r
-        gIndention -= 4\r
-        return FvInfo + FfsInfo\r
-\r
-    def _Unpack(self):\r
-        Size = self._LENGTH_.unpack_from(self._BUF_, self._OFF_)[0]\r
-        self.empty()\r
-        self.extend(self._BUF_[self._OFF_:self._OFF_+Size])\r
-\r
-        # traverse the FFS\r
-        EndOfFv = Size\r
-        FfsStartAddress = self.HeaderSize\r
-        LastFfsObj = None\r
-        while FfsStartAddress < EndOfFv:\r
-            FfsObj = Ffs()\r
-            FfsObj.frombuffer(self, FfsStartAddress)\r
-            FfsId = repr(FfsObj)\r
-            if ((self.Attributes & 0x00000800) != 0 and len(FfsObj) == 0xFFFFFF) \\r
-                or ((self.Attributes & 0x00000800) == 0 and len(FfsObj) == 0):\r
-                if LastFfsObj is not None:\r
-                    LastFfsObj.FreeSpace = EndOfFv - LastFfsObj._OFF_ - len(LastFfsObj)\r
-            else:\r
-                if FfsId in self.FfsDict:\r
-                    EdkLogger.error("FV", 0, "Duplicate GUID in FFS",\r
-                                    ExtraData="\t%s @ %s\n\t%s @ %s" \\r
-                                    % (FfsObj.Guid, FfsObj.Offset,\r
-                                       self.FfsDict[FfsId].Guid, self.FfsDict[FfsId].Offset))\r
-                self.FfsDict[FfsId] = FfsObj\r
-                if LastFfsObj is not None:\r
-                    LastFfsObj.FreeSpace = FfsStartAddress - LastFfsObj._OFF_ - len(LastFfsObj)\r
-\r
-            FfsStartAddress += len(FfsObj)\r
-            #\r
-            # align to next 8-byte aligned address: A = (A + 8 - 1) & (~(8 - 1))\r
-            # The next FFS must be at the latest next 8-byte aligned address\r
-            #\r
-            FfsStartAddress = (FfsStartAddress + 7) & (~7)\r
-            LastFfsObj = FfsObj\r
-\r
-    def _GetAttributes(self):\r
-        return self.GetField(self._ATTR_, 0)[0]\r
-\r
-    def _GetSize(self):\r
-        return self.GetField(self._LENGTH_, 0)[0]\r
-\r
-    def _GetChecksum(self):\r
-        return self.GetField(self._CHECKSUM_, 0)[0]\r
-\r
-    def _GetHeaderLength(self):\r
-        return self.GetField(self._HLEN_, 0)[0]\r
-\r
-    def _GetFileSystemGuid(self):\r
-        return gGuidStringFormat % self.GetField(self._GUID_, 0)\r
-\r
-    Attributes = property(_GetAttributes)\r
-    Size = property(_GetSize)\r
-    Checksum = property(_GetChecksum)\r
-    HeaderSize = property(_GetHeaderLength)\r
-    FileSystemGuid = property(_GetFileSystemGuid)\r
-\r
-## CompressedImage() class\r
-#\r
-#  A class for Compressed Image\r
-#\r
-class CompressedImage(Image):\r
-    # UncompressedLength = 4-byte\r
-    # CompressionType = 1-byte\r
-    _HEADER_ = struct.Struct("1I 1B")\r
-    _HEADER_SIZE_ = _HEADER_.size\r
-\r
-    _ORIG_SIZE_     = struct.Struct("1I")\r
-    _CMPRS_TYPE_    = struct.Struct("4x 1B")\r
-\r
-    def __init__(m, CompressedData=None, CompressionType=None, UncompressedLength=None):\r
-        Image.__init__(m)\r
-        if UncompressedLength is not None:\r
-            m.UncompressedLength = UncompressedLength\r
-        if CompressionType is not None:\r
-            m.CompressionType = CompressionType\r
-        if CompressedData is not None:\r
-            m.Data = CompressedData\r
-\r
-    def __str__(m):\r
-        global gIndention\r
-        S = "algorithm=%s uncompressed=%x" % (m.CompressionType, m.UncompressedLength)\r
-        for Sec in m.Sections:\r
-            S += '\n' + str(Sec)\r
-\r
-        return S\r
-\r
-    def _SetOriginalSize(m, Size):\r
-        m.SetField(m._ORIG_SIZE_, 0, Size)\r
-\r
-    def _GetOriginalSize(m):\r
-        return m.GetField(m._ORIG_SIZE_)[0]\r
-\r
-    def _SetCompressionType(m, Type):\r
-        m.SetField(m._CMPRS_TYPE_, 0, Type)\r
-\r
-    def _GetCompressionType(m):\r
-        return m.GetField(m._CMPRS_TYPE_)[0]\r
-\r
-    def _GetSections(m):\r
-        try:\r
-            import EfiCompressor\r
-            TmpData = EfiCompressor.FrameworkDecompress(\r
-                                        m[m._HEADER_SIZE_:],\r
-                                        len(m) - m._HEADER_SIZE_\r
-                                        )\r
-            DecData = array('B')\r
-            DecData.fromstring(TmpData)\r
-        except:\r
-            import EfiCompressor\r
-            TmpData = EfiCompressor.UefiDecompress(\r
-                                        m[m._HEADER_SIZE_:],\r
-                                        len(m) - m._HEADER_SIZE_\r
-                                        )\r
-            DecData = array('B')\r
-            DecData.fromstring(TmpData)\r
-\r
-        SectionList = []\r
-        Offset = 0\r
-        while Offset < len(DecData):\r
-            Sec = Section()\r
-            try:\r
-                Sec.frombuffer(DecData, Offset)\r
-                Offset += Sec.Size\r
-                # the section is aligned to 4-byte boundary\r
-            except:\r
-                break\r
-            SectionList.append(Sec)\r
-        return SectionList\r
-\r
-    UncompressedLength = property(_GetOriginalSize, _SetOriginalSize)\r
-    CompressionType = property(_GetCompressionType, _SetCompressionType)\r
-    Sections = property(_GetSections)\r
-\r
-## GuidDefinedImage() class\r
-#\r
-#  A class for GUID Defined Image\r
-#\r
-class GuidDefinedImage(Image):\r
-    _HEADER_ = struct.Struct("1I2H8B 1H 1H")\r
-    _HEADER_SIZE_ = _HEADER_.size\r
-\r
-    _GUID_          = struct.Struct("1I2H8B")\r
-    _DATA_OFFSET_   = struct.Struct("16x 1H")\r
-    _ATTR_          = struct.Struct("18x 1H")\r
-\r
-    CRC32_GUID          = "FC1BCDB0-7D31-49AA-936A-A4600D9DD083"\r
-    TIANO_COMPRESS_GUID = 'A31280AD-481E-41B6-95E8-127F4C984779'\r
-    LZMA_COMPRESS_GUID  = 'EE4E5898-3914-4259-9D6E-DC7BD79403CF'\r
-\r
-    def __init__(m, SectionDefinitionGuid=None, DataOffset=None, Attributes=None, Data=None):\r
-        Image.__init__(m)\r
-        if SectionDefinitionGuid is not None:\r
-            m.SectionDefinitionGuid = SectionDefinitionGuid\r
-        if DataOffset is not None:\r
-            m.DataOffset = DataOffset\r
-        if Attributes is not None:\r
-            m.Attributes = Attributes\r
-        if Data is not None:\r
-            m.Data = Data\r
-\r
-    def __str__(m):\r
-        S = "guid=%s" % (gGuidStringFormat % m.SectionDefinitionGuid)\r
-        for Sec in m.Sections:\r
-            S += "\n" + str(Sec)\r
-        return S\r
-\r
-    def _Unpack(m):\r
-        # keep header in this Image object\r
-        m.empty()\r
-        m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_])\r
-        return len(m)\r
-\r
-    def _SetAttribute(m, Attribute):\r
-        m.SetField(m._ATTR_, 0, Attribute)\r
-\r
-    def _GetAttribute(m):\r
-        return m.GetField(m._ATTR_)[0]\r
-\r
-    def _SetGuid(m, Guid):\r
-        m.SetField(m._GUID_, 0, Guid)\r
-\r
-    def _GetGuid(m):\r
-        return m.GetField(m._GUID_)\r
-\r
-    def _SetDataOffset(m, Offset):\r
-        m.SetField(m._DATA_OFFSET_, 0, Offset)\r
-\r
-    def _GetDataOffset(m):\r
-        return m.GetField(m._DATA_OFFSET_)[0]\r
-\r
-    def _GetSections(m):\r
-        SectionList = []\r
-        Guid = gGuidStringFormat % m.SectionDefinitionGuid\r
-        if Guid == m.CRC32_GUID:\r
-            # skip the CRC32 value, we don't do CRC32 verification here\r
-            Offset = m.DataOffset - 4\r
-            while Offset < len(m):\r
-                Sec = Section()\r
-                try:\r
-                    Sec.frombuffer(m, Offset)\r
-                    Offset += Sec.Size\r
-                    # the section is aligned to 4-byte boundary\r
-                    Offset = (Offset + 3) & (~3)\r
-                except:\r
-                    break\r
-                SectionList.append(Sec)\r
-        elif Guid == m.TIANO_COMPRESS_GUID:\r
-            try:\r
-                import EfiCompressor\r
-                # skip the header\r
-                Offset = m.DataOffset - 4\r
-                TmpData = EfiCompressor.FrameworkDecompress(m[Offset:], len(m)-Offset)\r
-                DecData = array('B')\r
-                DecData.fromstring(TmpData)\r
-                Offset = 0\r
-                while Offset < len(DecData):\r
-                    Sec = Section()\r
-                    try:\r
-                        Sec.frombuffer(DecData, Offset)\r
-                        Offset += Sec.Size\r
-                        # the section is aligned to 4-byte boundary\r
-                        Offset = (Offset + 3) & (~3)\r
-                    except:\r
-                        break\r
-                    SectionList.append(Sec)\r
-            except:\r
-                pass\r
-        elif Guid == m.LZMA_COMPRESS_GUID:\r
-            try:\r
-                import LzmaCompressor\r
-                # skip the header\r
-                Offset = m.DataOffset - 4\r
-                TmpData = LzmaCompressor.LzmaDecompress(m[Offset:], len(m)-Offset)\r
-                DecData = array('B')\r
-                DecData.fromstring(TmpData)\r
-                Offset = 0\r
-                while Offset < len(DecData):\r
-                    Sec = Section()\r
-                    try:\r
-                        Sec.frombuffer(DecData, Offset)\r
-                        Offset += Sec.Size\r
-                        # the section is aligned to 4-byte boundary\r
-                        Offset = (Offset + 3) & (~3)\r
-                    except:\r
-                        break\r
-                    SectionList.append(Sec)\r
-            except:\r
-                pass\r
-\r
-        return SectionList\r
-\r
-    Attributes = property(_GetAttribute, _SetAttribute)\r
-    SectionDefinitionGuid = property(_GetGuid, _SetGuid)\r
-    DataOffset = property(_GetDataOffset, _SetDataOffset)\r
-    Sections = property(_GetSections)\r
-\r
-## Depex() class\r
-#\r
-#  A class for Depex\r
-#\r
-class Depex(Image):\r
-    _HEADER_ = struct.Struct("")\r
-    _HEADER_SIZE_ = 0\r
-\r
-    _GUID_          = struct.Struct("1I2H8B")\r
-    _OPCODE_        = struct.Struct("1B")\r
-\r
-    _OPCODE_STRING_ = {\r
-        0x00    :   "BEFORE",\r
-        0x01    :   "AFTER",\r
-        0x02    :   "PUSH",\r
-        0x03    :   "AND",\r
-        0x04    :   "OR",\r
-        0x05    :   "NOT",\r
-        0x06    :   "TRUE",\r
-        0x07    :   "FALSE",\r
-        0x08    :   "END",\r
-        0x09    :   "SOR"\r
-    }\r
-\r
-    _NEXT_ = {\r
-        -1      :   _OPCODE_,   # first one in depex must be an opcdoe\r
-        0x00    :   _GUID_,     #"BEFORE",\r
-        0x01    :   _GUID_,     #"AFTER",\r
-        0x02    :   _GUID_,     #"PUSH",\r
-        0x03    :   _OPCODE_,   #"AND",\r
-        0x04    :   _OPCODE_,   #"OR",\r
-        0x05    :   _OPCODE_,   #"NOT",\r
-        0x06    :   _OPCODE_,   #"TRUE",\r
-        0x07    :   _OPCODE_,   #"FALSE",\r
-        0x08    :   None,       #"END",\r
-        0x09    :   _OPCODE_,   #"SOR"\r
-    }\r
-\r
-    def __init__(m):\r
-        Image.__init__(m)\r
-        m._ExprList = []\r
-\r
-    def __str__(m):\r
-        global gIndention\r
-        gIndention += 4\r
-        Indention = ' ' * gIndention\r
-        S = '\n'\r
-        for T in m.Expression:\r
-            if T in m._OPCODE_STRING_:\r
-                S += Indention + m._OPCODE_STRING_[T]\r
-                if T not in [0x00, 0x01, 0x02]:\r
-                    S += '\n'\r
-            else:\r
-                S += ' ' + gGuidStringFormat % T + '\n'\r
-        gIndention -= 4\r
-        return S\r
-\r
-    def _Unpack(m):\r
-        # keep header in this Image object\r
-        m.empty()\r
-        m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_])\r
-        return len(m)\r
-\r
-    def _GetExpression(m):\r
-        if m._ExprList == []:\r
-            Offset = 0\r
-            CurrentData = m._OPCODE_\r
-            while Offset < len(m):\r
-                Token = CurrentData.unpack_from(m, Offset)\r
-                Offset += CurrentData.size\r
-                if len(Token) == 1:\r
-                    Token = Token[0]\r
-                    if Token in m._NEXT_:\r
-                        CurrentData = m._NEXT_[Token]\r
-                    else:\r
-                        CurrentData = m._GUID_\r
-                else:\r
-                    CurrentData = m._OPCODE_\r
-                m._ExprList.append(Token)\r
-                if CurrentData is None:\r
-                    break\r
-        return m._ExprList\r
-\r
-    Expression = property(_GetExpression)\r
-\r
-## Ui() class\r
-#\r
-#  A class for Ui\r
-#\r
-class Ui(Image):\r
-    _HEADER_ = struct.Struct("")\r
-    _HEADER_SIZE_ = 0\r
-\r
-    def __init__(m):\r
-        Image.__init__(m)\r
-\r
-    def __str__(m):\r
-        return m.String\r
-\r
-    def _Unpack(m):\r
-        # keep header in this Image object\r
-        m.empty()\r
-        m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_])\r
-        return len(m)\r
-\r
-    def _GetUiString(m):\r
-        return codecs.utf_16_decode(m[0:-2].tostring())[0]\r
-\r
-    String = property(_GetUiString)\r
-\r
-## Section() class\r
-#\r
-#  A class for Section\r
-#\r
-class Section(Image):\r
-    _TypeName = {\r
-        0x00    :   "<unknown>",\r
-        0x01    :   "COMPRESSION",\r
-        0x02    :   "GUID_DEFINED",\r
-        0x10    :   "PE32",\r
-        0x11    :   "PIC",\r
-        0x12    :   "TE",\r
-        0x13    :   "DXE_DEPEX",\r
-        0x14    :   "VERSION",\r
-        0x15    :   "USER_INTERFACE",\r
-        0x16    :   "COMPATIBILITY16",\r
-        0x17    :   "FIRMWARE_VOLUME_IMAGE",\r
-        0x18    :   "FREEFORM_SUBTYPE_GUID",\r
-        0x19    :   "RAW",\r
-        0x1B    :   "PEI_DEPEX"\r
-    }\r
-\r
-    _SectionSubImages = {\r
-        0x01    :   CompressedImage,\r
-        0x02    :   GuidDefinedImage,\r
-        0x17    :   FirmwareVolume,\r
-        0x13    :   Depex,\r
-        0x1B    :   Depex,\r
-        0x15    :   Ui\r
-    }\r
-\r
-    # Size = 3-byte\r
-    # Type = 1-byte\r
-    _HEADER_ = struct.Struct("3B 1B")\r
-    _HEADER_SIZE_ = _HEADER_.size\r
-\r
-    # SubTypeGuid\r
-    # _FREE_FORM_SUBTYPE_GUID_HEADER_ = struct.Struct("1I2H8B")\r
-\r
-    _SIZE_          = struct.Struct("3B")\r
-    _TYPE_          = struct.Struct("3x 1B")\r
-\r
-    def __init__(m, Type=None, Size=None):\r
-        Image.__init__(m)\r
-        m._Alignment = 1\r
-        if Type is not None:\r
-            m.Type = Type\r
-        if Size is not None:\r
-            m.Size = Size\r
-\r
-    def __str__(m):\r
-        global gIndention\r
-        gIndention += 4\r
-        SectionInfo = ' ' * gIndention\r
-        if m.Type in m._TypeName:\r
-            SectionInfo += "[SECTION:%s] offset=%x size=%x" % (m._TypeName[m.Type], m._OFF_, m.Size)\r
-        else:\r
-            SectionInfo += "[SECTION:%x<unknown>] offset=%x size=%x " % (m.Type, m._OFF_, m.Size)\r
-        for Offset in m._SubImages:\r
-            SectionInfo += ", " + str(m._SubImages[Offset])\r
-        gIndention -= 4\r
-        return SectionInfo\r
-\r
-    def _Unpack(m):\r
-        m.empty()\r
-        Type, = m._TYPE_.unpack_from(m._BUF_, m._OFF_)\r
-        Size1, Size2, Size3 = m._SIZE_.unpack_from(m._BUF_, m._OFF_)\r
-        Size = Size1 + (Size2 << 8) + (Size3 << 16)\r
-\r
-        if Type not in m._SectionSubImages:\r
-            # no need to extract sub-image, keep all in this Image object\r
-            m.extend(m._BUF_[m._OFF_ : m._OFF_ + Size])\r
-        else:\r
-            # keep header in this Image object\r
-            m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._HEADER_SIZE_])\r
-            #\r
-            # use new Image object to represent payload, which may be another kind\r
-            # of image such as PE32\r
-            #\r
-            PayloadOffset = m._HEADER_SIZE_\r
-            PayloadLen = m.Size - m._HEADER_SIZE_\r
-            Payload = m._SectionSubImages[m.Type]()\r
-            Payload.frombuffer(m._BUF_, m._OFF_ + m._HEADER_SIZE_, PayloadLen)\r
-            m._SubImages[PayloadOffset] = Payload\r
-\r
-        return Size\r
-\r
-    def _SetSize(m, Size):\r
-        Size1 = Size & 0xFF\r
-        Size2 = (Size & 0xFF00) >> 8\r
-        Size3 = (Size & 0xFF0000) >> 16\r
-        m.SetField(m._SIZE_, 0, Size1, Size2, Size3)\r
-\r
-    def _GetSize(m):\r
-        Size1, Size2, Size3 = m.GetField(m._SIZE_)\r
-        return Size1 + (Size2 << 8) + (Size3 << 16)\r
-\r
-    def _SetType(m, Type):\r
-        m.SetField(m._TYPE_, 0, Type)\r
-\r
-    def _GetType(m):\r
-        return m.GetField(m._TYPE_)[0]\r
-\r
-    def _GetAlignment(m):\r
-        return m._Alignment\r
-\r
-    def _SetAlignment(m, Alignment):\r
-        m._Alignment = Alignment\r
-        AlignmentMask = Alignment - 1\r
-        # section alignment is actually for payload, so we need to add header size\r
-        PayloadOffset = m._OFF_ + m._HEADER_SIZE_\r
-        if (PayloadOffset & (~AlignmentMask)) == 0:\r
-            return\r
-        NewOffset = (PayloadOffset + AlignmentMask) & (~AlignmentMask)\r
-        while (NewOffset - PayloadOffset) < m._HEADER_SIZE_:\r
-            NewOffset += m._Alignment\r
-\r
-    def tofile(m, f):\r
-        m.Size = len(m)\r
-        Image.tofile(m, f)\r
-        for Offset in m._SubImages:\r
-            m._SubImages[Offset].tofile(f)\r
-\r
-    Type = property(_GetType, _SetType)\r
-    Size = property(_GetSize, _SetSize)\r
-    Alignment = property(_GetAlignment, _SetAlignment)\r
-    # SubTypeGuid = property(_GetGuid, _SetGuid)\r
-\r
-## PadSection() class\r
-#\r
-#  A class for Pad Section\r
-#\r
-class PadSection(Section):\r
-    def __init__(m, Size):\r
-        Section.__init__(m)\r
-        m.Type = 0x19\r
-        m.Size = Size\r
-        m.Data = [0] * (Size - m._HEADER_SIZE_)\r
-\r
-## Ffs() class\r
-#\r
-#  A class for Ffs Section\r
-#\r
-class Ffs(Image):\r
-    _FfsFormat = "24B%(payload_size)sB"\r
-    # skip IntegrityCheck\r
-    _HEADER_ = struct.Struct("1I2H8B 2x 1B 1B 3B 1B")\r
-    _HEADER_SIZE_ = _HEADER_.size\r
-\r
-    _NAME_      = struct.Struct("1I2H8B")\r
-    _INT_CHECK_ = struct.Struct("16x 1H")\r
-    _TYPE_      = struct.Struct("18x 1B")\r
-    _ATTR_      = struct.Struct("19x 1B")\r
-    _SIZE_      = struct.Struct("20x 3B")\r
-    _STATE_     = struct.Struct("23x 1B")\r
-\r
-    VTF_GUID = "1BA0062E-C779-4582-8566-336AE8F78F09"\r
-\r
-    FFS_ATTRIB_FIXED              = 0x04\r
-    FFS_ATTRIB_DATA_ALIGNMENT     = 0x38\r
-    FFS_ATTRIB_CHECKSUM           = 0x40\r
-\r
-    _TypeName = {\r
-        0x00    :   "<unknown>",\r
-        0x01    :   "RAW",\r
-        0x02    :   "FREEFORM",\r
-        0x03    :   "SECURITY_CORE",\r
-        0x04    :   "PEI_CORE",\r
-        0x05    :   "DXE_CORE",\r
-        0x06    :   "PEIM",\r
-        0x07    :   "DRIVER",\r
-        0x08    :   "COMBINED_PEIM_DRIVER",\r
-        0x09    :   "APPLICATION",\r
-        0x0A    :   "SMM",\r
-        0x0B    :   "FIRMWARE_VOLUME_IMAGE",\r
-        0x0C    :   "COMBINED_SMM_DXE",\r
-        0x0D    :   "SMM_CORE",\r
-        0x0E    :   "MM_STANDALONE",\r
-        0x0F    :   "MM_CORE_STANDALONE",\r
-        0xc0    :   "OEM_MIN",\r
-        0xdf    :   "OEM_MAX",\r
-        0xe0    :   "DEBUG_MIN",\r
-        0xef    :   "DEBUG_MAX",\r
-        0xf0    :   "FFS_MIN",\r
-        0xff    :   "FFS_MAX",\r
-        0xf0    :   "FFS_PAD",\r
-    }\r
-\r
-    def __init__(self):\r
-        Image.__init__(self)\r
-        self.FreeSpace = 0\r
-\r
-        self.Sections = sdict()\r
-        self.Depex = ''\r
-\r
-        self.__ID__ = None\r
-\r
-    def __str__(self):\r
-        global gIndention\r
-        gIndention += 4\r
-        Indention = ' ' * gIndention\r
-        FfsInfo = Indention\r
-        FfsInfo +=  "[FFS:%s] offset=%x size=%x guid=%s free_space=%x alignment=%s\n" % \\r
-                    (Ffs._TypeName[self.Type], self._OFF_, self.Size, self.Guid, self.FreeSpace, self.Alignment)\r
-        SectionInfo = '\n'.join([str(self.Sections[Offset]) for Offset in self.Sections])\r
-        gIndention -= 4\r
-        return FfsInfo + SectionInfo + "\n"\r
-\r
-    def __len__(self):\r
-        return self.Size\r
-\r
-    def __repr__(self):\r
-        return self.__ID__\r
-\r
-    def _Unpack(self):\r
-        Size1, Size2, Size3 = self._SIZE_.unpack_from(self._BUF_, self._OFF_)\r
-        Size = Size1 + (Size2 << 8) + (Size3 << 16)\r
-        self.empty()\r
-        self.extend(self._BUF_[self._OFF_ : self._OFF_ + Size])\r
-\r
-        # Pad FFS may use the same GUID. We need to avoid it.\r
-        if self.Type == 0xf0:\r
-            self.__ID__ = str(uuid.uuid1()).upper()\r
-        else:\r
-            self.__ID__ = self.Guid\r
-\r
-        # Traverse the SECTION. RAW and PAD do not have sections\r
-        if self.Type not in [0xf0, 0x01] and Size > 0 and Size < 0xFFFFFF:\r
-            EndOfFfs = Size\r
-            SectionStartAddress = self._HEADER_SIZE_\r
-            while SectionStartAddress < EndOfFfs:\r
-                SectionObj = Section()\r
-                SectionObj.frombuffer(self, SectionStartAddress)\r
-                #f = open(repr(SectionObj), 'wb')\r
-                #SectionObj.Size = 0\r
-                #SectionObj.tofile(f)\r
-                #f.close()\r
-                self.Sections[SectionStartAddress] = SectionObj\r
-                SectionStartAddress += len(SectionObj)\r
-                SectionStartAddress = (SectionStartAddress + 3) & (~3)\r
-\r
-    def Pack(self):\r
-        pass\r
-\r
-    def SetFreeSpace(self, Size):\r
-        self.FreeSpace = Size\r
-\r
-    def _GetGuid(self):\r
-        return gGuidStringFormat % self.Name\r
-\r
-    def _SetName(self, Value):\r
-        # Guid1, Guid2, Guid3, Guid4, Guid5, Guid6, Guid7, Guid8, Guid9, Guid10, Guid11\r
-        self.SetField(self._NAME_, 0, Value)\r
-\r
-    def _GetName(self):\r
-        # Guid1, Guid2, Guid3, Guid4, Guid5, Guid6, Guid7, Guid8, Guid9, Guid10, Guid11\r
-        return self.GetField(self._NAME_)\r
-\r
-    def _SetSize(m, Size):\r
-        Size1 = Size & 0xFF\r
-        Size2 = (Size & 0xFF00) >> 8\r
-        Size3 = (Size & 0xFF0000) >> 16\r
-        m.SetField(m._SIZE_, 0, Size1, Size2, Size3)\r
-\r
-    def _GetSize(m):\r
-        Size1, Size2, Size3 = m.GetField(m._SIZE_)\r
-        return Size1 + (Size2 << 8) + (Size3 << 16)\r
-\r
-    def _SetType(m, Type):\r
-        m.SetField(m._TYPE_, 0, Type)\r
-\r
-    def _GetType(m):\r
-        return m.GetField(m._TYPE_)[0]\r
-\r
-    def _SetAttributes(self, Value):\r
-        self.SetField(m._ATTR_, 0, Value)\r
-\r
-    def _GetAttributes(self):\r
-        return self.GetField(self._ATTR_)[0]\r
-\r
-    def _GetFixed(self):\r
-        if (self.Attributes & self.FFS_ATTRIB_FIXED) != 0:\r
-            return True\r
-        return False\r
-\r
-    def _GetCheckSum(self):\r
-        if (self.Attributes & self.FFS_ATTRIB_CHECKSUM) != 0:\r
-            return True\r
-        return False\r
-\r
-    def _GetAlignment(self):\r
-        return (self.Attributes & self.FFS_ATTRIB_DATA_ALIGNMENT) >> 3\r
-\r
-    def _SetState(self, Value):\r
-        self.SetField(m._STATE_, 0, Value)\r
-\r
-    def _GetState(self):\r
-        return self.GetField(m._STATE_)[0]\r
-\r
-    Name = property(_GetName, _SetName)\r
-    Guid = property(_GetGuid)\r
-    Type = property(_GetType, _SetType)\r
-    Size = property(_GetSize, _SetSize)\r
-    Attributes = property(_GetAttributes, _SetAttributes)\r
-    Fixed = property(_GetFixed)\r
-    Checksum = property(_GetCheckSum)\r
-    Alignment = property(_GetAlignment)\r
-    State = property(_GetState, _SetState)\r
-\r
-## PeImage() class\r
-#\r
-#  A class for PE Image\r
-#\r
-class PeImage:\r
-    #\r
-    # just extract e_lfanew\r
-    #\r
-    _DosHeaderFormat = "60x 1I"\r
-    #\r
-    # Machine\r
-    # NumberOfSections\r
-    # SizeOfOptionalHeader\r
-    #\r
-    _FileHeaderFormat = "4x 1H 1H 4x 4x 4x 1H 2x"\r
-    #\r
-    # Magic\r
-    # SizeOfImage\r
-    # SizeOfHeaders\r
-    # CheckSum\r
-    # NumberOfRvaAndSizes\r
-    #\r
-    _OptionalHeader32Format = "1H 54x 1I 1I 1I 24x 1I"\r
-    _OptionalHeader64Format = ""\r
-    def __init__(self, Buf, Offset, Size):\r
-        self.Offset = Offset\r
-        self.Size = Size\r
-        self.Machine = 0x014c # IA32\r
-        self.NumberOfSections = 0\r
-        self.SizeOfImage = 0\r
-        self.SizeOfOptionalHeader = 0\r
-        self.Checksum = 0\r
-        self._PeImageBuf = Buf\r
-        self._SectionList = []\r
-\r
-        self._DosHeader = struct.Struct(PeImage._DosHeaderFormat)\r
-        self._FileHeader = struct.Struct(PeImage._FileHeaderFormat)\r
-        self._OptionalHeader32 = struct.Struct(PeImage._OptionalHeader32Format)\r
-\r
-        self.Buffer = None\r
-\r
-        self._Unpack()\r
-\r
-    def __str__(self):\r
-        pass\r
-\r
-    def __len__(self):\r
-        return self.Size\r
-\r
-    def _Unpack(self):\r
-        # from DOS header, get the offset of PE header\r
-        FileHeaderOffset, = self._DosHeader.unpack_from(self._PeImageBuf, self.Offset)\r
-        if FileHeaderOffset < struct.calcsize(self._DosHeaderFormat):\r
-            EdkLogger.error("PE+", 0, "Invalid offset of IMAGE_FILE_HEADER: %s" % FileHeaderOffset)\r
-\r
-        # from FILE header, get the optional header size\r
-        self.Machine, self.NumberOfSections, self.SizeOfOptionalHeader = \\r
-            self._FileHeader.unpack_from(self._PeImageBuf, self.Offset + FileHeaderOffset)\r
-\r
-        print "Machine=%x NumberOfSections=%x SizeOfOptionalHeader=%x" % (self.Machine, self.NumberOfSections, self.SizeOfOptionalHeader)\r
-        # optional header follows the FILE header\r
-        OptionalHeaderOffset = FileHeaderOffset + struct.calcsize(self._FileHeaderFormat)\r
-        Magic, self.SizeOfImage, SizeOfHeaders, self.Checksum, NumberOfRvaAndSizes = \\r
-            self._OptionalHeader32.unpack_from(self._PeImageBuf, self.Offset + OptionalHeaderOffset)\r
-        print "Magic=%x SizeOfImage=%x SizeOfHeaders=%x, Checksum=%x, NumberOfRvaAndSizes=%x" % (Magic, self.SizeOfImage, SizeOfHeaders, self.Checksum, NumberOfRvaAndSizes)\r
-\r
-        PeImageSectionTableOffset = OptionalHeaderOffset + self.SizeOfOptionalHeader\r
-        PeSections = PeSectionTable(self._PeImageBuf, self.Offset + PeImageSectionTableOffset, self.NumberOfSections)\r
-\r
-        print "%x" % PeSections.GetFileAddress(0x3920)\r
-\r
-## PeSectionTable() class\r
-#\r
-#  A class for PE Section Table\r
-#\r
-class PeSectionTable:\r
-    def __init__(self, Buf, Offset, NumberOfSections):\r
-        self._SectionList = []\r
-\r
-        SectionHeaderOffset = Offset\r
-        for TableIndex in range(0, NumberOfSections):\r
-            SectionHeader = PeSectionHeader(Buf, SectionHeaderOffset)\r
-            self._SectionList.append(SectionHeader)\r
-            SectionHeaderOffset += len(SectionHeader)\r
-            print SectionHeader\r
-\r
-    def GetFileAddress(self, Rva):\r
-        for PeSection in self._SectionList:\r
-            if Rva in PeSection:\r
-                return PeSection[Rva]\r
-\r
-## PeSectionHeader() class\r
-#\r
-#  A class for PE Section Header\r
-#\r
-class PeSectionHeader:\r
-    #\r
-    # VirtualAddress\r
-    # SizeOfRawData\r
-    # PointerToRawData\r
-    #\r
-    _HeaderFormat = "12x 1I 1I 1I 16x"\r
-    _HeaderLength = struct.calcsize(_HeaderFormat)\r
-\r
-    def __init__(self, Buf, Offset):\r
-        self.VirtualAddressStart, self.SizeOfRawData, self.PointerToRawData = \\r
-            struct.unpack_from(self._HeaderFormat, Buf, Offset)\r
-        self.VirtualAddressEnd = self.VirtualAddressStart + self.SizeOfRawData - 1\r
-\r
-    def __str__(self):\r
-        return "VirtualAddress=%x, SizeOfRawData=%x, PointerToRawData=%x" % (self.VirtualAddressStart, self.SizeOfRawData, self.PointerToRawData)\r
-\r
-    def __len__(self):\r
-        return self._HeaderLength\r
-\r
-    def __contains__(self, Rva):\r
-        return Rva >= self.VirtualAddressStart and Rva <= self.VirtualAddressEnd\r
-\r
-    def __getitem__(self, Rva):\r
-        return Rva - self.VirtualAddressStart + self.PointerToRawData\r
-\r
-## LinkMap() class\r
-#\r
-#  A class for Link Map\r
-#\r
-class LinkMap:\r
-    _StartFlag = {\r
-        "MSFT"  :   re.compile("Address +Publics by Value +Rva\+Base +Lib:Object"),\r
-        "GCC"   :   re.compile("^\.(text|bss|data|edata)"),\r
-    }\r
-\r
-    _MappingFormat = {\r
-        "MSFT"  :   re.compile("([0-9a-f]+):([0-9a-f]+)\s+_+([0-9A-Za-z]+)\s+([0-9a-f]+)\s+"),\r
-        "GCC"   :   re.compile("^(\.\w)?\s+(0x[0-9a-f]+)\s+_+([0-9A-Za-z]+)"),\r
-    }\r
-\r
-    def __init__(self, MapFile, MapType="MSFT"):\r
-        self.File = MapFile\r
-        self.MapType = MapType\r
-        self._Globals = {}  # global:RVA\r
-\r
-        self._Parse()\r
-\r
-    def _Parse(self):\r
-        MapFile = open(self.File, 'r')\r
-        MappingTitle = self._StartFlag[self.MapType]\r
-        MappingFormat = self._MappingFormat[self.MapType]\r
-        MappingStart = False\r
-        try:\r
-            for Line in MapFile:\r
-                Line = Line.strip()\r
-                if not MappingStart:\r
-                    if MappingTitle.match(Line) is not None:\r
-                        MappingStart = True\r
-                    continue\r
-                ResultList = MappingFormat.findall(Line)\r
-                if len(ResultList) == 0 or len(ResultList[0]) != 4:\r
-                    continue\r
-                self._Globals[ResultList[2]] = int(ResultList[3], 16)\r
-                EdkLogger.verbose(ResultList[0])\r
-        finally:\r
-            MapFile.close()\r
-\r
-    def __contains__(self, Var):\r
-        return Var in self._Globals\r
-\r
-    def __getitem__(self, Var):\r
-        if Var not in self._Globals:\r
-            return None\r
-        return self._Globals[Var]\r
-\r
-## MultipleFv() class\r
-#\r
-#  A class for Multiple FV\r
-#\r
-class MultipleFv(FirmwareVolume):\r
-    def __init__(self, FvList):\r
-        FirmwareVolume.__init__(self)\r
-        self.BasicInfo = []\r
-        for FvPath in FvList:\r
-            FvName = os.path.splitext(os.path.split(FvPath)[1])[0]\r
-            Fd = open(FvPath, 'rb')\r
-            Buf = array('B')\r
-            try:\r
-                Buf.fromfile(Fd, os.path.getsize(FvPath))\r
-            except EOFError:\r
-                pass\r
-\r
-            Fv = FirmwareVolume(FvName)\r
-            Fv.frombuffer(Buf, 0, len(Buf))\r
-\r
-            self.BasicInfo.append([Fv.Name, Fv.FileSystemGuid, Fv.Size])\r
-            self.FfsDict.append(Fv.FfsDict)\r
-\r
-# Version and Copyright\r
-__version_number__ = "0.01"\r
-__version__ = "%prog Version " + __version_number__\r
-__copyright__ = "Copyright (c) 2008, Intel Corporation. All rights reserved."\r
-\r
-## Parse command line options\r
-#\r
-# Using standard Python module optparse to parse command line option of this tool.\r
-#\r
-# @retval Options   A optparse.Values object containing the parsed options\r
-# @retval InputFile Path of file to be trimmed\r
-#\r
-def GetOptions():\r
-    OptionList = [\r
-        make_option("-a", "--arch", dest="Arch",\r
-                          help="The input file is preprocessed source code, including C or assembly code"),\r
-        make_option("-p", "--platform", dest="ActivePlatform",\r
-                          help="The input file is preprocessed VFR file"),\r
-        make_option("-m", "--module", dest="ActiveModule",\r
-                          help="Convert standard hex format (0xabcd) to MASM format (abcdh)"),\r
-        make_option("-f", "--FDF-file", dest="FdfFile",\r
-                          help="Convert standard hex format (0xabcd) to MASM format (abcdh)"),\r
-        make_option("-o", "--output", dest="OutputDirectory",\r
-                          help="File to store the trimmed content"),\r
-        make_option("-t", "--toolchain-tag", dest="ToolChain",\r
-                          help=""),\r
-        make_option("-k", "--msft", dest="MakefileType", action="store_const", const="nmake",\r
-                          help=""),\r
-        make_option("-g", "--gcc", dest="MakefileType", action="store_const", const="gmake",\r
-                          help=""),\r
-        make_option("-v", "--verbose", dest="LogLevel", action="store_const", const=EdkLogger.VERBOSE,\r
-                          help="Run verbosely"),\r
-        make_option("-d", "--debug", dest="LogLevel", type="int",\r
-                          help="Run with debug information"),\r
-        make_option("-q", "--quiet", dest="LogLevel", action="store_const", const=EdkLogger.QUIET,\r
-                          help="Run quietly"),\r
-        make_option("-?", action="help", help="show this help message and exit"),\r
-    ]\r
-\r
-    # use clearer usage to override default usage message\r
-    UsageString = "%prog [-a ARCH] [-p PLATFORM] [-m MODULE] [-t TOOLCHAIN_TAG] [-k] [-g] [-v|-d <debug_level>|-q] [-o <output_directory>] [GenC|GenMake]"\r
-\r
-    Parser = OptionParser(description=__copyright__, version=__version__, option_list=OptionList, usage=UsageString)\r
-    Parser.set_defaults(Arch=[])\r
-    Parser.set_defaults(ActivePlatform=None)\r
-    Parser.set_defaults(ActiveModule=None)\r
-    Parser.set_defaults(OutputDirectory="build")\r
-    Parser.set_defaults(FdfFile=None)\r
-    Parser.set_defaults(ToolChain="MYTOOLS")\r
-    if sys.platform == "win32":\r
-        Parser.set_defaults(MakefileType="nmake")\r
-    else:\r
-        Parser.set_defaults(MakefileType="gmake")\r
-    Parser.set_defaults(LogLevel=EdkLogger.INFO)\r
-\r
-    Options, Args = Parser.parse_args()\r
-\r
-    # error check\r
-    if len(Args) == 0:\r
-        Options.Target = "genmake"\r
-        sys.argv.append("genmake")\r
-    elif len(Args) == 1:\r
-        Options.Target = Args[0].lower()\r
-        if Options.Target not in ["genc", "genmake"]:\r
-            EdkLogger.error("AutoGen", OPTION_NOT_SUPPORTED, "Not supported target",\r
-                            ExtraData="%s\n\n%s" % (Options.Target, Parser.get_usage()))\r
-    else:\r
-        EdkLogger.error("AutoGen", OPTION_NOT_SUPPORTED, "Too many targets",\r
-                        ExtraData=Parser.get_usage())\r
-\r
-    return Options\r
-\r
-## Entrance method\r
-#\r
-# This method mainly dispatch specific methods per the command line options.\r
-# If no error found, return zero value so the caller of this tool can know\r
-# if it's executed successfully or not.\r
-#\r
-# @retval 0     Tool was successful\r
-# @retval 1     Tool failed\r
-#\r
-def Main():\r
-    from build import build\r
-    try:\r
-        Option = GetOptions()\r
-        build.main()\r
-    except Exception, e:\r
-        print e\r
-        return 1\r
-\r
-    return 0\r
-\r
-# This acts like the main() function for the script, unless it is 'import'ed into another script.\r
-if __name__ == '__main__':\r
-    EdkLogger.Initialize()\r
-    # sys.exit(Main())\r
-\r
-    if len(sys.argv) > 1:\r
-        FilePath = sys.argv[1]\r
-        if FilePath.lower().endswith(".fv"):\r
-            fd = open(FilePath, 'rb')\r
-            buf = array('B')\r
-            try:\r
-                buf.fromfile(fd, os.path.getsize(FilePath))\r
-            except EOFError:\r
-                pass\r
-\r
-            fv = FirmwareVolume("FVRECOVERY")\r
-            fv.frombuffer(buf, 0, len(buf))\r
-            #fv.Dispatch(None)\r
-            print fv\r
-        elif FilePath.endswith(".efi"):\r
-            fd = open(FilePath, 'rb')\r
-            buf = array('B')\r
-            Size = os.path.getsize(FilePath)\r
-\r
-            try:\r
-                buf.fromfile(fd, Size)\r
-            except EOFError:\r
-                pass\r
-\r
-            PeSection = Section(Type=0x10)\r
-            PeSection.Data = buf\r
-            sf, ext = os.path.splitext(os.path.basename(FilePath))\r
-            sf += ".sec"\r
-            PeSection.tofile(open(sf, 'wb'))\r
-        elif FilePath.endswith(".map"):\r
-            mf = LinkMap(FilePath)\r
index e34c840..a51207d 100644 (file)
@@ -110,7 +110,6 @@ CMD_BUILD=$(BASE_TOOLS_PATH)\Source\Python\build\BuildReport.py \
     $(BASE_TOOLS_PATH)\Source\Python\Eot\EotGlobalData.py \\r
     $(BASE_TOOLS_PATH)\Source\Python\Eot\EotToolError.py \\r
     $(BASE_TOOLS_PATH)\Source\Python\Eot\FileProfile.py \\r
-    $(BASE_TOOLS_PATH)\Source\Python\Eot\FvImage.py \\r
     $(BASE_TOOLS_PATH)\Source\Python\Eot\InfParserLite.py \\r
     $(BASE_TOOLS_PATH)\Source\Python\Eot\LzmaCompressor.pyd \\r
     $(BASE_TOOLS_PATH)\Source\Python\Eot\Parser.py \\r