BaseTools: Replace BSD License with BSD+Patent License

[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / GenDepex.py

## @file\r
# This file is used to generate DEPEX file for module's dependency expression\r
#\r
# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
# SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
## Import Modules\r
#\r
import sys\r
import Common.LongFilePathOs as os\r
import re\r
import traceback\r
from Common.LongFilePathSupport import OpenLongFilePath as open\r
from io import BytesIO\r
from struct import pack\r
from Common.BuildToolError import *\r
from Common.Misc import SaveFileOnChange\r
from Common.Misc import GuidStructureStringToGuidString\r
from Common.Misc import GuidStructureByteArrayToGuidString\r
from Common.Misc import GuidStringToGuidStructureString\r
from Common import EdkLogger as EdkLogger\r
from Common.BuildVersion import gBUILD_VERSION\r
from Common.DataType import *\r
\r
## Regular expression for matching "DEPENDENCY_START ... DEPENDENCY_END"\r
gStartClosePattern = re.compile(".*DEPENDENCY_START(.+)DEPENDENCY_END.*", re.S)\r
\r
## Mapping between module type and EFI phase\r
gType2Phase = {\r
    SUP_MODULE_BASE              :   None,\r
    SUP_MODULE_SEC               :   "PEI",\r
    SUP_MODULE_PEI_CORE          :   "PEI",\r
    SUP_MODULE_PEIM              :   "PEI",\r
    SUP_MODULE_DXE_CORE          :   "DXE",\r
    SUP_MODULE_DXE_DRIVER        :   "DXE",\r
    SUP_MODULE_DXE_SMM_DRIVER    :   "DXE",\r
    SUP_MODULE_DXE_RUNTIME_DRIVER:   "DXE",\r
    SUP_MODULE_DXE_SAL_DRIVER    :   "DXE",\r
    SUP_MODULE_UEFI_DRIVER       :   "DXE",\r
    SUP_MODULE_UEFI_APPLICATION  :   "DXE",\r
    SUP_MODULE_SMM_CORE          :   "DXE",\r
    SUP_MODULE_MM_STANDALONE     :   "MM",\r
    SUP_MODULE_MM_CORE_STANDALONE :  "MM",\r
}\r
\r
## Convert dependency expression string into EFI internal representation\r
#\r
#   DependencyExpression class is used to parse dependency expression string and\r
# convert it into its binary form.\r
#\r
class DependencyExpression:\r
\r
    ArchProtocols = {\r
                        '665e3ff6-46cc-11d4-9a38-0090273fc14d',     #   'gEfiBdsArchProtocolGuid'\r
                        '26baccb1-6f42-11d4-bce7-0080c73c8881',     #   'gEfiCpuArchProtocolGuid'\r
                        '26baccb2-6f42-11d4-bce7-0080c73c8881',     #   'gEfiMetronomeArchProtocolGuid'\r
                        '1da97072-bddc-4b30-99f1-72a0b56fff2a',     #   'gEfiMonotonicCounterArchProtocolGuid'\r
                        '27cfac87-46cc-11d4-9a38-0090273fc14d',     #   'gEfiRealTimeClockArchProtocolGuid'\r
                        '27cfac88-46cc-11d4-9a38-0090273fc14d',     #   'gEfiResetArchProtocolGuid'\r
                        'b7dfb4e1-052f-449f-87be-9818fc91b733',     #   'gEfiRuntimeArchProtocolGuid'\r
                        'a46423e3-4617-49f1-b9ff-d1bfa9115839',     #   'gEfiSecurityArchProtocolGuid'\r
                        '26baccb3-6f42-11d4-bce7-0080c73c8881',     #   'gEfiTimerArchProtocolGuid'\r
                        '6441f818-6362-4e44-b570-7dba31dd2453',     #   'gEfiVariableWriteArchProtocolGuid'\r
                        '1e5668e2-8481-11d4-bcf1-0080c73c8881',     #   'gEfiVariableArchProtocolGuid'\r
                        '665e3ff5-46cc-11d4-9a38-0090273fc14d'      #   'gEfiWatchdogTimerArchProtocolGuid'\r
                    }\r
\r
    OpcodePriority = {\r
        DEPEX_OPCODE_AND   :   1,\r
        DEPEX_OPCODE_OR    :   1,\r
        DEPEX_OPCODE_NOT   :   2,\r
    }\r
\r
    Opcode = {\r
        "PEI"   : {\r
            DEPEX_OPCODE_PUSH  :   0x02,\r
            DEPEX_OPCODE_AND   :   0x03,\r
            DEPEX_OPCODE_OR    :   0x04,\r
            DEPEX_OPCODE_NOT   :   0x05,\r
            DEPEX_OPCODE_TRUE  :   0x06,\r
            DEPEX_OPCODE_FALSE :   0x07,\r
            DEPEX_OPCODE_END   :   0x08\r
        },\r
\r
        "DXE"   : {\r
            DEPEX_OPCODE_BEFORE:   0x00,\r
            DEPEX_OPCODE_AFTER :   0x01,\r
            DEPEX_OPCODE_PUSH  :   0x02,\r
            DEPEX_OPCODE_AND   :   0x03,\r
            DEPEX_OPCODE_OR    :   0x04,\r
            DEPEX_OPCODE_NOT   :   0x05,\r
            DEPEX_OPCODE_TRUE  :   0x06,\r
            DEPEX_OPCODE_FALSE :   0x07,\r
            DEPEX_OPCODE_END   :   0x08,\r
            DEPEX_OPCODE_SOR   :   0x09\r
        },\r
\r
        "MM"   : {\r
            DEPEX_OPCODE_BEFORE:   0x00,\r
            DEPEX_OPCODE_AFTER :   0x01,\r
            DEPEX_OPCODE_PUSH  :   0x02,\r
            DEPEX_OPCODE_AND   :   0x03,\r
            DEPEX_OPCODE_OR    :   0x04,\r
            DEPEX_OPCODE_NOT   :   0x05,\r
            DEPEX_OPCODE_TRUE  :   0x06,\r
            DEPEX_OPCODE_FALSE :   0x07,\r
            DEPEX_OPCODE_END   :   0x08,\r
            DEPEX_OPCODE_SOR   :   0x09\r
        }\r
    }\r
\r
    # all supported op codes and operands\r
    SupportedOpcode = [DEPEX_OPCODE_BEFORE, DEPEX_OPCODE_AFTER, DEPEX_OPCODE_PUSH, DEPEX_OPCODE_AND, DEPEX_OPCODE_OR, DEPEX_OPCODE_NOT, DEPEX_OPCODE_END, DEPEX_OPCODE_SOR]\r
    SupportedOperand = [DEPEX_OPCODE_TRUE, DEPEX_OPCODE_FALSE]\r
\r
    OpcodeWithSingleOperand = [DEPEX_OPCODE_NOT, DEPEX_OPCODE_BEFORE, DEPEX_OPCODE_AFTER]\r
    OpcodeWithTwoOperand = [DEPEX_OPCODE_AND, DEPEX_OPCODE_OR]\r
\r
    # op code that should not be the last one\r
    NonEndingOpcode = [DEPEX_OPCODE_AND, DEPEX_OPCODE_OR, DEPEX_OPCODE_NOT, DEPEX_OPCODE_SOR]\r
    # op code must not present at the same time\r
    ExclusiveOpcode = [DEPEX_OPCODE_BEFORE, DEPEX_OPCODE_AFTER]\r
    # op code that should be the first one if it presents\r
    AboveAllOpcode = [DEPEX_OPCODE_SOR, DEPEX_OPCODE_BEFORE, DEPEX_OPCODE_AFTER]\r
\r
    #\r
    # open and close brace must be taken as individual tokens\r
    #\r
    TokenPattern = re.compile("(\(|\)|\{[^{}]+\{?[^{}]+\}?[ ]*\}|\w+)")\r
\r
    ## Constructor\r
    #\r
    #   @param  Expression  The list or string of dependency expression\r
    #   @param  ModuleType  The type of the module using the dependency expression\r
    #\r
    def __init__(self, Expression, ModuleType, Optimize=False):\r
        self.ModuleType = ModuleType\r
        self.Phase = gType2Phase[ModuleType]\r
        if isinstance(Expression, type([])):\r
            self.ExpressionString = " ".join(Expression)\r
            self.TokenList = Expression\r
        else:\r
            self.ExpressionString = Expression\r
            self.GetExpressionTokenList()\r
\r
        self.PostfixNotation = []\r
        self.OpcodeList = []\r
\r
        self.GetPostfixNotation()\r
        self.ValidateOpcode()\r
\r
        EdkLogger.debug(EdkLogger.DEBUG_8, repr(self))\r
        if Optimize:\r
            self.Optimize()\r
            EdkLogger.debug(EdkLogger.DEBUG_8, "\n    Optimized: " + repr(self))\r
\r
    def __str__(self):\r
        return " ".join(self.TokenList)\r
\r
    def __repr__(self):\r
        WellForm = ''\r
        for Token in self.PostfixNotation:\r
            if Token in self.SupportedOpcode:\r
                WellForm += "\n    " + Token\r
            else:\r
                WellForm += ' ' + Token\r
        return WellForm\r
\r
    ## Split the expression string into token list\r
    def GetExpressionTokenList(self):\r
        self.TokenList = self.TokenPattern.findall(self.ExpressionString)\r
\r
    ## Convert token list into postfix notation\r
    def GetPostfixNotation(self):\r
        Stack = []\r
        LastToken = ''\r
        for Token in self.TokenList:\r
            if Token == "(":\r
                if LastToken not in self.SupportedOpcode + ['(', '', None]:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operator before open parentheses",\r
                                    ExtraData="Near %s" % LastToken)\r
                Stack.append(Token)\r
            elif Token == ")":\r
                if '(' not in Stack:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: mismatched parentheses",\r
                                    ExtraData=str(self))\r
                elif LastToken in self.SupportedOpcode + ['', None]:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operand before close parentheses",\r
                                    ExtraData="Near %s" % LastToken)\r
                while len(Stack) > 0:\r
                    if Stack[-1] == '(':\r
                        Stack.pop()\r
                        break\r
                    self.PostfixNotation.append(Stack.pop())\r
            elif Token in self.OpcodePriority:\r
                if Token == DEPEX_OPCODE_NOT:\r
                    if LastToken not in self.SupportedOpcode + ['(', '', None]:\r
                        EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operator before NOT",\r
                                        ExtraData="Near %s" % LastToken)\r
                elif LastToken in self.SupportedOpcode + ['(', '', None]:\r
                        EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operand before " + Token,\r
                                        ExtraData="Near %s" % LastToken)\r
