} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(ElementType == null ||
ElementType.HandleType == HandleType.TypeDefinition ||
ElementType.HandleType == HandleType.TypeReference ||
ElementType.HandleType == HandleType.TypeSpecification);
writer.Write(ElementType);
writer.Write(Rank);
writer.Write(Sizes);
writer.Write(LowerBounds);
} // Save
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
// This node does not trigger generation of other nodes.
if (relocsOnly)
return new ObjectData(Array.Empty<byte>(), Array.Empty<Relocation>(), 1, new ISymbolNode[] { this });
var writer = new NativeWriter();
var typeMapHashTable = new VertexHashtable();
Section hashTableSection = writer.NewSection();
hashTableSection.Place(typeMapHashTable);
foreach (var mappingEntry in factory.MetadataManager.GetTypeDefinitionMapping())
{
if (!factory.CompilationModuleGroup.ContainsType(mappingEntry.Entity))
continue;
// We are looking for any EEType - constructed or not, it has to be in the mapping
// table so that we can map it to metadata.
EETypeNode node = null;
if (!mappingEntry.Entity.IsGenericDefinition)
{
node = factory.ConstructedTypeSymbol(mappingEntry.Entity) as EETypeNode;
}
if (node == null || !node.Marked)
{
// This might have been a typeof() expression.
node = factory.NecessaryTypeSymbol(mappingEntry.Entity) as EETypeNode;
}
if (node.Marked)
{
Vertex vertex = writer.GetTuple(
writer.GetUnsignedConstant(_externalReferences.GetIndex(node)),
writer.GetUnsignedConstant((uint)mappingEntry.MetadataHandle)
);
int hashCode = node.Type.GetHashCode();
typeMapHashTable.Append((uint)hashCode, hashTableSection.Place(vertex));
}
}
MemoryStream ms = new MemoryStream();
writer.Save(ms);
byte[] hashTableBytes = ms.ToArray();
_endSymbol.SetSymbolOffset(hashTableBytes.Length);
return new ObjectData(hashTableBytes, Array.Empty<Relocation>(), 1, new ISymbolNode[] { this, _endSymbol });
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
// This node does not trigger generation of other nodes.
if (relocsOnly)
return new ObjectData(Array.Empty<byte>(), Array.Empty<Relocation>(), 1, new ISymbolNode[] { this });
var writer = new NativeWriter();
var typeMapHashTable = new VertexHashtable();
Section hashTableSection = writer.NewSection();
hashTableSection.Place(typeMapHashTable);
foreach (var node in factory.MetadataManager.GetCctorContextMapping())
{
MetadataType type = node.Type;
Debug.Assert(factory.TypeSystemContext.HasLazyStaticConstructor(type));
// If this type doesn't generate an EEType in the current compilation, don't report it in the table.
// If nobody can get to the EEType, they can't ask to run the cctor. We don't need to force generate it.
if (!factory.MetadataManager.TypeGeneratesEEType(type))
continue;
// Hash table is hashed by the hashcode of the owning type.
// Each entry has: the EEType of the type, followed by the non-GC static base.
// The non-GC static base is prefixed by the class constructor context.
// Unfortunately we need to adjust for the cctor context just so that we can subtract it again at runtime...
int delta = NonGCStaticsNode.GetClassConstructorContextStorageSize(factory.TypeSystemContext.Target, type);
Vertex vertex = writer.GetTuple(
writer.GetUnsignedConstant(_externalReferences.GetIndex(factory.NecessaryTypeSymbol(type))),
writer.GetUnsignedConstant(_externalReferences.GetIndex(node, delta))
);
int hashCode = type.GetHashCode();
typeMapHashTable.Append((uint)hashCode, hashTableSection.Place(vertex));
}
MemoryStream ms = new MemoryStream();
writer.Save(ms);
byte[] hashTableBytes = ms.ToArray();
_endSymbol.SetSymbolOffset(hashTableBytes.Length);
return new ObjectData(hashTableBytes, Array.Empty<Relocation>(), 1, new ISymbolNode[] { this, _endSymbol });
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
// This node does not trigger generation of other nodes.
if (relocsOnly)
return new ObjectData(Array.Empty<byte>(), Array.Empty<Relocation>(), 1, new ISymbolNode[] { this });
var writer = new NativeWriter();
var typeMapHashTable = new VertexHashtable();
Section hashTableSection = writer.NewSection();
hashTableSection.Place(typeMapHashTable);
foreach (var mappingEntry in factory.MetadataManager.GetTypeDefinitionMapping())
{
if (!factory.CompilationModuleGroup.ContainsType(mappingEntry.Entity))
continue;
// Types that don't have EETypes don't need mapping table entries because there's no risk of them
// not unifying to the same System.Type at runtime.
if (!factory.MetadataManager.TypeGeneratesEEType(mappingEntry.Entity))
continue;
// Go with a necessary type symbol. It will be upgraded to a constructed one if a constructed was emitted.
IEETypeNode typeSymbol = factory.NecessaryTypeSymbol(mappingEntry.Entity);
Vertex vertex = writer.GetTuple(
writer.GetUnsignedConstant(_externalReferences.GetIndex(typeSymbol)),
writer.GetUnsignedConstant((uint)mappingEntry.MetadataHandle)
);
int hashCode = typeSymbol.Type.GetHashCode();
typeMapHashTable.Append((uint)hashCode, hashTableSection.Place(vertex));
}
MemoryStream ms = new MemoryStream();
writer.Save(ms);
byte[] hashTableBytes = ms.ToArray();
_endSymbol.SetSymbolOffset(hashTableBytes.Length);
return new ObjectData(hashTableBytes, Array.Empty<Relocation>(), 1, new ISymbolNode[] { this, _endSymbol });
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
// This node does not trigger generation of other nodes.
if (relocsOnly)
return new ObjectData(Array.Empty<byte>(), Array.Empty<Relocation>(), 1, new ISymbolNode[] { this });
var writer = new NativeWriter();
var typeMapHashTable = new VertexHashtable();
Section hashTableSection = writer.NewSection();
hashTableSection.Place(typeMapHashTable);
foreach (var arrayType in factory.MetadataManager.GetArrayTypeMapping())
{
if (!arrayType.IsSzArray)
continue;
if (!factory.MetadataManager.TypeGeneratesEEType(arrayType))
continue;
// TODO: This should only be emitted for arrays of value types. The type loader builds everything else.
// Go with a necessary type symbol. It will be upgraded to a constructed one if a constructed was emitted.
IEETypeNode arrayTypeSymbol = factory.NecessaryTypeSymbol(arrayType);
Vertex vertex = writer.GetUnsignedConstant(_externalReferences.GetIndex(arrayTypeSymbol));
int hashCode = arrayType.GetHashCode();
typeMapHashTable.Append((uint)hashCode, hashTableSection.Place(vertex));
}
MemoryStream ms = new MemoryStream();
writer.Save(ms);
byte[] hashTableBytes = ms.ToArray();
_endSymbol.SetSymbolOffset(hashTableBytes.Length);
return new ObjectData(hashTableBytes, Array.Empty<Relocation>(), 1, new ISymbolNode[] { this, _endSymbol });
}
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Flags);
writer.Write(Name);
writer.Write(HashAlgorithm);
writer.Write(MajorVersion);
writer.Write(MinorVersion);
writer.Write(BuildNumber);
writer.Write(RevisionNumber);
writer.Write(PublicKey);
writer.Write(Culture);
writer.Write(RootNamespaceDefinition);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(ElementType == null ||
ElementType.HandleType == HandleType.TypeDefinition ||
ElementType.HandleType == HandleType.TypeReference ||
ElementType.HandleType == HandleType.TypeSpecification ||
ElementType.HandleType == HandleType.ModifiedType);
writer.Write(ElementType);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Method);
writer.Write(EnclosingType);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Number);
writer.Write(Flags);
writer.Write(Kind);
writer.Write(Name);
Debug.Assert(Constraints.TrueForAll(handle => handle == null ||
handle.HandleType == HandleType.TypeDefinition ||
handle.HandleType == HandleType.TypeReference ||
handle.HandleType == HandleType.TypeSpecification));
writer.Write(Constraints);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Number);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(ParentNamespaceOrType == null ||
ParentNamespaceOrType.HandleType == HandleType.NamespaceReference ||
ParentNamespaceOrType.HandleType == HandleType.TypeReference);
writer.Write(ParentNamespaceOrType);
writer.Write(TypeName);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Scope);
writer.Write(Name);
writer.Write(NestedTypes);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(ParentScopeOrNamespace == null ||
ParentScopeOrNamespace.HandleType == HandleType.NamespaceDefinition ||
ParentScopeOrNamespace.HandleType == HandleType.ScopeDefinition);
writer.Write(ParentScopeOrNamespace);
writer.Write(Name);
writer.Write(TypeDefinitions);
writer.Write(TypeForwarders);
writer.Write(NamespaceDefinitions);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(IsOptional);
Debug.Assert(ModifierType == null ||
ModifierType.HandleType == HandleType.TypeDefinition ||
ModifierType.HandleType == HandleType.TypeReference ||
ModifierType.HandleType == HandleType.TypeSpecification);
writer.Write(ModifierType);
Debug.Assert(Type == null ||
Type.HandleType == HandleType.TypeDefinition ||
Type.HandleType == HandleType.TypeReference ||
Type.HandleType == HandleType.TypeSpecification ||
Type.HandleType == HandleType.ModifiedType);
writer.Write(Type);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Attributes);
writer.Write(Method);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(Method == null ||
Method.HandleType == HandleType.QualifiedMethod ||
Method.HandleType == HandleType.MemberReference);
writer.Write(Method);
Debug.Assert(GenericTypeArguments.TrueForAll(handle => handle == null ||
handle.HandleType == HandleType.TypeDefinition ||
handle.HandleType == HandleType.TypeReference ||
handle.HandleType == HandleType.TypeSpecification));
writer.Write(GenericTypeArguments);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(MethodBody == null ||
MethodBody.HandleType == HandleType.QualifiedMethod ||
MethodBody.HandleType == HandleType.MemberReference);
writer.Write(MethodBody);
Debug.Assert(MethodDeclaration == null ||
MethodDeclaration.HandleType == HandleType.QualifiedMethod ||
MethodDeclaration.HandleType == HandleType.MemberReference);
writer.Write(MethodDeclaration);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Flags);
writer.Write(ImplFlags);
writer.Write(Name);
writer.Write(Signature);
writer.Write(Parameters);
writer.Write(GenericParameters);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(Parent == null ||
Parent.HandleType == HandleType.TypeDefinition ||
Parent.HandleType == HandleType.TypeReference ||
Parent.HandleType == HandleType.TypeSpecification);
writer.Write(Parent);
writer.Write(Name);
Debug.Assert(Signature == null ||
Signature.HandleType == HandleType.MethodSignature ||
Signature.HandleType == HandleType.FieldSignature);
writer.Write(Signature);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Flags);
writer.Write(Name);
writer.Write(MajorVersion);
writer.Write(MinorVersion);
writer.Write(BuildNumber);
writer.Write(RevisionNumber);
writer.Write(PublicKeyOrToken);
writer.Write(Culture);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Flags);
Debug.Assert(BaseType == null ||
BaseType.HandleType == HandleType.TypeDefinition ||
BaseType.HandleType == HandleType.TypeReference ||
BaseType.HandleType == HandleType.TypeSpecification);
writer.Write(BaseType);
writer.Write(NamespaceDefinition);
writer.Write(Name);
writer.Write(Size);
writer.Write(PackingSize);
writer.Write(EnclosingType);
writer.Write(NestedTypes);
writer.Write(Methods);
writer.Write(Fields);
writer.Write(Properties);
writer.Write(Events);
writer.Write(GenericParameters);
Debug.Assert(Interfaces.TrueForAll(handle => handle == null ||
handle.HandleType == HandleType.TypeDefinition ||
handle.HandleType == HandleType.TypeReference ||
handle.HandleType == HandleType.TypeSpecification));
writer.Write(Interfaces);
writer.Write(MethodImpls);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(Value == null ||
Value.HandleType == HandleType.ConstantByteValue ||
Value.HandleType == HandleType.ConstantSByteValue ||
Value.HandleType == HandleType.ConstantInt16Value ||
Value.HandleType == HandleType.ConstantUInt16Value ||
Value.HandleType == HandleType.ConstantInt32Value ||
Value.HandleType == HandleType.ConstantUInt32Value ||
Value.HandleType == HandleType.ConstantInt64Value ||
Value.HandleType == HandleType.ConstantUInt64Value);
writer.Write(Value);
Debug.Assert(Type == null ||
Type.HandleType == HandleType.TypeDefinition ||
Type.HandleType == HandleType.TypeReference);
writer.Write(Type);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(GenericType == null ||
GenericType.HandleType == HandleType.TypeDefinition ||
GenericType.HandleType == HandleType.TypeReference ||
GenericType.HandleType == HandleType.TypeSpecification);
writer.Write(GenericType);
Debug.Assert(GenericTypeArguments.TrueForAll(handle => handle == null ||
handle.HandleType == HandleType.TypeDefinition ||
handle.HandleType == HandleType.TypeReference ||
handle.HandleType == HandleType.TypeSpecification));
writer.Write(GenericTypeArguments);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Value);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(Signature == null ||
Signature.HandleType == HandleType.TypeDefinition ||
Signature.HandleType == HandleType.TypeReference ||
Signature.HandleType == HandleType.TypeInstantiationSignature ||
Signature.HandleType == HandleType.SZArraySignature ||
Signature.HandleType == HandleType.ArraySignature ||
Signature.HandleType == HandleType.PointerSignature ||
Signature.HandleType == HandleType.ByReferenceSignature ||
Signature.HandleType == HandleType.TypeVariableSignature ||
Signature.HandleType == HandleType.MethodTypeVariableSignature);
writer.Write(Signature);
writer.Write(CustomAttributes);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(CallingConvention);
Debug.Assert(Type == null ||
Type.HandleType == HandleType.TypeDefinition ||
Type.HandleType == HandleType.TypeReference ||
Type.HandleType == HandleType.TypeSpecification ||
Type.HandleType == HandleType.ModifiedType);
writer.Write(Type);
Debug.Assert(Parameters.TrueForAll(handle => handle == null ||
handle.HandleType == HandleType.TypeDefinition ||
handle.HandleType == HandleType.TypeReference ||
handle.HandleType == HandleType.TypeSpecification ||
handle.HandleType == HandleType.ModifiedType));
writer.Write(Parameters);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
Debug.Assert(ParentScopeOrNamespace == null ||
ParentScopeOrNamespace.HandleType == HandleType.NamespaceReference ||
ParentScopeOrNamespace.HandleType == HandleType.ScopeReference);
writer.Write(ParentScopeOrNamespace);
writer.Write(Name);
} // Save
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Flags);
Debug.Assert(Type == null ||
Type.HandleType == HandleType.TypeDefinition ||
Type.HandleType == HandleType.TypeReference ||
Type.HandleType == HandleType.TypeSpecification);
writer.Write(Type);
Debug.Assert(Value == null ||
Value.HandleType == HandleType.TypeDefinition ||
Value.HandleType == HandleType.TypeReference ||
Value.HandleType == HandleType.TypeSpecification ||
Value.HandleType == HandleType.ConstantBooleanArray ||
Value.HandleType == HandleType.ConstantBooleanValue ||
Value.HandleType == HandleType.ConstantByteArray ||
Value.HandleType == HandleType.ConstantByteValue ||
Value.HandleType == HandleType.ConstantCharArray ||
Value.HandleType == HandleType.ConstantCharValue ||
Value.HandleType == HandleType.ConstantDoubleArray ||
Value.HandleType == HandleType.ConstantDoubleValue ||
Value.HandleType == HandleType.ConstantHandleArray ||
Value.HandleType == HandleType.ConstantInt16Array ||
Value.HandleType == HandleType.ConstantInt16Value ||
Value.HandleType == HandleType.ConstantInt32Array ||
Value.HandleType == HandleType.ConstantInt32Value ||
Value.HandleType == HandleType.ConstantInt64Array ||
Value.HandleType == HandleType.ConstantInt64Value ||
Value.HandleType == HandleType.ConstantReferenceValue ||
Value.HandleType == HandleType.ConstantSByteArray ||
Value.HandleType == HandleType.ConstantSByteValue ||
Value.HandleType == HandleType.ConstantSingleArray ||
Value.HandleType == HandleType.ConstantSingleValue ||
Value.HandleType == HandleType.ConstantStringArray ||
Value.HandleType == HandleType.ConstantStringValue ||
Value.HandleType == HandleType.ConstantUInt16Array ||
Value.HandleType == HandleType.ConstantUInt16Value ||
Value.HandleType == HandleType.ConstantUInt32Array ||
Value.HandleType == HandleType.ConstantUInt32Value ||
Value.HandleType == HandleType.ConstantUInt64Array ||
Value.HandleType == HandleType.ConstantUInt64Value);
writer.Write(Value);
} // Save
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
// This node does not trigger generation of other nodes.
if (relocsOnly)
return new ObjectData(Array.Empty<byte>(), Array.Empty<Relocation>(), 1, new ISymbolNode[] { this });
var writer = new NativeWriter();
var typeMapHashTable = new VertexHashtable();
Section hashTableSection = writer.NewSection();
hashTableSection.Place(typeMapHashTable);
// Get a list of all methods that have a method body and metadata from the metadata manager.
foreach (var mappingEntry in factory.MetadataManager.GetMethodMapping())
{
MethodDesc method = mappingEntry.Entity;
// The current format requires us to have an EEType for the owning type. We might want to lift this.
if (!factory.MetadataManager.TypeGeneratesEEType(method.OwningType))
continue;
// We have a method body, we have a metadata token, but we can't get an invoke stub. Bail.
if (!factory.MetadataManager.HasReflectionInvokeStub(method))
continue;
InvokeTableFlags flags = 0;
if (method.HasInstantiation)
flags |= InvokeTableFlags.IsGenericMethod;
if (method.GetCanonMethodTarget(CanonicalFormKind.Specific).RequiresInstArg())
flags |= InvokeTableFlags.RequiresInstArg;
// TODO: better check for default public(!) constructor
if (method.IsConstructor && method.Signature.Length == 0)
flags |= InvokeTableFlags.IsDefaultConstructor;
// TODO: HasVirtualInvoke
if (!method.IsAbstract)
flags |= InvokeTableFlags.HasEntrypoint;
// Once we have a true multi module compilation story, we'll need to start emitting entries where this is not set.
flags |= InvokeTableFlags.HasMetadataHandle;
// TODO: native signature for P/Invokes and NativeCallable methods
if (method.IsRawPInvoke() || method.IsNativeCallable)
continue;
// Grammar of an entry in the hash table:
// Flags + DeclaringType + MetadataHandle/NameAndSig + Entrypoint + DynamicInvokeMethod + [NumGenericArgs + GenericArgs]
Vertex vertex = writer.GetUnsignedConstant((uint)flags);
if ((flags & InvokeTableFlags.HasMetadataHandle) != 0)
{
// Only store the offset portion of the metadata handle to get better integer compression
vertex = writer.GetTuple(vertex,
writer.GetUnsignedConstant((uint)(mappingEntry.MetadataHandle & MetadataGeneration.MetadataOffsetMask)));
}
else
{
// TODO: no MD handle case
}
// Go with a necessary type symbol. It will be upgraded to a constructed one if a constructed was emitted.
IEETypeNode owningTypeSymbol = factory.NecessaryTypeSymbol(method.OwningType);
vertex = writer.GetTuple(vertex,
writer.GetUnsignedConstant(_externalReferences.GetIndex(owningTypeSymbol)));
if ((flags & InvokeTableFlags.HasEntrypoint) != 0)
{
vertex = writer.GetTuple(vertex,
writer.GetUnsignedConstant(_externalReferences.GetIndex(
factory.MethodEntrypoint(method.GetCanonMethodTarget(CanonicalFormKind.Specific)))));
}
// TODO: data to generate the generic dictionary with the type loader
MethodDesc invokeStubMethod = factory.MetadataManager.GetReflectionInvokeStub(method);
MethodDesc canonInvokeStubMethod = invokeStubMethod.GetCanonMethodTarget(CanonicalFormKind.Specific);
if (invokeStubMethod != canonInvokeStubMethod)
{
vertex = writer.GetTuple(vertex,
writer.GetUnsignedConstant(_externalReferences.GetIndex(factory.FatFunctionPointer(invokeStubMethod), FatFunctionPointerConstants.Offset) << 1));
}
else
{
vertex = writer.GetTuple(vertex,
writer.GetUnsignedConstant(_externalReferences.GetIndex(factory.MethodEntrypoint(invokeStubMethod)) << 1));
}
if ((flags & InvokeTableFlags.IsGenericMethod) != 0)
{
if ((flags & InvokeTableFlags.RequiresInstArg) == 0 || (flags & InvokeTableFlags.HasEntrypoint) == 0)
{
VertexSequence args = new VertexSequence();
for (int i = 0; i < method.Instantiation.Length; i++)
{
uint argId = _externalReferences.GetIndex(factory.NecessaryTypeSymbol(method.Instantiation[i]));
args.Append(writer.GetUnsignedConstant(argId));
}
vertex = writer.GetTuple(vertex, args);
}
else
{
uint dictionaryId = _externalReferences.GetIndex(factory.MethodGenericDictionary(method));
vertex = writer.GetTuple(vertex, writer.GetUnsignedConstant(dictionaryId));
}
}
int hashCode = method.GetCanonMethodTarget(CanonicalFormKind.Specific).OwningType.GetHashCode();
typeMapHashTable.Append((uint)hashCode, hashTableSection.Place(vertex));
}
MemoryStream ms = new MemoryStream();
writer.Save(ms);
byte[] hashTableBytes = ms.ToArray();
_endSymbol.SetSymbolOffset(hashTableBytes.Length);
return new ObjectData(hashTableBytes, Array.Empty<Relocation>(), 1, new ISymbolNode[] { this, _endSymbol });
}
} // GetHashCode
internal override void Save(NativeWriter writer)
{
writer.Write(Flags);
writer.Write(Name);
writer.Write(Signature);
writer.Write(MethodSemantics);
Debug.Assert(DefaultValue == null ||
DefaultValue.HandleType == HandleType.TypeDefinition ||
DefaultValue.HandleType == HandleType.TypeReference ||
DefaultValue.HandleType == HandleType.TypeSpecification ||
DefaultValue.HandleType == HandleType.ConstantBooleanArray ||
DefaultValue.HandleType == HandleType.ConstantBooleanValue ||
DefaultValue.HandleType == HandleType.ConstantByteArray ||
DefaultValue.HandleType == HandleType.ConstantByteValue ||
DefaultValue.HandleType == HandleType.ConstantCharArray ||
DefaultValue.HandleType == HandleType.ConstantCharValue ||
DefaultValue.HandleType == HandleType.ConstantDoubleArray ||
DefaultValue.HandleType == HandleType.ConstantDoubleValue ||
DefaultValue.HandleType == HandleType.ConstantHandleArray ||
DefaultValue.HandleType == HandleType.ConstantInt16Array ||
DefaultValue.HandleType == HandleType.ConstantInt16Value ||
DefaultValue.HandleType == HandleType.ConstantInt32Array ||
DefaultValue.HandleType == HandleType.ConstantInt32Value ||
DefaultValue.HandleType == HandleType.ConstantInt64Array ||
DefaultValue.HandleType == HandleType.ConstantInt64Value ||
DefaultValue.HandleType == HandleType.ConstantReferenceValue ||
DefaultValue.HandleType == HandleType.ConstantSByteArray ||
DefaultValue.HandleType == HandleType.ConstantSByteValue ||
DefaultValue.HandleType == HandleType.ConstantSingleArray ||
DefaultValue.HandleType == HandleType.ConstantSingleValue ||
DefaultValue.HandleType == HandleType.ConstantStringArray ||
DefaultValue.HandleType == HandleType.ConstantStringValue ||
DefaultValue.HandleType == HandleType.ConstantUInt16Array ||
DefaultValue.HandleType == HandleType.ConstantUInt16Value ||
DefaultValue.HandleType == HandleType.ConstantUInt32Array ||
DefaultValue.HandleType == HandleType.ConstantUInt32Value ||
DefaultValue.HandleType == HandleType.ConstantUInt64Array ||
DefaultValue.HandleType == HandleType.ConstantUInt64Value);
writer.Write(DefaultValue);
writer.Write(CustomAttributes);
} // Save
