/// <summary>
/// Encodes a method body and adds it to the method body stream.
/// </summary>
/// <param name="codeSize">Number of bytes to be reserved for instructions.</param>
/// <param name="maxStack">Max stack.</param>
/// <param name="exceptionRegionCount">Number of exception regions.</param>
/// <param name="hasSmallExceptionRegions">True if the exception regions should be encoded in 'small' format.</param>
/// <param name="localVariablesSignature">Local variables signature handle.</param>
/// <param name="attributes">Attributes.</param>
/// <param name="hasDynamicStackAllocation">True if the method allocates from dynamic local memory pool (<c>localloc</c> instruction).</param>
/// <returns>The offset of the encoded body within the method body stream.</returns>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="codeSize"/>, <paramref name="exceptionRegionCount"/>, or <paramref name="maxStack"/> is out of allowed range.
/// </exception>
public MethodBody AddMethodBody(
int codeSize,
int maxStack = 8,
int exceptionRegionCount = 0,
bool hasSmallExceptionRegions = true,
StandaloneSignatureHandle localVariablesSignature = default,
MethodBodyAttributes attributes = MethodBodyAttributes.InitLocals,
bool hasDynamicStackAllocation = false)
{
if (codeSize < 0)
{
Throw.ArgumentOutOfRange(nameof(codeSize));
}
if (unchecked ((uint)maxStack) > ushort.MaxValue)
{
Throw.ArgumentOutOfRange(nameof(maxStack));
}
if (!ExceptionRegionEncoder.IsExceptionRegionCountInBounds(exceptionRegionCount))
{
Throw.ArgumentOutOfRange(nameof(exceptionRegionCount));
}
int bodyOffset = SerializeHeader(codeSize, (ushort)maxStack, exceptionRegionCount, attributes, localVariablesSignature, hasDynamicStackAllocation);
var instructions = Builder.ReserveBytes(codeSize);
var regionEncoder = (exceptionRegionCount > 0) ?
ExceptionRegionEncoder.SerializeTableHeader(Builder, exceptionRegionCount, hasSmallExceptionRegions) : default;
return(new MethodBody(bodyOffset, instructions, regionEncoder));
}
internal void SerializeExceptionTable(BlobBuilder builder)
{
if (_lazyExceptionHandlers == null || _lazyExceptionHandlers.Count == 0)
{
return;
}
var regionEncoder = ExceptionRegionEncoder.SerializeTableHeader(builder, _lazyExceptionHandlers.Count, HasSmallExceptionRegions());
foreach (var handler in _lazyExceptionHandlers)
{
// Note that labels have been validated when added to the handler list,
// they might not have been marked though.
int tryStart = GetLabelOffsetChecked(handler.TryStart);
int tryEnd = GetLabelOffsetChecked(handler.TryEnd);
int handlerStart = GetLabelOffsetChecked(handler.HandlerStart);
int handlerEnd = GetLabelOffsetChecked(handler.HandlerEnd);
if (tryStart > tryEnd)
{
Throw.InvalidOperation(StarkPlatform.Reflection.Resources.SR.Format(SR.InvalidExceptionRegionBounds, tryStart, tryEnd));
}
if (handlerStart > handlerEnd)
{
Throw.InvalidOperation(StarkPlatform.Reflection.Resources.SR.Format(SR.InvalidExceptionRegionBounds, handlerStart, handlerEnd));
}
int catchTokenOrOffset;
switch (handler.Kind)
{
case ExceptionRegionKind.Catch:
catchTokenOrOffset = MetadataTokens.GetToken(handler.CatchType);
break;
case ExceptionRegionKind.Filter:
catchTokenOrOffset = GetLabelOffsetChecked(handler.FilterStart);
break;
default:
catchTokenOrOffset = 0;
break;
}
regionEncoder.AddUnchecked(
handler.Kind,
tryStart,
tryEnd - tryStart,
handlerStart,
handlerEnd - handlerStart,
catchTokenOrOffset);
}
}