\r
                while len(Stack) > 0:\r
                    if Stack[-1] == "(" or self.OpcodePriority[Token] >= self.OpcodePriority[Stack[-1]]:\r
                        break\r
                    self.PostfixNotation.append(Stack.pop())\r
                Stack.append(Token)\r
                self.OpcodeList.append(Token)\r
            else:\r
                if Token not in self.SupportedOpcode:\r
                    # not OP, take it as GUID\r
                    if LastToken not in self.SupportedOpcode + ['(', '', None]:\r
                        EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operator before %s" % Token,\r
                                        ExtraData="Near %s" % LastToken)\r
                    if len(self.OpcodeList) == 0 or self.OpcodeList[-1] not in self.ExclusiveOpcode:\r
                        if Token not in self.SupportedOperand:\r
                            self.PostfixNotation.append(DEPEX_OPCODE_PUSH)\r
                # check if OP is valid in this phase\r
                elif Token in self.Opcode[self.Phase]:\r
                    if Token == DEPEX_OPCODE_END:\r
                        break\r
                    self.OpcodeList.append(Token)\r
                else:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR,\r
                                    "Opcode=%s doesn't supported in %s stage " % (Token, self.Phase),\r
                                    ExtraData=str(self))\r
                self.PostfixNotation.append(Token)\r
            LastToken = Token\r
