From b1e959ec4d4dc3f9ea4155148eed88c69139bac3 Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 27 Feb 2018 08:14:42 +0000 Subject: [PATCH 01/10] acpi: define list of AML opcodes The list provides a uniform mapping for regular (one byte), extended (0x1b + one byte) opcodes as well as some "internal" opcodes that will be used by the parser to represent method calls, named fields and resolved named object references. --- .../device/acpi/aml/parser_opcode_table.go | 132 ++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 src/gopheros/device/acpi/aml/parser_opcode_table.go diff --git a/src/gopheros/device/acpi/aml/parser_opcode_table.go b/src/gopheros/device/acpi/aml/parser_opcode_table.go new file mode 100644 index 0000000..66e5ef2 --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser_opcode_table.go @@ -0,0 +1,132 @@ +package aml + +// List of AML opcodes. +const ( + // Regular opcode list + pOpZero = uint16(0x00) + pOpOne = uint16(0x01) + pOpAlias = uint16(0x06) + pOpName = uint16(0x08) + pOpBytePrefix = uint16(0x0a) + pOpWordPrefix = uint16(0x0b) + pOpDwordPrefix = uint16(0x0c) + pOpStringPrefix = uint16(0x0d) + pOpQwordPrefix = uint16(0x0e) + pOpScope = uint16(0x10) + pOpBuffer = uint16(0x11) + pOpPackage = uint16(0x12) + pOpVarPackage = uint16(0x13) + pOpMethod = uint16(0x14) + pOpExternal = uint16(0x15) + pOpLocal0 = uint16(0x60) + pOpLocal1 = uint16(0x61) + pOpLocal2 = uint16(0x62) + pOpLocal3 = uint16(0x63) + pOpLocal4 = uint16(0x64) + pOpLocal5 = uint16(0x65) + pOpLocal6 = uint16(0x66) + pOpLocal7 = uint16(0x67) + pOpArg0 = uint16(0x68) + pOpArg1 = uint16(0x69) + pOpArg2 = uint16(0x6a) + pOpArg3 = uint16(0x6b) + pOpArg4 = uint16(0x6c) + pOpArg5 = uint16(0x6d) + pOpArg6 = uint16(0x6e) + pOpStore = uint16(0x70) + pOpRefOf = uint16(0x71) + pOpAdd = uint16(0x72) + pOpConcat = uint16(0x73) + pOpSubtract = uint16(0x74) + pOpIncrement = uint16(0x75) + pOpDecrement = uint16(0x76) + pOpMultiply = uint16(0x77) + pOpDivide = uint16(0x78) + pOpShiftLeft = uint16(0x79) + pOpShiftRight = uint16(0x7a) + pOpAnd = uint16(0x7b) + pOpNand = uint16(0x7c) + pOpOr = uint16(0x7d) + pOpNor = uint16(0x7e) + pOpXor = uint16(0x7f) + pOpNot = uint16(0x80) + pOpFindSetLeftBit = uint16(0x81) + pOpFindSetRightBit = uint16(0x82) + pOpDerefOf = uint16(0x83) + pOpConcatRes = uint16(0x84) + pOpMod = uint16(0x85) + pOpNotify = uint16(0x86) + pOpSizeOf = uint16(0x87) + pOpIndex = uint16(0x88) + pOpMatch = uint16(0x89) + pOpCreateDWordField = uint16(0x8a) + pOpCreateWordField = uint16(0x8b) + pOpCreateByteField = uint16(0x8c) + pOpCreateBitField = uint16(0x8d) + pOpObjectType = uint16(0x8e) + pOpCreateQWordField = uint16(0x8f) + pOpLand = uint16(0x90) + pOpLor = uint16(0x91) + pOpLnot = uint16(0x92) + pOpLEqual = uint16(0x93) + pOpLGreater = uint16(0x94) + pOpLLess = uint16(0x95) + pOpToBuffer = uint16(0x96) + pOpToDecimalString = uint16(0x97) + pOpToHexString = uint16(0x98) + pOpToInteger = uint16(0x99) + pOpToString = uint16(0x9c) + pOpCopyObject = uint16(0x9d) + pOpMid = uint16(0x9e) + pOpContinue = uint16(0x9f) + pOpIf = uint16(0xa0) + pOpElse = uint16(0xa1) + pOpWhile = uint16(0xa2) + pOpNoop = uint16(0xa3) + pOpReturn = uint16(0xa4) + pOpBreak = uint16(0xa5) + pOpBreakPoint = uint16(0xcc) + pOpOnes = uint16(0xff) + // Extended opcodes + pOpMutex = uint16(0xff + 0x01) + pOpEvent = uint16(0xff + 0x02) + pOpCondRefOf = uint16(0xff + 0x12) + pOpCreateField = uint16(0xff + 0x13) + pOpLoadTable = uint16(0xff + 0x1f) + pOpLoad = uint16(0xff + 0x20) + pOpStall = uint16(0xff + 0x21) + pOpSleep = uint16(0xff + 0x22) + pOpAcquire = uint16(0xff + 0x23) + pOpSignal = uint16(0xff + 0x24) + pOpWait = uint16(0xff + 0x25) + pOpReset = uint16(0xff + 0x26) + pOpRelease = uint16(0xff + 0x27) + pOpFromBCD = uint16(0xff + 0x28) + pOpToBCD = uint16(0xff + 0x29) + pOpUnload = uint16(0xff + 0x2a) + pOpRevision = uint16(0xff + 0x30) + pOpDebug = uint16(0xff + 0x31) + pOpFatal = uint16(0xff + 0x32) + pOpTimer = uint16(0xff + 0x33) + pOpOpRegion = uint16(0xff + 0x80) + pOpField = uint16(0xff + 0x81) + pOpDevice = uint16(0xff + 0x82) + pOpProcessor = uint16(0xff + 0x83) + pOpPowerRes = uint16(0xff + 0x84) + pOpThermalZone = uint16(0xff + 0x85) + pOpIndexField = uint16(0xff + 0x86) + pOpBankField = uint16(0xff + 0x87) + pOpDataRegion = uint16(0xff + 0x88) + // Special internal opcodes which are not part of the spec; these are + // for internal use by the AML parser. + pOpIntScopeBlock = uint16(0xff + 0xf7) + pOpIntByteList = uint16(0xff + 0xf8) + pOpIntConnection = uint16(0xff + 0xf9) + pOpIntNamedField = uint16(0xff + 0xfa) + pOpIntResolvedNamePath = uint16(0xff + 0xfb) + pOpIntNamePath = uint16(0xff + 0xfc) + pOpIntNamePathOrMethodCall = uint16(0xff + 0xfd) + pOpIntMethodCall = uint16(0xff + 0xfe) + // Sentinel value to indicate freed objects + pOpIntFreedObject = uint16(0xff + 0xff) +) From ca1682c431d4ff051b56f6b5f77c49db2f756112 Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 27 Feb 2018 08:37:55 +0000 Subject: [PATCH 02/10] acpi: define helper functions for working with opcode groups --- .../device/acpi/aml/parser_opcode_table.go | 66 +++++++++++ .../acpi/aml/parser_opcode_table_test.go | 108 ++++++++++++++++++ 2 files changed, 174 insertions(+) create mode 100644 src/gopheros/device/acpi/aml/parser_opcode_table_test.go diff --git a/src/gopheros/device/acpi/aml/parser_opcode_table.go b/src/gopheros/device/acpi/aml/parser_opcode_table.go index 66e5ef2..c1c43f8 100644 --- a/src/gopheros/device/acpi/aml/parser_opcode_table.go +++ b/src/gopheros/device/acpi/aml/parser_opcode_table.go @@ -130,3 +130,69 @@ const ( // Sentinel value to indicate freed objects pOpIntFreedObject = uint16(0xff + 0xff) ) + +// pOpIsLocalArg returns true if this opcode represents any of the supported local +// function args 0 to 7. +func pOpIsLocalArg(op uint16) bool { + return op >= pOpLocal0 && op <= pOpLocal7 +} + +// pOpIsMethodArg returns true if this opcode represents any of the supported +// input function args 0 to 6. +func pOpIsMethodArg(op uint16) bool { + return op >= pOpArg0 && op <= pOpArg6 +} + +// pOpIsArg returns true if this opcode is either a local or a method arg. +func pOpIsArg(op uint16) bool { + return pOpIsLocalArg(op) || pOpIsMethodArg(op) +} + +// pOpIsType2 returns true if this is a Type2Opcode. +// +// Grammar: +// Type2Opcode := DefAcquire | DefAdd | DefAnd | DefBuffer | DefConcat | +// DefConcatRes | DefCondRefOf | DefCopyObject | DefDecrement | +// DefDerefOf | DefDivide | DefFindSetLeftBit | DefFindSetRightBit | +// DefFromBCD | DefIncrement | DefIndex | DefLAnd | DefLEqual | +// DefLGreater | DefLGreaterEqual | DefLLess | DefLLessEqual | DefMid | +// DefLNot | DefLNotEqual | DefLoadTable | DefLOr | DefMatch | DefMod | +// DefMultiply | DefNAnd | DefNOr | DefNot | DefObjectType | DefOr | +// DefPackage | DefVarPackage | DefRefOf | DefShiftLeft | DefShiftRight | +// DefSizeOf | DefStore | DefSubtract | DefTimer | DefToBCD | DefToBuffer | +// DefToDecimalString | DefToHexString | DefToInteger | DefToString | +// DefWait | DefXOr +func pOpIsType2(op uint16) bool { + switch op { + case pOpAcquire, pOpAdd, pOpAnd, pOpBuffer, pOpConcat, + pOpConcatRes, pOpCondRefOf, pOpCopyObject, pOpDecrement, + pOpDerefOf, pOpDivide, pOpFindSetLeftBit, pOpFindSetRightBit, + pOpFromBCD, pOpIncrement, pOpIndex, pOpLand, pOpLEqual, + pOpLGreater, pOpLLess, pOpMid, + pOpLnot, pOpLoadTable, pOpLor, pOpMatch, pOpMod, + pOpMultiply, pOpNand, pOpNor, pOpNot, pOpObjectType, pOpOr, + pOpPackage, pOpVarPackage, pOpRefOf, pOpShiftLeft, pOpShiftRight, + pOpSizeOf, pOpStore, pOpSubtract, pOpTimer, pOpToBCD, pOpToBuffer, + pOpToDecimalString, pOpToHexString, pOpToInteger, pOpToString, + pOpWait, pOpXor: + return true + default: + return false + } +} + +// pOpIsDataObject returns true if this opcode is part of a DataObject definition +// +// Grammar: +// DataObject := ComputationalData | DefPackage | DefVarPackage +// ComputationalData := ByteConst | WordConst | DWordConst | QWordConst | String | ConstObj | RevisionOp | DefBuffer +// ConstObj := ZeroOp | OneOp | OnesOp +func pOpIsDataObject(op uint16) bool { + switch op { + case pOpBytePrefix, pOpWordPrefix, pOpDwordPrefix, pOpQwordPrefix, pOpStringPrefix, + pOpZero, pOpOne, pOpOnes, pOpRevision, pOpBuffer, pOpPackage, pOpVarPackage: + return true + default: + return false + } +} diff --git a/src/gopheros/device/acpi/aml/parser_opcode_table_test.go b/src/gopheros/device/acpi/aml/parser_opcode_table_test.go new file mode 100644 index 0000000..faa1c00 --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser_opcode_table_test.go @@ -0,0 +1,108 @@ +package aml + +import "testing" + +func TestOpcodeIsX(t *testing.T) { + specs := []struct { + op uint16 + testFn func(uint16) bool + want bool + }{ + // OpIsLocalArg + {pOpLocal0, pOpIsLocalArg, true}, + {pOpLocal1, pOpIsLocalArg, true}, + {pOpLocal2, pOpIsLocalArg, true}, + {pOpLocal3, pOpIsLocalArg, true}, + {pOpLocal4, pOpIsLocalArg, true}, + {pOpLocal5, pOpIsLocalArg, true}, + {pOpLocal6, pOpIsLocalArg, true}, + {pOpLocal7, pOpIsLocalArg, true}, + {pOpArg0, pOpIsLocalArg, false}, + {pOpDivide, pOpIsLocalArg, false}, + // OpIsMethodArg + {pOpArg0, pOpIsMethodArg, true}, + {pOpArg1, pOpIsMethodArg, true}, + {pOpArg2, pOpIsMethodArg, true}, + {pOpArg3, pOpIsMethodArg, true}, + {pOpArg4, pOpIsMethodArg, true}, + {pOpArg5, pOpIsMethodArg, true}, + {pOpArg6, pOpIsMethodArg, true}, + {pOpLocal7, pOpIsMethodArg, false}, + {pOpIf, pOpIsMethodArg, false}, + // OpIsArg + {pOpLocal5, pOpIsArg, true}, + {pOpArg1, pOpIsArg, true}, + {pOpDivide, pOpIsArg, false}, + // OpIsType2 + {pOpAcquire, pOpIsType2, true}, + {pOpAdd, pOpIsType2, true}, + {pOpAnd, pOpIsType2, true}, + {pOpBuffer, pOpIsType2, true}, + {pOpConcat, pOpIsType2, true}, + {pOpConcatRes, pOpIsType2, true}, + {pOpCondRefOf, pOpIsType2, true}, + {pOpCopyObject, pOpIsType2, true}, + {pOpDecrement, pOpIsType2, true}, + {pOpDerefOf, pOpIsType2, true}, + {pOpDivide, pOpIsType2, true}, + {pOpFindSetLeftBit, pOpIsType2, true}, + {pOpFindSetRightBit, pOpIsType2, true}, + {pOpFromBCD, pOpIsType2, true}, + {pOpIncrement, pOpIsType2, true}, + {pOpIndex, pOpIsType2, true}, + {pOpLand, pOpIsType2, true}, + {pOpLEqual, pOpIsType2, true}, + {pOpLGreater, pOpIsType2, true}, + {pOpLLess, pOpIsType2, true}, + {pOpMid, pOpIsType2, true}, + {pOpLnot, pOpIsType2, true}, + {pOpLoadTable, pOpIsType2, true}, + {pOpLor, pOpIsType2, true}, + {pOpMatch, pOpIsType2, true}, + {pOpMod, pOpIsType2, true}, + {pOpMultiply, pOpIsType2, true}, + {pOpNand, pOpIsType2, true}, + {pOpNor, pOpIsType2, true}, + {pOpNot, pOpIsType2, true}, + {pOpObjectType, pOpIsType2, true}, + {pOpOr, pOpIsType2, true}, + {pOpPackage, pOpIsType2, true}, + {pOpVarPackage, pOpIsType2, true}, + {pOpRefOf, pOpIsType2, true}, + {pOpShiftLeft, pOpIsType2, true}, + {pOpShiftRight, pOpIsType2, true}, + {pOpSizeOf, pOpIsType2, true}, + {pOpStore, pOpIsType2, true}, + {pOpSubtract, pOpIsType2, true}, + {pOpTimer, pOpIsType2, true}, + {pOpToBCD, pOpIsType2, true}, + {pOpToBuffer, pOpIsType2, true}, + {pOpToDecimalString, pOpIsType2, true}, + {pOpToHexString, pOpIsType2, true}, + {pOpToInteger, pOpIsType2, true}, + {pOpToString, pOpIsType2, true}, + {pOpWait, pOpIsType2, true}, + {pOpXor, pOpIsType2, true}, + {pOpBytePrefix, pOpIsType2, false}, + // OpIsDataObject + {pOpBytePrefix, pOpIsDataObject, true}, + {pOpWordPrefix, pOpIsDataObject, true}, + {pOpDwordPrefix, pOpIsDataObject, true}, + {pOpQwordPrefix, pOpIsDataObject, true}, + {pOpStringPrefix, pOpIsDataObject, true}, + {pOpZero, pOpIsDataObject, true}, + {pOpOne, pOpIsDataObject, true}, + {pOpOnes, pOpIsDataObject, true}, + {pOpRevision, pOpIsDataObject, true}, + {pOpBuffer, pOpIsDataObject, true}, + {pOpPackage, pOpIsDataObject, true}, + {pOpVarPackage, pOpIsDataObject, true}, + {pOpLor, pOpIsDataObject, false}, + } + + for specIndex, spec := range specs { + if got := spec.testFn(spec.op); got != spec.want { + t.Errorf("[spec %d] opcode %q: expected to get %t; got %t", specIndex, spec.op, spec.want, got) + } + } +} From 851011f957e2d2b76b75cb706a7d78f199c2da71 Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 27 Feb 2018 08:38:55 +0000 Subject: [PATCH 03/10] acpi: define parser tables for decoding AML opcodes The opcode tables establish a 2-level mapping between AML opcodes (regular or extended) and a secondary table that allows the parser to decode each opcode. This information includes: - the opcode name - the opcode flags (e.g. specifies a named object or parsing must be deferred to a later pass) - the expected arguments for each opcode and their types. --- .../device/acpi/aml/parser_opcode_table.go | 329 ++++++++++++++++++ .../acpi/aml/parser_opcode_table_test.go | 35 ++ 2 files changed, 364 insertions(+) diff --git a/src/gopheros/device/acpi/aml/parser_opcode_table.go b/src/gopheros/device/acpi/aml/parser_opcode_table.go index c1c43f8..74bb7f9 100644 --- a/src/gopheros/device/acpi/aml/parser_opcode_table.go +++ b/src/gopheros/device/acpi/aml/parser_opcode_table.go @@ -196,3 +196,332 @@ func pOpIsDataObject(op uint16) bool { return false } } + +const ( + badOpcode = 0xff + extOpPrefix = 0x5b +) + +// pOpFlag specifies a list of OR-able flags that describe the object +// type/attributes generated by a particular opcode. +type pOpFlag uint8 + +const ( + pOpFlagNamed = 1 << iota + pOpFlagConstant + pOpFlagReference + pOpFlagCreate + pOpFlagExecutable + pOpFlagScoped + pOpFlagDeferParsing +) + +// pOpArgTypeList encodes up to 7 opArgFlag values in a uint64 value. +type pOpArgTypeList uint64 + +// argCount returns the number of encoded args in the given arg type list. +func (fl pOpArgTypeList) argCount() (count uint8) { + // Each argument is specified using 8 bits with 0x0 indicating the end of the + // argument list + for ; fl&0xf != 0; fl, count = fl>>8, count+1 { + } + + return count +} + +// arg returns the arg type for argument "num" where num is the 0-based index +// of the argument to return. The allowed values for num are 0-6. +func (fl pOpArgTypeList) arg(num uint8) pArgType { + return pArgType((fl >> (num * 8)) & 0xf) +} + +// pArgType represents the type of an argument expected by a particular opcode. +type pArgType uint8 + +// The list of supported opArgFlag values. +const ( + _ pArgType = iota + pArgTypeTermList + pArgTypeTermArg + pArgTypeByteList + pArgTypeString + pArgTypeByteData + pArgTypeWordData + pArgTypeDwordData + pArgTypeQwordData + pArgTypeNameString + pArgTypeSuperName + pArgTypeSimpleName + pArgTypeDataRefObj + pArgTypeTarget + pArgTypeFieldList + pArgTypePkgLen +) + +func makeArg0() pOpArgTypeList { return 0 } +func makeArg1(arg0 pArgType) pOpArgTypeList { return pOpArgTypeList(arg0) } +func makeArg2(arg0, arg1 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg3(arg0, arg1, arg2 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg4(arg0, arg1, arg2, arg3 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg3)<<24 | pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg5(arg0, arg1, arg2, arg3, arg4 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg4)<<32 | pOpArgTypeList(arg3)<<24 | pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg6(arg0, arg1, arg2, arg3, arg4, arg5 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg5)<<40 | pOpArgTypeList(arg4)<<32 | pOpArgTypeList(arg3)<<24 | pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} +func makeArg7(arg0, arg1, arg2, arg3, arg4, arg5, arg6 pArgType) pOpArgTypeList { + return pOpArgTypeList(arg6)<<48 | pOpArgTypeList(arg5)<<40 | pOpArgTypeList(arg4)<<32 | pOpArgTypeList(arg3)<<24 | pOpArgTypeList(arg2)<<16 | pOpArgTypeList(arg1)<<8 | pOpArgTypeList(arg0) +} + +// pOpcodeInfo contains all known information about an opcode, +// its argument count and types as well as the type of object +// represented by it. +type pOpcodeInfo struct { + op uint16 + opName string + + flags pOpFlag + argFlags pOpArgTypeList +} + +// The opcode table contains all opcode-related information that the parser knows. +// This table is modeled after a similar table used in the acpica implementation. +var pOpcodeTable = []pOpcodeInfo{ + /*0x00*/ {pOpZero, "Zero", pOpFlagConstant, makeArg0()}, + /*0x01*/ {pOpOne, "One", pOpFlagConstant, makeArg0()}, + /*0x02*/ {pOpAlias, "Alias", pOpFlagNamed, makeArg2(pArgTypeNameString, pArgTypeNameString)}, + /*0x03*/ {pOpName, "Name", pOpFlagNamed, makeArg2(pArgTypeNameString, pArgTypeDataRefObj)}, + /*0x04*/ {pOpBytePrefix, "BytePrefix", pOpFlagConstant, makeArg1(pArgTypeByteData)}, + /*0x05*/ {pOpWordPrefix, "WordPrefix", pOpFlagConstant, makeArg1(pArgTypeWordData)}, + /*0x06*/ {pOpDwordPrefix, "DwordPrefix", pOpFlagConstant, makeArg1(pArgTypeDwordData)}, + /*0x07*/ {pOpStringPrefix, "StringPrefix", pOpFlagConstant, makeArg1(pArgTypeString)}, + /*0x08*/ {pOpQwordPrefix, "QwordPrefix", pOpFlagConstant, makeArg1(pArgTypeQwordData)}, + /*0x09*/ {pOpScope, "Scope", 0, makeArg3(pArgTypePkgLen, pArgTypeNameString, pArgTypeTermList)}, + /*0x0a*/ {pOpBuffer, "Buffer", pOpFlagDeferParsing | pOpFlagCreate, makeArg3(pArgTypePkgLen, pArgTypeTermArg, pArgTypeByteList)}, + /*0x0b*/ {pOpPackage, "Package", pOpFlagCreate, makeArg3(pArgTypePkgLen, pArgTypeByteData, pArgTypeTermList)}, + /*0x0c*/ {pOpVarPackage, "VarPackage", pOpFlagCreate, makeArg3(pArgTypePkgLen, pArgTypeByteData, pArgTypeTermList)}, + /*0x0d*/ {pOpMethod, "Method", pOpFlagNamed | pOpFlagScoped, makeArg4(pArgTypePkgLen, pArgTypeNameString, pArgTypeByteData, pArgTypeTermList)}, + /*0x0e*/ {pOpExternal, "External", pOpFlagNamed, makeArg3(pArgTypeNameString, pArgTypeByteData, pArgTypeByteData)}, + /*0x0f*/ {pOpLocal0, "Local0", pOpFlagExecutable, makeArg0()}, + /*0x10*/ {pOpLocal1, "Local1", pOpFlagExecutable, makeArg0()}, + /*0x11*/ {pOpLocal2, "Local2", pOpFlagExecutable, makeArg0()}, + /*0x12*/ {pOpLocal3, "Local3", pOpFlagExecutable, makeArg0()}, + /*0x13*/ {pOpLocal4, "Local4", pOpFlagExecutable, makeArg0()}, + /*0120*/ {pOpLocal5, "Local5", pOpFlagExecutable, makeArg0()}, + /*0x15*/ {pOpLocal6, "Local6", pOpFlagExecutable, makeArg0()}, + /*0x16*/ {pOpLocal7, "Local7", pOpFlagExecutable, makeArg0()}, + /*0x17*/ {pOpArg0, "Arg0", pOpFlagExecutable, makeArg0()}, + /*0x18*/ {pOpArg1, "Arg1", pOpFlagExecutable, makeArg0()}, + /*0x19*/ {pOpArg2, "Arg2", pOpFlagExecutable, makeArg0()}, + /*0x1a*/ {pOpArg3, "Arg3", pOpFlagExecutable, makeArg0()}, + /*0x1b*/ {pOpArg4, "Arg4", pOpFlagExecutable, makeArg0()}, + /*0x1c*/ {pOpArg5, "Arg5", pOpFlagExecutable, makeArg0()}, + /*0x1d*/ {pOpArg6, "Arg6", pOpFlagExecutable, makeArg0()}, + /*0x1e*/ {pOpStore, "Store", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeSuperName)}, + /*0x1f*/ {pOpRefOf, "RefOf", pOpFlagReference | pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x20*/ {pOpAdd, "Add", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x21*/ {pOpConcat, "Concat", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x22*/ {pOpSubtract, "Subtract", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x23*/ {pOpIncrement, "Increment", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x24*/ {pOpDecrement, "Decrement", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x25*/ {pOpMultiply, "Multiply", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x26*/ {pOpDivide, "Divide", pOpFlagExecutable, makeArg4(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget, pArgTypeTarget)}, + /*0x27*/ {pOpShiftLeft, "ShiftLeft", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x28*/ {pOpShiftRight, "ShiftRight", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x29*/ {pOpAnd, "And", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2a*/ {pOpNand, "Nand", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2b*/ {pOpOr, "Or", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2c*/ {pOpNor, "Nor", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2d*/ {pOpXor, "Xor", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x2e*/ {pOpNot, "Not", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x2f*/ {pOpFindSetLeftBit, "FindSetLeftBit", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x30*/ {pOpFindSetRightBit, "FindSetRightBit", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x31*/ {pOpDerefOf, "DerefOf", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x32*/ {pOpConcatRes, "ConcatRes", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x33*/ {pOpMod, "Mod", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x34*/ {pOpNotify, "Notify", pOpFlagExecutable, makeArg2(pArgTypeSuperName, pArgTypeTermArg)}, + /*0x35*/ {pOpSizeOf, "SizeOf", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x36*/ {pOpIndex, "Index", pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x37*/ {pOpMatch, "Match", pOpFlagExecutable, makeArg6(pArgTypeTermArg, pArgTypeByteData, pArgTypeTermArg, pArgTypeByteData, pArgTypeTermArg, pArgTypeTermArg)}, + /*0x38*/ {pOpCreateDWordField, "CreateDWordField", pOpFlagCreate | pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x39*/ {pOpCreateWordField, "CreateWordField", pOpFlagCreate | pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x3a*/ {pOpCreateByteField, "CreateByteField", pOpFlagCreate | pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x3b*/ {pOpCreateBitField, "CreateBitField", pOpFlagCreate | pOpFlagExecutable, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x3c*/ {pOpObjectType, "ObjectType", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x3d*/ {pOpCreateQWordField, "CreateQWordField", pOpFlagCreate, makeArg3(pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x3e*/ {pOpLand, "Land", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x3f*/ {pOpLor, "Lor", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x40*/ {pOpLnot, "Lnot", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x41*/ {pOpLEqual, "LEqual", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x42*/ {pOpLGreater, "LGreater", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x43*/ {pOpLLess, "LLess", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTermArg)}, + /*0x44*/ {pOpToBuffer, "ToBuffer", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x45*/ {pOpToDecimalString, "ToDecimalString", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x46*/ {pOpToHexString, "ToHexString", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x47*/ {pOpToInteger, "ToInteger", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x48*/ {pOpToString, "ToString", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x49*/ {pOpCopyObject, "CopyObject", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeSimpleName)}, + /*0x4a*/ {pOpMid, "Mid", pOpFlagExecutable, makeArg4(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTarget)}, + /*0x4b*/ {pOpContinue, "Continue", pOpFlagExecutable, makeArg0()}, + /*0x4c*/ {pOpIf, "If", pOpFlagExecutable | pOpFlagScoped, makeArg3(pArgTypePkgLen, pArgTypeTermArg, pArgTypeTermList)}, + /*0x4d*/ {pOpElse, "Else", pOpFlagExecutable | pOpFlagScoped, makeArg2(pArgTypePkgLen, pArgTypeTermList)}, + /*0x4e*/ {pOpWhile, "While", pOpFlagDeferParsing | pOpFlagExecutable | pOpFlagScoped, makeArg3(pArgTypePkgLen, pArgTypeTermArg, pArgTypeTermList)}, + /*0x4f*/ {pOpNoop, "Noop", pOpFlagExecutable, makeArg0()}, + /*0x50*/ {pOpReturn, "Return", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x51*/ {pOpBreak, "Break", pOpFlagExecutable, makeArg0()}, + /*0x52*/ {pOpBreakPoint, "BreakPoint", pOpFlagExecutable, makeArg0()}, + /*0x53*/ {pOpOnes, "Ones", pOpFlagConstant, makeArg0()}, + /*0x54*/ {pOpMutex, "Mutex", pOpFlagNamed, makeArg2(pArgTypeNameString, pArgTypeByteData)}, + /*0x55*/ {pOpEvent, "Event", pOpFlagNamed, makeArg1(pArgTypeNameString)}, + /*0x56*/ {pOpCondRefOf, "CondRefOf", pOpFlagExecutable, makeArg2(pArgTypeSuperName, pArgTypeSuperName)}, + /*0x57*/ {pOpCreateField, "CreateField", pOpFlagExecutable, makeArg4(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeNameString)}, + /*0x58*/ {pOpLoadTable, "LoadTable", pOpFlagExecutable, makeArg7(pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg)}, + /*0x59*/ {pOpLoad, "Load", pOpFlagExecutable, makeArg2(pArgTypeNameString, pArgTypeSuperName)}, + /*0x5a*/ {pOpStall, "Stall", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x5b*/ {pOpSleep, "Sleep", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x5c*/ {pOpAcquire, "Acquire", pOpFlagExecutable, makeArg2(pArgTypeSuperName, pArgTypeWordData)}, + /*0x5d*/ {pOpSignal, "Signal", pOpFlagExecutable, makeArg1(pArgTypeTermArg)}, + /*0x5e*/ {pOpWait, "Wait", pOpFlagExecutable, makeArg2(pArgTypeSuperName, pArgTypeTermArg)}, + /*0x5f*/ {pOpReset, "Reset", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x60*/ {pOpRelease, "Release", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x61*/ {pOpFromBCD, "FromBCD", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x62*/ {pOpToBCD, "ToBCD", pOpFlagExecutable, makeArg2(pArgTypeTermArg, pArgTypeTarget)}, + /*0x63*/ {pOpUnload, "Unload", pOpFlagExecutable, makeArg1(pArgTypeSuperName)}, + /*0x64*/ {pOpRevision, "Revision", pOpFlagConstant | pOpFlagExecutable, makeArg0()}, + /*0x65*/ {pOpDebug, "Debug", pOpFlagExecutable, makeArg0()}, + /*0x66*/ {pOpFatal, "Fatal", pOpFlagExecutable, makeArg3(pArgTypeByteData, pArgTypeDwordData, pArgTypeTermArg)}, + /*0x67*/ {pOpTimer, "Timer", pOpFlagExecutable, makeArg0()}, + /*0x68*/ {pOpOpRegion, "OpRegion", pOpFlagNamed, makeArg4(pArgTypeNameString, pArgTypeByteData, pArgTypeTermArg, pArgTypeTermArg)}, + /*0x69*/ {pOpField, "Field", pOpFlagCreate, makeArg4(pArgTypePkgLen, pArgTypeNameString, pArgTypeByteData, pArgTypeFieldList)}, + /*0x6a*/ {pOpDevice, "Device", pOpFlagNamed | pOpFlagScoped, makeArg3(pArgTypePkgLen, pArgTypeNameString, pArgTypeTermList)}, + /*0x6b*/ {pOpProcessor, "Processor", pOpFlagNamed | pOpFlagScoped, makeArg6(pArgTypePkgLen, pArgTypeNameString, pArgTypeByteData, pArgTypeDwordData, pArgTypeByteData, pArgTypeTermList)}, + /*0x6c*/ {pOpPowerRes, "PowerRes", pOpFlagNamed | pOpFlagScoped, makeArg5(pArgTypePkgLen, pArgTypeNameString, pArgTypeByteData, pArgTypeWordData, pArgTypeTermList)}, + /*0x6d*/ {pOpThermalZone, "ThermalZone", pOpFlagNamed | pOpFlagScoped, makeArg3(pArgTypePkgLen, pArgTypeNameString, pArgTypeTermList)}, + /*0x6e*/ {pOpIndexField, "IndexField", pOpFlagCreate | pOpFlagNamed, makeArg5(pArgTypePkgLen, pArgTypeNameString, pArgTypeNameString, pArgTypeByteData, pArgTypeFieldList)}, + /*0x6f*/ {pOpBankField, "BankField", pOpFlagDeferParsing | pOpFlagCreate | pOpFlagNamed, makeArg6(pArgTypePkgLen, pArgTypeNameString, pArgTypeNameString, pArgTypeTermArg, pArgTypeByteData, pArgTypeFieldList)}, + /*0x70*/ {pOpDataRegion, "DataRegion", pOpFlagCreate | pOpFlagNamed, makeArg4(pArgTypeNameString, pArgTypeTermArg, pArgTypeTermArg, pArgTypeTermArg)}, + // Special internal opcodes + /*0xf7*/ {pOpIntScopeBlock, "ScopeBlock", pOpFlagCreate | pOpFlagNamed, makeArg1(pArgTypeTermList)}, + /*0xf8*/ {pOpIntByteList, "ByteList", pOpFlagCreate, makeArg0()}, + /*0xf9*/ {pOpIntConnection, "Connection", pOpFlagCreate, makeArg0()}, + /*0xfa*/ {pOpIntNamedField, "NamedField", pOpFlagCreate, makeArg0()}, + /*0xfb*/ {pOpIntResolvedNamePath, "ResolvedNamePath", pOpFlagCreate, makeArg0()}, + /*0xfc*/ {pOpIntNamePath, "NamePath", pOpFlagCreate, makeArg0()}, + /*0xfd*/ {pOpIntNamePathOrMethodCall, "NamePath or MethodCall", pOpFlagCreate, makeArg0()}, + /*0xfe*/ {pOpIntMethodCall, "MethodCall", pOpFlagCreate, makeArg0()}, +} + +// opcodeMap maps an AML opcode to an entry in the opcode table. Entries with +// the value 0xff indicate an invalid/unsupported opcode. +var opcodeMap = [256]uint8{ + /* 0 1 2 3 4 5 6 7*/ + /*0x00 - 0x07*/ 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0x02, 0xff, + /*0x08 - 0x0f*/ 0x03, 0xff, 0x04, 0x05, 0x06, 0x07, 0x08, 0xff, + /*0x10 - 0x17*/ 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0xff, 0xff, + /*0x18 - 0x1f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x20 - 0x27*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x28 - 0x2f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x30 - 0x37*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x38 - 0x3f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x40 - 0x47*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x48 - 0x4f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x50 - 0x57*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x58 - 0x5f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x60 - 0x67*/ 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, + /*0x68 - 0x6f*/ 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0xff, + /*0x70 - 0x77*/ 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, + /*0x78 - 0x7f*/ 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, + /*0x80 - 0x87*/ 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, + /*0x88 - 0x8f*/ 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, + /*0x90 - 0x97*/ 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, + /*0x98 - 0x9f*/ 0x46, 0x47, 0xff, 0xff, 0x48, 0x49, 0x4a, 0x4b, + /*0xa0 - 0xa7*/ 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0xff, 0xff, + /*0xa8 - 0xaf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xb0 - 0xb7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xb8 - 0xbf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xc0 - 0xc7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xc8 - 0xcf*/ 0xff, 0xff, 0xff, 0xff, 0x52, 0xff, 0xff, 0xff, + /*0xd0 - 0xd7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xd8 - 0xdf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xe0 - 0xe7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xe8 - 0xef*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xf0 - 0xf7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xf8 - 0xff*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x53, +} + +// extendedOpcodeMap maps an AML extended opcode (extOpPrefix + code) to an +// entry in the opcode table. Entries with the value 0xff indicate an +// invalid/unsupported opcode. +var extendedOpcodeMap = [256]uint8{ + /* 0 1 2 3 4 5 6 7*/ + /*0x00 - 0x07*/ 0xff, 0x54, 0x55, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x08 - 0x0f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x10 - 0x17*/ 0xff, 0xff, 0x56, 0x57, 0xff, 0xff, 0xff, 0xff, + /*0x18 - 0x1f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x58, + /*0x20 - 0x27*/ 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, + /*0x28 - 0x2f*/ 0x61, 0x62, 0x63, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x30 - 0x37*/ 0x64, 0x65, 0x66, 0x67, 0xff, 0xff, 0xff, 0xff, + /*0x38 - 0x3f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x40 - 0x47*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x48 - 0x4f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x50 - 0x57*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x58 - 0x5f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x60 - 0x67*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x68 - 0x6f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x70 - 0x77*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x78 - 0x7f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x80 - 0x87*/ 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + /*0x88 - 0x8f*/ 0x70, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x90 - 0x97*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0x98 - 0x9f*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xa0 - 0xa7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xa8 - 0xaf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xb0 - 0xb7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xb8 - 0xbf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xc0 - 0xc7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xc8 - 0xcf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xd0 - 0xd7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xd8 - 0xdf*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xe0 - 0xe7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xe8 - 0xef*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xf0 - 0xf7*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + /*0xf8 - 0xff*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +} + +// pOpcodeName returns the name of an opcode as a string. +func pOpcodeName(opcode uint16) string { + index := pOpcodeTableIndex(opcode, true) + if index == badOpcode { + return "unknown" + } + + return pOpcodeTable[index].opName +} + +// pOpcodeTableIndex returns the opcode table index for opcode or badOpcode(0xff) +// if opcode does not map to a valid opcode table entry. +func pOpcodeTableIndex(opcode uint16, allowInternalOp bool) uint8 { + if opcode <= 0xff { + return opcodeMap[opcode] + } + + index := extendedOpcodeMap[opcode-0xff] + + // internal opcodes do not have entries in the extendedOpcodeMap. They get + // allocated descending opcode values starting from (0xff + 0xfe). They do + // however have entries in the opcodeTable. To calculate their index we use + // the following formula: len(opcodeTable) - 1 - (0x1fd - intOpcode) or the + // equivalent: len(opcodeTable) + (intOpcode - 0x1fe) + // with + if index == badOpcode && allowInternalOp { + index = uint8(len(pOpcodeTable) + int(opcode) - 0x1fe) + } + + return index +} diff --git a/src/gopheros/device/acpi/aml/parser_opcode_table_test.go b/src/gopheros/device/acpi/aml/parser_opcode_table_test.go index faa1c00..083a250 100644 --- a/src/gopheros/device/acpi/aml/parser_opcode_table_test.go +++ b/src/gopheros/device/acpi/aml/parser_opcode_table_test.go @@ -106,3 +106,38 @@ func TestOpcodeIsX(t *testing.T) { } } } + +func TestOpcodeName(t *testing.T) { + for specIndex, spec := range pOpcodeTable { + if got := pOpcodeName(spec.op); got != spec.opName { + t.Errorf("[spec %d] expected OpcodeName(0x%x) to return %q; got %q", specIndex, spec.op, spec.opName, got) + } + } + + if exp, got := "unknown", pOpcodeName(0xf8); got != exp { + t.Fatalf("expected OpcodeName to return %q for unknown opcode; got %q", exp, got) + } +} + +func TestOpcodeMap(t *testing.T) { + freqs := make(map[uint8]int) + for _, tableIndex := range opcodeMap { + if tableIndex == badOpcode { + continue + } + freqs[tableIndex]++ + } + + for _, tableIndex := range extendedOpcodeMap { + if tableIndex == badOpcode { + continue + } + freqs[tableIndex]++ + } + + for tableIndex, freq := range freqs { + if freq > 1 { + t.Errorf("[index 0x%x] found %d duplicate entries in opcodeMap/extendedOpcodeMap for %s", tableIndex, freq, pOpcodeTable[tableIndex].opName) + } + } +} From b00fff0e398b599a3ea4c3eebb0f48cc1d0cd9e3 Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 27 Feb 2018 08:49:32 +0000 Subject: [PATCH 04/10] acpi: define tree-based structure for storing parsed AML entities ACPI entity definitions form a tree whose roots are a sequence of pre-defined namespace objects. The parser stores all AML entities using a space-optimized structure (Object). These objects are organized into a tree via the ObjectTree structure. Instead of storing pointers to other objects (i.e. siblings, children or parent), objects use uint32 indices to objects managed by the ObjectTree. This has the nice advantage of reducing the memory requirements for our tree in half when running on 64-bits (4-bytes per index vs 8-bytes per pointer) while also allowing us to recycle objects that are explicitly freed by the parser. --- src/gopheros/device/acpi/aml/obj_tree.go | 398 ++++++++++++++++ src/gopheros/device/acpi/aml/obj_tree_test.go | 434 ++++++++++++++++++ 2 files changed, 832 insertions(+) create mode 100644 src/gopheros/device/acpi/aml/obj_tree.go create mode 100644 src/gopheros/device/acpi/aml/obj_tree_test.go diff --git a/src/gopheros/device/acpi/aml/obj_tree.go b/src/gopheros/device/acpi/aml/obj_tree.go new file mode 100644 index 0000000..f34ee5a --- /dev/null +++ b/src/gopheros/device/acpi/aml/obj_tree.go @@ -0,0 +1,398 @@ +package aml + +const ( + // InvalidIndex is a sentinel value used by ObjectTree to indicate that + // a returned object index is not valid. + InvalidIndex uint32 = (1 << 32) - 1 + + // The size of AML name identifiers in bytes. + amlNameLen = 4 +) + +// fieldElement groups together information about a field element. This +// information can also be obtained by scanning a field element's siblings but +// it is summarized in this structure for convenience. +type fieldElement struct { + // The offset in the address space defined by parent field. + offset uint32 + + // The width of this field element in bits. + width uint32 + + accessLength uint8 + _pad [3]uint8 + + accessType uint8 + accessAttrib uint8 + lockType uint8 + updateType uint8 + + // The index of an Object to use as a connection target. Used only for + // GenericSerialBus and GeneralPurposeIO operation regions. + connectionIndex uint32 + + // The index of the Field (pOpField, pOpIndexField or pOpBankField) that this + // field element belongs to. According to the spec, named fields appear + // at the same scope as their parent. + fieldIndex uint32 +} + +// Object describes an entity encoded in the AML bytestream. +type Object struct { + // The AML ocode that describes this oBject. + opcode uint16 + + // The Index in the opcodeTable for this opcode + infoIndex uint8 + + // The table handle which contains this entity. + tableHandle uint8 + + // Named AML entities provide a fixed-width name which is padded by '_' chars. + name [amlNameLen]byte + + // The following indices refer to other Objects in the ObjectTree + // that allocated this Object instance. Uninitialized indices are + // represented via a math.MaxUint32 value. + index uint32 + parentIndex uint32 + prevSiblingIndex uint32 + nextSiblingIndex uint32 + firstArgIndex uint32 + lastArgIndex uint32 + + // The byte offset in the AML stream where this opcode is defined. + amlOffset uint32 + + // A non-zero value for pkgEnd indicates that this opcode requires deferred + // parsing due to its potentially ambiguous contents. + pkgEnd uint32 + + // A value placeholder for entites that contain values (e.g. int + // or string constants byte slices e.t.c) + value interface{} +} + +// ObjectTree is a structure that contains a tree of AML entities where each +// entity is allocated from a contiguous Object pool. Index #0 of the pool +// contains the root scope ('\') of the AML tree. +type ObjectTree struct { + objPool []*Object + freeListHeadIndex uint32 +} + +// NewObjectTree returns a new ObjectTree instance. +func NewObjectTree() *ObjectTree { + return &ObjectTree{ + freeListHeadIndex: InvalidIndex, + } +} + +// CreateDefaultScopes populates the Object pool with the default scopes +// specified by the ACPI standard: +// +// +-[\] (Root scope) +// +- [_GPE] (General events in GPE register block) +// +- [_PR_] (ACPI 1.0 processor namespace) +// +- [_SB_] (System bus with all device objects) +// +- [_SI_] (System indicators) +// +- [_TZ_] (ACPI 1.0 thermal zone namespace) +func (tree *ObjectTree) CreateDefaultScopes(tableHandle uint8) { + root := tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'\\'}) + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'G', 'P', 'E'})) // General events in GPE register block + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'P', 'R', '_'})) // ACPI 1.0 processor namespace + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'S', 'B', '_'})) // System bus with all device objects + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'S', 'I', '_'})) // System indicators + tree.append(root, tree.newNamedObject(pOpIntScopeBlock, tableHandle, [amlNameLen]byte{'_', 'T', 'Z', '_'})) // ACPI 1.0 thermal zone namespace +} + +// newObject allocates a new Object from the Object pool, populates its +// contents and returns back a pointer to it. +func (tree *ObjectTree) newObject(opcode uint16, tableHandle uint8) *Object { + var obj *Object + + // Check the free list first + if tree.freeListHeadIndex != InvalidIndex { + obj = tree.objPool[tree.freeListHeadIndex] + tree.freeListHeadIndex = obj.nextSiblingIndex + } else { + // Allocate new object and attach it to the pool + obj = new(Object) + obj.index = uint32(len(tree.objPool)) + tree.objPool = append(tree.objPool, obj) + } + + obj.opcode = opcode + obj.infoIndex = pOpcodeTableIndex(opcode, true) + obj.tableHandle = tableHandle + obj.parentIndex = InvalidIndex + obj.prevSiblingIndex = InvalidIndex + obj.nextSiblingIndex = InvalidIndex + obj.firstArgIndex = InvalidIndex + obj.lastArgIndex = InvalidIndex + obj.value = nil + + return obj +} + +// newNamedObject allocates a new Object from the Object pool, populates its +// name and returns back a pointer to it. +func (tree *ObjectTree) newNamedObject(opcode uint16, tableHandle uint8, name [amlNameLen]byte) *Object { + obj := tree.newObject(opcode, tableHandle) + obj.name = name + return obj +} + +// append appends arg to obj's argument list. +func (tree *ObjectTree) append(obj, arg *Object) { + arg.parentIndex = obj.index + + if obj.lastArgIndex == InvalidIndex { + obj.firstArgIndex = arg.index + obj.lastArgIndex = arg.index + return + } + + LastArg := tree.ObjectAt(obj.lastArgIndex) + LastArg.nextSiblingIndex = arg.index + arg.prevSiblingIndex = LastArg.index + arg.nextSiblingIndex = InvalidIndex + obj.lastArgIndex = arg.index +} + +// appendAfter appends arg to obj's argument list after nextTo. +func (tree *ObjectTree) appendAfter(obj, arg, nextTo *Object) { + // nextTo is the last arg of obj; this is equivalent to a regular append + if nextTo.nextSiblingIndex == InvalidIndex { + tree.append(obj, arg) + return + } + + arg.parentIndex = obj.index + arg.prevSiblingIndex = nextTo.index + arg.nextSiblingIndex = nextTo.nextSiblingIndex + + tree.ObjectAt(arg.nextSiblingIndex).prevSiblingIndex = arg.index + nextTo.nextSiblingIndex = arg.index +} + +// free appends obj to the tree's free object list allowing it to be re-used by +// future calls to NewObject and NewNamedObject. Callers must ensure that any +// held pointers to the object are not used after calling free. +func (tree *ObjectTree) free(obj *Object) { + if obj.parentIndex != InvalidIndex { + tree.detach(tree.ObjectAt(obj.parentIndex), obj) + } + + if obj.firstArgIndex != InvalidIndex || obj.lastArgIndex != InvalidIndex { + panic("aml.ObjectTree: attempted to free object that still contains argument references") + } + + // Push the object to the top of the free list and change its opcode to + // indicate this is a freed node + obj.opcode = pOpIntFreedObject + obj.nextSiblingIndex = tree.freeListHeadIndex + tree.freeListHeadIndex = obj.index +} + +// detach detaches arg from obj's argument list. +func (tree *ObjectTree) detach(obj, arg *Object) { + if obj.firstArgIndex == arg.index { + obj.firstArgIndex = arg.nextSiblingIndex + } + + if obj.lastArgIndex == arg.index { + obj.lastArgIndex = arg.prevSiblingIndex + } + + if arg.nextSiblingIndex != InvalidIndex { + tree.ObjectAt(arg.nextSiblingIndex).prevSiblingIndex = arg.prevSiblingIndex + } + + if arg.prevSiblingIndex != InvalidIndex { + tree.ObjectAt(arg.prevSiblingIndex).nextSiblingIndex = arg.nextSiblingIndex + } + + arg.prevSiblingIndex = InvalidIndex + arg.nextSiblingIndex = InvalidIndex + arg.parentIndex = InvalidIndex +} + +// ObjectAt returns a pointer to the Object at the specified index or nil if +// no object with this index exists inside the object tree. +func (tree *ObjectTree) ObjectAt(index uint32) *Object { + if index >= uint32(len(tree.objPool)) { + return nil + } + obj := tree.objPool[index] + if obj.opcode == pOpIntFreedObject { + return nil + } + + return obj +} + +// Find attempts to resolve the given expression into an Object using the rules +// specified in page 252 of the ACPI 6.2 spec: +// +// There are two types of namespace paths: an absolute namespace path (that is, +// one that starts with a ‘\’ prefix), and a relative namespace path (that is, +// one that is relative to the current namespace). The namespace search rules +// discussed above, only apply to single NameSeg paths, which is a relative +// namespace path. For those relative name paths that contain multiple NameSegs +// or Parent Prefixes, ‘^’, the search rules do not apply. If the search rules +// do not apply to a relative namespace path, the namespace object is looked up +// relative to the current namespace +func (tree *ObjectTree) Find(scopeIndex uint32, expr []byte) uint32 { + exprLen := len(expr) + if exprLen == 0 || scopeIndex == InvalidIndex { + return InvalidIndex + } + + switch { + case expr[0] == '\\': // relative to the root scope + // Name was just `\`; this matches the root namespace + if exprLen == 1 { + return 0 + } + + return tree.findRelative(0, expr[1:]) + case expr[0] == '^': // relative to the parent scope(s) + for startIndex := 0; startIndex < exprLen; startIndex++ { + switch expr[startIndex] { + case '^': + // Mpve up one parent. If we were at the root scope + // then the lookup failed. + if scopeIndex = tree.ObjectAt(scopeIndex).parentIndex; scopeIndex == InvalidIndex { + return InvalidIndex + } + default: + // Found the start of the name. Look it up relative to current scope + return tree.findRelative(scopeIndex, expr[startIndex:]) + } + } + + // Name was just a sequence of '^'; this matches the last scopeIndex value + return scopeIndex + case exprLen > amlNameLen: + // The expression consists of multiple name segments joined together (e.g. FOOFBAR0) + // In this case we need to apply relative lookup rules for FOOF.BAR0 + return tree.findRelative(scopeIndex, expr) + default: + // expr is a simple name. According to the spec, we need to + // search for it in this scope and all its parent scopes till + // we reach the root. + for nextScopeIndex := scopeIndex; nextScopeIndex != InvalidIndex; nextScopeIndex = tree.ObjectAt(nextScopeIndex).parentIndex { + scopeObj := tree.ObjectAt(nextScopeIndex) + checkNextSibling: + for nextIndex := scopeObj.firstArgIndex; nextIndex != InvalidIndex; nextIndex = tree.ObjectAt(nextIndex).nextSiblingIndex { + obj := tree.ObjectAt(nextIndex) + for byteIndex := 0; byteIndex < amlNameLen; byteIndex++ { + if expr[byteIndex] != obj.name[byteIndex] { + continue checkNextSibling + } + } + + // Found match + return obj.index + } + } + } + + // Not found + return InvalidIndex +} + +// findRelative attempts to resolve an object using relative scope lookup rules. +func (tree *ObjectTree) findRelative(scopeIndex uint32, expr []byte) uint32 { + exprLen := len(expr) + +nextSegment: + for segIndex := 0; segIndex < exprLen; segIndex += amlNameLen { + // If expr contains a dual or multinamed path then we may encounter special + // prefix chars in the stream (the parser extracts the raw data). In this + // case skip over them. + for ; segIndex < exprLen && expr[segIndex] != '_' && (expr[segIndex] < 'A' || expr[segIndex] > 'Z'); segIndex++ { + } + if segIndex >= exprLen { + return InvalidIndex + } + + // Search current scope for an entity matching the next name segment + scopeObj := tree.ObjectAt(scopeIndex) + + checkNextSibling: + for nextIndex := scopeObj.firstArgIndex; nextIndex != InvalidIndex; nextIndex = tree.ObjectAt(nextIndex).nextSiblingIndex { + obj := tree.ObjectAt(nextIndex) + for byteIndex := 0; byteIndex < amlNameLen; byteIndex++ { + if expr[segIndex+byteIndex] != obj.name[byteIndex] { + continue checkNextSibling + } + } + + // Found match; set match as the next scope index and + // try to match the next segment + scopeIndex = nextIndex + continue nextSegment + } + + // Failed to match next segment. Lookup failed + return InvalidIndex + } + + // scopeIndex contains the index of the last matched name in the expression + // which is the target we were looking for. + return scopeIndex +} + +// ClosestNamedAncestor returns the index of the first named object that is an +// ancestor of obj. If any of obj's parents are unresolved scope directives +// then the call will return InvalidIndex. +func (tree *ObjectTree) ClosestNamedAncestor(obj *Object) uint32 { + if obj == nil { + return InvalidIndex + } + + for ancestorIndex := obj.parentIndex; ancestorIndex != InvalidIndex; { + ancestor := tree.ObjectAt(ancestorIndex) + if ancestor.opcode == pOpScope { + break + } + + if pOpcodeTable[ancestor.infoIndex].flags&pOpFlagNamed != 0 { + return ancestorIndex + } + + ancestorIndex = ancestor.parentIndex + } + + return InvalidIndex +} + +// NumArgs returns the number of arguments contained in obj. +func (tree *ObjectTree) NumArgs(obj *Object) uint32 { + if obj == nil { + return 0 + } + + var argCount uint32 + for siblingIndex := obj.firstArgIndex; siblingIndex != InvalidIndex; siblingIndex = tree.ObjectAt(siblingIndex).nextSiblingIndex { + argCount++ + } + + return argCount +} + +// ArgAt returns a pointer to obj's arg located at index. +func (tree *ObjectTree) ArgAt(obj *Object, index uint32) *Object { + if obj == nil { + return nil + } + for argIndex, siblingIndex := uint32(0), obj.firstArgIndex; siblingIndex != InvalidIndex; argIndex, siblingIndex = argIndex+1, tree.ObjectAt(siblingIndex).nextSiblingIndex { + if argIndex == index { + return tree.ObjectAt(siblingIndex) + } + } + + return nil +} diff --git a/src/gopheros/device/acpi/aml/obj_tree_test.go b/src/gopheros/device/acpi/aml/obj_tree_test.go new file mode 100644 index 0000000..fb488a0 --- /dev/null +++ b/src/gopheros/device/acpi/aml/obj_tree_test.go @@ -0,0 +1,434 @@ +package aml + +import ( + "fmt" + "testing" +) + +func TestTreeObjectAt(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + + tree.append(root, obj1) + + if got := tree.ObjectAt(obj1.index); got != obj1 { + t.Fatalf("expected to get back obj1; got %#+v", got) + } + + if got := tree.ObjectAt(obj1.index + 1); got != nil { + t.Fatalf("expected to get nil; got %#+v", got) + } + + tree.free(obj1) + if got := tree.ObjectAt(obj1.index); got != nil { + t.Fatalf("expected to get back nil after freeing obj1; got %#+v", got) + } +} + +func TestTreeFreelist(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + obj2 := tree.newObject(pOpIntScopeBlock, 2) + obj3 := tree.newObject(pOpIntScopeBlock, 3) + + tree.append(root, obj1) + tree.append(root, obj2) + tree.append(root, obj3) + + // By freeing these objects they will be re-used by the following NewObject + // calls in LIFO order. + obj2Index := obj2.index + obj3Index := obj3.index + tree.free(obj3) + tree.free(obj2) + + newObj := tree.newObject(pOpIntScopeBlock, 4) + if newObj.index != obj2Index { + t.Errorf("expected object index to be %d; got %d", obj2Index, newObj.index) + } + + newObj = tree.newObject(pOpIntScopeBlock, 4) + if newObj.index != obj3Index { + t.Errorf("expected object index to be %d; got %d", obj3Index, newObj.index) + } + + if tree.freeListHeadIndex != InvalidIndex { + t.Errorf("expected free list head index to be InvalidIndex; got %d", tree.freeListHeadIndex) + } +} + +func TestTreeFreelistPanic(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + + defer func() { + expErr := "aml.ObjectTree: attempted to free object that still contains argument references" + if err := recover(); err != expErr { + t.Fatalf("expected call to Free to panic with: %s; got: %v", expErr, err) + } + }() + + // Call should panic as root contains argument references + tree.free(tree.ObjectAt(0)) +} + +func TestTreeAppend(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + obj2 := tree.newObject(pOpIntScopeBlock, 2) + obj3 := tree.newObject(pOpIntScopeBlock, 3) + + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatal("expected root First/Last arg indices to be InvalidIndex") + } + + tree.append(root, obj1) + if root.firstArgIndex != obj1.index || root.lastArgIndex != obj1.index { + t.Fatal("expected root First/Last arg indices to point to obj1") + } + + if obj1.parentIndex != root.index { + t.Fatal("expected obj1 parent index to point to root") + } + + if obj1.firstArgIndex != InvalidIndex || obj1.lastArgIndex != InvalidIndex { + t.Fatal("expected obj1 First/Last arg indices to be InvalidIndex") + } + + // Attach the remaining pointers and follow the links both ways + tree.append(root, obj2) + tree.append(root, obj3) + + visitedObjects := 0 + for i := root.firstArgIndex; i != InvalidIndex; i = tree.ObjectAt(i).nextSiblingIndex { + visitedObjects++ + } + + if want := 3; visitedObjects != want { + t.Fatalf("expected to visit %d objects in left -> right traversal; visited %d", want, visitedObjects) + } + + visitedObjects = 0 + for i := root.lastArgIndex; i != InvalidIndex; i = tree.ObjectAt(i).prevSiblingIndex { + visitedObjects++ + } + + if want := 3; visitedObjects != want { + t.Fatalf("expected to visit %d objects in right -> left traversal; visited %d", want, visitedObjects) + } +} + +func TestTreeAppendAfter(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + obj2 := tree.newObject(pOpIntScopeBlock, 2) + obj3 := tree.newObject(pOpIntScopeBlock, 3) + + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatal("expected root First/Last arg indices to be InvalidIndex") + } + + tree.append(root, obj1) + + tree.appendAfter(root, obj2, obj1) + tree.appendAfter(root, obj3, obj1) + + expIndexList := []uint32{obj1.index, obj3.index, obj2.index} + + visitedObjects := 0 + for i := root.firstArgIndex; i != InvalidIndex; i = tree.ObjectAt(i).nextSiblingIndex { + if i != expIndexList[visitedObjects] { + t.Fatalf("expected arg %d to have index %d; got %d", visitedObjects, expIndexList[visitedObjects], i) + } + visitedObjects++ + } + + if want := 3; visitedObjects != want { + t.Fatalf("expected to visit %d objects in left -> right traversal; visited %d", want, visitedObjects) + } +} + +func TestTreeDetach(t *testing.T) { + tree := NewObjectTree() + + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpIntScopeBlock, 1) + obj2 := tree.newObject(pOpIntScopeBlock, 2) + obj3 := tree.newObject(pOpIntScopeBlock, 3) + + t.Run("detach in reverse order", func(t *testing.T) { + tree.append(root, obj1) + tree.append(root, obj2) + tree.append(root, obj3) + + tree.detach(root, obj3) + if root.firstArgIndex != obj1.index || root.lastArgIndex != obj2.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj1.index, obj2.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj2) + if root.firstArgIndex != obj1.index || root.lastArgIndex != obj1.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj1.index, obj1.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj1) + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", InvalidIndex, InvalidIndex, root.firstArgIndex, root.lastArgIndex) + } + }) + + t.Run("detach in insertion order", func(t *testing.T) { + tree.append(root, obj1) + tree.append(root, obj2) + tree.append(root, obj3) + + tree.detach(root, obj1) + if root.firstArgIndex != obj2.index || root.lastArgIndex != obj3.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj2.index, obj3.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj2) + if root.firstArgIndex != obj3.index || root.lastArgIndex != obj3.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj3.index, obj3.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj3) + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", InvalidIndex, InvalidIndex, root.firstArgIndex, root.lastArgIndex) + } + }) + + t.Run("detach middle node and then edges", func(t *testing.T) { + tree.append(root, obj1) + tree.append(root, obj2) + tree.append(root, obj3) + + tree.detach(root, obj2) + if root.firstArgIndex != obj1.index || root.lastArgIndex != obj3.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj1.index, obj3.index, root.firstArgIndex, root.lastArgIndex) + } + + if obj1.nextSiblingIndex != obj3.index { + t.Fatalf("expected obj1 NextSiblingIndex to be %d; got %d", obj3.index, obj1.nextSiblingIndex) + } + + if obj3.prevSiblingIndex != obj1.index { + t.Fatalf("expected obj3 PrevSiblingIndex to be %d; got %d", obj1.index, obj3.prevSiblingIndex) + } + + tree.detach(root, obj1) + if root.firstArgIndex != obj3.index || root.lastArgIndex != obj3.index { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", obj3.index, obj3.index, root.firstArgIndex, root.lastArgIndex) + } + + tree.detach(root, obj3) + if root.firstArgIndex != InvalidIndex || root.lastArgIndex != InvalidIndex { + t.Fatalf("unexpected first/last indices: want (%d, %d); got (%d, %d)", InvalidIndex, InvalidIndex, root.firstArgIndex, root.lastArgIndex) + } + }) +} + +func TestFind(t *testing.T) { + tree, scopeMap := genTestScopes() + + specs := []struct { + curScope uint32 + expr string + want uint32 + }{ + // Search rules do not apply for these cases + { + scopeMap["PCI0"], + `\`, + scopeMap[`\`], + }, + { + scopeMap["PCI0"], + "IDE0_ADR", + scopeMap["_ADR"], + }, + { + scopeMap["IDE0"], + "^^PCI0IDE0_ADR", + scopeMap["_ADR"], + }, + { + scopeMap["IDE0"], + `\_SB_PCI0IDE0_ADR`, + scopeMap["_ADR"], + }, + // Raw multi-segment path (prefix 0x2f, segCount: 3) + { + scopeMap["_ADR"], + fmt.Sprintf("\\%c%c_SB_PCI0IDE0", 0x2f, 0x03), + scopeMap["IDE0"], + }, + { + scopeMap["IDE0"], + `\_SB_PCI0`, + scopeMap["PCI0"], + }, + { + scopeMap["IDE0"], + `^`, + scopeMap["PCI0"], + }, + // Bad queries + { + scopeMap["_SB_"], + "PCI0USB0_CRS", + InvalidIndex, + }, + { + scopeMap["IDE0"], + "^^^^^^^^^^^^^^^^^^^", + InvalidIndex, + }, + { + scopeMap["IDE0"], + `^^^^^^^^^^^FOO`, + InvalidIndex, + }, + { + scopeMap["IDE0"], + "FOO", + InvalidIndex, + }, + { + scopeMap["IDE0"], + "", + InvalidIndex, + }, + // Incomplete multi-segment path (prefix 0x2f, segCount: 3) + { + scopeMap["_ADR"], + fmt.Sprintf("\\%c%c?", 0x2f, 0x03), + InvalidIndex, + }, + // Search rules apply for these cases + { + scopeMap["IDE0"], + "_CRS", + scopeMap["_CRS"], + }, + } + + for specIndex, spec := range specs { + if got := tree.Find(spec.curScope, []byte(spec.expr)); got != spec.want { + t.Errorf("[spec %d] expected lookup to return index %d; got %d", specIndex, spec.want, got) + } + } +} + +func TestNumArgs(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + + if exp, got := uint32(5), tree.NumArgs(tree.ObjectAt(0)); got != exp { + t.Fatalf("expected NumArgs(root) to return %d; got %d", exp, got) + } + + if got := tree.NumArgs(nil); got != 0 { + t.Fatalf("expected NumArgs(nil) to return 0; got %d", got) + } +} + +func TestArgAt(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + + root := tree.ObjectAt(0) + arg0 := tree.ArgAt(root, 0) + expName := [amlNameLen]byte{'_', 'G', 'P', 'E'} + if arg0.name != expName { + t.Errorf("expected ArgAt(root, 0) to return object with name: %s; got: %s", string(expName[:]), string(arg0.name[:])) + } + + if got := tree.ArgAt(root, InvalidIndex); got != nil { + t.Errorf("expected ArgAt(root, InvalidIndex) to return nil; got: %v", got) + } + + if got := tree.ArgAt(nil, 1); got != nil { + t.Fatalf("expected ArgAt(nil, x) to return nil; got %#+v", got) + } +} + +func TestClosestNamedAncestor(t *testing.T) { + tree := NewObjectTree() + root := tree.newObject(pOpIntScopeBlock, 0) + obj1 := tree.newObject(pOpMethod, 1) + obj2 := tree.newObject(pOpIf, 2) + scope := tree.newObject(pOpScope, 3) + obj3 := tree.newObject(pOpIf, 4) + + tree.append(root, obj1) + tree.append(obj1, obj2) + tree.append(obj2, scope) + tree.append(scope, obj3) + + if got := tree.ClosestNamedAncestor(obj3); got != InvalidIndex { + t.Errorf("expected ClosestNamedAncestor to return InvalidIndex; got %d", got) + } + + // No parent exists + if got := tree.ClosestNamedAncestor(root); got != InvalidIndex { + t.Errorf("expected ClosestNamedAncestor to return InvalidIndex; got %d", got) + } + + // Make the root a non-named object and call ClosestNamedAncestor on its child + root.opcode = pOpAdd + root.infoIndex = pOpcodeTableIndex(root.opcode, false) + if got := tree.ClosestNamedAncestor(obj1); got != InvalidIndex { + t.Errorf("expected ClosestNamedAncestor to return InvalidIndex; got %d", got) + } + + if got := tree.ClosestNamedAncestor(nil); got != InvalidIndex { + t.Fatalf("expected ClosestNamedAncestor(nil) to return InvalidIndex; got %d", got) + } +} + +func genTestScopes() (*ObjectTree, map[string]uint32) { + // Setup the example tree from page 252 of the acpi 6.2 spec + // \ + // SB + // \ + // PCI0 + // | _CRS + // \ + // IDE0 + // | _ADR + + tree := NewObjectTree() + + root := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'\\'}) + pci := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'P', 'C', 'I', '0'}) + ide := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'I', 'D', 'E', '0'}) + sb := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'_', 'S', 'B', '_'}) + + crs := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'_', 'C', 'R', 'S'}) + adr := tree.newNamedObject(pOpIntScopeBlock, 0, [4]byte{'_', 'A', 'D', 'R'}) + + // Setup tree + tree.append(root, sb) + tree.append(sb, pci) + tree.append(pci, crs) + tree.append(pci, ide) + tree.append(ide, adr) + + return tree, map[string]uint32{ + "IDE0": ide.index, + "PCI0": pci.index, + "_SB_": sb.index, + "\\": root.index, + "_ADR": adr.index, + "_CRS": crs.index, + } +} From 98fe98bc8391dac8ac965fca3b7cf7398f170dff Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 27 Feb 2018 08:51:20 +0000 Subject: [PATCH 05/10] acpi: implement reader abstraction for AML in-memory byte-streams --- src/gopheros/device/acpi/aml/stream_reader.go | 106 ++++++++++++++ .../device/acpi/aml/stream_reader_test.go | 131 ++++++++++++++++++ 2 files changed, 237 insertions(+) create mode 100644 src/gopheros/device/acpi/aml/stream_reader.go create mode 100644 src/gopheros/device/acpi/aml/stream_reader_test.go diff --git a/src/gopheros/device/acpi/aml/stream_reader.go b/src/gopheros/device/acpi/aml/stream_reader.go new file mode 100644 index 0000000..850059c --- /dev/null +++ b/src/gopheros/device/acpi/aml/stream_reader.go @@ -0,0 +1,106 @@ +package aml + +import ( + "gopheros/kernel" + "reflect" + "unsafe" +) + +var ( + errInvalidUnreadByte = &kernel.Error{Module: "acpi_aml_parser", Message: "bad call to UnreadByte; stream offset is 0"} + errInvalidPkgEnd = &kernel.Error{Module: "acpi_aml_parser", Message: "attempted to set pkgEnd past the end of the stream"} + errReadPastPkgEnd = &kernel.Error{Module: "acpi_aml_parser", Message: "attempted to read past pkgEnd"} +) + +type amlStreamReader struct { + offset uint32 + data []byte + pkgEnd uint32 +} + +// Init sets up the reader so it can read up to dataLen bytes from the virtual +// memory address dataAddr. If a non-zero initialOffset is specified, it will +// be used as the current offset in the stream. +func (r *amlStreamReader) Init(dataAddr uintptr, dataLen, initialOffset uint32) { + // Overlay a byte slice on top of the memory block to be accessed. + r.data = *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{ + Len: int(dataLen), + Cap: int(dataLen), + Data: dataAddr, + })) + + r.SetOffset(initialOffset) +} + +// EOF returns true if the end of the pkg has been reached. +func (r *amlStreamReader) EOF() bool { + return r.offset == r.pkgEnd +} + +func (r *amlStreamReader) SetPkgEnd(pkgEnd uint32) error { + if pkgEnd > uint32(len(r.data)) { + return errInvalidPkgEnd + } + + r.pkgEnd = pkgEnd + return nil +} + +// ReadByte returns the next byte from the stream. +func (r *amlStreamReader) ReadByte() (byte, error) { + if r.EOF() { + return 0, errReadPastPkgEnd + } + + r.offset++ + return r.data[r.offset-1], nil +} + +// PeekByte returns the next byte from the stream without advancing the read pointer. +func (r *amlStreamReader) PeekByte() (byte, error) { + if r.EOF() { + return 0, errReadPastPkgEnd + } + + return r.data[r.offset], nil +} + +// LastByte returns the last byte read off the stream +func (r *amlStreamReader) LastByte() (byte, error) { + if r.offset == 0 { + return 0, errReadPastPkgEnd + } + + return r.data[r.offset-1], nil +} + +// UnreadByte moves back the read pointer by one byte. +func (r *amlStreamReader) UnreadByte() error { + if r.offset == 0 { + return errInvalidUnreadByte + } + + r.offset-- + return nil +} + +// Offset returns the current offset. +func (r *amlStreamReader) Offset() uint32 { + return r.offset +} + +// DataPtr returns a pointer to the stream contents at the current stream offset. +func (r *amlStreamReader) DataPtr() uintptr { + if r.EOF() { + return 0 + } + return uintptr(unsafe.Pointer(&r.data[r.offset])) +} + +// SetOffset sets the reader offset to the supplied value. +func (r *amlStreamReader) SetOffset(off uint32) { + if max := uint32(len(r.data)); off > max { + off = max + } + r.offset = off +} diff --git a/src/gopheros/device/acpi/aml/stream_reader_test.go b/src/gopheros/device/acpi/aml/stream_reader_test.go new file mode 100644 index 0000000..4fab06d --- /dev/null +++ b/src/gopheros/device/acpi/aml/stream_reader_test.go @@ -0,0 +1,131 @@ +package aml + +import ( + "math" + "testing" + "unsafe" +) + +func TestAMLStreamReader(t *testing.T) { + buf := make([]byte, 16) + for i := 0; i < len(buf); i++ { + buf[i] = byte(i) + } + + t.Run("without offset", func(t *testing.T) { + var r amlStreamReader + r.Init( + uintptr(unsafe.Pointer(&buf[0])), + uint32(len(buf)), + 0, + ) + + if err := r.SetPkgEnd(uint32(len(buf) + 1)); err != errInvalidPkgEnd { + t.Fatalf("expected to get errInvalidPkgEnd; got: %v", err) + } + + if err := r.SetPkgEnd(uint32(len(buf))); err != nil { + t.Fatal(err) + } + + if r.EOF() { + t.Fatal("unexpected EOF") + } + + if err := r.UnreadByte(); err != errInvalidUnreadByte { + t.Fatalf("expected errInvalidUnreadByte; got %v", err) + } + + if _, err := r.LastByte(); err != errReadPastPkgEnd { + t.Fatalf("unexpected error: %v", err) + } + + for i := 0; i < len(buf); i++ { + exp := byte(i) + + next, err := r.PeekByte() + if err != nil { + t.Fatal(err) + } + if next != exp { + t.Fatalf("expected PeekByte to return %d; got %d", exp, next) + } + + next, err = r.ReadByte() + if err != nil { + t.Fatal(err) + } + if next != exp { + t.Fatalf("expected ReadByte to return %d; got %d", exp, next) + } + + last, err := r.LastByte() + if err != nil { + t.Fatal(err) + } + if last != exp { + t.Fatalf("expected LastByte to return %d; got %d", exp, last) + } + } + + if err := r.UnreadByte(); err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // Set offset past EOF; reader should cap the offset to len(buf) + r.SetOffset(math.MaxUint32) + + if _, err := r.PeekByte(); err != errReadPastPkgEnd { + t.Fatalf("unexpected error: %v", err) + } + if _, err := r.ReadByte(); err != errReadPastPkgEnd { + t.Fatalf("unexpected error: %v", err) + } + exp := byte(len(buf) - 1) + if last, _ := r.LastByte(); last != exp { + t.Fatalf("expected LastByte to return %d; got %d", exp, last) + } + + }) + + t.Run("with offset", func(t *testing.T) { + var r amlStreamReader + r.Init( + uintptr(unsafe.Pointer(&buf[0])), + uint32(len(buf)), + 8, + ) + + if r.EOF() { + t.Fatal("unexpected EOF") + } + + if exp, got := uint32(8), r.Offset(); got != exp { + t.Fatalf("expected Offset() to return %d; got %d", exp, got) + } + + exp := byte(8) + if next, _ := r.ReadByte(); next != exp { + t.Fatalf("expected ReadByte to return %d; got %d", exp, next) + } + }) + + t.Run("ptr to data", func(t *testing.T) { + var r amlStreamReader + r.Init( + uintptr(unsafe.Pointer(&buf[0])), + uint32(len(buf)), + 8, + ) + + if r.EOF() { + t.Fatal("unexpected EOF") + } + + r.SetOffset(2) + ptr := r.DataPtr() + if got := *((*byte)(unsafe.Pointer(ptr))); got != buf[2] { + t.Fatal("expected DataPtr to return a pointer to buf[2]") + } + }) +} From fe6c8f7293f28003823747485d73e17c31579bab Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 6 Mar 2018 08:19:43 +0000 Subject: [PATCH 06/10] acpi: implement AML multi-pass parser --- src/gopheros/device/acpi/aml/parser.go | 1437 +++++++++++++++++++ src/gopheros/device/acpi/aml/parser_test.go | 905 ++++++++++++ 2 files changed, 2342 insertions(+) create mode 100644 src/gopheros/device/acpi/aml/parser.go create mode 100644 src/gopheros/device/acpi/aml/parser_test.go diff --git a/src/gopheros/device/acpi/aml/parser.go b/src/gopheros/device/acpi/aml/parser.go new file mode 100644 index 0000000..810edd6 --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser.go @@ -0,0 +1,1437 @@ +package aml + +import ( + "gopheros/device/acpi/table" + "gopheros/kernel" + "gopheros/kernel/kfmt" + "io" + "reflect" + "unsafe" +) + +var ( + errParsingAML = &kernel.Error{Module: "acpi_aml_parser", Message: "could not parse AML bytecode"} +) + +type parseResult uint8 +type parseMode uint8 + +const ( + parseResultFailed parseResult = iota + parseResultOk + parseResultShortCircuit + parseResultRequireExtraPass + + parseModeSkipAmbiguousBlocks parseMode = iota + parseModeAllBlocks + + // The maximum number of mergeScopeDirectives - relocateNamedObjects passes + // attempted by the parser to fully resolve static objects. + maxResolvePasses = 5 +) + +// Parser implements a parser for ACPI Machine Language (AML) bytecode. +type Parser struct { + r amlStreamReader + errWriter io.Writer + + tableName string + tableHandle uint8 + + objTree *ObjectTree + scopeStack []uint32 + pkgEndStack []uint32 + + resolvePasses uint32 + mergedScopes uint32 + relocatedObjects uint32 + + mode parseMode +} + +// NewParser creates a new AML parser instance that attaches parsed AML entities to +// the provided objTree and emits parse errors to errWriter. +func NewParser(errWriter io.Writer, objTree *ObjectTree) *Parser { + return &Parser{ + errWriter: errWriter, + objTree: objTree, + } +} + +// ParseAML attempts to parse the AML byte-code contained in the supplied ACPI +// table tagging each scoped entity with the supplied table handle. +func (p *Parser) ParseAML(tableHandle uint8, tableName string, header *table.SDTHeader) *kernel.Error { + p.init(tableHandle, tableName, header) + + // Parse raw object list starting at the root scope + p.scopeEnter(0) + if p.parseObjectList() == parseResultFailed { + return errParsingAML + } + + // Connect missing args to named objects + if p.connectNamedObjArgs(0) != parseResultOk { + return errParsingAML + } + + // Resolve scope directives for non-executable blocks and relocate named + // objects. These two tasks run in lockstep until both steps report success + // or either reports an error. Running multiple passes is required to deal + // with edge cases like this one: + // Scope (_SB) + // { + // Device(SBRG) + // { + // Name(_HID, 0xf00) + // } + // } + // Scope (_SB ) + // { + // Scope(SBRG) + // { + // Device(^PCIE) + // { + // Name(_HID, 0xba1) + // } + // } + // } + // Scope (_SB) + // { + // Scope(PCIE) + // { + // Name(CRS, Zero) + // } + // } + // + // In this example, calling mergeScopeDirectives will place the PCIE device + // into the SBRG scope. However, the PCIE device must actually be placed in + // the _SB scope due to the ^ prefix in its name. The 3rd block expects to + // find PCIE in the _SB scope and will fail with parseResultRequireExtraPass. + // + // Running relocateNamedObjects immediately after will place the PCIE device + // at the correct location allowing us to run an extra mergeScopeDirectives + // pass to fully resolve the scope directive. + p.resolvePasses = 1 + for ; ; p.resolvePasses++ { + mergeRes := p.mergeScopeDirectives(0) + if mergeRes == parseResultFailed { + return errParsingAML + } + + relocateRes := p.relocateNamedObjects(0) + if relocateRes == parseResultFailed { + return errParsingAML + } + + // Stop if both calls returned OK + if mergeRes == parseResultOk && relocateRes == parseResultOk { + break + } + } + + // Parse deferred blocks + if p.parseDeferredBlocks(0) != parseResultOk { + return errParsingAML + } + + // Resolve method calls + if p.resolveMethodCalls(0) != parseResultOk { + return errParsingAML + } + + // Connect missing args that include method invocations to remaining + // non-named objects + if p.connectNonNamedObjArgs(0) != parseResultOk { + return errParsingAML + } + + return nil +} + +func (p *Parser) init(tableHandle uint8, tableName string, header *table.SDTHeader) { + p.resetState(tableHandle, tableName) + + p.r.Init( + uintptr(unsafe.Pointer(header)), + header.Length, + uint32(unsafe.Sizeof(table.SDTHeader{})), + ) + + _ = p.pushPkgEnd(header.Length) +} + +func (p *Parser) resetState(tableHandle uint8, tableName string) { + p.tableHandle = tableHandle + p.tableName = tableName + p.resolvePasses = 0 + p.mergedScopes = 0 + p.relocatedObjects = 0 + p.mode = parseModeSkipAmbiguousBlocks + + p.scopeStack = nil + p.pkgEndStack = nil + +} + +// parseObjectList tries to parse an AML object list. Object lists are usually +// specified together with a pkgLen block which is used to calculate the max +// read offset that the parser may reach. +func (p *Parser) parseObjectList() parseResult { + for len(p.scopeStack) != 0 { + // Consume up to the current package end + for !p.r.EOF() { + if p.parseNextObject() != parseResultOk { + return parseResultFailed + } + } + + // If the pkgEnd stack matches the scope stack this means the parser + // completed a scoped block and we need to pop it from the stack + if len(p.pkgEndStack) == len(p.scopeStack) { + p.scopeExit() + } + p.popPkgEnd() + } + + return parseResultOk +} + +// parseNextObject tries to parse a single object from the AML stream and +// attach it to the currently active scope. +func (p *Parser) parseNextObject() parseResult { + curOffset := p.r.Offset() + nextOp, res := p.nextOpcode() + if nextOp == pOpNoop { + return parseResultOk + } + + if res == parseResultFailed { + return p.parseNamePathOrMethodCall() + } + + curObj := p.objTree.newObject(nextOp, p.tableHandle) + curObj.amlOffset = curOffset + p.objTree.append(p.scopeCurrent(), curObj) + return p.parseObjectArgs(curObj) +} + +func (p *Parser) parseObjectArgs(curObj *Object) parseResult { + var res parseResult + + // Special case for constants that are used as TermArgs; just read the + // value directly into the supplied curObject + switch curObj.opcode { + case pOpBytePrefix: + curObj.value, res = p.parseNumConstant(1) + case pOpWordPrefix: + curObj.value, res = p.parseNumConstant(2) + case pOpDwordPrefix: + curObj.value, res = p.parseNumConstant(4) + case pOpQwordPrefix: + curObj.value, res = p.parseNumConstant(8) + case pOpStringPrefix: + curObj.value, res = p.parseString() + default: + res = p.parseArgs(&pOpcodeTable[curObj.infoIndex], curObj, 0) + } + + if res == parseResultShortCircuit { + res = parseResultOk + } + + return res +} + +func (p *Parser) parseArgs(info *pOpcodeInfo, curObj *Object, argOffset uint8) parseResult { + var ( + argCount = info.argFlags.argCount() + argObj *Object + res = parseResultOk + ) + + if argCount == 0 { + return parseResultOk + } + + for argIndex := argOffset; argIndex < argCount && res == parseResultOk; argIndex++ { + argObj, res = p.parseArg(info, curObj, info.argFlags.arg(argIndex)) + + // Ignore nil args (e.g. result of parsing a pkgLen) + if argObj != nil { + p.objTree.append(curObj, argObj) + } + } + + return res +} + +func (p *Parser) parseArg(info *pOpcodeInfo, curObj *Object, argType pArgType) (*Object, parseResult) { + switch argType { + case pArgTypeByteData, pArgTypeWordData, pArgTypeDwordData, pArgTypeQwordData, pArgTypeString, pArgTypeNameString: + return p.parseSimpleArg(argType) + case pArgTypeByteList: + argObj := p.objTree.newObject(pOpIntByteList, p.tableHandle) + p.parseByteList(argObj, p.r.pkgEnd-p.r.Offset()) + return argObj, parseResultOk + case pArgTypePkgLen: + origOffset := p.r.Offset() + pkgLen, res := p.parsePkgLength() + if res != parseResultOk { + return nil, res + } + + // If this opcode requires deferred parsing just keep track of + // the package end and skip over it. + if p.mode == parseModeSkipAmbiguousBlocks && (info.flags&pOpFlagDeferParsing != 0) { + curObj.pkgEnd = origOffset + pkgLen + p.r.SetOffset(curObj.pkgEnd) + return nil, parseResultShortCircuit + } + + if err := p.pushPkgEnd(origOffset + pkgLen); err != nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] %s\n", p.tableName, p.r.Offset(), err.Error()) + return nil, parseResultFailed + } + + return nil, parseResultOk + case pArgTypeFieldList: + return nil, p.parseFieldElements(curObj) + case pArgTypeTermArg, pArgTypeDataRefObj: + // A TermObj may contain a method call to a not-yet defined + // method. Since the AML stream does not contain info about + // the number of arguments in method calls the parser cannot + // distinguish where the TermObj actually ends. To work around + // this limitation, the parser will process any object up to + // the current package end and append them as *siblings* to + // curObj. We will then need to perform a second pass to + // properly populate the arguments. + if p.mode == parseModeAllBlocks { + return p.parseStrictTermArg(curObj) + } + + return nil, parseResultShortCircuit + case pArgTypeTermList: + // Create a new scope and shortcircuit the arg parser + scope := p.objTree.newObject(pOpIntScopeBlock, p.tableHandle) + scope.amlOffset = p.r.Offset() + p.scopeEnter(scope.index) + + if p.mode == parseModeSkipAmbiguousBlocks { + return scope, parseResultShortCircuit + } + + // Attach scope to curObj so lookups work and consume all objects till the package end + p.objTree.append(curObj, scope) + for !p.r.EOF() { + if p.parseNextObject() != parseResultOk { + return nil, parseResultFailed + } + } + p.scopeExit() + p.objTree.detach(curObj, scope) + return scope, parseResultOk + default: // pArgTypeTarget, pArgTypeSimpleName, pArgTypeSuperName: + return p.parseTarget() + } +} + +// parseNamePathOrMethodCall is invoked by the parser when it cannot parse an +// opcode from the AML stream. This indicates that the stream may contain +// either a method call or a named path reference. If the current parse mode is +// parseModeAllBlocks the method will return an error if the next term in the +// stream does not match an existing namepath or method name. +func (p *Parser) parseNamePathOrMethodCall() parseResult { + curOffset := p.r.Offset() + + pathExpr, res := p.parseNameString() + if res != parseResultOk { + return parseResultFailed + } + + // During the initial pass we cannot be sure about whether this is actually + // a method name or a named path reference as AML allows for forward decls. + if p.mode == parseModeSkipAmbiguousBlocks { + curObj := p.objTree.newObject(pOpIntNamePathOrMethodCall, p.tableHandle) + curObj.amlOffset = curOffset + curObj.value = pathExpr + p.objTree.append(p.scopeCurrent(), curObj) + return parseResultOk + } + + // Lookup the object pointed to by the path expression + targetIndex := p.objTree.Find( + p.objTree.ClosestNamedAncestor(p.scopeCurrent()), + pathExpr, + ) + + if targetIndex == InvalidIndex { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unable to resolve path expression %s\n", p.tableName, p.r.Offset(), pathExpr) + return parseResultFailed + } + + target := p.objTree.ObjectAt(targetIndex) + curObj := p.objTree.newObject(pOpIntResolvedNamePath, p.tableHandle) + curObj.amlOffset = curOffset + curObj.value = targetIndex + p.objTree.append(p.scopeCurrent(), curObj) + if target.opcode != pOpMethod { + return parseResultOk + } + + // If target is a method definition we need to make curObj the active scope + // and parse the number of args specified by the definition. + curObj.opcode = pOpIntMethodCall + curObj.infoIndex = pOpcodeTableIndex(curObj.opcode, true) + p.scopeEnter(curObj.index) + + argCount := uint8(p.objTree.ArgAt(target, 1).value.(uint64) & 0x7) + for argIndex := uint8(0); argIndex < argCount; argIndex++ { + if p.parseNextObject() != parseResultOk { + p.scopeExit() + return parseResultFailed + } + } + p.scopeExit() + return parseResultOk +} + +// parseStrictTermObj attempts to parse a TermArg from the stream using the +// strict grammar definitions from p. 1022 of the spec. As TermArgs may also +// contain method invocations, parseStrictTermArg must only be called after +// all static scope directives have been fully evaluated. +// +// Grammar: +// TermArg := Type2Opcode | DataObject | ArgObj | LocalObj +func (p *Parser) parseStrictTermArg(curObj *Object) (*Object, parseResult) { + var ( + termObj *Object + curOffset = p.r.Offset() + ) + + nextOp, res := p.peekNextOpcode() + if res != parseResultOk { + // make curObj the active scope so that lookups can work and parse a + // method call. + p.scopeEnter(curObj.index) + res = p.parseNamePathOrMethodCall() + p.scopeExit() + + // parseNamePathOrMethodCall will append the parsed object to the scope + // so we need to detach it. + if res == parseResultOk { + termObj = p.objTree.ObjectAt(curObj.lastArgIndex) + p.objTree.detach(curObj, termObj) + } + + if p.r.EOF() { + p.popPkgEnd() + } + return termObj, res + } + + if !pOpIsType2(nextOp) && !pOpIsDataObject(nextOp) && !pOpIsArg(nextOp) { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] encountered unexpected opcode %s while parsing termArg\n", p.tableName, p.r.Offset(), pOpcodeName(nextOp)) + } + + _, _ = p.nextOpcode() + termObj = p.objTree.newObject(nextOp, p.tableHandle) + termObj.amlOffset = curOffset + res = p.parseObjectArgs(termObj) + if p.r.EOF() { + p.popPkgEnd() + } + + return termObj, res +} + +func (p *Parser) parseSimpleArg(argType pArgType) (*Object, parseResult) { + var ( + obj = p.objTree.newObject(0, p.tableHandle) + res parseResult + ) + + obj.amlOffset = p.r.Offset() + + switch argType { + case pArgTypeByteData: + obj.opcode = pOpBytePrefix + obj.value, res = p.parseNumConstant(1) + case pArgTypeWordData: + obj.opcode = pOpWordPrefix + obj.value, res = p.parseNumConstant(2) + case pArgTypeDwordData: + obj.opcode = pOpDwordPrefix + obj.value, res = p.parseNumConstant(4) + case pArgTypeQwordData: + obj.opcode = pOpQwordPrefix + obj.value, res = p.parseNumConstant(8) + case pArgTypeString: + obj.opcode = pOpStringPrefix + obj.value, res = p.parseString() + case pArgTypeNameString: + obj.opcode = pOpIntNamePath + obj.value, res = p.parseNameString() + default: + return nil, parseResultFailed + } + + obj.infoIndex = pOpcodeTableIndex(obj.opcode, true) + return obj, res +} + +// parseTarget attempts to pass a Target from the AML bytestream. +// +// Grammar: +// Target := SuperName | NullName +// NullName := 0x00 +// SuperName := SimpleName | DebugObj | Type6Opcode +// Type6Opcode := DefRefOf | DefDerefOf | DefIndex | UserTermObj +// SimpleName := NameString | ArgObj | LocalObj +// +// UserTermObj is a control method invocation. +func (p *Parser) parseTarget() (*Object, parseResult) { + // Peek next opcode + origOffset := p.r.Offset() + nextOp, res := p.nextOpcode() + + if res == parseResultOk { + switch { + case nextOp == pOpZero: // NullName == no target + return nil, parseResultOk + case pOpIsArg(nextOp) || + nextOp == pOpRefOf || nextOp == pOpDerefOf || + nextOp == pOpIndex || nextOp == pOpDebug: + // This is a SuperName or a Type6Opcode + obj := p.objTree.newObject(nextOp, p.tableHandle) + obj.amlOffset = origOffset + return obj, p.parseObjectArgs(obj) + default: + // Unexpected opcode + return nil, parseResultFailed + } + } + + // In this case, this is either a method call or a named reference. Just + // like in parseObjectList we assume it's a named reference. + p.r.SetOffset(origOffset) + curObj := p.objTree.newObject(pOpIntNamePath, p.tableHandle) + curObj.amlOffset = origOffset + curObj.value, res = p.parseNameString() + return curObj, res +} + +// parseFieldElements parses a list of named field elements from the AML stream. +// +// FieldList := | FieldElement FieldList +// FieldElement := NamedField | ReservedField | AccessField | ExtendedAccessField | ConnectField +// NamedField := NameSeg PkgLength +// ReservedField := 0x00 PkgLength +// AccessField := 0x1 AccessType AccessAttrib +// ConnectField := 0x02 NameString | 0x02 BufferData +// ExtendedAccessField := 0x3 AccessType ExtendedAccessAttrib AccessLength +func (p *Parser) parseFieldElements(curObj *Object) parseResult { + var ( + nextFieldOffset uint32 + accessLength uint8 + accessType uint8 + accessAttrib uint8 + lockType uint8 + updateType uint8 + + field *Object + connection, connArg *Object + appendAfter = curObj + connectionIndex = InvalidIndex + + next uint8 + nextOp uint16 + err error + value uint64 + pkgLen uint32 + parseRes parseResult + ) + + // Initialize default flags based on the default flags of curObj + initialFlags := uint8(p.objTree.ObjectAt(curObj.lastArgIndex).value.(uint64)) + accessType = initialFlags & 0xf // bits [0:3] + lockType = (initialFlags >> 4) & 0x1 // bits [4:4] + updateType = (initialFlags >> 5) & 0x3 // bits [5:6] + + for !p.r.EOF() { + next, _ = p.r.ReadByte() + + switch next { + case 0x00: // ReservedField + if pkgLen, parseRes = p.parsePkgLength(); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse pkgLen for ReservedField element\n", p.tableName, p.r.Offset()) + return parseResultFailed + } + + nextFieldOffset += pkgLen + case 0x01: // AccessField: change default access type for fields that follow + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessType for AccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessType = uint8(value & 0xff) // bits [0:7] + + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessAttrib for AccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessAttrib = uint8(value & 0xff) // bits [0:7] + case 0x03: // ExtAccessField + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessType for ExtAccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessType = uint8(value & 0xff) // bits [0:7] + + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessAttrib for ExtAccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessAttrib = uint8(value & 0xff) // bits [0:7] + + if value, parseRes = p.parseNumConstant(1); parseRes == parseResultFailed { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse AccessLength for ExtAccessField element\n", p.tableName, p.r.Offset()) + return parseRes + } + + accessLength = uint8(value & 0xff) // bits [0:7] + case 0x02: // Connection + // Connection can be either a namestring or a buffer + next, err = p.r.ReadByte() + if err != nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unexpected end of stream while parsing Connection\n", p.tableName, p.r.Offset()) + return parseResultFailed + } + + connection = p.objTree.newObject(pOpIntConnection, p.tableHandle) + connectionIndex = connection.index + p.objTree.append(curObj, connection) + + switch next { + case uint8(pOpBuffer): + origPkgEnd := p.r.pkgEnd + origOffset := p.r.Offset() + if pkgLen, parseRes = p.parsePkgLength(); parseRes != parseResultOk { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse pkgLen for Connection\n", p.tableName, p.r.Offset()) + return parseRes + } + + dataLen := uint64(0) + if pkgLen > 0 { + if err = p.r.SetPkgEnd(origOffset + pkgLen); err != nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] failed to set pkgEnd for Buffer\n", p.tableName, p.r.Offset()) + return parseResultFailed + } + + if nextOp, parseRes = p.nextOpcode(); parseRes != parseResultOk { + return parseRes + } + + // Read data length + parseRes = parseResultOk + + switch nextOp { + case pOpBytePrefix: + dataLen, parseRes = p.parseNumConstant(1) + case pOpWordPrefix: + dataLen, parseRes = p.parseNumConstant(2) + case pOpDwordPrefix: + dataLen, parseRes = p.parseNumConstant(4) + } + + if parseRes == parseResultFailed { + return parseRes + } + } + + connArg = p.objTree.newObject(pOpIntByteList, p.tableHandle) + connArg.amlOffset = origOffset + p.parseByteList(connArg, uint32(dataLen)) + + // Restore previous pkg end and jump to end of buffer package + _ = p.r.SetPkgEnd(origPkgEnd) + p.r.SetOffset(origOffset + pkgLen) + default: + // unread first byte of namepath + _ = p.r.UnreadByte() + connArg = p.objTree.newObject(pOpIntNamePath, p.tableHandle) + connArg.amlOffset = p.r.Offset() + if connArg.value, parseRes = p.parseNameString(); parseRes != parseResultOk { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse namestring for Connection\n", p.tableName, p.r.Offset()) + return parseRes + } + } + + p.objTree.append(connection, connArg) + default: + // This is a named field and next is the first part of its name. We need + // to rewind the stream + _ = p.r.UnreadByte() + + field = p.objTree.newObject(pOpIntNamedField, p.tableHandle) + field.amlOffset = p.r.Offset() + for i := 0; i < amlNameLen; i++ { + if field.name[i], err = p.r.ReadByte(); err != nil { + return parseResultFailed + } + } + + if pkgLen, parseRes = p.parsePkgLength(); parseRes != parseResultOk { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] could not parse pkgLen for NamedField\n", p.tableName, p.r.Offset()) + return parseRes + } + + // Populate field element and attach field object + field.value = &fieldElement{ + offset: nextFieldOffset, + width: pkgLen, + accessLength: accessLength, + accessType: accessType, + accessAttrib: accessAttrib, + lockType: lockType, + updateType: updateType, + connectionIndex: connectionIndex, + fieldIndex: curObj.index, + } + + // According to the spec, field elements appear at the same scope as + // their Field/IndexField/BankField container + p.objTree.appendAfter(p.objTree.ObjectAt(curObj.parentIndex), field, appendAfter) + appendAfter = field + + // Calculate offset for next field + nextFieldOffset += pkgLen + } + } + + // Skip to the end of the arg list for the current field object + return parseResultShortCircuit +} + +func (p *Parser) parseByteList(obj *Object, dataLen uint32) { + obj.opcode = pOpIntByteList + obj.infoIndex = pOpcodeTableIndex(obj.opcode, true) + obj.value = *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{ + Len: int(dataLen), + Cap: int(dataLen), + Data: p.r.DataPtr(), + })) + + p.r.SetOffset(p.r.Offset() + dataLen) +} + +// parsePkgLength parses a PkgLength value from the AML bytestream. +func (p *Parser) parsePkgLength() (uint32, parseResult) { + origOffset := p.r.Offset() + lead, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + // The high 2 bits of the lead byte indicate how many bytes follow. + var pkgLen uint32 + switch lead >> 6 { + case 0: + pkgLen = uint32(lead) + case 1: + b1, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + // lead bits 0-3 are the lsb of the length nybble + pkgLen = uint32(b1)<<4 | uint32(lead&0xf) + case 2: + b1, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + b2, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + // lead bits 0-3 are the lsb of the length nybble + pkgLen = uint32(b2)<<12 | uint32(b1)<<4 | uint32(lead&0xf) + case 3: + b1, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + b2, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + b3, err := p.r.ReadByte() + if err != nil { + p.r.SetOffset(origOffset) + return 0, parseResultFailed + } + + // lead bits 0-3 are the lsb of the length nybble + pkgLen = uint32(b3)<<20 | uint32(b2)<<12 | uint32(b1)<<4 | uint32(lead&0xf) + } + + return pkgLen, parseResultOk +} + +// parseNumConstant parses a byte/word/dword or qword value from the AML bytestream. +func (p *Parser) parseNumConstant(numBytes uint8) (uint64, parseResult) { + var ( + next byte + err error + res uint64 + ) + + for c := uint8(0); c < numBytes; c++ { + if next, err = p.r.ReadByte(); err != nil { + return 0, parseResultFailed + } + + res = res | (uint64(next) << (8 * c)) + } + + return res, parseResultOk +} + +// parseString parses a string from the AML bytestream and returns back a +// []byte pointing at its contents. +func (p *Parser) parseString() ([]byte, parseResult) { + // Read ASCII chars till we reach a null byte + var ( + next byte + err error + res = parseResultOk + str = reflect.SliceHeader{Data: p.r.DataPtr()} + ) + + for { + next, err = p.r.ReadByte() + if err != nil { + res = parseResultFailed + break + } + + if next == 0x00 { + break + } else if next >= 0x01 && next <= 0x7f { // AsciiChar + str.Len++ + } else { + res = parseResultFailed + break + } + } + + str.Cap = str.Len + return *(*[]byte)(unsafe.Pointer(&str)), res +} + +// parseNameString parses a NameString from the AML bytestream and returns back +// a []byte pointing at its contents. +// +// Grammar: +// NameString := RootChar NamePath | PrefixPath NamePath +// PrefixPath := Nothing | '^' PrefixPath +// NamePath := NameSeg | DualNamePath | MultiNamePath | NullName +func (p *Parser) parseNameString() ([]byte, parseResult) { + var ( + res = parseResultOk + str = reflect.SliceHeader{Data: p.r.DataPtr()} + next byte + err error + startOffset = p.r.Offset() + endOffset uint32 + ) + + // Skip over RootChar ('\') and Caret ('^') prefixes + for { + if next, err = p.r.PeekByte(); err != nil { + return nil, parseResultFailed + } + + if next != '\\' && next != '^' { + break + } + + _, _ = p.r.ReadByte() + } + + // Decode NamePath; note: the for loop above has already checked whether the + // next byte is readable via the call to PeekByte. This call to read will + // never error. + next, _ = p.r.ReadByte() + + switch next { + case 0x00: // NullName (null string or a name terminator) + startOffset = p.r.Offset() + // return empty string + case 0x2e: // DualNamePath := DualNamePrefix NameSeg NameSeg + endOffset = p.r.Offset() + uint32(amlNameLen*2) + if endOffset > p.r.pkgEnd { + return nil, parseResultFailed + } + p.r.SetOffset(endOffset) + case 0x2f: // MultiNamePath := MultiNamePrefix SegCount NameSeg(SegCount) + segCount, err := p.r.ReadByte() + if segCount == 0 || err != nil { + return nil, parseResultFailed + } + + endOffset = p.r.Offset() + uint32(amlNameLen*segCount) + if endOffset > p.r.pkgEnd { + return nil, parseResultFailed + } + + p.r.SetOffset(endOffset) + default: // NameSeg := LeadNameChar NameChar NameChar NameChar + // LeadNameChar := 'A' - 'Z' | '_' + if (next < 'A' || next > 'Z') && next != '_' { + return nil, parseResultFailed + } + + endOffset = p.r.Offset() + uint32(amlNameLen-1) + if endOffset > p.r.pkgEnd { + return nil, parseResultFailed + } + + // Skip past the remaning amlNameLen-1 chars + p.r.SetOffset(endOffset) + } + + str.Len = int(p.r.Offset() - startOffset) + str.Cap = str.Len + return *(*[]byte)(unsafe.Pointer(&str)), res +} + +// peekNextOpcode returns the next opcode in the stream without advancing the +// stream pointer. +func (p *Parser) peekNextOpcode() (uint16, parseResult) { + curOffset := p.r.Offset() + op, res := p.nextOpcode() + p.r.SetOffset(curOffset) + + return op, res +} + +// nextOpcode decodes an AML opcode from the stream. +func (p *Parser) nextOpcode() (uint16, parseResult) { + var ( + opLen uint32 = 1 + op uint16 + ) + + next, err := p.r.ReadByte() + if err != nil { + return 0xffff, parseResultFailed + } + + op = uint16(next) + + if next == extOpPrefix { + op = 0xff + if next, err = p.r.ReadByte(); err != nil { + _ = p.r.UnreadByte() + return 0xffff, parseResultFailed + } + + opLen++ + op += uint16(next) + } + + // If this is not a valid opcode, rewind the stream. + if pOpcodeTableIndex(op, false) == badOpcode { + p.r.SetOffset(p.r.Offset() - opLen) + return 0xffff, parseResultFailed + } + + return op, parseResultOk +} + +// scopeCurrent returns the currently active scope. +func (p *Parser) scopeCurrent() *Object { + return p.objTree.ObjectAt(p.scopeStack[len(p.scopeStack)-1]) +} + +// scopeEnter enters the given scope. +func (p *Parser) scopeEnter(index uint32) { + p.scopeStack = append(p.scopeStack, index) +} + +// scopeExit exits the current scope. +func (p *Parser) scopeExit() { + p.scopeStack = p.scopeStack[:len(p.scopeStack)-1] +} + +func (p *Parser) pushPkgEnd(pkgEnd uint32) error { + p.pkgEndStack = append(p.pkgEndStack, pkgEnd) + return p.r.SetPkgEnd(pkgEnd) +} + +func (p *Parser) popPkgEnd() { + p.pkgEndStack = p.pkgEndStack[:len(p.pkgEndStack)-1] + if len(p.pkgEndStack) != 0 { + _ = p.r.SetPkgEnd(p.pkgEndStack[len(p.pkgEndStack)-1]) + } +} + +// connectNamedObjArgs visits each named object in the AML tree and populates +// any missing args by consuming the object's siblings. +func (p *Parser) connectNamedObjArgs(objIndex uint32) parseResult { + var ( + obj = p.objTree.ObjectAt(objIndex) + argObj *Object + argFlags pOpArgTypeList + argCount uint8 + termArgIndex uint8 + namepath []byte + nameIndex int + ok bool + ) + + // The arg list must be visited in reverse order to handle nesting + for argIndex := obj.lastArgIndex; argIndex != InvalidIndex; argIndex = argObj.prevSiblingIndex { + // Recursively process children first + argObj = p.objTree.ObjectAt(argIndex) + if p.connectNamedObjArgs(argObj.index) != parseResultOk { + return parseResultFailed + } + + // Ignore non-named objects and objects not defined by the table currently parsed + if pOpcodeTable[argObj.infoIndex].flags&pOpFlagNamed == 0 || argObj.tableHandle != p.tableHandle || argObj.firstArgIndex == InvalidIndex || argObj.opcode == pOpIntScopeBlock { + continue + } + + // Named opcodes contain a namepath as the first arg + if namepath, ok = p.objTree.ObjectAt(argObj.firstArgIndex).value.([]byte); !ok { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] named object of type %s without a valid name\n", p.tableName, argObj.amlOffset, pOpcodeName(argObj.opcode)) + return parseResultFailed + } + + // The last amlNameLen contain the name for this object + nameIndex = len(namepath) - amlNameLen + for i := 0; i < amlNameLen; i++ { + argObj.name[i] = namepath[nameIndex+i] + } + + // Check if this object's args specify a TermObj/DataRefObj which + // would cause the parser to consume any object found till the + // enclosing package end. + argFlags = pOpcodeTable[argObj.infoIndex].argFlags + argCount = argFlags.argCount() + for termArgIndex = 0; termArgIndex < argCount; termArgIndex++ { + if argType := argFlags.arg(termArgIndex); argType == pArgTypeTermArg || argType == pArgTypeDataRefObj { + break + } + } + + // All args connected OR no term args; assume object has been completely parsed + if p.objTree.NumArgs(argObj) == uint32(argCount) || termArgIndex >= argCount { + continue + } + + // The parser has already attached args [0, termArgIndex) to + // the object and has parsed the remaining args as siblings to + // the object. Detach the missing args from the sibling list and + // attach them to object. + if p.attachSiblingsAsArgs(obj, argObj, argCount-termArgIndex, false) != parseResultOk { + return parseResultFailed + } + } + + return parseResultOk +} + +// mergeScopeDirectives visits pOpScope objects inside non-executable blocks +// and attempts to merge their contents to the scope referenced by the Scope +// directive. +func (p *Parser) mergeScopeDirectives(objIndex uint32) parseResult { + var ( + res = parseResultOk + obj = p.objTree.ObjectAt(objIndex) + firstArgIndex = obj.firstArgIndex + ) + + if objIndex == 0 { + p.mergedScopes = 0 + } + + // Ignore executable section contents + if pOpcodeTable[obj.infoIndex].flags&pOpFlagExecutable != 0 { + return res + } + + if obj.opcode == pOpScope && obj.tableHandle == p.tableHandle { + if obj.firstArgIndex == InvalidIndex { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] malformed scope object\n", p.tableName, obj.amlOffset) + return parseResultFailed + } + + // Lookup target and make sure it resolves to a scoped object + nameObj := p.objTree.ObjectAt(obj.firstArgIndex) + targetName := nameObj.value.([]byte) + targetIndex := p.objTree.Find(obj.parentIndex, targetName) + + // If the lookup failed we may need to run a couple more mergeScopeDirectives / + // relocateNamedObjects passes to resolve things. If however no objects got + // relocated in the previous pass then report this as an error. + if targetIndex == InvalidIndex { + if p.resolvePasses > 1 && p.relocatedObjects == 0 { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unable to resolve reference to scope \"%s\"\n", p.tableName, obj.amlOffset, targetName) + return parseResultFailed + } + return parseResultRequireExtraPass + } + + // Unless the new parent is an pOpIntScopeBlock it will contain a nested + // pOpIntScopeBlock which is where we should actually attach obj + targetObj := p.objTree.ObjectAt(targetIndex) + if targetObj.opcode != pOpIntScopeBlock { + for targetIndex, targetObj = targetObj.firstArgIndex, nil; targetIndex != InvalidIndex; targetIndex = p.objTree.ObjectAt(targetIndex).nextSiblingIndex { + if nextObj := p.objTree.ObjectAt(targetIndex); nextObj.opcode == pOpIntScopeBlock { + targetObj = nextObj + break + } + } + + if targetObj == nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] reference to scope \"%s\" resolved to non-scope object\n", p.tableName, obj.amlOffset, targetName) + return parseResultFailed + } + } + + // Relocate contents to the new scope + contentsObj := p.objTree.ObjectAt(obj.lastArgIndex) + firstArgIndex = contentsObj.firstArgIndex + for siblingIndex := firstArgIndex; siblingIndex != InvalidIndex; { + argObj := p.objTree.ObjectAt(siblingIndex) + siblingIndex = argObj.nextSiblingIndex + + p.objTree.detach(contentsObj, argObj) + p.objTree.append(targetObj, argObj) + } + + // The scope object and its children can now be freed + p.objTree.free(nameObj) + p.objTree.free(contentsObj) + p.objTree.free(obj) + p.mergedScopes++ + } + + // Recursively process nested objects + for siblingIndex := firstArgIndex; siblingIndex != InvalidIndex; { + argObj := p.objTree.ObjectAt(siblingIndex) + siblingIndex = argObj.nextSiblingIndex + + switch p.mergeScopeDirectives(argObj.index) { + case parseResultFailed: + return parseResultFailed + case parseResultRequireExtraPass: + res = parseResultRequireExtraPass + } + } + + return res +} + +// relocateNamedObjects processes named objects whose name contains a relative +// or absolute path prefix and moves the objects to the appropriate parent. +func (p *Parser) relocateNamedObjects(objIndex uint32) parseResult { + var ( + obj = p.objTree.ObjectAt(objIndex) + flags = pOpcodeTable[obj.infoIndex].flags + argObj, targetObj *Object + targetIndex uint32 + nameIndex int + namepath []byte + ok bool + res = parseResultOk + ) + + if objIndex == 0 { + p.relocatedObjects = 0 + } + + // Ignore executable section contents + if flags&pOpFlagExecutable != 0 { + return res + } + + if flags&pOpFlagNamed != 0 && obj.firstArgIndex != InvalidIndex && obj.tableHandle == p.tableHandle && obj.opcode != pOpIntScopeBlock { + // This is a named object. Check if its namepath requires relocation + if namepath, ok = p.objTree.ObjectAt(obj.firstArgIndex).value.([]byte); !ok { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] named object of type %s without a valid name\n", p.tableName, obj.amlOffset, pOpcodeName(obj.opcode)) + return parseResultFailed + } + + // If the namepath is longer than amlNameLen then it's a scoped path + // expression that needs to be resolved using the closest named ancestor as + // the scope. If the resolve succeeds, the object will be attached to the + // resolved parent and the namepath will be cleaned up. + if nameIndex = len(namepath) - amlNameLen; nameIndex > 0 { + targetIndex = p.objTree.Find(p.objTree.ClosestNamedAncestor(obj), namepath[:nameIndex]) + if targetIndex == InvalidIndex { + if p.resolvePasses > maxResolvePasses { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unable to resolve relocation path %s for object of type %s after %d passes; aborting\n", p.tableName, obj.amlOffset, namepath[:], pOpcodeName(obj.opcode), p.resolvePasses) + return parseResultFailed + } + return parseResultRequireExtraPass + } + + targetObj = p.objTree.ObjectAt(targetIndex) + if targetObj.opcode != pOpIntScopeBlock { + for targetIndex, targetObj = targetObj.firstArgIndex, nil; targetIndex != InvalidIndex; targetIndex = p.objTree.ObjectAt(targetIndex).nextSiblingIndex { + if nextObj := p.objTree.ObjectAt(targetIndex); nextObj.opcode == pOpIntScopeBlock { + targetObj = nextObj + break + } + } + + if targetObj == nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] relocation path \"%s\" resolved to non-scope object\n", p.tableName, obj.amlOffset, namepath[:]) + return parseResultFailed + } + } + p.objTree.detach(p.objTree.ObjectAt(obj.parentIndex), obj) + p.objTree.append(targetObj, obj) + p.objTree.ObjectAt(obj.firstArgIndex).value = namepath[nameIndex:] + p.relocatedObjects++ + } + } + + // Recursively process nested objects + for siblingIndex := obj.firstArgIndex; siblingIndex != InvalidIndex; { + argObj = p.objTree.ObjectAt(siblingIndex) + siblingIndex = argObj.nextSiblingIndex + + switch p.relocateNamedObjects(argObj.index) { + case parseResultFailed: + return parseResultFailed + case parseResultRequireExtraPass: + res = parseResultRequireExtraPass + } + } + + return res +} + +// parseDeferredBlocks attempts to parse any objects that contain objects that +// are flagged as deferred (e.g. Buffers and BankFields). +func (p *Parser) parseDeferredBlocks(objIndex uint32) parseResult { + obj := p.objTree.ObjectAt(objIndex) + if pOpcodeTable[obj.infoIndex].flags&pOpFlagDeferParsing != 0 && obj.tableHandle == p.tableHandle { + p.mode = parseModeAllBlocks + + // Set stream offset to the first arg + p.r.SetOffset(obj.amlOffset + 1) + if obj.opcode > 0xff { // opcode length = 2 + _, _ = p.r.ReadByte() + } + + if p.parseObjectArgs(obj) != parseResultOk { + return parseResultFailed + } + + // As we are using a different parse flow than the one used for + // non-deferred we need to manually clean up the pkgEndStack after the + // object has been parsed. + for len(p.pkgEndStack) != 0 { + p.popPkgEnd() + } + + // The parseObjectArgs() call has parsed all children of the deferred node. + // At this point we can simply return without processing the children. + return parseResultOk + } + + // Recursively process children + for argIndex := obj.firstArgIndex; argIndex != InvalidIndex; argIndex = p.objTree.ObjectAt(argIndex).nextSiblingIndex { + if p.parseDeferredBlocks(argIndex) != parseResultOk { + return parseResultFailed + } + } + + return parseResultOk +} + +// connectNonNamedObjArgs behaves in a similar way as connectNamedObjArgs but +// only operates on non-named objects. +func (p *Parser) connectNonNamedObjArgs(objIndex uint32) parseResult { + var ( + obj = p.objTree.ObjectAt(objIndex) + argObj *Object + argFlags pOpArgTypeList + argCount uint8 + termArgIndex uint8 + ) + + // The arg list must be visited in reverse order to handle nesting + for argIndex := obj.lastArgIndex; argIndex != InvalidIndex; argIndex = argObj.prevSiblingIndex { + // Recursively process children first + argObj = p.objTree.ObjectAt(argIndex) + if p.connectNonNamedObjArgs(argObj.index) != parseResultOk { + return parseResultFailed + } + + // Ignore named objects and objects not defined by the table currently parsed + if pOpcodeTable[argObj.infoIndex].flags&pOpFlagNamed != 0 || argObj.tableHandle != p.tableHandle { + continue + } + + // Check if this object's args specify a TermObj/DataRefObj which + // would cause the parser to consume any object found till the + // enclosing package end. + argFlags = pOpcodeTable[argObj.infoIndex].argFlags + argCount = argFlags.argCount() + for termArgIndex = 0; termArgIndex < argCount; termArgIndex++ { + if argType := argFlags.arg(termArgIndex); argType == pArgTypeTermArg || argType == pArgTypeDataRefObj { + break + } + } + + // No term args OR we have parsed beyond the TermArg; assume object has been completely parsed + if termArgIndex >= argCount || p.objTree.NumArgs(argObj) > uint32(termArgIndex) { + continue + } + + // The parser has already attached args [0, termArgIndex) to + // the object and has parsed the remaining args as siblings to + // the object. Detach the missing args from the sibling list and + // attach them to object. The following call may also return back + // parseResultRequireExtraPass which is OK at this stage. + if p.attachSiblingsAsArgs(obj, argObj, argCount-termArgIndex, true) == parseResultFailed { + return parseResultFailed + } + } + + return parseResultOk +} + +// resolveMethodCalls visits each object with the pOpIntNamePathOrMethodCall +// opcode and resolves it to either a pOpIntMethodCall or a pOpIntNamePath based +// on the result of a lookup using the attached namepath. +// +// If the namepath lookup resolves into a method definition, the object will be +// mutated into an pOpIntMethodCall and the expected number of arguments (as +// specified by the referenced method) will be extracted from the object's +// sibling list. +// +// If the nemepath resolves into a non-method object then the object will be +// instead mutated into an pOpIntResolvedNamePath. +// +// If the lookup fails, then the object will be mutated into an pOpIntNamePath +// to be resolved at run-time. +func (p *Parser) resolveMethodCalls(objIndex uint32) parseResult { + var ( + obj = p.objTree.ObjectAt(objIndex) + ok bool + argObj, resolvedObj *Object + argCount uint64 + targetIndex uint32 + ) + + // The arg list must be visited in reverse order to handle nesting: + // FOOF( BARB(1,2), 3) will appear in the stream as: FOOF BARB 1 2 3 + // By processing the objects in reverse order we sequentially transform + // the object list as follows: + // FOOF BARB(1,2) 3 + // FOOF( BARB(1,2), 3) + for argIndex := obj.lastArgIndex; argIndex != InvalidIndex; argIndex = argObj.prevSiblingIndex { + // Recursively process children first + argObj = p.objTree.ObjectAt(argIndex) + if p.resolveMethodCalls(argObj.index) != parseResultOk { + return parseResultFailed + } + + if argObj.opcode != pOpIntNamePathOrMethodCall || argObj.tableHandle != p.tableHandle { + continue + } + + // Resolve namepath + targetIndex = p.objTree.Find(argObj.parentIndex, argObj.value.([]byte)) + switch targetIndex { + case InvalidIndex: + // Treat this as a namepath to be resolved at run-time + argObj.opcode = pOpIntNamePath + argObj.infoIndex = pOpcodeTableIndex(argObj.opcode, true) + default: + resolvedObj = p.objTree.ObjectAt(targetIndex) + + switch resolvedObj.opcode { + case pOpMethod: + // Mutate into a method call with value pointing at the resolved method index + argObj.opcode = pOpIntMethodCall + argObj.infoIndex = pOpcodeTableIndex(argObj.opcode, true) + argObj.value = resolvedObj.index + + // Consume the required number of args which are encoded as + // bits [0:2] of the method obj 2nd arg + methodFlagsObj := p.objTree.ArgAt(resolvedObj, 1) + if methodFlagsObj == nil { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] target method \"%s\" is missing a flag object\n", p.tableName, argObj.amlOffset, resolvedObj.name[:]) + return parseResultFailed + } + + argCount, ok = methodFlagsObj.value.(uint64) + if !ok { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] target method \"%s\" contains a malformed flag object\n", p.tableName, argObj.amlOffset, resolvedObj.name[:]) + return parseResultFailed + } + + if p.attachSiblingsAsArgs(obj, argObj, uint8(argCount&0x7), true) != parseResultOk { + return parseResultFailed + } + default: + // Mutate into a resolved name path with value pointing at the resolved object intdex + argObj.opcode = pOpIntResolvedNamePath + argObj.infoIndex = pOpcodeTableIndex(argObj.opcode, true) + argObj.value = resolvedObj.index + } + } + } + + return parseResultOk +} + +// attachSiblingsAsArgs detaches numArgs sibling nodes of targetObj and +// re-attaches them as args to targetObj. If we run out of sibling nodes and +// useParentSiblings is set to true, then attachSiblingsAsArgs will continue +// detaching siblings from the parent +func (p *Parser) attachSiblingsAsArgs(parentObj, targetObj *Object, numArgs uint8, useParentSiblings bool) parseResult { + var siblingObj *Object + + for siblingIndex := targetObj.nextSiblingIndex; numArgs > 0; numArgs-- { + if siblingIndex == InvalidIndex && useParentSiblings { + siblingIndex = parentObj.nextSiblingIndex + } + + if siblingIndex == InvalidIndex { + kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] unexpected arg count for opcode: %s (0x%x)\n", p.tableName, targetObj.amlOffset, pOpcodeName(targetObj.opcode), targetObj.opcode) + return parseResultFailed + } + + // Update siblingIndex before siblingObj gets detached + siblingObj = p.objTree.ObjectAt(siblingIndex) + siblingIndex = siblingObj.nextSiblingIndex + + p.objTree.detach(parentObj, siblingObj) + p.objTree.append(targetObj, siblingObj) + } + return parseResultOk +} diff --git a/src/gopheros/device/acpi/aml/parser_test.go b/src/gopheros/device/acpi/aml/parser_test.go new file mode 100644 index 0000000..d579994 --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser_test.go @@ -0,0 +1,905 @@ +package aml + +import ( + "bytes" + "gopheros/device/acpi/table" + "io/ioutil" + "os" + "reflect" + "testing" + "unsafe" +) + +func TestParseAMLErrors(t *testing.T) { + t.Run("parseObjectList failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{uint8(pOpBuffer)}) + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("connectNamedObjArgs failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + namedObj := p.objTree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + p.objTree.append(namedObj, p.objTree.newObject(pOpDwordPrefix, 0)) + p.objTree.append(p.objTree.ObjectAt(1), namedObj) // Attach to first child of root scope + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("mergeScopeDirectives failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + scopeDirective := p.objTree.newObject(pOpScope, 0) + p.objTree.append(p.objTree.ObjectAt(1), scopeDirective) // Attach to first child of root scope + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("relocateNamedObjects failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + namedObj := p.objTree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepath := p.objTree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'^', '^', 'F', 'O', 'O', 'F'} + target := p.objTree.newObject(pOpOnes, 0) + p.objTree.append(namedObj, namepath) + p.objTree.append(namedObj, target) + p.objTree.append(p.objTree.ObjectAt(0), namedObj) + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("parseDeferredBlocks failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + // Attach a deferred block to the first child of the root scope + def := p.objTree.newObject(pOpBankField, 0) + def.pkgEnd = 1 + p.objTree.append(p.objTree.ObjectAt(1), def) + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("resolveMethodCalls failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + method := p.objTree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'M', 'T', 'H', 'D'}) + namepath := p.objTree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'M', 'T', 'H', 'D'} + p.objTree.append(method, namepath) + p.objTree.append(p.objTree.ObjectAt(0), method) + + inv := p.objTree.newObject(pOpIntNamePathOrMethodCall, 0) + inv.value = []byte{'M', 'T', 'H', 'D'} + p.objTree.append(p.objTree.ObjectAt(0), inv) + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) + + t.Run("connectNonNamedObjArgs failed", func(t *testing.T) { + p, resolver := parserForMockPayload(t, []byte{}) + + // Use a named object whose args contain a TermArg + obj := p.objTree.newObject(pOpMatch, 0) + p.objTree.append(p.objTree.ObjectAt(0), obj) + + if err := p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")); err != errParsingAML { + t.Fatalf("expected to get errParsingAML; got: %v", err) + } + }) +} + +func TestParseObjectListErrors(t *testing.T) { + p, _ := parserForMockPayload(t, []byte{uint8(pOpBuffer)}) + p.scopeEnter(0) + if res := p.parseObjectList(); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestParseArgErrors(t *testing.T) { + info := new(pOpcodeInfo) + obj := new(Object) + + t.Run("parsePkgLength error", func(t *testing.T) { + // Incomplete pkg length + p, _ := parserForMockPayload(t, []byte{0xff}) + if _, res := p.parseArg(info, obj, pArgTypePkgLen); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("invalid pkgLen", func(t *testing.T) { + p, _ := parserForMockPayload(t, []byte{0x4}) + if _, res := p.parseArg(info, obj, pArgTypePkgLen); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("parseTermList error", func(t *testing.T) { + p, _ := parserForMockPayload(t, []byte{extOpPrefix}) + p.mode = parseModeAllBlocks + if _, res := p.parseArg(info, obj, pArgTypeTermList); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestParseNameOrMethodCallErrors(t *testing.T) { + payload := []byte{ + // Namestring + 'F', 'O', 'O', 'F', + } + + t.Run("path not resolving to entity", func(t *testing.T) { + p, _ := parserForMockPayload(t, payload) + p.scopeEnter(0) + + p.mode = parseModeAllBlocks + if res := p.parseNamePathOrMethodCall(); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("incomplete method call", func(t *testing.T) { + p, _ := parserForMockPayload(t, payload) + p.mode = parseModeAllBlocks + + // Add a method FOOF object as a child of the root scope and set it up + // so that it requires 1 arg. + method := p.objTree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + p.objTree.append(p.objTree.ObjectAt(0), method) + + p.objTree.append(method, p.objTree.newObject(pOpIntNamePath, 0)) + argCountObj := p.objTree.newObject(pOpBytePrefix, 0) + argCountObj.value = uint64(1) + p.objTree.append(method, argCountObj) + + // Enter one of the default child scopes of the root scope + // so the lookup for FOOF yields the object we just appended. + p.scopeEnter(1) + + p.mode = parseModeAllBlocks + if res := p.parseNamePathOrMethodCall(); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestParseStrictTermArgErrors(t *testing.T) { + // Set up the stream to include a non-Type2/arg opcode + p, _ := parserForMockPayload(t, []byte{uint8(pOpMethod)}) + p.scopeEnter(0) + + p.mode = parseModeAllBlocks + if _, res := p.parseStrictTermArg(new(Object)); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestParseSimpleArg(t *testing.T) { + specs := []struct { + payload []byte + argType pArgType + expRes parseResult + expVal interface{} + }{ + { + []byte{0x32}, + pArgTypeByteData, + parseResultOk, + uint64(0x32), + }, + { + []byte{0x32, 0x33}, + pArgTypeWordData, + parseResultOk, + uint64(0x3332), + }, + { + []byte{0x32, 0x33, 0x34, 0x35}, + pArgTypeDwordData, + parseResultOk, + uint64(0x35343332), + }, + { + []byte{0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39}, + pArgTypeQwordData, + parseResultOk, + uint64(0x3938373635343332), + }, + { + []byte{'F', 'O', 'O', 0x00}, + pArgTypeString, + parseResultOk, + []byte{'F', 'O', 'O'}, + }, + { + []byte{'^', '^', 'F', 'O', 'O', 'F'}, + pArgTypeNameString, + parseResultOk, + []byte{'^', '^', 'F', 'O', 'O', 'F'}, + }, + // unsupported arg type + { + []byte{}, + pArgTypeFieldList, + parseResultFailed, + nil, + }, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec.payload) + obj, res := p.parseSimpleArg(spec.argType) + if res != spec.expRes { + t.Errorf("[spec %d] expected to get parse result %d; got %d", specIndex, spec.expRes, res) + continue + } + + if obj != nil && !reflect.DeepEqual(obj.value, spec.expVal) { + t.Errorf("[spec %d] expected to get value \"%v\"; got \"%v\"", specIndex, spec.expVal, obj.value) + } + } +} + +func TestParseTargetErrors(t *testing.T) { + // Set up the stream to include an un-expected opcode + p, _ := parserForMockPayload(t, []byte{uint8(pOpMethod)}) + p.scopeEnter(0) + + if _, res := p.parseTarget(); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestParseFieldElementsErrors(t *testing.T) { + genFieldObj := func(tree *ObjectTree) *Object { + field := tree.newObject(pOpField, 0) + flags := tree.newObject(pOpBytePrefix, 0) + flags.value = uint64(0xfe) + tree.append(field, flags) + tree.append(tree.ObjectAt(0), field) + return field + } + + specs := []struct { + descr string + payload []byte + }{ + { + "reserved field parsePkgLength error", + []byte{ + 0x00, // ReservedField + }, + }, + { + "access field access type parse error", + []byte{ + 0x01, // AccessField + }, + }, + { + "access field access attrib parse error", + []byte{ + 0x01, // AccessField + 0x01, // AccessType + }, + }, + { + "ext. access field access type parse error", + []byte{ + 0x03, // ExtendedAccessField + }, + }, + { + "ext. access field access attrib parse error", + []byte{ + 0x03, // ExtendedAccessField + 0x01, // AccessType + }, + }, + { + "ext. access field access length parse error", + []byte{ + 0x03, // ExtendedAccessField + 0x01, // AccessType + 0x02, // AccessAttrib + }, + }, + { + "EOF parsing connection", + []byte{ + 0x02, // Connection + }, + }, + { + "connection buffer data parsePkgLength error", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + }, + }, + { + "connection buffer length exceeds stream length", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + 0x5, // pkgLen + }, + }, + { + "connection bad opcode type for buffer size", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + 0x1, // pkgLen + extOpPrefix, + }, + }, + { + "connection bad word buffer size", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + 0x2, // pkgLen + uint8(pOpWordPrefix), + 0x1, // missing next byte + }, + }, + { + "connection bad dword buffer size", + []byte{ + 0x02, // Connection + uint8(pOpBuffer), + 0x3, // pkgLen + uint8(pOpDwordPrefix), + 0x1, 0x2, 0x3, // missing next byte + }, + }, + { + "connection parse namestring error", + []byte{ + 0x02, // Connection + '^', + }, + }, + { + "incomplete named field name", + []byte{ + 'F', 'O', 'O', // missing last character + }, + }, + { + "error parsing named field pkgLength", + []byte{ + 'F', 'O', 'O', 'F', + 0xff, // incomplete pkg length + }, + }, + } + + for _, spec := range specs { + t.Run(spec.descr, func(t *testing.T) { + p, _ := parserForMockPayload(t, spec.payload) + if res := p.parseFieldElements(genFieldObj(p.objTree)); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + } +} + +func TestParsePkgLength(t *testing.T) { + specs := []struct { + payload []byte + exp uint32 + }{ + // lead byte bits (6:7) indicate 1 extra byte for the len. The + // parsed length will use bits 0:3 from the lead byte plus + // the full 8 bits of the following byte. + { + []byte{1<<6 | 7, 255}, + 4087, + }, + // lead byte bits (6:7) indicate 2 extra bytes for the len. The + // parsed length will use bits 0:3 from the lead byte plus + // the full 8 bits of the following bytes. + { + []byte{2<<6 | 8, 255, 128}, + 528376, + }, + // lead byte bits (6:7) indicate 3 extra bytes for the len. The + // parsed length will use bits 0:3 from the lead byte plus + // the full 8 bits of the following bytes. + { + []byte{3<<6 | 6, 255, 128, 42}, + 44568566, + }, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec.payload) + got, res := p.parsePkgLength() + + if res != parseResultOk { + t.Errorf("[spec %d] expected to get parseResultOk(%d); got %d", specIndex, parseResultOk, res) + continue + } + + if got != spec.exp { + t.Errorf("[spec %d] expected parsePkgLength to return %d; got %d", specIndex, spec.exp, got) + } + } +} + +func TestParsePkgLengthErrors(t *testing.T) { + specs := [][]byte{ + // lead byte bits (6:7) indicate 1 extra byte that is missing + []byte{1 << 6}, + // lead byte bits (6:7) indicate 2 extra bytes with the 1st and then 2nd missing + []byte{2 << 6}, + []byte{2 << 6, 0x1}, + // lead byte bits (6:7) indicate 3 extra bytes with the 1st and then 2nd and then 3rd missing + []byte{3 << 6}, + []byte{3 << 6, 0x1}, + []byte{3 << 6, 0x1, 0x2}, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec) + if _, res := p.parsePkgLength(); res != parseResultFailed { + t.Errorf("[spec %d] expected to get parseResultFailed(%d); got %d", specIndex, parseResultFailed, res) + } + } +} + +func TestParseStringErrors(t *testing.T) { + specs := [][]byte{ + // Unexpected EOF before terminating null byte + []byte{'A'}, + // Characters outside the allowed [0x01, 0x7f] range + []byte{'A', 0xba, 0xdf, 0x00}, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec) + + if _, res := p.parseString(); res != parseResultFailed { + t.Errorf("[spec %d] expected to get parseResultFailed(%d); got %d", specIndex, parseResultFailed, res) + } + } +} + +func TestParseNamestring(t *testing.T) { + specs := []struct { + payload []byte + expRes parseResult + expVal []byte + }{ + { + []byte{0x00}, + parseResultOk, + []byte{}, + }, + { + // NameSeg with root prefix + []byte{'\\', '_', 'F', 'O', 'O'}, + parseResultOk, + []byte{'\\', '_', 'F', 'O', 'O'}, + }, + { + // DualNamePath + []byte{0x2e, 'F', 'O', 'O', 'F', 'B', 'A', 'R', 'B'}, + parseResultOk, + []byte{0x2e, 'F', 'O', 'O', 'F', 'B', 'A', 'R', 'B'}, + }, + { + // MultiNamePath with caret prefix + []byte{'^', '^', + 0x2f, + 0x3, // 3 segments + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + }, + parseResultOk, + []byte{'^', '^', + 0x2f, + 0x3, // 3 segments + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + }, + }, + { + // Unexpected EOF after prefix + []byte{'^'}, + parseResultFailed, + nil, + }, + { + // Unexpected EOF in DualNamePath + []byte{0x2e, 'F', 'O', 'O', 'F', 'B', 'A', 'R'}, // missing last char + parseResultFailed, + nil, + }, + { + // Unexpected EOF reading SegCount in MultiNamePath + []byte{'^', '^', + 0x2f, + // missing segment count + }, + parseResultFailed, + nil, + }, + { + // Unexpected EOF in MultiNamePath + []byte{'^', '^', + 0x2f, + 0x3, // 3 segments + 'F', 'O', 'O', 'F', + 'F', 'O', 'O', 'F', + // missing third segment + }, + parseResultFailed, + nil, + }, + { + // Unexpected EOF in NameSeg + []byte{'F', 'O', 'O'}, // missing last char + parseResultFailed, + nil, + }, + { + // Invalid lead char for NameSeg + []byte{'0', 'F', 'O', 'O'}, + parseResultFailed, + nil, + }, + } + + for specIndex, spec := range specs { + p, _ := parserForMockPayload(t, spec.payload) + obj, res := p.parseNameString() + if res != spec.expRes { + t.Errorf("[spec %d] expected to get parse result %d; got %d", specIndex, spec.expRes, res) + continue + } + + if obj != nil && !reflect.DeepEqual(obj, spec.expVal) { + t.Errorf("[spec %d] expected to get value \"%v\"; got \"%v\"", specIndex, spec.expVal, obj) + } + } +} + +func TestConnectNamedObjectsErrors(t *testing.T) { + t.Run("first arg is not a namepath", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + namedObj := tree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + tree.append(namedObj, tree.newObject(pOpDwordPrefix, 0)) + tree.append(tree.ObjectAt(1), namedObj) // Attach to first child of root scope + + p := NewParser(ioutil.Discard, tree) + if res := p.connectNamedObjArgs(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("named object arg count mismatch", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + // Use a named object whose args contain a TermArg + namedObj := tree.newNamedObject(pOpBankField, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'F', 'O', 'O', 'F'} + tree.append(namedObj, namepathObj) + tree.append(tree.ObjectAt(0), namedObj) + + p := NewParser(ioutil.Discard, tree) + if res := p.connectNamedObjArgs(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestMergeScopeDirectivesErrors(t *testing.T) { + t.Run("malformed scope object", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + scopeDirective := tree.newObject(pOpScope, 0) + tree.append(tree.ObjectAt(1), scopeDirective) // Attach to first child of root scope + + p := NewParser(ioutil.Discard, tree) + if res := p.mergeScopeDirectives(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("unable to resolve scope reference", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + scopeDirective := tree.newObject(pOpScope, 0) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'F', 'O', 'O', 'F'} + tree.append(scopeDirective, namepathObj) + tree.append(tree.ObjectAt(1), scopeDirective) // Attach to first child of root scope + + // Simulate second mergeScopes attempt + p := NewParser(ioutil.Discard, tree) + p.resolvePasses = 2 + + if res := p.mergeScopeDirectives(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("scope target resolves to obj without IntScopeBlock child", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + scopeDirective := tree.newObject(pOpScope, 0) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'D', 'E', 'V', '0'} + tree.append(scopeDirective, namepathObj) + tree.append(tree.ObjectAt(1), scopeDirective) // Attach to first child of root scope + + tree.append(tree.ObjectAt(0), tree.newNamedObject(pOpDevice, 0, [amlNameLen]byte{'D', 'E', 'V', '0'})) + + // Simulate second mergeScopes attempt + p := NewParser(ioutil.Discard, tree) + p.resolvePasses = 2 + + if res := p.mergeScopeDirectives(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestRelocateNamedObjectsErrors(t *testing.T) { + t.Run("first arg is not a namepath", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + namedObj := tree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + tree.append(namedObj, tree.newObject(pOpDwordPrefix, 0)) + tree.append(tree.ObjectAt(1), namedObj) // Attach to first child of root scope + + p := NewParser(ioutil.Discard, tree) + if res := p.relocateNamedObjects(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("unresolved relocation target", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + scope := tree.newNamedObject(pOpIntScopeBlock, 0, [amlNameLen]byte{'S', 'C', 'O', 'P'}) + tree.append(tree.ObjectAt(1), scope) + + namedObj := tree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'^', '^', '^', '^', 'F', 'O', 'O', 'F'} + tree.append(namedObj, namepathObj) + tree.append(scope, namedObj) + + p := NewParser(ioutil.Discard, tree) + if res := p.relocateNamedObjects(0); res != parseResultRequireExtraPass { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultRequireExtraPass, res) + } + }) + + t.Run("unresolved relocation target after maxResolvePasses", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + namedObj := tree.newNamedObject(pOpName, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'^', '^', 'F', 'O', 'O', 'F'} + tree.append(namedObj, namepathObj) + + // call relocateNamedObjects on detached nameObj and simulate maxResolvePasses relocateNamedObjects calls + p := NewParser(ioutil.Discard, tree) + p.resolvePasses = maxResolvePasses + 1 + + if res := p.relocateNamedObjects(namedObj.index); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("resolve target resolves to obj without IntScopeBlock child", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + dev0 := tree.newNamedObject(pOpDevice, 0, [amlNameLen]byte{'D', 'E', 'V', '0'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'D', 'E', 'V', '0'} + tree.append(dev0, namepathObj) + tree.append(tree.ObjectAt(0), dev0) + + dev1 := tree.newNamedObject(pOpDevice, 0, [amlNameLen]byte{'D', 'E', 'V', '1'}) + namepathObj = tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'^', 'D', 'E', 'V', '1'} + tree.append(dev1, namepathObj) + + // place another named obj between dev0 and dev1 so that the caret in + // dev1 namepath resolves to dev0 + cpu0 := tree.newNamedObject(pOpProcessor, 0, [amlNameLen]byte{'C', 'P', 'U', '0'}) + namepathObj = tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'C', 'P', 'U', '0'} + tree.append(cpu0, namepathObj) + tree.append(dev0, cpu0) + tree.append(cpu0, dev1) + + p := NewParser(ioutil.Discard, tree) + if res := p.relocateNamedObjects(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func TestParseDeferredBlocksErrors(t *testing.T) { + p, _ := parserForMockPayload(t, []byte{extOpPrefix}) + + // Attach a deferred block to the first child of the root scope + def := p.objTree.newObject(pOpBankField, 0) + def.pkgEnd = 1 + p.objTree.append(p.objTree.ObjectAt(1), def) + + if res := p.parseDeferredBlocks(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestConnectNonNamedObjectsErrors(t *testing.T) { + // Allocate a tree but don't create default scopes to make sure that we lack + // the number of args (siblings OR parent's siblings) required for the pOpAdd opcode + tree := NewObjectTree() + root := tree.newObject(pOpIntScopeBlock, 0) + scope := tree.newObject(pOpIntScopeBlock, 0) + tree.append(root, scope) + + // Use a named object whose args contain a TermArg + obj := tree.newObject(pOpAdd, 0) + tree.append(scope, obj) + + p := NewParser(os.Stdout, tree) + if res := p.connectNonNamedObjArgs(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } +} + +func TestResolveMethodCallsErrors(t *testing.T) { + t.Run("method missing flag object", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + method := tree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'M', 'T', 'H', 'D'}) + namepath := tree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'M', 'T', 'H', 'D'} + tree.append(method, namepath) + tree.append(tree.ObjectAt(0), method) + + inv := tree.newObject(pOpIntNamePathOrMethodCall, 0) + inv.value = []byte{'M', 'T', 'H', 'D'} + tree.append(tree.ObjectAt(0), inv) + + p := NewParser(os.Stdout, tree) + if res := p.resolveMethodCalls(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("method contains malformed flag object", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + method := tree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'M', 'T', 'H', 'D'}) + namepath := tree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'M', 'T', 'H', 'D'} + flags := tree.newObject(pOpStringPrefix, 0) + flags.value = []byte{'F', 'O', 'O'} // malformed flags: this should be a uint64 + tree.append(method, namepath) + tree.append(method, flags) + tree.append(tree.ObjectAt(0), method) + + inv := tree.newObject(pOpIntNamePathOrMethodCall, 0) + inv.value = []byte{'M', 'T', 'H', 'D'} + tree.append(tree.ObjectAt(0), inv) + + p := NewParser(os.Stdout, tree) + if res := p.resolveMethodCalls(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + + t.Run("method call arg count mismatch", func(t *testing.T) { + // Allocate a tree but don't create default scopes to make sure that we lack + // the number of args (siblings OR parent's siblings) required for the method + // invocation + tree := NewObjectTree() + root := tree.newObject(pOpIntScopeBlock, 0) + scope := tree.newObject(pOpIntScopeBlock, 0) + tree.append(root, scope) + + // MTHD calls expect 6 args + method := tree.newNamedObject(pOpMethod, 0, [amlNameLen]byte{'M', 'T', 'H', 'D'}) + namepath := tree.newObject(pOpIntNamePath, 0) + namepath.value = []byte{'M', 'T', 'H', 'D'} + flags := tree.newObject(pOpBytePrefix, 0) + flags.value = uint64(0x6) + tree.append(method, namepath) + tree.append(method, flags) + tree.append(scope, method) + + inv := tree.newObject(pOpIntNamePathOrMethodCall, 0) + inv.value = []byte{'M', 'T', 'H', 'D'} + tree.append(scope, inv) + + p := NewParser(os.Stdout, tree) + if res := p.resolveMethodCalls(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) +} + +func parserForMockPayload(t *testing.T, payload []byte) (*Parser, table.Resolver) { + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + p := NewParser(&testWriter{t: t}, tree) + + resolver := mockByteDataResolver(payload) + + p.init(0, "DSDT", resolver.LookupTable("DSDT")) + return p, resolver +} + +type testWriter struct { + t *testing.T + buf bytes.Buffer +} + +func (t *testWriter) Write(data []byte) (int, error) { + for _, b := range data { + if b == '\n' { + t.t.Log(t.buf.String()) + t.buf.Reset() + continue + } + _ = t.buf.WriteByte(b) + } + + return len(data), nil +} + +type mockByteDataResolver []byte + +func (m mockByteDataResolver) LookupTable(string) *table.SDTHeader { + headerLen := unsafe.Sizeof(table.SDTHeader{}) + stream := make([]byte, int(headerLen)+len(m)) + copy(stream[headerLen:], m) + + header := (*table.SDTHeader)(unsafe.Pointer(&stream[0])) + header.Signature = [4]byte{'D', 'S', 'D', 'T'} + header.Length = uint32(len(stream)) + header.Revision = 2 + + return header +} From 9dd9ab9adddbbd22b26cd682905c4cec6d130fd3 Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 6 Mar 2018 08:20:21 +0000 Subject: [PATCH 07/10] acpi: add helper method to pretty-print AML object trees --- src/gopheros/device/acpi/aml/obj_tree.go | 200 +++++++++++++++++++++++ 1 file changed, 200 insertions(+) diff --git a/src/gopheros/device/acpi/aml/obj_tree.go b/src/gopheros/device/acpi/aml/obj_tree.go index f34ee5a..c8dd353 100644 --- a/src/gopheros/device/acpi/aml/obj_tree.go +++ b/src/gopheros/device/acpi/aml/obj_tree.go @@ -1,5 +1,11 @@ package aml +import ( + "bytes" + "gopheros/kernel/kfmt" + "io" +) + const ( // InvalidIndex is a sentinel value used by ObjectTree to indicate that // a returned object index is not valid. @@ -396,3 +402,197 @@ func (tree *ObjectTree) ArgAt(obj *Object, index uint32) *Object { return nil } + +// PrettyPrint outputs a pretty-printed version of the AML tree to w. +func (tree *ObjectTree) PrettyPrint(w io.Writer) { + if len(tree.objPool) != 0 { + var padBuf bytes.Buffer + padBuf.WriteByte(' ') + tree.toString(w, &padBuf, 0) + } +} + +func (tree *ObjectTree) toString(w io.Writer, padBuf *bytes.Buffer, index uint32) { + curObj := tree.ObjectAt(index) + + _, _ = w.Write(padBuf.Bytes()) + kfmt.Fprintf(w, "+- [%s", pOpcodeName(curObj.opcode)) + + if name := nameOf(curObj); len(name) != 0 { + kfmt.Fprintf(w, ", name: \"%s\"", name) + } + + if curObj.opcode == pOpMethod { + kfmt.Fprintf(w, ", argCount: %d", uint8(tree.ArgAt(curObj, 1).value.(uint64)&0x7)) + } + + kfmt.Fprintf(w, ", table: %d, index: %d, offset: 0x%x", curObj.tableHandle, curObj.index, curObj.amlOffset) + kfmt.Fprintf(w, "]") + + if curObj.opcode == pOpIntMethodCall { + methodObj := tree.ObjectAt(curObj.value.(uint32)) + argCount := uint8(tree.ArgAt(methodObj, 1).value.(uint64) & 0x7) + kfmt.Fprintf(w, " -> [call to \"%s\", argCount: %d, table: %d, index: %d, offset: 0x%x]", methodObj.name[:], argCount, methodObj.tableHandle, methodObj.index, methodObj.amlOffset) + } else if curObj.opcode == pOpIntResolvedNamePath { + resolvedObj := tree.ObjectAt(curObj.value.(uint32)) + kfmt.Fprintf(w, " -> [resolved to \"%s\", table: %d, index: %d, offset: 0x%x]", nameOf(resolvedObj), resolvedObj.tableHandle, resolvedObj.index, resolvedObj.amlOffset) + } else if curObj.opcode == pOpIntNamedField { + field := curObj.value.(*fieldElement) + kfmt.Fprintf(w, " -> [field index: %d, offset(bytes): 0x%x, width(bits): 0x%x, accType: ", field.fieldIndex, field.offset, field.width) + switch field.accessType { + case 0x00: + kfmt.Fprintf(w, "Any") + case 0x01: + kfmt.Fprintf(w, "Byte") + case 0x02: + kfmt.Fprintf(w, "Word") + case 0x03: + kfmt.Fprintf(w, "Dword") + case 0x04: + kfmt.Fprintf(w, "Qword") + case 0x05: + kfmt.Fprintf(w, "Buffer, accAttr: ") + switch field.accessAttrib { + case 0x02: + kfmt.Fprintf(w, "Quick") + case 0x04: + kfmt.Fprintf(w, "SendReceive") + case 0x06: + kfmt.Fprintf(w, "Byte") + case 0x08: + kfmt.Fprintf(w, "Word") + case 0x0a: + kfmt.Fprintf(w, "Block") + case 0x0b: + kfmt.Fprintf(w, "Bytes(0x%x)", field.accessLength) + case 0x0c: + kfmt.Fprintf(w, "ProcessCall") + case 0x0d: + kfmt.Fprintf(w, "BlockProcessCall") + case 0x0e: + kfmt.Fprintf(w, "RawBytes(0x%x)", field.accessLength) + case 0x0f: + kfmt.Fprintf(w, "RawProcessBytes(0x%x)", field.accessLength) + } + /* + case 0x40: + kfmt.Fprintf(w, "Bytes(0x%x)", field.AccessAttrib) + case 0x80: + kfmt.Fprintf(w, "RawBytes(0x%x)", field.AccessAttrib) + case 0xc0: + kfmt.Fprintf(w, "RawProcessBytes(0x%x)", field.AccessAttrib) + */ + } + + kfmt.Fprintf(w, ", lockType: ") + switch field.lockType { + case 0x00: + kfmt.Fprintf(w, "NoLock") + case 0x01: + kfmt.Fprintf(w, "Lock") + } + + kfmt.Fprintf(w, ", updateType: ") + switch field.updateType { + case 0x00: + kfmt.Fprintf(w, "Preserve") + case 0x01: + kfmt.Fprintf(w, "WriteAsOnes") + case 0x02: + kfmt.Fprintf(w, "WriteAsZeroes") + } + + switch field.connectionIndex { + case InvalidIndex: + kfmt.Fprintf(w, ", connection: -]") + default: + kfmt.Fprintf(w, ", connection: index %d]", field.connectionIndex) + } + } else if curObj.opcode == pOpStringPrefix { + kfmt.Fprintf(w, " -> [string value: \"%s\"]", curObj.value.([]byte)) + } else if curObj.opcode == pOpIntNamePath { + kfmt.Fprintf(w, " -> [namepath: \"%s\"]", curObj.value.([]byte)) + } else if curObj.value != nil { + switch v := curObj.value.(type) { + case uint64: + kfmt.Fprintf(w, " -> [num value; dec: %d, hex: 0x%x]", v, v) + + // If this is an encoded EISA id convert it back to a string + if curObj.opcode == pOpDwordPrefix && tree.ObjectAt(curObj.parentIndex).name == [amlNameLen]byte{'_', 'H', 'I', 'D'} { + // Poor-man's ntohl + id := uint32((v>>24)&0xff) | + uint32((v>>16)&0xff)<<8 | + uint32((v>>8)&0xff)<<16 | + uint32(v&0xff)<<24 + + var eisaID = [7]byte{ + '@' + (byte)((id>>26)&0x1f), + '@' + (byte)((id>>21)&0x1f), + '@' + (byte)((id>>16)&0x1f), + hexToASCII(id >> 12), + hexToASCII(id >> 8), + hexToASCII(id >> 4), + hexToASCII(id), + } + + kfmt.Fprintf(w, " [EISA: \"%s\"]", eisaID[:]) + } + case []byte: + + kfmt.Fprintf(w, " -> [bytelist value; len: %d; data: [", len(v)) + for i, b := range v { + if i != 0 { + kfmt.Fprintf(w, ", ") + } + kfmt.Fprintf(w, "0x%x", uint8(b)) + } + kfmt.Fprintf(w, "]]") + } + } + + kfmt.Fprintf(w, "\n") + + padLen := padBuf.Len() + if curObj.nextSiblingIndex == InvalidIndex { + padBuf.WriteByte(' ') + } else { + padBuf.WriteByte('|') + } + padBuf.WriteByte(' ') + padBuf.WriteByte(' ') + + for argIndex := curObj.firstArgIndex; argIndex != InvalidIndex; argIndex = tree.ObjectAt(argIndex).nextSiblingIndex { + tree.toString(w, padBuf, argIndex) + } + + padBuf.Truncate(padLen) +} + +func hexToASCII(val uint32) byte { + v := byte(val & 0xf) + if v <= 9 { + return '0' + v + } + + return 'A' + (v - 0xa) +} + +func nameOf(obj *Object) []byte { + var nameStartIndex, nameEndIndex int + for ; nameStartIndex < amlNameLen; nameStartIndex++ { + if ch := obj.name[nameStartIndex]; (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '\\' { + break + } + } + for nameEndIndex = nameStartIndex; nameEndIndex < amlNameLen; nameEndIndex++ { + if ch := obj.name[nameEndIndex]; !((ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '\\') { + break + } + } + + if nameStartIndex != amlNameLen { + return obj.name[nameStartIndex:nameEndIndex] + } + + return nil +} From d7028ed73d7719d755697cab16732913ad4cd54d Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 6 Mar 2018 08:49:52 +0000 Subject: [PATCH 08/10] acpi: test the parser against actual AML dumps All dumps are located in the tabletest package. The DSDT/SSDT dumps were obtained by running an aml dump tool inside a virtualbox instance. The dumps were disassembled using the iasl tool (version 20180105) from Intel's reference ACPICA implementation. The parser-testsuite dumps were written by hand to ensure that all possible happy-paths in the parser were followed and then compiled into AML using the same iasl tool. The added TestParser function attempts to parse various sets of AML dumps and then uses the object tree pretty-printer to obtain a dump of the tree. The dump is then compared to an expected value (.exp files are also placed in the tabletest package). The test code supports passing the "-aml-regenerate-parser-exp-files" flag to update the exp files: go test -run TestParser -aml-regenerate-parser-exp-files --- src/gopheros/device/acpi/aml/parser_test.go | 107 + .../device/acpi/table/tabletest/DSDT-SSDT.exp | 3594 +++++++++++++++++ .../device/acpi/table/tabletest/DSDT.dsl | 3332 +++++++++++++++ .../device/acpi/table/tabletest/SSDT.dsl | 431 ++ .../table/tabletest/parser-testsuite-DSDT.aml | Bin 0 -> 993 bytes .../table/tabletest/parser-testsuite-DSDT.dsl | 255 ++ .../table/tabletest/parser-testsuite-DSDT.exp | 346 ++ 7 files changed, 8065 insertions(+) create mode 100644 src/gopheros/device/acpi/table/tabletest/DSDT-SSDT.exp create mode 100644 src/gopheros/device/acpi/table/tabletest/DSDT.dsl create mode 100644 src/gopheros/device/acpi/table/tabletest/SSDT.dsl create mode 100644 src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.aml create mode 100644 src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.dsl create mode 100644 src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.exp diff --git a/src/gopheros/device/acpi/aml/parser_test.go b/src/gopheros/device/acpi/aml/parser_test.go index d579994..29b9721 100644 --- a/src/gopheros/device/acpi/aml/parser_test.go +++ b/src/gopheros/device/acpi/aml/parser_test.go @@ -2,14 +2,94 @@ package aml import ( "bytes" + "flag" + "fmt" "gopheros/device/acpi/table" "io/ioutil" "os" + "path/filepath" "reflect" + "runtime" + "strings" "testing" "unsafe" ) +var ( + regenExpFiles = flag.Bool("aml-regenerate-parser-exp-files", false, "Regenerate the expected output files for AML parser tests against real AML files") +) + +func TestParser(t *testing.T) { + flag.Parse() + + pathToDumps := pkgDir() + "/../table/tabletest/" + + specs := []struct { + expTreeContentFile string + tableFiles []string + }{ + { + "DSDT-SSDT.exp", + []string{"DSDT.aml", "SSDT.aml"}, + }, + { + "parser-testsuite-DSDT.exp", + []string{"parser-testsuite-DSDT.aml"}, + }, + } + + for _, spec := range specs { + t.Run(fmt.Sprintf("parse [%s]", strings.Join(spec.tableFiles, ", ")), func(t *testing.T) { + var resolver = mockResolver{ + pathToDumps: pathToDumps, + tableFiles: spec.tableFiles, + } + + tree := NewObjectTree() + tree.CreateDefaultScopes(42) + + p := NewParser(&testWriter{t: t}, tree) + for tableIndex, tableFile := range spec.tableFiles { + tableName := strings.Replace(tableFile, ".aml", "", -1) + if err := p.ParseAML(uint8(tableIndex), tableName, resolver.LookupTable(tableName)); err != nil { + t.Errorf("[%s]: %v", tableName, err) + return + } + } + + // Pretty-print tree + var treeDump bytes.Buffer + tree.PrettyPrint(&treeDump) + + // Check if we need to rebuild the exp files + pathToExpFile := filepath.Join(pathToDumps, spec.expTreeContentFile) + if *regenExpFiles { + f, err := os.Create(pathToExpFile) + if err != nil { + t.Fatal(err) + } + defer func() { _ = f.Close() }() + + if _, err = treeDump.WriteTo(f); err != nil { + t.Fatal(err) + } + t.Logf("regenerated exp file contents: %s", pathToExpFile) + return + } + + // Read the exp file and compare its contents to the generated dump + expDump, err := ioutil.ReadFile(pathToExpFile) + if err != nil { + t.Fatalf("error opening exp file: %s; try running tests with -aml-regenerate-parser-exp-files", pathToExpFile) + } + + if !reflect.DeepEqual(expDump, treeDump.Bytes()) { + t.Fatal("parsed tree content does not match expected content") + } + }) + } +} + func TestParseAMLErrors(t *testing.T) { t.Run("parseObjectList failed", func(t *testing.T) { p, resolver := parserForMockPayload(t, []byte{uint8(pOpBuffer)}) @@ -903,3 +983,30 @@ func (m mockByteDataResolver) LookupTable(string) *table.SDTHeader { return header } + +func pkgDir() string { + _, f, _, _ := runtime.Caller(1) + return filepath.Dir(f) +} + +type mockResolver struct { + pathToDumps string + tableFiles []string +} + +func (m mockResolver) LookupTable(name string) *table.SDTHeader { + for _, f := range m.tableFiles { + if !strings.Contains(f, name) { + continue + } + + data, err := ioutil.ReadFile(filepath.Join(m.pathToDumps, f)) + if err != nil { + panic(err) + } + + return (*table.SDTHeader)(unsafe.Pointer(&data[0])) + } + + return nil +} diff --git a/src/gopheros/device/acpi/table/tabletest/DSDT-SSDT.exp b/src/gopheros/device/acpi/table/tabletest/DSDT-SSDT.exp new file mode 100644 index 0000000..9d6afac --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/DSDT-SSDT.exp @@ -0,0 +1,3594 @@ + +- [ScopeBlock, name: "\", table: 42, index: 0, offset: 0x0] + +- [ScopeBlock, name: "_GPE", table: 42, index: 1, offset: 0x0] + | +- [Method, name: "_L02", argCount: 0, table: 0, index: 2735, offset: 0x1993] + | | +- [NamePath, table: 0, index: 2736, offset: 0x1995] -> [namepath: "_L02"] + | | +- [BytePrefix, table: 0, index: 2737, offset: 0x1999] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 2738, offset: 0x199a] + | | +- [Notify, table: 0, index: 2739, offset: 0x199a] + | | +- [NamePath, table: 0, index: 2740, offset: 0x199b] -> [namepath: "\/_SB_PCI0GFX0"] + | | +- [BytePrefix, table: 0, index: 2741, offset: 0x19aa] -> [num value; dec: 129, hex: 0x81] + | +- [Method, name: "_L00", argCount: 0, table: 0, index: 2840, offset: 0x1a8d] + | +- [NamePath, table: 0, index: 2841, offset: 0x1a8f] -> [namepath: "_L00"] + | +- [BytePrefix, table: 0, index: 2842, offset: 0x1a93] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 2843, offset: 0x1a94] + | +- [Notify, table: 0, index: 2844, offset: 0x1a94] + | | +- [NamePath, table: 0, index: 2845, offset: 0x1a95] -> [namepath: "\/_SB_PCI0BAT0"] + | | +- [BytePrefix, table: 0, index: 2846, offset: 0x1aa4] -> [num value; dec: 128, hex: 0x80] + | +- [Notify, table: 0, index: 2847, offset: 0x1aa6] + | +- [NamePath, table: 0, index: 2848, offset: 0x1aa7] -> [namepath: "\/_SB_PCI0AC__"] + | +- [BytePrefix, table: 0, index: 2849, offset: 0x1ab6] -> [num value; dec: 128, hex: 0x80] + +- [ScopeBlock, name: "_PR_", table: 42, index: 2, offset: 0x0] + | +- [Processor, name: "CPU0", table: 1, index: 3580, offset: 0x2c] + | +- [NamePath, table: 1, index: 3581, offset: 0x2f] -> [namepath: "CPU0"] + | +- [BytePrefix, table: 1, index: 3582, offset: 0x33] -> [num value; dec: 0, hex: 0x0] + | +- [DwordPrefix, table: 1, index: 3583, offset: 0x34] -> [num value; dec: 0, hex: 0x0] + | +- [BytePrefix, table: 1, index: 3584, offset: 0x38] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 1, index: 3585, offset: 0x39] + +- [ScopeBlock, name: "_SB_", table: 42, index: 3, offset: 0x0] + | +- [Method, name: "_INI", argCount: 0, table: 0, index: 369, offset: 0x4cc] + | | +- [NamePath, table: 0, index: 370, offset: 0x4cf] -> [namepath: "_INI"] + | | +- [BytePrefix, table: 0, index: 371, offset: 0x4d3] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 372, offset: 0x4d4] + | | +- [Store, table: 0, index: 373, offset: 0x4d4] + | | | +- [DwordPrefix, table: 0, index: 374, offset: 0x4d5] -> [num value; dec: 195936478, hex: 0xbadc0de] + | | | +- [ResolvedNamePath, table: 0, index: 375, offset: 0x4da] -> [resolved to "VAIN", table: 0, index: 365, offset: 0x4bf] + | | +- [MethodCall, table: 0, index: 376, offset: 0x4de] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 377, offset: 0x4e2] -> [string value: "MEML: "] + | | +- [MethodCall, table: 0, index: 378, offset: 0x4ea] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 379, offset: 0x4ee] -> [resolved to "MEML", table: 0, index: 333, offset: 0x41a] + | | +- [MethodCall, table: 0, index: 380, offset: 0x4f2] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 381, offset: 0x4f6] -> [string value: "UIOA: "] + | | +- [MethodCall, table: 0, index: 382, offset: 0x4fe] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 383, offset: 0x502] -> [resolved to "UIOA", table: 0, index: 334, offset: 0x41f] + | | +- [MethodCall, table: 0, index: 384, offset: 0x506] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 385, offset: 0x50a] -> [string value: "UHPT: "] + | | +- [MethodCall, table: 0, index: 386, offset: 0x512] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 387, offset: 0x516] -> [resolved to "UHPT", table: 0, index: 335, offset: 0x424] + | | +- [MethodCall, table: 0, index: 388, offset: 0x51a] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 389, offset: 0x51e] -> [string value: "USMC: "] + | | +- [MethodCall, table: 0, index: 390, offset: 0x526] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 391, offset: 0x52a] -> [resolved to "USMC", table: 0, index: 336, offset: 0x429] + | | +- [MethodCall, table: 0, index: 392, offset: 0x52e] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 393, offset: 0x532] -> [string value: "UFDC: "] + | | +- [MethodCall, table: 0, index: 394, offset: 0x53a] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | +- [ResolvedNamePath, table: 0, index: 395, offset: 0x53e] -> [resolved to "UFDC", table: 0, index: 337, offset: 0x42e] + | | +- [MethodCall, table: 0, index: 396, offset: 0x542] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 397, offset: 0x546] -> [string value: "PMNN: "] + | | +- [MethodCall, table: 0, index: 398, offset: 0x54e] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | +- [ResolvedNamePath, table: 0, index: 399, offset: 0x552] -> [resolved to "PMNN", table: 0, index: 342, offset: 0x447] + | +- [Name, name: "PR00", table: 0, index: 400, offset: 0x556] + | | +- [NamePath, table: 0, index: 401, offset: 0x557] -> [namepath: "PR00"] + | | +- [Package, table: 0, index: 402, offset: 0x55b] + | | +- [BytePrefix, table: 0, index: 403, offset: 0x55e] -> [num value; dec: 120, hex: 0x78] + | | +- [ScopeBlock, table: 0, index: 404, offset: 0x55f] + | | +- [Package, table: 0, index: 405, offset: 0x55f] + | | | +- [BytePrefix, table: 0, index: 406, offset: 0x561] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 407, offset: 0x562] + | | | +- [DwordPrefix, table: 0, index: 408, offset: 0x562] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [Zero, table: 0, index: 409, offset: 0x567] + | | | +- [ResolvedNamePath, table: 0, index: 410, offset: 0x568] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 411, offset: 0x56c] + | | +- [Package, table: 0, index: 412, offset: 0x56d] + | | | +- [BytePrefix, table: 0, index: 413, offset: 0x56f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 414, offset: 0x570] + | | | +- [DwordPrefix, table: 0, index: 415, offset: 0x570] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [One, table: 0, index: 416, offset: 0x575] + | | | +- [ResolvedNamePath, table: 0, index: 417, offset: 0x576] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 418, offset: 0x57a] + | | +- [Package, table: 0, index: 419, offset: 0x57b] + | | | +- [BytePrefix, table: 0, index: 420, offset: 0x57d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 421, offset: 0x57e] + | | | +- [DwordPrefix, table: 0, index: 422, offset: 0x57e] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [BytePrefix, table: 0, index: 423, offset: 0x583] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 424, offset: 0x585] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 425, offset: 0x589] + | | +- [Package, table: 0, index: 426, offset: 0x58a] + | | | +- [BytePrefix, table: 0, index: 427, offset: 0x58c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 428, offset: 0x58d] + | | | +- [DwordPrefix, table: 0, index: 429, offset: 0x58d] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [BytePrefix, table: 0, index: 430, offset: 0x592] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 431, offset: 0x594] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 432, offset: 0x598] + | | +- [Package, table: 0, index: 433, offset: 0x599] + | | | +- [BytePrefix, table: 0, index: 434, offset: 0x59b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 435, offset: 0x59c] + | | | +- [DwordPrefix, table: 0, index: 436, offset: 0x59c] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [Zero, table: 0, index: 437, offset: 0x5a1] + | | | +- [ResolvedNamePath, table: 0, index: 438, offset: 0x5a2] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 439, offset: 0x5a6] + | | +- [Package, table: 0, index: 440, offset: 0x5a7] + | | | +- [BytePrefix, table: 0, index: 441, offset: 0x5a9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 442, offset: 0x5aa] + | | | +- [DwordPrefix, table: 0, index: 443, offset: 0x5aa] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [One, table: 0, index: 444, offset: 0x5af] + | | | +- [ResolvedNamePath, table: 0, index: 445, offset: 0x5b0] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 446, offset: 0x5b4] + | | +- [Package, table: 0, index: 447, offset: 0x5b5] + | | | +- [BytePrefix, table: 0, index: 448, offset: 0x5b7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 449, offset: 0x5b8] + | | | +- [DwordPrefix, table: 0, index: 450, offset: 0x5b8] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [BytePrefix, table: 0, index: 451, offset: 0x5bd] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 452, offset: 0x5bf] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 453, offset: 0x5c3] + | | +- [Package, table: 0, index: 454, offset: 0x5c4] + | | | +- [BytePrefix, table: 0, index: 455, offset: 0x5c6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 456, offset: 0x5c7] + | | | +- [DwordPrefix, table: 0, index: 457, offset: 0x5c7] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [BytePrefix, table: 0, index: 458, offset: 0x5cc] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 459, offset: 0x5ce] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 460, offset: 0x5d2] + | | +- [Package, table: 0, index: 461, offset: 0x5d3] + | | | +- [BytePrefix, table: 0, index: 462, offset: 0x5d5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 463, offset: 0x5d6] + | | | +- [DwordPrefix, table: 0, index: 464, offset: 0x5d6] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [Zero, table: 0, index: 465, offset: 0x5db] + | | | +- [ResolvedNamePath, table: 0, index: 466, offset: 0x5dc] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 467, offset: 0x5e0] + | | +- [Package, table: 0, index: 468, offset: 0x5e1] + | | | +- [BytePrefix, table: 0, index: 469, offset: 0x5e3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 470, offset: 0x5e4] + | | | +- [DwordPrefix, table: 0, index: 471, offset: 0x5e4] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [One, table: 0, index: 472, offset: 0x5e9] + | | | +- [ResolvedNamePath, table: 0, index: 473, offset: 0x5ea] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 474, offset: 0x5ee] + | | +- [Package, table: 0, index: 475, offset: 0x5ef] + | | | +- [BytePrefix, table: 0, index: 476, offset: 0x5f1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 477, offset: 0x5f2] + | | | +- [DwordPrefix, table: 0, index: 478, offset: 0x5f2] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [BytePrefix, table: 0, index: 479, offset: 0x5f7] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 480, offset: 0x5f9] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 481, offset: 0x5fd] + | | +- [Package, table: 0, index: 482, offset: 0x5fe] + | | | +- [BytePrefix, table: 0, index: 483, offset: 0x600] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 484, offset: 0x601] + | | | +- [DwordPrefix, table: 0, index: 485, offset: 0x601] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [BytePrefix, table: 0, index: 486, offset: 0x606] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 487, offset: 0x608] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 488, offset: 0x60c] + | | +- [Package, table: 0, index: 489, offset: 0x60d] + | | | +- [BytePrefix, table: 0, index: 490, offset: 0x60f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 491, offset: 0x610] + | | | +- [DwordPrefix, table: 0, index: 492, offset: 0x610] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [Zero, table: 0, index: 493, offset: 0x615] + | | | +- [ResolvedNamePath, table: 0, index: 494, offset: 0x616] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 495, offset: 0x61a] + | | +- [Package, table: 0, index: 496, offset: 0x61b] + | | | +- [BytePrefix, table: 0, index: 497, offset: 0x61d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 498, offset: 0x61e] + | | | +- [DwordPrefix, table: 0, index: 499, offset: 0x61e] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [One, table: 0, index: 500, offset: 0x623] + | | | +- [ResolvedNamePath, table: 0, index: 501, offset: 0x624] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 502, offset: 0x628] + | | +- [Package, table: 0, index: 503, offset: 0x629] + | | | +- [BytePrefix, table: 0, index: 504, offset: 0x62b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 505, offset: 0x62c] + | | | +- [DwordPrefix, table: 0, index: 506, offset: 0x62c] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [BytePrefix, table: 0, index: 507, offset: 0x631] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 508, offset: 0x633] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 509, offset: 0x637] + | | +- [Package, table: 0, index: 510, offset: 0x638] + | | | +- [BytePrefix, table: 0, index: 511, offset: 0x63a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 512, offset: 0x63b] + | | | +- [DwordPrefix, table: 0, index: 513, offset: 0x63b] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [BytePrefix, table: 0, index: 514, offset: 0x640] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 515, offset: 0x642] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 516, offset: 0x646] + | | +- [Package, table: 0, index: 517, offset: 0x647] + | | | +- [BytePrefix, table: 0, index: 518, offset: 0x649] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 519, offset: 0x64a] + | | | +- [DwordPrefix, table: 0, index: 520, offset: 0x64a] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [Zero, table: 0, index: 521, offset: 0x64f] + | | | +- [ResolvedNamePath, table: 0, index: 522, offset: 0x650] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 523, offset: 0x654] + | | +- [Package, table: 0, index: 524, offset: 0x655] + | | | +- [BytePrefix, table: 0, index: 525, offset: 0x657] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 526, offset: 0x658] + | | | +- [DwordPrefix, table: 0, index: 527, offset: 0x658] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [One, table: 0, index: 528, offset: 0x65d] + | | | +- [ResolvedNamePath, table: 0, index: 529, offset: 0x65e] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 530, offset: 0x662] + | | +- [Package, table: 0, index: 531, offset: 0x663] + | | | +- [BytePrefix, table: 0, index: 532, offset: 0x665] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 533, offset: 0x666] + | | | +- [DwordPrefix, table: 0, index: 534, offset: 0x666] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [BytePrefix, table: 0, index: 535, offset: 0x66b] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 536, offset: 0x66d] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 537, offset: 0x671] + | | +- [Package, table: 0, index: 538, offset: 0x672] + | | | +- [BytePrefix, table: 0, index: 539, offset: 0x674] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 540, offset: 0x675] + | | | +- [DwordPrefix, table: 0, index: 541, offset: 0x675] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [BytePrefix, table: 0, index: 542, offset: 0x67a] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 543, offset: 0x67c] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 544, offset: 0x680] + | | +- [Package, table: 0, index: 545, offset: 0x681] + | | | +- [BytePrefix, table: 0, index: 546, offset: 0x683] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 547, offset: 0x684] + | | | +- [DwordPrefix, table: 0, index: 548, offset: 0x684] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [Zero, table: 0, index: 549, offset: 0x689] + | | | +- [ResolvedNamePath, table: 0, index: 550, offset: 0x68a] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 551, offset: 0x68e] + | | +- [Package, table: 0, index: 552, offset: 0x68f] + | | | +- [BytePrefix, table: 0, index: 553, offset: 0x691] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 554, offset: 0x692] + | | | +- [DwordPrefix, table: 0, index: 555, offset: 0x692] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [One, table: 0, index: 556, offset: 0x697] + | | | +- [ResolvedNamePath, table: 0, index: 557, offset: 0x698] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 558, offset: 0x69c] + | | +- [Package, table: 0, index: 559, offset: 0x69d] + | | | +- [BytePrefix, table: 0, index: 560, offset: 0x69f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 561, offset: 0x6a0] + | | | +- [DwordPrefix, table: 0, index: 562, offset: 0x6a0] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [BytePrefix, table: 0, index: 563, offset: 0x6a5] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 564, offset: 0x6a7] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 565, offset: 0x6ab] + | | +- [Package, table: 0, index: 566, offset: 0x6ac] + | | | +- [BytePrefix, table: 0, index: 567, offset: 0x6ae] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 568, offset: 0x6af] + | | | +- [DwordPrefix, table: 0, index: 569, offset: 0x6af] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [BytePrefix, table: 0, index: 570, offset: 0x6b4] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 571, offset: 0x6b6] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 572, offset: 0x6ba] + | | +- [Package, table: 0, index: 573, offset: 0x6bb] + | | | +- [BytePrefix, table: 0, index: 574, offset: 0x6bd] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 575, offset: 0x6be] + | | | +- [DwordPrefix, table: 0, index: 576, offset: 0x6be] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [Zero, table: 0, index: 577, offset: 0x6c3] + | | | +- [ResolvedNamePath, table: 0, index: 578, offset: 0x6c4] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 579, offset: 0x6c8] + | | +- [Package, table: 0, index: 580, offset: 0x6c9] + | | | +- [BytePrefix, table: 0, index: 581, offset: 0x6cb] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 582, offset: 0x6cc] + | | | +- [DwordPrefix, table: 0, index: 583, offset: 0x6cc] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [One, table: 0, index: 584, offset: 0x6d1] + | | | +- [ResolvedNamePath, table: 0, index: 585, offset: 0x6d2] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 586, offset: 0x6d6] + | | +- [Package, table: 0, index: 587, offset: 0x6d7] + | | | +- [BytePrefix, table: 0, index: 588, offset: 0x6d9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 589, offset: 0x6da] + | | | +- [DwordPrefix, table: 0, index: 590, offset: 0x6da] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [BytePrefix, table: 0, index: 591, offset: 0x6df] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 592, offset: 0x6e1] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 593, offset: 0x6e5] + | | +- [Package, table: 0, index: 594, offset: 0x6e6] + | | | +- [BytePrefix, table: 0, index: 595, offset: 0x6e8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 596, offset: 0x6e9] + | | | +- [DwordPrefix, table: 0, index: 597, offset: 0x6e9] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [BytePrefix, table: 0, index: 598, offset: 0x6ee] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 599, offset: 0x6f0] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 600, offset: 0x6f4] + | | +- [Package, table: 0, index: 601, offset: 0x6f5] + | | | +- [BytePrefix, table: 0, index: 602, offset: 0x6f7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 603, offset: 0x6f8] + | | | +- [DwordPrefix, table: 0, index: 604, offset: 0x6f8] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [Zero, table: 0, index: 605, offset: 0x6fd] + | | | +- [ResolvedNamePath, table: 0, index: 606, offset: 0x6fe] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 607, offset: 0x702] + | | +- [Package, table: 0, index: 608, offset: 0x703] + | | | +- [BytePrefix, table: 0, index: 609, offset: 0x705] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 610, offset: 0x706] + | | | +- [DwordPrefix, table: 0, index: 611, offset: 0x706] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [One, table: 0, index: 612, offset: 0x70b] + | | | +- [ResolvedNamePath, table: 0, index: 613, offset: 0x70c] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 614, offset: 0x710] + | | +- [Package, table: 0, index: 615, offset: 0x711] + | | | +- [BytePrefix, table: 0, index: 616, offset: 0x713] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 617, offset: 0x714] + | | | +- [DwordPrefix, table: 0, index: 618, offset: 0x714] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [BytePrefix, table: 0, index: 619, offset: 0x719] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 620, offset: 0x71b] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 621, offset: 0x71f] + | | +- [Package, table: 0, index: 622, offset: 0x720] + | | | +- [BytePrefix, table: 0, index: 623, offset: 0x722] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 624, offset: 0x723] + | | | +- [DwordPrefix, table: 0, index: 625, offset: 0x723] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [BytePrefix, table: 0, index: 626, offset: 0x728] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 627, offset: 0x72a] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 628, offset: 0x72e] + | | +- [Package, table: 0, index: 629, offset: 0x72f] + | | | +- [BytePrefix, table: 0, index: 630, offset: 0x731] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 631, offset: 0x732] + | | | +- [DwordPrefix, table: 0, index: 632, offset: 0x732] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [Zero, table: 0, index: 633, offset: 0x737] + | | | +- [ResolvedNamePath, table: 0, index: 634, offset: 0x738] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 635, offset: 0x73c] + | | +- [Package, table: 0, index: 636, offset: 0x73d] + | | | +- [BytePrefix, table: 0, index: 637, offset: 0x73f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 638, offset: 0x740] + | | | +- [DwordPrefix, table: 0, index: 639, offset: 0x740] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [One, table: 0, index: 640, offset: 0x745] + | | | +- [ResolvedNamePath, table: 0, index: 641, offset: 0x746] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 642, offset: 0x74a] + | | +- [Package, table: 0, index: 643, offset: 0x74b] + | | | +- [BytePrefix, table: 0, index: 644, offset: 0x74d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 645, offset: 0x74e] + | | | +- [DwordPrefix, table: 0, index: 646, offset: 0x74e] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [BytePrefix, table: 0, index: 647, offset: 0x753] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 648, offset: 0x755] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 649, offset: 0x759] + | | +- [Package, table: 0, index: 650, offset: 0x75a] + | | | +- [BytePrefix, table: 0, index: 651, offset: 0x75c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 652, offset: 0x75d] + | | | +- [DwordPrefix, table: 0, index: 653, offset: 0x75d] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [BytePrefix, table: 0, index: 654, offset: 0x762] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 655, offset: 0x764] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 656, offset: 0x768] + | | +- [Package, table: 0, index: 657, offset: 0x769] + | | | +- [BytePrefix, table: 0, index: 658, offset: 0x76b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 659, offset: 0x76c] + | | | +- [DwordPrefix, table: 0, index: 660, offset: 0x76c] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [Zero, table: 0, index: 661, offset: 0x771] + | | | +- [ResolvedNamePath, table: 0, index: 662, offset: 0x772] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 663, offset: 0x776] + | | +- [Package, table: 0, index: 664, offset: 0x777] + | | | +- [BytePrefix, table: 0, index: 665, offset: 0x779] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 666, offset: 0x77a] + | | | +- [DwordPrefix, table: 0, index: 667, offset: 0x77a] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [One, table: 0, index: 668, offset: 0x77f] + | | | +- [ResolvedNamePath, table: 0, index: 669, offset: 0x780] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 670, offset: 0x784] + | | +- [Package, table: 0, index: 671, offset: 0x785] + | | | +- [BytePrefix, table: 0, index: 672, offset: 0x787] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 673, offset: 0x788] + | | | +- [DwordPrefix, table: 0, index: 674, offset: 0x788] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [BytePrefix, table: 0, index: 675, offset: 0x78d] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 676, offset: 0x78f] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 677, offset: 0x793] + | | +- [Package, table: 0, index: 678, offset: 0x794] + | | | +- [BytePrefix, table: 0, index: 679, offset: 0x796] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 680, offset: 0x797] + | | | +- [DwordPrefix, table: 0, index: 681, offset: 0x797] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [BytePrefix, table: 0, index: 682, offset: 0x79c] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 683, offset: 0x79e] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 684, offset: 0x7a2] + | | +- [Package, table: 0, index: 685, offset: 0x7a3] + | | | +- [BytePrefix, table: 0, index: 686, offset: 0x7a5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 687, offset: 0x7a6] + | | | +- [DwordPrefix, table: 0, index: 688, offset: 0x7a6] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [Zero, table: 0, index: 689, offset: 0x7ab] + | | | +- [ResolvedNamePath, table: 0, index: 690, offset: 0x7ac] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 691, offset: 0x7b0] + | | +- [Package, table: 0, index: 692, offset: 0x7b1] + | | | +- [BytePrefix, table: 0, index: 693, offset: 0x7b3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 694, offset: 0x7b4] + | | | +- [DwordPrefix, table: 0, index: 695, offset: 0x7b4] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [One, table: 0, index: 696, offset: 0x7b9] + | | | +- [ResolvedNamePath, table: 0, index: 697, offset: 0x7ba] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 698, offset: 0x7be] + | | +- [Package, table: 0, index: 699, offset: 0x7bf] + | | | +- [BytePrefix, table: 0, index: 700, offset: 0x7c1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 701, offset: 0x7c2] + | | | +- [DwordPrefix, table: 0, index: 702, offset: 0x7c2] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [BytePrefix, table: 0, index: 703, offset: 0x7c7] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 704, offset: 0x7c9] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 705, offset: 0x7cd] + | | +- [Package, table: 0, index: 706, offset: 0x7ce] + | | | +- [BytePrefix, table: 0, index: 707, offset: 0x7d0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 708, offset: 0x7d1] + | | | +- [DwordPrefix, table: 0, index: 709, offset: 0x7d1] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [BytePrefix, table: 0, index: 710, offset: 0x7d6] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 711, offset: 0x7d8] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 712, offset: 0x7dc] + | | +- [Package, table: 0, index: 713, offset: 0x7dd] + | | | +- [BytePrefix, table: 0, index: 714, offset: 0x7df] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 715, offset: 0x7e0] + | | | +- [DwordPrefix, table: 0, index: 716, offset: 0x7e0] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [Zero, table: 0, index: 717, offset: 0x7e5] + | | | +- [ResolvedNamePath, table: 0, index: 718, offset: 0x7e6] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 719, offset: 0x7ea] + | | +- [Package, table: 0, index: 720, offset: 0x7eb] + | | | +- [BytePrefix, table: 0, index: 721, offset: 0x7ed] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 722, offset: 0x7ee] + | | | +- [DwordPrefix, table: 0, index: 723, offset: 0x7ee] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [One, table: 0, index: 724, offset: 0x7f3] + | | | +- [ResolvedNamePath, table: 0, index: 725, offset: 0x7f4] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 726, offset: 0x7f8] + | | +- [Package, table: 0, index: 727, offset: 0x7f9] + | | | +- [BytePrefix, table: 0, index: 728, offset: 0x7fb] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 729, offset: 0x7fc] + | | | +- [DwordPrefix, table: 0, index: 730, offset: 0x7fc] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [BytePrefix, table: 0, index: 731, offset: 0x801] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 732, offset: 0x803] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 733, offset: 0x807] + | | +- [Package, table: 0, index: 734, offset: 0x808] + | | | +- [BytePrefix, table: 0, index: 735, offset: 0x80a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 736, offset: 0x80b] + | | | +- [DwordPrefix, table: 0, index: 737, offset: 0x80b] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [BytePrefix, table: 0, index: 738, offset: 0x810] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 739, offset: 0x812] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 740, offset: 0x816] + | | +- [Package, table: 0, index: 741, offset: 0x817] + | | | +- [BytePrefix, table: 0, index: 742, offset: 0x819] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 743, offset: 0x81a] + | | | +- [DwordPrefix, table: 0, index: 744, offset: 0x81a] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [Zero, table: 0, index: 745, offset: 0x81f] + | | | +- [ResolvedNamePath, table: 0, index: 746, offset: 0x820] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 747, offset: 0x824] + | | +- [Package, table: 0, index: 748, offset: 0x825] + | | | +- [BytePrefix, table: 0, index: 749, offset: 0x827] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 750, offset: 0x828] + | | | +- [DwordPrefix, table: 0, index: 751, offset: 0x828] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [One, table: 0, index: 752, offset: 0x82d] + | | | +- [ResolvedNamePath, table: 0, index: 753, offset: 0x82e] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 754, offset: 0x832] + | | +- [Package, table: 0, index: 755, offset: 0x833] + | | | +- [BytePrefix, table: 0, index: 756, offset: 0x835] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 757, offset: 0x836] + | | | +- [DwordPrefix, table: 0, index: 758, offset: 0x836] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [BytePrefix, table: 0, index: 759, offset: 0x83b] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 760, offset: 0x83d] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 761, offset: 0x841] + | | +- [Package, table: 0, index: 762, offset: 0x842] + | | | +- [BytePrefix, table: 0, index: 763, offset: 0x844] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 764, offset: 0x845] + | | | +- [DwordPrefix, table: 0, index: 765, offset: 0x845] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [BytePrefix, table: 0, index: 766, offset: 0x84a] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 767, offset: 0x84c] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 768, offset: 0x850] + | | +- [Package, table: 0, index: 769, offset: 0x851] + | | | +- [BytePrefix, table: 0, index: 770, offset: 0x853] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 771, offset: 0x854] + | | | +- [DwordPrefix, table: 0, index: 772, offset: 0x854] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [Zero, table: 0, index: 773, offset: 0x859] + | | | +- [ResolvedNamePath, table: 0, index: 774, offset: 0x85a] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 775, offset: 0x85e] + | | +- [Package, table: 0, index: 776, offset: 0x85f] + | | | +- [BytePrefix, table: 0, index: 777, offset: 0x861] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 778, offset: 0x862] + | | | +- [DwordPrefix, table: 0, index: 779, offset: 0x862] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [One, table: 0, index: 780, offset: 0x867] + | | | +- [ResolvedNamePath, table: 0, index: 781, offset: 0x868] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 782, offset: 0x86c] + | | +- [Package, table: 0, index: 783, offset: 0x86d] + | | | +- [BytePrefix, table: 0, index: 784, offset: 0x86f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 785, offset: 0x870] + | | | +- [DwordPrefix, table: 0, index: 786, offset: 0x870] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [BytePrefix, table: 0, index: 787, offset: 0x875] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 788, offset: 0x877] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 789, offset: 0x87b] + | | +- [Package, table: 0, index: 790, offset: 0x87c] + | | | +- [BytePrefix, table: 0, index: 791, offset: 0x87e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 792, offset: 0x87f] + | | | +- [DwordPrefix, table: 0, index: 793, offset: 0x87f] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [BytePrefix, table: 0, index: 794, offset: 0x884] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 795, offset: 0x886] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 796, offset: 0x88a] + | | +- [Package, table: 0, index: 797, offset: 0x88b] + | | | +- [BytePrefix, table: 0, index: 798, offset: 0x88d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 799, offset: 0x88e] + | | | +- [DwordPrefix, table: 0, index: 800, offset: 0x88e] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [Zero, table: 0, index: 801, offset: 0x893] + | | | +- [ResolvedNamePath, table: 0, index: 802, offset: 0x894] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 803, offset: 0x898] + | | +- [Package, table: 0, index: 804, offset: 0x899] + | | | +- [BytePrefix, table: 0, index: 805, offset: 0x89b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 806, offset: 0x89c] + | | | +- [DwordPrefix, table: 0, index: 807, offset: 0x89c] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [One, table: 0, index: 808, offset: 0x8a1] + | | | +- [ResolvedNamePath, table: 0, index: 809, offset: 0x8a2] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 810, offset: 0x8a6] + | | +- [Package, table: 0, index: 811, offset: 0x8a7] + | | | +- [BytePrefix, table: 0, index: 812, offset: 0x8a9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 813, offset: 0x8aa] + | | | +- [DwordPrefix, table: 0, index: 814, offset: 0x8aa] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [BytePrefix, table: 0, index: 815, offset: 0x8af] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 816, offset: 0x8b1] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 817, offset: 0x8b5] + | | +- [Package, table: 0, index: 818, offset: 0x8b6] + | | | +- [BytePrefix, table: 0, index: 819, offset: 0x8b8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 820, offset: 0x8b9] + | | | +- [DwordPrefix, table: 0, index: 821, offset: 0x8b9] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [BytePrefix, table: 0, index: 822, offset: 0x8be] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 823, offset: 0x8c0] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 824, offset: 0x8c4] + | | +- [Package, table: 0, index: 825, offset: 0x8c5] + | | | +- [BytePrefix, table: 0, index: 826, offset: 0x8c7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 827, offset: 0x8c8] + | | | +- [DwordPrefix, table: 0, index: 828, offset: 0x8c8] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [Zero, table: 0, index: 829, offset: 0x8cd] + | | | +- [ResolvedNamePath, table: 0, index: 830, offset: 0x8ce] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 831, offset: 0x8d2] + | | +- [Package, table: 0, index: 832, offset: 0x8d3] + | | | +- [BytePrefix, table: 0, index: 833, offset: 0x8d5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 834, offset: 0x8d6] + | | | +- [DwordPrefix, table: 0, index: 835, offset: 0x8d6] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [One, table: 0, index: 836, offset: 0x8db] + | | | +- [ResolvedNamePath, table: 0, index: 837, offset: 0x8dc] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 838, offset: 0x8e0] + | | +- [Package, table: 0, index: 839, offset: 0x8e1] + | | | +- [BytePrefix, table: 0, index: 840, offset: 0x8e3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 841, offset: 0x8e4] + | | | +- [DwordPrefix, table: 0, index: 842, offset: 0x8e4] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [BytePrefix, table: 0, index: 843, offset: 0x8e9] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 844, offset: 0x8eb] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 845, offset: 0x8ef] + | | +- [Package, table: 0, index: 846, offset: 0x8f0] + | | | +- [BytePrefix, table: 0, index: 847, offset: 0x8f2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 848, offset: 0x8f3] + | | | +- [DwordPrefix, table: 0, index: 849, offset: 0x8f3] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [BytePrefix, table: 0, index: 850, offset: 0x8f8] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 851, offset: 0x8fa] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 852, offset: 0x8fe] + | | +- [Package, table: 0, index: 853, offset: 0x8ff] + | | | +- [BytePrefix, table: 0, index: 854, offset: 0x901] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 855, offset: 0x902] + | | | +- [DwordPrefix, table: 0, index: 856, offset: 0x902] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [Zero, table: 0, index: 857, offset: 0x907] + | | | +- [ResolvedNamePath, table: 0, index: 858, offset: 0x908] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 859, offset: 0x90c] + | | +- [Package, table: 0, index: 860, offset: 0x90d] + | | | +- [BytePrefix, table: 0, index: 861, offset: 0x90f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 862, offset: 0x910] + | | | +- [DwordPrefix, table: 0, index: 863, offset: 0x910] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [One, table: 0, index: 864, offset: 0x915] + | | | +- [ResolvedNamePath, table: 0, index: 865, offset: 0x916] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 866, offset: 0x91a] + | | +- [Package, table: 0, index: 867, offset: 0x91b] + | | | +- [BytePrefix, table: 0, index: 868, offset: 0x91d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 869, offset: 0x91e] + | | | +- [DwordPrefix, table: 0, index: 870, offset: 0x91e] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [BytePrefix, table: 0, index: 871, offset: 0x923] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 872, offset: 0x925] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 873, offset: 0x929] + | | +- [Package, table: 0, index: 874, offset: 0x92a] + | | | +- [BytePrefix, table: 0, index: 875, offset: 0x92c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 876, offset: 0x92d] + | | | +- [DwordPrefix, table: 0, index: 877, offset: 0x92d] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [BytePrefix, table: 0, index: 878, offset: 0x932] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 879, offset: 0x934] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 880, offset: 0x938] + | | +- [Package, table: 0, index: 881, offset: 0x939] + | | | +- [BytePrefix, table: 0, index: 882, offset: 0x93b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 883, offset: 0x93c] + | | | +- [DwordPrefix, table: 0, index: 884, offset: 0x93c] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [Zero, table: 0, index: 885, offset: 0x941] + | | | +- [ResolvedNamePath, table: 0, index: 886, offset: 0x942] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 887, offset: 0x946] + | | +- [Package, table: 0, index: 888, offset: 0x947] + | | | +- [BytePrefix, table: 0, index: 889, offset: 0x949] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 890, offset: 0x94a] + | | | +- [DwordPrefix, table: 0, index: 891, offset: 0x94a] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [One, table: 0, index: 892, offset: 0x94f] + | | | +- [ResolvedNamePath, table: 0, index: 893, offset: 0x950] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 894, offset: 0x954] + | | +- [Package, table: 0, index: 895, offset: 0x955] + | | | +- [BytePrefix, table: 0, index: 896, offset: 0x957] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 897, offset: 0x958] + | | | +- [DwordPrefix, table: 0, index: 898, offset: 0x958] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [BytePrefix, table: 0, index: 899, offset: 0x95d] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 900, offset: 0x95f] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 901, offset: 0x963] + | | +- [Package, table: 0, index: 902, offset: 0x964] + | | | +- [BytePrefix, table: 0, index: 903, offset: 0x966] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 904, offset: 0x967] + | | | +- [DwordPrefix, table: 0, index: 905, offset: 0x967] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [BytePrefix, table: 0, index: 906, offset: 0x96c] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 907, offset: 0x96e] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 908, offset: 0x972] + | | +- [Package, table: 0, index: 909, offset: 0x973] + | | | +- [BytePrefix, table: 0, index: 910, offset: 0x975] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 911, offset: 0x976] + | | | +- [DwordPrefix, table: 0, index: 912, offset: 0x976] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [Zero, table: 0, index: 913, offset: 0x97b] + | | | +- [ResolvedNamePath, table: 0, index: 914, offset: 0x97c] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 915, offset: 0x980] + | | +- [Package, table: 0, index: 916, offset: 0x981] + | | | +- [BytePrefix, table: 0, index: 917, offset: 0x983] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 918, offset: 0x984] + | | | +- [DwordPrefix, table: 0, index: 919, offset: 0x984] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [One, table: 0, index: 920, offset: 0x989] + | | | +- [ResolvedNamePath, table: 0, index: 921, offset: 0x98a] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 922, offset: 0x98e] + | | +- [Package, table: 0, index: 923, offset: 0x98f] + | | | +- [BytePrefix, table: 0, index: 924, offset: 0x991] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 925, offset: 0x992] + | | | +- [DwordPrefix, table: 0, index: 926, offset: 0x992] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [BytePrefix, table: 0, index: 927, offset: 0x997] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 928, offset: 0x999] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 929, offset: 0x99d] + | | +- [Package, table: 0, index: 930, offset: 0x99e] + | | | +- [BytePrefix, table: 0, index: 931, offset: 0x9a0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 932, offset: 0x9a1] + | | | +- [DwordPrefix, table: 0, index: 933, offset: 0x9a1] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [BytePrefix, table: 0, index: 934, offset: 0x9a6] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 935, offset: 0x9a8] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 936, offset: 0x9ac] + | | +- [Package, table: 0, index: 937, offset: 0x9ad] + | | | +- [BytePrefix, table: 0, index: 938, offset: 0x9af] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 939, offset: 0x9b0] + | | | +- [DwordPrefix, table: 0, index: 940, offset: 0x9b0] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [Zero, table: 0, index: 941, offset: 0x9b5] + | | | +- [ResolvedNamePath, table: 0, index: 942, offset: 0x9b6] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 943, offset: 0x9ba] + | | +- [Package, table: 0, index: 944, offset: 0x9bb] + | | | +- [BytePrefix, table: 0, index: 945, offset: 0x9bd] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 946, offset: 0x9be] + | | | +- [DwordPrefix, table: 0, index: 947, offset: 0x9be] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [One, table: 0, index: 948, offset: 0x9c3] + | | | +- [ResolvedNamePath, table: 0, index: 949, offset: 0x9c4] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 950, offset: 0x9c8] + | | +- [Package, table: 0, index: 951, offset: 0x9c9] + | | | +- [BytePrefix, table: 0, index: 952, offset: 0x9cb] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 953, offset: 0x9cc] + | | | +- [DwordPrefix, table: 0, index: 954, offset: 0x9cc] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [BytePrefix, table: 0, index: 955, offset: 0x9d1] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 956, offset: 0x9d3] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 957, offset: 0x9d7] + | | +- [Package, table: 0, index: 958, offset: 0x9d8] + | | | +- [BytePrefix, table: 0, index: 959, offset: 0x9da] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 960, offset: 0x9db] + | | | +- [DwordPrefix, table: 0, index: 961, offset: 0x9db] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [BytePrefix, table: 0, index: 962, offset: 0x9e0] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 963, offset: 0x9e2] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 964, offset: 0x9e6] + | | +- [Package, table: 0, index: 965, offset: 0x9e7] + | | | +- [BytePrefix, table: 0, index: 966, offset: 0x9e9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 967, offset: 0x9ea] + | | | +- [DwordPrefix, table: 0, index: 968, offset: 0x9ea] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [Zero, table: 0, index: 969, offset: 0x9ef] + | | | +- [ResolvedNamePath, table: 0, index: 970, offset: 0x9f0] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 971, offset: 0x9f4] + | | +- [Package, table: 0, index: 972, offset: 0x9f5] + | | | +- [BytePrefix, table: 0, index: 973, offset: 0x9f7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 974, offset: 0x9f8] + | | | +- [DwordPrefix, table: 0, index: 975, offset: 0x9f8] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [One, table: 0, index: 976, offset: 0x9fd] + | | | +- [ResolvedNamePath, table: 0, index: 977, offset: 0x9fe] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 978, offset: 0xa02] + | | +- [Package, table: 0, index: 979, offset: 0xa03] + | | | +- [BytePrefix, table: 0, index: 980, offset: 0xa05] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 981, offset: 0xa06] + | | | +- [DwordPrefix, table: 0, index: 982, offset: 0xa06] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [BytePrefix, table: 0, index: 983, offset: 0xa0b] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 984, offset: 0xa0d] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 985, offset: 0xa11] + | | +- [Package, table: 0, index: 986, offset: 0xa12] + | | | +- [BytePrefix, table: 0, index: 987, offset: 0xa14] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 988, offset: 0xa15] + | | | +- [DwordPrefix, table: 0, index: 989, offset: 0xa15] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [BytePrefix, table: 0, index: 990, offset: 0xa1a] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 991, offset: 0xa1c] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 992, offset: 0xa20] + | | +- [Package, table: 0, index: 993, offset: 0xa21] + | | | +- [BytePrefix, table: 0, index: 994, offset: 0xa23] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 995, offset: 0xa24] + | | | +- [DwordPrefix, table: 0, index: 996, offset: 0xa24] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [Zero, table: 0, index: 997, offset: 0xa29] + | | | +- [ResolvedNamePath, table: 0, index: 998, offset: 0xa2a] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 999, offset: 0xa2e] + | | +- [Package, table: 0, index: 1000, offset: 0xa2f] + | | | +- [BytePrefix, table: 0, index: 1001, offset: 0xa31] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1002, offset: 0xa32] + | | | +- [DwordPrefix, table: 0, index: 1003, offset: 0xa32] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [One, table: 0, index: 1004, offset: 0xa37] + | | | +- [ResolvedNamePath, table: 0, index: 1005, offset: 0xa38] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1006, offset: 0xa3c] + | | +- [Package, table: 0, index: 1007, offset: 0xa3d] + | | | +- [BytePrefix, table: 0, index: 1008, offset: 0xa3f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1009, offset: 0xa40] + | | | +- [DwordPrefix, table: 0, index: 1010, offset: 0xa40] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [BytePrefix, table: 0, index: 1011, offset: 0xa45] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1012, offset: 0xa47] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1013, offset: 0xa4b] + | | +- [Package, table: 0, index: 1014, offset: 0xa4c] + | | | +- [BytePrefix, table: 0, index: 1015, offset: 0xa4e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1016, offset: 0xa4f] + | | | +- [DwordPrefix, table: 0, index: 1017, offset: 0xa4f] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [BytePrefix, table: 0, index: 1018, offset: 0xa54] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1019, offset: 0xa56] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1020, offset: 0xa5a] + | | +- [Package, table: 0, index: 1021, offset: 0xa5b] + | | | +- [BytePrefix, table: 0, index: 1022, offset: 0xa5d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1023, offset: 0xa5e] + | | | +- [DwordPrefix, table: 0, index: 1024, offset: 0xa5e] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [Zero, table: 0, index: 1025, offset: 0xa63] + | | | +- [ResolvedNamePath, table: 0, index: 1026, offset: 0xa64] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1027, offset: 0xa68] + | | +- [Package, table: 0, index: 1028, offset: 0xa69] + | | | +- [BytePrefix, table: 0, index: 1029, offset: 0xa6b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1030, offset: 0xa6c] + | | | +- [DwordPrefix, table: 0, index: 1031, offset: 0xa6c] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [One, table: 0, index: 1032, offset: 0xa71] + | | | +- [ResolvedNamePath, table: 0, index: 1033, offset: 0xa72] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1034, offset: 0xa76] + | | +- [Package, table: 0, index: 1035, offset: 0xa77] + | | | +- [BytePrefix, table: 0, index: 1036, offset: 0xa79] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1037, offset: 0xa7a] + | | | +- [DwordPrefix, table: 0, index: 1038, offset: 0xa7a] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [BytePrefix, table: 0, index: 1039, offset: 0xa7f] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1040, offset: 0xa81] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1041, offset: 0xa85] + | | +- [Package, table: 0, index: 1042, offset: 0xa86] + | | | +- [BytePrefix, table: 0, index: 1043, offset: 0xa88] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1044, offset: 0xa89] + | | | +- [DwordPrefix, table: 0, index: 1045, offset: 0xa89] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [BytePrefix, table: 0, index: 1046, offset: 0xa8e] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1047, offset: 0xa90] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1048, offset: 0xa94] + | | +- [Package, table: 0, index: 1049, offset: 0xa95] + | | | +- [BytePrefix, table: 0, index: 1050, offset: 0xa97] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1051, offset: 0xa98] + | | | +- [DwordPrefix, table: 0, index: 1052, offset: 0xa98] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [Zero, table: 0, index: 1053, offset: 0xa9d] + | | | +- [ResolvedNamePath, table: 0, index: 1054, offset: 0xa9e] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1055, offset: 0xaa2] + | | +- [Package, table: 0, index: 1056, offset: 0xaa3] + | | | +- [BytePrefix, table: 0, index: 1057, offset: 0xaa5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1058, offset: 0xaa6] + | | | +- [DwordPrefix, table: 0, index: 1059, offset: 0xaa6] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [One, table: 0, index: 1060, offset: 0xaab] + | | | +- [ResolvedNamePath, table: 0, index: 1061, offset: 0xaac] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1062, offset: 0xab0] + | | +- [Package, table: 0, index: 1063, offset: 0xab1] + | | | +- [BytePrefix, table: 0, index: 1064, offset: 0xab3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1065, offset: 0xab4] + | | | +- [DwordPrefix, table: 0, index: 1066, offset: 0xab4] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [BytePrefix, table: 0, index: 1067, offset: 0xab9] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1068, offset: 0xabb] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1069, offset: 0xabf] + | | +- [Package, table: 0, index: 1070, offset: 0xac0] + | | | +- [BytePrefix, table: 0, index: 1071, offset: 0xac2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1072, offset: 0xac3] + | | | +- [DwordPrefix, table: 0, index: 1073, offset: 0xac3] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [BytePrefix, table: 0, index: 1074, offset: 0xac8] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1075, offset: 0xaca] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1076, offset: 0xace] + | | +- [Package, table: 0, index: 1077, offset: 0xacf] + | | | +- [BytePrefix, table: 0, index: 1078, offset: 0xad1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1079, offset: 0xad2] + | | | +- [DwordPrefix, table: 0, index: 1080, offset: 0xad2] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [Zero, table: 0, index: 1081, offset: 0xad7] + | | | +- [ResolvedNamePath, table: 0, index: 1082, offset: 0xad8] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1083, offset: 0xadc] + | | +- [Package, table: 0, index: 1084, offset: 0xadd] + | | | +- [BytePrefix, table: 0, index: 1085, offset: 0xadf] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1086, offset: 0xae0] + | | | +- [DwordPrefix, table: 0, index: 1087, offset: 0xae0] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [One, table: 0, index: 1088, offset: 0xae5] + | | | +- [ResolvedNamePath, table: 0, index: 1089, offset: 0xae6] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1090, offset: 0xaea] + | | +- [Package, table: 0, index: 1091, offset: 0xaeb] + | | | +- [BytePrefix, table: 0, index: 1092, offset: 0xaed] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1093, offset: 0xaee] + | | | +- [DwordPrefix, table: 0, index: 1094, offset: 0xaee] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [BytePrefix, table: 0, index: 1095, offset: 0xaf3] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1096, offset: 0xaf5] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1097, offset: 0xaf9] + | | +- [Package, table: 0, index: 1098, offset: 0xafa] + | | | +- [BytePrefix, table: 0, index: 1099, offset: 0xafc] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1100, offset: 0xafd] + | | | +- [DwordPrefix, table: 0, index: 1101, offset: 0xafd] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [BytePrefix, table: 0, index: 1102, offset: 0xb02] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1103, offset: 0xb04] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1104, offset: 0xb08] + | | +- [Package, table: 0, index: 1105, offset: 0xb09] + | | | +- [BytePrefix, table: 0, index: 1106, offset: 0xb0b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1107, offset: 0xb0c] + | | | +- [DwordPrefix, table: 0, index: 1108, offset: 0xb0c] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [Zero, table: 0, index: 1109, offset: 0xb11] + | | | +- [ResolvedNamePath, table: 0, index: 1110, offset: 0xb12] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1111, offset: 0xb16] + | | +- [Package, table: 0, index: 1112, offset: 0xb17] + | | | +- [BytePrefix, table: 0, index: 1113, offset: 0xb19] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1114, offset: 0xb1a] + | | | +- [DwordPrefix, table: 0, index: 1115, offset: 0xb1a] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [One, table: 0, index: 1116, offset: 0xb1f] + | | | +- [ResolvedNamePath, table: 0, index: 1117, offset: 0xb20] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1118, offset: 0xb24] + | | +- [Package, table: 0, index: 1119, offset: 0xb25] + | | | +- [BytePrefix, table: 0, index: 1120, offset: 0xb27] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1121, offset: 0xb28] + | | | +- [DwordPrefix, table: 0, index: 1122, offset: 0xb28] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [BytePrefix, table: 0, index: 1123, offset: 0xb2d] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1124, offset: 0xb2f] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1125, offset: 0xb33] + | | +- [Package, table: 0, index: 1126, offset: 0xb34] + | | | +- [BytePrefix, table: 0, index: 1127, offset: 0xb36] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1128, offset: 0xb37] + | | | +- [DwordPrefix, table: 0, index: 1129, offset: 0xb37] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [BytePrefix, table: 0, index: 1130, offset: 0xb3c] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1131, offset: 0xb3e] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1132, offset: 0xb42] + | | +- [Package, table: 0, index: 1133, offset: 0xb43] + | | | +- [BytePrefix, table: 0, index: 1134, offset: 0xb45] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1135, offset: 0xb46] + | | | +- [DwordPrefix, table: 0, index: 1136, offset: 0xb46] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [Zero, table: 0, index: 1137, offset: 0xb4b] + | | | +- [ResolvedNamePath, table: 0, index: 1138, offset: 0xb4c] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1139, offset: 0xb50] + | | +- [Package, table: 0, index: 1140, offset: 0xb51] + | | | +- [BytePrefix, table: 0, index: 1141, offset: 0xb53] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1142, offset: 0xb54] + | | | +- [DwordPrefix, table: 0, index: 1143, offset: 0xb54] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [One, table: 0, index: 1144, offset: 0xb59] + | | | +- [ResolvedNamePath, table: 0, index: 1145, offset: 0xb5a] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1146, offset: 0xb5e] + | | +- [Package, table: 0, index: 1147, offset: 0xb5f] + | | | +- [BytePrefix, table: 0, index: 1148, offset: 0xb61] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1149, offset: 0xb62] + | | | +- [DwordPrefix, table: 0, index: 1150, offset: 0xb62] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [BytePrefix, table: 0, index: 1151, offset: 0xb67] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1152, offset: 0xb69] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1153, offset: 0xb6d] + | | +- [Package, table: 0, index: 1154, offset: 0xb6e] + | | | +- [BytePrefix, table: 0, index: 1155, offset: 0xb70] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1156, offset: 0xb71] + | | | +- [DwordPrefix, table: 0, index: 1157, offset: 0xb71] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [BytePrefix, table: 0, index: 1158, offset: 0xb76] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1159, offset: 0xb78] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1160, offset: 0xb7c] + | | +- [Package, table: 0, index: 1161, offset: 0xb7d] + | | | +- [BytePrefix, table: 0, index: 1162, offset: 0xb7f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1163, offset: 0xb80] + | | | +- [DwordPrefix, table: 0, index: 1164, offset: 0xb80] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [Zero, table: 0, index: 1165, offset: 0xb85] + | | | +- [ResolvedNamePath, table: 0, index: 1166, offset: 0xb86] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1167, offset: 0xb8a] + | | +- [Package, table: 0, index: 1168, offset: 0xb8b] + | | | +- [BytePrefix, table: 0, index: 1169, offset: 0xb8d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1170, offset: 0xb8e] + | | | +- [DwordPrefix, table: 0, index: 1171, offset: 0xb8e] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [One, table: 0, index: 1172, offset: 0xb93] + | | | +- [ResolvedNamePath, table: 0, index: 1173, offset: 0xb94] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1174, offset: 0xb98] + | | +- [Package, table: 0, index: 1175, offset: 0xb99] + | | | +- [BytePrefix, table: 0, index: 1176, offset: 0xb9b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1177, offset: 0xb9c] + | | | +- [DwordPrefix, table: 0, index: 1178, offset: 0xb9c] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [BytePrefix, table: 0, index: 1179, offset: 0xba1] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1180, offset: 0xba3] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1181, offset: 0xba7] + | | +- [Package, table: 0, index: 1182, offset: 0xba8] + | | | +- [BytePrefix, table: 0, index: 1183, offset: 0xbaa] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1184, offset: 0xbab] + | | | +- [DwordPrefix, table: 0, index: 1185, offset: 0xbab] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [BytePrefix, table: 0, index: 1186, offset: 0xbb0] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1187, offset: 0xbb2] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1188, offset: 0xbb6] + | | +- [Package, table: 0, index: 1189, offset: 0xbb7] + | | | +- [BytePrefix, table: 0, index: 1190, offset: 0xbb9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1191, offset: 0xbba] + | | | +- [DwordPrefix, table: 0, index: 1192, offset: 0xbba] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [Zero, table: 0, index: 1193, offset: 0xbbf] + | | | +- [ResolvedNamePath, table: 0, index: 1194, offset: 0xbc0] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | | +- [Zero, table: 0, index: 1195, offset: 0xbc4] + | | +- [Package, table: 0, index: 1196, offset: 0xbc5] + | | | +- [BytePrefix, table: 0, index: 1197, offset: 0xbc7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1198, offset: 0xbc8] + | | | +- [DwordPrefix, table: 0, index: 1199, offset: 0xbc8] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [One, table: 0, index: 1200, offset: 0xbcd] + | | | +- [ResolvedNamePath, table: 0, index: 1201, offset: 0xbce] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1202, offset: 0xbd2] + | | +- [Package, table: 0, index: 1203, offset: 0xbd3] + | | | +- [BytePrefix, table: 0, index: 1204, offset: 0xbd5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1205, offset: 0xbd6] + | | | +- [DwordPrefix, table: 0, index: 1206, offset: 0xbd6] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [BytePrefix, table: 0, index: 1207, offset: 0xbdb] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1208, offset: 0xbdd] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1209, offset: 0xbe1] + | | +- [Package, table: 0, index: 1210, offset: 0xbe2] + | | | +- [BytePrefix, table: 0, index: 1211, offset: 0xbe4] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1212, offset: 0xbe5] + | | | +- [DwordPrefix, table: 0, index: 1213, offset: 0xbe5] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [BytePrefix, table: 0, index: 1214, offset: 0xbea] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 1215, offset: 0xbec] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1216, offset: 0xbf0] + | | +- [Package, table: 0, index: 1217, offset: 0xbf1] + | | | +- [BytePrefix, table: 0, index: 1218, offset: 0xbf3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1219, offset: 0xbf4] + | | | +- [DwordPrefix, table: 0, index: 1220, offset: 0xbf4] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [Zero, table: 0, index: 1221, offset: 0xbf9] + | | | +- [ResolvedNamePath, table: 0, index: 1222, offset: 0xbfa] -> [resolved to "LNKC", table: 0, index: 3345, offset: 0x205c] + | | | +- [Zero, table: 0, index: 1223, offset: 0xbfe] + | | +- [Package, table: 0, index: 1224, offset: 0xbff] + | | | +- [BytePrefix, table: 0, index: 1225, offset: 0xc01] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1226, offset: 0xc02] + | | | +- [DwordPrefix, table: 0, index: 1227, offset: 0xc02] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [One, table: 0, index: 1228, offset: 0xc07] + | | | +- [ResolvedNamePath, table: 0, index: 1229, offset: 0xc08] -> [resolved to "LNKD", table: 0, index: 3395, offset: 0x20e0] + | | | +- [Zero, table: 0, index: 1230, offset: 0xc0c] + | | +- [Package, table: 0, index: 1231, offset: 0xc0d] + | | | +- [BytePrefix, table: 0, index: 1232, offset: 0xc0f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1233, offset: 0xc10] + | | | +- [DwordPrefix, table: 0, index: 1234, offset: 0xc10] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [BytePrefix, table: 0, index: 1235, offset: 0xc15] -> [num value; dec: 2, hex: 0x2] + | | | +- [ResolvedNamePath, table: 0, index: 1236, offset: 0xc17] -> [resolved to "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | | +- [Zero, table: 0, index: 1237, offset: 0xc1b] + | | +- [Package, table: 0, index: 1238, offset: 0xc1c] + | | +- [BytePrefix, table: 0, index: 1239, offset: 0xc1e] -> [num value; dec: 4, hex: 0x4] + | | +- [ScopeBlock, table: 0, index: 1240, offset: 0xc1f] + | | +- [DwordPrefix, table: 0, index: 1241, offset: 0xc1f] -> [num value; dec: 2097151, hex: 0x1fffff] + | | +- [BytePrefix, table: 0, index: 1242, offset: 0xc24] -> [num value; dec: 3, hex: 0x3] + | | +- [ResolvedNamePath, table: 0, index: 1243, offset: 0xc26] -> [resolved to "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | +- [Zero, table: 0, index: 1244, offset: 0xc2a] + | +- [Name, name: "PR01", table: 0, index: 1245, offset: 0xc2b] + | | +- [NamePath, table: 0, index: 1246, offset: 0xc2c] -> [namepath: "PR01"] + | | +- [Package, table: 0, index: 1247, offset: 0xc30] + | | +- [BytePrefix, table: 0, index: 1248, offset: 0xc33] -> [num value; dec: 120, hex: 0x78] + | | +- [ScopeBlock, table: 0, index: 1249, offset: 0xc34] + | | +- [Package, table: 0, index: 1250, offset: 0xc34] + | | | +- [BytePrefix, table: 0, index: 1251, offset: 0xc36] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1252, offset: 0xc37] + | | | +- [DwordPrefix, table: 0, index: 1253, offset: 0xc37] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [Zero, table: 0, index: 1254, offset: 0xc3c] + | | | +- [Zero, table: 0, index: 1255, offset: 0xc3d] + | | | +- [BytePrefix, table: 0, index: 1256, offset: 0xc3e] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1257, offset: 0xc40] + | | | +- [BytePrefix, table: 0, index: 1258, offset: 0xc42] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1259, offset: 0xc43] + | | | +- [DwordPrefix, table: 0, index: 1260, offset: 0xc43] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [One, table: 0, index: 1261, offset: 0xc48] + | | | +- [Zero, table: 0, index: 1262, offset: 0xc49] + | | | +- [BytePrefix, table: 0, index: 1263, offset: 0xc4a] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1264, offset: 0xc4c] + | | | +- [BytePrefix, table: 0, index: 1265, offset: 0xc4e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1266, offset: 0xc4f] + | | | +- [DwordPrefix, table: 0, index: 1267, offset: 0xc4f] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [BytePrefix, table: 0, index: 1268, offset: 0xc54] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1269, offset: 0xc56] + | | | +- [BytePrefix, table: 0, index: 1270, offset: 0xc57] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1271, offset: 0xc59] + | | | +- [BytePrefix, table: 0, index: 1272, offset: 0xc5b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1273, offset: 0xc5c] + | | | +- [DwordPrefix, table: 0, index: 1274, offset: 0xc5c] -> [num value; dec: 196607, hex: 0x2ffff] + | | | +- [BytePrefix, table: 0, index: 1275, offset: 0xc61] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1276, offset: 0xc63] + | | | +- [BytePrefix, table: 0, index: 1277, offset: 0xc64] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1278, offset: 0xc66] + | | | +- [BytePrefix, table: 0, index: 1279, offset: 0xc68] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1280, offset: 0xc69] + | | | +- [DwordPrefix, table: 0, index: 1281, offset: 0xc69] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [Zero, table: 0, index: 1282, offset: 0xc6e] + | | | +- [Zero, table: 0, index: 1283, offset: 0xc6f] + | | | +- [BytePrefix, table: 0, index: 1284, offset: 0xc70] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1285, offset: 0xc72] + | | | +- [BytePrefix, table: 0, index: 1286, offset: 0xc74] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1287, offset: 0xc75] + | | | +- [DwordPrefix, table: 0, index: 1288, offset: 0xc75] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [One, table: 0, index: 1289, offset: 0xc7a] + | | | +- [Zero, table: 0, index: 1290, offset: 0xc7b] + | | | +- [BytePrefix, table: 0, index: 1291, offset: 0xc7c] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1292, offset: 0xc7e] + | | | +- [BytePrefix, table: 0, index: 1293, offset: 0xc80] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1294, offset: 0xc81] + | | | +- [DwordPrefix, table: 0, index: 1295, offset: 0xc81] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [BytePrefix, table: 0, index: 1296, offset: 0xc86] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1297, offset: 0xc88] + | | | +- [BytePrefix, table: 0, index: 1298, offset: 0xc89] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1299, offset: 0xc8b] + | | | +- [BytePrefix, table: 0, index: 1300, offset: 0xc8d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1301, offset: 0xc8e] + | | | +- [DwordPrefix, table: 0, index: 1302, offset: 0xc8e] -> [num value; dec: 262143, hex: 0x3ffff] + | | | +- [BytePrefix, table: 0, index: 1303, offset: 0xc93] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1304, offset: 0xc95] + | | | +- [BytePrefix, table: 0, index: 1305, offset: 0xc96] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1306, offset: 0xc98] + | | | +- [BytePrefix, table: 0, index: 1307, offset: 0xc9a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1308, offset: 0xc9b] + | | | +- [DwordPrefix, table: 0, index: 1309, offset: 0xc9b] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [Zero, table: 0, index: 1310, offset: 0xca0] + | | | +- [Zero, table: 0, index: 1311, offset: 0xca1] + | | | +- [BytePrefix, table: 0, index: 1312, offset: 0xca2] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1313, offset: 0xca4] + | | | +- [BytePrefix, table: 0, index: 1314, offset: 0xca6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1315, offset: 0xca7] + | | | +- [DwordPrefix, table: 0, index: 1316, offset: 0xca7] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [One, table: 0, index: 1317, offset: 0xcac] + | | | +- [Zero, table: 0, index: 1318, offset: 0xcad] + | | | +- [BytePrefix, table: 0, index: 1319, offset: 0xcae] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1320, offset: 0xcb0] + | | | +- [BytePrefix, table: 0, index: 1321, offset: 0xcb2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1322, offset: 0xcb3] + | | | +- [DwordPrefix, table: 0, index: 1323, offset: 0xcb3] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [BytePrefix, table: 0, index: 1324, offset: 0xcb8] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1325, offset: 0xcba] + | | | +- [BytePrefix, table: 0, index: 1326, offset: 0xcbb] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1327, offset: 0xcbd] + | | | +- [BytePrefix, table: 0, index: 1328, offset: 0xcbf] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1329, offset: 0xcc0] + | | | +- [DwordPrefix, table: 0, index: 1330, offset: 0xcc0] -> [num value; dec: 327679, hex: 0x4ffff] + | | | +- [BytePrefix, table: 0, index: 1331, offset: 0xcc5] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1332, offset: 0xcc7] + | | | +- [BytePrefix, table: 0, index: 1333, offset: 0xcc8] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1334, offset: 0xcca] + | | | +- [BytePrefix, table: 0, index: 1335, offset: 0xccc] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1336, offset: 0xccd] + | | | +- [DwordPrefix, table: 0, index: 1337, offset: 0xccd] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [Zero, table: 0, index: 1338, offset: 0xcd2] + | | | +- [Zero, table: 0, index: 1339, offset: 0xcd3] + | | | +- [BytePrefix, table: 0, index: 1340, offset: 0xcd4] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1341, offset: 0xcd6] + | | | +- [BytePrefix, table: 0, index: 1342, offset: 0xcd8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1343, offset: 0xcd9] + | | | +- [DwordPrefix, table: 0, index: 1344, offset: 0xcd9] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [One, table: 0, index: 1345, offset: 0xcde] + | | | +- [Zero, table: 0, index: 1346, offset: 0xcdf] + | | | +- [BytePrefix, table: 0, index: 1347, offset: 0xce0] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1348, offset: 0xce2] + | | | +- [BytePrefix, table: 0, index: 1349, offset: 0xce4] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1350, offset: 0xce5] + | | | +- [DwordPrefix, table: 0, index: 1351, offset: 0xce5] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [BytePrefix, table: 0, index: 1352, offset: 0xcea] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1353, offset: 0xcec] + | | | +- [BytePrefix, table: 0, index: 1354, offset: 0xced] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1355, offset: 0xcef] + | | | +- [BytePrefix, table: 0, index: 1356, offset: 0xcf1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1357, offset: 0xcf2] + | | | +- [DwordPrefix, table: 0, index: 1358, offset: 0xcf2] -> [num value; dec: 393215, hex: 0x5ffff] + | | | +- [BytePrefix, table: 0, index: 1359, offset: 0xcf7] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1360, offset: 0xcf9] + | | | +- [BytePrefix, table: 0, index: 1361, offset: 0xcfa] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1362, offset: 0xcfc] + | | | +- [BytePrefix, table: 0, index: 1363, offset: 0xcfe] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1364, offset: 0xcff] + | | | +- [DwordPrefix, table: 0, index: 1365, offset: 0xcff] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [Zero, table: 0, index: 1366, offset: 0xd04] + | | | +- [Zero, table: 0, index: 1367, offset: 0xd05] + | | | +- [BytePrefix, table: 0, index: 1368, offset: 0xd06] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1369, offset: 0xd08] + | | | +- [BytePrefix, table: 0, index: 1370, offset: 0xd0a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1371, offset: 0xd0b] + | | | +- [DwordPrefix, table: 0, index: 1372, offset: 0xd0b] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [One, table: 0, index: 1373, offset: 0xd10] + | | | +- [Zero, table: 0, index: 1374, offset: 0xd11] + | | | +- [BytePrefix, table: 0, index: 1375, offset: 0xd12] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1376, offset: 0xd14] + | | | +- [BytePrefix, table: 0, index: 1377, offset: 0xd16] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1378, offset: 0xd17] + | | | +- [DwordPrefix, table: 0, index: 1379, offset: 0xd17] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [BytePrefix, table: 0, index: 1380, offset: 0xd1c] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1381, offset: 0xd1e] + | | | +- [BytePrefix, table: 0, index: 1382, offset: 0xd1f] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1383, offset: 0xd21] + | | | +- [BytePrefix, table: 0, index: 1384, offset: 0xd23] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1385, offset: 0xd24] + | | | +- [DwordPrefix, table: 0, index: 1386, offset: 0xd24] -> [num value; dec: 458751, hex: 0x6ffff] + | | | +- [BytePrefix, table: 0, index: 1387, offset: 0xd29] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1388, offset: 0xd2b] + | | | +- [BytePrefix, table: 0, index: 1389, offset: 0xd2c] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1390, offset: 0xd2e] + | | | +- [BytePrefix, table: 0, index: 1391, offset: 0xd30] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1392, offset: 0xd31] + | | | +- [DwordPrefix, table: 0, index: 1393, offset: 0xd31] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [Zero, table: 0, index: 1394, offset: 0xd36] + | | | +- [Zero, table: 0, index: 1395, offset: 0xd37] + | | | +- [BytePrefix, table: 0, index: 1396, offset: 0xd38] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1397, offset: 0xd3a] + | | | +- [BytePrefix, table: 0, index: 1398, offset: 0xd3c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1399, offset: 0xd3d] + | | | +- [DwordPrefix, table: 0, index: 1400, offset: 0xd3d] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [One, table: 0, index: 1401, offset: 0xd42] + | | | +- [Zero, table: 0, index: 1402, offset: 0xd43] + | | | +- [BytePrefix, table: 0, index: 1403, offset: 0xd44] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1404, offset: 0xd46] + | | | +- [BytePrefix, table: 0, index: 1405, offset: 0xd48] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1406, offset: 0xd49] + | | | +- [DwordPrefix, table: 0, index: 1407, offset: 0xd49] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [BytePrefix, table: 0, index: 1408, offset: 0xd4e] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1409, offset: 0xd50] + | | | +- [BytePrefix, table: 0, index: 1410, offset: 0xd51] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1411, offset: 0xd53] + | | | +- [BytePrefix, table: 0, index: 1412, offset: 0xd55] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1413, offset: 0xd56] + | | | +- [DwordPrefix, table: 0, index: 1414, offset: 0xd56] -> [num value; dec: 524287, hex: 0x7ffff] + | | | +- [BytePrefix, table: 0, index: 1415, offset: 0xd5b] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1416, offset: 0xd5d] + | | | +- [BytePrefix, table: 0, index: 1417, offset: 0xd5e] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1418, offset: 0xd60] + | | | +- [BytePrefix, table: 0, index: 1419, offset: 0xd62] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1420, offset: 0xd63] + | | | +- [DwordPrefix, table: 0, index: 1421, offset: 0xd63] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [Zero, table: 0, index: 1422, offset: 0xd68] + | | | +- [Zero, table: 0, index: 1423, offset: 0xd69] + | | | +- [BytePrefix, table: 0, index: 1424, offset: 0xd6a] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1425, offset: 0xd6c] + | | | +- [BytePrefix, table: 0, index: 1426, offset: 0xd6e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1427, offset: 0xd6f] + | | | +- [DwordPrefix, table: 0, index: 1428, offset: 0xd6f] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [One, table: 0, index: 1429, offset: 0xd74] + | | | +- [Zero, table: 0, index: 1430, offset: 0xd75] + | | | +- [BytePrefix, table: 0, index: 1431, offset: 0xd76] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1432, offset: 0xd78] + | | | +- [BytePrefix, table: 0, index: 1433, offset: 0xd7a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1434, offset: 0xd7b] + | | | +- [DwordPrefix, table: 0, index: 1435, offset: 0xd7b] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [BytePrefix, table: 0, index: 1436, offset: 0xd80] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1437, offset: 0xd82] + | | | +- [BytePrefix, table: 0, index: 1438, offset: 0xd83] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1439, offset: 0xd85] + | | | +- [BytePrefix, table: 0, index: 1440, offset: 0xd87] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1441, offset: 0xd88] + | | | +- [DwordPrefix, table: 0, index: 1442, offset: 0xd88] -> [num value; dec: 589823, hex: 0x8ffff] + | | | +- [BytePrefix, table: 0, index: 1443, offset: 0xd8d] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1444, offset: 0xd8f] + | | | +- [BytePrefix, table: 0, index: 1445, offset: 0xd90] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1446, offset: 0xd92] + | | | +- [BytePrefix, table: 0, index: 1447, offset: 0xd94] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1448, offset: 0xd95] + | | | +- [DwordPrefix, table: 0, index: 1449, offset: 0xd95] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [Zero, table: 0, index: 1450, offset: 0xd9a] + | | | +- [Zero, table: 0, index: 1451, offset: 0xd9b] + | | | +- [BytePrefix, table: 0, index: 1452, offset: 0xd9c] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1453, offset: 0xd9e] + | | | +- [BytePrefix, table: 0, index: 1454, offset: 0xda0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1455, offset: 0xda1] + | | | +- [DwordPrefix, table: 0, index: 1456, offset: 0xda1] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [One, table: 0, index: 1457, offset: 0xda6] + | | | +- [Zero, table: 0, index: 1458, offset: 0xda7] + | | | +- [BytePrefix, table: 0, index: 1459, offset: 0xda8] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1460, offset: 0xdaa] + | | | +- [BytePrefix, table: 0, index: 1461, offset: 0xdac] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1462, offset: 0xdad] + | | | +- [DwordPrefix, table: 0, index: 1463, offset: 0xdad] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [BytePrefix, table: 0, index: 1464, offset: 0xdb2] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1465, offset: 0xdb4] + | | | +- [BytePrefix, table: 0, index: 1466, offset: 0xdb5] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1467, offset: 0xdb7] + | | | +- [BytePrefix, table: 0, index: 1468, offset: 0xdb9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1469, offset: 0xdba] + | | | +- [DwordPrefix, table: 0, index: 1470, offset: 0xdba] -> [num value; dec: 655359, hex: 0x9ffff] + | | | +- [BytePrefix, table: 0, index: 1471, offset: 0xdbf] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1472, offset: 0xdc1] + | | | +- [BytePrefix, table: 0, index: 1473, offset: 0xdc2] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1474, offset: 0xdc4] + | | | +- [BytePrefix, table: 0, index: 1475, offset: 0xdc6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1476, offset: 0xdc7] + | | | +- [DwordPrefix, table: 0, index: 1477, offset: 0xdc7] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [Zero, table: 0, index: 1478, offset: 0xdcc] + | | | +- [Zero, table: 0, index: 1479, offset: 0xdcd] + | | | +- [BytePrefix, table: 0, index: 1480, offset: 0xdce] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1481, offset: 0xdd0] + | | | +- [BytePrefix, table: 0, index: 1482, offset: 0xdd2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1483, offset: 0xdd3] + | | | +- [DwordPrefix, table: 0, index: 1484, offset: 0xdd3] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [One, table: 0, index: 1485, offset: 0xdd8] + | | | +- [Zero, table: 0, index: 1486, offset: 0xdd9] + | | | +- [BytePrefix, table: 0, index: 1487, offset: 0xdda] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1488, offset: 0xddc] + | | | +- [BytePrefix, table: 0, index: 1489, offset: 0xdde] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1490, offset: 0xddf] + | | | +- [DwordPrefix, table: 0, index: 1491, offset: 0xddf] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [BytePrefix, table: 0, index: 1492, offset: 0xde4] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1493, offset: 0xde6] + | | | +- [BytePrefix, table: 0, index: 1494, offset: 0xde7] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1495, offset: 0xde9] + | | | +- [BytePrefix, table: 0, index: 1496, offset: 0xdeb] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1497, offset: 0xdec] + | | | +- [DwordPrefix, table: 0, index: 1498, offset: 0xdec] -> [num value; dec: 720895, hex: 0xaffff] + | | | +- [BytePrefix, table: 0, index: 1499, offset: 0xdf1] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1500, offset: 0xdf3] + | | | +- [BytePrefix, table: 0, index: 1501, offset: 0xdf4] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1502, offset: 0xdf6] + | | | +- [BytePrefix, table: 0, index: 1503, offset: 0xdf8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1504, offset: 0xdf9] + | | | +- [DwordPrefix, table: 0, index: 1505, offset: 0xdf9] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [Zero, table: 0, index: 1506, offset: 0xdfe] + | | | +- [Zero, table: 0, index: 1507, offset: 0xdff] + | | | +- [BytePrefix, table: 0, index: 1508, offset: 0xe00] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1509, offset: 0xe02] + | | | +- [BytePrefix, table: 0, index: 1510, offset: 0xe04] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1511, offset: 0xe05] + | | | +- [DwordPrefix, table: 0, index: 1512, offset: 0xe05] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [One, table: 0, index: 1513, offset: 0xe0a] + | | | +- [Zero, table: 0, index: 1514, offset: 0xe0b] + | | | +- [BytePrefix, table: 0, index: 1515, offset: 0xe0c] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1516, offset: 0xe0e] + | | | +- [BytePrefix, table: 0, index: 1517, offset: 0xe10] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1518, offset: 0xe11] + | | | +- [DwordPrefix, table: 0, index: 1519, offset: 0xe11] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [BytePrefix, table: 0, index: 1520, offset: 0xe16] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1521, offset: 0xe18] + | | | +- [BytePrefix, table: 0, index: 1522, offset: 0xe19] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1523, offset: 0xe1b] + | | | +- [BytePrefix, table: 0, index: 1524, offset: 0xe1d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1525, offset: 0xe1e] + | | | +- [DwordPrefix, table: 0, index: 1526, offset: 0xe1e] -> [num value; dec: 786431, hex: 0xbffff] + | | | +- [BytePrefix, table: 0, index: 1527, offset: 0xe23] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1528, offset: 0xe25] + | | | +- [BytePrefix, table: 0, index: 1529, offset: 0xe26] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1530, offset: 0xe28] + | | | +- [BytePrefix, table: 0, index: 1531, offset: 0xe2a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1532, offset: 0xe2b] + | | | +- [DwordPrefix, table: 0, index: 1533, offset: 0xe2b] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [Zero, table: 0, index: 1534, offset: 0xe30] + | | | +- [Zero, table: 0, index: 1535, offset: 0xe31] + | | | +- [BytePrefix, table: 0, index: 1536, offset: 0xe32] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1537, offset: 0xe34] + | | | +- [BytePrefix, table: 0, index: 1538, offset: 0xe36] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1539, offset: 0xe37] + | | | +- [DwordPrefix, table: 0, index: 1540, offset: 0xe37] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [One, table: 0, index: 1541, offset: 0xe3c] + | | | +- [Zero, table: 0, index: 1542, offset: 0xe3d] + | | | +- [BytePrefix, table: 0, index: 1543, offset: 0xe3e] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1544, offset: 0xe40] + | | | +- [BytePrefix, table: 0, index: 1545, offset: 0xe42] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1546, offset: 0xe43] + | | | +- [DwordPrefix, table: 0, index: 1547, offset: 0xe43] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [BytePrefix, table: 0, index: 1548, offset: 0xe48] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1549, offset: 0xe4a] + | | | +- [BytePrefix, table: 0, index: 1550, offset: 0xe4b] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1551, offset: 0xe4d] + | | | +- [BytePrefix, table: 0, index: 1552, offset: 0xe4f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1553, offset: 0xe50] + | | | +- [DwordPrefix, table: 0, index: 1554, offset: 0xe50] -> [num value; dec: 851967, hex: 0xcffff] + | | | +- [BytePrefix, table: 0, index: 1555, offset: 0xe55] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1556, offset: 0xe57] + | | | +- [BytePrefix, table: 0, index: 1557, offset: 0xe58] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1558, offset: 0xe5a] + | | | +- [BytePrefix, table: 0, index: 1559, offset: 0xe5c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1560, offset: 0xe5d] + | | | +- [DwordPrefix, table: 0, index: 1561, offset: 0xe5d] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [Zero, table: 0, index: 1562, offset: 0xe62] + | | | +- [Zero, table: 0, index: 1563, offset: 0xe63] + | | | +- [BytePrefix, table: 0, index: 1564, offset: 0xe64] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1565, offset: 0xe66] + | | | +- [BytePrefix, table: 0, index: 1566, offset: 0xe68] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1567, offset: 0xe69] + | | | +- [DwordPrefix, table: 0, index: 1568, offset: 0xe69] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [One, table: 0, index: 1569, offset: 0xe6e] + | | | +- [Zero, table: 0, index: 1570, offset: 0xe6f] + | | | +- [BytePrefix, table: 0, index: 1571, offset: 0xe70] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1572, offset: 0xe72] + | | | +- [BytePrefix, table: 0, index: 1573, offset: 0xe74] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1574, offset: 0xe75] + | | | +- [DwordPrefix, table: 0, index: 1575, offset: 0xe75] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [BytePrefix, table: 0, index: 1576, offset: 0xe7a] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1577, offset: 0xe7c] + | | | +- [BytePrefix, table: 0, index: 1578, offset: 0xe7d] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1579, offset: 0xe7f] + | | | +- [BytePrefix, table: 0, index: 1580, offset: 0xe81] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1581, offset: 0xe82] + | | | +- [DwordPrefix, table: 0, index: 1582, offset: 0xe82] -> [num value; dec: 917503, hex: 0xdffff] + | | | +- [BytePrefix, table: 0, index: 1583, offset: 0xe87] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1584, offset: 0xe89] + | | | +- [BytePrefix, table: 0, index: 1585, offset: 0xe8a] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1586, offset: 0xe8c] + | | | +- [BytePrefix, table: 0, index: 1587, offset: 0xe8e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1588, offset: 0xe8f] + | | | +- [DwordPrefix, table: 0, index: 1589, offset: 0xe8f] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [Zero, table: 0, index: 1590, offset: 0xe94] + | | | +- [Zero, table: 0, index: 1591, offset: 0xe95] + | | | +- [BytePrefix, table: 0, index: 1592, offset: 0xe96] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1593, offset: 0xe98] + | | | +- [BytePrefix, table: 0, index: 1594, offset: 0xe9a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1595, offset: 0xe9b] + | | | +- [DwordPrefix, table: 0, index: 1596, offset: 0xe9b] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [One, table: 0, index: 1597, offset: 0xea0] + | | | +- [Zero, table: 0, index: 1598, offset: 0xea1] + | | | +- [BytePrefix, table: 0, index: 1599, offset: 0xea2] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1600, offset: 0xea4] + | | | +- [BytePrefix, table: 0, index: 1601, offset: 0xea6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1602, offset: 0xea7] + | | | +- [DwordPrefix, table: 0, index: 1603, offset: 0xea7] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [BytePrefix, table: 0, index: 1604, offset: 0xeac] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1605, offset: 0xeae] + | | | +- [BytePrefix, table: 0, index: 1606, offset: 0xeaf] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1607, offset: 0xeb1] + | | | +- [BytePrefix, table: 0, index: 1608, offset: 0xeb3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1609, offset: 0xeb4] + | | | +- [DwordPrefix, table: 0, index: 1610, offset: 0xeb4] -> [num value; dec: 983039, hex: 0xeffff] + | | | +- [BytePrefix, table: 0, index: 1611, offset: 0xeb9] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1612, offset: 0xebb] + | | | +- [BytePrefix, table: 0, index: 1613, offset: 0xebc] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1614, offset: 0xebe] + | | | +- [BytePrefix, table: 0, index: 1615, offset: 0xec0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1616, offset: 0xec1] + | | | +- [DwordPrefix, table: 0, index: 1617, offset: 0xec1] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [Zero, table: 0, index: 1618, offset: 0xec6] + | | | +- [Zero, table: 0, index: 1619, offset: 0xec7] + | | | +- [BytePrefix, table: 0, index: 1620, offset: 0xec8] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1621, offset: 0xeca] + | | | +- [BytePrefix, table: 0, index: 1622, offset: 0xecc] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1623, offset: 0xecd] + | | | +- [DwordPrefix, table: 0, index: 1624, offset: 0xecd] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [One, table: 0, index: 1625, offset: 0xed2] + | | | +- [Zero, table: 0, index: 1626, offset: 0xed3] + | | | +- [BytePrefix, table: 0, index: 1627, offset: 0xed4] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1628, offset: 0xed6] + | | | +- [BytePrefix, table: 0, index: 1629, offset: 0xed8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1630, offset: 0xed9] + | | | +- [DwordPrefix, table: 0, index: 1631, offset: 0xed9] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [BytePrefix, table: 0, index: 1632, offset: 0xede] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1633, offset: 0xee0] + | | | +- [BytePrefix, table: 0, index: 1634, offset: 0xee1] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1635, offset: 0xee3] + | | | +- [BytePrefix, table: 0, index: 1636, offset: 0xee5] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1637, offset: 0xee6] + | | | +- [DwordPrefix, table: 0, index: 1638, offset: 0xee6] -> [num value; dec: 1048575, hex: 0xfffff] + | | | +- [BytePrefix, table: 0, index: 1639, offset: 0xeeb] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1640, offset: 0xeed] + | | | +- [BytePrefix, table: 0, index: 1641, offset: 0xeee] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1642, offset: 0xef0] + | | | +- [BytePrefix, table: 0, index: 1643, offset: 0xef2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1644, offset: 0xef3] + | | | +- [DwordPrefix, table: 0, index: 1645, offset: 0xef3] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [Zero, table: 0, index: 1646, offset: 0xef8] + | | | +- [Zero, table: 0, index: 1647, offset: 0xef9] + | | | +- [BytePrefix, table: 0, index: 1648, offset: 0xefa] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1649, offset: 0xefc] + | | | +- [BytePrefix, table: 0, index: 1650, offset: 0xefe] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1651, offset: 0xeff] + | | | +- [DwordPrefix, table: 0, index: 1652, offset: 0xeff] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [One, table: 0, index: 1653, offset: 0xf04] + | | | +- [Zero, table: 0, index: 1654, offset: 0xf05] + | | | +- [BytePrefix, table: 0, index: 1655, offset: 0xf06] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1656, offset: 0xf08] + | | | +- [BytePrefix, table: 0, index: 1657, offset: 0xf0a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1658, offset: 0xf0b] + | | | +- [DwordPrefix, table: 0, index: 1659, offset: 0xf0b] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [BytePrefix, table: 0, index: 1660, offset: 0xf10] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1661, offset: 0xf12] + | | | +- [BytePrefix, table: 0, index: 1662, offset: 0xf13] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1663, offset: 0xf15] + | | | +- [BytePrefix, table: 0, index: 1664, offset: 0xf17] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1665, offset: 0xf18] + | | | +- [DwordPrefix, table: 0, index: 1666, offset: 0xf18] -> [num value; dec: 1114111, hex: 0x10ffff] + | | | +- [BytePrefix, table: 0, index: 1667, offset: 0xf1d] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1668, offset: 0xf1f] + | | | +- [BytePrefix, table: 0, index: 1669, offset: 0xf20] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1670, offset: 0xf22] + | | | +- [BytePrefix, table: 0, index: 1671, offset: 0xf24] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1672, offset: 0xf25] + | | | +- [DwordPrefix, table: 0, index: 1673, offset: 0xf25] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [Zero, table: 0, index: 1674, offset: 0xf2a] + | | | +- [Zero, table: 0, index: 1675, offset: 0xf2b] + | | | +- [BytePrefix, table: 0, index: 1676, offset: 0xf2c] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1677, offset: 0xf2e] + | | | +- [BytePrefix, table: 0, index: 1678, offset: 0xf30] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1679, offset: 0xf31] + | | | +- [DwordPrefix, table: 0, index: 1680, offset: 0xf31] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [One, table: 0, index: 1681, offset: 0xf36] + | | | +- [Zero, table: 0, index: 1682, offset: 0xf37] + | | | +- [BytePrefix, table: 0, index: 1683, offset: 0xf38] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1684, offset: 0xf3a] + | | | +- [BytePrefix, table: 0, index: 1685, offset: 0xf3c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1686, offset: 0xf3d] + | | | +- [DwordPrefix, table: 0, index: 1687, offset: 0xf3d] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [BytePrefix, table: 0, index: 1688, offset: 0xf42] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1689, offset: 0xf44] + | | | +- [BytePrefix, table: 0, index: 1690, offset: 0xf45] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1691, offset: 0xf47] + | | | +- [BytePrefix, table: 0, index: 1692, offset: 0xf49] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1693, offset: 0xf4a] + | | | +- [DwordPrefix, table: 0, index: 1694, offset: 0xf4a] -> [num value; dec: 1179647, hex: 0x11ffff] + | | | +- [BytePrefix, table: 0, index: 1695, offset: 0xf4f] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1696, offset: 0xf51] + | | | +- [BytePrefix, table: 0, index: 1697, offset: 0xf52] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1698, offset: 0xf54] + | | | +- [BytePrefix, table: 0, index: 1699, offset: 0xf56] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1700, offset: 0xf57] + | | | +- [DwordPrefix, table: 0, index: 1701, offset: 0xf57] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [Zero, table: 0, index: 1702, offset: 0xf5c] + | | | +- [Zero, table: 0, index: 1703, offset: 0xf5d] + | | | +- [BytePrefix, table: 0, index: 1704, offset: 0xf5e] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1705, offset: 0xf60] + | | | +- [BytePrefix, table: 0, index: 1706, offset: 0xf62] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1707, offset: 0xf63] + | | | +- [DwordPrefix, table: 0, index: 1708, offset: 0xf63] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [One, table: 0, index: 1709, offset: 0xf68] + | | | +- [Zero, table: 0, index: 1710, offset: 0xf69] + | | | +- [BytePrefix, table: 0, index: 1711, offset: 0xf6a] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1712, offset: 0xf6c] + | | | +- [BytePrefix, table: 0, index: 1713, offset: 0xf6e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1714, offset: 0xf6f] + | | | +- [DwordPrefix, table: 0, index: 1715, offset: 0xf6f] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [BytePrefix, table: 0, index: 1716, offset: 0xf74] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1717, offset: 0xf76] + | | | +- [BytePrefix, table: 0, index: 1718, offset: 0xf77] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1719, offset: 0xf79] + | | | +- [BytePrefix, table: 0, index: 1720, offset: 0xf7b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1721, offset: 0xf7c] + | | | +- [DwordPrefix, table: 0, index: 1722, offset: 0xf7c] -> [num value; dec: 1245183, hex: 0x12ffff] + | | | +- [BytePrefix, table: 0, index: 1723, offset: 0xf81] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1724, offset: 0xf83] + | | | +- [BytePrefix, table: 0, index: 1725, offset: 0xf84] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1726, offset: 0xf86] + | | | +- [BytePrefix, table: 0, index: 1727, offset: 0xf88] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1728, offset: 0xf89] + | | | +- [DwordPrefix, table: 0, index: 1729, offset: 0xf89] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [Zero, table: 0, index: 1730, offset: 0xf8e] + | | | +- [Zero, table: 0, index: 1731, offset: 0xf8f] + | | | +- [BytePrefix, table: 0, index: 1732, offset: 0xf90] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1733, offset: 0xf92] + | | | +- [BytePrefix, table: 0, index: 1734, offset: 0xf94] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1735, offset: 0xf95] + | | | +- [DwordPrefix, table: 0, index: 1736, offset: 0xf95] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [One, table: 0, index: 1737, offset: 0xf9a] + | | | +- [Zero, table: 0, index: 1738, offset: 0xf9b] + | | | +- [BytePrefix, table: 0, index: 1739, offset: 0xf9c] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1740, offset: 0xf9e] + | | | +- [BytePrefix, table: 0, index: 1741, offset: 0xfa0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1742, offset: 0xfa1] + | | | +- [DwordPrefix, table: 0, index: 1743, offset: 0xfa1] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [BytePrefix, table: 0, index: 1744, offset: 0xfa6] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1745, offset: 0xfa8] + | | | +- [BytePrefix, table: 0, index: 1746, offset: 0xfa9] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1747, offset: 0xfab] + | | | +- [BytePrefix, table: 0, index: 1748, offset: 0xfad] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1749, offset: 0xfae] + | | | +- [DwordPrefix, table: 0, index: 1750, offset: 0xfae] -> [num value; dec: 1310719, hex: 0x13ffff] + | | | +- [BytePrefix, table: 0, index: 1751, offset: 0xfb3] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1752, offset: 0xfb5] + | | | +- [BytePrefix, table: 0, index: 1753, offset: 0xfb6] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1754, offset: 0xfb8] + | | | +- [BytePrefix, table: 0, index: 1755, offset: 0xfba] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1756, offset: 0xfbb] + | | | +- [DwordPrefix, table: 0, index: 1757, offset: 0xfbb] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [Zero, table: 0, index: 1758, offset: 0xfc0] + | | | +- [Zero, table: 0, index: 1759, offset: 0xfc1] + | | | +- [BytePrefix, table: 0, index: 1760, offset: 0xfc2] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1761, offset: 0xfc4] + | | | +- [BytePrefix, table: 0, index: 1762, offset: 0xfc6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1763, offset: 0xfc7] + | | | +- [DwordPrefix, table: 0, index: 1764, offset: 0xfc7] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [One, table: 0, index: 1765, offset: 0xfcc] + | | | +- [Zero, table: 0, index: 1766, offset: 0xfcd] + | | | +- [BytePrefix, table: 0, index: 1767, offset: 0xfce] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1768, offset: 0xfd0] + | | | +- [BytePrefix, table: 0, index: 1769, offset: 0xfd2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1770, offset: 0xfd3] + | | | +- [DwordPrefix, table: 0, index: 1771, offset: 0xfd3] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [BytePrefix, table: 0, index: 1772, offset: 0xfd8] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1773, offset: 0xfda] + | | | +- [BytePrefix, table: 0, index: 1774, offset: 0xfdb] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1775, offset: 0xfdd] + | | | +- [BytePrefix, table: 0, index: 1776, offset: 0xfdf] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1777, offset: 0xfe0] + | | | +- [DwordPrefix, table: 0, index: 1778, offset: 0xfe0] -> [num value; dec: 1376255, hex: 0x14ffff] + | | | +- [BytePrefix, table: 0, index: 1779, offset: 0xfe5] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1780, offset: 0xfe7] + | | | +- [BytePrefix, table: 0, index: 1781, offset: 0xfe8] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1782, offset: 0xfea] + | | | +- [BytePrefix, table: 0, index: 1783, offset: 0xfec] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1784, offset: 0xfed] + | | | +- [DwordPrefix, table: 0, index: 1785, offset: 0xfed] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [Zero, table: 0, index: 1786, offset: 0xff2] + | | | +- [Zero, table: 0, index: 1787, offset: 0xff3] + | | | +- [BytePrefix, table: 0, index: 1788, offset: 0xff4] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1789, offset: 0xff6] + | | | +- [BytePrefix, table: 0, index: 1790, offset: 0xff8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1791, offset: 0xff9] + | | | +- [DwordPrefix, table: 0, index: 1792, offset: 0xff9] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [One, table: 0, index: 1793, offset: 0xffe] + | | | +- [Zero, table: 0, index: 1794, offset: 0xfff] + | | | +- [BytePrefix, table: 0, index: 1795, offset: 0x1000] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1796, offset: 0x1002] + | | | +- [BytePrefix, table: 0, index: 1797, offset: 0x1004] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1798, offset: 0x1005] + | | | +- [DwordPrefix, table: 0, index: 1799, offset: 0x1005] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [BytePrefix, table: 0, index: 1800, offset: 0x100a] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1801, offset: 0x100c] + | | | +- [BytePrefix, table: 0, index: 1802, offset: 0x100d] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1803, offset: 0x100f] + | | | +- [BytePrefix, table: 0, index: 1804, offset: 0x1011] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1805, offset: 0x1012] + | | | +- [DwordPrefix, table: 0, index: 1806, offset: 0x1012] -> [num value; dec: 1441791, hex: 0x15ffff] + | | | +- [BytePrefix, table: 0, index: 1807, offset: 0x1017] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1808, offset: 0x1019] + | | | +- [BytePrefix, table: 0, index: 1809, offset: 0x101a] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1810, offset: 0x101c] + | | | +- [BytePrefix, table: 0, index: 1811, offset: 0x101e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1812, offset: 0x101f] + | | | +- [DwordPrefix, table: 0, index: 1813, offset: 0x101f] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [Zero, table: 0, index: 1814, offset: 0x1024] + | | | +- [Zero, table: 0, index: 1815, offset: 0x1025] + | | | +- [BytePrefix, table: 0, index: 1816, offset: 0x1026] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1817, offset: 0x1028] + | | | +- [BytePrefix, table: 0, index: 1818, offset: 0x102a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1819, offset: 0x102b] + | | | +- [DwordPrefix, table: 0, index: 1820, offset: 0x102b] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [One, table: 0, index: 1821, offset: 0x1030] + | | | +- [Zero, table: 0, index: 1822, offset: 0x1031] + | | | +- [BytePrefix, table: 0, index: 1823, offset: 0x1032] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1824, offset: 0x1034] + | | | +- [BytePrefix, table: 0, index: 1825, offset: 0x1036] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1826, offset: 0x1037] + | | | +- [DwordPrefix, table: 0, index: 1827, offset: 0x1037] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [BytePrefix, table: 0, index: 1828, offset: 0x103c] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1829, offset: 0x103e] + | | | +- [BytePrefix, table: 0, index: 1830, offset: 0x103f] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1831, offset: 0x1041] + | | | +- [BytePrefix, table: 0, index: 1832, offset: 0x1043] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1833, offset: 0x1044] + | | | +- [DwordPrefix, table: 0, index: 1834, offset: 0x1044] -> [num value; dec: 1507327, hex: 0x16ffff] + | | | +- [BytePrefix, table: 0, index: 1835, offset: 0x1049] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1836, offset: 0x104b] + | | | +- [BytePrefix, table: 0, index: 1837, offset: 0x104c] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1838, offset: 0x104e] + | | | +- [BytePrefix, table: 0, index: 1839, offset: 0x1050] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1840, offset: 0x1051] + | | | +- [DwordPrefix, table: 0, index: 1841, offset: 0x1051] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [Zero, table: 0, index: 1842, offset: 0x1056] + | | | +- [Zero, table: 0, index: 1843, offset: 0x1057] + | | | +- [BytePrefix, table: 0, index: 1844, offset: 0x1058] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 1845, offset: 0x105a] + | | | +- [BytePrefix, table: 0, index: 1846, offset: 0x105c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1847, offset: 0x105d] + | | | +- [DwordPrefix, table: 0, index: 1848, offset: 0x105d] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [One, table: 0, index: 1849, offset: 0x1062] + | | | +- [Zero, table: 0, index: 1850, offset: 0x1063] + | | | +- [BytePrefix, table: 0, index: 1851, offset: 0x1064] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1852, offset: 0x1066] + | | | +- [BytePrefix, table: 0, index: 1853, offset: 0x1068] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1854, offset: 0x1069] + | | | +- [DwordPrefix, table: 0, index: 1855, offset: 0x1069] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [BytePrefix, table: 0, index: 1856, offset: 0x106e] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1857, offset: 0x1070] + | | | +- [BytePrefix, table: 0, index: 1858, offset: 0x1071] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1859, offset: 0x1073] + | | | +- [BytePrefix, table: 0, index: 1860, offset: 0x1075] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1861, offset: 0x1076] + | | | +- [DwordPrefix, table: 0, index: 1862, offset: 0x1076] -> [num value; dec: 1572863, hex: 0x17ffff] + | | | +- [BytePrefix, table: 0, index: 1863, offset: 0x107b] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1864, offset: 0x107d] + | | | +- [BytePrefix, table: 0, index: 1865, offset: 0x107e] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1866, offset: 0x1080] + | | | +- [BytePrefix, table: 0, index: 1867, offset: 0x1082] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1868, offset: 0x1083] + | | | +- [DwordPrefix, table: 0, index: 1869, offset: 0x1083] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [Zero, table: 0, index: 1870, offset: 0x1088] + | | | +- [Zero, table: 0, index: 1871, offset: 0x1089] + | | | +- [BytePrefix, table: 0, index: 1872, offset: 0x108a] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 1873, offset: 0x108c] + | | | +- [BytePrefix, table: 0, index: 1874, offset: 0x108e] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1875, offset: 0x108f] + | | | +- [DwordPrefix, table: 0, index: 1876, offset: 0x108f] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [One, table: 0, index: 1877, offset: 0x1094] + | | | +- [Zero, table: 0, index: 1878, offset: 0x1095] + | | | +- [BytePrefix, table: 0, index: 1879, offset: 0x1096] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1880, offset: 0x1098] + | | | +- [BytePrefix, table: 0, index: 1881, offset: 0x109a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1882, offset: 0x109b] + | | | +- [DwordPrefix, table: 0, index: 1883, offset: 0x109b] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [BytePrefix, table: 0, index: 1884, offset: 0x10a0] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1885, offset: 0x10a2] + | | | +- [BytePrefix, table: 0, index: 1886, offset: 0x10a3] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1887, offset: 0x10a5] + | | | +- [BytePrefix, table: 0, index: 1888, offset: 0x10a7] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1889, offset: 0x10a8] + | | | +- [DwordPrefix, table: 0, index: 1890, offset: 0x10a8] -> [num value; dec: 1638399, hex: 0x18ffff] + | | | +- [BytePrefix, table: 0, index: 1891, offset: 0x10ad] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1892, offset: 0x10af] + | | | +- [BytePrefix, table: 0, index: 1893, offset: 0x10b0] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1894, offset: 0x10b2] + | | | +- [BytePrefix, table: 0, index: 1895, offset: 0x10b4] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1896, offset: 0x10b5] + | | | +- [DwordPrefix, table: 0, index: 1897, offset: 0x10b5] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [Zero, table: 0, index: 1898, offset: 0x10ba] + | | | +- [Zero, table: 0, index: 1899, offset: 0x10bb] + | | | +- [BytePrefix, table: 0, index: 1900, offset: 0x10bc] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 1901, offset: 0x10be] + | | | +- [BytePrefix, table: 0, index: 1902, offset: 0x10c0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1903, offset: 0x10c1] + | | | +- [DwordPrefix, table: 0, index: 1904, offset: 0x10c1] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [One, table: 0, index: 1905, offset: 0x10c6] + | | | +- [Zero, table: 0, index: 1906, offset: 0x10c7] + | | | +- [BytePrefix, table: 0, index: 1907, offset: 0x10c8] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1908, offset: 0x10ca] + | | | +- [BytePrefix, table: 0, index: 1909, offset: 0x10cc] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1910, offset: 0x10cd] + | | | +- [DwordPrefix, table: 0, index: 1911, offset: 0x10cd] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [BytePrefix, table: 0, index: 1912, offset: 0x10d2] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1913, offset: 0x10d4] + | | | +- [BytePrefix, table: 0, index: 1914, offset: 0x10d5] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1915, offset: 0x10d7] + | | | +- [BytePrefix, table: 0, index: 1916, offset: 0x10d9] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1917, offset: 0x10da] + | | | +- [DwordPrefix, table: 0, index: 1918, offset: 0x10da] -> [num value; dec: 1703935, hex: 0x19ffff] + | | | +- [BytePrefix, table: 0, index: 1919, offset: 0x10df] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1920, offset: 0x10e1] + | | | +- [BytePrefix, table: 0, index: 1921, offset: 0x10e2] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1922, offset: 0x10e4] + | | | +- [BytePrefix, table: 0, index: 1923, offset: 0x10e6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1924, offset: 0x10e7] + | | | +- [DwordPrefix, table: 0, index: 1925, offset: 0x10e7] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [Zero, table: 0, index: 1926, offset: 0x10ec] + | | | +- [Zero, table: 0, index: 1927, offset: 0x10ed] + | | | +- [BytePrefix, table: 0, index: 1928, offset: 0x10ee] -> [num value; dec: 18, hex: 0x12] + | | +- [Package, table: 0, index: 1929, offset: 0x10f0] + | | | +- [BytePrefix, table: 0, index: 1930, offset: 0x10f2] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1931, offset: 0x10f3] + | | | +- [DwordPrefix, table: 0, index: 1932, offset: 0x10f3] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [One, table: 0, index: 1933, offset: 0x10f8] + | | | +- [Zero, table: 0, index: 1934, offset: 0x10f9] + | | | +- [BytePrefix, table: 0, index: 1935, offset: 0x10fa] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1936, offset: 0x10fc] + | | | +- [BytePrefix, table: 0, index: 1937, offset: 0x10fe] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1938, offset: 0x10ff] + | | | +- [DwordPrefix, table: 0, index: 1939, offset: 0x10ff] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [BytePrefix, table: 0, index: 1940, offset: 0x1104] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1941, offset: 0x1106] + | | | +- [BytePrefix, table: 0, index: 1942, offset: 0x1107] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1943, offset: 0x1109] + | | | +- [BytePrefix, table: 0, index: 1944, offset: 0x110b] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1945, offset: 0x110c] + | | | +- [DwordPrefix, table: 0, index: 1946, offset: 0x110c] -> [num value; dec: 1769471, hex: 0x1affff] + | | | +- [BytePrefix, table: 0, index: 1947, offset: 0x1111] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1948, offset: 0x1113] + | | | +- [BytePrefix, table: 0, index: 1949, offset: 0x1114] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1950, offset: 0x1116] + | | | +- [BytePrefix, table: 0, index: 1951, offset: 0x1118] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1952, offset: 0x1119] + | | | +- [DwordPrefix, table: 0, index: 1953, offset: 0x1119] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [Zero, table: 0, index: 1954, offset: 0x111e] + | | | +- [Zero, table: 0, index: 1955, offset: 0x111f] + | | | +- [BytePrefix, table: 0, index: 1956, offset: 0x1120] -> [num value; dec: 19, hex: 0x13] + | | +- [Package, table: 0, index: 1957, offset: 0x1122] + | | | +- [BytePrefix, table: 0, index: 1958, offset: 0x1124] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1959, offset: 0x1125] + | | | +- [DwordPrefix, table: 0, index: 1960, offset: 0x1125] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [One, table: 0, index: 1961, offset: 0x112a] + | | | +- [Zero, table: 0, index: 1962, offset: 0x112b] + | | | +- [BytePrefix, table: 0, index: 1963, offset: 0x112c] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1964, offset: 0x112e] + | | | +- [BytePrefix, table: 0, index: 1965, offset: 0x1130] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1966, offset: 0x1131] + | | | +- [DwordPrefix, table: 0, index: 1967, offset: 0x1131] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [BytePrefix, table: 0, index: 1968, offset: 0x1136] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1969, offset: 0x1138] + | | | +- [BytePrefix, table: 0, index: 1970, offset: 0x1139] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1971, offset: 0x113b] + | | | +- [BytePrefix, table: 0, index: 1972, offset: 0x113d] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1973, offset: 0x113e] + | | | +- [DwordPrefix, table: 0, index: 1974, offset: 0x113e] -> [num value; dec: 1835007, hex: 0x1bffff] + | | | +- [BytePrefix, table: 0, index: 1975, offset: 0x1143] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 1976, offset: 0x1145] + | | | +- [BytePrefix, table: 0, index: 1977, offset: 0x1146] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1978, offset: 0x1148] + | | | +- [BytePrefix, table: 0, index: 1979, offset: 0x114a] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1980, offset: 0x114b] + | | | +- [DwordPrefix, table: 0, index: 1981, offset: 0x114b] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [Zero, table: 0, index: 1982, offset: 0x1150] + | | | +- [Zero, table: 0, index: 1983, offset: 0x1151] + | | | +- [BytePrefix, table: 0, index: 1984, offset: 0x1152] -> [num value; dec: 20, hex: 0x14] + | | +- [Package, table: 0, index: 1985, offset: 0x1154] + | | | +- [BytePrefix, table: 0, index: 1986, offset: 0x1156] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1987, offset: 0x1157] + | | | +- [DwordPrefix, table: 0, index: 1988, offset: 0x1157] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [One, table: 0, index: 1989, offset: 0x115c] + | | | +- [Zero, table: 0, index: 1990, offset: 0x115d] + | | | +- [BytePrefix, table: 0, index: 1991, offset: 0x115e] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 1992, offset: 0x1160] + | | | +- [BytePrefix, table: 0, index: 1993, offset: 0x1162] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 1994, offset: 0x1163] + | | | +- [DwordPrefix, table: 0, index: 1995, offset: 0x1163] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [BytePrefix, table: 0, index: 1996, offset: 0x1168] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 1997, offset: 0x116a] + | | | +- [BytePrefix, table: 0, index: 1998, offset: 0x116b] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 1999, offset: 0x116d] + | | | +- [BytePrefix, table: 0, index: 2000, offset: 0x116f] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2001, offset: 0x1170] + | | | +- [DwordPrefix, table: 0, index: 2002, offset: 0x1170] -> [num value; dec: 1900543, hex: 0x1cffff] + | | | +- [BytePrefix, table: 0, index: 2003, offset: 0x1175] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 2004, offset: 0x1177] + | | | +- [BytePrefix, table: 0, index: 2005, offset: 0x1178] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 2006, offset: 0x117a] + | | | +- [BytePrefix, table: 0, index: 2007, offset: 0x117c] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2008, offset: 0x117d] + | | | +- [DwordPrefix, table: 0, index: 2009, offset: 0x117d] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [Zero, table: 0, index: 2010, offset: 0x1182] + | | | +- [Zero, table: 0, index: 2011, offset: 0x1183] + | | | +- [BytePrefix, table: 0, index: 2012, offset: 0x1184] -> [num value; dec: 21, hex: 0x15] + | | +- [Package, table: 0, index: 2013, offset: 0x1186] + | | | +- [BytePrefix, table: 0, index: 2014, offset: 0x1188] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2015, offset: 0x1189] + | | | +- [DwordPrefix, table: 0, index: 2016, offset: 0x1189] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [One, table: 0, index: 2017, offset: 0x118e] + | | | +- [Zero, table: 0, index: 2018, offset: 0x118f] + | | | +- [BytePrefix, table: 0, index: 2019, offset: 0x1190] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 2020, offset: 0x1192] + | | | +- [BytePrefix, table: 0, index: 2021, offset: 0x1194] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2022, offset: 0x1195] + | | | +- [DwordPrefix, table: 0, index: 2023, offset: 0x1195] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [BytePrefix, table: 0, index: 2024, offset: 0x119a] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 2025, offset: 0x119c] + | | | +- [BytePrefix, table: 0, index: 2026, offset: 0x119d] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 2027, offset: 0x119f] + | | | +- [BytePrefix, table: 0, index: 2028, offset: 0x11a1] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2029, offset: 0x11a2] + | | | +- [DwordPrefix, table: 0, index: 2030, offset: 0x11a2] -> [num value; dec: 1966079, hex: 0x1dffff] + | | | +- [BytePrefix, table: 0, index: 2031, offset: 0x11a7] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 2032, offset: 0x11a9] + | | | +- [BytePrefix, table: 0, index: 2033, offset: 0x11aa] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 2034, offset: 0x11ac] + | | | +- [BytePrefix, table: 0, index: 2035, offset: 0x11ae] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2036, offset: 0x11af] + | | | +- [DwordPrefix, table: 0, index: 2037, offset: 0x11af] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [Zero, table: 0, index: 2038, offset: 0x11b4] + | | | +- [Zero, table: 0, index: 2039, offset: 0x11b5] + | | | +- [BytePrefix, table: 0, index: 2040, offset: 0x11b6] -> [num value; dec: 22, hex: 0x16] + | | +- [Package, table: 0, index: 2041, offset: 0x11b8] + | | | +- [BytePrefix, table: 0, index: 2042, offset: 0x11ba] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2043, offset: 0x11bb] + | | | +- [DwordPrefix, table: 0, index: 2044, offset: 0x11bb] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [One, table: 0, index: 2045, offset: 0x11c0] + | | | +- [Zero, table: 0, index: 2046, offset: 0x11c1] + | | | +- [BytePrefix, table: 0, index: 2047, offset: 0x11c2] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 2048, offset: 0x11c4] + | | | +- [BytePrefix, table: 0, index: 2049, offset: 0x11c6] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2050, offset: 0x11c7] + | | | +- [DwordPrefix, table: 0, index: 2051, offset: 0x11c7] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [BytePrefix, table: 0, index: 2052, offset: 0x11cc] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 2053, offset: 0x11ce] + | | | +- [BytePrefix, table: 0, index: 2054, offset: 0x11cf] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 2055, offset: 0x11d1] + | | | +- [BytePrefix, table: 0, index: 2056, offset: 0x11d3] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2057, offset: 0x11d4] + | | | +- [DwordPrefix, table: 0, index: 2058, offset: 0x11d4] -> [num value; dec: 2031615, hex: 0x1effff] + | | | +- [BytePrefix, table: 0, index: 2059, offset: 0x11d9] -> [num value; dec: 3, hex: 0x3] + | | | +- [Zero, table: 0, index: 2060, offset: 0x11db] + | | | +- [BytePrefix, table: 0, index: 2061, offset: 0x11dc] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 2062, offset: 0x11de] + | | | +- [BytePrefix, table: 0, index: 2063, offset: 0x11e0] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2064, offset: 0x11e1] + | | | +- [DwordPrefix, table: 0, index: 2065, offset: 0x11e1] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [Zero, table: 0, index: 2066, offset: 0x11e6] + | | | +- [Zero, table: 0, index: 2067, offset: 0x11e7] + | | | +- [BytePrefix, table: 0, index: 2068, offset: 0x11e8] -> [num value; dec: 23, hex: 0x17] + | | +- [Package, table: 0, index: 2069, offset: 0x11ea] + | | | +- [BytePrefix, table: 0, index: 2070, offset: 0x11ec] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2071, offset: 0x11ed] + | | | +- [DwordPrefix, table: 0, index: 2072, offset: 0x11ed] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [One, table: 0, index: 2073, offset: 0x11f2] + | | | +- [Zero, table: 0, index: 2074, offset: 0x11f3] + | | | +- [BytePrefix, table: 0, index: 2075, offset: 0x11f4] -> [num value; dec: 16, hex: 0x10] + | | +- [Package, table: 0, index: 2076, offset: 0x11f6] + | | | +- [BytePrefix, table: 0, index: 2077, offset: 0x11f8] -> [num value; dec: 4, hex: 0x4] + | | | +- [ScopeBlock, table: 0, index: 2078, offset: 0x11f9] + | | | +- [DwordPrefix, table: 0, index: 2079, offset: 0x11f9] -> [num value; dec: 2097151, hex: 0x1fffff] + | | | +- [BytePrefix, table: 0, index: 2080, offset: 0x11fe] -> [num value; dec: 2, hex: 0x2] + | | | +- [Zero, table: 0, index: 2081, offset: 0x1200] + | | | +- [BytePrefix, table: 0, index: 2082, offset: 0x1201] -> [num value; dec: 17, hex: 0x11] + | | +- [Package, table: 0, index: 2083, offset: 0x1203] + | | +- [BytePrefix, table: 0, index: 2084, offset: 0x1205] -> [num value; dec: 4, hex: 0x4] + | | +- [ScopeBlock, table: 0, index: 2085, offset: 0x1206] + | | +- [DwordPrefix, table: 0, index: 2086, offset: 0x1206] -> [num value; dec: 2097151, hex: 0x1fffff] + | | +- [BytePrefix, table: 0, index: 2087, offset: 0x120b] -> [num value; dec: 3, hex: 0x3] + | | +- [Zero, table: 0, index: 2088, offset: 0x120d] + | | +- [BytePrefix, table: 0, index: 2089, offset: 0x120e] -> [num value; dec: 18, hex: 0x12] + | +- [Name, name: "PRSA", table: 0, index: 2090, offset: 0x1210] + | | +- [NamePath, table: 0, index: 2091, offset: 0x1211] -> [namepath: "PRSA"] + | | +- [Buffer, table: 0, index: 2092, offset: 0x1215] + | | +- [BytePrefix, table: 0, index: 3167, offset: 0x1217] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3169, offset: 0x1e80] -> [bytelist value; len: 6; data: [0x23, 0x20, 0xe, 0x18, 0x79, 0x0]] + | +- [Name, name: "PRSB", table: 0, index: 2093, offset: 0x121f] + | | +- [NamePath, table: 0, index: 2094, offset: 0x1220] -> [namepath: "PRSB"] + | | +- [Buffer, table: 0, index: 2095, offset: 0x1224] + | | +- [BytePrefix, table: 0, index: 3168, offset: 0x1226] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3088, offset: 0x1d10] -> [bytelist value; len: 6; data: [0x23, 0x20, 0xe, 0x18, 0x79, 0x0]] + | +- [Name, name: "PRSC", table: 0, index: 2096, offset: 0x122e] + | | +- [NamePath, table: 0, index: 2097, offset: 0x122f] -> [namepath: "PRSC"] + | | +- [Buffer, table: 0, index: 2098, offset: 0x1233] + | | +- [BytePrefix, table: 0, index: 3090, offset: 0x1235] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3089, offset: 0x1d13] -> [bytelist value; len: 6; data: [0x23, 0x20, 0xe, 0x18, 0x79, 0x0]] + | +- [Name, name: "PRSD", table: 0, index: 2099, offset: 0x123d] + | | +- [NamePath, table: 0, index: 2100, offset: 0x123e] -> [namepath: "PRSD"] + | | +- [Buffer, table: 0, index: 2101, offset: 0x1242] + | | +- [BytePrefix, table: 0, index: 3085, offset: 0x1244] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3087, offset: 0x1d10] -> [bytelist value; len: 6; data: [0x23, 0x20, 0xe, 0x18, 0x79, 0x0]] + | +- [Device, name: "PCI0", table: 0, index: 2102, offset: 0x124c] + | | +- [NamePath, table: 0, index: 2103, offset: 0x1250] -> [namepath: "PCI0"] + | | +- [ScopeBlock, table: 0, index: 2104, offset: 0x1254] + | | +- [Name, name: "_HID", table: 0, index: 2105, offset: 0x1254] + | | | +- [NamePath, table: 0, index: 2106, offset: 0x1255] -> [namepath: "_HID"] + | | | +- [DwordPrefix, table: 0, index: 2107, offset: 0x1259] -> [num value; dec: 51040321, hex: 0x30ad041] [EISA: "PNP0A03"] + | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2108, offset: 0x125e] + | | | +- [NamePath, table: 0, index: 2109, offset: 0x1260] -> [namepath: "_ADR"] + | | | +- [BytePrefix, table: 0, index: 2110, offset: 0x1264] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2111, offset: 0x1265] + | | | +- [Return, table: 0, index: 2112, offset: 0x1265] + | | | +- [ResolvedNamePath, table: 0, index: 2113, offset: 0x1266] -> [resolved to "HBCA", table: 0, index: 352, offset: 0x479] + | | +- [Name, name: "_BBN", table: 0, index: 2114, offset: 0x126a] + | | | +- [NamePath, table: 0, index: 2115, offset: 0x126b] -> [namepath: "_BBN"] + | | | +- [Zero, table: 0, index: 2116, offset: 0x126f] + | | +- [Name, name: "_UID", table: 0, index: 2117, offset: 0x1270] + | | | +- [NamePath, table: 0, index: 2118, offset: 0x1271] -> [namepath: "_UID"] + | | | +- [Zero, table: 0, index: 2119, offset: 0x1275] + | | +- [Method, name: "_PRT", argCount: 0, table: 0, index: 2120, offset: 0x1276] + | | | +- [NamePath, table: 0, index: 2121, offset: 0x1279] -> [namepath: "_PRT"] + | | | +- [BytePrefix, table: 0, index: 2122, offset: 0x127d] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2123, offset: 0x127e] + | | | +- [If, table: 0, index: 2124, offset: 0x127e] + | | | | +- [LEqual, table: 0, index: 2125, offset: 0x1280] + | | | | | +- [Land, table: 0, index: 2126, offset: 0x1281] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2127, offset: 0x1282] -> [resolved to "PICM", table: 0, index: 305, offset: 0x3c7] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2128, offset: 0x1286] -> [resolved to "UIOA", table: 0, index: 334, offset: 0x41f] + | | | | | +- [Zero, table: 0, index: 2129, offset: 0x128a] + | | | | +- [MethodCall, table: 0, index: 2130, offset: 0x128b] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 2131, offset: 0x128f] -> [string value: "RETURNING PIC +"] + | | | +- [Store, table: 0, index: 2132, offset: 0x129f] + | | | | +- [Zero, table: 0, index: 2133, offset: 0x12a0] + | | | | +- [NamePath, table: 0, index: 2134, offset: 0x12a1] -> [namepath: "^.SBRGAPDE"] + | | | +- [Store, table: 0, index: 2135, offset: 0x12ab] + | | | | +- [Zero, table: 0, index: 2136, offset: 0x12ac] + | | | | +- [NamePath, table: 0, index: 2137, offset: 0x12ad] -> [namepath: "^.SBRGAPAD"] + | | | +- [Return, table: 0, index: 2138, offset: 0x12b7] + | | | | +- [ResolvedNamePath, table: 0, index: 2139, offset: 0x12b8] -> [resolved to "PR00", table: 0, index: 400, offset: 0x556] + | | | +- [Else, table: 0, index: 2140, offset: 0x12bc] + | | | +- [ScopeBlock, table: 0, index: 2141, offset: 0x12be] + | | | +- [MethodCall, table: 0, index: 2142, offset: 0x12be] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 2143, offset: 0x12c2] -> [string value: "RETURNING APIC +"] + | | | +- [Store, table: 0, index: 2144, offset: 0x12d3] + | | | | +- [BytePrefix, table: 0, index: 2145, offset: 0x12d4] -> [num value; dec: 190, hex: 0xbe] + | | | | +- [NamePath, table: 0, index: 2146, offset: 0x12d6] -> [namepath: "^.SBRGAPDE"] + | | | +- [Store, table: 0, index: 2147, offset: 0x12e0] + | | | | +- [BytePrefix, table: 0, index: 2148, offset: 0x12e1] -> [num value; dec: 239, hex: 0xef] + | | | | +- [NamePath, table: 0, index: 2149, offset: 0x12e3] -> [namepath: "^.SBRGAPAD"] + | | | +- [Return, table: 0, index: 2150, offset: 0x12ed] + | | | +- [ResolvedNamePath, table: 0, index: 2151, offset: 0x12ee] -> [resolved to "PR01", table: 0, index: 1245, offset: 0xc2b] + | | +- [Device, name: "SBRG", table: 0, index: 2152, offset: 0x12f2] + | | | +- [NamePath, table: 0, index: 2153, offset: 0x12f6] -> [namepath: "SBRG"] + | | | +- [ScopeBlock, table: 0, index: 2154, offset: 0x12fa] + | | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2155, offset: 0x12fa] + | | | | +- [NamePath, table: 0, index: 2156, offset: 0x12fc] -> [namepath: "_ADR"] + | | | | +- [BytePrefix, table: 0, index: 2157, offset: 0x1300] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2158, offset: 0x1301] + | | | | +- [Return, table: 0, index: 2159, offset: 0x1301] + | | | | +- [ResolvedNamePath, table: 0, index: 2160, offset: 0x1302] -> [resolved to "IOCA", table: 0, index: 351, offset: 0x474] + | | | +- [OpRegion, name: "PCIC", table: 0, index: 2161, offset: 0x1306] + | | | | +- [NamePath, table: 0, index: 2162, offset: 0x1308] -> [namepath: "PCIC"] + | | | | +- [BytePrefix, table: 0, index: 2163, offset: 0x130c] -> [num value; dec: 2, hex: 0x2] + | | | | +- [Zero, table: 0, index: 2164, offset: 0x130d] + | | | | +- [BytePrefix, table: 0, index: 2165, offset: 0x130e] -> [num value; dec: 255, hex: 0xff] + | | | +- [Field, table: 0, index: 2166, offset: 0x1310] + | | | | +- [NamePath, table: 0, index: 2167, offset: 0x1313] -> [namepath: "PCIC"] + | | | | +- [BytePrefix, table: 0, index: 2168, offset: 0x1317] -> [num value; dec: 1, hex: 0x1] + | | | +- [NamedField, name: "APAD", table: 0, index: 2169, offset: 0x131b] -> [field index: 2166, offset(bytes): 0x568, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "APDE", table: 0, index: 2170, offset: 0x1323] -> [field index: 2166, offset(bytes): 0x6f0, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [Device, name: "PS2K", table: 0, index: 2217, offset: 0x13a3] + | | | | +- [NamePath, table: 0, index: 2218, offset: 0x13a6] -> [namepath: "PS2K"] + | | | | +- [ScopeBlock, table: 0, index: 2219, offset: 0x13aa] + | | | | +- [Name, name: "_HID", table: 0, index: 2220, offset: 0x13aa] + | | | | | +- [NamePath, table: 0, index: 2221, offset: 0x13ab] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2222, offset: 0x13af] -> [num value; dec: 50581569, hex: 0x303d041] [EISA: "PNP0303"] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2223, offset: 0x13b4] + | | | | | +- [NamePath, table: 0, index: 2224, offset: 0x13b6] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2225, offset: 0x13ba] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2226, offset: 0x13bb] + | | | | | +- [Return, table: 0, index: 2227, offset: 0x13bb] + | | | | | +- [BytePrefix, table: 0, index: 2228, offset: 0x13bc] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "_CRS", table: 0, index: 2229, offset: 0x13be] + | | | | +- [NamePath, table: 0, index: 2230, offset: 0x13bf] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2231, offset: 0x13c3] + | | | | +- [BytePrefix, table: 0, index: 3086, offset: 0x13c5] -> [num value; dec: 21, hex: 0x15] + | | | | +- [ByteList, table: 0, index: 2837, offset: 0x1a86] -> [bytelist value; len: 21; data: [0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x0, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x0, 0x1, 0x22, 0x2, 0x0, 0x79, 0x0]] + | | | +- [Device, name: "DMAC", table: 0, index: 2232, offset: 0x13dc] + | | | | +- [NamePath, table: 0, index: 2233, offset: 0x13df] -> [namepath: "DMAC"] + | | | | +- [ScopeBlock, table: 0, index: 2234, offset: 0x13e3] + | | | | +- [Name, name: "_HID", table: 0, index: 2235, offset: 0x13e3] + | | | | | +- [NamePath, table: 0, index: 2236, offset: 0x13e4] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2237, offset: 0x13e8] -> [num value; dec: 184385, hex: 0x2d041] [EISA: "PNP0200"] + | | | | +- [Name, name: "_CRS", table: 0, index: 2238, offset: 0x13ed] + | | | | +- [NamePath, table: 0, index: 2239, offset: 0x13ee] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2240, offset: 0x13f2] + | | | | +- [BytePrefix, table: 0, index: 2839, offset: 0x13f4] -> [num value; dec: 29, hex: 0x1d] + | | | | +- [ByteList, table: 0, index: 2838, offset: 0x1a88] -> [bytelist value; len: 29; data: [0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x10, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x10, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x5, 0x79, 0x0]] + | | | +- [Device, name: "FDC0", table: 0, index: 2241, offset: 0x1413] + | | | | +- [NamePath, table: 0, index: 2242, offset: 0x1417] -> [namepath: "FDC0"] + | | | | +- [ScopeBlock, table: 0, index: 2243, offset: 0x141b] + | | | | +- [Name, name: "_HID", table: 0, index: 2244, offset: 0x141b] + | | | | | +- [NamePath, table: 0, index: 2245, offset: 0x141c] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2246, offset: 0x1420] -> [num value; dec: 512065, hex: 0x7d041] [EISA: "PNP0700"] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2247, offset: 0x1425] + | | | | | +- [NamePath, table: 0, index: 2248, offset: 0x1427] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2249, offset: 0x142b] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2250, offset: 0x142c] + | | | | | +- [Return, table: 0, index: 2251, offset: 0x142c] + | | | | | +- [ResolvedNamePath, table: 0, index: 2252, offset: 0x142d] -> [resolved to "UFDC", table: 0, index: 337, offset: 0x42e] + | | | | +- [Name, name: "_CRS", table: 0, index: 2253, offset: 0x1431] + | | | | | +- [NamePath, table: 0, index: 2254, offset: 0x1432] -> [namepath: "_CRS"] + | | | | | +- [Buffer, table: 0, index: 2255, offset: 0x1436] + | | | | | +- [BytePrefix, table: 0, index: 2732, offset: 0x1438] -> [num value; dec: 24, hex: 0x18] + | | | | | +- [ByteList, table: 0, index: 2734, offset: 0x1993] -> [bytelist value; len: 24; data: [0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x1, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x79, 0x0]] + | | | | +- [Name, name: "_PRS", table: 0, index: 2256, offset: 0x1452] + | | | | +- [NamePath, table: 0, index: 2257, offset: 0x1453] -> [namepath: "_PRS"] + | | | | +- [Buffer, table: 0, index: 2258, offset: 0x1457] + | | | | +- [BytePrefix, table: 0, index: 2733, offset: 0x1459] -> [num value; dec: 24, hex: 0x18] + | | | | +- [ByteList, table: 0, index: 366, offset: 0x4c4] -> [bytelist value; len: 24; data: [0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x1, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x79, 0x0]] + | | | +- [Device, name: "PS2M", table: 0, index: 2259, offset: 0x1473] + | | | | +- [NamePath, table: 0, index: 2260, offset: 0x1476] -> [namepath: "PS2M"] + | | | | +- [ScopeBlock, table: 0, index: 2261, offset: 0x147a] + | | | | +- [Name, name: "_HID", table: 0, index: 2262, offset: 0x147a] + | | | | | +- [NamePath, table: 0, index: 2263, offset: 0x147b] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2264, offset: 0x147f] -> [num value; dec: 51368001, hex: 0x30fd041] [EISA: "PNP0F03"] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2265, offset: 0x1484] + | | | | | +- [NamePath, table: 0, index: 2266, offset: 0x1486] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2267, offset: 0x148a] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2268, offset: 0x148b] + | | | | | +- [Return, table: 0, index: 2269, offset: 0x148b] + | | | | | +- [BytePrefix, table: 0, index: 2270, offset: 0x148c] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "_CRS", table: 0, index: 2271, offset: 0x148e] + | | | | +- [NamePath, table: 0, index: 2272, offset: 0x148f] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2273, offset: 0x1493] + | | | | +- [BytePrefix, table: 0, index: 368, offset: 0x1495] -> [num value; dec: 5, hex: 0x5] + | | | | +- [ByteList, table: 0, index: 367, offset: 0x4c8] -> [bytelist value; len: 5; data: [0x22, 0x0, 0x10, 0x79, 0x0]] + | | | +- [Device, name: "TIMR", table: 0, index: 2598, offset: 0x17fa] + | | | | +- [NamePath, table: 0, index: 2599, offset: 0x17fd] -> [namepath: "TIMR"] + | | | | +- [ScopeBlock, table: 0, index: 2600, offset: 0x1801] + | | | | +- [Name, name: "_HID", table: 0, index: 2601, offset: 0x1801] + | | | | | +- [NamePath, table: 0, index: 2602, offset: 0x1802] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2603, offset: 0x1806] -> [num value; dec: 118849, hex: 0x1d041] [EISA: "PNP0100"] + | | | | +- [Name, name: "_CRS", table: 0, index: 2604, offset: 0x180b] + | | | | +- [NamePath, table: 0, index: 2605, offset: 0x180c] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2606, offset: 0x1810] + | | | | +- [BytePrefix, table: 0, index: 3491, offset: 0x1812] -> [num value; dec: 18, hex: 0x12] + | | | | +- [ByteList, table: 0, index: 3492, offset: 0x0] -> [bytelist value; len: 18; data: [0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x0, 0x4, 0x47, 0x1, 0x50, 0x0, 0x50, 0x0, 0x10, 0x4, 0x79, 0x0]] + | | | +- [Device, name: "PIC_", table: 0, index: 2607, offset: 0x1826] + | | | | +- [NamePath, table: 0, index: 2608, offset: 0x1829] -> [namepath: "PIC_"] + | | | | +- [ScopeBlock, table: 0, index: 2609, offset: 0x182d] + | | | | +- [Name, name: "_HID", table: 0, index: 2610, offset: 0x182d] + | | | | | +- [NamePath, table: 0, index: 2611, offset: 0x182e] -> [namepath: "_HID"] + | | | | | +- [WordPrefix, table: 0, index: 2612, offset: 0x1832] -> [num value; dec: 53313, hex: 0xd041] + | | | | +- [Name, name: "_CRS", table: 0, index: 2613, offset: 0x1835] + | | | | +- [NamePath, table: 0, index: 2614, offset: 0x1836] -> [namepath: "_CRS"] + | | | | +- [Buffer, table: 0, index: 2615, offset: 0x183a] + | | | | +- [BytePrefix, table: 0, index: 3493, offset: 0x183c] -> [num value; dec: 21, hex: 0x15] + | | | | +- [ByteList, table: 0, index: 3494, offset: 0x0] -> [bytelist value; len: 21; data: [0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x0, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x0, 0x2, 0x22, 0x4, 0x0, 0x79, 0x0]] + | | | +- [Device, name: "RTC_", table: 0, index: 2616, offset: 0x1853] + | | | | +- [NamePath, table: 0, index: 2617, offset: 0x1856] -> [namepath: "RTC_"] + | | | | +- [ScopeBlock, table: 0, index: 2618, offset: 0x185a] + | | | | +- [Name, name: "_HID", table: 0, index: 2619, offset: 0x185a] + | | | | | +- [NamePath, table: 0, index: 2620, offset: 0x185b] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2621, offset: 0x185f] -> [num value; dec: 774209, hex: 0xbd041] [EISA: "PNP0B00"] + | | | | +- [Name, name: "_CRS", table: 0, index: 2622, offset: 0x1864] + | | | | | +- [NamePath, table: 0, index: 2623, offset: 0x1865] -> [namepath: "_CRS"] + | | | | | +- [Buffer, table: 0, index: 2624, offset: 0x1869] + | | | | | +- [BytePrefix, table: 0, index: 3495, offset: 0x186b] -> [num value; dec: 10, hex: 0xa] + | | | | | +- [ByteList, table: 0, index: 3496, offset: 0x0] -> [bytelist value; len: 10; data: [0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x1, 0x2, 0x79, 0x0]] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2625, offset: 0x1877] + | | | | +- [NamePath, table: 0, index: 2626, offset: 0x1879] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2627, offset: 0x187d] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2628, offset: 0x187e] + | | | | +- [Return, table: 0, index: 2629, offset: 0x187e] + | | | | +- [ResolvedNamePath, table: 0, index: 2630, offset: 0x187f] -> [resolved to "URTC", table: 0, index: 343, offset: 0x44c] + | | | +- [Device, name: "HPET", table: 0, index: 2631, offset: 0x1883] + | | | | +- [NamePath, table: 0, index: 2632, offset: 0x1887] -> [namepath: "HPET"] + | | | | +- [ScopeBlock, table: 0, index: 2633, offset: 0x188b] + | | | | +- [Name, name: "_HID", table: 0, index: 2634, offset: 0x188b] + | | | | | +- [NamePath, table: 0, index: 2635, offset: 0x188c] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2636, offset: 0x1890] -> [num value; dec: 50450497, hex: 0x301d041] [EISA: "PNP0103"] + | | | | +- [Name, name: "_CID", table: 0, index: 2637, offset: 0x1895] + | | | | | +- [NamePath, table: 0, index: 2638, offset: 0x1896] -> [namepath: "_CID"] + | | | | | +- [DwordPrefix, table: 0, index: 2639, offset: 0x189a] -> [num value; dec: 17616961, hex: 0x10cd041] + | | | | +- [Name, name: "_UID", table: 0, index: 2640, offset: 0x189f] + | | | | | +- [NamePath, table: 0, index: 2641, offset: 0x18a0] -> [namepath: "_UID"] + | | | | | +- [Zero, table: 0, index: 2642, offset: 0x18a4] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2643, offset: 0x18a5] + | | | | | +- [NamePath, table: 0, index: 2644, offset: 0x18a7] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2645, offset: 0x18ab] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2646, offset: 0x18ac] + | | | | | +- [Return, table: 0, index: 2647, offset: 0x18ac] + | | | | | +- [ResolvedNamePath, table: 0, index: 2648, offset: 0x18ad] -> [resolved to "UHPT", table: 0, index: 335, offset: 0x424] + | | | | +- [Name, name: "CRS_", table: 0, index: 2649, offset: 0x18b1] + | | | | | +- [NamePath, table: 0, index: 2650, offset: 0x18b2] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2651, offset: 0x18b6] + | | | | | +- [BytePrefix, table: 0, index: 3497, offset: 0x18b8] -> [num value; dec: 20, hex: 0x14] + | | | | | +- [ByteList, table: 0, index: 3498, offset: 0x0] -> [bytelist value; len: 20; data: [0x22, 0x1, 0x0, 0x22, 0x0, 0x1, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xd0, 0xfe, 0x0, 0x4, 0x0, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2652, offset: 0x18ce] + | | | | +- [NamePath, table: 0, index: 2653, offset: 0x18d0] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2654, offset: 0x18d4] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2655, offset: 0x18d5] + | | | | +- [Return, table: 0, index: 2656, offset: 0x18d5] + | | | | +- [ResolvedNamePath, table: 0, index: 2657, offset: 0x18d6] -> [resolved to "CRS_", table: 0, index: 2649, offset: 0x18b1] + | | | +- [Device, name: "SMC_", table: 0, index: 2658, offset: 0x18da] + | | | | +- [NamePath, table: 0, index: 2659, offset: 0x18de] -> [namepath: "SMC_"] + | | | | +- [ScopeBlock, table: 0, index: 2660, offset: 0x18e2] + | | | | +- [Name, name: "_HID", table: 0, index: 2661, offset: 0x18e2] + | | | | | +- [NamePath, table: 0, index: 2662, offset: 0x18e3] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2663, offset: 0x18e7] -> [num value; dec: 16781318, hex: 0x1001006] [EISA: "APP0001"] + | | | | +- [Name, name: "_CID", table: 0, index: 2664, offset: 0x18ec] + | | | | | +- [NamePath, table: 0, index: 2665, offset: 0x18ed] -> [namepath: "_CID"] + | | | | | +- [StringPrefix, table: 0, index: 2666, offset: 0x18f1] -> [string value: "smc-napa"] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2667, offset: 0x18fb] + | | | | | +- [NamePath, table: 0, index: 2668, offset: 0x18fd] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2669, offset: 0x1901] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2670, offset: 0x1902] + | | | | | +- [Return, table: 0, index: 2671, offset: 0x1902] + | | | | | +- [ResolvedNamePath, table: 0, index: 2672, offset: 0x1903] -> [resolved to "USMC", table: 0, index: 336, offset: 0x429] + | | | | +- [Name, name: "CRS_", table: 0, index: 2673, offset: 0x1907] + | | | | | +- [NamePath, table: 0, index: 2674, offset: 0x1908] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2675, offset: 0x190c] + | | | | | +- [BytePrefix, table: 0, index: 3499, offset: 0x190e] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3500, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0x0, 0x3, 0x0, 0x3, 0x1, 0x20, 0x22, 0x40, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2676, offset: 0x191d] + | | | | +- [NamePath, table: 0, index: 2677, offset: 0x191f] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2678, offset: 0x1923] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2679, offset: 0x1924] + | | | | +- [Return, table: 0, index: 2680, offset: 0x1924] + | | | | +- [ResolvedNamePath, table: 0, index: 2681, offset: 0x1925] -> [resolved to "CRS_", table: 0, index: 2673, offset: 0x1907] + | | | +- [Device, name: "PCIE", table: 0, index: 2171, offset: 0x1328] + | | | | +- [NamePath, table: 0, index: 2172, offset: 0x132c] -> [namepath: "PCIE"] + | | | | +- [ScopeBlock, table: 0, index: 2173, offset: 0x1331] + | | | | +- [Name, name: "_HID", table: 0, index: 2174, offset: 0x1331] + | | | | | +- [NamePath, table: 0, index: 2175, offset: 0x1332] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2176, offset: 0x1336] -> [num value; dec: 34394177, hex: 0x20cd041] [EISA: "PNP0C02"] + | | | | +- [Name, name: "_UID", table: 0, index: 2177, offset: 0x133b] + | | | | | +- [NamePath, table: 0, index: 2178, offset: 0x133c] -> [namepath: "_UID"] + | | | | | +- [BytePrefix, table: 0, index: 2179, offset: 0x1340] -> [num value; dec: 17, hex: 0x11] + | | | | +- [Name, name: "CRS_", table: 0, index: 2180, offset: 0x1342] + | | | | | +- [NamePath, table: 0, index: 2181, offset: 0x1343] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2182, offset: 0x1347] + | | | | | +- [BytePrefix, table: 0, index: 3501, offset: 0x1349] -> [num value; dec: 14, hex: 0xe] + | | | | | +- [ByteList, table: 0, index: 3502, offset: 0x0] -> [bytelist value; len: 14; data: [0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xdc, 0x0, 0x0, 0x0, 0x4, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2183, offset: 0x1359] + | | | | | +- [NamePath, table: 0, index: 2184, offset: 0x135b] -> [namepath: "_CRS"] + | | | | | +- [BytePrefix, table: 0, index: 2185, offset: 0x135f] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2186, offset: 0x1360] + | | | | | +- [CreateDWordField, table: 0, index: 2187, offset: 0x1360] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2188, offset: 0x1361] -> [resolved to "CRS_", table: 0, index: 2180, offset: 0x1342] + | | | | | | +- [BytePrefix, table: 0, index: 2189, offset: 0x1365] -> [num value; dec: 4, hex: 0x4] + | | | | | | +- [NamePath, table: 0, index: 2190, offset: 0x1367] -> [namepath: "BAS1"] + | | | | | +- [CreateDWordField, table: 0, index: 2191, offset: 0x136b] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2192, offset: 0x136c] -> [resolved to "CRS_", table: 0, index: 2180, offset: 0x1342] + | | | | | | +- [BytePrefix, table: 0, index: 2193, offset: 0x1370] -> [num value; dec: 8, hex: 0x8] + | | | | | | +- [NamePath, table: 0, index: 2194, offset: 0x1372] -> [namepath: "LEN1"] + | | | | | +- [Store, table: 0, index: 2195, offset: 0x1376] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2196, offset: 0x1377] -> [resolved to "PCIB", table: 0, index: 353, offset: 0x47e] + | | | | | | +- [NamePath, table: 0, index: 2197, offset: 0x137b] -> [namepath: "BAS1"] + | | | | | +- [Store, table: 0, index: 2198, offset: 0x137f] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2199, offset: 0x1380] -> [resolved to "PCIL", table: 0, index: 354, offset: 0x483] + | | | | | | +- [NamePath, table: 0, index: 2200, offset: 0x1384] -> [namepath: "LEN1"] + | | | | | +- [Return, table: 0, index: 2201, offset: 0x1388] + | | | | | +- [ResolvedNamePath, table: 0, index: 2202, offset: 0x1389] -> [resolved to "CRS_", table: 0, index: 2180, offset: 0x1342] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2203, offset: 0x138d] + | | | | +- [NamePath, table: 0, index: 2204, offset: 0x138f] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2205, offset: 0x1393] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2206, offset: 0x1394] + | | | | +- [If, table: 0, index: 2207, offset: 0x1394] + | | | | | +- [LEqual, table: 0, index: 2208, offset: 0x1396] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2209, offset: 0x1397] -> [resolved to "PCIB", table: 0, index: 353, offset: 0x47e] + | | | | | | +- [Zero, table: 0, index: 2210, offset: 0x139b] + | | | | | +- [Return, table: 0, index: 2211, offset: 0x139c] + | | | | | +- [Zero, table: 0, index: 2212, offset: 0x139d] + | | | | +- [Else, table: 0, index: 2213, offset: 0x139e] + | | | | +- [ScopeBlock, table: 0, index: 2214, offset: 0x13a0] + | | | | +- [Return, table: 0, index: 2215, offset: 0x13a0] + | | | | +- [BytePrefix, table: 0, index: 2216, offset: 0x13a1] -> [num value; dec: 15, hex: 0xf] + | | | +- [Device, name: "LPT0", table: 0, index: 2274, offset: 0x149c] + | | | | +- [NamePath, table: 0, index: 2275, offset: 0x14a0] -> [namepath: "LPT0"] + | | | | +- [ScopeBlock, table: 0, index: 2276, offset: 0x14a5] + | | | | +- [Name, name: "_HID", table: 0, index: 2277, offset: 0x14a5] + | | | | | +- [NamePath, table: 0, index: 2278, offset: 0x14a6] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2279, offset: 0x14aa] -> [num value; dec: 315457, hex: 0x4d041] [EISA: "PNP0400"] + | | | | +- [Name, name: "_UID", table: 0, index: 2280, offset: 0x14af] + | | | | | +- [NamePath, table: 0, index: 2281, offset: 0x14b0] -> [namepath: "_UID"] + | | | | | +- [One, table: 0, index: 2282, offset: 0x14b4] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2283, offset: 0x14b5] + | | | | | +- [NamePath, table: 0, index: 2284, offset: 0x14b7] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2285, offset: 0x14bb] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2286, offset: 0x14bc] + | | | | | +- [If, table: 0, index: 2287, offset: 0x14bc] + | | | | | | +- [LEqual, table: 0, index: 2288, offset: 0x14be] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2289, offset: 0x14bf] -> [resolved to "PP0B", table: 0, index: 359, offset: 0x49c] + | | | | | | | +- [Zero, table: 0, index: 2290, offset: 0x14c3] + | | | | | | +- [Return, table: 0, index: 2291, offset: 0x14c4] + | | | | | | +- [Zero, table: 0, index: 2292, offset: 0x14c5] + | | | | | +- [Else, table: 0, index: 2293, offset: 0x14c6] + | | | | | +- [ScopeBlock, table: 0, index: 2294, offset: 0x14c8] + | | | | | +- [Return, table: 0, index: 2295, offset: 0x14c8] + | | | | | +- [BytePrefix, table: 0, index: 2296, offset: 0x14c9] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | | | +- [NamePath, table: 0, index: 2298, offset: 0x14cc] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2299, offset: 0x14d0] + | | | | | +- [BytePrefix, table: 0, index: 3503, offset: 0x14d2] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3504, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x8, 0x8, 0x22, 0x80, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2300, offset: 0x14e1] + | | | | +- [NamePath, table: 0, index: 2301, offset: 0x14e4] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2302, offset: 0x14e8] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2303, offset: 0x14e9] + | | | | +- [CreateWordField, table: 0, index: 2304, offset: 0x14e9] + | | | | | +- [ResolvedNamePath, table: 0, index: 2305, offset: 0x14ea] -> [resolved to "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | | | +- [BytePrefix, table: 0, index: 2306, offset: 0x14ee] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2307, offset: 0x14f0] -> [namepath: "PMI0"] + | | | | +- [CreateWordField, table: 0, index: 2308, offset: 0x14f4] + | | | | | +- [ResolvedNamePath, table: 0, index: 2309, offset: 0x14f5] -> [resolved to "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | | | +- [BytePrefix, table: 0, index: 2310, offset: 0x14f9] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2311, offset: 0x14fb] -> [namepath: "PMA0"] + | | | | +- [CreateWordField, table: 0, index: 2312, offset: 0x14ff] + | | | | | +- [ResolvedNamePath, table: 0, index: 2313, offset: 0x1500] -> [resolved to "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | | | +- [BytePrefix, table: 0, index: 2314, offset: 0x1504] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2315, offset: 0x1506] -> [namepath: "PIQ0"] + | | | | +- [Store, table: 0, index: 2316, offset: 0x150a] + | | | | | +- [ResolvedNamePath, table: 0, index: 2317, offset: 0x150b] -> [resolved to "PP0B", table: 0, index: 359, offset: 0x49c] + | | | | | +- [NamePath, table: 0, index: 2318, offset: 0x150f] -> [namepath: "PMI0"] + | | | | +- [Store, table: 0, index: 2319, offset: 0x1513] + | | | | | +- [ResolvedNamePath, table: 0, index: 2320, offset: 0x1514] -> [resolved to "PP0B", table: 0, index: 359, offset: 0x49c] + | | | | | +- [NamePath, table: 0, index: 2321, offset: 0x1518] -> [namepath: "PMA0"] + | | | | +- [ShiftLeft, table: 0, index: 2322, offset: 0x151c] + | | | | | +- [One, table: 0, index: 2323, offset: 0x151d] + | | | | | +- [ResolvedNamePath, table: 0, index: 2324, offset: 0x151e] -> [resolved to "PP0I", table: 0, index: 360, offset: 0x4a1] + | | | | | +- [NamePath, table: 0, index: 2325, offset: 0x1522] -> [namepath: "PIQ0"] + | | | | +- [Return, table: 0, index: 2326, offset: 0x1526] + | | | | +- [ResolvedNamePath, table: 0, index: 2327, offset: 0x1527] -> [resolved to "CRS_", table: 0, index: 2297, offset: 0x14cb] + | | | +- [Device, name: "LPT1", table: 0, index: 2328, offset: 0x152b] + | | | | +- [NamePath, table: 0, index: 2329, offset: 0x152f] -> [namepath: "LPT1"] + | | | | +- [ScopeBlock, table: 0, index: 2330, offset: 0x1534] + | | | | +- [Name, name: "_HID", table: 0, index: 2331, offset: 0x1534] + | | | | | +- [NamePath, table: 0, index: 2332, offset: 0x1535] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2333, offset: 0x1539] -> [num value; dec: 315457, hex: 0x4d041] [EISA: "PNP0400"] + | | | | +- [Name, name: "_UID", table: 0, index: 2334, offset: 0x153e] + | | | | | +- [NamePath, table: 0, index: 2335, offset: 0x153f] -> [namepath: "_UID"] + | | | | | +- [BytePrefix, table: 0, index: 2336, offset: 0x1543] -> [num value; dec: 2, hex: 0x2] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2337, offset: 0x1545] + | | | | | +- [NamePath, table: 0, index: 2338, offset: 0x1547] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2339, offset: 0x154b] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2340, offset: 0x154c] + | | | | | +- [If, table: 0, index: 2341, offset: 0x154c] + | | | | | | +- [LEqual, table: 0, index: 2342, offset: 0x154e] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2343, offset: 0x154f] -> [resolved to "PP1B", table: 0, index: 361, offset: 0x4a6] + | | | | | | | +- [Zero, table: 0, index: 2344, offset: 0x1553] + | | | | | | +- [Return, table: 0, index: 2345, offset: 0x1554] + | | | | | | +- [Zero, table: 0, index: 2346, offset: 0x1555] + | | | | | +- [Else, table: 0, index: 2347, offset: 0x1556] + | | | | | +- [ScopeBlock, table: 0, index: 2348, offset: 0x1558] + | | | | | +- [Return, table: 0, index: 2349, offset: 0x1558] + | | | | | +- [BytePrefix, table: 0, index: 2350, offset: 0x1559] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | | | +- [NamePath, table: 0, index: 2352, offset: 0x155c] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2353, offset: 0x1560] + | | | | | +- [BytePrefix, table: 0, index: 3505, offset: 0x1562] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3506, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x8, 0x8, 0x22, 0x20, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2354, offset: 0x1571] + | | | | +- [NamePath, table: 0, index: 2355, offset: 0x1574] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2356, offset: 0x1578] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2357, offset: 0x1579] + | | | | +- [CreateWordField, table: 0, index: 2358, offset: 0x1579] + | | | | | +- [ResolvedNamePath, table: 0, index: 2359, offset: 0x157a] -> [resolved to "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | | | +- [BytePrefix, table: 0, index: 2360, offset: 0x157e] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2361, offset: 0x1580] -> [namepath: "PMI1"] + | | | | +- [CreateWordField, table: 0, index: 2362, offset: 0x1584] + | | | | | +- [ResolvedNamePath, table: 0, index: 2363, offset: 0x1585] -> [resolved to "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | | | +- [BytePrefix, table: 0, index: 2364, offset: 0x1589] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2365, offset: 0x158b] -> [namepath: "PMA1"] + | | | | +- [CreateWordField, table: 0, index: 2366, offset: 0x158f] + | | | | | +- [ResolvedNamePath, table: 0, index: 2367, offset: 0x1590] -> [resolved to "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | | | +- [BytePrefix, table: 0, index: 2368, offset: 0x1594] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2369, offset: 0x1596] -> [namepath: "PIQ1"] + | | | | +- [Store, table: 0, index: 2370, offset: 0x159a] + | | | | | +- [ResolvedNamePath, table: 0, index: 2371, offset: 0x159b] -> [resolved to "PP1B", table: 0, index: 361, offset: 0x4a6] + | | | | | +- [NamePath, table: 0, index: 2372, offset: 0x159f] -> [namepath: "PMI1"] + | | | | +- [Store, table: 0, index: 2373, offset: 0x15a3] + | | | | | +- [ResolvedNamePath, table: 0, index: 2374, offset: 0x15a4] -> [resolved to "PP1B", table: 0, index: 361, offset: 0x4a6] + | | | | | +- [NamePath, table: 0, index: 2375, offset: 0x15a8] -> [namepath: "PMA1"] + | | | | +- [ShiftLeft, table: 0, index: 2376, offset: 0x15ac] + | | | | | +- [One, table: 0, index: 2377, offset: 0x15ad] + | | | | | +- [ResolvedNamePath, table: 0, index: 2378, offset: 0x15ae] -> [resolved to "PP1I", table: 0, index: 362, offset: 0x4ab] + | | | | | +- [NamePath, table: 0, index: 2379, offset: 0x15b2] -> [namepath: "PIQ1"] + | | | | +- [Return, table: 0, index: 2380, offset: 0x15b6] + | | | | +- [ResolvedNamePath, table: 0, index: 2381, offset: 0x15b7] -> [resolved to "CRS_", table: 0, index: 2351, offset: 0x155b] + | | | +- [Device, name: "SRL0", table: 0, index: 2382, offset: 0x15bb] + | | | | +- [NamePath, table: 0, index: 2383, offset: 0x15bf] -> [namepath: "SRL0"] + | | | | +- [ScopeBlock, table: 0, index: 2384, offset: 0x15c4] + | | | | +- [Name, name: "_HID", table: 0, index: 2385, offset: 0x15c4] + | | | | | +- [NamePath, table: 0, index: 2386, offset: 0x15c5] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2387, offset: 0x15c9] -> [num value; dec: 17158209, hex: 0x105d041] [EISA: "PNP0501"] + | | | | +- [Name, name: "_UID", table: 0, index: 2388, offset: 0x15ce] + | | | | | +- [NamePath, table: 0, index: 2389, offset: 0x15cf] -> [namepath: "_UID"] + | | | | | +- [One, table: 0, index: 2390, offset: 0x15d3] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2391, offset: 0x15d4] + | | | | | +- [NamePath, table: 0, index: 2392, offset: 0x15d6] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2393, offset: 0x15da] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2394, offset: 0x15db] + | | | | | +- [If, table: 0, index: 2395, offset: 0x15db] + | | | | | | +- [LEqual, table: 0, index: 2396, offset: 0x15dd] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2397, offset: 0x15de] -> [resolved to "SL0B", table: 0, index: 355, offset: 0x488] + | | | | | | | +- [Zero, table: 0, index: 2398, offset: 0x15e2] + | | | | | | +- [Return, table: 0, index: 2399, offset: 0x15e3] + | | | | | | +- [Zero, table: 0, index: 2400, offset: 0x15e4] + | | | | | +- [Else, table: 0, index: 2401, offset: 0x15e5] + | | | | | +- [ScopeBlock, table: 0, index: 2402, offset: 0x15e7] + | | | | | +- [Return, table: 0, index: 2403, offset: 0x15e7] + | | | | | +- [BytePrefix, table: 0, index: 2404, offset: 0x15e8] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | | | +- [NamePath, table: 0, index: 2406, offset: 0x15eb] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2407, offset: 0x15ef] + | | | | | +- [BytePrefix, table: 0, index: 3507, offset: 0x15f1] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3508, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x22, 0x10, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2408, offset: 0x1600] + | | | | +- [NamePath, table: 0, index: 2409, offset: 0x1603] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2410, offset: 0x1607] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2411, offset: 0x1608] + | | | | +- [CreateWordField, table: 0, index: 2412, offset: 0x1608] + | | | | | +- [ResolvedNamePath, table: 0, index: 2413, offset: 0x1609] -> [resolved to "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | | | +- [BytePrefix, table: 0, index: 2414, offset: 0x160d] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2415, offset: 0x160f] -> [namepath: "MIN0"] + | | | | +- [CreateWordField, table: 0, index: 2416, offset: 0x1613] + | | | | | +- [ResolvedNamePath, table: 0, index: 2417, offset: 0x1614] -> [resolved to "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | | | +- [BytePrefix, table: 0, index: 2418, offset: 0x1618] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2419, offset: 0x161a] -> [namepath: "MAX0"] + | | | | +- [CreateWordField, table: 0, index: 2420, offset: 0x161e] + | | | | | +- [ResolvedNamePath, table: 0, index: 2421, offset: 0x161f] -> [resolved to "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | | | +- [BytePrefix, table: 0, index: 2422, offset: 0x1623] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2423, offset: 0x1625] -> [namepath: "IRQ0"] + | | | | +- [Store, table: 0, index: 2424, offset: 0x1629] + | | | | | +- [ResolvedNamePath, table: 0, index: 2425, offset: 0x162a] -> [resolved to "SL0B", table: 0, index: 355, offset: 0x488] + | | | | | +- [NamePath, table: 0, index: 2426, offset: 0x162e] -> [namepath: "MIN0"] + | | | | +- [Store, table: 0, index: 2427, offset: 0x1632] + | | | | | +- [ResolvedNamePath, table: 0, index: 2428, offset: 0x1633] -> [resolved to "SL0B", table: 0, index: 355, offset: 0x488] + | | | | | +- [NamePath, table: 0, index: 2429, offset: 0x1637] -> [namepath: "MAX0"] + | | | | +- [ShiftLeft, table: 0, index: 2430, offset: 0x163b] + | | | | | +- [One, table: 0, index: 2431, offset: 0x163c] + | | | | | +- [ResolvedNamePath, table: 0, index: 2432, offset: 0x163d] -> [resolved to "SL0I", table: 0, index: 356, offset: 0x48d] + | | | | | +- [NamePath, table: 0, index: 2433, offset: 0x1641] -> [namepath: "IRQ0"] + | | | | +- [Return, table: 0, index: 2434, offset: 0x1645] + | | | | +- [ResolvedNamePath, table: 0, index: 2435, offset: 0x1646] -> [resolved to "CRS_", table: 0, index: 2405, offset: 0x15ea] + | | | +- [Device, name: "SRL1", table: 0, index: 2436, offset: 0x164a] + | | | | +- [NamePath, table: 0, index: 2437, offset: 0x164e] -> [namepath: "SRL1"] + | | | | +- [ScopeBlock, table: 0, index: 2438, offset: 0x1653] + | | | | +- [Name, name: "_HID", table: 0, index: 2439, offset: 0x1653] + | | | | | +- [NamePath, table: 0, index: 2440, offset: 0x1654] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2441, offset: 0x1658] -> [num value; dec: 17158209, hex: 0x105d041] [EISA: "PNP0501"] + | | | | +- [Name, name: "_UID", table: 0, index: 2442, offset: 0x165d] + | | | | | +- [NamePath, table: 0, index: 2443, offset: 0x165e] -> [namepath: "_UID"] + | | | | | +- [BytePrefix, table: 0, index: 2444, offset: 0x1662] -> [num value; dec: 2, hex: 0x2] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2445, offset: 0x1664] + | | | | | +- [NamePath, table: 0, index: 2446, offset: 0x1666] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2447, offset: 0x166a] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2448, offset: 0x166b] + | | | | | +- [If, table: 0, index: 2449, offset: 0x166b] + | | | | | | +- [LEqual, table: 0, index: 2450, offset: 0x166d] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2451, offset: 0x166e] -> [resolved to "SL1B", table: 0, index: 357, offset: 0x492] + | | | | | | | +- [Zero, table: 0, index: 2452, offset: 0x1672] + | | | | | | +- [Return, table: 0, index: 2453, offset: 0x1673] + | | | | | | +- [Zero, table: 0, index: 2454, offset: 0x1674] + | | | | | +- [Else, table: 0, index: 2455, offset: 0x1675] + | | | | | +- [ScopeBlock, table: 0, index: 2456, offset: 0x1677] + | | | | | +- [Return, table: 0, index: 2457, offset: 0x1677] + | | | | | +- [BytePrefix, table: 0, index: 2458, offset: 0x1678] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | | | +- [NamePath, table: 0, index: 2460, offset: 0x167b] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2461, offset: 0x167f] + | | | | | +- [BytePrefix, table: 0, index: 3509, offset: 0x1681] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3510, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x22, 0x8, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2462, offset: 0x1690] + | | | | +- [NamePath, table: 0, index: 2463, offset: 0x1693] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2464, offset: 0x1697] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2465, offset: 0x1698] + | | | | +- [CreateWordField, table: 0, index: 2466, offset: 0x1698] + | | | | | +- [ResolvedNamePath, table: 0, index: 2467, offset: 0x1699] -> [resolved to "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | | | +- [BytePrefix, table: 0, index: 2468, offset: 0x169d] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2469, offset: 0x169f] -> [namepath: "MIN1"] + | | | | +- [CreateWordField, table: 0, index: 2470, offset: 0x16a3] + | | | | | +- [ResolvedNamePath, table: 0, index: 2471, offset: 0x16a4] -> [resolved to "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | | | +- [BytePrefix, table: 0, index: 2472, offset: 0x16a8] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2473, offset: 0x16aa] -> [namepath: "MAX1"] + | | | | +- [CreateWordField, table: 0, index: 2474, offset: 0x16ae] + | | | | | +- [ResolvedNamePath, table: 0, index: 2475, offset: 0x16af] -> [resolved to "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | | | +- [BytePrefix, table: 0, index: 2476, offset: 0x16b3] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2477, offset: 0x16b5] -> [namepath: "IRQ1"] + | | | | +- [Store, table: 0, index: 2478, offset: 0x16b9] + | | | | | +- [ResolvedNamePath, table: 0, index: 2479, offset: 0x16ba] -> [resolved to "SL1B", table: 0, index: 357, offset: 0x492] + | | | | | +- [NamePath, table: 0, index: 2480, offset: 0x16be] -> [namepath: "MIN1"] + | | | | +- [Store, table: 0, index: 2481, offset: 0x16c2] + | | | | | +- [ResolvedNamePath, table: 0, index: 2482, offset: 0x16c3] -> [resolved to "SL1B", table: 0, index: 357, offset: 0x492] + | | | | | +- [NamePath, table: 0, index: 2483, offset: 0x16c7] -> [namepath: "MAX1"] + | | | | +- [ShiftLeft, table: 0, index: 2484, offset: 0x16cb] + | | | | | +- [One, table: 0, index: 2485, offset: 0x16cc] + | | | | | +- [ResolvedNamePath, table: 0, index: 2486, offset: 0x16cd] -> [resolved to "SL1I", table: 0, index: 358, offset: 0x497] + | | | | | +- [NamePath, table: 0, index: 2487, offset: 0x16d1] -> [namepath: "IRQ1"] + | | | | +- [Return, table: 0, index: 2488, offset: 0x16d5] + | | | | +- [ResolvedNamePath, table: 0, index: 2489, offset: 0x16d6] -> [resolved to "CRS_", table: 0, index: 2459, offset: 0x167a] + | | | +- [Device, name: "SRL2", table: 0, index: 2490, offset: 0x16da] + | | | | +- [NamePath, table: 0, index: 2491, offset: 0x16de] -> [namepath: "SRL2"] + | | | | +- [ScopeBlock, table: 0, index: 2492, offset: 0x16e3] + | | | | +- [Name, name: "_HID", table: 0, index: 2493, offset: 0x16e3] + | | | | | +- [NamePath, table: 0, index: 2494, offset: 0x16e4] -> [namepath: "_HID"] + | | | | | +- [DwordPrefix, table: 0, index: 2495, offset: 0x16e8] -> [num value; dec: 17158209, hex: 0x105d041] [EISA: "PNP0501"] + | | | | +- [Name, name: "_UID", table: 0, index: 2496, offset: 0x16ed] + | | | | | +- [NamePath, table: 0, index: 2497, offset: 0x16ee] -> [namepath: "_UID"] + | | | | | +- [BytePrefix, table: 0, index: 2498, offset: 0x16f2] -> [num value; dec: 3, hex: 0x3] + | | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2499, offset: 0x16f4] + | | | | | +- [NamePath, table: 0, index: 2500, offset: 0x16f6] -> [namepath: "_STA"] + | | | | | +- [BytePrefix, table: 0, index: 2501, offset: 0x16fa] -> [num value; dec: 0, hex: 0x0] + | | | | | +- [ScopeBlock, table: 0, index: 2502, offset: 0x16fb] + | | | | | +- [If, table: 0, index: 2503, offset: 0x16fb] + | | | | | | +- [LEqual, table: 0, index: 2504, offset: 0x16fd] + | | | | | | | +- [ResolvedNamePath, table: 0, index: 2505, offset: 0x16fe] -> [resolved to "SL2B", table: 0, index: 338, offset: 0x433] + | | | | | | | +- [Zero, table: 0, index: 2506, offset: 0x1702] + | | | | | | +- [Return, table: 0, index: 2507, offset: 0x1703] + | | | | | | +- [Zero, table: 0, index: 2508, offset: 0x1704] + | | | | | +- [Else, table: 0, index: 2509, offset: 0x1705] + | | | | | +- [ScopeBlock, table: 0, index: 2510, offset: 0x1707] + | | | | | +- [Return, table: 0, index: 2511, offset: 0x1707] + | | | | | +- [BytePrefix, table: 0, index: 2512, offset: 0x1708] -> [num value; dec: 15, hex: 0xf] + | | | | +- [Name, name: "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | | | +- [NamePath, table: 0, index: 2514, offset: 0x170b] -> [namepath: "CRS_"] + | | | | | +- [Buffer, table: 0, index: 2515, offset: 0x170f] + | | | | | +- [BytePrefix, table: 0, index: 3511, offset: 0x1711] -> [num value; dec: 13, hex: 0xd] + | | | | | +- [ByteList, table: 0, index: 3512, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x22, 0x8, 0x0, 0x79, 0x0]] + | | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2516, offset: 0x1720] + | | | | +- [NamePath, table: 0, index: 2517, offset: 0x1723] -> [namepath: "_CRS"] + | | | | +- [BytePrefix, table: 0, index: 2518, offset: 0x1727] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2519, offset: 0x1728] + | | | | +- [CreateWordField, table: 0, index: 2520, offset: 0x1728] + | | | | | +- [ResolvedNamePath, table: 0, index: 2521, offset: 0x1729] -> [resolved to "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | | | +- [BytePrefix, table: 0, index: 2522, offset: 0x172d] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [NamePath, table: 0, index: 2523, offset: 0x172f] -> [namepath: "MIN1"] + | | | | +- [CreateWordField, table: 0, index: 2524, offset: 0x1733] + | | | | | +- [ResolvedNamePath, table: 0, index: 2525, offset: 0x1734] -> [resolved to "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | | | +- [BytePrefix, table: 0, index: 2526, offset: 0x1738] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [NamePath, table: 0, index: 2527, offset: 0x173a] -> [namepath: "MAX1"] + | | | | +- [CreateWordField, table: 0, index: 2528, offset: 0x173e] + | | | | | +- [ResolvedNamePath, table: 0, index: 2529, offset: 0x173f] -> [resolved to "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | | | +- [BytePrefix, table: 0, index: 2530, offset: 0x1743] -> [num value; dec: 9, hex: 0x9] + | | | | | +- [NamePath, table: 0, index: 2531, offset: 0x1745] -> [namepath: "IRQ1"] + | | | | +- [Store, table: 0, index: 2532, offset: 0x1749] + | | | | | +- [ResolvedNamePath, table: 0, index: 2533, offset: 0x174a] -> [resolved to "SL2B", table: 0, index: 338, offset: 0x433] + | | | | | +- [NamePath, table: 0, index: 2534, offset: 0x174e] -> [namepath: "MIN1"] + | | | | +- [Store, table: 0, index: 2535, offset: 0x1752] + | | | | | +- [ResolvedNamePath, table: 0, index: 2536, offset: 0x1753] -> [resolved to "SL2B", table: 0, index: 338, offset: 0x433] + | | | | | +- [NamePath, table: 0, index: 2537, offset: 0x1757] -> [namepath: "MAX1"] + | | | | +- [ShiftLeft, table: 0, index: 2538, offset: 0x175b] + | | | | | +- [One, table: 0, index: 2539, offset: 0x175c] + | | | | | +- [ResolvedNamePath, table: 0, index: 2540, offset: 0x175d] -> [resolved to "SL2I", table: 0, index: 339, offset: 0x438] + | | | | | +- [NamePath, table: 0, index: 2541, offset: 0x1761] -> [namepath: "IRQ1"] + | | | | +- [Return, table: 0, index: 2542, offset: 0x1765] + | | | | +- [ResolvedNamePath, table: 0, index: 2543, offset: 0x1766] -> [resolved to "CRS_", table: 0, index: 2513, offset: 0x170a] + | | | +- [Device, name: "SRL3", table: 0, index: 2544, offset: 0x176a] + | | | +- [NamePath, table: 0, index: 2545, offset: 0x176e] -> [namepath: "SRL3"] + | | | +- [ScopeBlock, table: 0, index: 2546, offset: 0x1773] + | | | +- [Name, name: "_HID", table: 0, index: 2547, offset: 0x1773] + | | | | +- [NamePath, table: 0, index: 2548, offset: 0x1774] -> [namepath: "_HID"] + | | | | +- [DwordPrefix, table: 0, index: 2549, offset: 0x1778] -> [num value; dec: 17158209, hex: 0x105d041] [EISA: "PNP0501"] + | | | +- [Name, name: "_UID", table: 0, index: 2550, offset: 0x177d] + | | | | +- [NamePath, table: 0, index: 2551, offset: 0x177e] -> [namepath: "_UID"] + | | | | +- [BytePrefix, table: 0, index: 2552, offset: 0x1782] -> [num value; dec: 4, hex: 0x4] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2553, offset: 0x1784] + | | | | +- [NamePath, table: 0, index: 2554, offset: 0x1786] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2555, offset: 0x178a] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2556, offset: 0x178b] + | | | | +- [If, table: 0, index: 2557, offset: 0x178b] + | | | | | +- [LEqual, table: 0, index: 2558, offset: 0x178d] + | | | | | | +- [ResolvedNamePath, table: 0, index: 2559, offset: 0x178e] -> [resolved to "SL3B", table: 0, index: 340, offset: 0x43d] + | | | | | | +- [Zero, table: 0, index: 2560, offset: 0x1792] + | | | | | +- [Return, table: 0, index: 2561, offset: 0x1793] + | | | | | +- [Zero, table: 0, index: 2562, offset: 0x1794] + | | | | +- [Else, table: 0, index: 2563, offset: 0x1795] + | | | | +- [ScopeBlock, table: 0, index: 2564, offset: 0x1797] + | | | | +- [Return, table: 0, index: 2565, offset: 0x1797] + | | | | +- [BytePrefix, table: 0, index: 2566, offset: 0x1798] -> [num value; dec: 15, hex: 0xf] + | | | +- [Name, name: "CRS_", table: 0, index: 2567, offset: 0x179a] + | | | | +- [NamePath, table: 0, index: 2568, offset: 0x179b] -> [namepath: "CRS_"] + | | | | +- [Buffer, table: 0, index: 2569, offset: 0x179f] + | | | | +- [BytePrefix, table: 0, index: 3513, offset: 0x17a1] -> [num value; dec: 13, hex: 0xd] + | | | | +- [ByteList, table: 0, index: 3514, offset: 0x0] -> [bytelist value; len: 13; data: [0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x22, 0x8, 0x0, 0x79, 0x0]] + | | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 2570, offset: 0x17b0] + | | | +- [NamePath, table: 0, index: 2571, offset: 0x17b3] -> [namepath: "_CRS"] + | | | +- [BytePrefix, table: 0, index: 2572, offset: 0x17b7] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2573, offset: 0x17b8] + | | | +- [CreateWordField, table: 0, index: 2574, offset: 0x17b8] + | | | | +- [ResolvedNamePath, table: 0, index: 2575, offset: 0x17b9] -> [resolved to "CRS_", table: 0, index: 2567, offset: 0x179a] + | | | | +- [BytePrefix, table: 0, index: 2576, offset: 0x17bd] -> [num value; dec: 2, hex: 0x2] + | | | | +- [NamePath, table: 0, index: 2577, offset: 0x17bf] -> [namepath: "MIN1"] + | | | +- [CreateWordField, table: 0, index: 2578, offset: 0x17c3] + | | | | +- [ResolvedNamePath, table: 0, index: 2579, offset: 0x17c4] -> [resolved to "CRS_", table: 0, index: 2567, offset: 0x179a] + | | | | +- [BytePrefix, table: 0, index: 2580, offset: 0x17c8] -> [num value; dec: 4, hex: 0x4] + | | | | +- [NamePath, table: 0, index: 2581, offset: 0x17ca] -> [namepath: "MAX1"] + | | | +- [CreateWordField, table: 0, index: 2582, offset: 0x17ce] + | | | | +- [ResolvedNamePath, table: 0, index: 2583, offset: 0x17cf] -> [resolved to "CRS_", table: 0, index: 2567, offset: 0x179a] + | | | | +- [BytePrefix, table: 0, index: 2584, offset: 0x17d3] -> [num value; dec: 9, hex: 0x9] + | | | | +- [NamePath, table: 0, index: 2585, offset: 0x17d5] -> [namepath: "IRQ1"] + | | | +- [Store, table: 0, index: 2586, offset: 0x17d9] + | | | | +- [ResolvedNamePath, table: 0, index: 2587, offset: 0x17da] -> [resolved to "SL3B", table: 0, index: 340, offset: 0x43d] + | | | | +- [NamePath, table: 0, index: 2588, offset: 0x17de] -> [namepath: "MIN1"] + | | | +- [Store, table: 0, index: 2589, offset: 0x17e2] + | | | | +- [ResolvedNamePath, table: 0, index: 2590, offset: 0x17e3] -> [resolved to "SL3B", table: 0, index: 340, offset: 0x43d] + | | | | +- [NamePath, table: 0, index: 2591, offset: 0x17e7] -> [namepath: "MAX1"] + | | | +- [ShiftLeft, table: 0, index: 2592, offset: 0x17eb] + | | | | +- [One, table: 0, index: 2593, offset: 0x17ec] + | | | | +- [ResolvedNamePath, table: 0, index: 2594, offset: 0x17ed] -> [resolved to "SL3I", table: 0, index: 341, offset: 0x442] + | | | | +- [NamePath, table: 0, index: 2595, offset: 0x17f1] -> [namepath: "IRQ1"] + | | | +- [Return, table: 0, index: 2596, offset: 0x17f5] + | | | +- [ResolvedNamePath, table: 0, index: 2597, offset: 0x17f6] -> [resolved to "CRS_", table: 0, index: 2567, offset: 0x179a] + | | +- [Device, name: "GIGE", table: 0, index: 2682, offset: 0x1929] + | | | +- [NamePath, table: 0, index: 2683, offset: 0x192c] -> [namepath: "GIGE"] + | | | +- [ScopeBlock, table: 0, index: 2684, offset: 0x1930] + | | | +- [Name, name: "_HID", table: 0, index: 2685, offset: 0x1930] + | | | | +- [NamePath, table: 0, index: 2686, offset: 0x1931] -> [namepath: "_HID"] + | | | | +- [DwordPrefix, table: 0, index: 2687, offset: 0x1935] -> [num value; dec: 2424557633, hex: 0x9083d041] [EISA: "PNP8390"] + | | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2688, offset: 0x193a] + | | | | +- [NamePath, table: 0, index: 2689, offset: 0x193c] -> [namepath: "_ADR"] + | | | | +- [BytePrefix, table: 0, index: 2690, offset: 0x1940] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2691, offset: 0x1941] + | | | | +- [Return, table: 0, index: 2692, offset: 0x1941] + | | | | +- [ResolvedNamePath, table: 0, index: 2693, offset: 0x1942] -> [resolved to "NICA", table: 0, index: 348, offset: 0x465] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2694, offset: 0x1946] + | | | +- [NamePath, table: 0, index: 2695, offset: 0x1948] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 2696, offset: 0x194c] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2697, offset: 0x194d] + | | | +- [If, table: 0, index: 2698, offset: 0x194d] + | | | | +- [LEqual, table: 0, index: 2699, offset: 0x194f] + | | | | | +- [ResolvedNamePath, table: 0, index: 2700, offset: 0x1950] -> [resolved to "NICA", table: 0, index: 348, offset: 0x465] + | | | | | +- [Zero, table: 0, index: 2701, offset: 0x1954] + | | | | +- [Return, table: 0, index: 2702, offset: 0x1955] + | | | | +- [Zero, table: 0, index: 2703, offset: 0x1956] + | | | +- [Else, table: 0, index: 2704, offset: 0x1957] + | | | +- [ScopeBlock, table: 0, index: 2705, offset: 0x1959] + | | | +- [Return, table: 0, index: 2706, offset: 0x1959] + | | | +- [BytePrefix, table: 0, index: 2707, offset: 0x195a] -> [num value; dec: 15, hex: 0xf] + | | +- [Device, name: "GFX0", table: 0, index: 2708, offset: 0x195c] + | | | +- [NamePath, table: 0, index: 2709, offset: 0x1960] -> [namepath: "GFX0"] + | | | +- [ScopeBlock, table: 0, index: 2710, offset: 0x1964] + | | | +- [Name, name: "_ADR", table: 0, index: 2711, offset: 0x1964] + | | | | +- [NamePath, table: 0, index: 2712, offset: 0x1965] -> [namepath: "_ADR"] + | | | | +- [DwordPrefix, table: 0, index: 2713, offset: 0x1969] -> [num value; dec: 131072, hex: 0x20000] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2714, offset: 0x196e] + | | | | +- [NamePath, table: 0, index: 2715, offset: 0x1970] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2716, offset: 0x1974] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2717, offset: 0x1975] + | | | | +- [If, table: 0, index: 2718, offset: 0x1975] + | | | | | +- [Land, table: 0, index: 2719, offset: 0x1977] + | | | | | | +- [LGreater, table: 0, index: 2720, offset: 0x1978] + | | | | | | | +- [MethodCall, table: 0, index: 2721, offset: 0x1979] -> [call to "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | | | | | | | +- [Zero, table: 0, index: 2722, offset: 0x197d] + | | | | | | +- [LLess, table: 0, index: 2723, offset: 0x197e] + | | | | | | +- [MethodCall, table: 0, index: 2724, offset: 0x197f] -> [call to "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | | | | | | +- [BytePrefix, table: 0, index: 2725, offset: 0x1983] -> [num value; dec: 8, hex: 0x8] + | | | | | +- [Return, table: 0, index: 2726, offset: 0x1985] + | | | | | +- [Zero, table: 0, index: 2727, offset: 0x1986] + | | | | +- [Else, table: 0, index: 2728, offset: 0x1987] + | | | | +- [ScopeBlock, table: 0, index: 2729, offset: 0x1989] + | | | | +- [Return, table: 0, index: 2730, offset: 0x1989] + | | | | +- [BytePrefix, table: 0, index: 2731, offset: 0x198a] -> [num value; dec: 15, hex: 0xf] + | | | +- [Method, name: "_DOS", argCount: 1, table: 0, index: 2742, offset: 0x19ac] + | | | | +- [NamePath, table: 0, index: 2743, offset: 0x19ae] -> [namepath: "_DOS"] + | | | | +- [BytePrefix, table: 0, index: 2744, offset: 0x19b2] -> [num value; dec: 1, hex: 0x1] + | | | | +- [ScopeBlock, table: 0, index: 2745, offset: 0x19b3] + | | | +- [Method, name: "_DOD", argCount: 0, table: 0, index: 2746, offset: 0x19b3] + | | | | +- [NamePath, table: 0, index: 2747, offset: 0x19b5] -> [namepath: "_DOD"] + | | | | +- [BytePrefix, table: 0, index: 2748, offset: 0x19b9] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2749, offset: 0x19ba] + | | | | +- [Return, table: 0, index: 2750, offset: 0x19ba] + | | | | +- [Package, table: 0, index: 2751, offset: 0x19bb] + | | | | +- [BytePrefix, table: 0, index: 2752, offset: 0x19bd] -> [num value; dec: 1, hex: 0x1] + | | | | +- [ScopeBlock, table: 0, index: 2753, offset: 0x19be] + | | | | +- [DwordPrefix, table: 0, index: 2754, offset: 0x19be] -> [num value; dec: 2147483904, hex: 0x80000100] + | | | +- [Device, name: "VGA_", table: 0, index: 2755, offset: 0x19c3] + | | | +- [NamePath, table: 0, index: 2756, offset: 0x19c6] -> [namepath: "VGA_"] + | | | +- [ScopeBlock, table: 0, index: 2757, offset: 0x19ca] + | | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2758, offset: 0x19ca] + | | | +- [NamePath, table: 0, index: 2759, offset: 0x19cc] -> [namepath: "_ADR"] + | | | +- [BytePrefix, table: 0, index: 2760, offset: 0x19d0] -> [num value; dec: 8, hex: 0x8] + | | | +- [ScopeBlock, table: 0, index: 2761, offset: 0x19d1] + | | | +- [Return, table: 0, index: 2762, offset: 0x19d1] + | | | +- [WordPrefix, table: 0, index: 2763, offset: 0x19d2] -> [num value; dec: 256, hex: 0x100] + | | +- [Device, name: "HDEF", table: 0, index: 2764, offset: 0x19d5] + | | | +- [NamePath, table: 0, index: 2765, offset: 0x19d9] -> [namepath: "HDEF"] + | | | +- [ScopeBlock, table: 0, index: 2766, offset: 0x19dd] + | | | +- [Method, name: "_DSM", argCount: 4, table: 0, index: 2767, offset: 0x19dd] + | | | | +- [NamePath, table: 0, index: 2768, offset: 0x19e0] -> [namepath: "_DSM"] + | | | | +- [BytePrefix, table: 0, index: 2769, offset: 0x19e4] -> [num value; dec: 4, hex: 0x4] + | | | | +- [ScopeBlock, table: 0, index: 2770, offset: 0x19e5] + | | | | +- [Store, table: 0, index: 2771, offset: 0x19e5] + | | | | | +- [Package, table: 0, index: 2772, offset: 0x19e6] + | | | | | | +- [BytePrefix, table: 0, index: 2773, offset: 0x19e8] -> [num value; dec: 4, hex: 0x4] + | | | | | | +- [ScopeBlock, table: 0, index: 2774, offset: 0x19e9] + | | | | | | +- [StringPrefix, table: 0, index: 2775, offset: 0x19e9] -> [string value: "layout-id"] + | | | | | | +- [Buffer, table: 0, index: 2776, offset: 0x19f4] + | | | | | | | +- [BytePrefix, table: 0, index: 3515, offset: 0x19f6] -> [num value; dec: 4, hex: 0x4] + | | | | | | | +- [ByteList, table: 0, index: 3516, offset: 0x0] -> [bytelist value; len: 4; data: [0x4, 0x0, 0x0, 0x0]] + | | | | | | +- [StringPrefix, table: 0, index: 2777, offset: 0x19fc] -> [string value: "PinConfigurations"] + | | | | | | +- [Buffer, table: 0, index: 2778, offset: 0x1a0f] + | | | | | | +- [Zero, table: 0, index: 3517, offset: 0x1a11] + | | | | | | +- [ByteList, table: 0, index: 3518, offset: 0x0] -> [bytelist value; len: 0; data: []] + | | | | | +- [Local0, table: 0, index: 2779, offset: 0x1a12] + | | | | +- [If, table: 0, index: 2780, offset: 0x1a13] + | | | | | +- [LEqual, table: 0, index: 2781, offset: 0x1a15] + | | | | | | +- [Arg0, table: 0, index: 2782, offset: 0x1a16] + | | | | | | +- [Buffer, table: 0, index: 2783, offset: 0x1a17] + | | | | | | +- [BytePrefix, table: 0, index: 3519, offset: 0x1a19] -> [num value; dec: 16, hex: 0x10] + | | | | | | +- [ByteList, table: 0, index: 3520, offset: 0x0] -> [bytelist value; len: 16; data: [0xc6, 0xb7, 0xb5, 0xa0, 0x18, 0x13, 0x1c, 0x44, 0xb0, 0xc9, 0xfe, 0x69, 0x5e, 0xaf, 0x94, 0x9b]] + | | | | | +- [If, table: 0, index: 2784, offset: 0x1a2b] + | | | | | +- [LEqual, table: 0, index: 2785, offset: 0x1a2d] + | | | | | | +- [Arg1, table: 0, index: 2786, offset: 0x1a2e] + | | | | | | +- [One, table: 0, index: 2787, offset: 0x1a2f] + | | | | | +- [If, table: 0, index: 2788, offset: 0x1a30] + | | | | | +- [LEqual, table: 0, index: 2789, offset: 0x1a32] + | | | | | | +- [Arg2, table: 0, index: 2790, offset: 0x1a33] + | | | | | | +- [Zero, table: 0, index: 2791, offset: 0x1a34] + | | | | | +- [Store, table: 0, index: 2792, offset: 0x1a35] + | | | | | +- [Buffer, table: 0, index: 2793, offset: 0x1a36] + | | | | | | +- [One, table: 0, index: 3521, offset: 0x1a38] + | | | | | | +- [ByteList, table: 0, index: 3522, offset: 0x0] -> [bytelist value; len: 1; data: [0x3]] + | | | | | +- [Local0, table: 0, index: 2794, offset: 0x1a3a] + | | | | +- [Return, table: 0, index: 2795, offset: 0x1a3b] + | | | | | +- [Local0, table: 0, index: 2796, offset: 0x1a3c] + | | | | +- [If, table: 0, index: 2797, offset: 0x1a3d] + | | | | | +- [LEqual, table: 0, index: 2798, offset: 0x1a3f] + | | | | | | +- [Arg2, table: 0, index: 2799, offset: 0x1a40] + | | | | | | +- [One, table: 0, index: 2800, offset: 0x1a41] + | | | | | +- [Return, table: 0, index: 2801, offset: 0x1a42] + | | | | | +- [Local0, table: 0, index: 2802, offset: 0x1a43] + | | | | +- [Store, table: 0, index: 2803, offset: 0x1a44] + | | | | | +- [Buffer, table: 0, index: 2804, offset: 0x1a45] + | | | | | | +- [One, table: 0, index: 3523, offset: 0x1a47] + | | | | | | +- [ByteList, table: 0, index: 3524, offset: 0x0] -> [bytelist value; len: 1; data: [0x0]] + | | | | | +- [Local0, table: 0, index: 2805, offset: 0x1a49] + | | | | +- [Return, table: 0, index: 2806, offset: 0x1a4a] + | | | | +- [Local0, table: 0, index: 2807, offset: 0x1a4b] + | | | +- [Method, name: "_ADR", argCount: 0, table: 0, index: 2808, offset: 0x1a4c] + | | | | +- [NamePath, table: 0, index: 2809, offset: 0x1a4e] -> [namepath: "_ADR"] + | | | | +- [BytePrefix, table: 0, index: 2810, offset: 0x1a52] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2811, offset: 0x1a53] + | | | | +- [Return, table: 0, index: 2812, offset: 0x1a53] + | | | | +- [ResolvedNamePath, table: 0, index: 2813, offset: 0x1a54] -> [resolved to "HDAA", table: 0, index: 349, offset: 0x46a] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2814, offset: 0x1a58] + | | | +- [NamePath, table: 0, index: 2815, offset: 0x1a5a] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 2816, offset: 0x1a5e] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 2817, offset: 0x1a5f] + | | | +- [If, table: 0, index: 2818, offset: 0x1a5f] + | | | | +- [LEqual, table: 0, index: 2819, offset: 0x1a61] + | | | | | +- [ResolvedNamePath, table: 0, index: 2820, offset: 0x1a62] -> [resolved to "HDAA", table: 0, index: 349, offset: 0x46a] + | | | | | +- [Zero, table: 0, index: 2821, offset: 0x1a66] + | | | | +- [Return, table: 0, index: 2822, offset: 0x1a67] + | | | | +- [Zero, table: 0, index: 2823, offset: 0x1a68] + | | | +- [Else, table: 0, index: 2824, offset: 0x1a69] + | | | +- [ScopeBlock, table: 0, index: 2825, offset: 0x1a6b] + | | | +- [Return, table: 0, index: 2826, offset: 0x1a6b] + | | | +- [BytePrefix, table: 0, index: 2827, offset: 0x1a6c] -> [num value; dec: 15, hex: 0xf] + | | +- [Device, name: "BAT0", table: 0, index: 2828, offset: 0x1a6e] + | | | +- [NamePath, table: 0, index: 2829, offset: 0x1a72] -> [namepath: "BAT0"] + | | | +- [ScopeBlock, table: 0, index: 2830, offset: 0x1a76] + | | | +- [Name, name: "_HID", table: 0, index: 2831, offset: 0x1a76] + | | | | +- [NamePath, table: 0, index: 2832, offset: 0x1a77] -> [namepath: "_HID"] + | | | | +- [DwordPrefix, table: 0, index: 2833, offset: 0x1a7b] -> [num value; dec: 168611905, hex: 0xa0cd041] [EISA: "PNP0C0A"] + | | | +- [Name, name: "_UID", table: 0, index: 2834, offset: 0x1a80] + | | | | +- [NamePath, table: 0, index: 2835, offset: 0x1a81] -> [namepath: "_UID"] + | | | | +- [Zero, table: 0, index: 2836, offset: 0x1a85] + | | | +- [OpRegion, name: "CBAT", table: 0, index: 2850, offset: 0x1ab8] + | | | | +- [NamePath, table: 0, index: 2851, offset: 0x1aba] -> [namepath: "CBAT"] + | | | | +- [BytePrefix, table: 0, index: 2852, offset: 0x1abe] -> [num value; dec: 1, hex: 0x1] + | | | | +- [WordPrefix, table: 0, index: 2853, offset: 0x1abf] -> [num value; dec: 16448, hex: 0x4040] + | | | | +- [BytePrefix, table: 0, index: 2854, offset: 0x1ac2] -> [num value; dec: 8, hex: 0x8] + | | | +- [Field, table: 0, index: 2855, offset: 0x1ac4] + | | | | +- [NamePath, table: 0, index: 2856, offset: 0x1ac7] -> [namepath: "CBAT"] + | | | | +- [BytePrefix, table: 0, index: 2857, offset: 0x1acb] -> [num value; dec: 3, hex: 0x3] + | | | +- [NamedField, name: "IDX0", table: 0, index: 2858, offset: 0x1acc] -> [field index: 2855, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DAT0", table: 0, index: 2859, offset: 0x1ad1] -> [field index: 2855, offset(bytes): 0x20, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [IndexField, name: "IDX0", table: 0, index: 2860, offset: 0x1ad6] + | | | | +- [NamePath, table: 0, index: 2861, offset: 0x1ada] -> [namepath: "IDX0"] + | | | | +- [NamePath, table: 0, index: 2862, offset: 0x1ade] -> [namepath: "DAT0"] + | | | | +- [BytePrefix, table: 0, index: 2863, offset: 0x1ae2] -> [num value; dec: 3, hex: 0x3] + | | | +- [NamedField, name: "STAT", table: 0, index: 2864, offset: 0x1ae3] -> [field index: 2860, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "PRAT", table: 0, index: 2865, offset: 0x1ae8] -> [field index: 2860, offset(bytes): 0x20, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "RCAP", table: 0, index: 2866, offset: 0x1aed] -> [field index: 2860, offset(bytes): 0x40, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "PVOL", table: 0, index: 2867, offset: 0x1af2] -> [field index: 2860, offset(bytes): 0x60, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "UNIT", table: 0, index: 2868, offset: 0x1af7] -> [field index: 2860, offset(bytes): 0x80, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DCAP", table: 0, index: 2869, offset: 0x1afc] -> [field index: 2860, offset(bytes): 0xa0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "LFCP", table: 0, index: 2870, offset: 0x1b01] -> [field index: 2860, offset(bytes): 0xc0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "BTEC", table: 0, index: 2871, offset: 0x1b06] -> [field index: 2860, offset(bytes): 0xe0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DVOL", table: 0, index: 2872, offset: 0x1b0b] -> [field index: 2860, offset(bytes): 0x100, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DWRN", table: 0, index: 2873, offset: 0x1b10] -> [field index: 2860, offset(bytes): 0x120, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "DLOW", table: 0, index: 2874, offset: 0x1b15] -> [field index: 2860, offset(bytes): 0x140, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "GRN1", table: 0, index: 2875, offset: 0x1b1a] -> [field index: 2860, offset(bytes): 0x160, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "GRN2", table: 0, index: 2876, offset: 0x1b1f] -> [field index: 2860, offset(bytes): 0x180, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "BSTA", table: 0, index: 2877, offset: 0x1b24] -> [field index: 2860, offset(bytes): 0x1a0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [NamedField, name: "APSR", table: 0, index: 2878, offset: 0x1b29] -> [field index: 2860, offset(bytes): 0x1c0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 2879, offset: 0x1b2e] + | | | | +- [NamePath, table: 0, index: 2880, offset: 0x1b30] -> [namepath: "_STA"] + | | | | +- [BytePrefix, table: 0, index: 2881, offset: 0x1b34] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2882, offset: 0x1b35] + | | | | +- [Return, table: 0, index: 2883, offset: 0x1b35] + | | | | +- [ResolvedNamePath, table: 0, index: 2884, offset: 0x1b36] -> [resolved to "BSTA", table: 0, index: 2877, offset: 0x1b24] + | | | +- [Name, name: "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | +- [NamePath, table: 0, index: 2886, offset: 0x1b3b] -> [namepath: "PBIF"] + | | | | +- [Package, table: 0, index: 2887, offset: 0x1b3f] + | | | | +- [BytePrefix, table: 0, index: 2888, offset: 0x1b41] -> [num value; dec: 13, hex: 0xd] + | | | | +- [ScopeBlock, table: 0, index: 2889, offset: 0x1b42] + | | | | +- [One, table: 0, index: 2890, offset: 0x1b42] + | | | | +- [DwordPrefix, table: 0, index: 2891, offset: 0x1b43] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | | +- [DwordPrefix, table: 0, index: 2892, offset: 0x1b48] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | | +- [Zero, table: 0, index: 2893, offset: 0x1b4d] + | | | | +- [DwordPrefix, table: 0, index: 2894, offset: 0x1b4e] -> [num value; dec: 4294967295, hex: 0xffffffff] + | | | | +- [Zero, table: 0, index: 2895, offset: 0x1b53] + | | | | +- [Zero, table: 0, index: 2896, offset: 0x1b54] + | | | | +- [BytePrefix, table: 0, index: 2897, offset: 0x1b55] -> [num value; dec: 4, hex: 0x4] + | | | | +- [BytePrefix, table: 0, index: 2898, offset: 0x1b57] -> [num value; dec: 4, hex: 0x4] + | | | | +- [StringPrefix, table: 0, index: 2899, offset: 0x1b59] -> [string value: "1"] + | | | | +- [StringPrefix, table: 0, index: 2900, offset: 0x1b5c] -> [string value: "0"] + | | | | +- [StringPrefix, table: 0, index: 2901, offset: 0x1b5f] -> [string value: "VBOX"] + | | | | +- [StringPrefix, table: 0, index: 2902, offset: 0x1b65] -> [string value: "innotek"] + | | | +- [Name, name: "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [NamePath, table: 0, index: 2904, offset: 0x1b6f] -> [namepath: "PBST"] + | | | | +- [Package, table: 0, index: 2905, offset: 0x1b73] + | | | | +- [BytePrefix, table: 0, index: 2906, offset: 0x1b75] -> [num value; dec: 4, hex: 0x4] + | | | | +- [ScopeBlock, table: 0, index: 2907, offset: 0x1b76] + | | | | +- [Zero, table: 0, index: 2908, offset: 0x1b76] + | | | | +- [DwordPrefix, table: 0, index: 2909, offset: 0x1b77] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | | +- [DwordPrefix, table: 0, index: 2910, offset: 0x1b7c] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | | +- [DwordPrefix, table: 0, index: 2911, offset: 0x1b81] -> [num value; dec: 2147483647, hex: 0x7fffffff] + | | | +- [Method, name: "_BIF", argCount: 0, table: 0, index: 2912, offset: 0x1b86] + | | | | +- [NamePath, table: 0, index: 2913, offset: 0x1b89] -> [namepath: "_BIF"] + | | | | +- [BytePrefix, table: 0, index: 2914, offset: 0x1b8d] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 2915, offset: 0x1b8e] + | | | | +- [Store, table: 0, index: 2916, offset: 0x1b8e] + | | | | | +- [ResolvedNamePath, table: 0, index: 2917, offset: 0x1b8f] -> [resolved to "UNIT", table: 0, index: 2868, offset: 0x1af7] + | | | | | +- [Index, table: 0, index: 2918, offset: 0x1b93] + | | | | | +- [ResolvedNamePath, table: 0, index: 2919, offset: 0x1b94] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [Zero, table: 0, index: 2920, offset: 0x1b98] + | | | | | +- [Zero, table: 0, index: 2921, offset: 0x1b99] + | | | | +- [Store, table: 0, index: 2922, offset: 0x1b9a] + | | | | | +- [ResolvedNamePath, table: 0, index: 2923, offset: 0x1b9b] -> [resolved to "DCAP", table: 0, index: 2869, offset: 0x1afc] + | | | | | +- [Index, table: 0, index: 2924, offset: 0x1b9f] + | | | | | +- [ResolvedNamePath, table: 0, index: 2925, offset: 0x1ba0] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [One, table: 0, index: 2926, offset: 0x1ba4] + | | | | | +- [Zero, table: 0, index: 2927, offset: 0x1ba5] + | | | | +- [Store, table: 0, index: 2928, offset: 0x1ba6] + | | | | | +- [ResolvedNamePath, table: 0, index: 2929, offset: 0x1ba7] -> [resolved to "LFCP", table: 0, index: 2870, offset: 0x1b01] + | | | | | +- [Index, table: 0, index: 2930, offset: 0x1bab] + | | | | | +- [ResolvedNamePath, table: 0, index: 2931, offset: 0x1bac] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2932, offset: 0x1bb0] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [Zero, table: 0, index: 2933, offset: 0x1bb2] + | | | | +- [Store, table: 0, index: 2934, offset: 0x1bb3] + | | | | | +- [ResolvedNamePath, table: 0, index: 2935, offset: 0x1bb4] -> [resolved to "BTEC", table: 0, index: 2871, offset: 0x1b06] + | | | | | +- [Index, table: 0, index: 2936, offset: 0x1bb8] + | | | | | +- [ResolvedNamePath, table: 0, index: 2937, offset: 0x1bb9] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2938, offset: 0x1bbd] -> [num value; dec: 3, hex: 0x3] + | | | | | +- [Zero, table: 0, index: 2939, offset: 0x1bbf] + | | | | +- [Store, table: 0, index: 2940, offset: 0x1bc0] + | | | | | +- [ResolvedNamePath, table: 0, index: 2941, offset: 0x1bc1] -> [resolved to "DVOL", table: 0, index: 2872, offset: 0x1b0b] + | | | | | +- [Index, table: 0, index: 2942, offset: 0x1bc5] + | | | | | +- [ResolvedNamePath, table: 0, index: 2943, offset: 0x1bc6] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2944, offset: 0x1bca] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [Zero, table: 0, index: 2945, offset: 0x1bcc] + | | | | +- [Store, table: 0, index: 2946, offset: 0x1bcd] + | | | | | +- [ResolvedNamePath, table: 0, index: 2947, offset: 0x1bce] -> [resolved to "DWRN", table: 0, index: 2873, offset: 0x1b10] + | | | | | +- [Index, table: 0, index: 2948, offset: 0x1bd2] + | | | | | +- [ResolvedNamePath, table: 0, index: 2949, offset: 0x1bd3] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2950, offset: 0x1bd7] -> [num value; dec: 5, hex: 0x5] + | | | | | +- [Zero, table: 0, index: 2951, offset: 0x1bd9] + | | | | +- [Store, table: 0, index: 2952, offset: 0x1bda] + | | | | | +- [ResolvedNamePath, table: 0, index: 2953, offset: 0x1bdb] -> [resolved to "DLOW", table: 0, index: 2874, offset: 0x1b15] + | | | | | +- [Index, table: 0, index: 2954, offset: 0x1bdf] + | | | | | +- [ResolvedNamePath, table: 0, index: 2955, offset: 0x1be0] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2956, offset: 0x1be4] -> [num value; dec: 6, hex: 0x6] + | | | | | +- [Zero, table: 0, index: 2957, offset: 0x1be6] + | | | | +- [Store, table: 0, index: 2958, offset: 0x1be7] + | | | | | +- [ResolvedNamePath, table: 0, index: 2959, offset: 0x1be8] -> [resolved to "GRN1", table: 0, index: 2875, offset: 0x1b1a] + | | | | | +- [Index, table: 0, index: 2960, offset: 0x1bec] + | | | | | +- [ResolvedNamePath, table: 0, index: 2961, offset: 0x1bed] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2962, offset: 0x1bf1] -> [num value; dec: 7, hex: 0x7] + | | | | | +- [Zero, table: 0, index: 2963, offset: 0x1bf3] + | | | | +- [Store, table: 0, index: 2964, offset: 0x1bf4] + | | | | | +- [ResolvedNamePath, table: 0, index: 2965, offset: 0x1bf5] -> [resolved to "GRN2", table: 0, index: 2876, offset: 0x1b1f] + | | | | | +- [Index, table: 0, index: 2966, offset: 0x1bf9] + | | | | | +- [ResolvedNamePath, table: 0, index: 2967, offset: 0x1bfa] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2968, offset: 0x1bfe] -> [num value; dec: 8, hex: 0x8] + | | | | | +- [Zero, table: 0, index: 2969, offset: 0x1c00] + | | | | +- [MethodCall, table: 0, index: 2970, offset: 0x1c01] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | | +- [StringPrefix, table: 0, index: 2971, offset: 0x1c05] -> [string value: "_BIF: +"] + | | | | +- [MethodCall, table: 0, index: 2972, offset: 0x1c0d] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2973, offset: 0x1c11] + | | | | | +- [Index, table: 0, index: 2974, offset: 0x1c12] + | | | | | +- [ResolvedNamePath, table: 0, index: 2975, offset: 0x1c13] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [Zero, table: 0, index: 2976, offset: 0x1c17] + | | | | | +- [Zero, table: 0, index: 2977, offset: 0x1c18] + | | | | +- [MethodCall, table: 0, index: 2978, offset: 0x1c19] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2979, offset: 0x1c1d] + | | | | | +- [Index, table: 0, index: 2980, offset: 0x1c1e] + | | | | | +- [ResolvedNamePath, table: 0, index: 2981, offset: 0x1c1f] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [One, table: 0, index: 2982, offset: 0x1c23] + | | | | | +- [Zero, table: 0, index: 2983, offset: 0x1c24] + | | | | +- [MethodCall, table: 0, index: 2984, offset: 0x1c25] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2985, offset: 0x1c29] + | | | | | +- [Index, table: 0, index: 2986, offset: 0x1c2a] + | | | | | +- [ResolvedNamePath, table: 0, index: 2987, offset: 0x1c2b] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2988, offset: 0x1c2f] -> [num value; dec: 2, hex: 0x2] + | | | | | +- [Zero, table: 0, index: 2989, offset: 0x1c31] + | | | | +- [MethodCall, table: 0, index: 2990, offset: 0x1c32] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2991, offset: 0x1c36] + | | | | | +- [Index, table: 0, index: 2992, offset: 0x1c37] + | | | | | +- [ResolvedNamePath, table: 0, index: 2993, offset: 0x1c38] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 2994, offset: 0x1c3c] -> [num value; dec: 3, hex: 0x3] + | | | | | +- [Zero, table: 0, index: 2995, offset: 0x1c3e] + | | | | +- [MethodCall, table: 0, index: 2996, offset: 0x1c3f] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 2997, offset: 0x1c43] + | | | | | +- [Index, table: 0, index: 2998, offset: 0x1c44] + | | | | | +- [ResolvedNamePath, table: 0, index: 2999, offset: 0x1c45] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3000, offset: 0x1c49] -> [num value; dec: 4, hex: 0x4] + | | | | | +- [Zero, table: 0, index: 3001, offset: 0x1c4b] + | | | | +- [MethodCall, table: 0, index: 3002, offset: 0x1c4c] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 3003, offset: 0x1c50] + | | | | | +- [Index, table: 0, index: 3004, offset: 0x1c51] + | | | | | +- [ResolvedNamePath, table: 0, index: 3005, offset: 0x1c52] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3006, offset: 0x1c56] -> [num value; dec: 5, hex: 0x5] + | | | | | +- [Zero, table: 0, index: 3007, offset: 0x1c58] + | | | | +- [MethodCall, table: 0, index: 3008, offset: 0x1c59] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 3009, offset: 0x1c5d] + | | | | | +- [Index, table: 0, index: 3010, offset: 0x1c5e] + | | | | | +- [ResolvedNamePath, table: 0, index: 3011, offset: 0x1c5f] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3012, offset: 0x1c63] -> [num value; dec: 6, hex: 0x6] + | | | | | +- [Zero, table: 0, index: 3013, offset: 0x1c65] + | | | | +- [MethodCall, table: 0, index: 3014, offset: 0x1c66] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 3015, offset: 0x1c6a] + | | | | | +- [Index, table: 0, index: 3016, offset: 0x1c6b] + | | | | | +- [ResolvedNamePath, table: 0, index: 3017, offset: 0x1c6c] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3018, offset: 0x1c70] -> [num value; dec: 7, hex: 0x7] + | | | | | +- [Zero, table: 0, index: 3019, offset: 0x1c72] + | | | | +- [MethodCall, table: 0, index: 3020, offset: 0x1c73] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | | | | +- [DerefOf, table: 0, index: 3021, offset: 0x1c77] + | | | | | +- [Index, table: 0, index: 3022, offset: 0x1c78] + | | | | | +- [ResolvedNamePath, table: 0, index: 3023, offset: 0x1c79] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | | | +- [BytePrefix, table: 0, index: 3024, offset: 0x1c7d] -> [num value; dec: 8, hex: 0x8] + | | | | | +- [Zero, table: 0, index: 3025, offset: 0x1c7f] + | | | | +- [Return, table: 0, index: 3026, offset: 0x1c80] + | | | | +- [ResolvedNamePath, table: 0, index: 3027, offset: 0x1c81] -> [resolved to "PBIF", table: 0, index: 2885, offset: 0x1b3a] + | | | +- [Method, name: "_BST", argCount: 0, table: 0, index: 3028, offset: 0x1c85] + | | | +- [NamePath, table: 0, index: 3029, offset: 0x1c87] -> [namepath: "_BST"] + | | | +- [BytePrefix, table: 0, index: 3030, offset: 0x1c8b] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3031, offset: 0x1c8c] + | | | +- [Store, table: 0, index: 3032, offset: 0x1c8c] + | | | | +- [ResolvedNamePath, table: 0, index: 3033, offset: 0x1c8d] -> [resolved to "STAT", table: 0, index: 2864, offset: 0x1ae3] + | | | | +- [Index, table: 0, index: 3034, offset: 0x1c91] + | | | | +- [ResolvedNamePath, table: 0, index: 3035, offset: 0x1c92] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [Zero, table: 0, index: 3036, offset: 0x1c96] + | | | | +- [Zero, table: 0, index: 3037, offset: 0x1c97] + | | | +- [Store, table: 0, index: 3038, offset: 0x1c98] + | | | | +- [ResolvedNamePath, table: 0, index: 3039, offset: 0x1c99] -> [resolved to "PRAT", table: 0, index: 2865, offset: 0x1ae8] + | | | | +- [Index, table: 0, index: 3040, offset: 0x1c9d] + | | | | +- [ResolvedNamePath, table: 0, index: 3041, offset: 0x1c9e] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [One, table: 0, index: 3042, offset: 0x1ca2] + | | | | +- [Zero, table: 0, index: 3043, offset: 0x1ca3] + | | | +- [Store, table: 0, index: 3044, offset: 0x1ca4] + | | | | +- [ResolvedNamePath, table: 0, index: 3045, offset: 0x1ca5] -> [resolved to "RCAP", table: 0, index: 2866, offset: 0x1aed] + | | | | +- [Index, table: 0, index: 3046, offset: 0x1ca9] + | | | | +- [ResolvedNamePath, table: 0, index: 3047, offset: 0x1caa] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [BytePrefix, table: 0, index: 3048, offset: 0x1cae] -> [num value; dec: 2, hex: 0x2] + | | | | +- [Zero, table: 0, index: 3049, offset: 0x1cb0] + | | | +- [Store, table: 0, index: 3050, offset: 0x1cb1] + | | | | +- [ResolvedNamePath, table: 0, index: 3051, offset: 0x1cb2] -> [resolved to "PVOL", table: 0, index: 2867, offset: 0x1af2] + | | | | +- [Index, table: 0, index: 3052, offset: 0x1cb6] + | | | | +- [ResolvedNamePath, table: 0, index: 3053, offset: 0x1cb7] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | | | +- [BytePrefix, table: 0, index: 3054, offset: 0x1cbb] -> [num value; dec: 3, hex: 0x3] + | | | | +- [Zero, table: 0, index: 3055, offset: 0x1cbd] + | | | +- [Return, table: 0, index: 3056, offset: 0x1cbe] + | | | +- [ResolvedNamePath, table: 0, index: 3057, offset: 0x1cbf] -> [resolved to "PBST", table: 0, index: 2903, offset: 0x1b6e] + | | +- [Device, name: "AC__", table: 0, index: 3058, offset: 0x1cc3] + | | | +- [NamePath, table: 0, index: 3059, offset: 0x1cc7] -> [namepath: "AC__"] + | | | +- [ScopeBlock, table: 0, index: 3060, offset: 0x1ccb] + | | | +- [Name, name: "_HID", table: 0, index: 3061, offset: 0x1ccb] + | | | | +- [NamePath, table: 0, index: 3062, offset: 0x1ccc] -> [namepath: "_HID"] + | | | | +- [StringPrefix, table: 0, index: 3063, offset: 0x1cd0] -> [string value: "ACPI0003"] + | | | +- [Name, name: "_UID", table: 0, index: 3064, offset: 0x1cda] + | | | | +- [NamePath, table: 0, index: 3065, offset: 0x1cdb] -> [namepath: "_UID"] + | | | | +- [Zero, table: 0, index: 3066, offset: 0x1cdf] + | | | +- [Name, name: "_PCL", table: 0, index: 3067, offset: 0x1ce0] + | | | | +- [NamePath, table: 0, index: 3068, offset: 0x1ce1] -> [namepath: "_PCL"] + | | | | +- [Package, table: 0, index: 3069, offset: 0x1ce5] + | | | | +- [BytePrefix, table: 0, index: 3070, offset: 0x1ce7] -> [num value; dec: 1, hex: 0x1] + | | | | +- [ScopeBlock, table: 0, index: 3071, offset: 0x1ce8] + | | | | +- [ResolvedNamePath, table: 0, index: 3072, offset: 0x1ce8] -> [resolved to "_SB_", table: 42, index: 3, offset: 0x0] + | | | +- [Method, name: "_PSR", argCount: 0, table: 0, index: 3073, offset: 0x1cec] + | | | | +- [NamePath, table: 0, index: 3074, offset: 0x1cee] -> [namepath: "_PSR"] + | | | | +- [BytePrefix, table: 0, index: 3075, offset: 0x1cf2] -> [num value; dec: 0, hex: 0x0] + | | | | +- [ScopeBlock, table: 0, index: 3076, offset: 0x1cf3] + | | | | +- [Return, table: 0, index: 3077, offset: 0x1cf3] + | | | | +- [NamePath, table: 0, index: 3078, offset: 0x1cf4] -> [namepath: "^^.BAT0APSR"] + | | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3079, offset: 0x1cff] + | | | +- [NamePath, table: 0, index: 3080, offset: 0x1d01] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 3081, offset: 0x1d05] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3082, offset: 0x1d06] + | | | +- [Return, table: 0, index: 3083, offset: 0x1d06] + | | | +- [BytePrefix, table: 0, index: 3084, offset: 0x1d07] -> [num value; dec: 15, hex: 0xf] + | | +- [Name, name: "CRS_", table: 0, index: 3091, offset: 0x1d17] + | | | +- [NamePath, table: 0, index: 3092, offset: 0x1d18] -> [namepath: "CRS_"] + | | | +- [Buffer, table: 0, index: 3093, offset: 0x1d1c] + | | | +- [BytePrefix, table: 0, index: 3525, offset: 0x1d1f] -> [num value; dec: 110, hex: 0x6e] + | | | +- [ByteList, table: 0, index: 3526, offset: 0x0] -> [bytelist value; len: 110; data: [0x88, 0xd, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x87, 0x17, 0x0, 0x0, 0x8, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xdf, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0]] + | | +- [Name, name: "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [NamePath, table: 0, index: 3095, offset: 0x1d90] -> [namepath: "TOM_"] + | | | +- [Buffer, table: 0, index: 3096, offset: 0x1d94] + | | | +- [BytePrefix, table: 0, index: 3527, offset: 0x1d96] -> [num value; dec: 48, hex: 0x30] + | | | +- [ByteList, table: 0, index: 3528, offset: 0x0] -> [bytelist value; len: 48; data: [0x8a, 0x2b, 0x0, 0x0, 0xc, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x79, 0x0]] + | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3097, offset: 0x1dc8] + | | +- [NamePath, table: 0, index: 3098, offset: 0x1dcb] -> [namepath: "_CRS"] + | | +- [BytePrefix, table: 0, index: 3099, offset: 0x1dcf] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3100, offset: 0x1dd0] + | | +- [CreateDWordField, table: 0, index: 3101, offset: 0x1dd0] + | | | +- [ResolvedNamePath, table: 0, index: 3102, offset: 0x1dd1] -> [resolved to "CRS_", table: 0, index: 3091, offset: 0x1d17] + | | | +- [BytePrefix, table: 0, index: 3103, offset: 0x1dd5] -> [num value; dec: 92, hex: 0x5c] + | | | +- [NamePath, table: 0, index: 3104, offset: 0x1dd7] -> [namepath: "RAMT"] + | | +- [CreateDWordField, table: 0, index: 3105, offset: 0x1ddb] + | | | +- [ResolvedNamePath, table: 0, index: 3106, offset: 0x1ddc] -> [resolved to "CRS_", table: 0, index: 3091, offset: 0x1d17] + | | | +- [BytePrefix, table: 0, index: 3107, offset: 0x1de0] -> [num value; dec: 104, hex: 0x68] + | | | +- [NamePath, table: 0, index: 3108, offset: 0x1de2] -> [namepath: "RAMR"] + | | +- [Store, table: 0, index: 3109, offset: 0x1de6] + | | | +- [ResolvedNamePath, table: 0, index: 3110, offset: 0x1de7] -> [resolved to "MEML", table: 0, index: 333, offset: 0x41a] + | | | +- [NamePath, table: 0, index: 3111, offset: 0x1deb] -> [namepath: "RAMT"] + | | +- [Subtract, table: 0, index: 3112, offset: 0x1def] + | | | +- [DwordPrefix, table: 0, index: 3113, offset: 0x1df0] -> [num value; dec: 4292870144, hex: 0xffe00000] + | | | +- [NamePath, table: 0, index: 3114, offset: 0x1df5] -> [namepath: "RAMT"] + | | | +- [NamePath, table: 0, index: 3115, offset: 0x1df9] -> [namepath: "RAMR"] + | | +- [If, table: 0, index: 3116, offset: 0x1dfd] + | | | +- [Lnot, table: 0, index: 3117, offset: 0x1e00] + | | | | +- [LEqual, table: 0, index: 3118, offset: 0x1e01] + | | | | +- [ResolvedNamePath, table: 0, index: 3119, offset: 0x1e02] -> [resolved to "PMNN", table: 0, index: 342, offset: 0x447] + | | | | +- [Zero, table: 0, index: 3120, offset: 0x1e06] + | | | +- [If, table: 0, index: 3121, offset: 0x1e07] + | | | +- [Lor, table: 0, index: 3122, offset: 0x1e0a] + | | | | +- [LLess, table: 0, index: 3123, offset: 0x1e0b] + | | | | | +- [MethodCall, table: 0, index: 3124, offset: 0x1e0c] -> [call to "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | | | | | +- [One, table: 0, index: 3125, offset: 0x1e10] + | | | | +- [LGreater, table: 0, index: 3126, offset: 0x1e11] + | | | | +- [MethodCall, table: 0, index: 3127, offset: 0x1e12] -> [call to "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | | | | +- [BytePrefix, table: 0, index: 3128, offset: 0x1e16] -> [num value; dec: 6, hex: 0x6] + | | | +- [CreateQWordField, table: 0, index: 3129, offset: 0x1e18] + | | | +- [ResolvedNamePath, table: 0, index: 3130, offset: 0x1e19] -> [resolved to "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [BytePrefix, table: 0, index: 3131, offset: 0x1e1d] -> [num value; dec: 14, hex: 0xe] + | | | +- [NamePath, table: 0, index: 3132, offset: 0x1e1f] -> [namepath: "TM4N"] + | | +- [CreateQWordField, table: 0, index: 3133, offset: 0x1e23] + | | | +- [ResolvedNamePath, table: 0, index: 3134, offset: 0x1e24] -> [resolved to "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [BytePrefix, table: 0, index: 3135, offset: 0x1e28] -> [num value; dec: 22, hex: 0x16] + | | | +- [NamePath, table: 0, index: 3136, offset: 0x1e2a] -> [namepath: "TM4X"] + | | +- [CreateQWordField, table: 0, index: 3137, offset: 0x1e2e] + | | | +- [ResolvedNamePath, table: 0, index: 3138, offset: 0x1e2f] -> [resolved to "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [BytePrefix, table: 0, index: 3139, offset: 0x1e33] -> [num value; dec: 38, hex: 0x26] + | | | +- [NamePath, table: 0, index: 3140, offset: 0x1e35] -> [namepath: "TM4L"] + | | +- [Multiply, table: 0, index: 3141, offset: 0x1e39] + | | | +- [ResolvedNamePath, table: 0, index: 3142, offset: 0x1e3a] -> [resolved to "PMNN", table: 0, index: 342, offset: 0x447] + | | | +- [DwordPrefix, table: 0, index: 3143, offset: 0x1e3e] -> [num value; dec: 65536, hex: 0x10000] + | | | +- [NamePath, table: 0, index: 3144, offset: 0x1e43] -> [namepath: "TM4N"] + | | +- [Subtract, table: 0, index: 3145, offset: 0x1e47] + | | | +- [Multiply, table: 0, index: 3146, offset: 0x1e48] + | | | | +- [ResolvedNamePath, table: 0, index: 3147, offset: 0x1e49] -> [resolved to "PMNX", table: 0, index: 363, offset: 0x4b0] + | | | | +- [DwordPrefix, table: 0, index: 3148, offset: 0x1e4d] -> [num value; dec: 65536, hex: 0x10000] + | | | | +- [Zero, table: 0, index: 3149, offset: 0x1e52] + | | | +- [One, table: 0, index: 3150, offset: 0x1e53] + | | | +- [NamePath, table: 0, index: 3151, offset: 0x1e54] -> [namepath: "TM4X"] + | | +- [Add, table: 0, index: 3152, offset: 0x1e58] + | | | +- [Subtract, table: 0, index: 3153, offset: 0x1e59] + | | | | +- [NamePath, table: 0, index: 3154, offset: 0x1e5a] -> [namepath: "TM4X"] + | | | | +- [NamePath, table: 0, index: 3155, offset: 0x1e5e] -> [namepath: "TM4N"] + | | | | +- [Zero, table: 0, index: 3156, offset: 0x1e62] + | | | +- [One, table: 0, index: 3157, offset: 0x1e63] + | | | +- [NamePath, table: 0, index: 3158, offset: 0x1e64] -> [namepath: "TM4L"] + | | +- [ConcatRes, table: 0, index: 3159, offset: 0x1e68] + | | | +- [ResolvedNamePath, table: 0, index: 3160, offset: 0x1e69] -> [resolved to "CRS_", table: 0, index: 3091, offset: 0x1d17] + | | | +- [ResolvedNamePath, table: 0, index: 3161, offset: 0x1e6d] -> [resolved to "TOM_", table: 0, index: 3094, offset: 0x1d8f] + | | | +- [Local2, table: 0, index: 3162, offset: 0x1e71] + | | +- [Return, table: 0, index: 3163, offset: 0x1e72] + | | | +- [Local2, table: 0, index: 3164, offset: 0x1e73] + | | +- [Return, table: 0, index: 3165, offset: 0x1e74] + | | +- [ResolvedNamePath, table: 0, index: 3166, offset: 0x1e75] -> [resolved to "CRS_", table: 0, index: 3091, offset: 0x1d17] + | +- [Field, table: 0, index: 3170, offset: 0x1e80] + | | +- [NamePath, table: 0, index: 3171, offset: 0x1e83] -> [namepath: "/PCI0SBRGPCIC"] + | | +- [BytePrefix, table: 0, index: 3172, offset: 0x1e91] -> [num value; dec: 1, hex: 0x1] + | +- [NamedField, name: "PIRA", table: 0, index: 3173, offset: 0x1e95] -> [field index: 3170, offset(bytes): 0x300, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | +- [NamedField, name: "PIRB", table: 0, index: 3174, offset: 0x1e9a] -> [field index: 3170, offset(bytes): 0x308, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | +- [NamedField, name: "PIRC", table: 0, index: 3175, offset: 0x1e9f] -> [field index: 3170, offset(bytes): 0x310, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | +- [NamedField, name: "PIRD", table: 0, index: 3176, offset: 0x1ea4] -> [field index: 3170, offset(bytes): 0x318, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + | +- [Name, name: "BUFA", table: 0, index: 3177, offset: 0x1ea9] + | | +- [NamePath, table: 0, index: 3178, offset: 0x1eaa] -> [namepath: "BUFA"] + | | +- [Buffer, table: 0, index: 3179, offset: 0x1eae] + | | +- [BytePrefix, table: 0, index: 3529, offset: 0x1eb0] -> [num value; dec: 6, hex: 0x6] + | | +- [ByteList, table: 0, index: 3530, offset: 0x0] -> [bytelist value; len: 6; data: [0x23, 0x0, 0x80, 0x18, 0x79, 0x0]] + | +- [CreateWordField, table: 0, index: 3180, offset: 0x1eb8] + | | +- [ResolvedNamePath, table: 0, index: 3181, offset: 0x1eb9] -> [resolved to "BUFA", table: 0, index: 3177, offset: 0x1ea9] + | | +- [One, table: 0, index: 3182, offset: 0x1ebd] + | | +- [NamePath, table: 0, index: 3183, offset: 0x1ebe] -> [namepath: "ICRS"] + | +- [Method, name: "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | +- [NamePath, table: 0, index: 3185, offset: 0x1ec4] -> [namepath: "LSTA"] + | | +- [BytePrefix, table: 0, index: 3186, offset: 0x1ec8] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3187, offset: 0x1ec9] + | | +- [And, table: 0, index: 3188, offset: 0x1ec9] + | | | +- [Arg0, table: 0, index: 3189, offset: 0x1eca] + | | | +- [BytePrefix, table: 0, index: 3190, offset: 0x1ecb] -> [num value; dec: 128, hex: 0x80] + | | | +- [Local0, table: 0, index: 3191, offset: 0x1ecd] + | | +- [If, table: 0, index: 3192, offset: 0x1ece] + | | | +- [Local0, table: 0, index: 3193, offset: 0x1ed0] + | | | +- [Return, table: 0, index: 3194, offset: 0x1ed1] + | | | +- [BytePrefix, table: 0, index: 3195, offset: 0x1ed2] -> [num value; dec: 9, hex: 0x9] + | | +- [Else, table: 0, index: 3196, offset: 0x1ed4] + | | +- [ScopeBlock, table: 0, index: 3197, offset: 0x1ed6] + | | +- [Return, table: 0, index: 3198, offset: 0x1ed6] + | | +- [BytePrefix, table: 0, index: 3199, offset: 0x1ed7] -> [num value; dec: 11, hex: 0xb] + | +- [Method, name: "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | +- [NamePath, table: 0, index: 3201, offset: 0x1edb] -> [namepath: "LCRS"] + | | +- [BytePrefix, table: 0, index: 3202, offset: 0x1edf] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3203, offset: 0x1ee0] + | | +- [And, table: 0, index: 3204, offset: 0x1ee0] + | | | +- [Arg0, table: 0, index: 3205, offset: 0x1ee1] + | | | +- [BytePrefix, table: 0, index: 3206, offset: 0x1ee2] -> [num value; dec: 15, hex: 0xf] + | | | +- [Local0, table: 0, index: 3207, offset: 0x1ee4] + | | +- [ShiftLeft, table: 0, index: 3208, offset: 0x1ee5] + | | | +- [One, table: 0, index: 3209, offset: 0x1ee6] + | | | +- [Local0, table: 0, index: 3210, offset: 0x1ee7] + | | | +- [NamePath, table: 0, index: 3211, offset: 0x1ee8] -> [namepath: "ICRS"] + | | +- [Return, table: 0, index: 3212, offset: 0x1eec] + | | +- [ResolvedNamePath, table: 0, index: 3213, offset: 0x1eed] -> [resolved to "BUFA", table: 0, index: 3177, offset: 0x1ea9] + | +- [Method, name: "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | +- [NamePath, table: 0, index: 3215, offset: 0x1ef3] -> [namepath: "LSRS"] + | | +- [BytePrefix, table: 0, index: 3216, offset: 0x1ef7] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3217, offset: 0x1ef8] + | | +- [CreateWordField, table: 0, index: 3218, offset: 0x1ef8] + | | | +- [Arg0, table: 0, index: 3219, offset: 0x1ef9] + | | | +- [One, table: 0, index: 3220, offset: 0x1efa] + | | | +- [NamePath, table: 0, index: 3221, offset: 0x1efb] -> [namepath: "ISRS"] + | | +- [FindSetRightBit, table: 0, index: 3222, offset: 0x1eff] + | | | +- [NamePath, table: 0, index: 3223, offset: 0x1f00] -> [namepath: "ISRS"] + | | | +- [Local0, table: 0, index: 3224, offset: 0x1f04] + | | +- [Return, table: 0, index: 3225, offset: 0x1f05] + | | +- [Decrement, table: 0, index: 3226, offset: 0x1f06] + | | +- [Local0, table: 0, index: 3227, offset: 0x1f07] + | +- [Method, name: "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | +- [NamePath, table: 0, index: 3229, offset: 0x1f0a] -> [namepath: "LDIS"] + | | +- [BytePrefix, table: 0, index: 3230, offset: 0x1f0e] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3231, offset: 0x1f0f] + | | +- [Return, table: 0, index: 3232, offset: 0x1f0f] + | | +- [Or, table: 0, index: 3233, offset: 0x1f10] + | | +- [Arg0, table: 0, index: 3234, offset: 0x1f11] + | | +- [BytePrefix, table: 0, index: 3235, offset: 0x1f12] -> [num value; dec: 128, hex: 0x80] + | | +- [Zero, table: 0, index: 3236, offset: 0x1f14] + | +- [Device, name: "LNKA", table: 0, index: 3237, offset: 0x1f15] + | | +- [NamePath, table: 0, index: 3238, offset: 0x1f19] -> [namepath: "LNKA"] + | | +- [ScopeBlock, table: 0, index: 3239, offset: 0x1f1d] + | | +- [Name, name: "_HID", table: 0, index: 3240, offset: 0x1f1d] + | | | +- [NamePath, table: 0, index: 3241, offset: 0x1f1e] -> [namepath: "_HID"] + | | | +- [DwordPrefix, table: 0, index: 3242, offset: 0x1f22] -> [num value; dec: 252497985, hex: 0xf0cd041] [EISA: "PNP0C0F"] + | | +- [Name, name: "_UID", table: 0, index: 3243, offset: 0x1f27] + | | | +- [NamePath, table: 0, index: 3244, offset: 0x1f28] -> [namepath: "_UID"] + | | | +- [One, table: 0, index: 3245, offset: 0x1f2c] + | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3246, offset: 0x1f2d] + | | | +- [NamePath, table: 0, index: 3247, offset: 0x1f2f] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 3248, offset: 0x1f33] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3249, offset: 0x1f34] + | | | +- [MethodCall, table: 0, index: 3250, offset: 0x1f34] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 3251, offset: 0x1f38] -> [string value: "LNKA._STA +"] + | | | +- [Return, table: 0, index: 3252, offset: 0x1f44] + | | | +- [MethodCall, table: 0, index: 3253, offset: 0x1f45] -> [call to "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | | +- [ResolvedNamePath, table: 0, index: 3254, offset: 0x1f49] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | +- [Method, name: "_PRS", argCount: 0, table: 0, index: 3255, offset: 0x1f4d] + | | | +- [NamePath, table: 0, index: 3256, offset: 0x1f4f] -> [namepath: "_PRS"] + | | | +- [BytePrefix, table: 0, index: 3257, offset: 0x1f53] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3258, offset: 0x1f54] + | | | +- [MethodCall, table: 0, index: 3259, offset: 0x1f54] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 3260, offset: 0x1f58] -> [string value: "LNKA._PRS +"] + | | | +- [Return, table: 0, index: 3261, offset: 0x1f64] + | | | +- [ResolvedNamePath, table: 0, index: 3262, offset: 0x1f65] -> [resolved to "PRSA", table: 0, index: 2090, offset: 0x1210] + | | +- [Method, name: "_DIS", argCount: 0, table: 0, index: 3263, offset: 0x1f69] + | | | +- [NamePath, table: 0, index: 3264, offset: 0x1f6b] -> [namepath: "_DIS"] + | | | +- [BytePrefix, table: 0, index: 3265, offset: 0x1f6f] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3266, offset: 0x1f70] + | | | +- [MethodCall, table: 0, index: 3267, offset: 0x1f70] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 3268, offset: 0x1f74] -> [string value: "LNKA._DIS +"] + | | | +- [Store, table: 0, index: 3269, offset: 0x1f80] + | | | +- [MethodCall, table: 0, index: 3270, offset: 0x1f81] -> [call to "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | | | +- [ResolvedNamePath, table: 0, index: 3271, offset: 0x1f85] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | | +- [ResolvedNamePath, table: 0, index: 3272, offset: 0x1f89] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3273, offset: 0x1f8d] + | | | +- [NamePath, table: 0, index: 3274, offset: 0x1f8f] -> [namepath: "_CRS"] + | | | +- [BytePrefix, table: 0, index: 3275, offset: 0x1f93] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3276, offset: 0x1f94] + | | | +- [MethodCall, table: 0, index: 3277, offset: 0x1f94] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | | +- [StringPrefix, table: 0, index: 3278, offset: 0x1f98] -> [string value: "LNKA._CRS +"] + | | | +- [Return, table: 0, index: 3279, offset: 0x1fa4] + | | | +- [MethodCall, table: 0, index: 3280, offset: 0x1fa5] -> [call to "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | | +- [ResolvedNamePath, table: 0, index: 3281, offset: 0x1fa9] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | +- [Method, name: "_SRS", argCount: 1, table: 0, index: 3282, offset: 0x1fad] + | | +- [NamePath, table: 0, index: 3283, offset: 0x1faf] -> [namepath: "_SRS"] + | | +- [BytePrefix, table: 0, index: 3284, offset: 0x1fb3] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3285, offset: 0x1fb4] + | | +- [MethodCall, table: 0, index: 3286, offset: 0x1fb4] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 3287, offset: 0x1fb8] -> [string value: "LNKA._SRS: "] + | | +- [MethodCall, table: 0, index: 3288, offset: 0x1fc5] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | | | +- [MethodCall, table: 0, index: 3289, offset: 0x1fc9] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3290, offset: 0x1fcd] + | | +- [Store, table: 0, index: 3291, offset: 0x1fce] + | | +- [MethodCall, table: 0, index: 3292, offset: 0x1fcf] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3293, offset: 0x1fd3] + | | +- [ResolvedNamePath, table: 0, index: 3294, offset: 0x1fd4] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | +- [Device, name: "LNKB", table: 0, index: 3295, offset: 0x1fd8] + | | +- [NamePath, table: 0, index: 3296, offset: 0x1fdc] -> [namepath: "LNKB"] + | | +- [ScopeBlock, table: 0, index: 3297, offset: 0x1fe0] + | | +- [Name, name: "_HID", table: 0, index: 3298, offset: 0x1fe0] + | | | +- [NamePath, table: 0, index: 3299, offset: 0x1fe1] -> [namepath: "_HID"] + | | | +- [DwordPrefix, table: 0, index: 3300, offset: 0x1fe5] -> [num value; dec: 252497985, hex: 0xf0cd041] [EISA: "PNP0C0F"] + | | +- [Name, name: "_UID", table: 0, index: 3301, offset: 0x1fea] + | | | +- [NamePath, table: 0, index: 3302, offset: 0x1feb] -> [namepath: "_UID"] + | | | +- [BytePrefix, table: 0, index: 3303, offset: 0x1fef] -> [num value; dec: 2, hex: 0x2] + | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3304, offset: 0x1ff1] + | | | +- [NamePath, table: 0, index: 3305, offset: 0x1ff3] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 3306, offset: 0x1ff7] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3307, offset: 0x1ff8] + | | | +- [Return, table: 0, index: 3308, offset: 0x1ff8] + | | | +- [MethodCall, table: 0, index: 3309, offset: 0x1ff9] -> [call to "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | | +- [ResolvedNamePath, table: 0, index: 3310, offset: 0x1ffd] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | | +- [Method, name: "_PRS", argCount: 0, table: 0, index: 3311, offset: 0x2001] + | | | +- [NamePath, table: 0, index: 3312, offset: 0x2003] -> [namepath: "_PRS"] + | | | +- [BytePrefix, table: 0, index: 3313, offset: 0x2007] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3314, offset: 0x2008] + | | | +- [Return, table: 0, index: 3315, offset: 0x2008] + | | | +- [ResolvedNamePath, table: 0, index: 3316, offset: 0x2009] -> [resolved to "PRSB", table: 0, index: 2093, offset: 0x121f] + | | +- [Method, name: "_DIS", argCount: 0, table: 0, index: 3317, offset: 0x200d] + | | | +- [NamePath, table: 0, index: 3318, offset: 0x200f] -> [namepath: "_DIS"] + | | | +- [BytePrefix, table: 0, index: 3319, offset: 0x2013] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3320, offset: 0x2014] + | | | +- [Store, table: 0, index: 3321, offset: 0x2014] + | | | +- [MethodCall, table: 0, index: 3322, offset: 0x2015] -> [call to "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | | | +- [ResolvedNamePath, table: 0, index: 3323, offset: 0x2019] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | | | +- [ResolvedNamePath, table: 0, index: 3324, offset: 0x201d] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3325, offset: 0x2021] + | | | +- [NamePath, table: 0, index: 3326, offset: 0x2023] -> [namepath: "_CRS"] + | | | +- [BytePrefix, table: 0, index: 3327, offset: 0x2027] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3328, offset: 0x2028] + | | | +- [Return, table: 0, index: 3329, offset: 0x2028] + | | | +- [MethodCall, table: 0, index: 3330, offset: 0x2029] -> [call to "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | | +- [ResolvedNamePath, table: 0, index: 3331, offset: 0x202d] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | | +- [Method, name: "_SRS", argCount: 1, table: 0, index: 3332, offset: 0x2031] + | | +- [NamePath, table: 0, index: 3333, offset: 0x2033] -> [namepath: "_SRS"] + | | +- [BytePrefix, table: 0, index: 3334, offset: 0x2037] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3335, offset: 0x2038] + | | +- [MethodCall, table: 0, index: 3336, offset: 0x2038] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 3337, offset: 0x203c] -> [string value: "LNKB._SRS: "] + | | +- [MethodCall, table: 0, index: 3338, offset: 0x2049] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | | | +- [MethodCall, table: 0, index: 3339, offset: 0x204d] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3340, offset: 0x2051] + | | +- [Store, table: 0, index: 3341, offset: 0x2052] + | | +- [MethodCall, table: 0, index: 3342, offset: 0x2053] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3343, offset: 0x2057] + | | +- [ResolvedNamePath, table: 0, index: 3344, offset: 0x2058] -> [resolved to "PIRB", table: 0, index: 3174, offset: 0x1e9a] + | +- [Device, name: "LNKC", table: 0, index: 3345, offset: 0x205c] + | | +- [NamePath, table: 0, index: 3346, offset: 0x2060] -> [namepath: "LNKC"] + | | +- [ScopeBlock, table: 0, index: 3347, offset: 0x2064] + | | +- [Name, name: "_HID", table: 0, index: 3348, offset: 0x2064] + | | | +- [NamePath, table: 0, index: 3349, offset: 0x2065] -> [namepath: "_HID"] + | | | +- [DwordPrefix, table: 0, index: 3350, offset: 0x2069] -> [num value; dec: 252497985, hex: 0xf0cd041] [EISA: "PNP0C0F"] + | | +- [Name, name: "_UID", table: 0, index: 3351, offset: 0x206e] + | | | +- [NamePath, table: 0, index: 3352, offset: 0x206f] -> [namepath: "_UID"] + | | | +- [BytePrefix, table: 0, index: 3353, offset: 0x2073] -> [num value; dec: 3, hex: 0x3] + | | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3354, offset: 0x2075] + | | | +- [NamePath, table: 0, index: 3355, offset: 0x2077] -> [namepath: "_STA"] + | | | +- [BytePrefix, table: 0, index: 3356, offset: 0x207b] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3357, offset: 0x207c] + | | | +- [Return, table: 0, index: 3358, offset: 0x207c] + | | | +- [MethodCall, table: 0, index: 3359, offset: 0x207d] -> [call to "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | | +- [ResolvedNamePath, table: 0, index: 3360, offset: 0x2081] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | | +- [Method, name: "_PRS", argCount: 0, table: 0, index: 3361, offset: 0x2085] + | | | +- [NamePath, table: 0, index: 3362, offset: 0x2087] -> [namepath: "_PRS"] + | | | +- [BytePrefix, table: 0, index: 3363, offset: 0x208b] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3364, offset: 0x208c] + | | | +- [Return, table: 0, index: 3365, offset: 0x208c] + | | | +- [ResolvedNamePath, table: 0, index: 3366, offset: 0x208d] -> [resolved to "PRSC", table: 0, index: 2096, offset: 0x122e] + | | +- [Method, name: "_DIS", argCount: 0, table: 0, index: 3367, offset: 0x2091] + | | | +- [NamePath, table: 0, index: 3368, offset: 0x2093] -> [namepath: "_DIS"] + | | | +- [BytePrefix, table: 0, index: 3369, offset: 0x2097] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3370, offset: 0x2098] + | | | +- [Store, table: 0, index: 3371, offset: 0x2098] + | | | +- [MethodCall, table: 0, index: 3372, offset: 0x2099] -> [call to "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | | | +- [ResolvedNamePath, table: 0, index: 3373, offset: 0x209d] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | | | +- [ResolvedNamePath, table: 0, index: 3374, offset: 0x20a1] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3375, offset: 0x20a5] + | | | +- [NamePath, table: 0, index: 3376, offset: 0x20a7] -> [namepath: "_CRS"] + | | | +- [BytePrefix, table: 0, index: 3377, offset: 0x20ab] -> [num value; dec: 0, hex: 0x0] + | | | +- [ScopeBlock, table: 0, index: 3378, offset: 0x20ac] + | | | +- [Return, table: 0, index: 3379, offset: 0x20ac] + | | | +- [MethodCall, table: 0, index: 3380, offset: 0x20ad] -> [call to "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | | +- [ResolvedNamePath, table: 0, index: 3381, offset: 0x20b1] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | | +- [Method, name: "_SRS", argCount: 1, table: 0, index: 3382, offset: 0x20b5] + | | +- [NamePath, table: 0, index: 3383, offset: 0x20b7] -> [namepath: "_SRS"] + | | +- [BytePrefix, table: 0, index: 3384, offset: 0x20bb] -> [num value; dec: 1, hex: 0x1] + | | +- [ScopeBlock, table: 0, index: 3385, offset: 0x20bc] + | | +- [MethodCall, table: 0, index: 3386, offset: 0x20bc] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | | +- [StringPrefix, table: 0, index: 3387, offset: 0x20c0] -> [string value: "LNKC._SRS: "] + | | +- [MethodCall, table: 0, index: 3388, offset: 0x20cd] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | | | +- [MethodCall, table: 0, index: 3389, offset: 0x20d1] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3390, offset: 0x20d5] + | | +- [Store, table: 0, index: 3391, offset: 0x20d6] + | | +- [MethodCall, table: 0, index: 3392, offset: 0x20d7] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | | +- [Arg0, table: 0, index: 3393, offset: 0x20db] + | | +- [ResolvedNamePath, table: 0, index: 3394, offset: 0x20dc] -> [resolved to "PIRC", table: 0, index: 3175, offset: 0x1e9f] + | +- [Device, name: "LNKD", table: 0, index: 3395, offset: 0x20e0] + | +- [NamePath, table: 0, index: 3396, offset: 0x20e4] -> [namepath: "LNKD"] + | +- [ScopeBlock, table: 0, index: 3397, offset: 0x20e8] + | +- [Name, name: "_HID", table: 0, index: 3398, offset: 0x20e8] + | | +- [NamePath, table: 0, index: 3399, offset: 0x20e9] -> [namepath: "_HID"] + | | +- [DwordPrefix, table: 0, index: 3400, offset: 0x20ed] -> [num value; dec: 252497985, hex: 0xf0cd041] [EISA: "PNP0C0F"] + | +- [Name, name: "_UID", table: 0, index: 3401, offset: 0x20f2] + | | +- [NamePath, table: 0, index: 3402, offset: 0x20f3] -> [namepath: "_UID"] + | | +- [BytePrefix, table: 0, index: 3403, offset: 0x20f7] -> [num value; dec: 4, hex: 0x4] + | +- [Method, name: "_STA", argCount: 0, table: 0, index: 3404, offset: 0x20f9] + | | +- [NamePath, table: 0, index: 3405, offset: 0x20fb] -> [namepath: "_STA"] + | | +- [BytePrefix, table: 0, index: 3406, offset: 0x20ff] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3407, offset: 0x2100] + | | +- [Return, table: 0, index: 3408, offset: 0x2100] + | | +- [MethodCall, table: 0, index: 3409, offset: 0x2101] -> [call to "LSTA", argCount: 1, table: 0, index: 3184, offset: 0x1ec2] + | | +- [ResolvedNamePath, table: 0, index: 3410, offset: 0x2105] -> [resolved to "PIRD", table: 0, index: 3176, offset: 0x1ea4] + | +- [Method, name: "_PRS", argCount: 0, table: 0, index: 3411, offset: 0x2109] + | | +- [NamePath, table: 0, index: 3412, offset: 0x210b] -> [namepath: "_PRS"] + | | +- [BytePrefix, table: 0, index: 3413, offset: 0x210f] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3414, offset: 0x2110] + | | +- [Return, table: 0, index: 3415, offset: 0x2110] + | | +- [ResolvedNamePath, table: 0, index: 3416, offset: 0x2111] -> [resolved to "PRSD", table: 0, index: 2099, offset: 0x123d] + | +- [Method, name: "_DIS", argCount: 0, table: 0, index: 3417, offset: 0x2115] + | | +- [NamePath, table: 0, index: 3418, offset: 0x2117] -> [namepath: "_DIS"] + | | +- [BytePrefix, table: 0, index: 3419, offset: 0x211b] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3420, offset: 0x211c] + | | +- [Store, table: 0, index: 3421, offset: 0x211c] + | | +- [MethodCall, table: 0, index: 3422, offset: 0x211d] -> [call to "LDIS", argCount: 1, table: 0, index: 3228, offset: 0x1f08] + | | | +- [ResolvedNamePath, table: 0, index: 3423, offset: 0x2121] -> [resolved to "PIRA", table: 0, index: 3173, offset: 0x1e95] + | | +- [ResolvedNamePath, table: 0, index: 3424, offset: 0x2125] -> [resolved to "PIRD", table: 0, index: 3176, offset: 0x1ea4] + | +- [Method, name: "_CRS", argCount: 0, table: 0, index: 3425, offset: 0x2129] + | | +- [NamePath, table: 0, index: 3426, offset: 0x212b] -> [namepath: "_CRS"] + | | +- [BytePrefix, table: 0, index: 3427, offset: 0x212f] -> [num value; dec: 0, hex: 0x0] + | | +- [ScopeBlock, table: 0, index: 3428, offset: 0x2130] + | | +- [Return, table: 0, index: 3429, offset: 0x2130] + | | +- [MethodCall, table: 0, index: 3430, offset: 0x2131] -> [call to "LCRS", argCount: 1, table: 0, index: 3200, offset: 0x1ed9] + | | +- [ResolvedNamePath, table: 0, index: 3431, offset: 0x2135] -> [resolved to "PIRD", table: 0, index: 3176, offset: 0x1ea4] + | +- [Method, name: "_SRS", argCount: 1, table: 0, index: 3432, offset: 0x2139] + | +- [NamePath, table: 0, index: 3433, offset: 0x213b] -> [namepath: "_SRS"] + | +- [BytePrefix, table: 0, index: 3434, offset: 0x213f] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 3435, offset: 0x2140] + | +- [MethodCall, table: 0, index: 3436, offset: 0x2140] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 3437, offset: 0x2144] -> [string value: "LNKD._SRS: "] + | +- [MethodCall, table: 0, index: 3438, offset: 0x2151] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | | +- [MethodCall, table: 0, index: 3439, offset: 0x2155] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | +- [Arg0, table: 0, index: 3440, offset: 0x2159] + | +- [Store, table: 0, index: 3441, offset: 0x215a] + | +- [MethodCall, table: 0, index: 3442, offset: 0x215b] -> [call to "LSRS", argCount: 1, table: 0, index: 3214, offset: 0x1ef1] + | | +- [Arg0, table: 0, index: 3443, offset: 0x215f] + | +- [ResolvedNamePath, table: 0, index: 3444, offset: 0x2160] -> [resolved to "PIRD", table: 0, index: 3176, offset: 0x1ea4] + +- [ScopeBlock, name: "_SI_", table: 42, index: 4, offset: 0x0] + +- [ScopeBlock, name: "_TZ_", table: 42, index: 5, offset: 0x0] + +- [OpRegion, name: "DBG0", table: 0, index: 6, offset: 0x24] + | +- [NamePath, table: 0, index: 7, offset: 0x26] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 8, offset: 0x2a] -> [num value; dec: 1, hex: 0x1] + | +- [WordPrefix, table: 0, index: 9, offset: 0x2b] -> [num value; dec: 12288, hex: 0x3000] + | +- [BytePrefix, table: 0, index: 10, offset: 0x2e] -> [num value; dec: 4, hex: 0x4] + +- [Field, table: 0, index: 11, offset: 0x30] + | +- [NamePath, table: 0, index: 12, offset: 0x33] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 13, offset: 0x37] -> [num value; dec: 1, hex: 0x1] + +- [NamedField, name: "DHE1", table: 0, index: 14, offset: 0x38] -> [field index: 11, offset(bytes): 0x0, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [Field, table: 0, index: 15, offset: 0x3d] + | +- [NamePath, table: 0, index: 16, offset: 0x40] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 17, offset: 0x44] -> [num value; dec: 2, hex: 0x2] + +- [NamedField, name: "DHE2", table: 0, index: 18, offset: 0x45] -> [field index: 15, offset(bytes): 0x0, width(bits): 0x10, accType: Word, lockType: NoLock, updateType: Preserve, connection: -] + +- [Field, table: 0, index: 19, offset: 0x4a] + | +- [NamePath, table: 0, index: 20, offset: 0x4d] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 21, offset: 0x51] -> [num value; dec: 3, hex: 0x3] + +- [NamedField, name: "DHE4", table: 0, index: 22, offset: 0x52] -> [field index: 19, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [Field, table: 0, index: 23, offset: 0x57] + | +- [NamePath, table: 0, index: 24, offset: 0x5a] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 25, offset: 0x5e] -> [num value; dec: 1, hex: 0x1] + +- [NamedField, name: "DCHR", table: 0, index: 26, offset: 0x61] -> [field index: 23, offset(bytes): 0x8, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [Method, name: "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + | +- [NamePath, table: 0, index: 28, offset: 0x68] -> [namepath: "HEX_"] + | +- [BytePrefix, table: 0, index: 29, offset: 0x6c] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 30, offset: 0x6d] + | +- [Store, table: 0, index: 31, offset: 0x6d] + | +- [Arg0, table: 0, index: 32, offset: 0x6e] + | +- [ResolvedNamePath, table: 0, index: 33, offset: 0x6f] -> [resolved to "DHE1", table: 0, index: 14, offset: 0x38] + +- [Method, name: "HEX2", argCount: 1, table: 0, index: 34, offset: 0x73] + | +- [NamePath, table: 0, index: 35, offset: 0x75] -> [namepath: "HEX2"] + | +- [BytePrefix, table: 0, index: 36, offset: 0x79] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 37, offset: 0x7a] + | +- [Store, table: 0, index: 38, offset: 0x7a] + | +- [Arg0, table: 0, index: 39, offset: 0x7b] + | +- [ResolvedNamePath, table: 0, index: 40, offset: 0x7c] -> [resolved to "DHE2", table: 0, index: 18, offset: 0x45] + +- [Method, name: "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | +- [NamePath, table: 0, index: 42, offset: 0x82] -> [namepath: "HEX4"] + | +- [BytePrefix, table: 0, index: 43, offset: 0x86] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 44, offset: 0x87] + | +- [Store, table: 0, index: 45, offset: 0x87] + | +- [Arg0, table: 0, index: 46, offset: 0x88] + | +- [ResolvedNamePath, table: 0, index: 47, offset: 0x89] -> [resolved to "DHE4", table: 0, index: 22, offset: 0x52] + +- [Method, name: "SLEN", argCount: 1, table: 0, index: 48, offset: 0x8d] + | +- [NamePath, table: 0, index: 49, offset: 0x8f] -> [namepath: "SLEN"] + | +- [BytePrefix, table: 0, index: 50, offset: 0x93] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 51, offset: 0x94] + | +- [Store, table: 0, index: 52, offset: 0x94] + | | +- [Arg0, table: 0, index: 53, offset: 0x95] + | | +- [Local0, table: 0, index: 54, offset: 0x96] + | +- [Return, table: 0, index: 55, offset: 0x97] + | +- [SizeOf, table: 0, index: 56, offset: 0x98] + | +- [Local0, table: 0, index: 57, offset: 0x99] + +- [Method, name: "S2BF", argCount: 1, table: 0, index: 58, offset: 0x9a] + | +- [NamePath, table: 0, index: 59, offset: 0x9c] -> [namepath: "S2BF"] + | +- [BytePrefix, table: 0, index: 60, offset: 0xa0] -> [num value; dec: 9, hex: 0x9] + | +- [ScopeBlock, table: 0, index: 61, offset: 0xa1] + | +- [Store, table: 0, index: 62, offset: 0xa1] + | | +- [Arg0, table: 0, index: 63, offset: 0xa2] + | | +- [Local0, table: 0, index: 64, offset: 0xa3] + | +- [Add, table: 0, index: 65, offset: 0xa4] + | | +- [MethodCall, table: 0, index: 66, offset: 0xa5] -> [call to "SLEN", argCount: 1, table: 0, index: 48, offset: 0x8d] + | | | +- [Local0, table: 0, index: 67, offset: 0xa9] + | | +- [One, table: 0, index: 68, offset: 0xaa] + | | +- [Local0, table: 0, index: 69, offset: 0xab] + | +- [Name, name: "BUFF", table: 0, index: 70, offset: 0xac] + | | +- [NamePath, table: 0, index: 71, offset: 0xad] -> [namepath: "BUFF"] + | | +- [Buffer, table: 0, index: 72, offset: 0xb1] + | | +- [Local0, table: 0, index: 3531, offset: 0xb3] + | | +- [ByteList, table: 0, index: 3532, offset: 0x0] -> [bytelist value; len: 0; data: []] + | +- [Store, table: 0, index: 73, offset: 0xb4] + | | +- [Arg0, table: 0, index: 74, offset: 0xb5] + | | +- [ResolvedNamePath, table: 0, index: 75, offset: 0xb6] -> [resolved to "BUFF", table: 0, index: 70, offset: 0xac] + | +- [Return, table: 0, index: 76, offset: 0xba] + | +- [ResolvedNamePath, table: 0, index: 77, offset: 0xbb] -> [resolved to "BUFF", table: 0, index: 70, offset: 0xac] + +- [Method, name: "MIN_", argCount: 2, table: 0, index: 78, offset: 0xbf] + | +- [NamePath, table: 0, index: 79, offset: 0xc1] -> [namepath: "MIN_"] + | +- [BytePrefix, table: 0, index: 80, offset: 0xc5] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 81, offset: 0xc6] + | +- [If, table: 0, index: 82, offset: 0xc6] + | | +- [LLess, table: 0, index: 83, offset: 0xc8] + | | | +- [Arg0, table: 0, index: 84, offset: 0xc9] + | | | +- [Arg1, table: 0, index: 85, offset: 0xca] + | | +- [Return, table: 0, index: 86, offset: 0xcb] + | | +- [Arg0, table: 0, index: 87, offset: 0xcc] + | +- [Else, table: 0, index: 88, offset: 0xcd] + | +- [ScopeBlock, table: 0, index: 89, offset: 0xcf] + | +- [Return, table: 0, index: 90, offset: 0xcf] + | +- [Arg1, table: 0, index: 91, offset: 0xd0] + +- [Method, name: "SCMP", argCount: 2, table: 0, index: 92, offset: 0xd1] + | +- [NamePath, table: 0, index: 93, offset: 0xd4] -> [namepath: "SCMP"] + | +- [BytePrefix, table: 0, index: 94, offset: 0xd8] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 95, offset: 0xd9] + | +- [Store, table: 0, index: 96, offset: 0xd9] + | | +- [Arg0, table: 0, index: 97, offset: 0xda] + | | +- [Local0, table: 0, index: 98, offset: 0xdb] + | +- [Store, table: 0, index: 99, offset: 0xdc] + | | +- [MethodCall, table: 0, index: 100, offset: 0xdd] -> [call to "S2BF", argCount: 1, table: 0, index: 58, offset: 0x9a] + | | | +- [Local0, table: 0, index: 101, offset: 0xe1] + | | +- [Local0, table: 0, index: 102, offset: 0xe2] + | +- [Store, table: 0, index: 103, offset: 0xe3] + | | +- [MethodCall, table: 0, index: 104, offset: 0xe4] -> [call to "S2BF", argCount: 1, table: 0, index: 58, offset: 0x9a] + | | | +- [Arg1, table: 0, index: 105, offset: 0xe8] + | | +- [Local1, table: 0, index: 106, offset: 0xe9] + | +- [Store, table: 0, index: 107, offset: 0xea] + | | +- [Zero, table: 0, index: 108, offset: 0xeb] + | | +- [Local4, table: 0, index: 109, offset: 0xec] + | +- [Store, table: 0, index: 110, offset: 0xed] + | | +- [MethodCall, table: 0, index: 111, offset: 0xee] -> [call to "SLEN", argCount: 1, table: 0, index: 48, offset: 0x8d] + | | | +- [Arg0, table: 0, index: 112, offset: 0xf2] + | | +- [Local5, table: 0, index: 113, offset: 0xf3] + | +- [Store, table: 0, index: 114, offset: 0xf4] + | | +- [MethodCall, table: 0, index: 115, offset: 0xf5] -> [call to "SLEN", argCount: 1, table: 0, index: 48, offset: 0x8d] + | | | +- [Arg1, table: 0, index: 116, offset: 0xf9] + | | +- [Local6, table: 0, index: 117, offset: 0xfa] + | +- [Store, table: 0, index: 118, offset: 0xfb] + | | +- [MethodCall, table: 0, index: 119, offset: 0xfc] -> [call to "MIN_", argCount: 2, table: 0, index: 78, offset: 0xbf] + | | | +- [Local5, table: 0, index: 120, offset: 0x100] + | | | +- [Local6, table: 0, index: 121, offset: 0x101] + | | +- [Local7, table: 0, index: 122, offset: 0x102] + | +- [While, table: 0, index: 123, offset: 0x103] + | | +- [LLess, table: 0, index: 3533, offset: 0x105] + | | | +- [Local4, table: 0, index: 3534, offset: 0x106] + | | | +- [Local7, table: 0, index: 3535, offset: 0x107] + | | +- [ScopeBlock, table: 0, index: 3536, offset: 0x108] + | | +- [Store, table: 0, index: 3537, offset: 0x108] + | | | +- [DerefOf, table: 0, index: 3538, offset: 0x109] + | | | | +- [Index, table: 0, index: 3539, offset: 0x10a] + | | | | +- [Local0, table: 0, index: 3540, offset: 0x10b] + | | | | +- [Local4, table: 0, index: 3541, offset: 0x10c] + | | | +- [Local2, table: 0, index: 3542, offset: 0x10e] + | | +- [Store, table: 0, index: 3543, offset: 0x10f] + | | | +- [DerefOf, table: 0, index: 3544, offset: 0x110] + | | | | +- [Index, table: 0, index: 3545, offset: 0x111] + | | | | +- [Local1, table: 0, index: 3546, offset: 0x112] + | | | | +- [Local4, table: 0, index: 3547, offset: 0x113] + | | | +- [Local3, table: 0, index: 3548, offset: 0x115] + | | +- [If, table: 0, index: 3549, offset: 0x116] + | | +- [LGreater, table: 0, index: 3550, offset: 0x118] + | | | +- [Local2, table: 0, index: 3551, offset: 0x119] + | | | +- [Local3, table: 0, index: 3552, offset: 0x11a] + | | +- [ScopeBlock, table: 0, index: 3553, offset: 0x11b] + | | +- [Return, table: 0, index: 3554, offset: 0x11b] + | | | +- [One, table: 0, index: 3555, offset: 0x11c] + | | +- [Else, table: 0, index: 3556, offset: 0x11d] + | | +- [ScopeBlock, table: 0, index: 3557, offset: 0x11f] + | | +- [If, table: 0, index: 3558, offset: 0x11f] + | | +- [LLess, table: 0, index: 3559, offset: 0x121] + | | | +- [Local2, table: 0, index: 3560, offset: 0x122] + | | | +- [Local3, table: 0, index: 3561, offset: 0x123] + | | +- [ScopeBlock, table: 0, index: 3562, offset: 0x124] + | | +- [Return, table: 0, index: 3563, offset: 0x124] + | | +- [Ones, table: 0, index: 3564, offset: 0x125] + | +- [If, table: 0, index: 124, offset: 0x128] + | | +- [LLess, table: 0, index: 125, offset: 0x12a] + | | | +- [Local4, table: 0, index: 126, offset: 0x12b] + | | | +- [Local5, table: 0, index: 127, offset: 0x12c] + | | +- [Return, table: 0, index: 128, offset: 0x12d] + | | +- [One, table: 0, index: 129, offset: 0x12e] + | +- [Else, table: 0, index: 130, offset: 0x12f] + | +- [ScopeBlock, table: 0, index: 131, offset: 0x131] + | +- [If, table: 0, index: 132, offset: 0x131] + | | +- [LLess, table: 0, index: 133, offset: 0x133] + | | | +- [Local4, table: 0, index: 134, offset: 0x134] + | | | +- [Local6, table: 0, index: 135, offset: 0x135] + | | +- [Return, table: 0, index: 136, offset: 0x136] + | | +- [Ones, table: 0, index: 137, offset: 0x137] + | +- [Else, table: 0, index: 138, offset: 0x138] + | +- [ScopeBlock, table: 0, index: 139, offset: 0x13a] + | +- [Return, table: 0, index: 140, offset: 0x13a] + | +- [Zero, table: 0, index: 141, offset: 0x13b] + +- [Method, name: "MTCH", argCount: 2, table: 0, index: 142, offset: 0x13c] + | +- [NamePath, table: 0, index: 143, offset: 0x13e] -> [namepath: "MTCH"] + | +- [BytePrefix, table: 0, index: 144, offset: 0x142] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 145, offset: 0x143] + | +- [Store, table: 0, index: 146, offset: 0x143] + | | +- [Arg0, table: 0, index: 147, offset: 0x144] + | | +- [Local0, table: 0, index: 148, offset: 0x145] + | +- [Store, table: 0, index: 149, offset: 0x146] + | | +- [Arg1, table: 0, index: 150, offset: 0x147] + | | +- [Local1, table: 0, index: 151, offset: 0x148] + | +- [Store, table: 0, index: 152, offset: 0x149] + | | +- [MethodCall, table: 0, index: 153, offset: 0x14a] -> [call to "SCMP", argCount: 2, table: 0, index: 92, offset: 0xd1] + | | | +- [Local0, table: 0, index: 154, offset: 0x14e] + | | | +- [Local1, table: 0, index: 155, offset: 0x14f] + | | +- [Local2, table: 0, index: 156, offset: 0x150] + | +- [Return, table: 0, index: 157, offset: 0x151] + | +- [Lnot, table: 0, index: 158, offset: 0x152] + | +- [Local2, table: 0, index: 159, offset: 0x153] + +- [Method, name: "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | +- [NamePath, table: 0, index: 161, offset: 0x156] -> [namepath: "DBG_"] + | +- [BytePrefix, table: 0, index: 162, offset: 0x15a] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 163, offset: 0x15b] + | +- [Store, table: 0, index: 164, offset: 0x15b] + | | +- [Arg0, table: 0, index: 165, offset: 0x15c] + | | +- [Local0, table: 0, index: 166, offset: 0x15d] + | +- [Store, table: 0, index: 167, offset: 0x15e] + | | +- [MethodCall, table: 0, index: 168, offset: 0x15f] -> [call to "S2BF", argCount: 1, table: 0, index: 58, offset: 0x9a] + | | | +- [Local0, table: 0, index: 169, offset: 0x163] + | | +- [Local1, table: 0, index: 170, offset: 0x164] + | +- [Store, table: 0, index: 171, offset: 0x165] + | | +- [SizeOf, table: 0, index: 172, offset: 0x166] + | | | +- [Local1, table: 0, index: 173, offset: 0x167] + | | +- [Local0, table: 0, index: 174, offset: 0x168] + | +- [Decrement, table: 0, index: 175, offset: 0x169] + | | +- [Local0, table: 0, index: 176, offset: 0x16a] + | +- [Store, table: 0, index: 177, offset: 0x16b] + | | +- [Zero, table: 0, index: 178, offset: 0x16c] + | | +- [Local2, table: 0, index: 179, offset: 0x16d] + | +- [While, table: 0, index: 180, offset: 0x16e] + | +- [Local0, table: 0, index: 3565, offset: 0x170] + | +- [ScopeBlock, table: 0, index: 3566, offset: 0x171] + | +- [Decrement, table: 0, index: 3567, offset: 0x171] + | | +- [Local0, table: 0, index: 3568, offset: 0x172] + | +- [Store, table: 0, index: 3569, offset: 0x173] + | | +- [DerefOf, table: 0, index: 3570, offset: 0x174] + | | | +- [Index, table: 0, index: 3571, offset: 0x175] + | | | +- [Local1, table: 0, index: 3572, offset: 0x176] + | | | +- [Local2, table: 0, index: 3573, offset: 0x177] + | | +- [NamePath, table: 0, index: 3574, offset: 0x179] -> [namepath: "DCHR"] + | +- [Increment, table: 0, index: 3575, offset: 0x17d] + | +- [Local2, table: 0, index: 3576, offset: 0x17e] + +- [Name, name: "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [NamePath, table: 0, index: 182, offset: 0x180] -> [namepath: "MSWV"] + | +- [Ones, table: 0, index: 183, offset: 0x184] + +- [Method, name: "MSWN", argCount: 0, table: 0, index: 184, offset: 0x185] + | +- [NamePath, table: 0, index: 185, offset: 0x188] -> [namepath: "MSWN"] + | +- [BytePrefix, table: 0, index: 186, offset: 0x18c] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 187, offset: 0x18d] + | +- [If, table: 0, index: 188, offset: 0x18d] + | | +- [Lnot, table: 0, index: 189, offset: 0x18f] + | | | +- [LEqual, table: 0, index: 190, offset: 0x190] + | | | +- [ResolvedNamePath, table: 0, index: 191, offset: 0x191] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | | | +- [Ones, table: 0, index: 192, offset: 0x195] + | | +- [Return, table: 0, index: 193, offset: 0x196] + | | +- [ResolvedNamePath, table: 0, index: 194, offset: 0x197] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [Store, table: 0, index: 195, offset: 0x19b] + | | +- [Zero, table: 0, index: 196, offset: 0x19c] + | | +- [ResolvedNamePath, table: 0, index: 197, offset: 0x19d] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [MethodCall, table: 0, index: 198, offset: 0x1a1] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 199, offset: 0x1a5] -> [string value: "_OS: "] + | +- [MethodCall, table: 0, index: 200, offset: 0x1ac] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [NamePath, table: 0, index: 201, offset: 0x1b0] -> [namepath: "_OS_"] + | +- [MethodCall, table: 0, index: 202, offset: 0x1b4] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 203, offset: 0x1b8] -> [string value: " +"] + | +- [If, table: 0, index: 204, offset: 0x1bb] + | | +- [CondRefOf, table: 0, index: 205, offset: 0x1be] + | | | +- [NamePath, table: 0, index: 206, offset: 0x1c0] -> [namepath: "_OSI"] + | | +- [MethodCall, table: 0, index: 207, offset: 0x1c5] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 208, offset: 0x1c9] -> [string value: "_OSI exists +"] + | +- [If, table: 0, index: 209, offset: 0x1d7] + | | +- [NamePath, table: 0, index: 210, offset: 0x1d9] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 211, offset: 0x1dd] -> [string value: "Windows 2001"] + | +- [Store, table: 0, index: 212, offset: 0x1eb] + | | +- [BytePrefix, table: 0, index: 213, offset: 0x1ec] -> [num value; dec: 4, hex: 0x4] + | | +- [ResolvedNamePath, table: 0, index: 214, offset: 0x1ee] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 215, offset: 0x1f2] + | | +- [NamePath, table: 0, index: 216, offset: 0x1f4] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 217, offset: 0x1f8] -> [string value: "Windows 2001.1"] + | +- [Store, table: 0, index: 218, offset: 0x208] + | | +- [BytePrefix, table: 0, index: 219, offset: 0x209] -> [num value; dec: 5, hex: 0x5] + | | +- [ResolvedNamePath, table: 0, index: 220, offset: 0x20b] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 221, offset: 0x20f] + | | +- [NamePath, table: 0, index: 222, offset: 0x211] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 223, offset: 0x215] -> [string value: "Windows 2006"] + | +- [Store, table: 0, index: 224, offset: 0x223] + | | +- [BytePrefix, table: 0, index: 225, offset: 0x224] -> [num value; dec: 6, hex: 0x6] + | | +- [ResolvedNamePath, table: 0, index: 226, offset: 0x226] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 227, offset: 0x22a] + | | +- [NamePath, table: 0, index: 228, offset: 0x22c] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 229, offset: 0x230] -> [string value: "Windows 2009"] + | +- [Store, table: 0, index: 230, offset: 0x23e] + | | +- [BytePrefix, table: 0, index: 231, offset: 0x23f] -> [num value; dec: 7, hex: 0x7] + | | +- [ResolvedNamePath, table: 0, index: 232, offset: 0x241] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 233, offset: 0x245] + | | +- [NamePath, table: 0, index: 234, offset: 0x247] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 235, offset: 0x24b] -> [string value: "Windows 2012"] + | +- [Store, table: 0, index: 236, offset: 0x259] + | | +- [BytePrefix, table: 0, index: 237, offset: 0x25a] -> [num value; dec: 8, hex: 0x8] + | | +- [ResolvedNamePath, table: 0, index: 238, offset: 0x25c] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 239, offset: 0x260] + | | +- [NamePath, table: 0, index: 240, offset: 0x262] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 241, offset: 0x266] -> [string value: "Windows 2013"] + | +- [Store, table: 0, index: 242, offset: 0x274] + | | +- [BytePrefix, table: 0, index: 243, offset: 0x275] -> [num value; dec: 9, hex: 0x9] + | | +- [ResolvedNamePath, table: 0, index: 244, offset: 0x277] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 245, offset: 0x27b] + | | +- [NamePath, table: 0, index: 246, offset: 0x27d] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 247, offset: 0x281] -> [string value: "Windows 2015"] + | +- [Store, table: 0, index: 248, offset: 0x28f] + | | +- [BytePrefix, table: 0, index: 249, offset: 0x290] -> [num value; dec: 10, hex: 0xa] + | | +- [ResolvedNamePath, table: 0, index: 250, offset: 0x292] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 251, offset: 0x296] + | | +- [NamePath, table: 0, index: 252, offset: 0x298] -> [namepath: "_OSI"] + | | +- [StringPrefix, table: 0, index: 253, offset: 0x29c] -> [string value: "Windows 2006 SP2"] + | +- [MethodCall, table: 0, index: 254, offset: 0x2ae] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 255, offset: 0x2b2] -> [string value: "Windows 2006 SP2 supported +"] + | +- [Store, table: 0, index: 256, offset: 0x2cf] + | | +- [Zero, table: 0, index: 257, offset: 0x2d0] + | | +- [ResolvedNamePath, table: 0, index: 258, offset: 0x2d1] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [Else, table: 0, index: 259, offset: 0x2d5] + | | +- [ScopeBlock, table: 0, index: 260, offset: 0x2d8] + | | +- [If, table: 0, index: 261, offset: 0x2d8] + | | | +- [MethodCall, table: 0, index: 262, offset: 0x2da] -> [call to "MTCH", argCount: 2, table: 0, index: 142, offset: 0x13c] + | | | | +- [NamePath, table: 0, index: 263, offset: 0x2de] -> [namepath: "_OS_"] + | | | | +- [StringPrefix, table: 0, index: 264, offset: 0x2e2] -> [string value: "Microsoft Windows NT"] + | | | +- [Store, table: 0, index: 265, offset: 0x2f8] + | | | +- [BytePrefix, table: 0, index: 266, offset: 0x2f9] -> [num value; dec: 3, hex: 0x3] + | | | +- [ResolvedNamePath, table: 0, index: 267, offset: 0x2fb] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | | +- [If, table: 0, index: 268, offset: 0x2ff] + | | +- [MethodCall, table: 0, index: 269, offset: 0x301] -> [call to "MTCH", argCount: 2, table: 0, index: 142, offset: 0x13c] + | | | +- [NamePath, table: 0, index: 270, offset: 0x305] -> [namepath: "_OS_"] + | | | +- [StringPrefix, table: 0, index: 271, offset: 0x309] -> [string value: "Microsoft WindowsME: Millennium Edition"] + | | +- [Store, table: 0, index: 272, offset: 0x332] + | | +- [BytePrefix, table: 0, index: 273, offset: 0x333] -> [num value; dec: 2, hex: 0x2] + | | +- [ResolvedNamePath, table: 0, index: 274, offset: 0x335] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [If, table: 0, index: 275, offset: 0x339] + | | +- [CondRefOf, table: 0, index: 276, offset: 0x33c] + | | | +- [NamePath, table: 0, index: 277, offset: 0x33e] -> [namepath: "_REV"] + | | +- [MethodCall, table: 0, index: 278, offset: 0x343] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 279, offset: 0x347] -> [string value: "_REV: "] + | +- [MethodCall, table: 0, index: 280, offset: 0x34f] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | +- [NamePath, table: 0, index: 281, offset: 0x353] -> [namepath: "_REV"] + | +- [If, table: 0, index: 282, offset: 0x357] + | | +- [Land, table: 0, index: 283, offset: 0x35a] + | | | +- [LGreater, table: 0, index: 284, offset: 0x35b] + | | | | +- [ResolvedNamePath, table: 0, index: 285, offset: 0x35c] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | | | | +- [Zero, table: 0, index: 286, offset: 0x360] + | | | +- [LGreater, table: 0, index: 287, offset: 0x361] + | | | +- [NamePath, table: 0, index: 288, offset: 0x362] -> [namepath: "_REV"] + | | | +- [BytePrefix, table: 0, index: 289, offset: 0x366] -> [num value; dec: 2, hex: 0x2] + | | +- [If, table: 0, index: 290, offset: 0x368] + | | +- [LLess, table: 0, index: 291, offset: 0x36a] + | | | +- [ResolvedNamePath, table: 0, index: 292, offset: 0x36b] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | | | +- [BytePrefix, table: 0, index: 293, offset: 0x36f] -> [num value; dec: 8, hex: 0x8] + | | +- [MethodCall, table: 0, index: 294, offset: 0x371] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 295, offset: 0x375] -> [string value: "ACPI rev mismatch, not a Microsoft OS +"] + | +- [Store, table: 0, index: 296, offset: 0x39d] + | | +- [Zero, table: 0, index: 297, offset: 0x39e] + | | +- [ResolvedNamePath, table: 0, index: 298, offset: 0x39f] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [MethodCall, table: 0, index: 299, offset: 0x3a3] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 300, offset: 0x3a7] -> [string value: "Determined MSWV: "] + | +- [MethodCall, table: 0, index: 301, offset: 0x3ba] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | +- [ResolvedNamePath, table: 0, index: 302, offset: 0x3be] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + | +- [Return, table: 0, index: 303, offset: 0x3c2] + | +- [ResolvedNamePath, table: 0, index: 304, offset: 0x3c3] -> [resolved to "MSWV", table: 0, index: 181, offset: 0x17f] + +- [Name, name: "PICM", table: 0, index: 305, offset: 0x3c7] + | +- [NamePath, table: 0, index: 306, offset: 0x3c8] -> [namepath: "PICM"] + | +- [Zero, table: 0, index: 307, offset: 0x3cc] + +- [Method, name: "_PIC", argCount: 1, table: 0, index: 308, offset: 0x3cd] + | +- [NamePath, table: 0, index: 309, offset: 0x3cf] -> [namepath: "_PIC"] + | +- [BytePrefix, table: 0, index: 310, offset: 0x3d3] -> [num value; dec: 1, hex: 0x1] + | +- [ScopeBlock, table: 0, index: 311, offset: 0x3d4] + | +- [MethodCall, table: 0, index: 312, offset: 0x3d4] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | | +- [StringPrefix, table: 0, index: 313, offset: 0x3d8] -> [string value: "Pic mode: "] + | +- [MethodCall, table: 0, index: 314, offset: 0x3e4] -> [call to "HEX4", argCount: 1, table: 0, index: 41, offset: 0x80] + | | +- [Arg0, table: 0, index: 315, offset: 0x3e8] + | +- [Store, table: 0, index: 316, offset: 0x3e9] + | +- [Arg0, table: 0, index: 317, offset: 0x3ea] + | +- [ResolvedNamePath, table: 0, index: 318, offset: 0x3eb] -> [resolved to "PICM", table: 0, index: 305, offset: 0x3c7] + +- [OpRegion, name: "SYSI", table: 0, index: 319, offset: 0x3ef] + | +- [NamePath, table: 0, index: 320, offset: 0x3f1] -> [namepath: "SYSI"] + | +- [BytePrefix, table: 0, index: 321, offset: 0x3f5] -> [num value; dec: 1, hex: 0x1] + | +- [WordPrefix, table: 0, index: 322, offset: 0x3f6] -> [num value; dec: 16456, hex: 0x4048] + | +- [BytePrefix, table: 0, index: 323, offset: 0x3f9] -> [num value; dec: 8, hex: 0x8] + +- [Field, table: 0, index: 324, offset: 0x3fb] + | +- [NamePath, table: 0, index: 325, offset: 0x3fe] -> [namepath: "SYSI"] + | +- [BytePrefix, table: 0, index: 326, offset: 0x402] -> [num value; dec: 3, hex: 0x3] + +- [NamedField, name: "IDX0", table: 0, index: 327, offset: 0x403] -> [field index: 324, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "DAT0", table: 0, index: 328, offset: 0x408] -> [field index: 324, offset(bytes): 0x20, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [IndexField, name: "IDX0", table: 0, index: 329, offset: 0x40d] + | +- [NamePath, table: 0, index: 330, offset: 0x411] -> [namepath: "IDX0"] + | +- [NamePath, table: 0, index: 331, offset: 0x415] -> [namepath: "DAT0"] + | +- [BytePrefix, table: 0, index: 332, offset: 0x419] -> [num value; dec: 3, hex: 0x3] + +- [NamedField, name: "MEML", table: 0, index: 333, offset: 0x41a] -> [field index: 329, offset(bytes): 0x0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "UIOA", table: 0, index: 334, offset: 0x41f] -> [field index: 329, offset(bytes): 0x20, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "UHPT", table: 0, index: 335, offset: 0x424] -> [field index: 329, offset(bytes): 0x40, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "USMC", table: 0, index: 336, offset: 0x429] -> [field index: 329, offset(bytes): 0x60, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "UFDC", table: 0, index: 337, offset: 0x42e] -> [field index: 329, offset(bytes): 0x80, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL2B", table: 0, index: 338, offset: 0x433] -> [field index: 329, offset(bytes): 0xa0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL2I", table: 0, index: 339, offset: 0x438] -> [field index: 329, offset(bytes): 0xc0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL3B", table: 0, index: 340, offset: 0x43d] -> [field index: 329, offset(bytes): 0xe0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL3I", table: 0, index: 341, offset: 0x442] -> [field index: 329, offset(bytes): 0x100, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PMNN", table: 0, index: 342, offset: 0x447] -> [field index: 329, offset(bytes): 0x120, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "URTC", table: 0, index: 343, offset: 0x44c] -> [field index: 329, offset(bytes): 0x140, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "CPUL", table: 0, index: 344, offset: 0x451] -> [field index: 329, offset(bytes): 0x160, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "CPUC", table: 0, index: 345, offset: 0x456] -> [field index: 329, offset(bytes): 0x180, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "CPET", table: 0, index: 346, offset: 0x45b] -> [field index: 329, offset(bytes): 0x1a0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "CPEV", table: 0, index: 347, offset: 0x460] -> [field index: 329, offset(bytes): 0x1c0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "NICA", table: 0, index: 348, offset: 0x465] -> [field index: 329, offset(bytes): 0x1e0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "HDAA", table: 0, index: 349, offset: 0x46a] -> [field index: 329, offset(bytes): 0x200, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PWRS", table: 0, index: 350, offset: 0x46f] -> [field index: 329, offset(bytes): 0x220, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "IOCA", table: 0, index: 351, offset: 0x474] -> [field index: 329, offset(bytes): 0x240, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "HBCA", table: 0, index: 352, offset: 0x479] -> [field index: 329, offset(bytes): 0x260, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PCIB", table: 0, index: 353, offset: 0x47e] -> [field index: 329, offset(bytes): 0x280, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PCIL", table: 0, index: 354, offset: 0x483] -> [field index: 329, offset(bytes): 0x2a0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL0B", table: 0, index: 355, offset: 0x488] -> [field index: 329, offset(bytes): 0x2c0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL0I", table: 0, index: 356, offset: 0x48d] -> [field index: 329, offset(bytes): 0x2e0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL1B", table: 0, index: 357, offset: 0x492] -> [field index: 329, offset(bytes): 0x300, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "SL1I", table: 0, index: 358, offset: 0x497] -> [field index: 329, offset(bytes): 0x320, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PP0B", table: 0, index: 359, offset: 0x49c] -> [field index: 329, offset(bytes): 0x340, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PP0I", table: 0, index: 360, offset: 0x4a1] -> [field index: 329, offset(bytes): 0x360, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PP1B", table: 0, index: 361, offset: 0x4a6] -> [field index: 329, offset(bytes): 0x380, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PP1I", table: 0, index: 362, offset: 0x4ab] -> [field index: 329, offset(bytes): 0x3a0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "PMNX", table: 0, index: 363, offset: 0x4b0] -> [field index: 329, offset(bytes): 0x3c0, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "ININ", table: 0, index: 364, offset: 0x4b7] -> [field index: 329, offset(bytes): 0x400, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "VAIN", table: 0, index: 365, offset: 0x4bf] -> [field index: 329, offset(bytes): 0x1000, width(bits): 0x20, accType: Dword, lockType: NoLock, updateType: Preserve, connection: -] + +- [Name, name: "_S0_", table: 0, index: 3445, offset: 0x2164] + | +- [NamePath, table: 0, index: 3446, offset: 0x2165] -> [namepath: "_S0_"] + | +- [Package, table: 0, index: 3447, offset: 0x2169] + | +- [BytePrefix, table: 0, index: 3448, offset: 0x216b] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 3449, offset: 0x216c] + | +- [Zero, table: 0, index: 3450, offset: 0x216c] + | +- [Zero, table: 0, index: 3451, offset: 0x216d] + +- [If, table: 0, index: 3452, offset: 0x216e] + | +- [And, table: 0, index: 3453, offset: 0x2170] + | | +- [ResolvedNamePath, table: 0, index: 3454, offset: 0x2171] -> [resolved to "PWRS", table: 0, index: 350, offset: 0x46f] + | | +- [BytePrefix, table: 0, index: 3455, offset: 0x2175] -> [num value; dec: 2, hex: 0x2] + | | +- [Zero, table: 0, index: 3456, offset: 0x2177] + | +- [Name, name: "_S1_", table: 0, index: 3457, offset: 0x2178] + | +- [NamePath, table: 0, index: 3458, offset: 0x2179] -> [namepath: "_S1_"] + | +- [Package, table: 0, index: 3459, offset: 0x217d] + | +- [BytePrefix, table: 0, index: 3460, offset: 0x217f] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 3461, offset: 0x2180] + | +- [One, table: 0, index: 3462, offset: 0x2180] + | +- [One, table: 0, index: 3463, offset: 0x2181] + +- [If, table: 0, index: 3464, offset: 0x2182] + | +- [And, table: 0, index: 3465, offset: 0x2184] + | | +- [ResolvedNamePath, table: 0, index: 3466, offset: 0x2185] -> [resolved to "PWRS", table: 0, index: 350, offset: 0x46f] + | | +- [BytePrefix, table: 0, index: 3467, offset: 0x2189] -> [num value; dec: 16, hex: 0x10] + | | +- [Zero, table: 0, index: 3468, offset: 0x218b] + | +- [Name, name: "_S4_", table: 0, index: 3469, offset: 0x218c] + | +- [NamePath, table: 0, index: 3470, offset: 0x218d] -> [namepath: "_S4_"] + | +- [Package, table: 0, index: 3471, offset: 0x2191] + | +- [BytePrefix, table: 0, index: 3472, offset: 0x2193] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 3473, offset: 0x2194] + | +- [BytePrefix, table: 0, index: 3474, offset: 0x2194] -> [num value; dec: 5, hex: 0x5] + | +- [BytePrefix, table: 0, index: 3475, offset: 0x2196] -> [num value; dec: 5, hex: 0x5] + +- [Name, name: "_S5_", table: 0, index: 3476, offset: 0x2198] + | +- [NamePath, table: 0, index: 3477, offset: 0x2199] -> [namepath: "_S5_"] + | +- [Package, table: 0, index: 3478, offset: 0x219d] + | +- [BytePrefix, table: 0, index: 3479, offset: 0x219f] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 3480, offset: 0x21a0] + | +- [BytePrefix, table: 0, index: 3481, offset: 0x21a0] -> [num value; dec: 5, hex: 0x5] + | +- [BytePrefix, table: 0, index: 3482, offset: 0x21a2] -> [num value; dec: 5, hex: 0x5] + +- [Method, name: "_PTS", argCount: 1, table: 0, index: 3483, offset: 0x21a4] + +- [NamePath, table: 0, index: 3484, offset: 0x21a6] -> [namepath: "_PTS"] + +- [BytePrefix, table: 0, index: 3485, offset: 0x21aa] -> [num value; dec: 1, hex: 0x1] + +- [ScopeBlock, table: 0, index: 3486, offset: 0x21ab] + +- [MethodCall, table: 0, index: 3487, offset: 0x21ab] -> [call to "DBG_", argCount: 1, table: 0, index: 160, offset: 0x154] + | +- [StringPrefix, table: 0, index: 3488, offset: 0x21af] -> [string value: "Prepare to sleep: "] + +- [MethodCall, table: 0, index: 3489, offset: 0x21c3] -> [call to "HEX_", argCount: 1, table: 0, index: 27, offset: 0x66] + +- [Arg0, table: 0, index: 3490, offset: 0x21c7] diff --git a/src/gopheros/device/acpi/table/tabletest/DSDT.dsl b/src/gopheros/device/acpi/table/tabletest/DSDT.dsl new file mode 100644 index 0000000..14c7c23 --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/DSDT.dsl @@ -0,0 +1,3332 @@ +/* + * Intel ACPI Component Architecture + * AML/ASL+ Disassembler version 20160108-64 + * Copyright (c) 2000 - 2016 Intel Corporation + * + * Disassembling to symbolic ASL+ operators + * + * Disassembly of DSDT.aml, Thu Jan 4 07:55:57 2018 + * + * Original Table Header: + * Signature "DSDT" + * Length 0x000021C8 (8648) + * Revision 0x02 + * Checksum 0xEE + * OEM ID "VBOX " + * OEM Table ID "VBOXBIOS" + * OEM Revision 0x00000002 (2) + * Compiler ID "INTL" + * Compiler Version 0x20100528 (537920808) + */ +DefinitionBlock ("DSDT.aml", "DSDT", 2, "VBOX ", "VBOXBIOS", 0x00000002) +{ + OperationRegion (DBG0, SystemIO, 0x3000, 0x04) + Field (DBG0, ByteAcc, NoLock, Preserve) + { + DHE1, 8 + } + + Field (DBG0, WordAcc, NoLock, Preserve) + { + DHE2, 16 + } + + Field (DBG0, DWordAcc, NoLock, Preserve) + { + DHE4, 32 + } + + Field (DBG0, ByteAcc, NoLock, Preserve) + { + Offset (0x01), + DCHR, 8 + } + + Method (HEX, 1, NotSerialized) + { + DHE1 = Arg0 + } + + Method (HEX2, 1, NotSerialized) + { + DHE2 = Arg0 + } + + Method (HEX4, 1, NotSerialized) + { + DHE4 = Arg0 + } + + Method (SLEN, 1, NotSerialized) + { + Local0 = Arg0 + Return (SizeOf (Local0)) + } + + Method (S2BF, 1, Serialized) + { + Local0 = Arg0 + Local0 = (SLEN (Local0) + One) + Name (BUFF, Buffer (Local0) {}) + BUFF = Arg0 + Return (BUFF) /* \S2BF.BUFF */ + } + + Method (MIN, 2, NotSerialized) + { + If ((Arg0 < Arg1)) + { + Return (Arg0) + } + Else + { + Return (Arg1) + } + } + + Method (SCMP, 2, NotSerialized) + { + Local0 = Arg0 + Local0 = S2BF (Local0) + Local1 = S2BF (Arg1) + Local4 = Zero + Local5 = SLEN (Arg0) + Local6 = SLEN (Arg1) + Local7 = MIN (Local5, Local6) + While ((Local4 < Local7)) + { + Local2 = DerefOf (Local0 [Local4]) + Local3 = DerefOf (Local1 [Local4]) + If ((Local2 > Local3)) + { + Return (One) + } + ElseIf ((Local2 < Local3)) + { + Return (Ones) + } + + Local4++ + } + + If ((Local4 < Local5)) + { + Return (One) + } + ElseIf ((Local4 < Local6)) + { + Return (Ones) + } + Else + { + Return (Zero) + } + } + + Method (MTCH, 2, NotSerialized) + { + Local0 = Arg0 + Local1 = Arg1 + Local2 = SCMP (Local0, Local1) + Return (!Local2) + } + + Method (DBG, 1, NotSerialized) + { + Local0 = Arg0 + Local1 = S2BF (Local0) + Local0 = SizeOf (Local1) + Local0-- + Local2 = Zero + While (Local0) + { + Local0-- + DCHR = DerefOf (Local1 [Local2]) + Local2++ + } + } + + Name (MSWV, Ones) + Method (MSWN, 0, NotSerialized) + { + If ((MSWV != Ones)) + { + Return (MSWV) /* \MSWV */ + } + + MSWV = Zero + DBG ("_OS: ") + DBG (_OS) + DBG ("\n") + If (CondRefOf (_OSI)) + { + DBG ("_OSI exists\n") + If (_OSI ("Windows 2001")) + { + MSWV = 0x04 + } + + If (_OSI ("Windows 2001.1")) + { + MSWV = 0x05 + } + + If (_OSI ("Windows 2006")) + { + MSWV = 0x06 + } + + If (_OSI ("Windows 2009")) + { + MSWV = 0x07 + } + + If (_OSI ("Windows 2012")) + { + MSWV = 0x08 + } + + If (_OSI ("Windows 2013")) + { + MSWV = 0x09 + } + + If (_OSI ("Windows 2015")) + { + MSWV = 0x0A + } + + If (_OSI ("Windows 2006 SP2")) + { + DBG ("Windows 2006 SP2 supported\n") + MSWV = Zero + } + } + ElseIf (MTCH (_OS, "Microsoft Windows NT")) + { + MSWV = 0x03 + } + + If (CondRefOf (_REV)) + { + DBG ("_REV: ") + HEX4 (_REV) + If (((MSWV > Zero) && (_REV > 0x02))) + { + If ((MSWV < 0x08)) + { + DBG ("ACPI rev mismatch, not a Microsoft OS\n") + MSWV = Zero + } + } + } + + DBG ("Determined MSWV: ") + HEX4 (MSWV) + Return (MSWV) /* \MSWV */ + } + + Name (PICM, Zero) + Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model + { + DBG ("Pic mode: ") + HEX4 (Arg0) + PICM = Arg0 + } + + OperationRegion (SYSI, SystemIO, 0x4048, 0x08) + Field (SYSI, DWordAcc, NoLock, Preserve) + { + IDX0, 32, + DAT0, 32 + } + + IndexField (IDX0, DAT0, DWordAcc, NoLock, Preserve) + { + MEML, 32, + UIOA, 32, + UHPT, 32, + USMC, 32, + UFDC, 32, + SL2B, 32, + SL2I, 32, + SL3B, 32, + SL3I, 32, + PMNN, 32, + URTC, 32, + CPUL, 32, + CPUC, 32, + CPET, 32, + CPEV, 32, + NICA, 32, + HDAA, 32, + PWRS, 32, + IOCA, 32, + HBCA, 32, + PCIB, 32, + PCIL, 32, + SL0B, 32, + SL0I, 32, + SL1B, 32, + SL1I, 32, + PP0B, 32, + PP0I, 32, + PP1B, 32, + PP1I, 32, + PMNX, 32, + Offset (0x80), + ININ, 32, + Offset (0x200), + VAIN, 32 + } + + Scope (_SB) + { + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + VAIN = 0x0BADC0DE + DBG ("MEML: ") + HEX4 (MEML) + DBG ("UIOA: ") + HEX4 (UIOA) + DBG ("UHPT: ") + HEX4 (UHPT) + DBG ("USMC: ") + HEX4 (USMC) + DBG ("UFDC: ") + HEX4 (UFDC) + DBG ("PMNN: ") + HEX4 (PMNN) + } + + Name (PR00, Package (0x78) + { + Package (0x04) + { + 0x0002FFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0002FFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0002FFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0002FFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0003FFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0003FFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0003FFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0003FFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0004FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0004FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0004FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0004FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0005FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0005FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0005FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0005FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0006FFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0006FFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0006FFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0006FFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0007FFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0007FFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0007FFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0007FFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0008FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0008FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0008FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0008FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0009FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0009FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0009FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0009FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000AFFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000AFFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000AFFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000AFFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000BFFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000BFFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000BFFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000BFFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000CFFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000CFFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000CFFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000CFFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000DFFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000DFFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000DFFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000DFFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000EFFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x000EFFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000EFFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000EFFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000FFFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x000FFFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x000FFFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x000FFFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0010FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0010FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0010FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0010FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0011FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0011FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0011FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0011FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0012FFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0012FFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0012FFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0012FFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0013FFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0013FFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0013FFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0013FFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0014FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0014FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0014FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0014FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0015FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0015FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0015FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0015FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0016FFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0016FFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0016FFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0016FFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0017FFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0017FFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0017FFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0017FFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0018FFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x0018FFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0018FFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0018FFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0019FFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x0019FFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x0019FFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x0019FFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001AFFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001AFFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001AFFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001AFFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001BFFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001BFFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001BFFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001BFFFF, + 0x03, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001CFFFF, + Zero, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001CFFFF, + One, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001CFFFF, + 0x02, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001CFFFF, + 0x03, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001DFFFF, + Zero, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001DFFFF, + One, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001DFFFF, + 0x02, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001DFFFF, + 0x03, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001EFFFF, + Zero, + LNKB, + Zero + }, + + Package (0x04) + { + 0x001EFFFF, + One, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001EFFFF, + 0x02, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001EFFFF, + 0x03, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001FFFFF, + Zero, + LNKC, + Zero + }, + + Package (0x04) + { + 0x001FFFFF, + One, + LNKD, + Zero + }, + + Package (0x04) + { + 0x001FFFFF, + 0x02, + LNKA, + Zero + }, + + Package (0x04) + { + 0x001FFFFF, + 0x03, + LNKB, + Zero + } + }) + Name (PR01, Package (0x78) + { + Package (0x04) + { + 0x0002FFFF, + Zero, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0002FFFF, + One, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0002FFFF, + 0x02, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0002FFFF, + 0x03, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0003FFFF, + Zero, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0003FFFF, + One, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0003FFFF, + 0x02, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0003FFFF, + 0x03, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0004FFFF, + Zero, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0004FFFF, + One, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0004FFFF, + 0x02, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0004FFFF, + 0x03, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0005FFFF, + Zero, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0005FFFF, + One, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0005FFFF, + 0x02, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0005FFFF, + 0x03, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0006FFFF, + Zero, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0006FFFF, + One, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0006FFFF, + 0x02, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0006FFFF, + 0x03, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0007FFFF, + Zero, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0007FFFF, + One, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0007FFFF, + 0x02, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0007FFFF, + 0x03, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0008FFFF, + Zero, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0008FFFF, + One, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0008FFFF, + 0x02, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0008FFFF, + 0x03, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0009FFFF, + Zero, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0009FFFF, + One, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0009FFFF, + 0x02, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0009FFFF, + 0x03, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x000AFFFF, + Zero, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x000AFFFF, + One, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x000AFFFF, + 0x02, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x000AFFFF, + 0x03, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x000BFFFF, + Zero, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x000BFFFF, + One, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x000BFFFF, + 0x02, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x000BFFFF, + 0x03, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x000CFFFF, + Zero, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x000CFFFF, + One, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x000CFFFF, + 0x02, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x000CFFFF, + 0x03, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x000DFFFF, + Zero, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x000DFFFF, + One, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x000DFFFF, + 0x02, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x000DFFFF, + 0x03, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x000EFFFF, + Zero, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x000EFFFF, + One, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x000EFFFF, + 0x02, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x000EFFFF, + 0x03, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x000FFFFF, + Zero, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x000FFFFF, + One, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x000FFFFF, + 0x02, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x000FFFFF, + 0x03, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0010FFFF, + Zero, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0010FFFF, + One, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0010FFFF, + 0x02, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0010FFFF, + 0x03, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0011FFFF, + Zero, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0011FFFF, + One, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0011FFFF, + 0x02, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0011FFFF, + 0x03, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0012FFFF, + Zero, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0012FFFF, + One, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0012FFFF, + 0x02, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0012FFFF, + 0x03, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0013FFFF, + Zero, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0013FFFF, + One, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0013FFFF, + 0x02, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0013FFFF, + 0x03, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0014FFFF, + Zero, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x0014FFFF, + One, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0014FFFF, + 0x02, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0014FFFF, + 0x03, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0015FFFF, + Zero, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x0015FFFF, + One, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0015FFFF, + 0x02, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0015FFFF, + 0x03, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0016FFFF, + Zero, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x0016FFFF, + One, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0016FFFF, + 0x02, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0016FFFF, + 0x03, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0017FFFF, + Zero, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x0017FFFF, + One, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0017FFFF, + 0x02, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0017FFFF, + 0x03, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0018FFFF, + Zero, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x0018FFFF, + One, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0018FFFF, + 0x02, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0018FFFF, + 0x03, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0019FFFF, + Zero, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x0019FFFF, + One, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x0019FFFF, + 0x02, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x0019FFFF, + 0x03, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x001AFFFF, + Zero, + Zero, + 0x12 + }, + + Package (0x04) + { + 0x001AFFFF, + One, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x001AFFFF, + 0x02, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x001AFFFF, + 0x03, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x001BFFFF, + Zero, + Zero, + 0x13 + }, + + Package (0x04) + { + 0x001BFFFF, + One, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x001BFFFF, + 0x02, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x001BFFFF, + 0x03, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x001CFFFF, + Zero, + Zero, + 0x14 + }, + + Package (0x04) + { + 0x001CFFFF, + One, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x001CFFFF, + 0x02, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x001CFFFF, + 0x03, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x001DFFFF, + Zero, + Zero, + 0x15 + }, + + Package (0x04) + { + 0x001DFFFF, + One, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x001DFFFF, + 0x02, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x001DFFFF, + 0x03, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x001EFFFF, + Zero, + Zero, + 0x16 + }, + + Package (0x04) + { + 0x001EFFFF, + One, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x001EFFFF, + 0x02, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x001EFFFF, + 0x03, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x001FFFFF, + Zero, + Zero, + 0x17 + }, + + Package (0x04) + { + 0x001FFFFF, + One, + Zero, + 0x10 + }, + + Package (0x04) + { + 0x001FFFFF, + 0x02, + Zero, + 0x11 + }, + + Package (0x04) + { + 0x001FFFFF, + 0x03, + Zero, + 0x12 + } + }) + Name (PRSA, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {5,9,10,11} + }) + Name (PRSB, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {5,9,10,11} + }) + Name (PRSC, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {5,9,10,11} + }) + Name (PRSD, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {5,9,10,11} + }) + Device (PCI0) + { + Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID + Method (_ADR, 0, NotSerialized) // _ADR: Address + { + Return (HBCA) /* \HBCA */ + } + + Name (_BBN, Zero) // _BBN: BIOS Bus Number + Name (_UID, Zero) // _UID: Unique ID + Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table + { + If (((PICM && UIOA) == Zero)) + { + DBG ("RETURNING PIC\n") + ^SBRG.APDE = Zero + ^SBRG.APAD = Zero + Return (PR00) /* \_SB_.PR00 */ + } + Else + { + DBG ("RETURNING APIC\n") + ^SBRG.APDE = 0xBE + ^SBRG.APAD = 0xEF + Return (PR01) /* \_SB_.PR01 */ + } + } + + Device (SBRG) + { + Method (_ADR, 0, NotSerialized) // _ADR: Address + { + Return (IOCA) /* \IOCA */ + } + + OperationRegion (PCIC, PCI_Config, Zero, 0xFF) + Field (PCIC, ByteAcc, NoLock, Preserve) + { + Offset (0xAD), + APAD, 8, + Offset (0xDE), + APDE, 8 + } + + Device (^PCIE) + { + Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID + Name (_UID, 0x11) // _UID: Unique ID + Name (CRS, ResourceTemplate () + { + Memory32Fixed (ReadOnly, + 0xDC000000, // Address Base + 0x04000000, // Address Length + _Y00) + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateDWordField (CRS, \_SB.PCI0.PCIE._Y00._BAS, BAS1) // _BAS: Base Address + CreateDWordField (CRS, \_SB.PCI0.PCIE._Y00._LEN, LEN1) // _LEN: Length + BAS1 = PCIB /* \PCIB */ + LEN1 = PCIL /* \PCIL */ + Return (CRS) /* \_SB_.PCI0.PCIE.CRS_ */ + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((PCIB == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + } + + Device (PS2K) + { + Name (_HID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */) // _HID: Hardware ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0060, // Range Minimum + 0x0060, // Range Maximum + 0x00, // Alignment + 0x01, // Length + ) + IO (Decode16, + 0x0064, // Range Minimum + 0x0064, // Range Maximum + 0x00, // Alignment + 0x01, // Length + ) + IRQNoFlags () + {1} + }) + } + + Device (DMAC) + { + Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */) // _HID: Hardware ID + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0000, // Range Minimum + 0x0000, // Range Maximum + 0x01, // Alignment + 0x10, // Length + ) + IO (Decode16, + 0x0080, // Range Minimum + 0x0080, // Range Maximum + 0x01, // Alignment + 0x10, // Length + ) + IO (Decode16, + 0x00C0, // Range Minimum + 0x00C0, // Range Maximum + 0x01, // Alignment + 0x20, // Length + ) + DMA (Compatibility, BusMaster, Transfer8_16, ) + {4} + }) + } + + Device (FDC0) + { + Name (_HID, EisaId ("PNP0700")) // _HID: Hardware ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (UFDC) /* \UFDC */ + } + + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x03F0, // Range Minimum + 0x03F0, // Range Maximum + 0x01, // Alignment + 0x06, // Length + ) + IO (Decode16, + 0x03F7, // Range Minimum + 0x03F7, // Range Maximum + 0x01, // Alignment + 0x01, // Length + ) + IRQNoFlags () + {6} + DMA (Compatibility, NotBusMaster, Transfer8, ) + {2} + }) + Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings + { + IO (Decode16, + 0x03F0, // Range Minimum + 0x03F0, // Range Maximum + 0x01, // Alignment + 0x06, // Length + ) + IO (Decode16, + 0x03F7, // Range Minimum + 0x03F7, // Range Maximum + 0x01, // Alignment + 0x01, // Length + ) + IRQNoFlags () + {6} + DMA (Compatibility, NotBusMaster, Transfer8, ) + {2} + }) + } + + Device (PS2M) + { + Name (_HID, EisaId ("PNP0F03") /* Microsoft PS/2-style Mouse */) // _HID: Hardware ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IRQNoFlags () + {12} + }) + } + + Device (^LPT0) + { + Name (_HID, EisaId ("PNP0400") /* Standard LPT Parallel Port */) // _HID: Hardware ID + Name (_UID, One) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((PP0B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x0378, // Range Minimum + 0x0378, // Range Maximum + 0x08, // Alignment + 0x08, // Length + _Y01) + IRQNoFlags (_Y02) + {7} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.LPT0._Y01._MIN, PMI0) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.LPT0._Y01._MAX, PMA0) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.LPT0._Y02._INT, PIQ0) // _INT: Interrupts + PMI0 = PP0B /* \PP0B */ + PMA0 = PP0B /* \PP0B */ + PIQ0 = (One << PP0I) /* \PP0I */ + Return (CRS) /* \_SB_.PCI0.LPT0.CRS_ */ + } + } + + Device (^LPT1) + { + Name (_HID, EisaId ("PNP0400") /* Standard LPT Parallel Port */) // _HID: Hardware ID + Name (_UID, 0x02) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((PP1B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x0278, // Range Minimum + 0x0278, // Range Maximum + 0x08, // Alignment + 0x08, // Length + _Y03) + IRQNoFlags (_Y04) + {5} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.LPT1._Y03._MIN, PMI1) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.LPT1._Y03._MAX, PMA1) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.LPT1._Y04._INT, PIQ1) // _INT: Interrupts + PMI1 = PP1B /* \PP1B */ + PMA1 = PP1B /* \PP1B */ + PIQ1 = (One << PP1I) /* \PP1I */ + Return (CRS) /* \_SB_.PCI0.LPT1.CRS_ */ + } + } + + Device (^SRL0) + { + Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID + Name (_UID, One) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((SL0B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x03F8, // Range Minimum + 0x03F8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + _Y05) + IRQNoFlags (_Y06) + {4} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.SRL0._Y05._MIN, MIN0) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL0._Y05._MAX, MAX0) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL0._Y06._INT, IRQ0) // _INT: Interrupts + MIN0 = SL0B /* \SL0B */ + MAX0 = SL0B /* \SL0B */ + IRQ0 = (One << SL0I) /* \SL0I */ + Return (CRS) /* \_SB_.PCI0.SRL0.CRS_ */ + } + } + + Device (^SRL1) + { + Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID + Name (_UID, 0x02) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((SL1B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x02F8, // Range Minimum + 0x02F8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + _Y07) + IRQNoFlags (_Y08) + {3} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.SRL1._Y07._MIN, MIN1) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL1._Y07._MAX, MAX1) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL1._Y08._INT, IRQ1) // _INT: Interrupts + MIN1 = SL1B /* \SL1B */ + MAX1 = SL1B /* \SL1B */ + IRQ1 = (One << SL1I) /* \SL1I */ + Return (CRS) /* \_SB_.PCI0.SRL1.CRS_ */ + } + } + + Device (^SRL2) + { + Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID + Name (_UID, 0x03) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((SL2B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x03E8, // Range Minimum + 0x03E8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + _Y09) + IRQNoFlags (_Y0A) + {3} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.SRL2._Y09._MIN, MIN1) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL2._Y09._MAX, MAX1) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL2._Y0A._INT, IRQ1) // _INT: Interrupts + MIN1 = SL2B /* \SL2B */ + MAX1 = SL2B /* \SL2B */ + IRQ1 = (One << SL2I) /* \SL2I */ + Return (CRS) /* \_SB_.PCI0.SRL2.CRS_ */ + } + } + + Device (^SRL3) + { + Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID + Name (_UID, 0x04) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((SL3B == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x02E8, // Range Minimum + 0x02E8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + _Y0B) + IRQNoFlags (_Y0C) + {3} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateWordField (CRS, \_SB.PCI0.SRL3._Y0B._MIN, MIN1) // _MIN: Minimum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL3._Y0B._MAX, MAX1) // _MAX: Maximum Base Address + CreateWordField (CRS, \_SB.PCI0.SRL3._Y0C._INT, IRQ1) // _INT: Interrupts + MIN1 = SL3B /* \SL3B */ + MAX1 = SL3B /* \SL3B */ + IRQ1 = (One << SL3I) /* \SL3I */ + Return (CRS) /* \_SB_.PCI0.SRL3.CRS_ */ + } + } + + Device (TIMR) + { + Name (_HID, EisaId ("PNP0100") /* PC-class System Timer */) // _HID: Hardware ID + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0040, // Range Minimum + 0x0040, // Range Maximum + 0x00, // Alignment + 0x04, // Length + ) + IO (Decode16, + 0x0050, // Range Minimum + 0x0050, // Range Maximum + 0x10, // Alignment + 0x04, // Length + ) + }) + } + + Device (PIC) + { + Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */) // _HID: Hardware ID + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0020, // Range Minimum + 0x0020, // Range Maximum + 0x00, // Alignment + 0x02, // Length + ) + IO (Decode16, + 0x00A0, // Range Minimum + 0x00A0, // Range Maximum + 0x00, // Alignment + 0x02, // Length + ) + IRQNoFlags () + {2} + }) + } + + Device (RTC) + { + Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0070, // Range Minimum + 0x0070, // Range Maximum + 0x01, // Alignment + 0x02, // Length + ) + }) + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (URTC) /* \URTC */ + } + } + + Device (HPET) + { + Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID + Name (_CID, EisaId ("PNP0C01") /* System Board */) // _CID: Compatible ID + Name (_UID, Zero) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (UHPT) /* \UHPT */ + } + + Name (CRS, ResourceTemplate () + { + IRQNoFlags () + {0} + IRQNoFlags () + {8} + Memory32Fixed (ReadWrite, + 0xFED00000, // Address Base + 0x00000400, // Address Length + ) + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (CRS) /* \_SB_.PCI0.SBRG.HPET.CRS_ */ + } + } + + Device (SMC) + { + Name (_HID, EisaId ("APP0001")) // _HID: Hardware ID + Name (_CID, "smc-napa") // _CID: Compatible ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (USMC) /* \USMC */ + } + + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x0300, // Range Minimum + 0x0300, // Range Maximum + 0x01, // Alignment + 0x20, // Length + ) + IRQNoFlags () + {6} + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (CRS) /* \_SB_.PCI0.SBRG.SMC_.CRS_ */ + } + } + } + + Device (GIGE) + { + Name (_HID, EisaId ("PNP8390")) // _HID: Hardware ID + Method (_ADR, 0, NotSerialized) // _ADR: Address + { + Return (NICA) /* \NICA */ + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((NICA == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + } + + Device (GFX0) + { + Name (_ADR, 0x00020000) // _ADR: Address + Method (_STA, 0, NotSerialized) // _STA: Status + { + If (((MSWN () > Zero) && (MSWN () < 0x08))) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + + Scope (\_GPE) + { + Method (_L02, 0, NotSerialized) // _Lxx: Level-Triggered GPE + { + Notify (\_SB.PCI0.GFX0, 0x81) // Information Change + } + } + + Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching + { + } + + Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices + { + Return (Package (0x01) + { + 0x80000100 + }) + } + + Device (VGA) + { + Method (_ADR, 0, Serialized) // _ADR: Address + { + Return (0x0100) + } + } + } + + Device (HDEF) + { + Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method + { + Local0 = Package (0x04) + { + "layout-id", + Unicode ("\x04"), + "PinConfigurations", + Buffer (Zero) {} + } + If ((Arg0 == ToUUID ("a0b5b7c6-1318-441c-b0c9-fe695eaf949b"))) + { + If ((Arg1 == One)) + { + If ((Arg2 == Zero)) + { + Local0 = Buffer (One) + { + 0x03 /* . */ + } + Return (Local0) + } + + If ((Arg2 == One)) + { + Return (Local0) + } + } + } + + Local0 = Buffer (One) + { + 0x00 /* . */ + } + Return (Local0) + } + + Method (_ADR, 0, NotSerialized) // _ADR: Address + { + Return (HDAA) /* \HDAA */ + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + If ((HDAA == Zero)) + { + Return (Zero) + } + Else + { + Return (0x0F) + } + } + } + + Device (BAT0) + { + Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID + Name (_UID, Zero) // _UID: Unique ID + Scope (\_GPE) + { + Method (_L00, 0, NotSerialized) // _Lxx: Level-Triggered GPE + { + Notify (\_SB.PCI0.BAT0, 0x80) // Status Change + Notify (\_SB.PCI0.AC, 0x80) // Status Change + } + } + + OperationRegion (CBAT, SystemIO, 0x4040, 0x08) + Field (CBAT, DWordAcc, NoLock, Preserve) + { + IDX0, 32, + DAT0, 32 + } + + IndexField (IDX0, DAT0, DWordAcc, NoLock, Preserve) + { + STAT, 32, + PRAT, 32, + RCAP, 32, + PVOL, 32, + UNIT, 32, + DCAP, 32, + LFCP, 32, + BTEC, 32, + DVOL, 32, + DWRN, 32, + DLOW, 32, + GRN1, 32, + GRN2, 32, + BSTA, 32, + APSR, 32 + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (BSTA) /* \_SB_.PCI0.BAT0.BSTA */ + } + + Name (PBIF, Package (0x0D) + { + One, + 0x7FFFFFFF, + 0x7FFFFFFF, + Zero, + 0xFFFFFFFF, + Zero, + Zero, + 0x04, + 0x04, + "1", + "0", + "VBOX", + "innotek" + }) + Name (PBST, Package (0x04) + { + Zero, + 0x7FFFFFFF, + 0x7FFFFFFF, + 0x7FFFFFFF + }) + Method (_BIF, 0, NotSerialized) // _BIF: Battery Information + { + PBIF [Zero] = UNIT /* \_SB_.PCI0.BAT0.UNIT */ + PBIF [One] = DCAP /* \_SB_.PCI0.BAT0.DCAP */ + PBIF [0x02] = LFCP /* \_SB_.PCI0.BAT0.LFCP */ + PBIF [0x03] = BTEC /* \_SB_.PCI0.BAT0.BTEC */ + PBIF [0x04] = DVOL /* \_SB_.PCI0.BAT0.DVOL */ + PBIF [0x05] = DWRN /* \_SB_.PCI0.BAT0.DWRN */ + PBIF [0x06] = DLOW /* \_SB_.PCI0.BAT0.DLOW */ + PBIF [0x07] = GRN1 /* \_SB_.PCI0.BAT0.GRN1 */ + PBIF [0x08] = GRN2 /* \_SB_.PCI0.BAT0.GRN2 */ + DBG ("_BIF:\n") + HEX4 (DerefOf (PBIF [Zero])) + HEX4 (DerefOf (PBIF [One])) + HEX4 (DerefOf (PBIF [0x02])) + HEX4 (DerefOf (PBIF [0x03])) + HEX4 (DerefOf (PBIF [0x04])) + HEX4 (DerefOf (PBIF [0x05])) + HEX4 (DerefOf (PBIF [0x06])) + HEX4 (DerefOf (PBIF [0x07])) + HEX4 (DerefOf (PBIF [0x08])) + Return (PBIF) /* \_SB_.PCI0.BAT0.PBIF */ + } + + Method (_BST, 0, NotSerialized) // _BST: Battery Status + { + PBST [Zero] = STAT /* \_SB_.PCI0.BAT0.STAT */ + PBST [One] = PRAT /* \_SB_.PCI0.BAT0.PRAT */ + PBST [0x02] = RCAP /* \_SB_.PCI0.BAT0.RCAP */ + PBST [0x03] = PVOL /* \_SB_.PCI0.BAT0.PVOL */ + Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ + } + } + + Device (AC) + { + Name (_HID, "ACPI0003" /* Power Source Device */) // _HID: Hardware ID + Name (_UID, Zero) // _UID: Unique ID + Name (_PCL, Package (0x01) // _PCL: Power Consumer List + { + _SB + }) + Method (_PSR, 0, NotSerialized) // _PSR: Power Source + { + Return (^^BAT0.APSR) /* \_SB_.PCI0.BAT0.APSR */ + } + + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + } + } + } + + Scope (_SB) + { + Scope (PCI0) + { + Name (CRS, ResourceTemplate () + { + WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, + 0x0000, // Granularity + 0x0000, // Range Minimum + 0x00FF, // Range Maximum + 0x0000, // Translation Offset + 0x0100, // Length + ,, ) + IO (Decode16, + 0x0CF8, // Range Minimum + 0x0CF8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + ) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000, // Granularity + 0x0000, // Range Minimum + 0x0CF7, // Range Maximum + 0x0000, // Translation Offset + 0x0CF8, // Length + ,, , TypeStatic) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000, // Granularity + 0x0D00, // Range Minimum + 0xFFFF, // Range Maximum + 0x0000, // Translation Offset + 0xF300, // Length + ,, , TypeStatic) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, // Granularity + 0x000A0000, // Range Minimum + 0x000BFFFF, // Range Maximum + 0x00000000, // Translation Offset + 0x00020000, // Length + ,, , AddressRangeMemory, TypeStatic) + DWordMemory (ResourceProducer, PosDecode, MinNotFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, // Granularity + 0x00000000, // Range Minimum + 0xFFDFFFFF, // Range Maximum + 0x00000000, // Translation Offset + 0x00000000, // Length + ,, _Y0D, AddressRangeMemory, TypeStatic) + }) + Name (TOM, ResourceTemplate () + { + QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Prefetchable, ReadWrite, + 0x0000000000000000, // Granularity + 0x0000000100000000, // Range Minimum + 0x0000000FFFFFFFFF, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x0000000F00000000, // Length + ,, _Y0E, AddressRangeMemory, TypeStatic) + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + CreateDWordField (CRS, \_SB.PCI0._Y0D._MIN, RAMT) // _MIN: Minimum Base Address + CreateDWordField (CRS, \_SB.PCI0._Y0D._LEN, RAMR) // _LEN: Length + RAMT = MEML /* \MEML */ + RAMR = (0xFFE00000 - RAMT) /* \_SB_.PCI0._CRS.RAMT */ + If ((PMNN != Zero)) + { + If (((MSWN () < One) || (MSWN () > 0x06))) + { + CreateQWordField (TOM, \_SB.PCI0._Y0E._MIN, TM4N) // _MIN: Minimum Base Address + CreateQWordField (TOM, \_SB.PCI0._Y0E._MAX, TM4X) // _MAX: Maximum Base Address + CreateQWordField (TOM, \_SB.PCI0._Y0E._LEN, TM4L) // _LEN: Length + TM4N = (PMNN * 0x00010000) + TM4X = ((PMNX * 0x00010000) - One) + TM4L = ((TM4X - TM4N) + One) + ConcatenateResTemplate (CRS, TOM, Local2) + Return (Local2) + } + } + + Return (CRS) /* \_SB_.PCI0.CRS_ */ + } + } + } + + Scope (_SB) + { + Field (PCI0.SBRG.PCIC, ByteAcc, NoLock, Preserve) + { + Offset (0x60), + PIRA, 8, + PIRB, 8, + PIRC, 8, + PIRD, 8 + } + + Name (BUFA, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared, ) + {15} + }) + CreateWordField (BUFA, One, ICRS) + Method (LSTA, 1, NotSerialized) + { + Local0 = (Arg0 & 0x80) + If (Local0) + { + Return (0x09) + } + Else + { + Return (0x0B) + } + } + + Method (LCRS, 1, NotSerialized) + { + Local0 = (Arg0 & 0x0F) + ICRS = (One << Local0) + Return (BUFA) /* \_SB_.BUFA */ + } + + Method (LSRS, 1, NotSerialized) + { + CreateWordField (Arg0, One, ISRS) + FindSetRightBit (ISRS, Local0) + Return (Local0--) + } + + Method (LDIS, 1, NotSerialized) + { + Return ((Arg0 | 0x80)) + } + + Device (LNKA) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID + Name (_UID, One) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + DBG ("LNKA._STA\n") + Return (LSTA (PIRA)) + } + + Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings + { + DBG ("LNKA._PRS\n") + Return (PRSA) /* \_SB_.PRSA */ + } + + Method (_DIS, 0, NotSerialized) // _DIS: Disable Device + { + DBG ("LNKA._DIS\n") + PIRA = LDIS (PIRA) + } + + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + DBG ("LNKA._CRS\n") + Return (LCRS (PIRA)) + } + + Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings + { + DBG ("LNKA._SRS: ") + HEX (LSRS (Arg0)) + PIRA = LSRS (Arg0) + } + } + + Device (LNKB) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID + Name (_UID, 0x02) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (LSTA (PIRB)) + } + + Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings + { + Return (PRSB) /* \_SB_.PRSB */ + } + + Method (_DIS, 0, NotSerialized) // _DIS: Disable Device + { + PIRB = LDIS (PIRB) + } + + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (LCRS (PIRB)) + } + + Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings + { + DBG ("LNKB._SRS: ") + HEX (LSRS (Arg0)) + PIRB = LSRS (Arg0) + } + } + + Device (LNKC) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID + Name (_UID, 0x03) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (LSTA (PIRC)) + } + + Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings + { + Return (PRSC) /* \_SB_.PRSC */ + } + + Method (_DIS, 0, NotSerialized) // _DIS: Disable Device + { + PIRC = LDIS (PIRC) + } + + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (LCRS (PIRC)) + } + + Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings + { + DBG ("LNKC._SRS: ") + HEX (LSRS (Arg0)) + PIRC = LSRS (Arg0) + } + } + + Device (LNKD) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID + Name (_UID, 0x04) // _UID: Unique ID + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (LSTA (PIRD)) + } + + Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings + { + Return (PRSD) /* \_SB_.PRSD */ + } + + Method (_DIS, 0, NotSerialized) // _DIS: Disable Device + { + PIRD = LDIS (PIRA) + } + + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (LCRS (PIRD)) + } + + Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings + { + DBG ("LNKD._SRS: ") + HEX (LSRS (Arg0)) + PIRD = LSRS (Arg0) + } + } + } + + Name (_S0, Package (0x02) // _S0_: S0 System State + { + Zero, + Zero + }) + If ((PWRS & 0x02)) + { + Name (_S1, Package (0x02) // _S1_: S1 System State + { + One, + One + }) + } + + If ((PWRS & 0x10)) + { + Name (_S4, Package (0x02) // _S4_: S4 System State + { + 0x05, + 0x05 + }) + } + + Name (_S5, Package (0x02) // _S5_: S5 System State + { + 0x05, + 0x05 + }) + Method (_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep + { + DBG ("Prepare to sleep: ") + HEX (Arg0) + } +} + diff --git a/src/gopheros/device/acpi/table/tabletest/SSDT.dsl b/src/gopheros/device/acpi/table/tabletest/SSDT.dsl new file mode 100644 index 0000000..3b29644 --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/SSDT.dsl @@ -0,0 +1,431 @@ +/* + * Intel ACPI Component Architecture + * AML/ASL+ Disassembler version 20180105 (64-bit version) + * Copyright (c) 2000 - 2018 Intel Corporation + * + * Disassembling to symbolic ASL+ operators + * + * Disassembly of SSDT.aml, Tue Jan 30 08:22:57 2018 + * + * Original Table Header: + * Signature "SSDT" + * Length 0x000001CC (460) + * Revision 0x01 + * Checksum 0x9D + * OEM ID "VBOX " + * OEM Table ID "VBOXCPUT" + * OEM Revision 0x00000002 (2) + * Compiler ID "INTL" + * Compiler Version 0x20100528 (537920808) + */ +DefinitionBlock ("", "SSDT", 1, "VBOX ", "VBOXCPUT", 0x00000002) +{ + Scope (\_PR) + { + Processor (CPU0, 0x00, 0x00000000, 0x00){} + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + Noop + } +} + diff --git a/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.aml b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.aml new file mode 100644 index 0000000000000000000000000000000000000000..c9f861784063f8904543121b2a225eafddde91f6 GIT binary patch literal 993 zcmYk5%Wl(95QgVCad3{~rWXrZ2}BXJTqLUFB;~S#y0(*uq>d7oLQh2;iAt^n$SP&g zT?>>VE@e@5iD*$+@&c@Q03HEV;sp?IU}hX4;l=#_e8>7_kH=2O34Ub&luFfa)!g== z`W*!T>I*?bW#f}_%dxA1=^%JkZtH2|)LcuG&!?RBU7>a7oOYtstXXg9`1{x6-^HKb zOubtTJm?b~uAf-xcI>X)3jCIp=b!`AI*u(yRIY4-+#V;cDukG-c@0NU!Tjx8gOicd zd}8k;FktvxOoPK$3?yXo6bl(u&*JSREu#))(3H^>6*LviEZ7a#%JHQ)t^IrH2=(9I1-)f-XCOQqKEg=EdeKrnfM8q+o1d#=dG zQiSntwP9Pm*m%5oHR?Ti_-GYEIZ2}m<(2S##9_&6h(o@Qu21&e09h$wgsis%R7#OT zsPtxl$|=eaDt{QDN{X_CDsl`NH_*{>HZ3rk_ff$J=IFh_psCHY=Ieq^ z92hMs{C^n6JPBhx!BR-@3gaOXy22R3n1wMK!}EQ7#Y;RN$;(miM{I1YKHUIm$i==Woo!=By%#LL_{22E7dp)^Tt^2rLQ@CJEZl6j!8YaV1Vvw^J?pRs5 zJ3$BJIaqLeoIVnLDT~RiPSbX>I@oD|tx@YTHP^v0Yq(IT7Ai+Ap(?0l)GTTRwSYQ{ zYM@@j-O)$UT&HasLvw?+$wYHgV*nk`!bnDnkqRkBW=JtIOIp$7>$Y1JG$0QQd#+7o z8RQFnzO^XWB*x_AORcrk7Wk9N9W_`MU31!N_)E&?GY8Syv*<8)5OMX>QSmUhzs8d< rM>*Qys2>fRgFk7f@F1wQo0{W#A{j2M{A(;Qiz_qKHG`UfK4*Uc8$I~} literal 0 HcmV?d00001 diff --git a/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.dsl b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.dsl new file mode 100644 index 0000000..f5a0ccf --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.dsl @@ -0,0 +1,255 @@ +// DSDT-parser-testsuite +// +// This file contains various ASL constructs to ensure that the AML parser +// properly handles all possible ASL opcodes it may encounter. This test file +// is used in addition to the DSDT.aml file obtained by running acpidump inside +// virtualbox. +DefinitionBlock ("parser-testsuite-DSDT.aml", "DSDT", 2, "GOPHER", "GOPHEROS", 0x00000002) +{ + OperationRegion (DBG0, SystemIO, 0x3000, 0x04) + Field (DBG0, ByteAcc, NoLock, Preserve) + { + DHE1, 8 + } + + Device (DRV0) + { + Name (_ADR, Ones) + + // named entity containing qword const + Name (H15F, 0xBADC0FEEDEADC0DE) + Method (_GTF, 0, NotSerialized) // _GTF: Get Task File + { + Return (H15F) + } + } + + // example from p. 268 of ACPI 6.2 spec + Scope(\_SB){ + OperationRegion(TOP1, GenericSerialBus, 0x00, 0x100) // GenericSerialBus device at command offset 0x00 + + Name (SDB0, ResourceTemplate() {}) + Field(TOP1, BufferAcc, NoLock, Preserve){ + Connection(SDB0), // Use the Resource Descriptor defined above + AccessAs(BufferAcc, AttribWord), + FLD0, 8, + FLD1, 8 + } + + Field(TOP1, BufferAcc, NoLock, Preserve){ + Connection(I2cSerialBus(0x5b,,100000,, "\\_SB",,,,RawDataBuffer(){3,9})), + AccessAs(BufferAcc, AttribBytes(4)), + FLD2, 8, + AccessAs(BufferAcc, AttribRawBytes(3)), + FLD3, 8, + AccessAs(BufferAcc, AttribRawProcessBytes(2)), + FLD4, 8 + } + } + + // Buffer whose size is given by a nested method invocation which is + // evaluated at load-time + Method(BLE1, 1, Serialized) + { + Return(Arg0 + 1) + } + + Name(BUFZ, Buffer(BLEN(BLE1(0xff), 0x0f)){0x48, 0x49, 0x21} ) + + Method(BLEN, 2, Serialized) + { + Return(Arg0 + Arg1 + 12) + } + + // Load time assignment + FET0 = 1 + + // A buffer whose length is given by a named object + Name(BUFL, One) + Name(BUFF, Buffer(BUFL){}) + + // Other entity types + Event(HLO0) + Mutex(MUT0,1) + Signal(HLO0) + + // Other executable bits + Method (EXE0, 1, Serialized) + { + // AML interpreter revision + Local0 = Revision + + // NameString target + Local1 = SizeOf(GLB1) + + Local0 = "my-handle" + Load(DBG0, Local0) + Unload(Local0) + + // CreateXXXField + CreateBitField(Arg0, 0, WFL0) + if(Arg0==0){ + Return(WFL0) + } + + CreateByteField(Arg0, 0, WFL1) + if(Arg0==1){ + Return(WFL1) + } + + CreateWordField(Arg0, 0, WFL2) + if(Arg0==2){ + Return(WFL2) + } + + CreateDwordField(Arg0, 0, WFL3) + if(Arg0==3){ + Return(WFL3) + } + + CreateQwordField(Arg0, 0, WFL4) + if(Arg0==4){ + Return(WFL4) + } + + CreateField(Arg0, 0, 13, WFL5) + if(Arg0==5){ + Return(WFL5) + } + + // Example from p. 951 of the spec + Store ( + LoadTable ("OEM1", "MYOEM", "TABLE1", "\\_SB.PCI0","MYD", Package () {0,"\\_SB.PCI0"}), + Local0 + ) + + // Various Assignments + Local0 = 0xff + Local0 = 0xffff + Local0 = 0xffffffff + Local0 = 0xffffffffffffffff + Local0 = Zero + Local0 = One + Local0 = Ones + Local0 = "FOO" + + // Conversions + FromBCD(9, Arg0) + ToBCD(Arg0, Local1) + + // Debugging and error handling + Breakpoint + Debug = "test" + Fatal(0xf0, 0xdeadc0de, 1) + + // Mutex support + Acquire(MUT0, 0xffff) // no timeout + Release(MUT0) + + // Signal/Wait + Reset(HLO0) + Wait(HLO0, 0xffff) + + // Get monotonic timer value + Local0 = Timer + + CopyObject(Local0, Local1) + Return(ObjectType(Local1)) + } + + // BankField example from p. 910 of the spec + // Define a 256-byte operational region in SystemIO space and name it GIO0 + OperationRegion (GIO0, SystemIO, 0x125, 0x100) + Field (GIO0, ByteAcc, NoLock, Preserve) { + GLB1, 1, + GLB2, 1, + Offset (1), // Move to offset for byte 1 + BNK1, 4 + } + + BankField (GIO0, BNK1, 0, ByteAcc, Lock, WriteAsOnes) { + Offset (0x30), + FET0, 1, + FET1, 1, + } + + // SMBus fields access types + OperationRegion(SMBD, SMBus, 0x4200, 0x100) + Field(SMBD, BufferAcc, NoLock, WriteAsZeros){ + AccessAs(BufferAcc, SMBByte), + SFL0, 8, + AccessAs(BufferAcc, SMBWord), + SFL1, 8, + AccessAs(BufferAcc, SMBBlock), + SFL2, 8, + AccessAs(BufferAcc, SMBQuick), + SFL3, 8, + AccessAs(BufferAcc, SMBSendReceive), + SFL4, 8, + AccessAs(BufferAcc, SMBProcessCall), + SFL5, 8, + AccessAs(BufferAcc, SMBBlockProcessCall), + SFL6, 8, + AccessAs(BufferAcc, AttribBytes(0x12)), + SFL7, 8, + AccessAs(BufferAcc, AttribRawBytes(0x13)), + SFL8, 8, + AccessAs(BufferAcc, AttribRawProcessBytes(0x14)), + SFL9, 8, + // + AccessAs(AnyAcc), + SF10, 8, + AccessAs(ByteAcc), + SF11, 8, + AccessAs(WordAcc), + SF12, 8, + AccessAs(DwordAcc), + SF13, 8, + AccessAs(QwordAcc), + SF14, 8, + } + + // Data Region + DataTableRegion (REG0, "FOOF", "BAR", "BAZ") + + // Other resources + Processor(CPU0, 1, 0x120, 6){} + PowerResource(PWR0, 0, 0){} + ThermalZone(TZ0){} + + // Method with various logic/flow changing opcodes + Method (FLOW, 2, NotSerialized) + { + While(Arg0 < Arg1) + { + Arg0++ + + If( Arg0 < 5 ) { + Continue + } Else { + If ( Arg1 == 0xff ) { + Break + } Else { + Arg0 = Arg0 + 1 + } + } + } + + Return(Arg0) + } + + // Forward declaration to SCP0 + Scope(\_SB) { + ThermalZone(^THRM){ + Name(DEF0, Ones) + } + } + + Scope(\THRM){ + Name(DEF1, Zero) + } + + Method(\THRM.MTH0, 0, NotSerialized){ + Return(1) + } +} diff --git a/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.exp b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.exp new file mode 100644 index 0000000..88e1cd7 --- /dev/null +++ b/src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.exp @@ -0,0 +1,346 @@ + +- [ScopeBlock, name: "\", table: 42, index: 0, offset: 0x0] + +- [ScopeBlock, name: "_GPE", table: 42, index: 1, offset: 0x0] + +- [ScopeBlock, name: "_PR_", table: 42, index: 2, offset: 0x0] + +- [ScopeBlock, name: "_SB_", table: 42, index: 3, offset: 0x0] + | +- [OpRegion, name: "TOP1", table: 0, index: 33, offset: 0x6c] + | | +- [NamePath, table: 0, index: 34, offset: 0x6e] -> [namepath: "TOP1"] + | | +- [BytePrefix, table: 0, index: 35, offset: 0x72] -> [num value; dec: 9, hex: 0x9] + | | +- [BytePrefix, table: 0, index: 36, offset: 0x73] -> [num value; dec: 0, hex: 0x0] + | | +- [WordPrefix, table: 0, index: 37, offset: 0x75] -> [num value; dec: 256, hex: 0x100] + | +- [Name, name: "SDB0", table: 0, index: 38, offset: 0x78] + | | +- [NamePath, table: 0, index: 39, offset: 0x79] -> [namepath: "SDB0"] + | | +- [Buffer, table: 0, index: 40, offset: 0x7d] + | | +- [BytePrefix, table: 0, index: 316, offset: 0x7f] -> [num value; dec: 2, hex: 0x2] + | | +- [ByteList, table: 0, index: 318, offset: 0x3cb] -> [bytelist value; len: 2; data: [0x79, 0x0]] + | +- [Field, table: 0, index: 41, offset: 0x83] + | | +- [NamePath, table: 0, index: 42, offset: 0x86] -> [namepath: "TOP1"] + | | +- [BytePrefix, table: 0, index: 43, offset: 0x8a] -> [num value; dec: 5, hex: 0x5] + | | +- [Connection, table: 0, index: 44, offset: 0x0] + | | +- [NamePath, table: 0, index: 45, offset: 0x8c] -> [namepath: "SDB0"] + | +- [NamedField, name: "FLD0", table: 0, index: 46, offset: 0x93] -> [field index: 41, offset(bytes): 0x0, width(bits): 0x8, accType: Buffer, accAttr: Word, lockType: NoLock, updateType: Preserve, connection: index 44] + | +- [NamedField, name: "FLD1", table: 0, index: 47, offset: 0x98] -> [field index: 41, offset(bytes): 0x8, width(bits): 0x8, accType: Buffer, accAttr: Word, lockType: NoLock, updateType: Preserve, connection: index 44] + | +- [Field, table: 0, index: 48, offset: 0x9d] + | | +- [NamePath, table: 0, index: 49, offset: 0xa0] -> [namepath: "TOP1"] + | | +- [BytePrefix, table: 0, index: 50, offset: 0xa4] -> [num value; dec: 5, hex: 0x5] + | | +- [Connection, table: 0, index: 51, offset: 0x0] + | | +- [ByteList, table: 0, index: 52, offset: 0xa7] -> [bytelist value; len: 25; data: [0x8e, 0x16, 0x0, 0x1, 0x0, 0x1, 0x2, 0x0, 0x0, 0x1, 0x8, 0x0, 0xa0, 0x86, 0x1, 0x0, 0x5b, 0x0, 0x3, 0x9, 0x5c, 0x5f, 0x53, 0x42, 0x0]] + | +- [NamedField, name: "FLD2", table: 0, index: 53, offset: 0xc7] -> [field index: 48, offset(bytes): 0x0, width(bits): 0x8, accType: Buffer, accAttr: Bytes(0x4), lockType: NoLock, updateType: Preserve, connection: index 51] + | +- [NamedField, name: "FLD3", table: 0, index: 54, offset: 0xd0] -> [field index: 48, offset(bytes): 0x8, width(bits): 0x8, accType: Buffer, accAttr: RawBytes(0x3), lockType: NoLock, updateType: Preserve, connection: index 51] + | +- [NamedField, name: "FLD4", table: 0, index: 55, offset: 0xd9] -> [field index: 48, offset(bytes): 0x10, width(bits): 0x8, accType: Buffer, accAttr: RawProcessBytes(0x2), lockType: NoLock, updateType: Preserve, connection: index 51] + +- [ScopeBlock, name: "_SI_", table: 42, index: 4, offset: 0x0] + +- [ScopeBlock, name: "_TZ_", table: 42, index: 5, offset: 0x0] + +- [OpRegion, name: "DBG0", table: 0, index: 6, offset: 0x24] + | +- [NamePath, table: 0, index: 7, offset: 0x26] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 8, offset: 0x2a] -> [num value; dec: 1, hex: 0x1] + | +- [WordPrefix, table: 0, index: 9, offset: 0x2b] -> [num value; dec: 12288, hex: 0x3000] + | +- [BytePrefix, table: 0, index: 10, offset: 0x2e] -> [num value; dec: 4, hex: 0x4] + +- [Field, table: 0, index: 11, offset: 0x30] + | +- [NamePath, table: 0, index: 12, offset: 0x33] -> [namepath: "DBG0"] + | +- [BytePrefix, table: 0, index: 13, offset: 0x37] -> [num value; dec: 1, hex: 0x1] + +- [NamedField, name: "DHE1", table: 0, index: 14, offset: 0x38] -> [field index: 11, offset(bytes): 0x0, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [Device, name: "DRV0", table: 0, index: 15, offset: 0x3d] + | +- [NamePath, table: 0, index: 16, offset: 0x40] -> [namepath: "DRV0"] + | +- [ScopeBlock, table: 0, index: 17, offset: 0x44] + | +- [Name, name: "_ADR", table: 0, index: 18, offset: 0x44] + | | +- [NamePath, table: 0, index: 19, offset: 0x45] -> [namepath: "_ADR"] + | | +- [Ones, table: 0, index: 20, offset: 0x49] + | +- [Name, name: "H15F", table: 0, index: 21, offset: 0x4a] + | | +- [NamePath, table: 0, index: 22, offset: 0x4b] -> [namepath: "H15F"] + | | +- [QwordPrefix, table: 0, index: 23, offset: 0x4f] -> [num value; dec: 13464654504543502558, hex: 0xbadc0feedeadc0de] + | +- [Method, name: "_GTF", argCount: 0, table: 0, index: 24, offset: 0x58] + | +- [NamePath, table: 0, index: 25, offset: 0x5a] -> [namepath: "_GTF"] + | +- [BytePrefix, table: 0, index: 26, offset: 0x5e] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 27, offset: 0x5f] + | +- [Return, table: 0, index: 28, offset: 0x5f] + | +- [ResolvedNamePath, table: 0, index: 29, offset: 0x60] -> [resolved to "H15F", table: 0, index: 21, offset: 0x4a] + +- [Method, name: "BLE1", argCount: 1, table: 0, index: 56, offset: 0xde] + | +- [NamePath, table: 0, index: 57, offset: 0xe0] -> [namepath: "BLE1"] + | +- [BytePrefix, table: 0, index: 58, offset: 0xe4] -> [num value; dec: 9, hex: 0x9] + | +- [ScopeBlock, table: 0, index: 59, offset: 0xe5] + | +- [Return, table: 0, index: 60, offset: 0xe5] + | +- [Add, table: 0, index: 61, offset: 0xe6] + | +- [Arg0, table: 0, index: 62, offset: 0xe7] + | +- [BytePrefix, table: 0, index: 63, offset: 0xe8] -> [num value; dec: 1, hex: 0x1] + | +- [Zero, table: 0, index: 64, offset: 0xea] + +- [Name, name: "BUFZ", table: 0, index: 65, offset: 0xeb] + | +- [NamePath, table: 0, index: 66, offset: 0xec] -> [namepath: "BUFZ"] + | +- [Buffer, table: 0, index: 67, offset: 0xf0] + | +- [MethodCall, table: 0, index: 317, offset: 0xf2] -> [call to "BLEN", argCount: 2, table: 0, index: 68, offset: 0x101] + | | +- [MethodCall, table: 0, index: 307, offset: 0xf6] -> [call to "BLE1", argCount: 1, table: 0, index: 56, offset: 0xde] + | | | +- [BytePrefix, table: 0, index: 309, offset: 0xfa] -> [num value; dec: 255, hex: 0xff] + | | +- [BytePrefix, table: 0, index: 308, offset: 0xfc] -> [num value; dec: 15, hex: 0xf] + | +- [ByteList, table: 0, index: 30, offset: 0x64] -> [bytelist value; len: 3; data: [0x48, 0x49, 0x21]] + +- [Method, name: "BLEN", argCount: 2, table: 0, index: 68, offset: 0x101] + | +- [NamePath, table: 0, index: 69, offset: 0x103] -> [namepath: "BLEN"] + | +- [BytePrefix, table: 0, index: 70, offset: 0x107] -> [num value; dec: 10, hex: 0xa] + | +- [ScopeBlock, table: 0, index: 71, offset: 0x108] + | +- [Return, table: 0, index: 72, offset: 0x108] + | +- [Add, table: 0, index: 73, offset: 0x109] + | +- [Add, table: 0, index: 74, offset: 0x10a] + | | +- [Arg0, table: 0, index: 75, offset: 0x10b] + | | +- [Arg1, table: 0, index: 76, offset: 0x10c] + | | +- [Zero, table: 0, index: 77, offset: 0x10d] + | +- [BytePrefix, table: 0, index: 78, offset: 0x10e] -> [num value; dec: 12, hex: 0xc] + | +- [Zero, table: 0, index: 79, offset: 0x110] + +- [Store, table: 0, index: 80, offset: 0x111] + | +- [BytePrefix, table: 0, index: 81, offset: 0x112] -> [num value; dec: 1, hex: 0x1] + | +- [ResolvedNamePath, table: 0, index: 82, offset: 0x114] -> [resolved to "FET0", table: 0, index: 332, offset: 0x2b9] + +- [Name, name: "BUFL", table: 0, index: 83, offset: 0x118] + | +- [NamePath, table: 0, index: 84, offset: 0x119] -> [namepath: "BUFL"] + | +- [One, table: 0, index: 85, offset: 0x11d] + +- [Name, name: "BUFF", table: 0, index: 86, offset: 0x11e] + | +- [NamePath, table: 0, index: 87, offset: 0x11f] -> [namepath: "BUFF"] + | +- [Buffer, table: 0, index: 88, offset: 0x123] + | +- [ResolvedNamePath, table: 0, index: 32, offset: 0x125] -> [resolved to "BUFL", table: 0, index: 83, offset: 0x118] + | +- [ByteList, table: 0, index: 31, offset: 0x67] -> [bytelist value; len: 0; data: []] + +- [Event, name: "HLO0", table: 0, index: 89, offset: 0x129] + | +- [NamePath, table: 0, index: 90, offset: 0x12b] -> [namepath: "HLO0"] + +- [Mutex, name: "MUT0", table: 0, index: 91, offset: 0x12f] + | +- [NamePath, table: 0, index: 92, offset: 0x131] -> [namepath: "MUT0"] + | +- [BytePrefix, table: 0, index: 93, offset: 0x135] -> [num value; dec: 1, hex: 0x1] + +- [Signal, table: 0, index: 94, offset: 0x136] + | +- [ResolvedNamePath, table: 0, index: 95, offset: 0x138] -> [resolved to "HLO0", table: 0, index: 89, offset: 0x129] + +- [Method, name: "EXE0", argCount: 1, table: 0, index: 96, offset: 0x13c] + | +- [NamePath, table: 0, index: 97, offset: 0x13f] -> [namepath: "EXE0"] + | +- [BytePrefix, table: 0, index: 98, offset: 0x143] -> [num value; dec: 9, hex: 0x9] + | +- [ScopeBlock, table: 0, index: 99, offset: 0x144] + | +- [Store, table: 0, index: 100, offset: 0x144] + | | +- [Revision, table: 0, index: 101, offset: 0x145] + | | +- [Local0, table: 0, index: 102, offset: 0x147] + | +- [Store, table: 0, index: 103, offset: 0x148] + | | +- [SizeOf, table: 0, index: 104, offset: 0x149] + | | | +- [NamePath, table: 0, index: 105, offset: 0x14a] -> [namepath: "GLB1"] + | | +- [Local1, table: 0, index: 106, offset: 0x14e] + | +- [Store, table: 0, index: 107, offset: 0x14f] + | | +- [StringPrefix, table: 0, index: 108, offset: 0x150] -> [string value: "my-handle"] + | | +- [Local0, table: 0, index: 109, offset: 0x15b] + | +- [Load, table: 0, index: 110, offset: 0x15c] + | | +- [NamePath, table: 0, index: 111, offset: 0x15e] -> [namepath: "DBG0"] + | | +- [Local0, table: 0, index: 112, offset: 0x162] + | +- [Unload, table: 0, index: 113, offset: 0x163] + | | +- [Local0, table: 0, index: 114, offset: 0x165] + | +- [CreateBitField, table: 0, index: 115, offset: 0x166] + | | +- [Arg0, table: 0, index: 116, offset: 0x167] + | | +- [BytePrefix, table: 0, index: 117, offset: 0x168] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 118, offset: 0x16a] -> [namepath: "WFL0"] + | +- [If, table: 0, index: 119, offset: 0x16e] + | | +- [LEqual, table: 0, index: 120, offset: 0x170] + | | | +- [Arg0, table: 0, index: 121, offset: 0x171] + | | | +- [BytePrefix, table: 0, index: 122, offset: 0x172] -> [num value; dec: 0, hex: 0x0] + | | +- [Return, table: 0, index: 123, offset: 0x174] + | | +- [NamePath, table: 0, index: 124, offset: 0x175] -> [namepath: "WFL0"] + | +- [CreateByteField, table: 0, index: 125, offset: 0x179] + | | +- [Arg0, table: 0, index: 126, offset: 0x17a] + | | +- [BytePrefix, table: 0, index: 127, offset: 0x17b] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 128, offset: 0x17d] -> [namepath: "WFL1"] + | +- [If, table: 0, index: 129, offset: 0x181] + | | +- [LEqual, table: 0, index: 130, offset: 0x183] + | | | +- [Arg0, table: 0, index: 131, offset: 0x184] + | | | +- [BytePrefix, table: 0, index: 132, offset: 0x185] -> [num value; dec: 1, hex: 0x1] + | | +- [Return, table: 0, index: 133, offset: 0x187] + | | +- [NamePath, table: 0, index: 134, offset: 0x188] -> [namepath: "WFL1"] + | +- [CreateWordField, table: 0, index: 135, offset: 0x18c] + | | +- [Arg0, table: 0, index: 136, offset: 0x18d] + | | +- [BytePrefix, table: 0, index: 137, offset: 0x18e] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 138, offset: 0x190] -> [namepath: "WFL2"] + | +- [If, table: 0, index: 139, offset: 0x194] + | | +- [LEqual, table: 0, index: 140, offset: 0x196] + | | | +- [Arg0, table: 0, index: 141, offset: 0x197] + | | | +- [BytePrefix, table: 0, index: 142, offset: 0x198] -> [num value; dec: 2, hex: 0x2] + | | +- [Return, table: 0, index: 143, offset: 0x19a] + | | +- [NamePath, table: 0, index: 144, offset: 0x19b] -> [namepath: "WFL2"] + | +- [CreateDWordField, table: 0, index: 145, offset: 0x19f] + | | +- [Arg0, table: 0, index: 146, offset: 0x1a0] + | | +- [BytePrefix, table: 0, index: 147, offset: 0x1a1] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 148, offset: 0x1a3] -> [namepath: "WFL3"] + | +- [If, table: 0, index: 149, offset: 0x1a7] + | | +- [LEqual, table: 0, index: 150, offset: 0x1a9] + | | | +- [Arg0, table: 0, index: 151, offset: 0x1aa] + | | | +- [BytePrefix, table: 0, index: 152, offset: 0x1ab] -> [num value; dec: 3, hex: 0x3] + | | +- [Return, table: 0, index: 153, offset: 0x1ad] + | | +- [NamePath, table: 0, index: 154, offset: 0x1ae] -> [namepath: "WFL3"] + | +- [CreateQWordField, table: 0, index: 155, offset: 0x1b2] + | | +- [Arg0, table: 0, index: 156, offset: 0x1b3] + | | +- [BytePrefix, table: 0, index: 157, offset: 0x1b4] -> [num value; dec: 0, hex: 0x0] + | | +- [NamePath, table: 0, index: 158, offset: 0x1b6] -> [namepath: "WFL4"] + | +- [If, table: 0, index: 159, offset: 0x1ba] + | | +- [LEqual, table: 0, index: 160, offset: 0x1bc] + | | | +- [Arg0, table: 0, index: 161, offset: 0x1bd] + | | | +- [BytePrefix, table: 0, index: 162, offset: 0x1be] -> [num value; dec: 4, hex: 0x4] + | | +- [Return, table: 0, index: 163, offset: 0x1c0] + | | +- [NamePath, table: 0, index: 164, offset: 0x1c1] -> [namepath: "WFL4"] + | +- [CreateField, table: 0, index: 165, offset: 0x1c5] + | | +- [Arg0, table: 0, index: 166, offset: 0x1c7] + | | +- [BytePrefix, table: 0, index: 167, offset: 0x1c8] -> [num value; dec: 0, hex: 0x0] + | | +- [BytePrefix, table: 0, index: 168, offset: 0x1ca] -> [num value; dec: 13, hex: 0xd] + | | +- [NamePath, table: 0, index: 169, offset: 0x1cc] -> [namepath: "WFL5"] + | +- [If, table: 0, index: 170, offset: 0x1d0] + | | +- [LEqual, table: 0, index: 171, offset: 0x1d2] + | | | +- [Arg0, table: 0, index: 172, offset: 0x1d3] + | | | +- [BytePrefix, table: 0, index: 173, offset: 0x1d4] -> [num value; dec: 5, hex: 0x5] + | | +- [Return, table: 0, index: 174, offset: 0x1d6] + | | +- [NamePath, table: 0, index: 175, offset: 0x1d7] -> [namepath: "WFL5"] + | +- [Store, table: 0, index: 176, offset: 0x1db] + | | +- [LoadTable, table: 0, index: 177, offset: 0x1dc] + | | | +- [StringPrefix, table: 0, index: 178, offset: 0x1de] -> [string value: "OEM1"] + | | | +- [StringPrefix, table: 0, index: 179, offset: 0x1e4] -> [string value: "MYOEM"] + | | | +- [StringPrefix, table: 0, index: 180, offset: 0x1eb] -> [string value: "TABLE1"] + | | | +- [StringPrefix, table: 0, index: 181, offset: 0x1f3] -> [string value: "\_SB.PCI0"] + | | | +- [StringPrefix, table: 0, index: 182, offset: 0x1fe] -> [string value: "MYD"] + | | | +- [Package, table: 0, index: 183, offset: 0x203] + | | | | +- [BytePrefix, table: 0, index: 184, offset: 0x205] -> [num value; dec: 2, hex: 0x2] + | | | | +- [ScopeBlock, table: 0, index: 185, offset: 0x206] + | | | | +- [BytePrefix, table: 0, index: 186, offset: 0x206] -> [num value; dec: 0, hex: 0x0] + | | | | +- [StringPrefix, table: 0, index: 187, offset: 0x208] -> [string value: "\_SB.PCI0"] + | | | +- [Local0, table: 0, index: 188, offset: 0x213] + | | +- [Store, table: 0, index: 189, offset: 0x214] + | | +- [BytePrefix, table: 0, index: 190, offset: 0x215] -> [num value; dec: 255, hex: 0xff] + | | +- [Local0, table: 0, index: 191, offset: 0x217] + | +- [Store, table: 0, index: 192, offset: 0x218] + | | +- [WordPrefix, table: 0, index: 193, offset: 0x219] -> [num value; dec: 65535, hex: 0xffff] + | | +- [Local0, table: 0, index: 194, offset: 0x21c] + | +- [Store, table: 0, index: 195, offset: 0x21d] + | | +- [DwordPrefix, table: 0, index: 196, offset: 0x21e] -> [num value; dec: 4294967295, hex: 0xffffffff] + | | +- [Local0, table: 0, index: 197, offset: 0x223] + | +- [Store, table: 0, index: 198, offset: 0x224] + | | +- [QwordPrefix, table: 0, index: 199, offset: 0x225] -> [num value; dec: 18446744073709551615, hex: 0xffffffffffffffff] + | | +- [Local0, table: 0, index: 200, offset: 0x22e] + | +- [Store, table: 0, index: 201, offset: 0x22f] + | | +- [Zero, table: 0, index: 202, offset: 0x230] + | | +- [Local0, table: 0, index: 203, offset: 0x231] + | +- [Store, table: 0, index: 204, offset: 0x232] + | | +- [One, table: 0, index: 205, offset: 0x233] + | | +- [Local0, table: 0, index: 206, offset: 0x234] + | +- [Store, table: 0, index: 207, offset: 0x235] + | | +- [Ones, table: 0, index: 208, offset: 0x236] + | | +- [Local0, table: 0, index: 209, offset: 0x237] + | +- [Store, table: 0, index: 210, offset: 0x238] + | | +- [StringPrefix, table: 0, index: 211, offset: 0x239] -> [string value: "FOO"] + | | +- [Local0, table: 0, index: 212, offset: 0x23e] + | +- [FromBCD, table: 0, index: 213, offset: 0x23f] + | | +- [BytePrefix, table: 0, index: 214, offset: 0x241] -> [num value; dec: 9, hex: 0x9] + | | +- [Arg0, table: 0, index: 215, offset: 0x243] + | +- [ToBCD, table: 0, index: 216, offset: 0x244] + | | +- [Arg0, table: 0, index: 217, offset: 0x246] + | | +- [Local1, table: 0, index: 218, offset: 0x247] + | +- [BreakPoint, table: 0, index: 219, offset: 0x248] + | +- [Store, table: 0, index: 220, offset: 0x249] + | | +- [StringPrefix, table: 0, index: 221, offset: 0x24a] -> [string value: "test"] + | | +- [Debug, table: 0, index: 222, offset: 0x250] + | +- [Fatal, table: 0, index: 223, offset: 0x252] + | | +- [BytePrefix, table: 0, index: 224, offset: 0x254] -> [num value; dec: 240, hex: 0xf0] + | | +- [DwordPrefix, table: 0, index: 225, offset: 0x255] -> [num value; dec: 3735929054, hex: 0xdeadc0de] + | | +- [BytePrefix, table: 0, index: 226, offset: 0x259] -> [num value; dec: 1, hex: 0x1] + | +- [Acquire, table: 0, index: 227, offset: 0x25b] + | | +- [NamePath, table: 0, index: 228, offset: 0x25d] -> [namepath: "MUT0"] + | | +- [WordPrefix, table: 0, index: 229, offset: 0x261] -> [num value; dec: 65535, hex: 0xffff] + | +- [Release, table: 0, index: 230, offset: 0x263] + | | +- [NamePath, table: 0, index: 231, offset: 0x265] -> [namepath: "MUT0"] + | +- [Reset, table: 0, index: 232, offset: 0x269] + | | +- [NamePath, table: 0, index: 233, offset: 0x26b] -> [namepath: "HLO0"] + | +- [Wait, table: 0, index: 234, offset: 0x26f] + | | +- [NamePath, table: 0, index: 235, offset: 0x271] -> [namepath: "HLO0"] + | | +- [WordPrefix, table: 0, index: 236, offset: 0x275] -> [num value; dec: 65535, hex: 0xffff] + | +- [Store, table: 0, index: 237, offset: 0x278] + | | +- [Timer, table: 0, index: 238, offset: 0x279] + | | +- [Local0, table: 0, index: 239, offset: 0x27b] + | +- [CopyObject, table: 0, index: 240, offset: 0x27c] + | | +- [Local0, table: 0, index: 241, offset: 0x27d] + | | +- [Local1, table: 0, index: 242, offset: 0x27e] + | +- [Return, table: 0, index: 243, offset: 0x27f] + | +- [ObjectType, table: 0, index: 244, offset: 0x280] + | +- [Local1, table: 0, index: 245, offset: 0x281] + +- [OpRegion, name: "GIO0", table: 0, index: 246, offset: 0x282] + | +- [NamePath, table: 0, index: 247, offset: 0x284] -> [namepath: "GIO0"] + | +- [BytePrefix, table: 0, index: 248, offset: 0x288] -> [num value; dec: 1, hex: 0x1] + | +- [WordPrefix, table: 0, index: 249, offset: 0x289] -> [num value; dec: 293, hex: 0x125] + | +- [WordPrefix, table: 0, index: 250, offset: 0x28c] -> [num value; dec: 256, hex: 0x100] + +- [Field, table: 0, index: 251, offset: 0x28f] + | +- [NamePath, table: 0, index: 252, offset: 0x292] -> [namepath: "GIO0"] + | +- [BytePrefix, table: 0, index: 253, offset: 0x296] -> [num value; dec: 1, hex: 0x1] + +- [NamedField, name: "GLB1", table: 0, index: 254, offset: 0x297] -> [field index: 251, offset(bytes): 0x0, width(bits): 0x1, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "GLB2", table: 0, index: 255, offset: 0x29c] -> [field index: 251, offset(bytes): 0x1, width(bits): 0x1, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [NamedField, name: "BNK1", table: 0, index: 256, offset: 0x2a3] -> [field index: 251, offset(bytes): 0x8, width(bits): 0x4, accType: Byte, lockType: NoLock, updateType: Preserve, connection: -] + +- [BankField, table: 0, index: 257, offset: 0x2a8] + | +- [NamePath, table: 0, index: 328, offset: 0x2ab] -> [namepath: "GIO0"] + | +- [NamePath, table: 0, index: 329, offset: 0x2af] -> [namepath: "BNK1"] + | +- [BytePrefix, table: 0, index: 330, offset: 0x2b3] -> [num value; dec: 0, hex: 0x0] + | +- [BytePrefix, table: 0, index: 331, offset: 0x2b5] -> [num value; dec: 49, hex: 0x31] + +- [NamedField, name: "FET0", table: 0, index: 332, offset: 0x2b9] -> [field index: 257, offset(bytes): 0x180, width(bits): 0x1, accType: Byte, lockType: Lock, updateType: WriteAsOnes, connection: -] + +- [NamedField, name: "FET1", table: 0, index: 333, offset: 0x2be] -> [field index: 257, offset(bytes): 0x181, width(bits): 0x1, accType: Byte, lockType: Lock, updateType: WriteAsOnes, connection: -] + +- [OpRegion, name: "SMBD", table: 0, index: 258, offset: 0x2c3] + | +- [NamePath, table: 0, index: 259, offset: 0x2c5] -> [namepath: "SMBD"] + | +- [BytePrefix, table: 0, index: 260, offset: 0x2c9] -> [num value; dec: 4, hex: 0x4] + | +- [WordPrefix, table: 0, index: 261, offset: 0x2ca] -> [num value; dec: 16896, hex: 0x4200] + | +- [WordPrefix, table: 0, index: 262, offset: 0x2cd] -> [num value; dec: 256, hex: 0x100] + +- [Field, table: 0, index: 263, offset: 0x2d0] + | +- [NamePath, table: 0, index: 264, offset: 0x2d4] -> [namepath: "SMBD"] + | +- [BytePrefix, table: 0, index: 265, offset: 0x2d8] -> [num value; dec: 69, hex: 0x45] + +- [NamedField, name: "SFL0", table: 0, index: 266, offset: 0x2dc] -> [field index: 263, offset(bytes): 0x0, width(bits): 0x8, accType: Buffer, accAttr: Byte, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL1", table: 0, index: 267, offset: 0x2e4] -> [field index: 263, offset(bytes): 0x8, width(bits): 0x8, accType: Buffer, accAttr: Word, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL2", table: 0, index: 268, offset: 0x2ec] -> [field index: 263, offset(bytes): 0x10, width(bits): 0x8, accType: Buffer, accAttr: Block, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL3", table: 0, index: 269, offset: 0x2f4] -> [field index: 263, offset(bytes): 0x18, width(bits): 0x8, accType: Buffer, accAttr: Quick, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL4", table: 0, index: 270, offset: 0x2fc] -> [field index: 263, offset(bytes): 0x20, width(bits): 0x8, accType: Buffer, accAttr: SendReceive, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL5", table: 0, index: 271, offset: 0x304] -> [field index: 263, offset(bytes): 0x28, width(bits): 0x8, accType: Buffer, accAttr: ProcessCall, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL6", table: 0, index: 272, offset: 0x30c] -> [field index: 263, offset(bytes): 0x30, width(bits): 0x8, accType: Buffer, accAttr: BlockProcessCall, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL7", table: 0, index: 273, offset: 0x315] -> [field index: 263, offset(bytes): 0x38, width(bits): 0x8, accType: Buffer, accAttr: Bytes(0x12), lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL8", table: 0, index: 274, offset: 0x31e] -> [field index: 263, offset(bytes): 0x40, width(bits): 0x8, accType: Buffer, accAttr: RawBytes(0x13), lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SFL9", table: 0, index: 275, offset: 0x327] -> [field index: 263, offset(bytes): 0x48, width(bits): 0x8, accType: Buffer, accAttr: RawProcessBytes(0x14), lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF10", table: 0, index: 276, offset: 0x32f] -> [field index: 263, offset(bytes): 0x50, width(bits): 0x8, accType: Any, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF11", table: 0, index: 277, offset: 0x337] -> [field index: 263, offset(bytes): 0x58, width(bits): 0x8, accType: Byte, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF12", table: 0, index: 278, offset: 0x33f] -> [field index: 263, offset(bytes): 0x60, width(bits): 0x8, accType: Word, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF13", table: 0, index: 279, offset: 0x347] -> [field index: 263, offset(bytes): 0x68, width(bits): 0x8, accType: Dword, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [NamedField, name: "SF14", table: 0, index: 280, offset: 0x34f] -> [field index: 263, offset(bytes): 0x70, width(bits): 0x8, accType: Qword, lockType: NoLock, updateType: WriteAsZeroes, connection: -] + +- [DataRegion, name: "REG0", table: 0, index: 281, offset: 0x354] + | +- [NamePath, table: 0, index: 282, offset: 0x356] -> [namepath: "REG0"] + | +- [StringPrefix, table: 0, index: 283, offset: 0x35a] -> [string value: "FOOF"] + | +- [StringPrefix, table: 0, index: 284, offset: 0x360] -> [string value: "BAR"] + | +- [StringPrefix, table: 0, index: 285, offset: 0x365] -> [string value: "BAZ"] + +- [Processor, name: "CPU0", table: 0, index: 286, offset: 0x36a] + | +- [NamePath, table: 0, index: 287, offset: 0x36d] -> [namepath: "CPU0"] + | +- [BytePrefix, table: 0, index: 288, offset: 0x371] -> [num value; dec: 1, hex: 0x1] + | +- [DwordPrefix, table: 0, index: 289, offset: 0x372] -> [num value; dec: 288, hex: 0x120] + | +- [BytePrefix, table: 0, index: 290, offset: 0x376] -> [num value; dec: 6, hex: 0x6] + | +- [ScopeBlock, table: 0, index: 291, offset: 0x377] + +- [PowerRes, name: "PWR0", table: 0, index: 292, offset: 0x377] + | +- [NamePath, table: 0, index: 293, offset: 0x37a] -> [namepath: "PWR0"] + | +- [BytePrefix, table: 0, index: 294, offset: 0x37e] -> [num value; dec: 0, hex: 0x0] + | +- [WordPrefix, table: 0, index: 295, offset: 0x37f] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 296, offset: 0x381] + +- [ThermalZone, name: "TZ0_", table: 0, index: 297, offset: 0x381] + | +- [NamePath, table: 0, index: 298, offset: 0x384] -> [namepath: "TZ0_"] + | +- [ScopeBlock, table: 0, index: 299, offset: 0x388] + +- [Method, name: "FLOW", argCount: 2, table: 0, index: 300, offset: 0x388] + | +- [NamePath, table: 0, index: 301, offset: 0x38a] -> [namepath: "FLOW"] + | +- [BytePrefix, table: 0, index: 302, offset: 0x38e] -> [num value; dec: 2, hex: 0x2] + | +- [ScopeBlock, table: 0, index: 303, offset: 0x38f] + | +- [While, table: 0, index: 304, offset: 0x38f] + | | +- [LLess, table: 0, index: 334, offset: 0x391] + | | | +- [Arg0, table: 0, index: 335, offset: 0x392] + | | | +- [Arg1, table: 0, index: 336, offset: 0x393] + | | +- [ScopeBlock, table: 0, index: 337, offset: 0x394] + | | +- [Increment, table: 0, index: 338, offset: 0x394] + | | | +- [Arg0, table: 0, index: 339, offset: 0x395] + | | +- [If, table: 0, index: 340, offset: 0x396] + | | +- [LLess, table: 0, index: 341, offset: 0x398] + | | | +- [Arg0, table: 0, index: 342, offset: 0x399] + | | | +- [BytePrefix, table: 0, index: 343, offset: 0x39a] -> [num value; dec: 5, hex: 0x5] + | | +- [ScopeBlock, table: 0, index: 344, offset: 0x39c] + | | +- [Continue, table: 0, index: 345, offset: 0x39c] + | +- [Return, table: 0, index: 305, offset: 0x3ad] + | +- [Arg0, table: 0, index: 306, offset: 0x3ae] + +- [ThermalZone, name: "THRM", table: 0, index: 310, offset: 0x3b6] + +- [NamePath, table: 0, index: 311, offset: 0x3b9] -> [namepath: "THRM"] + +- [ScopeBlock, table: 0, index: 312, offset: 0x3be] + +- [Name, name: "DEF0", table: 0, index: 313, offset: 0x3be] + | +- [NamePath, table: 0, index: 314, offset: 0x3bf] -> [namepath: "DEF0"] + | +- [Ones, table: 0, index: 315, offset: 0x3c3] + +- [Method, name: "MTH0", argCount: 0, table: 0, index: 322, offset: 0x3d1] + | +- [NamePath, table: 0, index: 323, offset: 0x3d3] -> [namepath: "MTH0"] + | +- [BytePrefix, table: 0, index: 324, offset: 0x3dd] -> [num value; dec: 0, hex: 0x0] + | +- [ScopeBlock, table: 0, index: 325, offset: 0x3de] + | +- [Return, table: 0, index: 326, offset: 0x3de] + | +- [BytePrefix, table: 0, index: 327, offset: 0x3df] -> [num value; dec: 1, hex: 0x1] + +- [Name, name: "DEF1", table: 0, index: 319, offset: 0x3cb] + +- [NamePath, table: 0, index: 320, offset: 0x3cc] -> [namepath: "DEF1"] + +- [Zero, table: 0, index: 321, offset: 0x3d0] From ddbddd2ea2c01de5c7cdda65bcb4ce574009f727 Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Tue, 6 Mar 2018 19:19:36 +0000 Subject: [PATCH 09/10] acpi: add Makefile target for fuzzing and AML parser fuzzer The fuzzer can be invoked by running: "make test-fuzz". The AML parser test suite has been augmented with a special "TestParserCrashers" function that can be used to replay corpuses identified by go-fuzz as causing parser crashes. The test can be invoked as: go test -v -run TestParserCrashers -aml-replace-crashers-from $BUILD/fuzz/corpus/src_gopheros_device_acpi_aml/crashers where $BUILD is the output directory (default: build/) defined in the Makefile. --- Makefile | 25 +++++++++++-- src/gopheros/device/acpi/aml/parser_fuzz.go | 40 +++++++++++++++++++++ src/gopheros/device/acpi/aml/parser_test.go | 34 +++++++++++++++++- 3 files changed, 96 insertions(+), 3 deletions(-) create mode 100644 src/gopheros/device/acpi/aml/parser_fuzz.go diff --git a/Makefile b/Makefile index c133d2a..fa49a19 100644 --- a/Makefile +++ b/Makefile @@ -11,13 +11,18 @@ iso_target := $(BUILD_DIR)/kernel-$(ARCH).iso # this: make run GO=go1.8 GO ?= go -# Prepend build path to GOPATH so the compiled packages and linter dependencies +# Prepend build path to GOPATH so the compiled packages and linter dependencies # end up inside the build folder GOPATH := $(BUILD_ABS_DIR):$(shell pwd):$(GOPATH) +FUZZ_PKG_LIST := src/gopheros/device/acpi/aml +# To append more entries to the above list use the following syntax +# FUZZ_PKG_LIST += path-to-pkg + ifeq ($(OS), Linux) export SHELL := /bin/bash -o pipefail + LD := ld AS := nasm @@ -143,7 +148,7 @@ run-vbox: iso VBoxManage storageattach $(VBOX_VM_NAME) --storagectl "IDE Controller" --port 0 --device 0 --type dvddrive \ --medium $(iso_target) || true VBoxManage startvm $(VBOX_VM_NAME) - + # When building gdb target disable optimizations (-N) and inlining (l) of Go code gdb: GC_FLAGS += -N -l gdb: iso @@ -185,12 +190,28 @@ lint: lint-check-deps src/... lint-check-deps: + @echo [go get] installing linter dependencies @GOPATH=$(GOPATH) $(GO) get -u -t gopkg.in/alecthomas/gometalinter.v1 @GOPATH=$(GOPATH) PATH=$(BUILD_ABS_DIR)/bin:$(PATH) gometalinter.v1 --install >/dev/null test: GOPATH=$(GOPATH) $(GO) test -cover gopheros/... +fuzz-deps: + @mkdir -p $(BUILD_DIR)/fuzz + @echo [go get] installing go-fuzz dependencies + @GOPATH=$(GOPATH) $(GO) get -u github.com/dvyukov/go-fuzz/... + +%.fuzzpkg: % + @echo [go-fuzz] fuzzing: $< + @GOPATH=$(GOPATH) PATH=$(BUILD_ABS_DIR)/bin:$(PATH) go-fuzz-build -o $(BUILD_ABS_DIR)/fuzz/$(subst /,_,$<).zip $(subst src/,,$<) + @mkdir -p $(BUILD_ABS_DIR)/fuzz/corpus/$(subst /,_,$<)/corpus + @echo [go-fuzz] + grepping for corpus file hints in $< + @grep "go-fuzz-corpus+=" $&1 | sed -e "s/^/ | /g" + +test-fuzz: fuzz-deps $(addsuffix .fuzzpkg,$(FUZZ_PKG_LIST)) + collect-coverage: GOPATH=$(GOPATH) sh coverage.sh diff --git a/src/gopheros/device/acpi/aml/parser_fuzz.go b/src/gopheros/device/acpi/aml/parser_fuzz.go new file mode 100644 index 0000000..6d3822f --- /dev/null +++ b/src/gopheros/device/acpi/aml/parser_fuzz.go @@ -0,0 +1,40 @@ +// +build gofuzz +// +// The following lines contain paths to interesting corpus data and will be +// automatically grepped and copied by the Makefile when fuzzing. +// +//go-fuzz-corpus+=src/gopheros/device/acpi/table/tabletest/DSDT.aml +//go-fuzz-corpus+=src/gopheros/device/acpi/table/tabletest/parser-testsuite-DSDT.aml + +package aml + +import ( + "gopheros/device/acpi/table" + "io/ioutil" + "unsafe" +) + +// Fuzz is the driver for go-fuzz. The function must return 1 if the fuzzer +// should increase priority of the given input during subsequent fuzzing (for +// example, the input is lexically correct and was parsed successfully); -1 if +// the input must not be added to corpus even if gives new coverage; and 0 +// otherwise; other values are reserved for future use. +func Fuzz(data []byte) int { + // Setup SDT header pointing to data + headerLen := unsafe.Sizeof(table.SDTHeader{}) + stream := make([]byte, int(headerLen)+len(data)) + copy(stream[headerLen:], data) + + header := (*table.SDTHeader)(unsafe.Pointer(&stream[0])) + header.Signature = [4]byte{'D', 'S', 'D', 'T'} + header.Length = uint32(len(stream)) + header.Revision = 2 + + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + if err := NewParser(ioutil.Discard, tree).ParseAML(uint8(1), "DSDT", header); err != nil { + return 0 + } + + return 1 +} diff --git a/src/gopheros/device/acpi/aml/parser_test.go b/src/gopheros/device/acpi/aml/parser_test.go index 29b9721..9fab368 100644 --- a/src/gopheros/device/acpi/aml/parser_test.go +++ b/src/gopheros/device/acpi/aml/parser_test.go @@ -16,9 +16,41 @@ import ( ) var ( - regenExpFiles = flag.Bool("aml-regenerate-parser-exp-files", false, "Regenerate the expected output files for AML parser tests against real AML files") + regenExpFiles = flag.Bool("aml-regenerate-parser-exp-files", false, "Regenerate the expected output files for AML parser tests against real AML files") + replayCrashersFrom = flag.String("aml-replay-crashers-from", "", "Replay go-fuzz generated crasher files from this folder") ) +// TestParserCrashers scans through the crasher corpus generated by go-fuzz and +// pipes each corpus through the AML parser. +func TestParserCrashers(t *testing.T) { + if *replayCrashersFrom == "" { + t.Skip("-aml-replay-crashers-from not specified; skipping") + return + } + + fuzzFiles, err := filepath.Glob(filepath.Join(*replayCrashersFrom, "*")) + if err != nil { + t.Fatal(err) + } + + for _, fuzzFile := range fuzzFiles { + // corpus files lack an extension + if filepath.Ext(fuzzFile) != "" { + continue + } + + data, err := ioutil.ReadFile(fuzzFile) + if err != nil { + t.Fatal(err) + } + + t.Logf("trying to parse crash corpus: %q", fuzzFile) + p, resolver := parserForMockPayload(t, data) + _ = p.ParseAML(0, "DSDT", resolver.LookupTable("DSDT")) + } + +} + func TestParser(t *testing.T) { flag.Parse() From f57aa9433d1635097ae1ae9bb235f864162f30f3 Mon Sep 17 00:00:00 2001 From: Achilleas Anagnostopoulos Date: Thu, 8 Mar 2018 08:37:25 +0000 Subject: [PATCH 10/10] acpi: fix bugs discovered by fuzzing --- src/gopheros/device/acpi/aml/obj_tree.go | 5 +++-- src/gopheros/device/acpi/aml/parser.go | 18 ++++++++++++++--- src/gopheros/device/acpi/aml/parser_test.go | 20 ++++++++++++++++++- src/gopheros/device/acpi/aml/stream_reader.go | 3 ++- 4 files changed, 39 insertions(+), 7 deletions(-) diff --git a/src/gopheros/device/acpi/aml/obj_tree.go b/src/gopheros/device/acpi/aml/obj_tree.go index c8dd353..12e79fd 100644 --- a/src/gopheros/device/acpi/aml/obj_tree.go +++ b/src/gopheros/device/acpi/aml/obj_tree.go @@ -284,7 +284,7 @@ func (tree *ObjectTree) Find(scopeIndex uint32, expr []byte) uint32 { // The expression consists of multiple name segments joined together (e.g. FOOFBAR0) // In this case we need to apply relative lookup rules for FOOF.BAR0 return tree.findRelative(scopeIndex, expr) - default: + case exprLen == amlNameLen: // expr is a simple name. According to the spec, we need to // search for it in this scope and all its parent scopes till // we reach the root. @@ -320,7 +320,8 @@ nextSegment: // case skip over them. for ; segIndex < exprLen && expr[segIndex] != '_' && (expr[segIndex] < 'A' || expr[segIndex] > 'Z'); segIndex++ { } - if segIndex >= exprLen { + + if exprLen-segIndex < amlNameLen { return InvalidIndex } diff --git a/src/gopheros/device/acpi/aml/parser.go b/src/gopheros/device/acpi/aml/parser.go index 810edd6..9051cd1 100644 --- a/src/gopheros/device/acpi/aml/parser.go +++ b/src/gopheros/device/acpi/aml/parser.go @@ -41,6 +41,7 @@ type Parser struct { objTree *ObjectTree scopeStack []uint32 pkgEndStack []uint32 + streamEnd uint32 resolvePasses uint32 mergedScopes uint32 @@ -157,6 +158,8 @@ func (p *Parser) init(tableHandle uint8, tableName string, header *table.SDTHead uint32(unsafe.Sizeof(table.SDTHeader{})), ) + // Keep track of the stream end for parsing deferred objects + p.streamEnd = header.Length _ = p.pushPkgEnd(header.Length) } @@ -431,6 +434,7 @@ func (p *Parser) parseStrictTermArg(curObj *Object) (*Object, parseResult) { if !pOpIsType2(nextOp) && !pOpIsDataObject(nextOp) && !pOpIsArg(nextOp) { kfmt.Fprintf(p.errWriter, "[table: %s, offset: 0x%x] encountered unexpected opcode %s while parsing termArg\n", p.tableName, p.r.Offset(), pOpcodeName(nextOp)) + return nil, parseResultFailed } _, _ = p.nextOpcode() @@ -985,8 +989,13 @@ func (p *Parser) pushPkgEnd(pkgEnd uint32) error { } func (p *Parser) popPkgEnd() { - p.pkgEndStack = p.pkgEndStack[:len(p.pkgEndStack)-1] + // Pop pkg end if one exists if len(p.pkgEndStack) != 0 { + p.pkgEndStack = p.pkgEndStack[:len(p.pkgEndStack)-1] + } + + // If the stack is not empty restore the last pushed pkgEnd + if len(p.pkgEndStack) != 0 && len(p.pkgEndStack) != 0 { _ = p.r.SetPkgEnd(p.pkgEndStack[len(p.pkgEndStack)-1]) } } @@ -1024,8 +1033,10 @@ func (p *Parser) connectNamedObjArgs(objIndex uint32) parseResult { return parseResultFailed } - // The last amlNameLen contain the name for this object - nameIndex = len(namepath) - amlNameLen + // The last amlNameLen part of the namepath contains the name for this object + if nameIndex = len(namepath) - amlNameLen; nameIndex < 0 { + return parseResultFailed + } for i := 0; i < amlNameLen; i++ { argObj.name[i] = namepath[nameIndex+i] } @@ -1239,6 +1250,7 @@ func (p *Parser) parseDeferredBlocks(objIndex uint32) parseResult { p.mode = parseModeAllBlocks // Set stream offset to the first arg + p.r.SetPkgEnd(p.streamEnd) p.r.SetOffset(obj.amlOffset + 1) if obj.opcode > 0xff { // opcode length = 2 _, _ = p.r.ReadByte() diff --git a/src/gopheros/device/acpi/aml/parser_test.go b/src/gopheros/device/acpi/aml/parser_test.go index 9fab368..2f514c9 100644 --- a/src/gopheros/device/acpi/aml/parser_test.go +++ b/src/gopheros/device/acpi/aml/parser_test.go @@ -200,7 +200,7 @@ func TestParseAMLErrors(t *testing.T) { } }) - t.Run("connectNonNamedObjArgs failed", func(t *testing.T) { + t.Run("connectNonNamedObjArgs failed", func(t *testing.T) { p, resolver := parserForMockPayload(t, []byte{}) // Use a named object whose args contain a TermArg @@ -727,6 +727,24 @@ func TestConnectNamedObjectsErrors(t *testing.T) { t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) } }) + + t.Run("incomplete namepath", func(t *testing.T) { + tree := NewObjectTree() + tree.CreateDefaultScopes(0) + + // Use a named object whose args contain a TermArg + namedObj := tree.newNamedObject(pOpBankField, 0, [amlNameLen]byte{'F', 'O', 'O', 'F'}) + namepathObj := tree.newObject(pOpIntNamePath, 0) + namepathObj.value = []byte{'F', 'O'} // namepath len < amlNameLen + tree.append(namedObj, namepathObj) + tree.append(tree.ObjectAt(0), namedObj) + + p := NewParser(ioutil.Discard, tree) + if res := p.connectNamedObjArgs(0); res != parseResultFailed { + t.Fatalf("expected to get parseResultFailed(%d); got %d", parseResultFailed, res) + } + }) + } func TestMergeScopeDirectivesErrors(t *testing.T) { diff --git a/src/gopheros/device/acpi/aml/stream_reader.go b/src/gopheros/device/acpi/aml/stream_reader.go index 850059c..a0a70f8 100644 --- a/src/gopheros/device/acpi/aml/stream_reader.go +++ b/src/gopheros/device/acpi/aml/stream_reader.go @@ -29,12 +29,13 @@ func (r *amlStreamReader) Init(dataAddr uintptr, dataLen, initialOffset uint32) Data: dataAddr, })) + r.SetPkgEnd(dataLen) r.SetOffset(initialOffset) } // EOF returns true if the end of the pkg has been reached. func (r *amlStreamReader) EOF() bool { - return r.offset == r.pkgEnd + return r.offset >= r.pkgEnd } func (r *amlStreamReader) SetPkgEnd(pkgEnd uint32) error {