public CIRegisterVisualization(CIRegister aRegister, ICIRegisterVisualizerVisitor aVisitor, string aDescription)
: base(aRegister.Container, aRegister)
{
iVisitor = aVisitor;
iRegister = aRegister;
iDescription = aDescription;
}
protected override void XmlSerializeContent(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
if (!iEntry.IsRegisterBasedEntry)
{
aParameters.Writer.WriteElementString(SegConstants.CmnAddress, iEntry.Address.ToString("x8"));
}
//
aParameters.Writer.WriteElementString(SegConstants.CmnValue, iEntry.Data.ToString("x8"));
aParameters.Writer.WriteElementString(SegConstants.CmnText, iEntry.DataAsString);
if (iEntry.FunctionOffset != 0)
{
aParameters.Writer.WriteElementString(SegConstants.Stacks_Stack_Data_Offset, iEntry.FunctionOffset.ToString("x4"));
}
//
if (iEntry.IsRegisterBasedEntry)
{
// Get the corresponding register from the stack
CIStack stack = iEntry.Stack;
CIRegister register = iEntry.Register;
if (register != null)
{
CXmlNode.WriteLink(register.Id, SegConstants.Registers, aParameters.Writer);
}
}
if (iEntry.Symbol != null)
{
CXmlNode.WriteLink(iEntry.Symbol.Id, SegConstants.Symbols, aParameters.Writer);
}
}
public override void Check(CIContainer aContainer)
{
CISummarisableEntityList list = aContainer.Summaries;
foreach (CISummarisableEntity entry in list)
{
bool stackAvailable = entry.IsAvailable(CISummarisableEntity.TElement.EElementStack);
bool regsAvailable = entry.IsAvailable(CISummarisableEntity.TElement.EElementRegisters);
if (stackAvailable && regsAvailable)
{
CIStack stack = entry.Stack;
//
bool pointerAvailable = stack.Registers.Contains(TArmRegisterType.EArmReg_SP);
if (pointerAvailable)
{
CIRegister regSP = stack.Pointer;
AddressRange stackDataRange = stack.RawDataRange;
//
if (!stackDataRange.Contains(regSP))
{
base.CreateWarning(aContainer, stack,
LibResources.CPIDStackDataValidator_Title,
string.Format(LibResources.CPIDStackDataValidator_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 void Read(CIStack aStack)
{
foreach (CIStackEntry entry in aStack)
{
CCrashInfoCSItem csItem = new CCrashInfoCSItem();
if (entry.IsCurrentStackPointerEntry)
{
iStackPointerLocation = iCallStack.Count;
csItem.iIsStackPointer = true;
}
CIRegister register = entry.Register;
if (register != null) //entry is from registers
{
csItem.iIsRegisterEntry = true;
if (register.Name == "PC")
{
csItem.iRegisterName = "Program counter";
}
else if (register.Name == "LR")
{
csItem.iRegisterName = "Link register";
}
else //other register
{
csItem.iRegisterName = register.Name;
}
}
else //entry is from memory (normal case)
{
csItem.iMemoryAddress = entry.Address;
}
//Add data contained in the memory location
csItem.iItemData = entry.Data;
csItem.iItemDataString = entry.DataAsString;
if (entry.Symbol != null) //add symbol if possible
{
csItem.iHasSymbol = true;
csItem.iSymbolName = entry.Symbol.Symbol.Name;
csItem.iSymbolOffset = entry.FunctionOffset;
csItem.iSymbolObject = entry.Symbol.Symbol.Object;
}
// else symbol is not available
iCallStack.Add(csItem);
}
}
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
}
/** Return CrashInfo compatible register name - R0-R15 in short numeric form, other as they are */
public static string GetRegisterName(CIRegister aRegister)
{
string ret = aRegister.Name;
//
switch (aRegister.Type)
{
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_00:
ret = "R0";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_01:
ret = "R1";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_02:
ret = "R2";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_03:
ret = "R3";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_04:
ret = "R4";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_05:
ret = "R5";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_06:
ret = "R6";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_07:
ret = "R7";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_08:
ret = "R8";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_09:
ret = "R9";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_10:
ret = "R10";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_11:
ret = "R11";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_12:
ret = "R12";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_SP:
ret = "R13";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_LR:
ret = "R14";
break;
case SymbianStructuresLib.Arm.Registers.TArmRegisterType.EArmReg_PC:
ret = "R15";
break;
default:
break;
}
//
return(ret);
}
public CXmlRegister(CIRegister aRegister)
: base(SegConstants.Registers_RegisterSet_Register)
{
iRegister = aRegister;
}
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, CIRegisterList aList)
{
CIRegister ret = New(aType, aValue, ArmRegister.GetTypeName(aType), aList);
return(ret);
}