\r
        # there should not be parentheses in Stack\r
        if '(' in Stack or ')' in Stack:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: mismatched parentheses",\r
                            ExtraData=str(self))\r
        while len(Stack) > 0:\r
            self.PostfixNotation.append(Stack.pop())\r
        if self.PostfixNotation[-1] != DEPEX_OPCODE_END:\r
            self.PostfixNotation.append(DEPEX_OPCODE_END)\r
\r
    ## Validate the dependency expression\r
    def ValidateOpcode(self):\r
        for Op in self.AboveAllOpcode:\r
            if Op in self.PostfixNotation:\r
                if Op != self.PostfixNotation[0]:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "%s should be the first opcode in the expression" % Op,\r
                                    ExtraData=str(self))\r
                if len(self.PostfixNotation) < 3:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Missing operand for %s" % Op,\r
                                    ExtraData=str(self))\r
        for Op in self.ExclusiveOpcode:\r
            if Op in self.OpcodeList:\r
                if len(self.OpcodeList) > 1:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "%s should be the only opcode in the expression" % Op,\r
                                    ExtraData=str(self))\r
                if len(self.PostfixNotation) < 3:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Missing operand for %s" % Op,\r
                                    ExtraData=str(self))\r
        if self.TokenList[-1] != DEPEX_OPCODE_END and self.TokenList[-1] in self.NonEndingOpcode:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Extra %s at the end of the dependency expression" % self.TokenList[-1],\r
                            ExtraData=str(self))\r
        if self.TokenList[-1] == DEPEX_OPCODE_END and self.TokenList[-2] in self.NonEndingOpcode:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Extra %s at the end of the dependency expression" % self.TokenList[-2],\r
                            ExtraData=str(self))\r
        if DEPEX_OPCODE_END in self.TokenList and DEPEX_OPCODE_END != self.TokenList[-1]:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Extra expressions after END",\r
                            ExtraData=str(self))\r
