mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-10 14:23:31 +01:00
326 lines
16 KiB
Python
Executable File
326 lines
16 KiB
Python
Executable File
## @file
|
|
# process rule section generation
|
|
#
|
|
# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
|
|
##
|
|
# Import Modules
|
|
#
|
|
from __future__ import absolute_import
|
|
from struct import *
|
|
from . import Section
|
|
from .GenFdsGlobalVariable import GenFdsGlobalVariable
|
|
import subprocess
|
|
from .Ffs import SectionSuffix
|
|
import Common.LongFilePathOs as os
|
|
from CommonDataClass.FdfClass import EfiSectionClassObject
|
|
from Common import EdkLogger
|
|
from Common.BuildToolError import *
|
|
from Common.Misc import PeImageClass
|
|
from Common.LongFilePathSupport import OpenLongFilePath as open
|
|
from Common.LongFilePathSupport import CopyLongFilePath
|
|
from Common.DataType import *
|
|
|
|
## generate rule section
|
|
#
|
|
#
|
|
class EfiSection (EfiSectionClassObject):
|
|
|
|
## The constructor
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
def __init__(self):
|
|
EfiSectionClassObject.__init__(self)
|
|
|
|
## GenSection() method
|
|
#
|
|
# Generate rule section
|
|
#
|
|
# @param self The object pointer
|
|
# @param OutputPath Where to place output file
|
|
# @param ModuleName Which module this section belongs to
|
|
# @param SecNum Index of section
|
|
# @param KeyStringList Filter for inputs of section generation
|
|
# @param FfsInf FfsInfStatement object that contains this section data
|
|
# @param Dict dictionary contains macro and its value
|
|
# @retval tuple (Generated file name list, section alignment)
|
|
#
|
|
def GenSection(self, OutputPath, ModuleName, SecNum, KeyStringList, FfsInf = None, Dict = None, IsMakefile = False) :
|
|
|
|
if self.FileName is not None and self.FileName.startswith('PCD('):
|
|
self.FileName = GenFdsGlobalVariable.GetPcdValue(self.FileName)
|
|
"""Prepare the parameter of GenSection"""
|
|
if FfsInf is not None :
|
|
InfFileName = FfsInf.InfFileName
|
|
SectionType = FfsInf.__ExtendMacro__(self.SectionType)
|
|
Filename = FfsInf.__ExtendMacro__(self.FileName)
|
|
BuildNum = FfsInf.__ExtendMacro__(self.BuildNum)
|
|
StringData = FfsInf.__ExtendMacro__(self.StringData)
|
|
ModuleNameStr = FfsInf.__ExtendMacro__('$(MODULE_NAME)')
|
|
NoStrip = True
|
|
if FfsInf.ModuleType in (SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM, SUP_MODULE_MM_CORE_STANDALONE) and SectionType in (BINARY_FILE_TYPE_TE, BINARY_FILE_TYPE_PE32):
|
|
if FfsInf.KeepReloc is not None:
|
|
NoStrip = FfsInf.KeepReloc
|
|
elif FfsInf.KeepRelocFromRule is not None:
|
|
NoStrip = FfsInf.KeepRelocFromRule
|
|
elif self.KeepReloc is not None:
|
|
NoStrip = self.KeepReloc
|
|
elif FfsInf.ShadowFromInfFile is not None:
|
|
NoStrip = FfsInf.ShadowFromInfFile
|
|
else:
|
|
EdkLogger.error("GenFds", GENFDS_ERROR, "Module %s apply rule for None!" %ModuleName)
|
|
|
|
"""If the file name was pointed out, add it in FileList"""
|
|
FileList = []
|
|
if Dict is None:
|
|
Dict = {}
|
|
if Filename is not None:
|
|
Filename = GenFdsGlobalVariable.MacroExtend(Filename, Dict)
|
|
# check if the path is absolute or relative
|
|
if os.path.isabs(Filename):
|
|
Filename = os.path.normpath(Filename)
|
|
else:
|
|
Filename = os.path.normpath(os.path.join(FfsInf.EfiOutputPath, Filename))
|
|
|
|
if not self.Optional:
|
|
FileList.append(Filename)
|
|
elif os.path.exists(Filename):
|
|
FileList.append(Filename)
|
|
elif IsMakefile:
|
|
SuffixMap = FfsInf.GetFinalTargetSuffixMap()
|
|
if '.depex' in SuffixMap:
|
|
FileList.append(Filename)
|
|
else:
|
|
FileList, IsSect = Section.Section.GetFileList(FfsInf, self.FileType, self.FileExtension, Dict, IsMakefile=IsMakefile, SectionType=SectionType)
|
|
if IsSect :
|
|
return FileList, self.Alignment
|
|
|
|
Index = 0
|
|
Align = self.Alignment
|
|
|
|
""" If Section type is 'VERSION'"""
|
|
OutputFileList = []
|
|
if SectionType == 'VERSION':
|
|
|
|
InfOverrideVerString = False
|
|
if FfsInf.Version is not None:
|
|
#StringData = FfsInf.Version
|
|
BuildNum = FfsInf.Version
|
|
InfOverrideVerString = True
|
|
|
|
if InfOverrideVerString:
|
|
#VerTuple = ('-n', '"' + StringData + '"')
|
|
if BuildNum is not None and BuildNum != '':
|
|
BuildNumTuple = ('-j', BuildNum)
|
|
else:
|
|
BuildNumTuple = tuple()
|
|
|
|
Num = SecNum
|
|
OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + SectionSuffix.get(SectionType))
|
|
GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_VERSION',
|
|
#Ui=StringData,
|
|
Ver=BuildNum,
|
|
IsMakefile=IsMakefile)
|
|
OutputFileList.append(OutputFile)
|
|
|
|
elif FileList != []:
|
|
for File in FileList:
|
|
Index = Index + 1
|
|
Num = '%s.%d' %(SecNum, Index)
|
|
OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + Num + SectionSuffix.get(SectionType))
|
|
f = open(File, 'r')
|
|
VerString = f.read()
|
|
f.close()
|
|
BuildNum = VerString
|
|
if BuildNum is not None and BuildNum != '':
|
|
BuildNumTuple = ('-j', BuildNum)
|
|
GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_VERSION',
|
|
#Ui=VerString,
|
|
Ver=BuildNum,
|
|
IsMakefile=IsMakefile)
|
|
OutputFileList.append(OutputFile)
|
|
|
|
else:
|
|
BuildNum = StringData
|
|
if BuildNum is not None and BuildNum != '':
|
|
BuildNumTuple = ('-j', BuildNum)
|
|
else:
|
|
BuildNumTuple = tuple()
|
|
BuildNumString = ' ' + ' '.join(BuildNumTuple)
|
|
|
|
#if VerString == '' and
|
|
if BuildNumString == '':
|
|
if self.Optional == True :
|
|
GenFdsGlobalVariable.VerboseLogger( "Optional Section don't exist!")
|
|
return [], None
|
|
else:
|
|
EdkLogger.error("GenFds", GENFDS_ERROR, "File: %s miss Version Section value" %InfFileName)
|
|
Num = SecNum
|
|
OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + SectionSuffix.get(SectionType))
|
|
GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_VERSION',
|
|
#Ui=VerString,
|
|
Ver=BuildNum,
|
|
IsMakefile=IsMakefile)
|
|
OutputFileList.append(OutputFile)
|
|
|
|
#
|
|
# If Section Type is BINARY_FILE_TYPE_UI
|
|
#
|
|
elif SectionType == BINARY_FILE_TYPE_UI:
|
|
|
|
InfOverrideUiString = False
|
|
if FfsInf.Ui is not None:
|
|
StringData = FfsInf.Ui
|
|
InfOverrideUiString = True
|
|
|
|
if InfOverrideUiString:
|
|
Num = SecNum
|
|
if IsMakefile and StringData == ModuleNameStr:
|
|
StringData = "$(MODULE_NAME)"
|
|
OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + SectionSuffix.get(SectionType))
|
|
GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_USER_INTERFACE',
|
|
Ui=StringData, IsMakefile=IsMakefile)
|
|
OutputFileList.append(OutputFile)
|
|
|
|
elif FileList != []:
|
|
for File in FileList:
|
|
Index = Index + 1
|
|
Num = '%s.%d' %(SecNum, Index)
|
|
OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + Num + SectionSuffix.get(SectionType))
|
|
f = open(File, 'r')
|
|
UiString = f.read()
|
|
f.close()
|
|
if IsMakefile and UiString == ModuleNameStr:
|
|
UiString = "$(MODULE_NAME)"
|
|
GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_USER_INTERFACE',
|
|
Ui=UiString, IsMakefile=IsMakefile)
|
|
OutputFileList.append(OutputFile)
|
|
else:
|
|
if StringData is not None and len(StringData) > 0:
|
|
UiTuple = ('-n', '"' + StringData + '"')
|
|
else:
|
|
UiTuple = tuple()
|
|
|
|
if self.Optional == True :
|
|
GenFdsGlobalVariable.VerboseLogger( "Optional Section don't exist!")
|
|
return '', None
|
|
else:
|
|
EdkLogger.error("GenFds", GENFDS_ERROR, "File: %s miss UI Section value" %InfFileName)
|
|
|
|
Num = SecNum
|
|
if IsMakefile and StringData == ModuleNameStr:
|
|
StringData = "$(MODULE_NAME)"
|
|
OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + SectionSuffix.get(SectionType))
|
|
GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_USER_INTERFACE',
|
|
Ui=StringData, IsMakefile=IsMakefile)
|
|
OutputFileList.append(OutputFile)
|
|
|
|
#
|
|
# If Section Type is BINARY_FILE_TYPE_RAW
|
|
#
|
|
elif SectionType == BINARY_FILE_TYPE_RAW:
|
|
"""If File List is empty"""
|
|
if FileList == []:
|
|
if self.Optional == True:
|
|
GenFdsGlobalVariable.VerboseLogger("Optional Section don't exist!")
|
|
return [], None
|
|
else:
|
|
EdkLogger.error("GenFds", GENFDS_ERROR, "Output file for %s section could not be found for %s" % (SectionType, InfFileName))
|
|
|
|
elif len(FileList) > 1:
|
|
EdkLogger.error("GenFds", GENFDS_ERROR,
|
|
"Files suffixed with %s are not allowed to have more than one file in %s[Binaries] section" % (
|
|
self.FileExtension, InfFileName))
|
|
else:
|
|
for File in FileList:
|
|
File = GenFdsGlobalVariable.MacroExtend(File, Dict)
|
|
OutputFileList.append(File)
|
|
|
|
else:
|
|
"""If File List is empty"""
|
|
if FileList == [] :
|
|
if self.Optional == True:
|
|
GenFdsGlobalVariable.VerboseLogger("Optional Section don't exist!")
|
|
return [], None
|
|
else:
|
|
EdkLogger.error("GenFds", GENFDS_ERROR, "Output file for %s section could not be found for %s" % (SectionType, InfFileName))
|
|
|
|
else:
|
|
"""Convert the File to Section file one by one """
|
|
for File in FileList:
|
|
""" Copy Map file to FFS output path """
|
|
Index = Index + 1
|
|
Num = '%s.%d' %(SecNum, Index)
|
|
OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + Num + SectionSuffix.get(SectionType))
|
|
File = GenFdsGlobalVariable.MacroExtend(File, Dict)
|
|
|
|
#Get PE Section alignment when align is set to AUTO
|
|
if self.Alignment == 'Auto' and (SectionType == BINARY_FILE_TYPE_PE32 or SectionType == BINARY_FILE_TYPE_TE):
|
|
ImageObj = PeImageClass (File)
|
|
if ImageObj.SectionAlignment < 0x400:
|
|
Align = str (ImageObj.SectionAlignment)
|
|
elif ImageObj.SectionAlignment < 0x100000:
|
|
Align = str (ImageObj.SectionAlignment // 0x400) + 'K'
|
|
else:
|
|
Align = str (ImageObj.SectionAlignment // 0x100000) + 'M'
|
|
|
|
if File[(len(File)-4):] == '.efi':
|
|
MapFile = File.replace('.efi', '.map')
|
|
CopyMapFile = os.path.join(OutputPath, ModuleName + '.map')
|
|
if IsMakefile:
|
|
if GenFdsGlobalVariable.CopyList == []:
|
|
GenFdsGlobalVariable.CopyList = [(MapFile, CopyMapFile)]
|
|
else:
|
|
GenFdsGlobalVariable.CopyList.append((MapFile, CopyMapFile))
|
|
else:
|
|
if os.path.exists(MapFile):
|
|
if not os.path.exists(CopyMapFile) or \
|
|
(os.path.getmtime(MapFile) > os.path.getmtime(CopyMapFile)):
|
|
CopyLongFilePath(MapFile, CopyMapFile)
|
|
|
|
if not NoStrip:
|
|
FileBeforeStrip = os.path.join(OutputPath, ModuleName + '.efi')
|
|
if IsMakefile:
|
|
if GenFdsGlobalVariable.CopyList == []:
|
|
GenFdsGlobalVariable.CopyList = [(File, FileBeforeStrip)]
|
|
else:
|
|
GenFdsGlobalVariable.CopyList.append((File, FileBeforeStrip))
|
|
else:
|
|
if not os.path.exists(FileBeforeStrip) or \
|
|
(os.path.getmtime(File) > os.path.getmtime(FileBeforeStrip)):
|
|
CopyLongFilePath(File, FileBeforeStrip)
|
|
StrippedFile = os.path.join(OutputPath, ModuleName + '.stripped')
|
|
GenFdsGlobalVariable.GenerateFirmwareImage(
|
|
StrippedFile,
|
|
[File],
|
|
Strip=True,
|
|
IsMakefile = IsMakefile
|
|
)
|
|
File = StrippedFile
|
|
|
|
"""For TE Section call GenFw to generate TE image"""
|
|
|
|
if SectionType == BINARY_FILE_TYPE_TE:
|
|
TeFile = os.path.join( OutputPath, ModuleName + 'Te.raw')
|
|
GenFdsGlobalVariable.GenerateFirmwareImage(
|
|
TeFile,
|
|
[File],
|
|
Type='te',
|
|
IsMakefile = IsMakefile
|
|
)
|
|
File = TeFile
|
|
|
|
"""Call GenSection"""
|
|
GenFdsGlobalVariable.GenerateSection(OutputFile,
|
|
[File],
|
|
Section.Section.SectionType.get (SectionType),
|
|
IsMakefile=IsMakefile
|
|
)
|
|
OutputFileList.append(OutputFile)
|
|
|
|
return OutputFileList, Align
|