}
// Performs recursive expansion within the tree for nodes that are along the path to varToExpand.
-// Expansion involves calulating a set of child expressions from the current expression via
+// Expansion involves calculating a set of child expressions from the current expression via
// field dereferencing, array index dereferencing, or casting to a base type.
// For example if a tree was rooted with expression 'foo.bar' and varToExpand is '(Baz)foo.bar[9]'
// then 'foo.bar', 'foo.bar[9]', and '(Baz)foo.bar[9]' nodes would all be expanded.
// pParsedType - A debuggee type that should be used as the context for interpreting
// pExpressionRemainder.
// pParsedDefaultValue - A fixed value from metadata that should be used as context for
-// interpretting pExpressionRemainder
+// interpreting pExpressionRemainder
// cchParsedDefaultValue- Size of pParsedDefaultValue
// pFrame - A debuggee IL frame that disambiguates the thread and context needed
// to evaluate a thread-static or context-static value
// ppExpressionNode - OUT - the resulting expression node
//
//
-// Valid combinations of state comming into this method:
+// Valid combinations of state coming into this method:
// The expression up to charactersParsed isn't recognized yet:
// pParsedValue = pParsedType = pParsedDefaultValue = NULL
// cchParsedDefaultValue = 0
if (instr[0] != 0xf8df)
return PC;
- // The first instruction is defintely a LDR of the form we expect so it's OK to read the second half of
+ // The first instruction is definitely a LDR of the form we expect so it's OK to read the second half of
// the encoding.
if (g_ExtData->ReadVirtual(TO_CDADDR(PC + 2), &instr[1], sizeof(WORD), NULL) != S_OK)
return 0;
move_xp (offs, retAddr-4);
*whereCalled = retAddr + (ULONG64)(LONG)(offs);
//*whereCalled = *((int*) (retAddr-4)) + retAddr;
- // on WOW64 the range valid for code is almost the whole 4GB adddress space
+ // on WOW64 the range valid for code is almost the whole 4GB address space
if (g_ExtData->ReadVirtual(TO_CDADDR(*whereCalled), &addr, sizeof(addr), NULL) == S_OK)
{
TADDR callee;
if (g_ExtData->ReadVirtual(TO_CDADDR(addr), whereCalled, sizeof(*whereCalled), NULL) == S_OK) {
move_xp (*whereCalled, addr);
//*whereCalled = **((unsigned**) (retAddr-4));
- // on WOW64 the range valid for code is almost the whole 4GB adddress space
+ // on WOW64 the range valid for code is almost the whole 4GB address space
if (g_ExtData->ReadVirtual(TO_CDADDR(*whereCalled), &addr, sizeof(addr), NULL) == S_OK)
{
TADDR callee;
if (!analyzeData.heap_analyze_success)
{
- ExtOut("Failed to gather needed data, possibly due to memory contraints in the debuggee.\n");
+ ExtOut("Failed to gather needed data, possibly due to memory constraints in the debuggee.\n");
ExtOut("To try again re-issue the !FindRoots -gen <N> command.\n");
return 0;
}
if (!analyzeData.heap_analyze_success)
{
- ExtOut("Failed to gather needed data, possibly due to memory contraints in the debuggee.\n");
+ ExtOut("Failed to gather needed data, possibly due to memory constraints in the debuggee.\n");
ExtOut("To try again re-issue the !FindRoots -gen <N> command.\n");
continue;
}
BOOL VerifyObject(const DacpGcHeapDetails &heap, DWORD_PTR objAddr, DWORD_PTR MTAddr, size_t objSize, BOOL bVerifyMember)
{
// This is only used by the other VerifyObject function if bVerifyMember is true,
- // so we only intialize it if we need it for verifying object members.
+ // so we only initialize it if we need it for verifying object members.
DacpHeapSegmentData seg;
if (bVerifyMember)
// TODO: pass info to callback having to lookup the MethodTableInfo again
MethodTableInfo* info = g_special_mtCache.Lookup((DWORD_PTR)methodTable);
- _ASSERTE(info->IsInitialized()); // This is the second pass, so we should be intialized
+ _ASSERTE(info->IsInitialized()); // This is the second pass, so we should be initialized
if (!info->bContainsPointers)
return;
BOOL bDoGcHist = (fileName == NULL);
FILE* file = NULL;
- // Fetch the circular buffer bookeeping data
+ // Fetch the circular buffer bookkeeping data
StressLog inProcLog;
HRESULT hr = memCallBack->ReadVirtual(UL64_TO_CDA(outProcLog), &inProcLog, sizeof(StressLog), 0);
if (hr != S_OK)
// To resolve this problem, SOS now abstracts the target behind the IMachine interface, and uses
// calls on IMachine to take target-specific actions. It implements X86Machine, ARMMachine, and
// AMD64Machine. An instance of these exists in each appropriate host (e.g. the X86 version of SOS
-// contains instaces of X86Machine and ARMMachine, the ARM version contains an instance of
+// contains instances of X86Machine and ARMMachine, the ARM version contains an instance of
// ARMMachine, and the AMD64 version contains an instance of AMD64Machine). The code included in
// each version if determined by the SosTarget*** MSBuild symbols, and SOS_TARGET_*** conditional
// compilation symbols (as specified in sos.targets).
}
// Get the address and method table of the state machine. While it'll generally be a struct,
- // it is valid for it to be a class, so we accomodate both.
+ // it is valid for it to be a class, so we accommodate both.
BOOL bStateMachineIsValueType = stateMachineField.Type == ELEMENT_TYPE_VALUETYPE;
CLRDATA_ADDRESS stateMachineAddr;
CLRDATA_ADDRESS stateMachineMT;
"Failed to reserve memory", // fgm_reserve_segment
"Didn't have enough memory to commit beginning of the segment", // fgm_commit_segment_beg
"Didn't have enough memory to commit the new ephemeral segment", // fgm_commit_eph_segment
- "Didn't have enough memory to grow the internal GC datastructures", // fgm_grow_table
- "Didn't have enough memory to commit the internal GC datastructures", // fgm_commit_table
+ "Didn't have enough memory to grow the internal GC data structures", // fgm_grow_table
+ "Didn't have enough memory to commit the internal GC data structures", // fgm_commit_table
};
void PrintOOMInfo(DacpOomData* oomData)
return Status;
}
- // aggregate stats accross heaps / generation
+ // aggregate stats across heaps / generation
GenUsageStat genUsageStat[4] = {0, 0, 0, 0};
for (DWORD n = 0; n < dwNHeaps; n ++)
pMeth->EndEnumInstances (h1);
}
- // if this is a generic method we need to add a defered bp
+ // if this is a generic method we need to add a deferred bp
BOOL bGeneric = FALSE;
pMeth->HasClassOrMethodInstantiation(&bGeneric);
static const char * const str_heap_compact_reasons[] =
{
"low on ephemeral space",
- "high fragmetation",
+ "high fragmentation",
"couldn't allocate gaps",
"user specfied compact LOH",
"last GC before OOM",
* *
* This function is called to dump all fields of a managed object. *
* dwStartAddr specifies the beginning memory address. *
-* bFirst is used to avoid printing header everytime. *
+* bFirst is used to avoid printing header every time. *
* *
\**********************************************************************/
void DisplayFields(CLRDATA_ADDRESS cdaMT, DacpMethodTableData *pMTD, DacpMethodTableFieldData *pMTFD, DWORD_PTR dwStartAddr, BOOL bFirst, BOOL bValueClass)
}
//
-// lldb doesn't have a way or API to unwind an arbitary context (IP, SP)
+// lldb doesn't have a way or API to unwind an arbitrary context (IP, SP)
// and return the next frame so we have to stick with the native frames
// lldb has found and find the closest frame to the incoming context SP.
//
//------------------------------------------------------------------------------
// MethodContext::recGlobalContext
// This method copies any relevant global (i.e. per-JIT-instance) data from
-// the given method context. Currently this is limited to configuiration
+// the given method context. Currently this is limited to configuration
// values, but may grow to encompass other information in the future (e.g.
// any information that is exposed by the ICorJitHost interface and is
// therefore accessible outside the context of a call to
ZeroMemory(&key, sizeof(GetArgType)); // We use the input structs as a key and use memcmp to compare.. so
// we need to zero out padding too
// Only setting values for things the EE seems to pay attention to... this is necessary since some of the values
- // are unset and fail our precise comparisions...
+ // are unset and fail our precise comparisons ...
key.flags = (DWORD)sig->flags;
key.numArgs = (DWORD)sig->numArgs;
key.sigInst_classInstCount = (DWORD)sig->sigInst.classInstCount;
}
void MethodContext::dmpCompareTypesForCast(DLDL key, DWORD value)
{
- printf("CompareTypesForCast key fromClas=%016llX, toClass=%016llx, result=%d", key.A, key.B, value);
+ printf("CompareTypesForCast key fromClass=%016llX, toClass=%016llx, result=%d", key.A, key.B, value);
}
TypeCompareState MethodContext::repCompareTypesForCast(CORINFO_CLASS_HANDLE fromClass, CORINFO_CLASS_HANDLE toClass)
{
void SetLogPathName()
{
- // NOTE: under PAL, we don't get the comand line, so we depend on the random number generator to give us a unique
+ // NOTE: under PAL, we don't get the command line, so we depend on the random number generator to give us a unique
// filename.
WCHAR* OriginalExecutableName =
GetCommandLineW(); // TODO-Cleanup: not cool to write to the process view of commandline....
*pcchDebuggerString = valueSize / sizeof(WCHAR);
// The size of an empty string with the null terminator is 2.
- BOOL fIsDebuggerStringEmptry = valueSize <= 2 ? TRUE : FALSE;
+ BOOL fIsDebuggerStringEmpty = valueSize <= 2 ? TRUE : FALSE;
- if ((ret != ERROR_SUCCESS) || (valueType != REG_SZ) || fIsDebuggerStringEmptry)
+ if ((ret != ERROR_SUCCESS) || (valueType != REG_SZ) || fIsDebuggerStringEmpty)
{
RegCloseKey(hKey);
return S_OK;
TerminateProcess(GetCurrentProcess(), 1);
break;
- // Tell caller to break at the correct loction.
+ // Tell caller to break at the correct location.
case IDRETRY:
if (IsDebuggerPresent())
// The output format is in MSDIS's disassembly format.
//
// Arguments:
-// block - A pointer to the code block to diassemble.
+// block - A pointer to the code block to disassemble.
// blocksize - The size of the code block to disassemble.
// originalAddr - The original base address of the code block.
//
// mc - The method context of the method to diff. Unused.
// cr1 - The first compile result to compare. Unused.
// cr2 - The second compile result to compare. Unused.
-// block1 - A pointer to the first code block to diassemble.
+// block1 - A pointer to the first code block to disassemble.
// blocksize1 - The size of the first code block to compare.
// datablock1 - A pointer to the first read-only data block to compare. Unused.
// datablockSize1 - The size of the first read-only data block to compare.
// otherCodeBlock1 - The original base address of the first cold code block. Note that this is
// just an address; we don't need the cold code buffer.
// otherCodeBlockSize1- The size of the first cold code block.
-// block2 - A pointer to the second code block to diassemble.
+// block2 - A pointer to the second code block to disassemble.
// blocksize2 - The size of the second code block to compare.
// datablock2 - A pointer to the second read-only data block to compare.
// datablockSize2 - The size of the second read-only data block to compare.
// mc - The method context of the method to diff.
// cr1 - The first compile result to compare.
// cr2 - The second compile result to compare.
-// block1 - A pointer to the first code block to diassemble.
+// block1 - A pointer to the first code block to disassemble.
// blocksize1 - The size of the first code block to compare.
// originalDataBlock1 - The original base address of the first read-only data block.
-// block2 - A pointer to the second code block to diassemble.
+// block2 - A pointer to the second code block to disassemble.
// blocksize2 - The size of the second code block to compare.
// originalDataBlock2 - The original base address of the second read-only data block.
//
projects / platform / upstream / coreclr.git / commitdiff