\r
    ## Simply optimize the dependency expression by removing duplicated operands\r
    def Optimize(self):\r
        OpcodeSet = set(self.OpcodeList)\r
        # if there are isn't one in the set, return\r
        if len(OpcodeSet) != 1:\r
          return\r
        Op = OpcodeSet.pop()\r
        #if Op isn't either OR or AND, return\r
        if Op not in [DEPEX_OPCODE_AND, DEPEX_OPCODE_OR]:\r
            return\r
        NewOperand = []\r
        AllOperand = set()\r
        for Token in self.PostfixNotation:\r
            if Token in self.SupportedOpcode or Token in NewOperand:\r
                continue\r
            AllOperand.add(Token)\r
            if Token == DEPEX_OPCODE_TRUE:\r
                if Op == DEPEX_OPCODE_AND:\r
                    continue\r
                else:\r
                    NewOperand.append(Token)\r
                    break\r
            elif Token == DEPEX_OPCODE_FALSE:\r
                if Op == DEPEX_OPCODE_OR:\r
                    continue\r
                else:\r
                    NewOperand.append(Token)\r
                    break\r
            NewOperand.append(Token)\r
\r
        # don't generate depex if only TRUE operand left\r
        if self.ModuleType == SUP_MODULE_PEIM and len(NewOperand) == 1 and NewOperand[0] == DEPEX_OPCODE_TRUE:\r
            self.PostfixNotation = []\r
            return\r
\r
        # don't generate depex if all operands are architecture protocols\r
        if self.ModuleType in [SUP_MODULE_UEFI_DRIVER, SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_MM_STANDALONE] and \\r
           Op == DEPEX_OPCODE_AND and \\r
           self.ArchProtocols == set(GuidStructureStringToGuidString(Guid) for Guid in AllOperand):\r
            self.PostfixNotation = []\r
            return\r
\r
        if len(NewOperand) == 0:\r
            self.TokenList = list(AllOperand)\r
        else:\r
            self.TokenList = []\r
            while True:\r
                self.TokenList.append(NewOperand.pop(0))\r
                if NewOperand == []:\r
                    break\r
                self.TokenList.append(Op)\r
        self.PostfixNotation = []\r
        self.GetPostfixNotation()\r
\r
\r
    ## Convert a GUID value in C structure format into its binary form\r
    #\r
    #   @param  Guid    The GUID value in C structure format\r
    #\r
    #   @retval array   The byte array representing the GUID value\r
    #\r
    def GetGuidValue(self, Guid):\r
        GuidValueString = Guid.replace("{", "").replace("}", "").replace(" ", "")\r
        GuidValueList = GuidValueString.split(",")\r
        if len(GuidValueList) != 11 and len(GuidValueList) == 16:\r
            GuidValueString = GuidStringToGuidStructureString(GuidStructureByteArrayToGuidString(Guid))\r
            GuidValueString = GuidValueString.replace("{", "").replace("}", "").replace(" ", "")\r
            GuidValueList = GuidValueString.split(",")\r
        if len(GuidValueList) != 11:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid GUID value string or opcode: %s" % Guid)\r
        return pack("1I2H8B", *(int(value, 16) for value in GuidValueList))\r
\r
    ## Save the binary form of dependency expression in file\r
    #\r
    #   @param  File    The path of file. If None is given, put the data on console\r
    #\r
    #   @retval True    If the file doesn't exist or file is changed\r
    #   @retval False   If file exists and is not changed.\r
    #\r
    def Generate(self, File=None):\r
        Buffer = BytesIO()\r
        if len(self.PostfixNotation) == 0:\r
            return False\r
\r
        for Item in self.PostfixNotation:\r
            if Item in self.Opcode[self.Phase]:\r
                Buffer.write(pack("B", self.Opcode[self.Phase][Item]))\r
            elif Item in self.SupportedOpcode:\r
                EdkLogger.error("GenDepex", FORMAT_INVALID,\r
                                "Opcode [%s] is not expected in %s phase" % (Item, self.Phase),\r
                                ExtraData=self.ExpressionString)\r
            else:\r
                Buffer.write(self.GetGuidValue(Item))\r
