public void ReadRegisterData(CIRegisterList aRegList) { //If long enough reglist starts with R0, it is assumed to be the "basic" register list (R0-R15) if (aRegList.Count > 15 && aRegList[0].Type == SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_00) { iBasicRegs.Name = aRegList.Name; foreach (CIRegister register in aRegList) { string regName = GetRegisterName(register); CCrasInfoRegisterItem regItem = new CCrasInfoRegisterItem(regName, register.Value); if (register.Symbol != null && CCrashInfoFileUtilities.IsSymbolSerializable(register.Symbol)) { regItem.Symbol = register.Symbol.Name; } iBasicRegs.Registers.Add(regItem); //Check if this is PC and save it separately if (register.Type == SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_PC) { iProgramCounter.Value = register.Value; iProgramCounter.Symbol = register.Symbol.Name; } } } else //all other registers as their own list { CCrashInfoRegisterList regs = new CCrashInfoRegisterList(); regs.Name = aRegList.Name; bool hasRealData = false; foreach (CIRegister register in aRegList) { string regName = GetRegisterName(register); CCrasInfoRegisterItem regItem = new CCrasInfoRegisterItem(regName, register.Value); if (register.Symbol != null && CCrashInfoFileUtilities.IsSymbolSerializable(register.Symbol)) { regItem.Symbol = register.Symbol.Name; } regs.Registers.Add(regItem); if (register.Value != 0) { hasRealData = true; } } if (hasRealData) { iOtherRegLists.Add(regs); } } }
public CIStack CreateStack(CIRegisterList aRegisters, byte[] aData, uint aAddressOfFirstByte, AddressRange aRange) { // The registers given must be a child of this thread (in some way) System.Diagnostics.Debug.Assert(aRegisters.OwningThread == this); // Add it to the overall item too CIStack stack = CIStack.NewThreadStack(this, aRegisters, aData, aAddressOfFirstByte, aRange); AddChild(stack); return(stack); }
private CIStack(CIRegisterList aRegisters, byte[] aData, uint aAddressOfFirstByte, AddressRange aRange) : base(aRegisters.Container) { base.AddSupportedChildType(typeof(CIStackEntry)); base.AddSupportedChildType(typeof(CIMessage)); iRegisters = aRegisters; iStackAddressRange = aRange; // Prepare data DataBufferPrimer primer = new DataBufferPrimer(iStackData); primer.Prime(aData, aAddressOfFirstByte); }
public CIRegisterCPSR(CIRegisterList aCollection, uint aValue) : base(aCollection, TArmRegisterType.EArmReg_CPSR, aValue) { PrepareMessage(); // CIRegisterVisualization modeARMv5 = new CIRegisterVisualization(this, this, KVisMode_ARMv5); this.AddChild(modeARMv5); modeARMv5.Refresh(); // CIRegisterVisualization modeARMv6 = new CIRegisterVisualization(this, this, KVisMode_ARMv6); this.AddChild(modeARMv6); modeARMv6.Refresh(); }
private void ExtractThreadStack(CIThread aThread) { DExcExtractorListStackData stackDataList = (DExcExtractorListStackData)iData[DExcExtractorListType.EListStackData]; DataBuffer stackData = stackDataList.StackData; // Get stack range details DExcExtractorListThreadInfo threadInfo = (DExcExtractorListThreadInfo)iData[DExcExtractorListType.EListThread]; AddressRange stackRange = threadInfo.StackRange; // If we didn't get the stack range, we cannot create a stack entry if (!stackRange.IsValid || stackRange.Max == 0 || stackRange.Min == 0) { CIMessageWarning warning = new CIMessageWarning(aThread.Container, "Stack Address Range Unavailable"); warning.AddLine("The stack address range details are invalid."); aThread.AddChild(warning); } else if (stackData.Count == 0) { // No stack data CIMessageWarning warning = new CIMessageWarning(aThread.Container, "Stack Data Unavailable"); warning.AddLine("The crash details contain no stack data."); aThread.AddChild(warning); } else { // Set base address of data buffer if not already set if (stackData.AddressOffset == 0) { stackData.AddressOffset = stackRange.Min; } // In theory, D_EXC only ever captures user-side crashes (panics/exceptions) therefore // we should always be able to assume that the stack data goes with a user-side thread. CIRegisterList userRegs = aThread.Registers[TArmRegisterBank.ETypeUser]; if (userRegs != null) { CIStack stack = aThread.CreateStack(userRegs, stackData, stackData.AddressOffset, stackRange); // Register it as a specific crash instance iContainer.AddChild(stack); } } }
internal static CIStack NewThreadStack(CIThread aThread, CIRegisterList aRegisters, byte[] aData, uint aAddressOfFirstByte, AddressRange aRange) { CIStack ret = new CIStack(aRegisters, aData, aAddressOfFirstByte, aRange); return(ret); }
public static CIStack NewStandAlone(CIRegisterList aRegisters, byte[] aData, uint aAddressOfFirstByte, AddressRange aRange) { CIStack ret = new CIStack(aRegisters, aData, aAddressOfFirstByte, aRange); return(ret); }
public CIRegisterFSR(CIRegisterList aCollection, uint aValue) : base(aCollection, TArmRegisterType.EArmReg_FSR, aValue) { PrepareMessage(); }
private void ExtractThreadRegisters(CIThread aThread) { CIThreadRegisterListCollection threadRegs = aThread.Registers; CIRegisterList regListUser = threadRegs[TArmRegisterBank.ETypeUser]; CIRegisterList regListEXC = threadRegs[TArmRegisterBank.ETypeException]; CIRegisterList regListCOP = threadRegs[TArmRegisterBank.ETypeCoProcessor]; CIRegisterList regListSVC = threadRegs[TArmRegisterBank.ETypeSupervisor]; #region User registers foreach (string line in iData[DExcExtractorListType.EListRegistersUser]) { Match m = EM.RegistersUserSet.Match(line); if (m.Success) { GroupCollection groups = m.Groups; int firstReg = int.Parse(groups[1].Value); for (int i = firstReg; i < firstReg + 4; i++) { Group gp = groups[2 + (i - firstReg)]; uint value = uint.Parse(gp.Value, System.Globalization.NumberStyles.HexNumber); TArmRegisterType regType = (TArmRegisterType)i; regListUser[regType].Value = value; } } else { m = EM.RegistersUserCPSR.Match(line); if (m.Success) { // Get CPSR value and set it uint cpsrValue = uint.Parse(m.Groups[1].Value, System.Globalization.NumberStyles.HexNumber); threadRegs.CPSR = cpsrValue; } } } #endregion #region Exception registers foreach (string line in iData[DExcExtractorListType.EListRegistersException]) { Match m = EM.RegistersExceptionSet1.Match(line); if (m.Success) { GroupCollection groups = m.Groups; // regListEXC[TArmRegisterType.EArmReg_EXCCODE].Value = uint.Parse(m.Groups[1].Value, System.Globalization.NumberStyles.HexNumber); regListEXC[TArmRegisterType.EArmReg_EXCPC].Value = uint.Parse(m.Groups[2].Value, System.Globalization.NumberStyles.HexNumber); // regListCOP[TArmRegisterType.EArmReg_FAR].Value = uint.Parse(m.Groups[3].Value, System.Globalization.NumberStyles.HexNumber); regListCOP[TArmRegisterType.EArmReg_FSR].Value = uint.Parse(m.Groups[4].Value, System.Globalization.NumberStyles.HexNumber); if (regListEXC.Contains(TArmRegisterType.EArmReg_EXCCODE)) { CIRegister reg = regListEXC[TArmRegisterType.EArmReg_EXCCODE]; System.Diagnostics.Debug.Assert(reg is CIRegisterExcCode); CIRegisterExcCode excReg = (CIRegisterExcCode)reg; // excReg.ExpandToFullExceptionRange(); } // It also means it was an exception aThread.ExitInfo.Type = CrashItemLib.Crash.ExitInfo.CIExitInfo.TExitType.EExitTypeException; } else { m = EM.RegistersExceptionSet2.Match(line); if (m.Success) { GroupCollection groups = m.Groups; // regListSVC[TArmRegisterType.EArmReg_SP].Value = uint.Parse(m.Groups[1].Value, System.Globalization.NumberStyles.HexNumber); regListSVC[TArmRegisterType.EArmReg_LR].Value = uint.Parse(m.Groups[2].Value, System.Globalization.NumberStyles.HexNumber); regListSVC[TArmRegisterType.EArmReg_SPSR].Value = uint.Parse(m.Groups[3].Value, System.Globalization.NumberStyles.HexNumber); } } } #endregion }
public CIRegisterExcCode(CIRegisterList aCollection, uint aValue) : base(aCollection, TArmRegisterType.EArmReg_EXCCODE, aValue) { iDescription = CreateMessage(); base.AddChild(iDescription); }
public override void Check(CIContainer aContainer) { CISummarisableEntityList list = aContainer.Summaries; foreach (CISummarisableEntity entry in list) { // Check that each stack contains some registers and at least the SP. bool stackAvailable = entry.IsAvailable(CISummarisableEntity.TElement.EElementStack); bool regsAvailable = entry.IsAvailable(CISummarisableEntity.TElement.EElementRegisters); // if (stackAvailable) { CIStack stack = entry.Stack; // if (regsAvailable) { CIRegisterList regs = stack.Registers; // Check that SP, LR and PC are available bool pointerAvailable = regs.Contains(TArmRegisterType.EArmReg_SP); if (!pointerAvailable) { base.CreateWarning(aContainer, stack, LibResources.CIPDRegAvailability_MissingSP_Title, string.Format(LibResources.CIPDRegAvailability_MissingSP_Description, base.CreateIdentifierText(entry)) ); } // bool lrAvailable = regs.Contains(TArmRegisterType.EArmReg_LR); if (!lrAvailable) { base.CreateWarning(aContainer, stack, LibResources.CIPDRegAvailability_MissingLR_Title, string.Format(LibResources.CIPDRegAvailability_MissingLR_Description, base.CreateIdentifierText(entry)) ); } // bool pcAvailable = regs.Contains(TArmRegisterType.EArmReg_PC); if (!pcAvailable) { base.CreateWarning(aContainer, stack, LibResources.CIPDRegAvailability_MissingPC_Title, string.Format(LibResources.CIPDRegAvailability_MissingPC_Description, base.CreateIdentifierText(entry)) ); } // If R0 is available, check if it is 0 and check whether an exception occurred - if so, it was possibly // caused by de-referencing a NULL this pointer. bool threadAvailable = entry.IsAvailable(CISummarisableEntity.TElement.EElementThread); if (threadAvailable) { if (regs.Contains(TArmRegisterType.EArmReg_00)) { CIRegister r0 = regs[TArmRegisterType.EArmReg_00]; // bool r0WasNull = (r0.Value == 0); bool wasException = entry.IsAbnormalTermination && (entry.Thread.ExitInfo.Type == CrashItemLib.Crash.ExitInfo.CIExitInfo.TExitType.EExitTypeException); bool wasKernExec3 = entry.IsAbnormalTermination && (entry.Thread.ExitInfo.Type == CrashItemLib.Crash.ExitInfo.CIExitInfo.TExitType.EExitTypePanic && entry.Thread.ExitInfo.Category.ToUpper() == "KERN-EXEC" && entry.Thread.ExitInfo.Reason == 3); // if (r0WasNull && (wasException || wasKernExec3)) { base.CreateWarning(aContainer, r0, LibResources.CIPDRegAvailability_NullThisPointer_Title, string.Format(LibResources.CIPDRegAvailability_NullThisPointer_Description, base.CreateIdentifierText(entry)) ); } } } } else { base.CreateWarning(aContainer, stack, LibResources.CIPDRegAvailability_NoRegsForStack_Title, string.Format(LibResources.CIPDRegAvailability_NoRegsForStack_Description, base.CreateIdentifierText(entry)) ); } } } }
public static CIRegister New(TArmRegisterType aType, uint aValue, string aName, CIRegisterList aList) { CIRegister ret = null; // switch (aType) { case TArmRegisterType.EArmReg_CPSR: ret = new CIRegisterCPSR(aList, aValue); break; case TArmRegisterType.EArmReg_FSR: ret = new CIRegisterFSR(aList, aValue); break; case TArmRegisterType.EArmReg_EXCCODE: ret = new CIRegisterExcCode(aList, aValue); break; default: ret = new CIRegister(aList, aType, aName, aValue); break; } // System.Diagnostics.Debug.Assert(ret.Type == aType); System.Diagnostics.Debug.Assert(ret.Value == aValue); System.Diagnostics.Debug.Assert(ret.Name == aName); // return(ret); }
public static CIRegister New(TArmRegisterType aType, uint aValue, CIRegisterList aList) { CIRegister ret = New(aType, aValue, ArmRegister.GetTypeName(aType), aList); return(ret); }
public CXmlRegisterSet(CIRegisterList aList) : base(SegConstants.Registers_RegisterSet) { iList = aList; }