BaseTools/Source/Python/AutoGen/ValidCheckingInfoObject.py

   1 # Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>
   2 # SPDX-License-Identifier: BSD-2-Clause-Patent
   3
   4 #
   5 # This file is used to collect the Variable checking information
   6 #
   7
   8 # #
   9 # Import Modules
  10 #
  11 import os
  12 from Common.RangeExpression import RangeExpression
  13 from Common.Misc import *
  14 from io import BytesIO
  15 from struct import pack
  16 from Common.DataType import *
  17
  18 class VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER(object):
  19     def __init__(self):
  20         self.var_check_info = []
  21
  22     def push_back(self, var_check_tab):
  23         for tab in self.var_check_info:
  24             if tab.equal(var_check_tab):
  25                 tab.merge(var_check_tab)
  26                 break
  27         else:
  28             self.var_check_info.append(var_check_tab)
  29
  30     def dump(self, dest, Phase):
  31
  32         if not os.path.isabs(dest):
  33             return
  34         if not os.path.exists(dest):
  35             os.mkdir(dest)
  36         BinFileName = "PcdVarCheck.bin"
  37         BinFilePath = os.path.join(dest, BinFileName)
  38         Buffer = bytearray()
  39         index = 0
  40         for var_check_tab in self.var_check_info:
  41             index += 1
  42             realLength = 0
  43             realLength += 32
  44             Name = var_check_tab.Name[1:-1]
  45             NameChars = Name.split(",")
  46             realLength += len(NameChars)
  47             if (index < len(self.var_check_info) and realLength % 4) or (index == len(self.var_check_info) and len(var_check_tab.validtab) > 0 and realLength % 4):
  48                 realLength += (4 - (realLength % 4))
  49             itemIndex = 0
  50             for item in var_check_tab.validtab:
  51                 itemIndex += 1
  52                 realLength += 5
  53                 for v_data in item.data:
  54                     if isinstance(v_data, int):
  55                         realLength += item.StorageWidth
  56                     else:
  57                         realLength += item.StorageWidth
  58                         realLength += item.StorageWidth
  59                 if (index == len(self.var_check_info)) :
  60                     if (itemIndex < len(var_check_tab.validtab)) and realLength % 4:
  61                         realLength += (4 - (realLength % 4))
  62                 else:
  63                     if realLength % 4:
  64                         realLength += (4 - (realLength % 4))
  65             var_check_tab.Length = realLength
  66         realLength = 0
  67         index = 0
  68         for var_check_tab in self.var_check_info:
  69             index += 1
  70
  71             b = pack("=H", var_check_tab.Revision)
  72             Buffer += b
  73             realLength += 2
  74
  75             b = pack("=H", var_check_tab.HeaderLength)
  76             Buffer += b
  77             realLength += 2
  78
  79             b = pack("=L", var_check_tab.Length)
  80             Buffer += b
  81             realLength += 4
  82
  83             b = pack("=B", var_check_tab.Type)
  84             Buffer += b
  85             realLength += 1
  86
  87             for i in range(0, 3):
  88                 b = pack("=B", var_check_tab.Reserved)
  89                 Buffer += b
  90                 realLength += 1
  91
  92             b = pack("=L", var_check_tab.Attributes)
  93             Buffer += b
  94             realLength += 4
  95
  96             Guid = var_check_tab.Guid
  97             b = PackByteFormatGUID(Guid)
  98             Buffer += b
  99             realLength += 16
 100
 101             Name = var_check_tab.Name[1:-1]
 102             NameChars = Name.split(",")
 103             for NameChar in NameChars:
 104                 NameCharNum = int(NameChar, 16)
 105                 b = pack("=B", NameCharNum)
 106                 Buffer += b
 107                 realLength += 1
 108
 109             if (index < len(self.var_check_info) and realLength % 4) or (index == len(self.var_check_info) and len(var_check_tab.validtab) > 0 and realLength % 4):
 110                 for i in range(4 - (realLength % 4)):
 111                     b = pack("=B", var_check_tab.pad)
 112                     Buffer += b
 113                     realLength += 1
 114             itemIndex = 0
 115             for item in var_check_tab.validtab:
 116                 itemIndex += 1
 117
 118                 b = pack("=B", item.Type)
 119                 Buffer += b
 120                 realLength += 1
 121
 122                 b = pack("=B", item.Length)
 123                 Buffer += b
 124                 realLength += 1
 125
 126                 b = pack("=H", int(item.VarOffset, 16))
 127                 Buffer += b
 128                 realLength += 2
 129
 130                 b = pack("=B", item.StorageWidth)
 131                 Buffer += b
 132                 realLength += 1
 133                 for v_data in item.data:
 134                     if isinstance(v_data, int):
 135                         b = pack(PACK_CODE_BY_SIZE[item.StorageWidth], v_data)
 136                         Buffer += b
 137                         realLength += item.StorageWidth
 138                     else:
 139                         b = pack(PACK_CODE_BY_SIZE[item.StorageWidth], v_data[0])
 140                         Buffer += b
 141                         realLength += item.StorageWidth
 142                         b = pack(PACK_CODE_BY_SIZE[item.StorageWidth], v_data[1])
 143                         Buffer += b
 144                         realLength += item.StorageWidth
 145
 146                 if (index == len(self.var_check_info)) :
 147                     if (itemIndex < len(var_check_tab.validtab)) and realLength % 4:
 148                         for i in range(4 - (realLength % 4)):
 149                             b = pack("=B", var_check_tab.pad)
 150                             Buffer += b
 151                             realLength += 1
 152                 else:
 153                     if realLength % 4:
 154                         for i in range(4 - (realLength % 4)):
 155                             b = pack("=B", var_check_tab.pad)
 156                             Buffer += b
 157                             realLength += 1
 158
 159         DbFile = BytesIO()
 160         if Phase == 'DXE' and os.path.exists(BinFilePath):
 161             BinFile = open(BinFilePath, "rb")
 162             BinBuffer = BinFile.read()
 163             BinFile.close()
 164             BinBufferSize = len(BinBuffer)
 165             if (BinBufferSize % 4):
 166                 for i in range(4 - (BinBufferSize % 4)):
 167                     b = pack("=B", VAR_CHECK_PCD_VARIABLE_TAB.pad)
 168                     BinBuffer += b
 169             Buffer = BinBuffer + Buffer
 170         DbFile.write(Buffer)
 171         SaveFileOnChange(BinFilePath, DbFile.getvalue(), True)
 172
 173
 174 class VAR_CHECK_PCD_VARIABLE_TAB(object):
 175     pad = 0xDA
 176     def __init__(self, TokenSpaceGuid, PcdCName):
 177         self.Revision = 0x0001
 178         self.HeaderLength = 0
 179         self.Length = 0  # Length include this header
 180         self.Type = 0
 181         self.Reserved = 0
 182         self.Attributes = 0x00000000
 183         self.Guid = eval("[" + TokenSpaceGuid.replace("{", "").replace("}", "") + "]")
 184         self.Name = PcdCName
 185         self.validtab = []
 186
 187     def UpdateSize(self):
 188         self.HeaderLength = 32 + len(self.Name.split(","))
 189         self.Length = 32 + len(self.Name.split(",")) + self.GetValidTabLen()
 190
 191     def GetValidTabLen(self):
 192         validtablen = 0
 193         for item in self.validtab:
 194             validtablen += item.Length
 195         return validtablen
 196
 197     def SetAttributes(self, attributes):
 198         self.Attributes = attributes
 199
 200     def push_back(self, valid_obj):
 201         if valid_obj is not None:
 202             self.validtab.append(valid_obj)
 203
 204     def equal(self, varchecktab):
 205         if self.Guid == varchecktab.Guid and self.Name == varchecktab.Name:
 206             return True
 207         else:
 208             return False
 209
 210     def merge(self, varchecktab):
 211         for validobj in varchecktab.validtab:
 212             if validobj in self.validtab:
 213                 continue
 214             self.validtab.append(validobj)
 215         self.UpdateSize()
 216
 217
 218 class VAR_CHECK_PCD_VALID_OBJ(object):
 219     def __init__(self, VarOffset, data, PcdDataType):
 220         self.Type = 1
 221         self.Length = 0  # Length include this header
 222         self.VarOffset = VarOffset
 223         self.PcdDataType = PcdDataType.strip()
 224         self.rawdata = data
 225         self.data = set()
 226         try:
 227             self.StorageWidth = MAX_SIZE_TYPE[self.PcdDataType]
 228             self.ValidData = True
 229         except:
 230             self.StorageWidth = 0
 231             self.ValidData = False
 232
 233     def __eq__(self, validObj):
 234         return validObj and self.VarOffset == validObj.VarOffset
 235
 236 class VAR_CHECK_PCD_VALID_LIST(VAR_CHECK_PCD_VALID_OBJ):
 237     def __init__(self, VarOffset, validlist, PcdDataType):
 238         super(VAR_CHECK_PCD_VALID_LIST, self).__init__(VarOffset, validlist, PcdDataType)
 239         self.Type = 1
 240         valid_num_list = []
 241         for item in self.rawdata:
 242             valid_num_list.extend(item.split(','))
 243
 244         for valid_num in valid_num_list:
 245             valid_num = valid_num.strip()
 246
 247             if valid_num.startswith('0x') or valid_num.startswith('0X'):
 248                 self.data.add(int(valid_num, 16))
 249             else:
 250                 self.data.add(int(valid_num))
 251
 252
 253         self.Length = 5 + len(self.data) * self.StorageWidth
 254
 255
 256 class VAR_CHECK_PCD_VALID_RANGE(VAR_CHECK_PCD_VALID_OBJ):
 257     def __init__(self, VarOffset, validrange, PcdDataType):
 258         super(VAR_CHECK_PCD_VALID_RANGE, self).__init__(VarOffset, validrange, PcdDataType)
 259         self.Type = 2
 260         RangeExpr = ""
 261         i = 0
 262         for item in self.rawdata:
 263             if i == 0:
 264                 RangeExpr = "( " + item + " )"
 265             else:
 266                 RangeExpr = RangeExpr + "OR ( " + item + " )"
 267         range_result = RangeExpression(RangeExpr, self.PcdDataType)(True)
 268         for rangelist in range_result:
 269             for obj in rangelist.pop():
 270                 self.data.add((obj.start, obj.end))
 271         self.Length = 5 + len(self.data) * 2 * self.StorageWidth
 272
 273
 274 def GetValidationObject(PcdClass, VarOffset):
 275     if PcdClass.validateranges:
 276         return VAR_CHECK_PCD_VALID_RANGE(VarOffset, PcdClass.validateranges, PcdClass.DatumType)
 277     if PcdClass.validlists:
 278         return VAR_CHECK_PCD_VALID_LIST(VarOffset, PcdClass.validlists, PcdClass.DatumType)
 279     else:
 280         return None