\r
        FilePath = ""\r
        FileChangeFlag = True\r
        if File is None:\r
            sys.stdout.write(Buffer.getvalue())\r
            FilePath = "STDOUT"\r
        else:\r
            FileChangeFlag = SaveFileOnChange(File, Buffer.getvalue(), True)\r
\r
        Buffer.close()\r
        return FileChangeFlag\r
\r
versionNumber = ("0.04" + " " + gBUILD_VERSION)\r
__version__ = "%prog Version " + versionNumber\r
__copyright__ = "Copyright (c) 2007-2018, Intel Corporation  All rights reserved."\r
__usage__ = "%prog [options] [dependency_expression_file]"\r
\r
## Parse command line options\r
#\r
#   @retval OptionParser\r
#\r
def GetOptions():\r
    from optparse import OptionParser\r
\r
    Parser = OptionParser(description=__copyright__, version=__version__, usage=__usage__)\r
\r
    Parser.add_option("-o", "--output", dest="OutputFile", default=None, metavar="FILE",\r
                      help="Specify the name of depex file to be generated")\r
    Parser.add_option("-t", "--module-type", dest="ModuleType", default=None,\r
                      help="The type of module for which the dependency expression serves")\r
    Parser.add_option("-e", "--dependency-expression", dest="Expression", default="",\r
                      help="The string of dependency expression. If this option presents, the input file will be ignored.")\r
    Parser.add_option("-m", "--optimize", dest="Optimize", default=False, action="store_true",\r
                      help="Do some simple optimization on the expression.")\r
    Parser.add_option("-v", "--verbose", dest="verbose", default=False, action="store_true",\r
                      help="build with verbose information")\r
    Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
    Parser.add_option("-q", "--quiet", dest="quiet", default=False, action="store_true",\r
                      help="build with little information")\r
\r
    return Parser.parse_args()\r
\r
\r
## Entrance method\r
#\r
# @retval 0     Tool was successful\r
# @retval 1     Tool failed\r
#\r
def Main():\r
    EdkLogger.Initialize()\r
    Option, Input = GetOptions()\r
\r
    # Set log level\r
    if Option.quiet:\r
        EdkLogger.SetLevel(EdkLogger.QUIET)\r
    elif Option.verbose:\r
        EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
    elif Option.debug is not None:\r
        EdkLogger.SetLevel(Option.debug + 1)\r
    else:\r
        EdkLogger.SetLevel(EdkLogger.INFO)\r
\r
    try:\r
        if Option.ModuleType is None or Option.ModuleType not in gType2Phase:\r
            EdkLogger.error("GenDepex", OPTION_MISSING, "Module type is not specified or supported")\r
\r
        DxsFile = ''\r
        if len(Input) > 0 and Option.Expression == "":\r
            DxsFile = Input[0]\r
            DxsString = open(DxsFile, 'r').read().replace("\n", " ").replace("\r", " ")\r
            DxsString = gStartClosePattern.sub("\\1", DxsString)\r
        elif Option.Expression != "":\r
            if Option.Expression[0] == '"':\r
                DxsString = Option.Expression[1:-1]\r
            else:\r
                DxsString = Option.Expression\r
        else:\r
            EdkLogger.error("GenDepex", OPTION_MISSING, "No expression string or file given")\r
\r
        Dpx = DependencyExpression(DxsString, Option.ModuleType, Option.Optimize)\r
        if Option.OutputFile is not None:\r
            FileChangeFlag = Dpx.Generate(Option.OutputFile)\r
            if not FileChangeFlag and DxsFile:\r
                #\r
                # Touch the output file if its time stamp is older than the original\r
                # DXS file to avoid re-invoke this tool for the dependency check in build rule.\r
                #\r
                if os.stat(DxsFile)[8] > os.stat(Option.OutputFile)[8]:\r
                    os.utime(Option.OutputFile, None)\r
        else:\r
            Dpx.Generate()\r
    except BaseException as X:\r
        EdkLogger.quiet("")\r
        if Option is not None and Option.debug is not None:\r
            EdkLogger.quiet(traceback.format_exc())\r
        else:\r
            EdkLogger.quiet(str(X))\r
        return 1\r
\r
    return 0\r
\r
if __name__ == '__main__':\r
    sys.exit(Main())\r
\r