public void WriteSerializedString()
{
var writer = new BlobBuilder(4);
writer.WriteSerializedString("");
writer.WriteSerializedString("a");
writer.WriteSerializedString(null);
writer.WriteSerializedString("");
writer.WriteSerializedString("\ud800"); // hi surrogate
writer.WriteSerializedString("\udc00"); // lo surrogate
writer.WriteSerializedString("\ud800\udc00"); // pair
writer.WriteSerializedString("\udc00\ud800"); // lo + hi
writer.WriteSerializedString("\u1234");
AssertEx.Equal(new byte[]
{
0x00,
0x01, 0x61,
0xff,
0x00,
0x03, 0xED, 0xA0, 0x80,
0x03, 0xED, 0xB0, 0x80,
0x04, 0xF0, 0x90, 0x80, 0x80,
0x06, 0xED, 0xB0, 0x80, 0xED, 0xA0, 0x80,
0x03, 0xE1, 0x88, 0xB4
}, writer.ToArray());
}
/// Just write the dictionary out to a blob as a count followed by
/// a length-prefixed UTF8 encoding of each key and value
private void ConvertDictionaryToBlob(IReadOnlyDictionary <string, string> properties, BlobBuilder builder)
{
int count = properties.Count;
builder.WriteCompressedInteger(count);
foreach (var kvp in properties)
{
builder.WriteSerializedString(kvp.Key);
builder.WriteSerializedString(kvp.Value);
}
}
private static string CompilerFeatureRequiredApplication(
bool?isOptional)
{
var builder = new BlobBuilder();
builder.WriteSerializedString("test");
var featureLengthAndName = string.Join(" ", builder.ToImmutableArray().Select(b => $"{b:x2}"));
var isOptionalText = isOptional switch
{
true => "01 00 54 02 0a 49 73 4f 70 74 69 6f 6e 61 6c 01", // One optional parameter, "IsOptional", true
false => "01 00 54 02 0a 49 73 4f 70 74 69 6f 6e 61 6c 00", // One optional parameter, "IsOptional", false
null => "00 00" // No optional parameters
};
return($"" "
.custom instance void System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute::.ctor(string) = (
01 00 {featureLengthAndName} {isOptionalText}
public void WriteSerializedString()
{
var writer = new BlobBuilder(4);
writer.WriteSerializedString("");
writer.WriteSerializedString("a");
writer.WriteSerializedString(null);
writer.WriteSerializedString("");
writer.WriteSerializedString("\ud800"); // hi surrogate
writer.WriteSerializedString("\udc00"); // lo surrogate
writer.WriteSerializedString("\ud800\udc00"); // pair
writer.WriteSerializedString("\udc00\ud800"); // lo + hi
writer.WriteSerializedString("\u1234");
AssertEx.Equal(new byte[]
{
0x00,
0x01, 0x61,
0xff,
0x00,
0x03, 0xED, 0xA0, 0x80,
0x03, 0xED, 0xB0, 0x80,
0x04, 0xF0, 0x90, 0x80, 0x80,
0x06, 0xED, 0xB0, 0x80, 0xED, 0xA0, 0x80,
0x03, 0xE1, 0x88, 0xB4
}, writer.ToArray());
}
public static ReadyToRunStandaloneMethodMetadata Compute(EcmaMethod wrappedMethod)
{
var metadataReader = wrappedMethod.MetadataReader;
var _module = wrappedMethod.Module;
var rva = wrappedMethod.MetadataReader.GetMethodDefinition(wrappedMethod.Handle).RelativeVirtualAddress;
var _methodBody = _module.PEReader.GetMethodBody(rva);
byte[] _alternateILStream = _methodBody.GetILBytes();
var exceptionRegions = _methodBody.ExceptionRegions;
ILExceptionRegion[] _exceptionRegions;
int length = exceptionRegions.Length;
if (length == 0)
{
_exceptionRegions = Array.Empty <ILExceptionRegion>();
}
else
{
_exceptionRegions = new ILExceptionRegion[length];
for (int i = 0; i < length; i++)
{
var exceptionRegion = exceptionRegions[i];
_exceptionRegions[i] = new ILExceptionRegion(
(ILExceptionRegionKind)exceptionRegion.Kind, // assumes that ILExceptionRegionKind and ExceptionRegionKind enums are in sync
exceptionRegion.TryOffset,
exceptionRegion.TryLength,
exceptionRegion.HandlerOffset,
exceptionRegion.HandlerLength,
MetadataTokens.GetToken(exceptionRegion.CatchType),
exceptionRegion.FilterOffset);
}
}
BlobReader localsBlob = default(BlobReader);
if (!_methodBody.LocalSignature.IsNil)
{
localsBlob = wrappedMethod.MetadataReader.GetBlobReader(wrappedMethod.MetadataReader.GetStandaloneSignature(_methodBody.LocalSignature).Signature);
}
AlternativeTypeRefProvider alternateTypes = new AlternativeTypeRefProvider();
EcmaSignatureEncoder <AlternativeTypeRefProvider> alternateEncoder = new EcmaSignatureEncoder <AlternativeTypeRefProvider>(alternateTypes);
Dictionary <int, int> _alternateNonTokenStrings = new Dictionary <int, int>();
BlobBuilder _alternateNonTypeRefStream = new BlobBuilder();
BlobBuilder _nonCodeAlternateBlob = new BlobBuilder();
{
// Generate alternate stream for exceptions.
_nonCodeAlternateBlob.WriteCompressedInteger(_exceptionRegions.Length);
for (int i = 0; i < _exceptionRegions.Length; i++)
{
var region = _exceptionRegions[i];
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.Kind);
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.TryOffset);
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.TryLength);
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.HandlerOffset);
_nonCodeAlternateBlob.WriteCompressedInteger((int)region.HandlerLength);
if (region.Kind == ILExceptionRegionKind.Catch)
{
int alternateToken = GetAlternateStreamToken(region.ClassToken);
int encodedToken = CodedIndex.TypeDefOrRefOrSpec(MetadataTokens.EntityHandle(alternateToken));
_nonCodeAlternateBlob.WriteCompressedInteger(encodedToken);
}
else if (region.Kind == ILExceptionRegionKind.Filter)
{
_nonCodeAlternateBlob.WriteCompressedInteger(region.FilterOffset);
}
}
if (localsBlob.Length == 0)
{
// No locals. Encode a 2 to indicate this
_nonCodeAlternateBlob.WriteByte(2);
}
else
{
_nonCodeAlternateBlob.WriteByte(_methodBody.LocalVariablesInitialized ? (byte)1 : (byte)0);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(localsBlob, _nonCodeAlternateBlob, GetAlternateStreamToken);
sigTranslator.ParseLocalsSignature();
}
}
ILTokenReplacer.Replace(_alternateILStream, GetAlternateStreamToken);
// Add all the streams together into the _nonCodeAlternateBlob
int expectedFinalSize = _nonCodeAlternateBlob.Count + _alternateILStream.Length + _alternateNonTypeRefStream.Count;
_nonCodeAlternateBlob.WriteBytes(_alternateILStream);
_nonCodeAlternateBlob.LinkSuffix(_alternateNonTypeRefStream);
Debug.Assert(expectedFinalSize == _nonCodeAlternateBlob.Count);
ReadyToRunStandaloneMethodMetadata methodBlock = new ReadyToRunStandaloneMethodMetadata();
methodBlock.ConstantData = _nonCodeAlternateBlob.ToArray();
methodBlock.TypeRefs = alternateTypes._alternateTypeRefStream.ToArray();
return(methodBlock);
///// HELPER FUNCTIONS
unsafe int GetAlternateStreamToken(int token)
{
if (token == 0 || !_alternateNonTokenStrings.TryGetValue(token, out int alternateToken))
{
var handle = MetadataTokens.Handle(token);
if (handle.Kind == HandleKind.TypeDefinition || handle.Kind == HandleKind.TypeReference)
{
EcmaType ecmaType = (EcmaType)wrappedMethod.Module.GetObject(MetadataTokens.EntityHandle(token));
alternateToken = MetadataTokens.GetToken(alternateTypes.GetTypeDefOrRefHandleForTypeDesc(ecmaType));
}
else
{
BlobBuilder blob = new BlobBuilder();
int flag = 0;
if (handle.Kind == HandleKind.UserString)
{
string strAlternate = metadataReader.GetUserString((UserStringHandle)handle);
flag = 0x70000000;
blob.WriteCompressedInteger(strAlternate.Length);
fixed(char *charData = strAlternate)
{
blob.WriteBytes((byte *)charData, strAlternate.Length * 2);
}
// TODO: consider encoding via wtf-8, or possibly utf-8
}
else if (handle.Kind == HandleKind.TypeSpecification)
{
flag = 0x1B000000;
var sigBlob = metadataReader.GetBlobReader(metadataReader.GetTypeSpecification((TypeSpecificationHandle)handle).Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseType();
}
else if (handle.Kind == HandleKind.MemberReference)
{
flag = 0x0a000000;
var memberReference = metadataReader.GetMemberReference((MemberReferenceHandle)handle);
var sigBlob = metadataReader.GetBlobReader(memberReference.Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseMemberRefSignature();
blob.WriteSerializedString(metadataReader.GetString(memberReference.Name));
blob.WriteCompressedInteger(CodedIndex.MemberRefParent(MetadataTokens.EntityHandle(GetAlternateStreamToken(MetadataTokens.GetToken(memberReference.Parent)))));
}
else if (handle.Kind == HandleKind.MethodDefinition)
{
flag = 0x0a000000;
var methodDefinition = metadataReader.GetMethodDefinition((MethodDefinitionHandle)handle);
var sigBlob = metadataReader.GetBlobReader(methodDefinition.Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseMethodSignature();
blob.WriteSerializedString(metadataReader.GetString(methodDefinition.Name));
blob.WriteCompressedInteger(CodedIndex.MemberRefParent(MetadataTokens.EntityHandle(GetAlternateStreamToken(MetadataTokens.GetToken(methodDefinition.GetDeclaringType())))));
}
else if (handle.Kind == HandleKind.FieldDefinition)
{
flag = 0x0a000000;
var fieldDefinition = metadataReader.GetFieldDefinition((FieldDefinitionHandle)handle);
var sigBlob = metadataReader.GetBlobReader(fieldDefinition.Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseFieldSignature();
blob.WriteSerializedString(metadataReader.GetString(fieldDefinition.Name));
blob.WriteCompressedInteger(CodedIndex.MemberRefParent(MetadataTokens.EntityHandle(GetAlternateStreamToken(MetadataTokens.GetToken(fieldDefinition.GetDeclaringType())))));
}
else if (handle.Kind == HandleKind.MethodSpecification)
{
flag = 0x2B000000;
var methodSpecification = metadataReader.GetMethodSpecification((MethodSpecificationHandle)handle);
var sigBlob = metadataReader.GetBlobReader(methodSpecification.Signature);
blob.WriteCompressedInteger(MetadataTokens.GetRowNumber(MetadataTokens.EntityHandle(GetAlternateStreamToken(MetadataTokens.GetToken(methodSpecification.Method)))));
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseMethodSpecSignature();
}
else if (handle.Kind == HandleKind.StandaloneSignature)
{
flag = 0x11000000;
var reader = wrappedMethod.Module.MetadataReader;
var sigBlob = reader.GetBlobReader(reader.GetStandaloneSignature((StandaloneSignatureHandle)handle).Signature);
EcmaSignatureTranslator sigTranslator = new EcmaSignatureTranslator(sigBlob, blob, GetAlternateStreamToken);
sigTranslator.ParseMethodSignature();
}
_alternateNonTypeRefStream.WriteBytes(blob.ToArray());
alternateToken = (_alternateNonTokenStrings.Count + 1) | flag;
}
_alternateNonTokenStrings.Add(token, alternateToken);
}
return(alternateToken);
}
}