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;
}
