private uint GetByRefTypeIndex(TypeDesc pointeeType)
{
uint typeIndex;
if (_byRefTypes.TryGetValue(pointeeType, out typeIndex))
{
return(typeIndex);
}
PointerTypeDescriptor descriptor = new PointerTypeDescriptor();
descriptor.ElementType = GetVariableTypeIndex(pointeeType, false);
descriptor.Is64Bit = Is64Bit ? 1 : 0;
descriptor.IsConst = 0;
descriptor.IsReference = 1;
// Calling GetVariableTypeIndex may have filled in _byRefTypes
if (_byRefTypes.TryGetValue(pointeeType, out typeIndex))
{
return(typeIndex);
}
typeIndex = _objectWriter.GetPointerTypeIndex(descriptor);
_byRefTypes.Add(pointeeType, typeIndex);
return(typeIndex);
}
private uint GetVariableTypeIndex(TypeDesc type, bool needsCompleteIndex)
{
uint variableTypeIndex = 0;
if (type.IsPrimitive)
{
variableTypeIndex = GetPrimitiveTypeIndex(type);
}
else
{
type = DebuggerCanonicalize(type);
if ((type.IsDefType && !type.IsValueType) || type.IsArray)
{
// The type index of a variable/field of a reference type is wrapped
// in a pointer, as these fields are really pointer fields, and the data is on the heap
variableTypeIndex = 0;
if (_knownReferenceWrappedTypes.TryGetValue(type, out variableTypeIndex))
{
return(variableTypeIndex);
}
else
{
uint typeindex = GetTypeIndex(type, false);
PointerTypeDescriptor descriptor = new PointerTypeDescriptor();
descriptor.ElementType = typeindex;
descriptor.Is64Bit = Is64Bit ? 1 : 0;
descriptor.IsConst = 0;
descriptor.IsReference = 1;
variableTypeIndex = _objectWriter.GetPointerTypeIndex(descriptor);
_knownReferenceWrappedTypes[type] = variableTypeIndex;
return(variableTypeIndex);
}
}
else if (type.IsEnum)
{
// Enum's use the LF_ENUM record as the variable type index, but it is required to also emit a regular structure record for them.
if (_enumTypes.TryGetValue(type, out variableTypeIndex))
{
return(variableTypeIndex);
}
variableTypeIndex = GetEnumTypeIndex(type);
GetTypeIndex(type, false); // Ensure regular structure record created
_enumTypes[type] = variableTypeIndex;
return(variableTypeIndex);
}
variableTypeIndex = GetTypeIndex(type, needsCompleteIndex);
}
return(variableTypeIndex);
}
private void InsertStaticFieldRegionMember(List <DataFieldDescriptor> fieldDescs, DefType defType, List <DataFieldDescriptor> staticFields, string staticFieldForm, string staticFieldFormTypePrefix, bool staticDataInObject)
{
if (staticFields != null && (staticFields.Count > 0))
{
// Generate struct symbol for type describing individual fields of the statics region
ClassFieldsTypeDescriptor fieldsDescriptor = new ClassFieldsTypeDescriptor
{
Size = (ulong)0,
FieldsCount = staticFields.Count
};
ClassTypeDescriptor classTypeDescriptor = new ClassTypeDescriptor
{
IsStruct = !staticDataInObject ? 1 : 0,
Name = staticFieldFormTypePrefix + _objectWriter.GetMangledName(defType),
BaseClassId = 0
};
if (staticDataInObject)
{
classTypeDescriptor.BaseClassId = GetTypeIndex(defType.Context.GetWellKnownType(WellKnownType.Object), true);
}
uint staticFieldRegionTypeIndex = _objectWriter.GetCompleteClassTypeIndex(classTypeDescriptor, fieldsDescriptor, staticFields.ToArray());
uint staticFieldRegionSymbolTypeIndex = staticFieldRegionTypeIndex;
// This means that access to this static region is done via a double indirection
if (staticDataInObject)
{
PointerTypeDescriptor pointerTypeDescriptor = new PointerTypeDescriptor();
pointerTypeDescriptor.Is64Bit = Is64Bit ? 1 : 0;
pointerTypeDescriptor.IsConst = 0;
pointerTypeDescriptor.IsReference = 0;
pointerTypeDescriptor.ElementType = staticFieldRegionTypeIndex;
uint intermediatePointerDescriptor = _objectWriter.GetPointerTypeIndex(pointerTypeDescriptor);
pointerTypeDescriptor.ElementType = intermediatePointerDescriptor;
staticFieldRegionSymbolTypeIndex = _objectWriter.GetPointerTypeIndex(pointerTypeDescriptor);
}
DataFieldDescriptor staticRegionField = new DataFieldDescriptor
{
FieldTypeIndex = staticFieldRegionSymbolTypeIndex,
Offset = 0xFFFFFFFF,
Name = staticFieldForm
};
fieldDescs.Add(staticRegionField);
}
}
// Get Type index for this pointer of specified type
public uint GetThisTypeIndex(TypeDesc type)
{
lock (_lock)
{
uint typeIndex;
if (_thisTypes.TryGetValue(type, out typeIndex))
{
return(typeIndex);
}
PointerTypeDescriptor descriptor = new PointerTypeDescriptor();
// Note the use of GetTypeIndex here instead of GetVariableTypeIndex (We need the type exactly, not a reference to the type (as would happen for arrays/classes), and not a primitive value (as would happen for primitives))
descriptor.ElementType = GetTypeIndex(type, true);
descriptor.Is64Bit = Is64Bit ? 1 : 0;
descriptor.IsConst = 1;
descriptor.IsReference = 0;
typeIndex = _objectWriter.GetPointerTypeIndex(descriptor);
_thisTypes.Add(type, typeIndex);
return(typeIndex);
}
}
uint ITypesDebugInfoWriter.GetPointerTypeIndex(PointerTypeDescriptor pointerDescriptor)
{
return(_dbgInfoWriter.GetPointerTypeIndex(pointerDescriptor));
}
uint ITypesDebugInfoWriter.GetPointerTypeIndex(PointerTypeDescriptor pointerDescriptor)
{
return(GetPointerTypeIndex(_nativeObjectWriter, pointerDescriptor));
}
private static extern uint GetPointerTypeIndex(IntPtr objWriter, PointerTypeDescriptor pointerDescriptor);
