6902 lines
231 KiB
C#
6902 lines
231 KiB
C#
|
using System;
|
||
|
|
using System.Collections.Generic;
|
||
|
|
using System.Collections.Immutable;
|
||
|
|
using System.Linq;
|
||
|
|
using System.Reflection.Metadata;
|
||
|
|
using System.Runtime.CompilerServices;
|
||
|
|
using System.Threading;
|
||
|
|
using Microsoft.Cci;
|
||
|
|
using Microsoft.CodeAnalysis.CSharp.Emit;
|
||
|
|
using Microsoft.CodeAnalysis.CSharp.Emit.NoPia;
|
||
|
|
using Microsoft.CodeAnalysis.CSharp.Symbols;
|
||
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax;
|
||
|
|
using Microsoft.CodeAnalysis.CodeGen;
|
||
|
|
using Microsoft.CodeAnalysis.Emit;
|
||
|
|
using Microsoft.CodeAnalysis.PooledObjects;
|
||
|
|
using Microsoft.CodeAnalysis.Symbols;
|
||
|
|
using Microsoft.CodeAnalysis.Text;
|
||
|
|
using Roslyn.Utilities;
|
||
|
|
|
||
|
|
namespace Microsoft.CodeAnalysis.CSharp.CodeGen;
|
||
|
|
|
||
|
|
internal sealed class CodeGenerator
|
||
|
|
{
|
||
|
|
private enum IndirectReturnState : byte
|
||
|
|
{
|
||
|
|
NotNeeded,
|
||
|
|
Needed,
|
||
|
|
Emitted
|
||
|
|
}
|
||
|
|
|
||
|
|
private enum ArrayInitializerStyle
|
||
|
|
{
|
||
|
|
Element,
|
||
|
|
Block,
|
||
|
|
Mixed
|
||
|
|
}
|
||
|
|
|
||
|
|
private readonly struct IndexDesc(int index, ImmutableArray<BoundExpression> initializers)
|
||
|
|
{
|
||
|
|
public readonly int Index = index;
|
||
|
|
|
||
|
|
public readonly ImmutableArray<BoundExpression> Initializers = initializers;
|
||
|
|
}
|
||
|
|
|
||
|
|
private class EmitCancelledException : Exception
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
private enum UseKind
|
||
|
|
{
|
||
|
|
Unused,
|
||
|
|
UsedAsValue,
|
||
|
|
UsedAsAddress
|
||
|
|
}
|
||
|
|
|
||
|
|
private sealed class IsConditionalConstrainedCallThatMustUseTempForReferenceTypeReceiverWalker : BoundTreeWalkerWithStackGuardWithoutRecursionOnTheLeftOfBinaryOperator
|
||
|
|
{
|
||
|
|
private readonly BoundLoweredConditionalAccess _conditionalAccess;
|
||
|
|
|
||
|
|
private bool? _result;
|
||
|
|
|
||
|
|
private IsConditionalConstrainedCallThatMustUseTempForReferenceTypeReceiverWalker(BoundLoweredConditionalAccess conditionalAccess)
|
||
|
|
{
|
||
|
|
_conditionalAccess = conditionalAccess;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool Analyze(BoundLoweredConditionalAccess conditionalAccess)
|
||
|
|
{
|
||
|
|
IsConditionalConstrainedCallThatMustUseTempForReferenceTypeReceiverWalker isConditionalConstrainedCallThatMustUseTempForReferenceTypeReceiverWalker = new IsConditionalConstrainedCallThatMustUseTempForReferenceTypeReceiverWalker(conditionalAccess);
|
||
|
|
isConditionalConstrainedCallThatMustUseTempForReferenceTypeReceiverWalker.Visit(conditionalAccess.WhenNotNull);
|
||
|
|
return isConditionalConstrainedCallThatMustUseTempForReferenceTypeReceiverWalker._result == true;
|
||
|
|
}
|
||
|
|
|
||
|
|
public override BoundNode Visit(BoundNode node)
|
||
|
|
{
|
||
|
|
if (_result.HasValue)
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return base.Visit(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override void VisitReceiver(BoundCall node)
|
||
|
|
{
|
||
|
|
if (node.ReceiverOpt is BoundConditionalReceiver { Id: var id } && id == _conditionalAccess.Id)
|
||
|
|
{
|
||
|
|
_result = !IsSafeToDereferenceReceiverRefAfterEvaluatingArguments(node.Arguments);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public override BoundNode VisitConditionalReceiver(BoundConditionalReceiver node)
|
||
|
|
{
|
||
|
|
if (node.Id == _conditionalAccess.Id)
|
||
|
|
{
|
||
|
|
_result = false;
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return base.VisitConditionalReceiver(node);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private enum CallKind
|
||
|
|
{
|
||
|
|
Call,
|
||
|
|
CallVirt,
|
||
|
|
ConstrainedCallVirt
|
||
|
|
}
|
||
|
|
|
||
|
|
private class FinallyCloner : BoundTreeRewriterWithStackGuardWithoutRecursionOnTheLeftOfBinaryOperator
|
||
|
|
{
|
||
|
|
private Dictionary<LabelSymbol, GeneratedLabelSymbol> _labelClones;
|
||
|
|
|
||
|
|
private FinallyCloner()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
public static BoundBlock MakeFinallyClone(BoundTryStatement node)
|
||
|
|
{
|
||
|
|
return (BoundBlock)new FinallyCloner().Visit(node.FinallyBlockOpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
public override BoundNode VisitLabelStatement(BoundLabelStatement node)
|
||
|
|
{
|
||
|
|
return node.Update(GetLabelClone(node.Label));
|
||
|
|
}
|
||
|
|
|
||
|
|
public override BoundNode VisitGotoStatement(BoundGotoStatement node)
|
||
|
|
{
|
||
|
|
GeneratedLabelSymbol labelClone = GetLabelClone(node.Label);
|
||
|
|
BoundExpression caseExpressionOpt = node.CaseExpressionOpt;
|
||
|
|
BoundLabel labelExpressionOpt = node.LabelExpressionOpt;
|
||
|
|
return node.Update(labelClone, caseExpressionOpt, labelExpressionOpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
public override BoundNode VisitConditionalGoto(BoundConditionalGoto node)
|
||
|
|
{
|
||
|
|
GeneratedLabelSymbol labelClone = GetLabelClone(node.Label);
|
||
|
|
BoundExpression condition = node.Condition;
|
||
|
|
return node.Update(condition, node.JumpIfTrue, labelClone);
|
||
|
|
}
|
||
|
|
|
||
|
|
public override BoundNode VisitSwitchDispatch(BoundSwitchDispatch node)
|
||
|
|
{
|
||
|
|
BoundExpression expression = node.Expression;
|
||
|
|
GeneratedLabelSymbol labelClone = GetLabelClone(node.DefaultLabel);
|
||
|
|
ArrayBuilder<(ConstantValue, LabelSymbol)> instance = ArrayBuilder<(ConstantValue, LabelSymbol)>.GetInstance();
|
||
|
|
ImmutableArray<(ConstantValue, LabelSymbol)>.Enumerator enumerator = node.Cases.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
var (item, label) = enumerator.Current;
|
||
|
|
instance.Add((item, (LabelSymbol)GetLabelClone(label)));
|
||
|
|
}
|
||
|
|
LengthBasedStringSwitchData lengthBasedStringSwitchDataOpt = node.LengthBasedStringSwitchDataOpt;
|
||
|
|
if (lengthBasedStringSwitchDataOpt != null)
|
||
|
|
{
|
||
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs", 1965);
|
||
|
|
}
|
||
|
|
return node.Update(expression, instance.ToImmutableAndFree(), labelClone, lengthBasedStringSwitchDataOpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
public override BoundNode VisitExpressionStatement(BoundExpressionStatement node)
|
||
|
|
{
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
|
||
|
|
private GeneratedLabelSymbol GetLabelClone(LabelSymbol label)
|
||
|
|
{
|
||
|
|
Dictionary<LabelSymbol, GeneratedLabelSymbol> dictionary = _labelClones;
|
||
|
|
if (dictionary == null)
|
||
|
|
{
|
||
|
|
dictionary = (_labelClones = new Dictionary<LabelSymbol, GeneratedLabelSymbol>());
|
||
|
|
}
|
||
|
|
if (!dictionary.TryGetValue(label, out var value))
|
||
|
|
{
|
||
|
|
value = new GeneratedLabelSymbol("cloned_" + label.Name);
|
||
|
|
dictionary.Add(label, value);
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[CompilerGenerated]
|
||
|
|
private static class _003C_003EO
|
||
|
|
{
|
||
|
|
public static Func<BoundExpression, bool> _003C0_003E__isSafeToDereferenceReceiverRefAfterEvaluatingArgument;
|
||
|
|
|
||
|
|
public static GetStringHashCode _003C1_003E__ComputeStringHash;
|
||
|
|
}
|
||
|
|
|
||
|
|
private readonly MethodSymbol _method;
|
||
|
|
|
||
|
|
private readonly SyntaxNode _methodBodySyntaxOpt;
|
||
|
|
|
||
|
|
private readonly BoundStatement _boundBody;
|
||
|
|
|
||
|
|
private readonly ILBuilder _builder;
|
||
|
|
|
||
|
|
private readonly PEModuleBuilder _module;
|
||
|
|
|
||
|
|
private readonly BindingDiagnosticBag _diagnostics;
|
||
|
|
|
||
|
|
private readonly ILEmitStyle _ilEmitStyle;
|
||
|
|
|
||
|
|
private readonly bool _emitPdbSequencePoints;
|
||
|
|
|
||
|
|
private readonly HashSet<LocalSymbol> _stackLocals;
|
||
|
|
|
||
|
|
private ArrayBuilder<LocalDefinition> _expressionTemps;
|
||
|
|
|
||
|
|
private int _tryNestingLevel;
|
||
|
|
|
||
|
|
private readonly SynthesizedLocalOrdinalsDispenser _synthesizedLocalOrdinals = new SynthesizedLocalOrdinalsDispenser();
|
||
|
|
|
||
|
|
private int _uniqueNameId;
|
||
|
|
|
||
|
|
private static readonly object s_returnLabel = new object();
|
||
|
|
|
||
|
|
private int _asyncCatchHandlerOffset = -1;
|
||
|
|
|
||
|
|
private ArrayBuilder<int> _asyncYieldPoints;
|
||
|
|
|
||
|
|
private ArrayBuilder<int> _asyncResumePoints;
|
||
|
|
|
||
|
|
private IndirectReturnState _indirectReturnState;
|
||
|
|
|
||
|
|
private PooledDictionary<object, TextSpan> _savedSequencePoints;
|
||
|
|
|
||
|
|
private LocalDefinition _returnTemp;
|
||
|
|
|
||
|
|
private bool _sawStackalloc;
|
||
|
|
|
||
|
|
private int _recursionDepth;
|
||
|
|
|
||
|
|
private static readonly ILOpCode[] s_compOpCodes = new ILOpCode[12]
|
||
|
|
{
|
||
|
|
ILOpCode.Clt,
|
||
|
|
ILOpCode.Cgt,
|
||
|
|
ILOpCode.Cgt,
|
||
|
|
ILOpCode.Clt,
|
||
|
|
ILOpCode.Clt_un,
|
||
|
|
ILOpCode.Cgt_un,
|
||
|
|
ILOpCode.Cgt_un,
|
||
|
|
ILOpCode.Clt_un,
|
||
|
|
ILOpCode.Clt,
|
||
|
|
ILOpCode.Cgt_un,
|
||
|
|
ILOpCode.Cgt,
|
||
|
|
ILOpCode.Clt_un
|
||
|
|
};
|
||
|
|
|
||
|
|
private const int IL_OP_CODE_ROW_LENGTH = 4;
|
||
|
|
|
||
|
|
private static readonly ILOpCode[] s_condJumpOpCodes = new ILOpCode[24]
|
||
|
|
{
|
||
|
|
ILOpCode.Blt,
|
||
|
|
ILOpCode.Ble,
|
||
|
|
ILOpCode.Bgt,
|
||
|
|
ILOpCode.Bge,
|
||
|
|
ILOpCode.Bge,
|
||
|
|
ILOpCode.Bgt,
|
||
|
|
ILOpCode.Ble,
|
||
|
|
ILOpCode.Blt,
|
||
|
|
ILOpCode.Blt_un,
|
||
|
|
ILOpCode.Ble_un,
|
||
|
|
ILOpCode.Bgt_un,
|
||
|
|
ILOpCode.Bge_un,
|
||
|
|
ILOpCode.Bge_un,
|
||
|
|
ILOpCode.Bgt_un,
|
||
|
|
ILOpCode.Ble_un,
|
||
|
|
ILOpCode.Blt_un,
|
||
|
|
ILOpCode.Blt,
|
||
|
|
ILOpCode.Ble,
|
||
|
|
ILOpCode.Bgt,
|
||
|
|
ILOpCode.Bge,
|
||
|
|
ILOpCode.Bge_un,
|
||
|
|
ILOpCode.Bgt_un,
|
||
|
|
ILOpCode.Ble_un,
|
||
|
|
ILOpCode.Blt_un
|
||
|
|
};
|
||
|
|
|
||
|
|
private LocalDefinition LazyReturnTemp
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
LocalDefinition val = _returnTemp;
|
||
|
|
if (val == null)
|
||
|
|
{
|
||
|
|
LocalSlotConstraints val2 = (LocalSlotConstraints)(((int)_method.RefKind != 0) ? 1 : 0);
|
||
|
|
SyntaxNode methodBodySyntaxOpt = _methodBodySyntaxOpt;
|
||
|
|
if ((int)_ilEmitStyle == 0 && methodBodySyntaxOpt != null)
|
||
|
|
{
|
||
|
|
int num = _method.CalculateLocalSyntaxOffset(LambdaUtilities.GetDeclaratorPosition(methodBodySyntaxOpt), methodBodySyntaxOpt.SyntaxTree);
|
||
|
|
SynthesizedLocal synthesizedLocal = new SynthesizedLocal(_method, _method.ReturnTypeWithAnnotations, (SynthesizedLocalKind)21, methodBodySyntaxOpt, isPinned: false, isKnownToReferToTempIfReferenceType: false, (RefKind)0);
|
||
|
|
val = _builder.LocalSlotManager.DeclareLocal(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(synthesizedLocal.Type, methodBodySyntaxOpt, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag), (ILocalSymbolInternal)(object)synthesizedLocal, (string)null, synthesizedLocal.SynthesizedKind, new LocalDebugId(num, 0), SynthesizedLocalKindExtensions.PdbAttributes(synthesizedLocal.SynthesizedKind), val2, ImmutableArray<bool>.Empty, ImmutableArray<string>.Empty, false);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
val = AllocateTemp(_method.ReturnType, _boundBody.Syntax, val2);
|
||
|
|
}
|
||
|
|
_returnTemp = val;
|
||
|
|
}
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool EnableEnumArrayBlockInitialization => ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.EnableEnumArrayBlockInitialization;
|
||
|
|
|
||
|
|
public CodeGenerator(MethodSymbol method, BoundStatement boundBody, ILBuilder builder, PEModuleBuilder moduleBuilder, BindingDiagnosticBag diagnostics, OptimizationLevel optimizations, bool emittingPdb)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000b: Expected O, but got Unknown
|
||
|
|
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0089: Invalid comparison between Unknown and I4
|
||
|
|
_method = method;
|
||
|
|
_boundBody = boundBody;
|
||
|
|
_builder = builder;
|
||
|
|
_module = moduleBuilder;
|
||
|
|
_diagnostics = diagnostics;
|
||
|
|
if (!method.GenerateDebugInfo)
|
||
|
|
{
|
||
|
|
_ilEmitStyle = (ILEmitStyle)2;
|
||
|
|
}
|
||
|
|
else if ((int)optimizations == 0)
|
||
|
|
{
|
||
|
|
_ilEmitStyle = (ILEmitStyle)0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_ilEmitStyle = (ILEmitStyle)(IsDebugPlus() ? 1 : 2);
|
||
|
|
}
|
||
|
|
_emitPdbSequencePoints = emittingPdb && method.GenerateDebugInfo;
|
||
|
|
try
|
||
|
|
{
|
||
|
|
_boundBody = Optimizer.Optimize(boundBody, (int)_ilEmitStyle != 2, out _stackLocals);
|
||
|
|
}
|
||
|
|
catch (BoundTreeVisitor.CancelledByStackGuardException ex)
|
||
|
|
{
|
||
|
|
ex.AddAnError(diagnostics);
|
||
|
|
_boundBody = boundBody;
|
||
|
|
}
|
||
|
|
SourceMemberMethodSymbol sourceMemberMethodSymbol = method as SourceMemberMethodSymbol;
|
||
|
|
(BlockSyntax blockBody, ArrowExpressionClauseSyntax arrowBody) obj = sourceMemberMethodSymbol?.Bodies ?? default((BlockSyntax, ArrowExpressionClauseSyntax));
|
||
|
|
BlockSyntax item = obj.blockBody;
|
||
|
|
ArrowExpressionClauseSyntax item2 = obj.arrowBody;
|
||
|
|
_methodBodySyntaxOpt = (SyntaxNode)(object)(item ?? item2 ?? sourceMemberMethodSymbol?.SyntaxNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsDebugPlus()
|
||
|
|
{
|
||
|
|
return ((CompilationOptions)((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.Options).DebugPlusMode;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsPeVerifyCompatEnabled()
|
||
|
|
{
|
||
|
|
return ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.IsPeVerifyCompatEnabled;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool IsStackLocal(LocalSymbol local, HashSet<LocalSymbol> stackLocalsOpt)
|
||
|
|
{
|
||
|
|
return stackLocalsOpt?.Contains(local) ?? false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsStackLocal(LocalSymbol local)
|
||
|
|
{
|
||
|
|
return IsStackLocal(local, _stackLocals);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void Generate(out bool hasStackalloc)
|
||
|
|
{
|
||
|
|
GenerateImpl();
|
||
|
|
hasStackalloc = _sawStackalloc;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void Generate(out int asyncCatchHandlerOffset, out ImmutableArray<int> asyncYieldPoints, out ImmutableArray<int> asyncResumePoints, out bool hasStackAlloc)
|
||
|
|
{
|
||
|
|
GenerateImpl();
|
||
|
|
hasStackAlloc = _sawStackalloc;
|
||
|
|
asyncCatchHandlerOffset = (((BindingDiagnosticBag)_diagnostics).HasAnyErrors() ? (-1) : _builder.GetILOffsetFromMarker(_asyncCatchHandlerOffset));
|
||
|
|
ArrayBuilder<int> asyncYieldPoints2 = _asyncYieldPoints;
|
||
|
|
ArrayBuilder<int> asyncResumePoints2 = _asyncResumePoints;
|
||
|
|
if (asyncYieldPoints2 == null || ((BindingDiagnosticBag)_diagnostics).HasAnyErrors())
|
||
|
|
{
|
||
|
|
asyncYieldPoints = ImmutableArray<int>.Empty;
|
||
|
|
asyncResumePoints = ImmutableArray<int>.Empty;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ArrayBuilder<int> instance = ArrayBuilder<int>.GetInstance();
|
||
|
|
ArrayBuilder<int> instance2 = ArrayBuilder<int>.GetInstance();
|
||
|
|
int count = asyncYieldPoints2.Count;
|
||
|
|
for (int i = 0; i < count; i++)
|
||
|
|
{
|
||
|
|
int iLOffsetFromMarker = _builder.GetILOffsetFromMarker(asyncYieldPoints2[i]);
|
||
|
|
int iLOffsetFromMarker2 = _builder.GetILOffsetFromMarker(asyncResumePoints2[i]);
|
||
|
|
if (iLOffsetFromMarker > 0)
|
||
|
|
{
|
||
|
|
instance.Add(iLOffsetFromMarker);
|
||
|
|
instance2.Add(iLOffsetFromMarker2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
asyncYieldPoints = instance.ToImmutableAndFree();
|
||
|
|
asyncResumePoints = instance2.ToImmutableAndFree();
|
||
|
|
asyncYieldPoints2.Free();
|
||
|
|
asyncResumePoints2.Free();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void GenerateImpl()
|
||
|
|
{
|
||
|
|
SetInitialDebugDocument();
|
||
|
|
if (_emitPdbSequencePoints && _method.IsImplicitlyDeclared)
|
||
|
|
{
|
||
|
|
_builder.DefineInitialHiddenSequencePoint();
|
||
|
|
}
|
||
|
|
try
|
||
|
|
{
|
||
|
|
EmitStatement(_boundBody);
|
||
|
|
if (_indirectReturnState == IndirectReturnState.Needed)
|
||
|
|
{
|
||
|
|
HandleReturn();
|
||
|
|
}
|
||
|
|
if (!((BindingDiagnosticBag)_diagnostics).HasAnyErrors())
|
||
|
|
{
|
||
|
|
_builder.Realize();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (EmitCancelledException)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
_synthesizedLocalOrdinals.Free();
|
||
|
|
_expressionTemps?.Free();
|
||
|
|
_savedSequencePoints?.Free();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void HandleReturn()
|
||
|
|
{
|
||
|
|
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
_builder.MarkLabel(s_returnLabel);
|
||
|
|
if (_emitPdbSequencePoints && !_method.IsIterator && !_method.IsAsync && _methodBodySyntaxOpt is BlockSyntax blockSyntax)
|
||
|
|
{
|
||
|
|
SyntaxTree syntaxTree = blockSyntax.SyntaxTree;
|
||
|
|
SyntaxToken closeBraceToken = blockSyntax.CloseBraceToken;
|
||
|
|
EmitSequencePoint(syntaxTree, ((SyntaxToken)(ref closeBraceToken)).Span);
|
||
|
|
}
|
||
|
|
if (_returnTemp != null)
|
||
|
|
{
|
||
|
|
_builder.EmitLocalLoad(LazyReturnTemp);
|
||
|
|
_builder.EmitRet(false);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitRet(true);
|
||
|
|
}
|
||
|
|
_indirectReturnState = IndirectReturnState.Emitted;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitTypeReferenceToken(ITypeReference symbol, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
_builder.EmitToken((IReference)(object)symbol, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSymbolToken(TypeSymbol symbol, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
EmitTypeReferenceToken(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(symbol, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag), syntaxNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSymbolToken(MethodSymbol method, SyntaxNode syntaxNode, BoundArgListOperator optArgList, bool encodeAsRawDefinitionToken = false)
|
||
|
|
{
|
||
|
|
IMethodReference val = _module.Translate(method, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, optArgList, encodeAsRawDefinitionToken);
|
||
|
|
_builder.EmitToken((IReference)(object)val, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)(encodeAsRawDefinitionToken ? 1 : 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSymbolToken(FieldSymbol symbol, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
IFieldReference val = _module.Translate(symbol, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
_builder.EmitToken((IReference)(object)val, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSignatureToken(FunctionPointerTypeSymbol symbol, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
_builder.EmitToken(_module.Translate(symbol).Signature, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSequencePointStatement(BoundSequencePoint node)
|
||
|
|
{
|
||
|
|
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxNode syntax = node.Syntax;
|
||
|
|
if (_emitPdbSequencePoints)
|
||
|
|
{
|
||
|
|
if (syntax == null)
|
||
|
|
{
|
||
|
|
EmitHiddenSequencePoint();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitSequencePoint(syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
BoundStatement statementOpt = node.StatementOpt;
|
||
|
|
int num = 0;
|
||
|
|
if (statementOpt != null)
|
||
|
|
{
|
||
|
|
num = EmitStatementAndCountInstructions(statementOpt);
|
||
|
|
}
|
||
|
|
if (num == 0 && syntax != null && (int)_ilEmitStyle == 0)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSequencePointStatement(BoundSequencePointWithSpan node)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
TextSpan span = node.Span;
|
||
|
|
if (span != default(TextSpan) && _emitPdbSequencePoints)
|
||
|
|
{
|
||
|
|
EmitSequencePoint(node.SyntaxTree, span);
|
||
|
|
}
|
||
|
|
BoundStatement statementOpt = node.StatementOpt;
|
||
|
|
int num = 0;
|
||
|
|
if (statementOpt != null)
|
||
|
|
{
|
||
|
|
num = EmitStatementAndCountInstructions(statementOpt);
|
||
|
|
}
|
||
|
|
if (num == 0 && span != default(TextSpan) && (int)_ilEmitStyle == 0)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSavePreviousSequencePoint(BoundSavePreviousSequencePoint statement)
|
||
|
|
{
|
||
|
|
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!_emitPdbSequencePoints)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ArrayBuilder<RawSequencePoint> seqPointsOpt = _builder.SeqPointsOpt;
|
||
|
|
if (seqPointsOpt == null)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (int num = seqPointsOpt.Count - 1; num >= 0; num--)
|
||
|
|
{
|
||
|
|
TextSpan span = seqPointsOpt[num].Span;
|
||
|
|
if (!(span == RawSequencePoint.HiddenSequencePointSpan))
|
||
|
|
{
|
||
|
|
if (_savedSequencePoints == null)
|
||
|
|
{
|
||
|
|
_savedSequencePoints = PooledDictionary<object, TextSpan>.GetInstance();
|
||
|
|
}
|
||
|
|
((Dictionary<object, TextSpan>)(object)_savedSequencePoints).Add(statement.Identifier, span);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitRestorePreviousSequencePoint(BoundRestorePreviousSequencePoint node)
|
||
|
|
{
|
||
|
|
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (_savedSequencePoints != null && ((Dictionary<object, TextSpan>)(object)_savedSequencePoints).TryGetValue(node.Identifier, out TextSpan value))
|
||
|
|
{
|
||
|
|
EmitStepThroughSequencePoint(node.Syntax.SyntaxTree, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStepThroughSequencePoint(BoundStepThroughSequencePoint node)
|
||
|
|
{
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
EmitStepThroughSequencePoint(node.Syntax.SyntaxTree, node.Span);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStepThroughSequencePoint(SyntaxTree syntaxTree, TextSpan span)
|
||
|
|
{
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (_emitPdbSequencePoints)
|
||
|
|
{
|
||
|
|
object obj = new object();
|
||
|
|
_builder.EmitConstantValue(ConstantValue.Create(true));
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj, ILOpCode.Nop);
|
||
|
|
EmitSequencePoint(syntaxTree, span);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Nop);
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
EmitHiddenSequencePoint();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void SetInitialDebugDocument()
|
||
|
|
{
|
||
|
|
if (_emitPdbSequencePoints && _methodBodySyntaxOpt != null)
|
||
|
|
{
|
||
|
|
_builder.SetInitialDebugDocument(_methodBodySyntaxOpt.SyntaxTree);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitHiddenSequencePoint()
|
||
|
|
{
|
||
|
|
_builder.DefineHiddenSequencePoint();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSequencePoint(SyntaxNode syntax)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
EmitSequencePoint(syntax.SyntaxTree, syntax.Span);
|
||
|
|
}
|
||
|
|
|
||
|
|
private TextSpan EmitSequencePoint(SyntaxTree syntaxTree, TextSpan span)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
_builder.DefineSequencePoint(syntaxTree, span);
|
||
|
|
return span;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void AddExpressionTemp(LocalDefinition temp)
|
||
|
|
{
|
||
|
|
if (temp != null)
|
||
|
|
{
|
||
|
|
ArrayBuilder<LocalDefinition> val = _expressionTemps;
|
||
|
|
if (val == null)
|
||
|
|
{
|
||
|
|
val = (_expressionTemps = ArrayBuilder<LocalDefinition>.GetInstance());
|
||
|
|
}
|
||
|
|
val.Add(temp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void ReleaseExpressionTemps()
|
||
|
|
{
|
||
|
|
ArrayBuilder<LocalDefinition> expressionTemps = _expressionTemps;
|
||
|
|
if (expressionTemps != null && expressionTemps.Count > 0)
|
||
|
|
{
|
||
|
|
for (int num = _expressionTemps.Count - 1; num >= 0; num--)
|
||
|
|
{
|
||
|
|
LocalDefinition temp = _expressionTemps[num];
|
||
|
|
FreeTemp(temp);
|
||
|
|
}
|
||
|
|
_expressionTemps.Clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitAddress(BoundExpression expression, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
//IL_0242: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0247: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0248: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_024a: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0257: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0259: Invalid comparison between Unknown and I4
|
||
|
|
switch (expression.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.RefValueOperator:
|
||
|
|
EmitRefValueAddress((BoundRefValueOperator)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.Local:
|
||
|
|
return EmitLocalAddress((BoundLocal)expression, addressKind);
|
||
|
|
case BoundKind.Dup:
|
||
|
|
return EmitDupAddress((BoundDup)expression, addressKind);
|
||
|
|
case BoundKind.ComplexConditionalReceiver:
|
||
|
|
EmitComplexConditionalReceiverAddress((BoundComplexConditionalReceiver)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.Parameter:
|
||
|
|
return EmitParameterAddress((BoundParameter)expression, addressKind);
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
return EmitFieldAddress((BoundFieldAccess)expression, addressKind);
|
||
|
|
case BoundKind.ArrayAccess:
|
||
|
|
if (HasHome(expression, addressKind))
|
||
|
|
{
|
||
|
|
EmitArrayElementAddress((BoundArrayAccess)expression, addressKind);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
goto default;
|
||
|
|
case BoundKind.ThisReference:
|
||
|
|
if (expression.Type.IsValueType)
|
||
|
|
{
|
||
|
|
if (HasHome(expression, addressKind))
|
||
|
|
{
|
||
|
|
_builder.EmitLoadArgumentOpcode(0);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
goto default;
|
||
|
|
}
|
||
|
|
_builder.EmitLoadArgumentAddrOpcode(0);
|
||
|
|
break;
|
||
|
|
case BoundKind.PreviousSubmissionReference:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)expression.Kind);
|
||
|
|
case BoundKind.PassByCopy:
|
||
|
|
return EmitPassByCopyAddress((BoundPassByCopy)expression, addressKind);
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
return EmitSequenceAddress((BoundSequence)expression, addressKind);
|
||
|
|
case BoundKind.PointerIndirectionOperator:
|
||
|
|
{
|
||
|
|
BoundExpression operand = ((BoundPointerIndirectionOperator)expression).Operand;
|
||
|
|
EmitExpression(operand, used: true);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.PseudoVariable:
|
||
|
|
EmitPseudoVariableAddress((BoundPseudoVariable)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.Call:
|
||
|
|
{
|
||
|
|
BoundCall call = (BoundCall)expression;
|
||
|
|
if (UseCallResultAsAddress(call, addressKind))
|
||
|
|
{
|
||
|
|
EmitCallExpression(call, UseKind.UsedAsAddress);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
goto default;
|
||
|
|
}
|
||
|
|
case BoundKind.FunctionPointerInvocation:
|
||
|
|
{
|
||
|
|
BoundFunctionPointerInvocation boundFunctionPointerInvocation = (BoundFunctionPointerInvocation)expression;
|
||
|
|
RefKind refKind = boundFunctionPointerInvocation.FunctionPointer.Signature.RefKind;
|
||
|
|
if ((int)refKind == 1 || (Binder.IsAnyReadOnly(addressKind) && (int)refKind == 3))
|
||
|
|
{
|
||
|
|
EmitCalli(boundFunctionPointerInvocation, UseKind.UsedAsAddress);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
goto default;
|
||
|
|
}
|
||
|
|
case BoundKind.DefaultExpression:
|
||
|
|
{
|
||
|
|
TypeSymbol type = expression.Type;
|
||
|
|
LocalDefinition val = AllocateTemp(type, expression.Syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalAddress(val);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Initobj);
|
||
|
|
EmitSymbolToken(type, expression.Syntax);
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
case BoundKind.ConditionalOperator:
|
||
|
|
if (HasHome(expression, addressKind))
|
||
|
|
{
|
||
|
|
EmitConditionalOperatorAddress((BoundConditionalOperator)expression, addressKind);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
goto default;
|
||
|
|
case BoundKind.AssignmentOperator:
|
||
|
|
{
|
||
|
|
BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)expression;
|
||
|
|
if (boundAssignmentOperator.IsRef && HasHome(boundAssignmentOperator, addressKind))
|
||
|
|
{
|
||
|
|
EmitAssignmentExpression(boundAssignmentOperator, UseKind.UsedAsAddress);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
goto default;
|
||
|
|
}
|
||
|
|
case BoundKind.ThrowExpression:
|
||
|
|
EmitExpression(expression, used: true);
|
||
|
|
return null;
|
||
|
|
default:
|
||
|
|
return EmitAddressOfTempClone(expression);
|
||
|
|
case BoundKind.BaseReference:
|
||
|
|
case BoundKind.ConditionalReceiver:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool UseCallResultAsAddress(BoundCall call, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Invalid comparison between Unknown and I4
|
||
|
|
RefKind refKind = call.Method.RefKind;
|
||
|
|
if ((int)refKind != 1)
|
||
|
|
{
|
||
|
|
if (Binder.IsAnyReadOnly(addressKind))
|
||
|
|
{
|
||
|
|
return (int)refKind == 3;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitPassByCopyAddress(BoundPassByCopy passByCopyExpr, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
if (passByCopyExpr.Expression is BoundSequence boundSequence && DigForValueLocal(boundSequence, boundSequence.Value) != null)
|
||
|
|
{
|
||
|
|
return EmitSequenceAddress(boundSequence, addressKind);
|
||
|
|
}
|
||
|
|
return EmitAddressOfTempClone(passByCopyExpr);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConditionalOperatorAddress(BoundConditionalOperator expr, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
object dest = new object();
|
||
|
|
object obj = new object();
|
||
|
|
EmitCondBranch(expr.Condition, ref dest, sense: true);
|
||
|
|
AddExpressionTemp(EmitAddress(expr.Alternative, addressKind));
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, obj, ILOpCode.Nop);
|
||
|
|
_builder.AdjustStack(-1);
|
||
|
|
_builder.MarkLabel(dest);
|
||
|
|
AddExpressionTemp(EmitAddress(expr.Consequence, addressKind));
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitComplexConditionalReceiverAddress(BoundComplexConditionalReceiver expression)
|
||
|
|
{
|
||
|
|
TypeSymbol type = expression.Type;
|
||
|
|
object obj = new object();
|
||
|
|
object obj2 = new object();
|
||
|
|
EmitInitObj(type, used: true, expression.Syntax);
|
||
|
|
EmitBox(type, expression.Syntax);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj, ILOpCode.Nop);
|
||
|
|
EmitAddress(expression.ReferenceTypeReceiver, Binder.AddressKind.ReadOnly);
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, obj2, ILOpCode.Nop);
|
||
|
|
_builder.AdjustStack(-1);
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
EmitReceiverRef(expression.ValueTypeReceiver, Binder.AddressKind.Constrained);
|
||
|
|
_builder.MarkLabel(obj2);
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitLocalAddress(BoundLocal localAccess, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
LocalSymbol localSymbol = localAccess.LocalSymbol;
|
||
|
|
if (!HasHome(localAccess, addressKind))
|
||
|
|
{
|
||
|
|
return EmitAddressOfTempClone(localAccess);
|
||
|
|
}
|
||
|
|
if (IsStackLocal(localSymbol))
|
||
|
|
{
|
||
|
|
if ((int)localSymbol.RefKind == 0)
|
||
|
|
{
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)localSymbol.RefKind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitLocalAddress(GetLocal(localAccess));
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitDupAddress(BoundDup dup, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
if (!HasHome(dup, addressKind))
|
||
|
|
{
|
||
|
|
return EmitAddressOfTempClone(dup);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitPseudoVariableAddress(BoundPseudoVariable expression)
|
||
|
|
{
|
||
|
|
EmitExpression(expression.EmitExpressions.GetAddress(expression), used: true);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitRefValueAddress(BoundRefValueOperator refValue)
|
||
|
|
{
|
||
|
|
EmitExpression(refValue.Operand, used: true);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Refanyval);
|
||
|
|
EmitSymbolToken(refValue.Type, refValue.Syntax);
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitAddressOfTempClone(BoundExpression expression)
|
||
|
|
{
|
||
|
|
EmitExpression(expression, used: true);
|
||
|
|
LocalDefinition val = AllocateTemp(expression.Type, expression.Syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(val);
|
||
|
|
_builder.EmitLocalAddress(val);
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitSequenceAddress(BoundSequence sequence, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
DefineAndRecordLocals(sequence);
|
||
|
|
EmitSideEffects(sequence);
|
||
|
|
LocalDefinition result = EmitAddress(sequence.Value, addressKind);
|
||
|
|
CloseScopeAndKeepLocals(sequence);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static LocalSymbol DigForValueLocal(BoundSequence topSequence, BoundExpression value)
|
||
|
|
{
|
||
|
|
switch (value.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.Local:
|
||
|
|
{
|
||
|
|
LocalSymbol localSymbol = ((BoundLocal)value).LocalSymbol;
|
||
|
|
if (topSequence.Locals.Contains(localSymbol))
|
||
|
|
{
|
||
|
|
return localSymbol;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
return DigForValueLocal(topSequence, ((BoundSequence)value).Value);
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
{
|
||
|
|
BoundFieldAccess boundFieldAccess = (BoundFieldAccess)value;
|
||
|
|
if (!boundFieldAccess.FieldSymbol.IsStatic)
|
||
|
|
{
|
||
|
|
BoundExpression receiverOpt = boundFieldAccess.ReceiverOpt;
|
||
|
|
if (!receiverOpt.Type.IsReferenceType)
|
||
|
|
{
|
||
|
|
return DigForValueLocal(topSequence, receiverOpt);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArrayIndices(ImmutableArray<BoundExpression> indices)
|
||
|
|
{
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
for (int i = 0; i < indices.Length; i++)
|
||
|
|
{
|
||
|
|
BoundExpression boundExpression = indices[i];
|
||
|
|
EmitExpression(boundExpression, used: true);
|
||
|
|
TreatLongsAsNative(boundExpression.Type.PrimitiveTypeCode);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArrayElementAddress(BoundArrayAccess arrayAccess, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
EmitExpression(arrayAccess.Expression, used: true);
|
||
|
|
EmitArrayIndices(arrayAccess.Indices);
|
||
|
|
if (ShouldEmitReadOnlyPrefix(arrayAccess, addressKind))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Readonly);
|
||
|
|
}
|
||
|
|
if (((ArrayTypeSymbol)arrayAccess.Expression.Type).IsSZArray)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelema);
|
||
|
|
TypeSymbol type = arrayAccess.Type;
|
||
|
|
EmitSymbolToken(type, arrayAccess.Syntax);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitArrayElementAddress(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool ShouldEmitReadOnlyPrefix(BoundArrayAccess arrayAccess, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
if (addressKind == Binder.AddressKind.Constrained)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (!Binder.IsAnyReadOnly(addressKind))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return !arrayAccess.Type.IsValueType;
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitFieldAddress(BoundFieldAccess fieldAccess, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
FieldSymbol fieldSymbol = fieldAccess.FieldSymbol;
|
||
|
|
if (!HasHome(fieldAccess, addressKind))
|
||
|
|
{
|
||
|
|
return EmitAddressOfTempClone(fieldAccess);
|
||
|
|
}
|
||
|
|
if (fieldAccess.FieldSymbol.IsStatic)
|
||
|
|
{
|
||
|
|
EmitStaticFieldAddress(fieldSymbol, fieldAccess.Syntax);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return EmitInstanceFieldAddress(fieldAccess, addressKind);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStaticFieldAddress(FieldSymbol field, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldsflda);
|
||
|
|
EmitSymbolToken(field, syntaxNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool HasHome(BoundExpression expression, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
return Binder.HasHome(expression, addressKind, _method, IsPeVerifyCompatEnabled(), _stackLocals);
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitParameterAddress(BoundParameter parameter, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
ParameterSymbol parameterSymbol = parameter.ParameterSymbol;
|
||
|
|
if (!HasHome(parameter, addressKind))
|
||
|
|
{
|
||
|
|
return EmitAddressOfTempClone(parameter);
|
||
|
|
}
|
||
|
|
int num = ParameterSlot(parameter);
|
||
|
|
if ((int)parameterSymbol.RefKind == 0)
|
||
|
|
{
|
||
|
|
_builder.EmitLoadArgumentAddrOpcode(num);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitLoadArgumentOpcode(num);
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitReceiverRef(BoundExpression receiver, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
TypeSymbol type = receiver.Type;
|
||
|
|
if (type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitExpression(receiver, used: true);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (BoxNonVerifierReferenceReceiver(type, addressKind))
|
||
|
|
{
|
||
|
|
EmitExpression(receiver, used: true);
|
||
|
|
if (receiver.Kind != BoundKind.ConditionalReceiver)
|
||
|
|
{
|
||
|
|
EmitBox(receiver.Type, receiver.Syntax);
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return EmitAddress(receiver, addressKind);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool BoxNonVerifierReferenceReceiver(TypeSymbol receiverType, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0008: Invalid comparison between Unknown and I4
|
||
|
|
if ((int)receiverType.TypeKind == 11)
|
||
|
|
{
|
||
|
|
return addressKind != Binder.AddressKind.Constrained;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitInstanceFieldAddress(BoundFieldAccess fieldAccess, Binder.AddressKind addressKind)
|
||
|
|
{
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
FieldSymbol fieldSymbol = fieldAccess.FieldSymbol;
|
||
|
|
LocalDefinition result = EmitReceiverRef(fieldAccess.ReceiverOpt, ((int)fieldSymbol.RefKind != 0) ? ((addressKind != Binder.AddressKind.ReadOnlyStrict) ? Binder.AddressKind.ReadOnly : addressKind) : ((addressKind != Binder.AddressKind.Constrained) ? addressKind : Binder.AddressKind.Writeable));
|
||
|
|
_builder.EmitOpCode(((int)fieldSymbol.RefKind == 0) ? ILOpCode.Ldflda : ILOpCode.Ldfld);
|
||
|
|
EmitSymbolToken(fieldSymbol, fieldAccess.Syntax);
|
||
|
|
if (fieldSymbol.IsFixedSizeBuffer)
|
||
|
|
{
|
||
|
|
FieldSymbol fixedElementField = fieldSymbol.FixedImplementationType(_module).FixedElementField;
|
||
|
|
if ((object)fixedElementField != null)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldflda);
|
||
|
|
EmitSymbolToken(fixedElementField, fieldAccess.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArrayInitializers(ArrayTypeSymbol arrayType, BoundArrayInitialization inits)
|
||
|
|
{
|
||
|
|
ImmutableArray<BoundExpression> initializers = inits.Initializers;
|
||
|
|
ArrayInitializerStyle arrayInitializerStyle = ShouldEmitBlockInitializer(arrayType.ElementType, initializers);
|
||
|
|
if (arrayInitializerStyle == ArrayInitializerStyle.Element)
|
||
|
|
{
|
||
|
|
EmitElementInitializers(arrayType, initializers, includeConstants: true);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ImmutableArray<byte> rawData = GetRawData(initializers);
|
||
|
|
_builder.EmitArrayBlockInitializer(rawData, inits.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
if (arrayInitializerStyle == ArrayInitializerStyle.Mixed)
|
||
|
|
{
|
||
|
|
EmitElementInitializers(arrayType, initializers, includeConstants: false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitElementInitializers(ArrayTypeSymbol arrayType, ImmutableArray<BoundExpression> inits, bool includeConstants)
|
||
|
|
{
|
||
|
|
if (!IsMultidimensionalInitializer(inits))
|
||
|
|
{
|
||
|
|
EmitVectorElementInitializers(arrayType, inits, includeConstants);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitMultidimensionalElementInitializers(arrayType, inits, includeConstants);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitVectorElementInitializers(ArrayTypeSymbol arrayType, ImmutableArray<BoundExpression> inits, bool includeConstants)
|
||
|
|
{
|
||
|
|
for (int i = 0; i < inits.Length; i++)
|
||
|
|
{
|
||
|
|
BoundExpression boundExpression = inits[i];
|
||
|
|
if (ShouldEmitInitExpression(includeConstants, boundExpression))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
_builder.EmitIntConstant(i);
|
||
|
|
EmitExpression(boundExpression, used: true);
|
||
|
|
EmitVectorElementStore(arrayType, boundExpression.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool ShouldEmitInitExpression(bool includeConstants, BoundExpression init)
|
||
|
|
{
|
||
|
|
if (init.IsDefaultValue())
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!includeConstants)
|
||
|
|
{
|
||
|
|
return init.ConstantValueOpt == (ConstantValue)null;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitMultidimensionalElementInitializers(ArrayTypeSymbol arrayType, ImmutableArray<BoundExpression> inits, bool includeConstants)
|
||
|
|
{
|
||
|
|
ArrayBuilder<IndexDesc> val = new ArrayBuilder<IndexDesc>();
|
||
|
|
for (int i = 0; i < inits.Length; i++)
|
||
|
|
{
|
||
|
|
ArrayBuilderExtensions.Push<IndexDesc>(val, new IndexDesc(i, ((BoundArrayInitialization)inits[i]).Initializers));
|
||
|
|
EmitAllElementInitializersRecursive(arrayType, val, includeConstants);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitAllElementInitializersRecursive(ArrayTypeSymbol arrayType, ArrayBuilder<IndexDesc> indices, bool includeConstants)
|
||
|
|
{
|
||
|
|
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
ImmutableArray<BoundExpression> initializers = ArrayBuilderExtensions.Peek<IndexDesc>(indices).Initializers;
|
||
|
|
if (IsMultidimensionalInitializer(initializers))
|
||
|
|
{
|
||
|
|
for (int i = 0; i < initializers.Length; i++)
|
||
|
|
{
|
||
|
|
ArrayBuilderExtensions.Push<IndexDesc>(indices, new IndexDesc(i, ((BoundArrayInitialization)initializers[i]).Initializers));
|
||
|
|
EmitAllElementInitializersRecursive(arrayType, indices, includeConstants);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
for (int j = 0; j < initializers.Length; j++)
|
||
|
|
{
|
||
|
|
BoundExpression boundExpression = initializers[j];
|
||
|
|
if (ShouldEmitInitExpression(includeConstants, boundExpression))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
Enumerator<IndexDesc> enumerator = indices.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
IndexDesc current = enumerator.Current;
|
||
|
|
_builder.EmitIntConstant(current.Index);
|
||
|
|
}
|
||
|
|
_builder.EmitIntConstant(j);
|
||
|
|
BoundExpression expression = initializers[j];
|
||
|
|
EmitExpression(expression, used: true);
|
||
|
|
EmitArrayElementStore(arrayType, boundExpression.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ArrayBuilderExtensions.Pop<IndexDesc>(indices);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static ConstantValue AsConstOrDefault(BoundExpression init)
|
||
|
|
{
|
||
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
ConstantValue constantValueOpt = init.ConstantValueOpt;
|
||
|
|
if (constantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
return constantValueOpt;
|
||
|
|
}
|
||
|
|
return ConstantValue.Default(init.Type.EnumUnderlyingTypeOrSelf().SpecialType);
|
||
|
|
}
|
||
|
|
|
||
|
|
private ArrayInitializerStyle ShouldEmitBlockInitializer(TypeSymbol elementType, ImmutableArray<BoundExpression> inits)
|
||
|
|
{
|
||
|
|
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (((CommonPEModuleBuilder)_module).IsEncDelta)
|
||
|
|
{
|
||
|
|
return ArrayInitializerStyle.Element;
|
||
|
|
}
|
||
|
|
if (elementType.IsEnumType())
|
||
|
|
{
|
||
|
|
if (!EnableEnumArrayBlockInitialization)
|
||
|
|
{
|
||
|
|
return ArrayInitializerStyle.Element;
|
||
|
|
}
|
||
|
|
elementType = elementType.EnumUnderlyingTypeOrSelf();
|
||
|
|
}
|
||
|
|
if (SpecialTypeExtensions.IsBlittable(elementType.SpecialType))
|
||
|
|
{
|
||
|
|
if (((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).GetInitArrayHelper() == null)
|
||
|
|
{
|
||
|
|
return ArrayInitializerStyle.Element;
|
||
|
|
}
|
||
|
|
int initCount = 0;
|
||
|
|
int constInits = 0;
|
||
|
|
InitializerCountRecursive(inits, ref initCount, ref constInits);
|
||
|
|
if (initCount > 2)
|
||
|
|
{
|
||
|
|
if (initCount == constInits)
|
||
|
|
{
|
||
|
|
return ArrayInitializerStyle.Block;
|
||
|
|
}
|
||
|
|
int num = Math.Max(3, initCount / 3);
|
||
|
|
if (constInits >= num)
|
||
|
|
{
|
||
|
|
return ArrayInitializerStyle.Mixed;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return ArrayInitializerStyle.Element;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void InitializerCountRecursive(ImmutableArray<BoundExpression> inits, ref int initCount, ref int constInits)
|
||
|
|
{
|
||
|
|
if (inits.Length == 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = inits.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundExpression current = enumerator.Current;
|
||
|
|
if (current is BoundArrayInitialization boundArrayInitialization)
|
||
|
|
{
|
||
|
|
InitializerCountRecursive(boundArrayInitialization.Initializers, ref initCount, ref constInits);
|
||
|
|
}
|
||
|
|
else if (!current.IsDefaultValue())
|
||
|
|
{
|
||
|
|
initCount++;
|
||
|
|
if (current.ConstantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
constInits++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private ImmutableArray<byte> GetRawData(ImmutableArray<BoundExpression> initializers)
|
||
|
|
{
|
||
|
|
BlobBuilder blobBuilder = new BlobBuilder(initializers.Length * 4);
|
||
|
|
SerializeArrayRecursive(blobBuilder, initializers);
|
||
|
|
return blobBuilder.ToImmutableArray();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void SerializeArrayRecursive(BlobBuilder bw, ImmutableArray<BoundExpression> inits)
|
||
|
|
{
|
||
|
|
if (inits.Length == 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (inits[0].Kind == BoundKind.ArrayInitialization)
|
||
|
|
{
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = inits.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundExpression current = enumerator.Current;
|
||
|
|
SerializeArrayRecursive(bw, ((BoundArrayInitialization)current).Initializers);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = inits.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
AsConstOrDefault(enumerator.Current).Serialize(bw);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool IsMultidimensionalInitializer(ImmutableArray<BoundExpression> inits)
|
||
|
|
{
|
||
|
|
if (inits.Length != 0)
|
||
|
|
{
|
||
|
|
return inits[0].Kind == BoundKind.ArrayInitialization;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool TryEmitReadonlySpanAsBlobWrapper(NamedTypeSymbol spanType, BoundExpression wrappedExpression, bool used, BoundExpression inPlaceTarget, out bool avoidInPlace, BoundExpression? start = null, BoundExpression? length = null)
|
||
|
|
{
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00e8: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0185: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0100: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0294: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (start == null != (length == null))
|
||
|
|
{
|
||
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/CodeGen/EmitArrayInitializer.cs", 438);
|
||
|
|
}
|
||
|
|
int num = -1;
|
||
|
|
avoidInPlace = false;
|
||
|
|
SpecialType val = (SpecialType)0;
|
||
|
|
if (((CommonPEModuleBuilder)_module).IsEncDelta)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
MethodSymbol methodSymbol = (MethodSymbol)Binder.GetWellKnownTypeMember(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (WellKnownMember)403, _diagnostics, null, wrappedExpression.Syntax, isOptional: true);
|
||
|
|
if ((object)methodSymbol == null)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
ImmutableArray<byte> data = default(ImmutableArray<byte>);
|
||
|
|
ArrayTypeSymbol arrayTypeSymbol = null;
|
||
|
|
TypeSymbol typeSymbol = null;
|
||
|
|
if (wrappedExpression is BoundArrayCreation boundArrayCreation)
|
||
|
|
{
|
||
|
|
arrayTypeSymbol = (ArrayTypeSymbol)boundArrayCreation.Type;
|
||
|
|
typeSymbol = arrayTypeSymbol.ElementType;
|
||
|
|
val = typeSymbol.EnumUnderlyingTypeOrSelf().SpecialType;
|
||
|
|
if (!IsTypeAllowedInBlobWrapper(val))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
num = TryGetRawDataForArrayInit(boundArrayCreation.InitializerOpt, out data);
|
||
|
|
}
|
||
|
|
if (num < 0)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
int num2;
|
||
|
|
if (start != null)
|
||
|
|
{
|
||
|
|
ConstantValue? constantValueOpt = start.ConstantValueOpt;
|
||
|
|
if (constantValueOpt == null || !constantValueOpt.IsDefaultValue || (int)start.ConstantValueOpt.Discriminator != 6)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
ConstantValue? constantValueOpt2 = length.ConstantValueOpt;
|
||
|
|
if (constantValueOpt2 == null || (int)constantValueOpt2.Discriminator != 6)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
num2 = length.ConstantValueOpt.Int32Value;
|
||
|
|
if (num2 > num || num2 < 0)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
num2 = num;
|
||
|
|
}
|
||
|
|
if (inPlaceTarget == null && !used)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (num == 0)
|
||
|
|
{
|
||
|
|
if (inPlaceTarget != null)
|
||
|
|
{
|
||
|
|
EmitAddress(inPlaceTarget, Binder.AddressKind.Writeable);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Initobj);
|
||
|
|
EmitSymbolToken(spanType, wrappedExpression.Syntax);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitExpression(inPlaceTarget, used: true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitDefaultValue(spanType, used, wrappedExpression.Syntax);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (IsPeVerifyCompatEnabled())
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (SpecialTypeExtensions.SizeInBytes(val) == 1)
|
||
|
|
{
|
||
|
|
if (inPlaceTarget != null)
|
||
|
|
{
|
||
|
|
EmitAddress(inPlaceTarget, Binder.AddressKind.Writeable);
|
||
|
|
}
|
||
|
|
IFieldReference fieldForData = _builder.module.GetFieldForData(data, (ushort)1, wrappedExpression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldsflda);
|
||
|
|
_builder.EmitToken((IReference)(object)fieldForData, wrappedExpression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.EmitIntConstant(num2);
|
||
|
|
if (inPlaceTarget != null)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, -3);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Newobj, -1);
|
||
|
|
}
|
||
|
|
EmitSymbolToken(methodSymbol.AsMember(spanType), wrappedExpression.Syntax, null);
|
||
|
|
if (inPlaceTarget != null && used)
|
||
|
|
{
|
||
|
|
EmitExpression(inPlaceTarget, used: true);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (num2 != num)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (inPlaceTarget != null)
|
||
|
|
{
|
||
|
|
avoidInPlace = true;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
MethodSymbol methodSymbol2 = (MethodSymbol)Binder.GetWellKnownTypeMember(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (WellKnownMember)123, _diagnostics, null, wrappedExpression.Syntax, isOptional: true);
|
||
|
|
if ((object)methodSymbol2 != null)
|
||
|
|
{
|
||
|
|
IFieldReference fieldForData2 = _builder.module.GetFieldForData(data, (ushort)SpecialTypeExtensions.SizeInBytes(val), wrappedExpression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
_builder.EmitToken((IReference)(object)fieldForData2, wrappedExpression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
EmitSymbolToken(methodSymbol2.Construct(typeSymbol), wrappedExpression.Syntax, null);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
MethodSymbol methodSymbol3 = (MethodSymbol)Binder.GetWellKnownTypeMember(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (WellKnownMember)404, _diagnostics, null, wrappedExpression.Syntax, isOptional: true);
|
||
|
|
if ((object)methodSymbol3 == null)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
arrayTypeSymbol = arrayTypeSymbol.WithElementType(TypeWithAnnotations.Create(typeSymbol.EnumUnderlyingTypeOrSelf()));
|
||
|
|
IFieldReference arrayCachingFieldForData = _builder.module.GetArrayCachingFieldForData(data, _module.Translate(arrayTypeSymbol), wrappedExpression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
object obj = new object();
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldsfld);
|
||
|
|
_builder.EmitToken((IReference)(object)arrayCachingFieldForData, wrappedExpression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj, ILOpCode.Nop);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Pop);
|
||
|
|
_builder.EmitIntConstant(num);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Newarr);
|
||
|
|
EmitSymbolToken(arrayTypeSymbol.ElementType, wrappedExpression.Syntax);
|
||
|
|
_builder.EmitArrayBlockInitializer(data, wrappedExpression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stsfld);
|
||
|
|
_builder.EmitToken((IReference)(object)arrayCachingFieldForData, wrappedExpression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Newobj, 0);
|
||
|
|
EmitSymbolToken(methodSymbol3.AsMember(spanType), wrappedExpression.Syntax, null);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool IsTypeAllowedInBlobWrapper(SpecialType type)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Invalid comparison between Unknown and I4
|
||
|
|
if (type - 7 <= 9 || type - 18 <= 1)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private int TryGetRawDataForArrayInit(BoundArrayInitialization initializer, out ImmutableArray<byte> data)
|
||
|
|
{
|
||
|
|
data = default(ImmutableArray<byte>);
|
||
|
|
if (initializer == null)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
ImmutableArray<BoundExpression> initializers = initializer.Initializers;
|
||
|
|
if (initializers.Any((BoundExpression init) => init.ConstantValueOpt == (ConstantValue)null))
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
int length = initializers.Length;
|
||
|
|
if (length == 0)
|
||
|
|
{
|
||
|
|
data = ImmutableArray<byte>.Empty;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
BlobBuilder blobBuilder = new BlobBuilder(initializers.Length * 4);
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = initializer.Initializers.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
enumerator.Current.ConstantValueOpt.Serialize(blobBuilder);
|
||
|
|
}
|
||
|
|
data = blobBuilder.ToImmutableArray();
|
||
|
|
return length;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool IsNumeric(TypeSymbol type)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004f: Expected I4, but got Unknown
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = type.PrimitiveTypeCode;
|
||
|
|
switch (primitiveTypeCode - 1)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
case 1:
|
||
|
|
case 2:
|
||
|
|
case 3:
|
||
|
|
case 4:
|
||
|
|
case 5:
|
||
|
|
case 6:
|
||
|
|
case 11:
|
||
|
|
case 12:
|
||
|
|
case 13:
|
||
|
|
case 14:
|
||
|
|
return true;
|
||
|
|
case 7:
|
||
|
|
case 15:
|
||
|
|
return type.IsNativeIntegerType;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConversionExpression(BoundConversion conversion, bool used)
|
||
|
|
{
|
||
|
|
switch (conversion.ConversionKind)
|
||
|
|
{
|
||
|
|
case ConversionKind.MethodGroup:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)conversion.ConversionKind);
|
||
|
|
case ConversionKind.ImplicitNullToPointer:
|
||
|
|
_builder.EmitIntConstant(0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_u);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
BoundExpression operand = conversion.Operand;
|
||
|
|
if (!used && !conversion.ConversionHasSideEffects())
|
||
|
|
{
|
||
|
|
EmitExpression(operand, used: false);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
EmitExpression(operand, used: true);
|
||
|
|
EmitConversion(conversion);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitReadOnlySpanFromArrayExpression(BoundReadOnlySpanFromArray expression, bool used)
|
||
|
|
{
|
||
|
|
BoundExpression operand = expression.Operand;
|
||
|
|
NamedTypeSymbol spanType = (NamedTypeSymbol)expression.Type;
|
||
|
|
if (!TryEmitReadonlySpanAsBlobWrapper(spanType, operand, used, null, out var _))
|
||
|
|
{
|
||
|
|
EmitExpression(operand, used);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
EmitSymbolToken(expression.ConversionMethod, expression.Syntax, null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConversion(BoundConversion conversion)
|
||
|
|
{
|
||
|
|
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
switch (conversion.ConversionKind)
|
||
|
|
{
|
||
|
|
case ConversionKind.Identity:
|
||
|
|
EmitIdentityConversion(conversion);
|
||
|
|
break;
|
||
|
|
case ConversionKind.ImplicitNumeric:
|
||
|
|
case ConversionKind.ExplicitNumeric:
|
||
|
|
EmitNumericConversion(conversion);
|
||
|
|
break;
|
||
|
|
case ConversionKind.ImplicitReference:
|
||
|
|
case ConversionKind.Boxing:
|
||
|
|
EmitImplicitReferenceConversion(conversion);
|
||
|
|
break;
|
||
|
|
case ConversionKind.ExplicitReference:
|
||
|
|
case ConversionKind.Unboxing:
|
||
|
|
EmitExplicitReferenceConversion(conversion);
|
||
|
|
break;
|
||
|
|
case ConversionKind.ImplicitEnumeration:
|
||
|
|
case ConversionKind.ExplicitEnumeration:
|
||
|
|
EmitEnumConversion(conversion);
|
||
|
|
break;
|
||
|
|
case ConversionKind.ImplicitThrow:
|
||
|
|
case ConversionKind.ImplicitTupleLiteral:
|
||
|
|
case ConversionKind.ImplicitTuple:
|
||
|
|
case ConversionKind.ExplicitTupleLiteral:
|
||
|
|
case ConversionKind.ExplicitTuple:
|
||
|
|
case ConversionKind.ImplicitDynamic:
|
||
|
|
case ConversionKind.ExplicitDynamic:
|
||
|
|
case ConversionKind.ImplicitUserDefined:
|
||
|
|
case ConversionKind.AnonymousFunction:
|
||
|
|
case ConversionKind.MethodGroup:
|
||
|
|
case ConversionKind.ExplicitUserDefined:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)conversion.ConversionKind);
|
||
|
|
case ConversionKind.ImplicitPointerToVoid:
|
||
|
|
case ConversionKind.ImplicitPointer:
|
||
|
|
case ConversionKind.ExplicitPointerToPointer:
|
||
|
|
break;
|
||
|
|
case ConversionKind.ExplicitIntegerToPointer:
|
||
|
|
case ConversionKind.ExplicitPointerToInteger:
|
||
|
|
{
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = conversion.Operand.Type.PrimitiveTypeCode;
|
||
|
|
PrimitiveTypeCode primitiveTypeCode2 = conversion.Type.PrimitiveTypeCode;
|
||
|
|
_builder.EmitNumericConversion(primitiveTypeCode, primitiveTypeCode2, conversion.Checked);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case ConversionKind.PinnedObjectToPointer:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_u);
|
||
|
|
break;
|
||
|
|
case ConversionKind.ImplicitNullToPointer:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)conversion.ConversionKind);
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)conversion.ConversionKind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitIdentityConversion(BoundConversion conversion)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Invalid comparison between Unknown and I4
|
||
|
|
if (conversion.ExplicitCastInCode)
|
||
|
|
{
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = conversion.Type.PrimitiveTypeCode;
|
||
|
|
if (primitiveTypeCode - 3 <= 1 && conversion.Operand.ConstantValueOpt == (ConstantValue)null)
|
||
|
|
{
|
||
|
|
EmitNumericConversion(conversion);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitNumericConversion(BoundConversion conversion)
|
||
|
|
{
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = conversion.Operand.Type.PrimitiveTypeCode;
|
||
|
|
PrimitiveTypeCode primitiveTypeCode2 = conversion.Type.PrimitiveTypeCode;
|
||
|
|
_builder.EmitNumericConversion(primitiveTypeCode, primitiveTypeCode2, conversion.Checked);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitImplicitReferenceConversion(BoundConversion conversion)
|
||
|
|
{
|
||
|
|
if (!conversion.Operand.Type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(conversion.Operand.Type, conversion.Operand.Syntax);
|
||
|
|
}
|
||
|
|
TypeSymbol type = conversion.Type;
|
||
|
|
if (!type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Unbox_any);
|
||
|
|
EmitSymbolToken(conversion.Type, conversion.Syntax);
|
||
|
|
}
|
||
|
|
else if (type.IsArray())
|
||
|
|
{
|
||
|
|
EmitStaticCast(conversion.Type, conversion.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitExplicitReferenceConversion(BoundConversion conversion)
|
||
|
|
{
|
||
|
|
if (!conversion.Operand.Type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(conversion.Operand.Type, conversion.Operand.Syntax);
|
||
|
|
}
|
||
|
|
if (conversion.Type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Castclass);
|
||
|
|
EmitSymbolToken(conversion.Type, conversion.Syntax);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Unbox_any);
|
||
|
|
EmitSymbolToken(conversion.Type, conversion.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitEnumConversion(BoundConversion conversion)
|
||
|
|
{
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
TypeSymbol typeSymbol = conversion.Operand.Type;
|
||
|
|
if (typeSymbol.IsEnumType())
|
||
|
|
{
|
||
|
|
typeSymbol = ((NamedTypeSymbol)typeSymbol).EnumUnderlyingType;
|
||
|
|
}
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = typeSymbol.PrimitiveTypeCode;
|
||
|
|
TypeSymbol typeSymbol2 = conversion.Type;
|
||
|
|
if (typeSymbol2.IsEnumType())
|
||
|
|
{
|
||
|
|
typeSymbol2 = ((NamedTypeSymbol)typeSymbol2).EnumUnderlyingType;
|
||
|
|
}
|
||
|
|
PrimitiveTypeCode primitiveTypeCode2 = typeSymbol2.PrimitiveTypeCode;
|
||
|
|
_builder.EmitNumericConversion(primitiveTypeCode, primitiveTypeCode2, conversion.Checked);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitDelegateCreation(BoundExpression node, BoundExpression receiver, bool isExtensionMethod, MethodSymbol method, TypeSymbol delegateType, bool used)
|
||
|
|
{
|
||
|
|
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0060: Invalid comparison between Unknown and I4
|
||
|
|
bool flag = receiver == null || (!isExtensionMethod && method.IsStatic);
|
||
|
|
if (!used)
|
||
|
|
{
|
||
|
|
if (!flag)
|
||
|
|
{
|
||
|
|
EmitExpression(receiver, used: false);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
_builder.EmitNullConstant();
|
||
|
|
if (method.IsAbstract || method.IsVirtual)
|
||
|
|
{
|
||
|
|
if (receiver is BoundTypeExpression boundTypeExpression)
|
||
|
|
{
|
||
|
|
TypeSymbol type = boundTypeExpression.Type;
|
||
|
|
if ((object)type != null && (int)type.TypeKind == 11)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Constrained);
|
||
|
|
EmitSymbolToken(receiver.Type, receiver.Syntax);
|
||
|
|
goto IL_00bd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/CodeGen/EmitConversion.cs", 333);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitExpression(receiver, used: true);
|
||
|
|
if (!receiver.Type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(receiver.Type, receiver.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
goto IL_00bd;
|
||
|
|
IL_00bd:
|
||
|
|
if (!method.IsStatic && method.IsMetadataVirtual() && !method.ContainingType.IsDelegateType() && !receiver.SuppressVirtualCalls)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldvirtftn);
|
||
|
|
method = method.GetConstructedLeastOverriddenMethod(_method.ContainingType, requireSameReturnType: true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldftn);
|
||
|
|
}
|
||
|
|
EmitSymbolToken(method, node.Syntax, null);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Newobj, -1);
|
||
|
|
MethodSymbol methodSymbol = DelegateConstructor(node.Syntax, delegateType);
|
||
|
|
if ((object)methodSymbol != null)
|
||
|
|
{
|
||
|
|
EmitSymbolToken(methodSymbol, node.Syntax, null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private MethodSymbol DelegateConstructor(SyntaxNode syntax, TypeSymbol delegateType)
|
||
|
|
{
|
||
|
|
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004a: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0064: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006a: Invalid comparison between Unknown and I4
|
||
|
|
ImmutableArray<Symbol>.Enumerator enumerator = delegateType.GetMembers(".ctor").GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
if (enumerator.Current is MethodSymbol { Parameters: { Length: 2 } parameters } methodSymbol && (int)parameters[0].Type.SpecialType == 1)
|
||
|
|
{
|
||
|
|
SpecialType specialType = parameters[1].Type.SpecialType;
|
||
|
|
if ((int)specialType == 21 || (int)specialType == 22)
|
||
|
|
{
|
||
|
|
return methodSymbol;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_diagnostics.Add(ErrorCode.ERR_BadDelegateConstructor, syntax.Location, delegateType);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitExpression(BoundExpression expression, bool used)
|
||
|
|
{
|
||
|
|
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002d: Invalid comparison between Unknown and I4
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ConstantValue constantValueOpt = expression.ConstantValueOpt;
|
||
|
|
if (constantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
if (!used)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if ((object)expression.Type == null || ((int)expression.Type.SpecialType != 17 && !expression.Type.IsNullableType()))
|
||
|
|
{
|
||
|
|
EmitConstantExpression(expression.Type, constantValueOpt, used, expression.Syntax);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_recursionDepth++;
|
||
|
|
if (_recursionDepth > 1)
|
||
|
|
{
|
||
|
|
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
|
||
|
|
EmitExpressionCore(expression, used);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitExpressionCoreWithStackGuard(expression, used);
|
||
|
|
}
|
||
|
|
_recursionDepth--;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitExpressionCoreWithStackGuard(BoundExpression expression, bool used)
|
||
|
|
{
|
||
|
|
try
|
||
|
|
{
|
||
|
|
EmitExpressionCore(expression, used);
|
||
|
|
}
|
||
|
|
catch (InsufficientExecutionStackException)
|
||
|
|
{
|
||
|
|
_diagnostics.Add(ErrorCode.ERR_InsufficientStack, BoundTreeVisitor.CancelledByStackGuardException.GetTooLongOrComplexExpressionErrorLocation(expression));
|
||
|
|
throw new EmitCancelledException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitExpressionCore(BoundExpression expression, bool used)
|
||
|
|
{
|
||
|
|
switch (expression.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.AssignmentOperator:
|
||
|
|
EmitAssignmentExpression((BoundAssignmentOperator)expression, used ? UseKind.UsedAsValue : UseKind.Unused);
|
||
|
|
break;
|
||
|
|
case BoundKind.Call:
|
||
|
|
EmitCallExpression((BoundCall)expression, used ? UseKind.UsedAsValue : UseKind.Unused);
|
||
|
|
break;
|
||
|
|
case BoundKind.ObjectCreationExpression:
|
||
|
|
EmitObjectCreationExpression((BoundObjectCreationExpression)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.DelegateCreationExpression:
|
||
|
|
EmitDelegateCreationExpression((BoundDelegateCreationExpression)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ArrayCreation:
|
||
|
|
EmitArrayCreationExpression((BoundArrayCreation)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ConvertedStackAllocExpression:
|
||
|
|
EmitConvertedStackAllocExpression((BoundConvertedStackAllocExpression)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ReadOnlySpanFromArray:
|
||
|
|
EmitReadOnlySpanFromArrayExpression((BoundReadOnlySpanFromArray)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.Conversion:
|
||
|
|
EmitConversionExpression((BoundConversion)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.Local:
|
||
|
|
EmitLocalLoad((BoundLocal)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.Dup:
|
||
|
|
EmitDupExpression((BoundDup)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.PassByCopy:
|
||
|
|
EmitExpression(((BoundPassByCopy)expression).Expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.Parameter:
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitParameterLoad((BoundParameter)expression);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
EmitFieldLoad((BoundFieldAccess)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ArrayAccess:
|
||
|
|
EmitArrayElementLoad((BoundArrayAccess)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ArrayLength:
|
||
|
|
EmitArrayLength((BoundArrayLength)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ThisReference:
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitThisReferenceExpression((BoundThisReference)expression);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BoundKind.PreviousSubmissionReference:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)expression.Kind);
|
||
|
|
case BoundKind.BaseReference:
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
NamedTypeSymbol containingType = _method.ContainingType;
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldarg_0);
|
||
|
|
if (containingType.IsValueType)
|
||
|
|
{
|
||
|
|
EmitLoadIndirect(containingType, expression.Syntax);
|
||
|
|
EmitBox(containingType, expression.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
EmitSequenceExpression((BoundSequence)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.SequencePointExpression:
|
||
|
|
EmitSequencePointExpression((BoundSequencePointExpression)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.UnaryOperator:
|
||
|
|
EmitUnaryOperatorExpression((BoundUnaryOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.BinaryOperator:
|
||
|
|
EmitBinaryOperatorExpression((BoundBinaryOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.NullCoalescingOperator:
|
||
|
|
EmitNullCoalescingOperator((BoundNullCoalescingOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.IsOperator:
|
||
|
|
EmitIsExpression((BoundIsOperator)expression, used, omitBooleanConversion: false);
|
||
|
|
break;
|
||
|
|
case BoundKind.AsOperator:
|
||
|
|
EmitAsExpression((BoundAsOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.DefaultExpression:
|
||
|
|
EmitDefaultExpression((BoundDefaultExpression)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.TypeOfOperator:
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitTypeOfExpression((BoundTypeOfOperator)expression);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BoundKind.SizeOfOperator:
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitSizeOfExpression((BoundSizeOfOperator)expression);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BoundKind.ModuleVersionId:
|
||
|
|
EmitModuleVersionIdLoad((BoundModuleVersionId)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.ModuleVersionIdString:
|
||
|
|
EmitModuleVersionIdStringLoad();
|
||
|
|
break;
|
||
|
|
case BoundKind.InstrumentationPayloadRoot:
|
||
|
|
EmitInstrumentationPayloadRootLoad((BoundInstrumentationPayloadRoot)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.MethodDefIndex:
|
||
|
|
EmitMethodDefIndexExpression((BoundMethodDefIndex)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.MaximumMethodDefIndex:
|
||
|
|
EmitMaximumMethodDefIndexExpression((BoundMaximumMethodDefIndex)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.SourceDocumentIndex:
|
||
|
|
EmitSourceDocumentIndex((BoundSourceDocumentIndex)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.LocalId:
|
||
|
|
EmitLocalIdExpression((BoundLocalId)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.ParameterId:
|
||
|
|
EmitParameterIdExpression((BoundParameterId)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.MethodInfo:
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitMethodInfoExpression((BoundMethodInfo)expression);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BoundKind.FieldInfo:
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitFieldInfoExpression((BoundFieldInfo)expression);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BoundKind.ConditionalOperator:
|
||
|
|
EmitConditionalOperator((BoundConditionalOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.AddressOfOperator:
|
||
|
|
EmitAddressOfExpression((BoundAddressOfOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.PointerIndirectionOperator:
|
||
|
|
EmitPointerIndirectionOperator((BoundPointerIndirectionOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ArgList:
|
||
|
|
EmitArgList(used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ArgListOperator:
|
||
|
|
EmitArgListOperator((BoundArgListOperator)expression);
|
||
|
|
break;
|
||
|
|
case BoundKind.RefTypeOperator:
|
||
|
|
EmitRefTypeOperator((BoundRefTypeOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.MakeRefOperator:
|
||
|
|
EmitMakeRefOperator((BoundMakeRefOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.RefValueOperator:
|
||
|
|
EmitRefValueOperator((BoundRefValueOperator)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.LoweredConditionalAccess:
|
||
|
|
EmitLoweredConditionalAccessExpression((BoundLoweredConditionalAccess)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ConditionalReceiver:
|
||
|
|
EmitConditionalReceiver((BoundConditionalReceiver)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ComplexConditionalReceiver:
|
||
|
|
EmitComplexConditionalReceiver((BoundComplexConditionalReceiver)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.PseudoVariable:
|
||
|
|
EmitPseudoVariableValue((BoundPseudoVariable)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.ThrowExpression:
|
||
|
|
EmitThrowExpression((BoundThrowExpression)expression, used);
|
||
|
|
break;
|
||
|
|
case BoundKind.FunctionPointerInvocation:
|
||
|
|
EmitCalli((BoundFunctionPointerInvocation)expression, used ? UseKind.UsedAsValue : UseKind.Unused);
|
||
|
|
break;
|
||
|
|
case BoundKind.FunctionPointerLoad:
|
||
|
|
EmitLoadFunction((BoundFunctionPointerLoad)expression, used);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)expression.Kind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitThrowExpression(BoundThrowExpression node, bool used)
|
||
|
|
{
|
||
|
|
EmitThrow(node.Expression);
|
||
|
|
EmitDefaultValue(node.Type, used, node.Syntax);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitComplexConditionalReceiver(BoundComplexConditionalReceiver expression, bool used)
|
||
|
|
{
|
||
|
|
TypeSymbol type = expression.Type;
|
||
|
|
object obj = new object();
|
||
|
|
object obj2 = new object();
|
||
|
|
EmitInitObj(type, used: true, expression.Syntax);
|
||
|
|
EmitBox(type, expression.Syntax);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj, ILOpCode.Nop);
|
||
|
|
EmitExpression(expression.ReferenceTypeReceiver, used);
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, obj2, ILOpCode.Nop);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
_builder.AdjustStack(-1);
|
||
|
|
}
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
EmitExpression(expression.ValueTypeReceiver, used);
|
||
|
|
_builder.MarkLabel(obj2);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitLoweredConditionalAccessExpression(BoundLoweredConditionalAccess expression, bool used)
|
||
|
|
{
|
||
|
|
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a9: Invalid comparison between Unknown and I4
|
||
|
|
BoundExpression receiver = expression.Receiver;
|
||
|
|
TypeSymbol type = receiver.Type;
|
||
|
|
LocalDefinition val = null;
|
||
|
|
ConstantValue? constantValueOpt = receiver.ConstantValueOpt;
|
||
|
|
if (constantValueOpt != null && !constantValueOpt.IsNull)
|
||
|
|
{
|
||
|
|
val = EmitReceiverRef(receiver, Binder.AddressKind.ReadOnly);
|
||
|
|
EmitExpression(expression.WhenNotNull, used);
|
||
|
|
if (val != null)
|
||
|
|
{
|
||
|
|
FreeTemp(val);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
object obj = new object();
|
||
|
|
object obj2 = new object();
|
||
|
|
LocalDefinition val2 = null;
|
||
|
|
bool flag = !type.IsReferenceType && !type.IsValueType;
|
||
|
|
bool flag2 = (expression.ForceCopyOfNullableValueType && flag && ((TypeParameterSymbol)type).EffectiveInterfacesNoUseSiteDiagnostics.IsEmpty) || LocalRewriter.CanChangeValueBetweenReads(receiver, localsMayBeAssignedOrCaptured: false) || (type.IsReferenceType && (int)type.TypeKind == 11) || (receiver.Kind == BoundKind.Local && IsStackLocal(((BoundLocal)receiver).LocalSymbol)) || (flag && IsConditionalConstrainedCallThatMustUseTempForReferenceTypeReceiverWalker.Analyze(expression));
|
||
|
|
if (flag2)
|
||
|
|
{
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
val = EmitReceiverRef(receiver, Binder.AddressKind.Constrained);
|
||
|
|
if (val == null)
|
||
|
|
{
|
||
|
|
EmitDefaultValue(type, used: true, receiver.Syntax);
|
||
|
|
EmitBox(type, receiver.Syntax);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj, ILOpCode.Nop);
|
||
|
|
EmitLoadIndirect(type, receiver.Syntax);
|
||
|
|
val2 = AllocateTemp(type, receiver.Syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(val2);
|
||
|
|
_builder.EmitLocalAddress(val2);
|
||
|
|
_builder.EmitLocalLoad(val2);
|
||
|
|
EmitBox(type, receiver.Syntax);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
EmitLoadIndirect(type, receiver.Syntax);
|
||
|
|
EmitBox(type, receiver.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Binder.AddressKind addressKind = Binder.AddressKind.ReadOnly;
|
||
|
|
val = EmitReceiverRef(receiver, addressKind);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
val = EmitReceiverRef(receiver, Binder.AddressKind.ReadOnly);
|
||
|
|
}
|
||
|
|
MethodSymbol hasValueMethodOpt = expression.HasValueMethodOpt;
|
||
|
|
if (hasValueMethodOpt != null)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
EmitSymbolToken(hasValueMethodOpt, expression.Syntax, null);
|
||
|
|
}
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj, ILOpCode.Nop);
|
||
|
|
if (val != null && !flag2)
|
||
|
|
{
|
||
|
|
FreeTemp(val);
|
||
|
|
val = null;
|
||
|
|
}
|
||
|
|
if (flag2)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Pop);
|
||
|
|
}
|
||
|
|
BoundExpression whenNullOpt = expression.WhenNullOpt;
|
||
|
|
if (whenNullOpt == null)
|
||
|
|
{
|
||
|
|
EmitDefaultValue(expression.Type, used, expression.Syntax);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitExpression(whenNullOpt, used);
|
||
|
|
}
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, obj2, ILOpCode.Nop);
|
||
|
|
if (flag2)
|
||
|
|
{
|
||
|
|
_builder.AdjustStack(1);
|
||
|
|
}
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
_builder.AdjustStack(-1);
|
||
|
|
}
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
if (!flag2)
|
||
|
|
{
|
||
|
|
val = EmitReceiverRef(receiver, Binder.AddressKind.Constrained);
|
||
|
|
}
|
||
|
|
EmitExpression(expression.WhenNotNull, used);
|
||
|
|
_builder.MarkLabel(obj2);
|
||
|
|
if (val2 != null)
|
||
|
|
{
|
||
|
|
FreeTemp(val2);
|
||
|
|
}
|
||
|
|
if (val != null)
|
||
|
|
{
|
||
|
|
FreeTemp(val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConditionalReceiver(BoundConditionalReceiver expression, bool used)
|
||
|
|
{
|
||
|
|
if (!expression.Type.IsReferenceType)
|
||
|
|
{
|
||
|
|
EmitLoadIndirect(expression.Type, expression.Syntax);
|
||
|
|
}
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitRefValueOperator(BoundRefValueOperator expression, bool used)
|
||
|
|
{
|
||
|
|
EmitRefValueAddress(expression);
|
||
|
|
EmitLoadIndirect(expression.Type, expression.Syntax);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitMakeRefOperator(BoundMakeRefOperator expression, bool used)
|
||
|
|
{
|
||
|
|
EmitAddress(expression.Operand, Binder.AddressKind.Writeable);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Mkrefany);
|
||
|
|
EmitSymbolToken(expression.Operand.Type, expression.Operand.Syntax);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitRefTypeOperator(BoundRefTypeOperator expression, bool used)
|
||
|
|
{
|
||
|
|
EmitExpression(expression.Operand, used: true);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Refanytype);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
MethodSymbol getTypeFromHandle = expression.GetTypeFromHandle;
|
||
|
|
EmitSymbolToken(getTypeFromHandle, expression.Syntax, null);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArgList(bool used)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Arglist);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArgListOperator(BoundArgListOperator expression)
|
||
|
|
{
|
||
|
|
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
for (int i = 0; i < expression.Arguments.Length; i++)
|
||
|
|
{
|
||
|
|
BoundExpression argument = expression.Arguments[i];
|
||
|
|
RefKind refKind = (RefKind)((!expression.ArgumentRefKindsOpt.IsDefaultOrEmpty) ? ((int)expression.ArgumentRefKindsOpt[i]) : 0);
|
||
|
|
EmitArgument(argument, refKind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArgument(BoundExpression argument, RefKind refKind)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0027: Invalid comparison between Unknown and I4
|
||
|
|
if ((int)refKind != 0)
|
||
|
|
{
|
||
|
|
if ((int)refKind == 3)
|
||
|
|
{
|
||
|
|
LocalDefinition temp = EmitAddress(argument, Binder.AddressKind.ReadOnly);
|
||
|
|
AddExpressionTemp(temp);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
LocalDefinition val = EmitAddress(argument, ((int)refKind == 5) ? Binder.AddressKind.ReadOnlyStrict : Binder.AddressKind.Writeable);
|
||
|
|
if (val != null)
|
||
|
|
{
|
||
|
|
AddExpressionTemp(val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitExpression(argument, used: true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitAddressOfExpression(BoundAddressOfOperator expression, bool used)
|
||
|
|
{
|
||
|
|
EmitAddress(expression.Operand, Binder.AddressKind.ReadOnlyStrict);
|
||
|
|
if (used && !expression.IsManaged)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_u);
|
||
|
|
}
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitPointerIndirectionOperator(BoundPointerIndirectionOperator expression, bool used)
|
||
|
|
{
|
||
|
|
EmitExpression(expression.Operand, used: true);
|
||
|
|
if (!expression.RefersToLocation)
|
||
|
|
{
|
||
|
|
EmitLoadIndirect(expression.Type, expression.Syntax);
|
||
|
|
}
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitDupExpression(BoundDup expression, bool used)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if ((int)expression.RefKind == 0)
|
||
|
|
{
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
EmitLoadIndirect(expression.Type, expression.Syntax);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitDelegateCreationExpression(BoundDelegateCreationExpression expression, bool used)
|
||
|
|
{
|
||
|
|
BoundExpression boundExpression = ((expression.Argument is BoundMethodGroup boundMethodGroup) ? boundMethodGroup.ReceiverOpt : expression.Argument);
|
||
|
|
MethodSymbol method = expression.MethodOpt ?? boundExpression.Type.DelegateInvokeMethod();
|
||
|
|
EmitDelegateCreation(expression, boundExpression, expression.IsExtensionMethod, method, expression.Type, used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitThisReferenceExpression(BoundThisReference thisRef)
|
||
|
|
{
|
||
|
|
TypeSymbol type = thisRef.Type;
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldarg_0);
|
||
|
|
if (type.IsValueType)
|
||
|
|
{
|
||
|
|
EmitLoadIndirect(type, thisRef.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitPseudoVariableValue(BoundPseudoVariable expression, bool used)
|
||
|
|
{
|
||
|
|
EmitExpression(expression.EmitExpressions.GetValue(expression, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag), used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSequencePointExpression(BoundSequencePointExpression node, bool used)
|
||
|
|
{
|
||
|
|
EmitSequencePoint(node);
|
||
|
|
EmitExpression(node.Expression, used: true);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSequencePoint(BoundSequencePointExpression node)
|
||
|
|
{
|
||
|
|
SyntaxNode syntax = node.Syntax;
|
||
|
|
if (_emitPdbSequencePoints)
|
||
|
|
{
|
||
|
|
if (syntax == null)
|
||
|
|
{
|
||
|
|
EmitHiddenSequencePoint();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitSequencePoint(syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSequenceExpression(BoundSequence sequence, bool used)
|
||
|
|
{
|
||
|
|
DefineLocals(sequence);
|
||
|
|
EmitSideEffects(sequence);
|
||
|
|
if (sequence.Value.Kind != BoundKind.TypeExpression)
|
||
|
|
{
|
||
|
|
EmitExpression(sequence.Value, used);
|
||
|
|
}
|
||
|
|
FreeLocals(sequence);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void DefineLocals(BoundSequence sequence)
|
||
|
|
{
|
||
|
|
if (!sequence.Locals.IsEmpty)
|
||
|
|
{
|
||
|
|
_builder.OpenLocalScope((ScopeType)0, (ITypeReference)null);
|
||
|
|
ImmutableArray<LocalSymbol>.Enumerator enumerator = sequence.Locals.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LocalSymbol current = enumerator.Current;
|
||
|
|
DefineLocal(current, sequence.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void FreeLocals(BoundSequence sequence)
|
||
|
|
{
|
||
|
|
if (!sequence.Locals.IsEmpty)
|
||
|
|
{
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
ImmutableArray<LocalSymbol>.Enumerator enumerator = sequence.Locals.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LocalSymbol current = enumerator.Current;
|
||
|
|
FreeLocal(current);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void DefineAndRecordLocals(BoundSequence sequence)
|
||
|
|
{
|
||
|
|
if (!sequence.Locals.IsEmpty)
|
||
|
|
{
|
||
|
|
_builder.OpenLocalScope((ScopeType)0, (ITypeReference)null);
|
||
|
|
ImmutableArray<LocalSymbol>.Enumerator enumerator = sequence.Locals.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LocalSymbol current = enumerator.Current;
|
||
|
|
LocalDefinition temp = DefineLocal(current, sequence.Syntax);
|
||
|
|
AddExpressionTemp(temp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void CloseScopeAndKeepLocals(BoundSequence sequence)
|
||
|
|
{
|
||
|
|
if (!sequence.Locals.IsEmpty)
|
||
|
|
{
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSideEffects(BoundSequence sequence)
|
||
|
|
{
|
||
|
|
ImmutableArray<BoundExpression> sideEffects = sequence.SideEffects;
|
||
|
|
if (!sideEffects.IsDefaultOrEmpty)
|
||
|
|
{
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = sideEffects.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundExpression current = enumerator.Current;
|
||
|
|
EmitExpression(current, used: false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
for (int i = 0; i < arguments.Length; i++)
|
||
|
|
{
|
||
|
|
RefKind argumentRefKind = GetArgumentRefKind(arguments, parameters, argRefKindsOpt, i);
|
||
|
|
EmitArgument(arguments[i], argumentRefKind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static RefKind GetArgumentRefKind(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt, int i)
|
||
|
|
{
|
||
|
|
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0038: Invalid comparison between Unknown and I4
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (i < parameters.Length)
|
||
|
|
{
|
||
|
|
if (!argRefKindsOpt.IsDefault && i < argRefKindsOpt.Length)
|
||
|
|
{
|
||
|
|
return argRefKindsOpt[i];
|
||
|
|
}
|
||
|
|
RefKind refKind = parameters[i].RefKind;
|
||
|
|
return ((int)refKind != 4) ? refKind : ((RefKind)3);
|
||
|
|
}
|
||
|
|
return (RefKind)0;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArrayElementLoad(BoundArrayAccess arrayAccess, bool used)
|
||
|
|
{
|
||
|
|
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ab: Expected I4, but got Unknown
|
||
|
|
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_01bc: Invalid comparison between Unknown and I4
|
||
|
|
EmitExpression(arrayAccess.Expression, used: true);
|
||
|
|
EmitArrayIndices(arrayAccess.Indices);
|
||
|
|
if (((ArrayTypeSymbol)arrayAccess.Expression.Type).IsSZArray)
|
||
|
|
{
|
||
|
|
TypeSymbol typeSymbol = arrayAccess.Type;
|
||
|
|
if (typeSymbol.IsEnumType())
|
||
|
|
{
|
||
|
|
typeSymbol = ((NamedTypeSymbol)typeSymbol).EnumUnderlyingType;
|
||
|
|
}
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = typeSymbol.PrimitiveTypeCode;
|
||
|
|
switch ((int)primitiveTypeCode)
|
||
|
|
{
|
||
|
|
case 2:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_i1);
|
||
|
|
break;
|
||
|
|
case 0:
|
||
|
|
case 12:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_u1);
|
||
|
|
break;
|
||
|
|
case 5:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_i2);
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
case 13:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_u2);
|
||
|
|
break;
|
||
|
|
case 6:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_i4);
|
||
|
|
break;
|
||
|
|
case 14:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_u4);
|
||
|
|
break;
|
||
|
|
case 7:
|
||
|
|
case 15:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_i8);
|
||
|
|
break;
|
||
|
|
case 8:
|
||
|
|
case 9:
|
||
|
|
case 16:
|
||
|
|
case 19:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_i);
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_r4);
|
||
|
|
break;
|
||
|
|
case 4:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_r8);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
if (typeSymbol.IsVerifierReference())
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem_ref);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelem);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if ((int)typeSymbol.TypeKind == 11)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Readonly);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldelema);
|
||
|
|
}
|
||
|
|
EmitSymbolToken(typeSymbol, arrayAccess.Syntax);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitArrayElementLoad(_module.Translate((ArrayTypeSymbol)arrayAccess.Expression.Type), arrayAccess.Expression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitFieldLoad(BoundFieldAccess fieldAccess, bool used)
|
||
|
|
{
|
||
|
|
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
FieldSymbol fieldSymbol = fieldAccess.FieldSymbol;
|
||
|
|
if (!used)
|
||
|
|
{
|
||
|
|
if (fieldSymbol.IsCapturedFrame)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!fieldSymbol.IsVolatile && !fieldSymbol.IsStatic && fieldAccess.ReceiverOpt.Type.IsVerifierValue() && (int)fieldSymbol.RefKind == 0)
|
||
|
|
{
|
||
|
|
EmitExpression(fieldAccess.ReceiverOpt, used: false);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitFieldLoadNoIndirection(fieldAccess, used);
|
||
|
|
if ((int)fieldSymbol.RefKind != 0)
|
||
|
|
{
|
||
|
|
EmitLoadIndirect(fieldSymbol.Type, fieldAccess.Syntax);
|
||
|
|
}
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitFieldLoadNoIndirection(BoundFieldAccess fieldAccess, bool used)
|
||
|
|
{
|
||
|
|
FieldSymbol fieldSymbol = fieldAccess.FieldSymbol;
|
||
|
|
if (fieldSymbol.IsStatic)
|
||
|
|
{
|
||
|
|
if (fieldSymbol.IsVolatile)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Volatile);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldsfld);
|
||
|
|
EmitSymbolToken(fieldSymbol, fieldAccess.Syntax);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
BoundExpression receiverOpt = fieldAccess.ReceiverOpt;
|
||
|
|
TypeSymbol type = fieldSymbol.Type;
|
||
|
|
if (type.IsValueType && (object)type == receiverOpt.Type)
|
||
|
|
{
|
||
|
|
EmitExpression(receiverOpt, used);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
LocalDefinition val = EmitFieldLoadReceiver(receiverOpt);
|
||
|
|
if (val != null)
|
||
|
|
{
|
||
|
|
FreeTemp(val);
|
||
|
|
}
|
||
|
|
if (fieldSymbol.IsVolatile)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Volatile);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldfld);
|
||
|
|
EmitSymbolToken(fieldSymbol, fieldAccess.Syntax);
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitFieldLoadReceiver(BoundExpression receiver)
|
||
|
|
{
|
||
|
|
if (FieldLoadMustUseRef(receiver) || FieldLoadPrefersRef(receiver))
|
||
|
|
{
|
||
|
|
if (!EmitFieldLoadReceiverAddress(receiver))
|
||
|
|
{
|
||
|
|
return EmitReceiverRef(receiver, Binder.AddressKind.ReadOnly);
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
EmitExpression(receiver, used: true);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool EmitFieldLoadReceiverAddress(BoundExpression receiver)
|
||
|
|
{
|
||
|
|
if (receiver == null || !receiver.Type.IsValueType)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (receiver.Kind == BoundKind.Conversion)
|
||
|
|
{
|
||
|
|
BoundConversion boundConversion = (BoundConversion)receiver;
|
||
|
|
if (boundConversion.ConversionKind == ConversionKind.Unboxing)
|
||
|
|
{
|
||
|
|
EmitExpression(boundConversion.Operand, used: true);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Unbox);
|
||
|
|
EmitSymbolToken(receiver.Type, receiver.Syntax);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (receiver.Kind == BoundKind.FieldAccess)
|
||
|
|
{
|
||
|
|
BoundFieldAccess boundFieldAccess = (BoundFieldAccess)receiver;
|
||
|
|
FieldSymbol fieldSymbol = boundFieldAccess.FieldSymbol;
|
||
|
|
if (!fieldSymbol.IsStatic && EmitFieldLoadReceiverAddress(boundFieldAccess.ReceiverOpt))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldflda);
|
||
|
|
EmitSymbolToken(fieldSymbol, boundFieldAccess.Syntax);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool FieldLoadPrefersRef(BoundExpression receiver)
|
||
|
|
{
|
||
|
|
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0088: Invalid comparison between Unknown and I4
|
||
|
|
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0074: Invalid comparison between Unknown and I4
|
||
|
|
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!receiver.Type.IsVerifierValue())
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (receiver.Kind == BoundKind.Conversion && ((BoundConversion)receiver).ConversionKind == ConversionKind.Unboxing)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (!HasHome(receiver, Binder.AddressKind.ReadOnly))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
switch (receiver.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.Parameter:
|
||
|
|
return (int)((BoundParameter)receiver).ParameterSymbol.RefKind > 0;
|
||
|
|
case BoundKind.Local:
|
||
|
|
return (int)((BoundLocal)receiver).LocalSymbol.RefKind > 0;
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
return FieldLoadPrefersRef(((BoundSequence)receiver).Value);
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
{
|
||
|
|
BoundFieldAccess boundFieldAccess = (BoundFieldAccess)receiver;
|
||
|
|
FieldSymbol fieldSymbol = boundFieldAccess.FieldSymbol;
|
||
|
|
if (fieldSymbol.IsStatic || (int)fieldSymbol.RefKind != 0)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (DiagnosticsPass.IsNonAgileFieldAccess(boundFieldAccess, ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return FieldLoadPrefersRef(boundFieldAccess.ReceiverOpt);
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool FieldLoadMustUseRef(BoundExpression expr)
|
||
|
|
{
|
||
|
|
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ac: Expected I4, but got Unknown
|
||
|
|
TypeSymbol type = expr.Type;
|
||
|
|
if (type.IsTypeParameter())
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
SpecialType specialType = type.SpecialType;
|
||
|
|
switch (specialType - 7)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
case 1:
|
||
|
|
case 2:
|
||
|
|
case 3:
|
||
|
|
case 4:
|
||
|
|
case 5:
|
||
|
|
case 6:
|
||
|
|
case 7:
|
||
|
|
case 8:
|
||
|
|
case 9:
|
||
|
|
case 11:
|
||
|
|
case 12:
|
||
|
|
case 14:
|
||
|
|
case 15:
|
||
|
|
case 31:
|
||
|
|
case 32:
|
||
|
|
case 33:
|
||
|
|
case 34:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return type.IsEnumType();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static int ParameterSlot(BoundParameter parameter)
|
||
|
|
{
|
||
|
|
ParameterSymbol parameterSymbol = parameter.ParameterSymbol;
|
||
|
|
int num = parameterSymbol.Ordinal;
|
||
|
|
if (!parameterSymbol.ContainingSymbol.IsStatic)
|
||
|
|
{
|
||
|
|
num++;
|
||
|
|
}
|
||
|
|
return num;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitLocalLoad(BoundLocal local, bool used)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Invalid comparison between Unknown and I4
|
||
|
|
bool flag = (int)local.LocalSymbol.RefKind > 0;
|
||
|
|
if (IsStackLocal(local.LocalSymbol))
|
||
|
|
{
|
||
|
|
EmitPopIfUnused(used || flag);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!(used || flag))
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
LocalDefinition local2 = GetLocal(local);
|
||
|
|
_builder.EmitLocalLoad(local2);
|
||
|
|
}
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
EmitLoadIndirect(local.LocalSymbol.Type, local.Syntax);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitParameterLoad(BoundParameter parameter)
|
||
|
|
{
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
int num = ParameterSlot(parameter);
|
||
|
|
_builder.EmitLoadArgumentOpcode(num);
|
||
|
|
if ((int)parameter.ParameterSymbol.RefKind != 0)
|
||
|
|
{
|
||
|
|
TypeSymbol type = parameter.ParameterSymbol.Type;
|
||
|
|
EmitLoadIndirect(type, parameter.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitLoadIndirect(TypeSymbol type, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0072: Expected I4, but got Unknown
|
||
|
|
if (type.IsEnumType())
|
||
|
|
{
|
||
|
|
type = ((NamedTypeSymbol)type).EnumUnderlyingType;
|
||
|
|
}
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = type.PrimitiveTypeCode;
|
||
|
|
switch ((int)primitiveTypeCode)
|
||
|
|
{
|
||
|
|
case 2:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_i1);
|
||
|
|
return;
|
||
|
|
case 0:
|
||
|
|
case 12:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_u1);
|
||
|
|
return;
|
||
|
|
case 5:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_i2);
|
||
|
|
return;
|
||
|
|
case 1:
|
||
|
|
case 13:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_u2);
|
||
|
|
return;
|
||
|
|
case 6:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_i4);
|
||
|
|
return;
|
||
|
|
case 14:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_u4);
|
||
|
|
return;
|
||
|
|
case 7:
|
||
|
|
case 15:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_i8);
|
||
|
|
return;
|
||
|
|
case 8:
|
||
|
|
case 9:
|
||
|
|
case 16:
|
||
|
|
case 19:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_i);
|
||
|
|
return;
|
||
|
|
case 3:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_r4);
|
||
|
|
return;
|
||
|
|
case 4:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_r8);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_ref);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldobj);
|
||
|
|
EmitSymbolToken(type, syntaxNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool CanUseCallOnRefTypeReceiver(BoundExpression receiver)
|
||
|
|
{
|
||
|
|
//IL_0129: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0130: Invalid comparison between Unknown and I4
|
||
|
|
if (receiver.Type.IsTypeParameter())
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
ConstantValue constantValueOpt = receiver.ConstantValueOpt;
|
||
|
|
if (constantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
return !constantValueOpt.IsNull;
|
||
|
|
}
|
||
|
|
switch (receiver.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.ArrayCreation:
|
||
|
|
return true;
|
||
|
|
case BoundKind.ObjectCreationExpression:
|
||
|
|
return true;
|
||
|
|
case BoundKind.Conversion:
|
||
|
|
{
|
||
|
|
BoundConversion boundConversion = (BoundConversion)receiver;
|
||
|
|
switch (boundConversion.ConversionKind)
|
||
|
|
{
|
||
|
|
case ConversionKind.Boxing:
|
||
|
|
return true;
|
||
|
|
case ConversionKind.AnonymousFunction:
|
||
|
|
case ConversionKind.MethodGroup:
|
||
|
|
return true;
|
||
|
|
case ConversionKind.ImplicitReference:
|
||
|
|
case ConversionKind.ExplicitReference:
|
||
|
|
return CanUseCallOnRefTypeReceiver(boundConversion.Operand);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.ThisReference:
|
||
|
|
return true;
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
return ((BoundFieldAccess)receiver).FieldSymbol.IsCapturedFrame;
|
||
|
|
case BoundKind.Local:
|
||
|
|
return (int)((BoundLocal)receiver).LocalSymbol.SynthesizedKind == -5;
|
||
|
|
case BoundKind.DelegateCreationExpression:
|
||
|
|
return true;
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
{
|
||
|
|
BoundExpression value = ((BoundSequence)receiver).Value;
|
||
|
|
return CanUseCallOnRefTypeReceiver(value);
|
||
|
|
}
|
||
|
|
case BoundKind.AssignmentOperator:
|
||
|
|
{
|
||
|
|
BoundExpression right = ((BoundAssignmentOperator)receiver).Right;
|
||
|
|
return CanUseCallOnRefTypeReceiver(right);
|
||
|
|
}
|
||
|
|
case BoundKind.TypeOfOperator:
|
||
|
|
return true;
|
||
|
|
case BoundKind.ConditionalReceiver:
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsThisReceiver(BoundExpression receiver)
|
||
|
|
{
|
||
|
|
switch (receiver.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.ThisReference:
|
||
|
|
return true;
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
{
|
||
|
|
BoundExpression value = ((BoundSequence)receiver).Value;
|
||
|
|
return IsThisReceiver(value);
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCallExpression(BoundCall call, UseKind useKind)
|
||
|
|
{
|
||
|
|
if (call.Method.IsDefaultValueTypeConstructor())
|
||
|
|
{
|
||
|
|
EmitDefaultValueTypeConstructorCallExpression(call);
|
||
|
|
}
|
||
|
|
else if (!call.Method.RequiresInstanceReceiver)
|
||
|
|
{
|
||
|
|
EmitStaticCallExpression(call, useKind);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitInstanceCallExpression(call, useKind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
|
|
private void EmitDefaultValueTypeConstructorCallExpression(BoundCall call)
|
||
|
|
{
|
||
|
|
MethodSymbol method = call.Method;
|
||
|
|
BoundExpression receiverOpt = call.ReceiverOpt;
|
||
|
|
LocalDefinition temp = EmitReceiverRef(receiverOpt, Binder.AddressKind.Writeable);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Initobj);
|
||
|
|
EmitSymbolToken(method.ContainingType, call.Syntax);
|
||
|
|
FreeOptTemp(temp);
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
|
|
private void EmitStaticCallExpression(BoundCall call, UseKind useKind)
|
||
|
|
{
|
||
|
|
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0062: Invalid comparison between Unknown and I4
|
||
|
|
MethodSymbol method = call.Method;
|
||
|
|
BoundExpression receiverOpt = call.ReceiverOpt;
|
||
|
|
ImmutableArray<BoundExpression> arguments = call.Arguments;
|
||
|
|
EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt);
|
||
|
|
int callStackBehavior = GetCallStackBehavior(method, arguments);
|
||
|
|
if (method.IsAbstract || method.IsVirtual)
|
||
|
|
{
|
||
|
|
if (receiverOpt is BoundTypeExpression boundTypeExpression)
|
||
|
|
{
|
||
|
|
TypeSymbol type = boundTypeExpression.Type;
|
||
|
|
if ((object)type != null && (int)type.TypeKind == 11)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Constrained);
|
||
|
|
EmitSymbolToken(receiverOpt.Type, receiverOpt.Syntax);
|
||
|
|
goto IL_0096;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs", 1644);
|
||
|
|
}
|
||
|
|
goto IL_0096;
|
||
|
|
IL_0096:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, callStackBehavior);
|
||
|
|
EmitSymbolToken(method, call.Syntax, method.IsVararg ? ((BoundArgListOperator)arguments[arguments.Length - 1]) : null);
|
||
|
|
EmitCallCleanup(call.Syntax, useKind, method);
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
|
|
private void EmitInstanceCallExpression(BoundCall call, UseKind useKind)
|
||
|
|
{
|
||
|
|
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
CallKind callKind;
|
||
|
|
Binder.AddressKind? addressKind;
|
||
|
|
bool box;
|
||
|
|
LocalDefinition tempOpt;
|
||
|
|
if (receiverIsInstanceCall(call, out var nested))
|
||
|
|
{
|
||
|
|
ArrayBuilder<BoundCall> instance = ArrayBuilder<BoundCall>.GetInstance();
|
||
|
|
ArrayBuilderExtensions.Push<BoundCall>(instance, call);
|
||
|
|
call = nested;
|
||
|
|
while (receiverIsInstanceCall(call, out nested))
|
||
|
|
{
|
||
|
|
ArrayBuilderExtensions.Push<BoundCall>(instance, call);
|
||
|
|
call = nested;
|
||
|
|
}
|
||
|
|
callKind = determineEmitReceiverStrategy(call, out addressKind, out box);
|
||
|
|
emitReceiver(call, callKind, addressKind, box, out tempOpt);
|
||
|
|
while (instance.Count != 0)
|
||
|
|
{
|
||
|
|
BoundCall boundCall = ArrayBuilderExtensions.Pop<BoundCall>(instance);
|
||
|
|
CallKind num = determineEmitReceiverStrategy(boundCall, out addressKind, out box);
|
||
|
|
TypeSymbol type = call.Type;
|
||
|
|
UseKind useKind2;
|
||
|
|
if (!addressKind.HasValue)
|
||
|
|
{
|
||
|
|
useKind2 = UseKind.UsedAsValue;
|
||
|
|
}
|
||
|
|
else if (BoxNonVerifierReferenceReceiver(type, addressKind.GetValueOrDefault()))
|
||
|
|
{
|
||
|
|
useKind2 = UseKind.UsedAsValue;
|
||
|
|
box = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_ = call.Method.RefKind;
|
||
|
|
useKind2 = ((!UseCallResultAsAddress(call, addressKind.GetValueOrDefault())) ? UseKind.UsedAsValue : UseKind.UsedAsAddress);
|
||
|
|
}
|
||
|
|
emitArgumentsAndCallEpilogue(call, callKind, useKind2);
|
||
|
|
FreeOptTemp(tempOpt);
|
||
|
|
tempOpt = null;
|
||
|
|
nested = call;
|
||
|
|
call = boundCall;
|
||
|
|
callKind = num;
|
||
|
|
if (box)
|
||
|
|
{
|
||
|
|
EmitBox(type, nested.Syntax);
|
||
|
|
}
|
||
|
|
else if (addressKind.HasValue)
|
||
|
|
{
|
||
|
|
if (useKind2 != UseKind.UsedAsAddress)
|
||
|
|
{
|
||
|
|
tempOpt = AllocateTemp(type, nested.Syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(tempOpt);
|
||
|
|
_builder.EmitLocalAddress(tempOpt);
|
||
|
|
}
|
||
|
|
emitGenericReceiverCloneIfNecessary(call, callKind, ref tempOpt);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
instance.Free();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
callKind = determineEmitReceiverStrategy(call, out addressKind, out box);
|
||
|
|
emitReceiver(call, callKind, addressKind, box, out tempOpt);
|
||
|
|
}
|
||
|
|
emitArgumentsAndCallEpilogue(call, callKind, useKind);
|
||
|
|
FreeOptTemp(tempOpt);
|
||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
|
|
CallKind determineEmitReceiverStrategy(BoundCall boundCall2, out Binder.AddressKind? reference2, out bool reference)
|
||
|
|
{
|
||
|
|
MethodSymbol method = boundCall2.Method;
|
||
|
|
BoundExpression receiverOpt = boundCall2.ReceiverOpt;
|
||
|
|
TypeSymbol type2 = receiverOpt.Type;
|
||
|
|
reference = false;
|
||
|
|
CallKind callKind2;
|
||
|
|
if (type2.IsVerifierReference())
|
||
|
|
{
|
||
|
|
reference2 = null;
|
||
|
|
callKind2 = ((!receiverOpt.SuppressVirtualCalls && (method.IsMetadataVirtual() || !CanUseCallOnRefTypeReceiver(receiverOpt))) ? CallKind.CallVirt : CallKind.Call);
|
||
|
|
}
|
||
|
|
else if (type2.IsVerifierValue())
|
||
|
|
{
|
||
|
|
NamedTypeSymbol containingType = method.ContainingType;
|
||
|
|
if (containingType.IsVerifierValue())
|
||
|
|
{
|
||
|
|
reference2 = (IsReadOnlyCall(method, containingType) ? Binder.AddressKind.ReadOnly : Binder.AddressKind.Writeable);
|
||
|
|
callKind2 = ((!MayUseCallForStructMethod(method)) ? CallKind.ConstrainedCallVirt : CallKind.Call);
|
||
|
|
}
|
||
|
|
else if (method.IsMetadataVirtual())
|
||
|
|
{
|
||
|
|
reference2 = Binder.AddressKind.Writeable;
|
||
|
|
callKind2 = CallKind.ConstrainedCallVirt;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
reference2 = null;
|
||
|
|
reference = true;
|
||
|
|
callKind2 = CallKind.Call;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
callKind2 = ((type2.IsReferenceType && !IsRef(receiverOpt)) ? CallKind.CallVirt : CallKind.ConstrainedCallVirt);
|
||
|
|
reference2 = ((callKind2 == CallKind.ConstrainedCallVirt) ? Binder.AddressKind.Constrained : Binder.AddressKind.Writeable);
|
||
|
|
}
|
||
|
|
return callKind2;
|
||
|
|
}
|
||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
|
|
void emitArgumentsAndCallEpilogue(BoundCall boundCall2, CallKind callKind2, UseKind useKind3)
|
||
|
|
{
|
||
|
|
MethodSymbol method = boundCall2.Method;
|
||
|
|
BoundExpression receiverOpt = boundCall2.ReceiverOpt;
|
||
|
|
MethodSymbol methodSymbol = method;
|
||
|
|
if (method.IsOverride && callKind2 != CallKind.Call)
|
||
|
|
{
|
||
|
|
methodSymbol = method.GetConstructedLeastOverriddenMethod(_method.ContainingType, requireSameReturnType: true);
|
||
|
|
}
|
||
|
|
if (callKind2 == CallKind.ConstrainedCallVirt && methodSymbol.ContainingType.IsValueType)
|
||
|
|
{
|
||
|
|
callKind2 = CallKind.Call;
|
||
|
|
}
|
||
|
|
if (callKind2 == CallKind.CallVirt)
|
||
|
|
{
|
||
|
|
if (IsThisReceiver(receiverOpt) && methodSymbol.ContainingType.IsSealed && (object)methodSymbol.ContainingModule == _method.ContainingModule)
|
||
|
|
{
|
||
|
|
callKind2 = CallKind.Call;
|
||
|
|
}
|
||
|
|
else if (methodSymbol.IsMetadataFinal && CanUseCallOnRefTypeReceiver(receiverOpt))
|
||
|
|
{
|
||
|
|
callKind2 = CallKind.Call;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ImmutableArray<BoundExpression> arguments = boundCall2.Arguments;
|
||
|
|
EmitArguments(arguments, method.Parameters, boundCall2.ArgumentRefKindsOpt);
|
||
|
|
int callStackBehavior = GetCallStackBehavior(method, arguments);
|
||
|
|
switch (callKind2)
|
||
|
|
{
|
||
|
|
case CallKind.Call:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, callStackBehavior);
|
||
|
|
break;
|
||
|
|
case CallKind.CallVirt:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Callvirt, callStackBehavior);
|
||
|
|
break;
|
||
|
|
case CallKind.ConstrainedCallVirt:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Constrained);
|
||
|
|
EmitSymbolToken(receiverOpt.Type, receiverOpt.Syntax);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Callvirt, callStackBehavior);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
EmitSymbolToken(methodSymbol, boundCall2.Syntax, methodSymbol.IsVararg ? ((BoundArgListOperator)arguments[arguments.Length - 1]) : null);
|
||
|
|
EmitCallCleanup(boundCall2.Syntax, useKind3, method);
|
||
|
|
}
|
||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
|
|
void emitGenericReceiverCloneIfNecessary(BoundCall boundCall2, CallKind callKind2, ref LocalDefinition reference)
|
||
|
|
{
|
||
|
|
BoundExpression receiverOpt = boundCall2.ReceiverOpt;
|
||
|
|
TypeSymbol type2 = receiverOpt.Type;
|
||
|
|
if (callKind2 == CallKind.ConstrainedCallVirt && reference == null && !type2.IsValueType && !ReceiverIsKnownToReferToTempIfReferenceType(receiverOpt) && !IsSafeToDereferenceReceiverRefAfterEvaluatingArguments(boundCall2.Arguments))
|
||
|
|
{
|
||
|
|
object obj = null;
|
||
|
|
if (!type2.IsReferenceType)
|
||
|
|
{
|
||
|
|
EmitDefaultValue(type2, used: true, receiverOpt.Syntax);
|
||
|
|
EmitBox(type2, receiverOpt.Syntax);
|
||
|
|
obj = new object();
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj, ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
EmitLoadIndirect(type2, receiverOpt.Syntax);
|
||
|
|
reference = AllocateTemp(type2, receiverOpt.Syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(reference);
|
||
|
|
_builder.EmitLocalAddress(reference);
|
||
|
|
if (obj != null)
|
||
|
|
{
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
|
|
void emitReceiver(BoundCall boundCall2, CallKind callKind2, Binder.AddressKind? addressKind2, bool flag, out LocalDefinition reference)
|
||
|
|
{
|
||
|
|
BoundExpression receiverOpt = boundCall2.ReceiverOpt;
|
||
|
|
TypeSymbol type2 = receiverOpt.Type;
|
||
|
|
reference = null;
|
||
|
|
if (!addressKind2.HasValue)
|
||
|
|
{
|
||
|
|
EmitExpression(receiverOpt, used: true);
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
EmitBox(type2, receiverOpt.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
reference = EmitReceiverRef(receiverOpt, addressKind2.GetValueOrDefault());
|
||
|
|
emitGenericReceiverCloneIfNecessary(boundCall2, callKind2, ref reference);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
static bool receiverIsInstanceCall(BoundCall boundCall3, out BoundCall reference)
|
||
|
|
{
|
||
|
|
if (boundCall3.ReceiverOpt is BoundCall boundCall2)
|
||
|
|
{
|
||
|
|
MethodSymbol method = boundCall2.Method;
|
||
|
|
if ((object)method != null && method.RequiresInstanceReceiver && !method.IsDefaultValueTypeConstructor())
|
||
|
|
{
|
||
|
|
reference = boundCall2;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
reference = null;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool IsPossibleReferenceTypeReceiverOfConstrainedCall(BoundExpression receiver)
|
||
|
|
{
|
||
|
|
TypeSymbol type = receiver.Type;
|
||
|
|
if (type.IsVerifierReference() || type.IsVerifierValue())
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return !type.IsValueType;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool ReceiverIsKnownToReferToTempIfReferenceType(BoundExpression receiver)
|
||
|
|
{
|
||
|
|
while (receiver is BoundSequence boundSequence)
|
||
|
|
{
|
||
|
|
receiver = boundSequence.Value;
|
||
|
|
}
|
||
|
|
if (receiver is BoundLocal boundLocal)
|
||
|
|
{
|
||
|
|
LocalSymbol localSymbol = boundLocal.LocalSymbol;
|
||
|
|
if ((object)localSymbol != null && localSymbol.IsKnownToReferToTempIfReferenceType)
|
||
|
|
{
|
||
|
|
goto IL_0062;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (receiver is BoundComplexConditionalReceiver)
|
||
|
|
{
|
||
|
|
goto IL_0062;
|
||
|
|
}
|
||
|
|
if (receiver is BoundConditionalReceiver boundConditionalReceiver)
|
||
|
|
{
|
||
|
|
TypeSymbol type = boundConditionalReceiver.Type;
|
||
|
|
if ((object)type != null && !type.IsReferenceType && !type.IsValueType)
|
||
|
|
{
|
||
|
|
goto IL_0062;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
bool flag = false;
|
||
|
|
goto IL_006a;
|
||
|
|
IL_006a:
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
IL_0062:
|
||
|
|
flag = true;
|
||
|
|
goto IL_006a;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool IsSafeToDereferenceReceiverRefAfterEvaluatingArguments(ImmutableArray<BoundExpression> arguments)
|
||
|
|
{
|
||
|
|
return arguments.All(isSafeToDereferenceReceiverRefAfterEvaluatingArgument);
|
||
|
|
static bool isSafeToDereferenceReceiverRefAfterEvaluatingArgument(BoundExpression expression)
|
||
|
|
{
|
||
|
|
BoundExpression boundExpression = expression;
|
||
|
|
while (!(boundExpression.ConstantValueOpt != (ConstantValue)null))
|
||
|
|
{
|
||
|
|
switch (boundExpression.Kind)
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
case BoundKind.TypeExpression:
|
||
|
|
case BoundKind.ThisReference:
|
||
|
|
case BoundKind.Local:
|
||
|
|
case BoundKind.Parameter:
|
||
|
|
return true;
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
boundExpression = ((BoundFieldAccess)boundExpression).ReceiverOpt;
|
||
|
|
if (boundExpression == null)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BoundKind.PassByCopy:
|
||
|
|
boundExpression = ((BoundPassByCopy)boundExpression).Expression;
|
||
|
|
break;
|
||
|
|
case BoundKind.BinaryOperator:
|
||
|
|
{
|
||
|
|
BoundBinaryOperator boundBinaryOperator = (BoundBinaryOperator)boundExpression;
|
||
|
|
if (boundBinaryOperator.OperatorKind.IsUserDefined() || !isSafeToDereferenceReceiverRefAfterEvaluatingArgument(boundBinaryOperator.Right))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
boundExpression = boundBinaryOperator.Left;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.Conversion:
|
||
|
|
{
|
||
|
|
BoundConversion boundConversion = (BoundConversion)boundExpression;
|
||
|
|
if (boundConversion.ConversionKind.IsUserDefinedConversion())
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
boundExpression = boundConversion.Operand;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsReadOnlyCall(MethodSymbol method, NamedTypeSymbol methodContainingType)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Invalid comparison between Unknown and I4
|
||
|
|
if (method.IsEffectivelyReadOnly && (int)method.MethodKind != 1)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (methodContainingType.IsNullableType())
|
||
|
|
{
|
||
|
|
MethodSymbol originalDefinition = method.OriginalDefinition;
|
||
|
|
if ((object)originalDefinition == ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.GetSpecialTypeMember((SpecialMember)114) || (object)originalDefinition == ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.GetSpecialTypeMember((SpecialMember)115) || (object)originalDefinition == ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.GetSpecialTypeMember((SpecialMember)116))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool IsRef(BoundExpression receiver)
|
||
|
|
{
|
||
|
|
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005c: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0098: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0089: Invalid comparison between Unknown and I4
|
||
|
|
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0070: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: Invalid comparison between Unknown and I4
|
||
|
|
return receiver.Kind switch
|
||
|
|
{
|
||
|
|
BoundKind.Local => (int)((BoundLocal)receiver).LocalSymbol.RefKind > 0,
|
||
|
|
BoundKind.Parameter => (int)((BoundParameter)receiver).ParameterSymbol.RefKind > 0,
|
||
|
|
BoundKind.Call => (int)((BoundCall)receiver).Method.RefKind > 0,
|
||
|
|
BoundKind.FunctionPointerInvocation => (int)((BoundFunctionPointerInvocation)receiver).FunctionPointer.Signature.RefKind > 0,
|
||
|
|
BoundKind.Dup => (int)((BoundDup)receiver).RefKind > 0,
|
||
|
|
BoundKind.Sequence => IsRef(((BoundSequence)receiver).Value),
|
||
|
|
_ => false,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
private static int GetCallStackBehavior(MethodSymbol method, ImmutableArray<BoundExpression> arguments)
|
||
|
|
{
|
||
|
|
int num = 0;
|
||
|
|
if (!method.ReturnsVoid)
|
||
|
|
{
|
||
|
|
num++;
|
||
|
|
}
|
||
|
|
if (method.RequiresInstanceReceiver)
|
||
|
|
{
|
||
|
|
num--;
|
||
|
|
}
|
||
|
|
if (method.IsVararg)
|
||
|
|
{
|
||
|
|
int num2 = arguments.Length - 1;
|
||
|
|
int length = ((BoundArgListOperator)arguments[num2]).Arguments.Length;
|
||
|
|
num -= num2;
|
||
|
|
return num - length;
|
||
|
|
}
|
||
|
|
return num - arguments.Length;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static int GetObjCreationStackBehavior(BoundObjectCreationExpression objCreation)
|
||
|
|
{
|
||
|
|
int num = 0;
|
||
|
|
num++;
|
||
|
|
if (objCreation.Constructor.IsVararg)
|
||
|
|
{
|
||
|
|
int num2 = objCreation.Arguments.Length - 1;
|
||
|
|
int length = ((BoundArgListOperator)objCreation.Arguments[num2]).Arguments.Length;
|
||
|
|
num -= num2;
|
||
|
|
return num - length;
|
||
|
|
}
|
||
|
|
return num - objCreation.Arguments.Length;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool MayUseCallForStructMethod(MethodSymbol method)
|
||
|
|
{
|
||
|
|
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0033: Invalid comparison between Unknown and I4
|
||
|
|
if (!method.IsMetadataVirtual() || method.IsStatic)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
MethodSymbol overriddenMethod = method.OverriddenMethod;
|
||
|
|
if ((object)overriddenMethod == null || overriddenMethod.IsAbstract)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return (int)method.ContainingType.SpecialType > 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void TreatLongsAsNative(PrimitiveTypeCode tc)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0002: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Invalid comparison between Unknown and I4
|
||
|
|
if ((int)tc == 7)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_ovf_i);
|
||
|
|
}
|
||
|
|
else if ((int)tc == 15)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_ovf_i_un);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArrayLength(BoundArrayLength expression, bool used)
|
||
|
|
{
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
EmitExpression(expression.Expression, used: true);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldlen);
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = expression.Type.PrimitiveTypeCode;
|
||
|
|
PrimitiveTypeCode val = (PrimitiveTypeCode)(PrimitiveTypeCodeExtensions.IsUnsigned(primitiveTypeCode) ? 16 : 8);
|
||
|
|
_builder.EmitNumericConversion(val, primitiveTypeCode, false);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArrayCreationExpression(BoundArrayCreation expression, bool used)
|
||
|
|
{
|
||
|
|
ArrayTypeSymbol arrayTypeSymbol = (ArrayTypeSymbol)expression.Type;
|
||
|
|
EmitArrayIndices(expression.Bounds);
|
||
|
|
if (arrayTypeSymbol.IsSZArray)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Newarr);
|
||
|
|
EmitSymbolToken(arrayTypeSymbol.ElementType, expression.Syntax);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitArrayCreation(_module.Translate(arrayTypeSymbol), expression.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
if (expression.InitializerOpt != null)
|
||
|
|
{
|
||
|
|
EmitArrayInitializers(arrayTypeSymbol, expression.InitializerOpt);
|
||
|
|
}
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConvertedStackAllocExpression(BoundConvertedStackAllocExpression expression, bool used)
|
||
|
|
{
|
||
|
|
EmitExpression(expression.Count, used);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
_sawStackalloc = true;
|
||
|
|
_builder.EmitOpCode(ILOpCode.Localloc);
|
||
|
|
}
|
||
|
|
BoundArrayInitialization initializerOpt = expression.InitializerOpt;
|
||
|
|
if (initializerOpt == null)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitStackAllocInitializers(expression.Type, initializerOpt);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = initializerOpt.Initializers.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundExpression current = enumerator.Current;
|
||
|
|
EmitExpression(current, used: false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitObjectCreationExpression(BoundObjectCreationExpression expression, bool used)
|
||
|
|
{
|
||
|
|
MethodSymbol constructor = expression.Constructor;
|
||
|
|
bool avoidInPlace;
|
||
|
|
if (constructor.IsDefaultValueTypeConstructor())
|
||
|
|
{
|
||
|
|
EmitInitObj(expression.Type, used, expression.Syntax);
|
||
|
|
}
|
||
|
|
else if (!used && ConstructorNotSideEffecting(constructor))
|
||
|
|
{
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = expression.Arguments.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundExpression current = enumerator.Current;
|
||
|
|
EmitExpression(current, used: false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (!TryEmitReadonlySpanAsBlobWrapper(expression, used, null, out avoidInPlace))
|
||
|
|
{
|
||
|
|
EmitArguments(expression.Arguments, constructor.Parameters, expression.ArgumentRefKindsOpt);
|
||
|
|
int objCreationStackBehavior = GetObjCreationStackBehavior(expression);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Newobj, objCreationStackBehavior);
|
||
|
|
EmitSymbolToken(constructor, expression.Syntax, constructor.IsVararg ? ((BoundArgListOperator)expression.Arguments[expression.Arguments.Length - 1]) : null);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool TryEmitReadonlySpanAsBlobWrapper(BoundObjectCreationExpression expression, bool used, BoundExpression inPlaceTarget, out bool avoidInPlace)
|
||
|
|
{
|
||
|
|
int length = expression.Arguments.Length;
|
||
|
|
avoidInPlace = false;
|
||
|
|
if ((length == 1 && (object)expression.Constructor.OriginalDefinition == ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.GetWellKnownTypeMember((WellKnownMember)404)) || (length == 3 && (object)expression.Constructor.OriginalDefinition == ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.GetWellKnownTypeMember((WellKnownMember)405)))
|
||
|
|
{
|
||
|
|
return TryEmitReadonlySpanAsBlobWrapper((NamedTypeSymbol)expression.Type, expression.Arguments[0], used, inPlaceTarget, out avoidInPlace, (length == 3) ? expression.Arguments[1] : null, (length == 3) ? expression.Arguments[2] : null);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool ConstructorNotSideEffecting(MethodSymbol constructor)
|
||
|
|
{
|
||
|
|
MethodSymbol originalDefinition = constructor.OriginalDefinition;
|
||
|
|
CSharpCompilation compilation = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation;
|
||
|
|
if (originalDefinition == compilation.GetSpecialTypeMember((SpecialMember)117))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (originalDefinition.ContainingType.Name == "ValueTuple" && (originalDefinition == compilation.GetWellKnownTypeMember((WellKnownMember)345) || originalDefinition == compilation.GetWellKnownTypeMember((WellKnownMember)346) || originalDefinition == compilation.GetWellKnownTypeMember((WellKnownMember)347) || originalDefinition == compilation.GetWellKnownTypeMember((WellKnownMember)348) || originalDefinition == compilation.GetWellKnownTypeMember((WellKnownMember)349) || originalDefinition == compilation.GetWellKnownTypeMember((WellKnownMember)350) || originalDefinition == compilation.GetWellKnownTypeMember((WellKnownMember)351) || originalDefinition == compilation.GetWellKnownTypeMember((WellKnownMember)344)))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitAssignmentExpression(BoundAssignmentOperator assignmentOperator, UseKind useKind)
|
||
|
|
{
|
||
|
|
if (!TryEmitAssignmentInPlace(assignmentOperator, useKind != UseKind.Unused))
|
||
|
|
{
|
||
|
|
bool lhsUsesStack = EmitAssignmentPreamble(assignmentOperator);
|
||
|
|
EmitAssignmentValue(assignmentOperator);
|
||
|
|
LocalDefinition temp = EmitAssignmentDuplication(assignmentOperator, useKind, lhsUsesStack);
|
||
|
|
EmitStore(assignmentOperator);
|
||
|
|
EmitAssignmentPostfix(assignmentOperator, temp, useKind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool TryEmitAssignmentInPlace(BoundAssignmentOperator assignmentOperator, bool used)
|
||
|
|
{
|
||
|
|
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005d: Invalid comparison between Unknown and I4
|
||
|
|
if (assignmentOperator.IsRef)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
BoundExpression left = assignmentOperator.Left;
|
||
|
|
if (used && !TargetIsNotOnHeap(left))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!SafeToGetWriteableReference(left))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
BoundExpression right = assignmentOperator.Right;
|
||
|
|
TypeSymbol type = right.Type;
|
||
|
|
if (!type.IsTypeParameter() && (type.IsReferenceType || (right.ConstantValueOpt != (ConstantValue)null && (int)type.SpecialType != 17)))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (right.IsDefaultValue())
|
||
|
|
{
|
||
|
|
InPlaceInit(left, used);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (right is BoundObjectCreationExpression boundObjectCreationExpression)
|
||
|
|
{
|
||
|
|
if (boundObjectCreationExpression.Arguments.Length > 0 && boundObjectCreationExpression.Arguments[0].Kind == BoundKind.ConvertedStackAllocExpression)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (PartialCtorResultCannotEscape(left))
|
||
|
|
{
|
||
|
|
MethodSymbol constructor = boundObjectCreationExpression.Constructor;
|
||
|
|
if (constructor.Parameters.All((ParameterSymbol p) => (int)p.RefKind == 0) && !constructor.IsVararg && TryInPlaceCtorCall(left, boundObjectCreationExpression, used))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool SafeToGetWriteableReference(BoundExpression left)
|
||
|
|
{
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Invalid comparison between Unknown and I4
|
||
|
|
if (!HasHome(left, Binder.AddressKind.Writeable))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (left.Kind == BoundKind.ArrayAccess && (int)left.Type.TypeKind == 11 && !left.Type.IsValueType)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (left.Kind == BoundKind.FieldAccess)
|
||
|
|
{
|
||
|
|
BoundFieldAccess boundFieldAccess = (BoundFieldAccess)left;
|
||
|
|
if (boundFieldAccess.FieldSymbol.IsVolatile || DiagnosticsPass.IsNonAgileFieldAccess(boundFieldAccess, ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void InPlaceInit(BoundExpression target, bool used)
|
||
|
|
{
|
||
|
|
EmitAddress(target, Binder.AddressKind.Writeable);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Initobj);
|
||
|
|
EmitSymbolToken(target.Type, target.Syntax);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitExpression(target, used);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool TryInPlaceCtorCall(BoundExpression target, BoundObjectCreationExpression objCreation, bool used)
|
||
|
|
{
|
||
|
|
if (TryEmitReadonlySpanAsBlobWrapper(objCreation, used, target, out var avoidInPlace))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (avoidInPlace)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
EmitAddress(target, Binder.AddressKind.Writeable);
|
||
|
|
MethodSymbol constructor = objCreation.Constructor;
|
||
|
|
EmitArguments(objCreation.Arguments, constructor.Parameters, objCreation.ArgumentRefKindsOpt);
|
||
|
|
int num = GetObjCreationStackBehavior(objCreation) - 2;
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, num);
|
||
|
|
EmitSymbolToken(constructor, objCreation.Syntax, constructor.IsVararg ? ((BoundArgListOperator)objCreation.Arguments[objCreation.Arguments.Length - 1]) : null);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
EmitExpression(target, used: true);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool PartialCtorResultCannotEscape(BoundExpression left)
|
||
|
|
{
|
||
|
|
if (TargetIsNotOnHeap(left))
|
||
|
|
{
|
||
|
|
if (_tryNestingLevel != 0)
|
||
|
|
{
|
||
|
|
if (left is BoundLocal localExpression && !_builder.PossiblyDefinedOutsideOfTry(GetLocal(localExpression)))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool TargetIsNotOnHeap(BoundExpression left)
|
||
|
|
{
|
||
|
|
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: Invalid comparison between Unknown and I4
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0022: Invalid comparison between Unknown and I4
|
||
|
|
return left.Kind switch
|
||
|
|
{
|
||
|
|
BoundKind.Parameter => (int)((BoundParameter)left).ParameterSymbol.RefKind == 0,
|
||
|
|
BoundKind.Local => (int)((BoundLocal)left).LocalSymbol.RefKind == 0,
|
||
|
|
_ => false,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool EmitAssignmentPreamble(BoundAssignmentOperator assignmentOperator)
|
||
|
|
{
|
||
|
|
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0184: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
BoundExpression left = assignmentOperator.Left;
|
||
|
|
bool result = false;
|
||
|
|
switch (left.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.RefValueOperator:
|
||
|
|
EmitRefValueAddress((BoundRefValueOperator)left);
|
||
|
|
break;
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
{
|
||
|
|
BoundFieldAccess boundFieldAccess = (BoundFieldAccess)left;
|
||
|
|
if ((int)boundFieldAccess.FieldSymbol.RefKind != 0 && !assignmentOperator.IsRef)
|
||
|
|
{
|
||
|
|
EmitFieldLoadNoIndirection(boundFieldAccess, used: true);
|
||
|
|
}
|
||
|
|
else if (!boundFieldAccess.FieldSymbol.IsStatic)
|
||
|
|
{
|
||
|
|
EmitReceiverRef(boundFieldAccess.ReceiverOpt, Binder.AddressKind.Writeable);
|
||
|
|
result = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.Parameter:
|
||
|
|
{
|
||
|
|
BoundParameter boundParameter = (BoundParameter)left;
|
||
|
|
if ((int)boundParameter.ParameterSymbol.RefKind != 0 && !assignmentOperator.IsRef)
|
||
|
|
{
|
||
|
|
_builder.EmitLoadArgumentOpcode(ParameterSlot(boundParameter));
|
||
|
|
result = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.Local:
|
||
|
|
{
|
||
|
|
BoundLocal boundLocal = (BoundLocal)left;
|
||
|
|
if ((int)boundLocal.LocalSymbol.RefKind != 0 && !assignmentOperator.IsRef)
|
||
|
|
{
|
||
|
|
if (!IsStackLocal(boundLocal.LocalSymbol))
|
||
|
|
{
|
||
|
|
LocalDefinition local = GetLocal(boundLocal);
|
||
|
|
_builder.EmitLocalLoad(local);
|
||
|
|
}
|
||
|
|
result = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.ArrayAccess:
|
||
|
|
{
|
||
|
|
BoundArrayAccess boundArrayAccess = (BoundArrayAccess)left;
|
||
|
|
EmitExpression(boundArrayAccess.Expression, used: true);
|
||
|
|
EmitArrayIndices(boundArrayAccess.Indices);
|
||
|
|
result = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.ThisReference:
|
||
|
|
{
|
||
|
|
BoundThisReference expression3 = (BoundThisReference)left;
|
||
|
|
EmitAddress(expression3, Binder.AddressKind.Writeable);
|
||
|
|
result = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.Dup:
|
||
|
|
{
|
||
|
|
BoundDup expression2 = (BoundDup)left;
|
||
|
|
EmitAddress(expression2, Binder.AddressKind.Writeable);
|
||
|
|
result = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.ConditionalOperator:
|
||
|
|
{
|
||
|
|
BoundConditionalOperator expression = (BoundConditionalOperator)left;
|
||
|
|
EmitAddress(expression, Binder.AddressKind.Writeable);
|
||
|
|
result = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.PointerIndirectionOperator:
|
||
|
|
{
|
||
|
|
BoundPointerIndirectionOperator boundPointerIndirectionOperator = (BoundPointerIndirectionOperator)left;
|
||
|
|
EmitExpression(boundPointerIndirectionOperator.Operand, used: true);
|
||
|
|
result = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
{
|
||
|
|
BoundSequence boundSequence = (BoundSequence)left;
|
||
|
|
DefineAndRecordLocals(boundSequence);
|
||
|
|
EmitSideEffects(boundSequence);
|
||
|
|
result = EmitAssignmentPreamble(assignmentOperator.Update(boundSequence.Value, assignmentOperator.Right, assignmentOperator.IsRef, assignmentOperator.Type));
|
||
|
|
CloseScopeAndKeepLocals(boundSequence);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.Call:
|
||
|
|
{
|
||
|
|
BoundCall call = (BoundCall)left;
|
||
|
|
EmitCallExpression(call, UseKind.UsedAsAddress);
|
||
|
|
result = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.FunctionPointerInvocation:
|
||
|
|
{
|
||
|
|
BoundFunctionPointerInvocation ptrInvocation = (BoundFunctionPointerInvocation)left;
|
||
|
|
EmitCalli(ptrInvocation, UseKind.UsedAsAddress);
|
||
|
|
result = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.PreviousSubmissionReference:
|
||
|
|
case BoundKind.PropertyAccess:
|
||
|
|
case BoundKind.IndexerAccess:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)left.Kind);
|
||
|
|
case BoundKind.PseudoVariable:
|
||
|
|
EmitPseudoVariableAddress((BoundPseudoVariable)left);
|
||
|
|
result = true;
|
||
|
|
break;
|
||
|
|
case BoundKind.AssignmentOperator:
|
||
|
|
{
|
||
|
|
BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)left;
|
||
|
|
if (boundAssignmentOperator.IsRef)
|
||
|
|
{
|
||
|
|
EmitAssignmentExpression(boundAssignmentOperator, UseKind.UsedAsAddress);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
goto default;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)left.Kind);
|
||
|
|
case BoundKind.InstrumentationPayloadRoot:
|
||
|
|
case BoundKind.ModuleVersionId:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitAssignmentValue(BoundAssignmentOperator assignmentOperator)
|
||
|
|
{
|
||
|
|
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0045: Invalid comparison between Unknown and I4
|
||
|
|
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!assignmentOperator.IsRef)
|
||
|
|
{
|
||
|
|
EmitExpression(assignmentOperator.Right, used: true);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int num = _expressionTemps?.Count ?? 0;
|
||
|
|
BoundExpression left = assignmentOperator.Left;
|
||
|
|
BoundExpression right = assignmentOperator.Right;
|
||
|
|
RefKind refKind = left.GetRefKind();
|
||
|
|
bool flag = refKind - 3 <= 2;
|
||
|
|
LocalDefinition temp = EmitAddress(right, flag ? Binder.AddressKind.ReadOnlyStrict : Binder.AddressKind.Writeable);
|
||
|
|
AddExpressionTemp(temp);
|
||
|
|
int num2 = _expressionTemps?.Count ?? 0;
|
||
|
|
if (left.Kind == BoundKind.Local && SynthesizedLocalKindExtensions.IsLongLived(((BoundLocal)left).LocalSymbol.SynthesizedKind) && num2 > num)
|
||
|
|
{
|
||
|
|
_expressionTemps.Count = num;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition EmitAssignmentDuplication(BoundAssignmentOperator assignmentOperator, UseKind useKind, bool lhsUsesStack)
|
||
|
|
{
|
||
|
|
LocalDefinition val = null;
|
||
|
|
if (useKind != UseKind.Unused)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
if (lhsUsesStack)
|
||
|
|
{
|
||
|
|
val = AllocateTemp(assignmentOperator.Left.Type, assignmentOperator.Left.Syntax, (LocalSlotConstraints)(assignmentOperator.IsRef ? 1 : 0));
|
||
|
|
_builder.EmitLocalStore(val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStore(BoundAssignmentOperator assignment)
|
||
|
|
{
|
||
|
|
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
BoundExpression left = assignment.Left;
|
||
|
|
switch (left.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
EmitFieldStore((BoundFieldAccess)left, assignment.IsRef);
|
||
|
|
return;
|
||
|
|
case BoundKind.Local:
|
||
|
|
{
|
||
|
|
BoundLocal boundLocal = (BoundLocal)left;
|
||
|
|
if ((int)boundLocal.LocalSymbol.RefKind != 0 && !assignment.IsRef)
|
||
|
|
{
|
||
|
|
EmitIndirectStore(boundLocal.LocalSymbol.Type, boundLocal.Syntax);
|
||
|
|
}
|
||
|
|
else if (!IsStackLocal(boundLocal.LocalSymbol))
|
||
|
|
{
|
||
|
|
_builder.EmitLocalStore(GetLocal(boundLocal));
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
case BoundKind.ArrayAccess:
|
||
|
|
{
|
||
|
|
ArrayTypeSymbol arrayType = (ArrayTypeSymbol)((BoundArrayAccess)left).Expression.Type;
|
||
|
|
EmitArrayElementStore(arrayType, left.Syntax);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
case BoundKind.ThisReference:
|
||
|
|
EmitThisStore((BoundThisReference)left);
|
||
|
|
return;
|
||
|
|
case BoundKind.Parameter:
|
||
|
|
EmitParameterStore((BoundParameter)left, assignment.IsRef);
|
||
|
|
return;
|
||
|
|
case BoundKind.Dup:
|
||
|
|
EmitIndirectStore(left.Type, left.Syntax);
|
||
|
|
return;
|
||
|
|
case BoundKind.ConditionalOperator:
|
||
|
|
EmitIndirectStore(left.Type, left.Syntax);
|
||
|
|
return;
|
||
|
|
case BoundKind.PointerIndirectionOperator:
|
||
|
|
case BoundKind.RefValueOperator:
|
||
|
|
case BoundKind.PseudoVariable:
|
||
|
|
EmitIndirectStore(left.Type, left.Syntax);
|
||
|
|
return;
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
{
|
||
|
|
BoundSequence boundSequence = (BoundSequence)left;
|
||
|
|
EmitStore(assignment.Update(boundSequence.Value, assignment.Right, assignment.IsRef, assignment.Type));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
case BoundKind.Call:
|
||
|
|
EmitIndirectStore(left.Type, left.Syntax);
|
||
|
|
return;
|
||
|
|
case BoundKind.FunctionPointerInvocation:
|
||
|
|
EmitIndirectStore(left.Type, left.Syntax);
|
||
|
|
return;
|
||
|
|
case BoundKind.ModuleVersionId:
|
||
|
|
EmitModuleVersionIdStore((BoundModuleVersionId)left);
|
||
|
|
return;
|
||
|
|
case BoundKind.InstrumentationPayloadRoot:
|
||
|
|
EmitInstrumentationPayloadRootStore((BoundInstrumentationPayloadRoot)left);
|
||
|
|
return;
|
||
|
|
case BoundKind.AssignmentOperator:
|
||
|
|
{
|
||
|
|
BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)left;
|
||
|
|
if (boundAssignmentOperator.IsRef)
|
||
|
|
{
|
||
|
|
EmitIndirectStore(boundAssignmentOperator.Type, left.Syntax);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)left.Kind);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitAssignmentPostfix(BoundAssignmentOperator assignment, LocalDefinition temp, UseKind useKind)
|
||
|
|
{
|
||
|
|
if (temp != null)
|
||
|
|
{
|
||
|
|
if (useKind == UseKind.UsedAsAddress)
|
||
|
|
{
|
||
|
|
_builder.EmitLocalAddress(temp);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitLocalLoad(temp);
|
||
|
|
}
|
||
|
|
FreeTemp(temp);
|
||
|
|
}
|
||
|
|
if (useKind == UseKind.UsedAsValue && assignment.IsRef)
|
||
|
|
{
|
||
|
|
EmitLoadIndirect(assignment.Type, assignment.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitThisStore(BoundThisReference thisRef)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stobj);
|
||
|
|
EmitSymbolToken(thisRef.Type, thisRef.Syntax);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitArrayElementStore(ArrayTypeSymbol arrayType, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
if (arrayType.IsSZArray)
|
||
|
|
{
|
||
|
|
EmitVectorElementStore(arrayType, syntaxNode);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitArrayElementStore(_module.Translate(arrayType), syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitVectorElementStore(ArrayTypeSymbol arrayType, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0078: Expected I4, but got Unknown
|
||
|
|
TypeSymbol typeSymbol = arrayType.ElementType;
|
||
|
|
if (typeSymbol.IsEnumType())
|
||
|
|
{
|
||
|
|
typeSymbol = ((NamedTypeSymbol)typeSymbol).EnumUnderlyingType;
|
||
|
|
}
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = typeSymbol.PrimitiveTypeCode;
|
||
|
|
switch ((int)primitiveTypeCode)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
case 2:
|
||
|
|
case 12:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem_i1);
|
||
|
|
return;
|
||
|
|
case 1:
|
||
|
|
case 5:
|
||
|
|
case 13:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem_i2);
|
||
|
|
return;
|
||
|
|
case 6:
|
||
|
|
case 14:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem_i4);
|
||
|
|
return;
|
||
|
|
case 7:
|
||
|
|
case 15:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem_i8);
|
||
|
|
return;
|
||
|
|
case 8:
|
||
|
|
case 9:
|
||
|
|
case 16:
|
||
|
|
case 19:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem_i);
|
||
|
|
return;
|
||
|
|
case 3:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem_r4);
|
||
|
|
return;
|
||
|
|
case 4:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem_r8);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (typeSymbol.IsVerifierReference())
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem_ref);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stelem);
|
||
|
|
EmitSymbolToken(typeSymbol, syntaxNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitFieldStore(BoundFieldAccess fieldAccess, bool refAssign)
|
||
|
|
{
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
FieldSymbol fieldSymbol = fieldAccess.FieldSymbol;
|
||
|
|
if (fieldSymbol.IsVolatile)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Volatile);
|
||
|
|
}
|
||
|
|
if ((int)fieldSymbol.RefKind != 0 && !refAssign)
|
||
|
|
{
|
||
|
|
EmitIndirectStore(fieldSymbol.Type, fieldAccess.Syntax);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(fieldSymbol.IsStatic ? ILOpCode.Stsfld : ILOpCode.Stfld);
|
||
|
|
EmitSymbolToken(fieldSymbol, fieldAccess.Syntax);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitParameterStore(BoundParameter parameter, bool refAssign)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if ((int)parameter.ParameterSymbol.RefKind != 0 && !refAssign)
|
||
|
|
{
|
||
|
|
EmitIndirectStore(parameter.ParameterSymbol.Type, parameter.Syntax);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int num = ParameterSlot(parameter);
|
||
|
|
_builder.EmitStoreArgumentOpcode(num);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitIndirectStore(TypeSymbol type, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0072: Expected I4, but got Unknown
|
||
|
|
if (type.IsEnumType())
|
||
|
|
{
|
||
|
|
type = ((NamedTypeSymbol)type).EnumUnderlyingType;
|
||
|
|
}
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = type.PrimitiveTypeCode;
|
||
|
|
switch ((int)primitiveTypeCode)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
case 2:
|
||
|
|
case 12:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stind_i1);
|
||
|
|
return;
|
||
|
|
case 1:
|
||
|
|
case 5:
|
||
|
|
case 13:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stind_i2);
|
||
|
|
return;
|
||
|
|
case 6:
|
||
|
|
case 14:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stind_i4);
|
||
|
|
return;
|
||
|
|
case 7:
|
||
|
|
case 15:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stind_i8);
|
||
|
|
return;
|
||
|
|
case 8:
|
||
|
|
case 9:
|
||
|
|
case 16:
|
||
|
|
case 19:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stind_i);
|
||
|
|
return;
|
||
|
|
case 3:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stind_r4);
|
||
|
|
return;
|
||
|
|
case 4:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stind_r8);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stind_ref);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stobj);
|
||
|
|
EmitSymbolToken(type, syntaxNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitPopIfUnused(bool used)
|
||
|
|
{
|
||
|
|
if (!used)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Pop);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitIsExpression(BoundIsOperator isOp, bool used, bool omitBooleanConversion)
|
||
|
|
{
|
||
|
|
BoundExpression operand = isOp.Operand;
|
||
|
|
EmitExpression(operand, used);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
if (!operand.Type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(operand.Type, operand.Syntax);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Isinst);
|
||
|
|
EmitSymbolToken(isOp.TargetType.Type, isOp.Syntax);
|
||
|
|
if (!omitBooleanConversion)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldnull);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Cgt_un);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitAsExpression(BoundAsOperator asOp, bool used)
|
||
|
|
{
|
||
|
|
BoundExpression operand = asOp.Operand;
|
||
|
|
EmitExpression(operand, used);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
TypeSymbol type = operand.Type;
|
||
|
|
TypeSymbol type2 = asOp.Type;
|
||
|
|
if ((object)type != null && !type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(type, operand.Syntax);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Isinst);
|
||
|
|
EmitSymbolToken(type2, asOp.Syntax);
|
||
|
|
if (!type2.IsVerifierReference())
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Unbox_any);
|
||
|
|
EmitSymbolToken(type2, asOp.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitDefaultValue(TypeSymbol type, bool used, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Invalid comparison between Unknown and I4
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0045: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006d: Invalid comparison between Unknown and I4
|
||
|
|
if (!used)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!type.IsTypeParameter() && (int)type.SpecialType != 17)
|
||
|
|
{
|
||
|
|
ConstantValue defaultValue = type.GetDefaultValue();
|
||
|
|
if (defaultValue != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
_builder.EmitConstantValue(defaultValue);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (type.IsPointerOrFunctionPointer() || (int)type.SpecialType == 22)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldc_i4_0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_u);
|
||
|
|
}
|
||
|
|
else if ((int)type.SpecialType == 21)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldc_i4_0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_i);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitInitObj(type, used: true, syntaxNode);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitDefaultExpression(BoundDefaultExpression expression, bool used)
|
||
|
|
{
|
||
|
|
EmitDefaultValue(expression.Type, used, expression.Syntax);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConstantExpression(TypeSymbol type, ConstantValue constantValue, bool used, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: Invalid comparison between Unknown and I4
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
if ((object)type != null && (int)type.TypeKind == 11 && constantValue.IsNull)
|
||
|
|
{
|
||
|
|
EmitInitObj(type, used, syntaxNode);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitConstantValue(constantValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitInitObj(TypeSymbol type, bool used, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
LocalDefinition val = AllocateTemp(type, syntaxNode, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalAddress(val);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Initobj);
|
||
|
|
EmitSymbolToken(type, syntaxNode);
|
||
|
|
_builder.EmitLocalLoad(val);
|
||
|
|
FreeTemp(val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitGetTypeFromHandle(BoundTypeOf boundTypeOf)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
MethodSymbol getTypeFromHandle = boundTypeOf.GetTypeFromHandle;
|
||
|
|
EmitSymbolToken(getTypeFromHandle, boundTypeOf.Syntax, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitTypeOfExpression(BoundTypeOfOperator boundTypeOfOperator)
|
||
|
|
{
|
||
|
|
TypeSymbol type = boundTypeOfOperator.SourceType.Type;
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
EmitSymbolToken(type, boundTypeOfOperator.SourceType.Syntax);
|
||
|
|
EmitGetTypeFromHandle(boundTypeOfOperator);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSizeOfExpression(BoundSizeOfOperator boundSizeOfOperator)
|
||
|
|
{
|
||
|
|
TypeSymbol type = boundSizeOfOperator.SourceType.Type;
|
||
|
|
_builder.EmitOpCode(ILOpCode.Sizeof);
|
||
|
|
EmitSymbolToken(type, boundSizeOfOperator.SourceType.Syntax);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitMethodDefIndexExpression(BoundMethodDefIndex node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
MethodSymbol method = node.Method.PartialDefinitionPart ?? node.Method;
|
||
|
|
EmitSymbolToken(method, node.Syntax, null, encodeAsRawDefinitionToken: true);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitLocalIdExpression(BoundLocalId node)
|
||
|
|
{
|
||
|
|
if ((object)node.HoistedField == null)
|
||
|
|
{
|
||
|
|
_builder.EmitIntConstant(GetLocal(node.Local).SlotIndex);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitHoistedVariableId(node.HoistedField, node.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitParameterIdExpression(BoundParameterId node)
|
||
|
|
{
|
||
|
|
if ((object)node.HoistedField == null)
|
||
|
|
{
|
||
|
|
_builder.EmitIntConstant(node.Parameter.Ordinal);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitHoistedVariableId(node.HoistedField, node.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitHoistedVariableId(FieldSymbol field, SyntaxNode syntax)
|
||
|
|
{
|
||
|
|
IFieldReference val = _module.Translate(field, syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, needDeclaration: true);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
_builder.EmitToken((IReference)(object)val, syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)4);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitMaximumMethodDefIndexExpression(BoundMaximumMethodDefIndex node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
_builder.EmitGreatestMethodToken();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitModuleVersionIdLoad(BoundModuleVersionId node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldsfld);
|
||
|
|
EmitModuleVersionIdToken(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitModuleVersionIdStore(BoundModuleVersionId node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stsfld);
|
||
|
|
EmitModuleVersionIdToken(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitModuleVersionIdToken(BoundModuleVersionId node)
|
||
|
|
{
|
||
|
|
_builder.EmitToken((IReference)(object)((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).GetModuleVersionId(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(node.Type, node.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag), node.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag), node.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitModuleVersionIdStringLoad()
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldstr);
|
||
|
|
_builder.EmitModuleVersionIdStringToken();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitInstrumentationPayloadRootLoad(BoundInstrumentationPayloadRoot node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldsfld);
|
||
|
|
EmitInstrumentationPayloadRootToken(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitInstrumentationPayloadRootStore(BoundInstrumentationPayloadRoot node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Stsfld);
|
||
|
|
EmitInstrumentationPayloadRootToken(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitInstrumentationPayloadRootToken(BoundInstrumentationPayloadRoot node)
|
||
|
|
{
|
||
|
|
_builder.EmitToken((IReference)(object)((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).GetInstrumentationPayloadRoot(node.AnalysisKind, ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(node.Type, node.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag), node.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag), node.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSourceDocumentIndex(BoundSourceDocumentIndex node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
_builder.EmitSourceDocumentIndexToken(node.Document);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitMethodInfoExpression(BoundMethodInfo node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
EmitSymbolToken(node.Method, node.Syntax, null);
|
||
|
|
MethodSymbol getMethodFromHandle = node.GetMethodFromHandle;
|
||
|
|
if (getMethodFromHandle.ParameterCount == 1)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
EmitSymbolToken(node.Method.ContainingType, node.Syntax);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, -1);
|
||
|
|
}
|
||
|
|
EmitSymbolToken(getMethodFromHandle, node.Syntax, null);
|
||
|
|
if (!TypeSymbol.Equals(node.Type, getMethodFromHandle.ReturnType, (TypeCompareKind)0))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Castclass);
|
||
|
|
EmitSymbolToken(node.Type, node.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitFieldInfoExpression(BoundFieldInfo node)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
EmitSymbolToken(node.Field, node.Syntax);
|
||
|
|
MethodSymbol getFieldFromHandle = node.GetFieldFromHandle;
|
||
|
|
if (getFieldFromHandle.ParameterCount == 1)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldtoken);
|
||
|
|
EmitSymbolToken(node.Field.ContainingType, node.Syntax);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, -1);
|
||
|
|
}
|
||
|
|
EmitSymbolToken(getFieldFromHandle, node.Syntax, null);
|
||
|
|
if (!TypeSymbol.Equals(node.Type, getFieldFromHandle.ReturnType, (TypeCompareKind)0))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Castclass);
|
||
|
|
EmitSymbolToken(node.Type, node.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConditionalOperator(BoundConditionalOperator expr, bool used)
|
||
|
|
{
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (used && (int)_ilEmitStyle != 0 && (IsNumeric(expr.Type) || (int)expr.Type.PrimitiveTypeCode == 0) && hasIntegralValueZeroOrOne(expr.Consequence, out var isOne) && hasIntegralValueZeroOrOne(expr.Alternative, out var isOne2) && isOne != isOne2 && TryEmitComparison(expr.Condition, isOne))
|
||
|
|
{
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = expr.Type.PrimitiveTypeCode;
|
||
|
|
if ((int)primitiveTypeCode != 0)
|
||
|
|
{
|
||
|
|
_builder.EmitNumericConversion((PrimitiveTypeCode)6, primitiveTypeCode, false);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
object dest = new object();
|
||
|
|
object obj = new object();
|
||
|
|
EmitCondBranch(expr.Condition, ref dest, sense: true);
|
||
|
|
EmitExpression(expr.Alternative, used);
|
||
|
|
TypeSymbol typeSymbol = StackMergeType(expr.Alternative);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
if (IsVarianceCast(expr.Type, typeSymbol))
|
||
|
|
{
|
||
|
|
EmitStaticCast(expr.Type, expr.Syntax);
|
||
|
|
typeSymbol = expr.Type;
|
||
|
|
}
|
||
|
|
else if (expr.Type.IsInterfaceType() && !TypeSymbol.Equals(expr.Type, typeSymbol, (TypeCompareKind)0))
|
||
|
|
{
|
||
|
|
EmitStaticCast(expr.Type, expr.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, obj, ILOpCode.Nop);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
_builder.AdjustStack(-1);
|
||
|
|
}
|
||
|
|
_builder.MarkLabel(dest);
|
||
|
|
EmitExpression(expr.Consequence, used);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
TypeSymbol typeSymbol2 = StackMergeType(expr.Consequence);
|
||
|
|
if (IsVarianceCast(expr.Type, typeSymbol2))
|
||
|
|
{
|
||
|
|
EmitStaticCast(expr.Type, expr.Syntax);
|
||
|
|
typeSymbol2 = expr.Type;
|
||
|
|
}
|
||
|
|
else if (expr.Type.IsInterfaceType() && !TypeSymbol.Equals(expr.Type, typeSymbol2, (TypeCompareKind)0))
|
||
|
|
{
|
||
|
|
EmitStaticCast(expr.Type, expr.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
static bool hasIntegralValueZeroOrOne(BoundExpression boundExpression, out bool reference)
|
||
|
|
{
|
||
|
|
ConstantValue constantValueOpt = boundExpression.ConstantValueOpt;
|
||
|
|
ulong uInt64Value = default(ulong);
|
||
|
|
bool flag;
|
||
|
|
if (constantValueOpt != null)
|
||
|
|
{
|
||
|
|
if (constantValueOpt != null && constantValueOpt.IsIntegral)
|
||
|
|
{
|
||
|
|
uInt64Value = constantValueOpt.UInt64Value;
|
||
|
|
if (uInt64Value <= 1)
|
||
|
|
{
|
||
|
|
flag = true;
|
||
|
|
goto IL_0029;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
flag = false;
|
||
|
|
goto IL_0029;
|
||
|
|
}
|
||
|
|
goto IL_007a;
|
||
|
|
IL_007a:
|
||
|
|
reference = false;
|
||
|
|
return false;
|
||
|
|
IL_0029:
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
reference = uInt64Value == 1;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (constantValueOpt != null && constantValueOpt.IsBoolean)
|
||
|
|
{
|
||
|
|
bool booleanValue = constantValueOpt.BooleanValue;
|
||
|
|
reference = booleanValue;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
char charValue = default(char);
|
||
|
|
if (constantValueOpt != null && constantValueOpt.IsChar)
|
||
|
|
{
|
||
|
|
charValue = constantValueOpt.CharValue;
|
||
|
|
if (charValue == '\0' || charValue == '\u0001')
|
||
|
|
{
|
||
|
|
flag = true;
|
||
|
|
goto IL_006e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
flag = false;
|
||
|
|
goto IL_006e;
|
||
|
|
IL_006e:
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
reference = charValue == '\u0001';
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
goto IL_007a;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitNullCoalescingOperator(BoundNullCoalescingOperator expr, bool used)
|
||
|
|
{
|
||
|
|
EmitExpression(expr.LeftOperand, used: true);
|
||
|
|
TypeSymbol typeSymbol = StackMergeType(expr.LeftOperand);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
if (IsVarianceCast(expr.Type, typeSymbol))
|
||
|
|
{
|
||
|
|
EmitStaticCast(expr.Type, expr.Syntax);
|
||
|
|
typeSymbol = expr.Type;
|
||
|
|
}
|
||
|
|
else if (expr.Type.IsInterfaceType() && !TypeSymbol.Equals(expr.Type, typeSymbol, (TypeCompareKind)0))
|
||
|
|
{
|
||
|
|
EmitStaticCast(expr.Type, expr.Syntax);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
}
|
||
|
|
if (expr.Type.IsTypeParameter())
|
||
|
|
{
|
||
|
|
EmitBox(expr.Type, expr.LeftOperand.Syntax);
|
||
|
|
}
|
||
|
|
object obj = new object();
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj, ILOpCode.Nop);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Pop);
|
||
|
|
}
|
||
|
|
EmitExpression(expr.RightOperand, used);
|
||
|
|
if (used)
|
||
|
|
{
|
||
|
|
TypeSymbol typeSymbol2 = StackMergeType(expr.RightOperand);
|
||
|
|
if (IsVarianceCast(expr.Type, typeSymbol2))
|
||
|
|
{
|
||
|
|
EmitStaticCast(expr.Type, expr.Syntax);
|
||
|
|
typeSymbol2 = expr.Type;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
private TypeSymbol StackMergeType(BoundExpression expr)
|
||
|
|
{
|
||
|
|
if (!expr.Type.IsInterfaceType() && !expr.Type.IsDelegateType())
|
||
|
|
{
|
||
|
|
return expr.Type;
|
||
|
|
}
|
||
|
|
switch (expr.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.Conversion:
|
||
|
|
{
|
||
|
|
BoundConversion boundConversion = (BoundConversion)expr;
|
||
|
|
ConversionKind conversionKind = boundConversion.ConversionKind;
|
||
|
|
if (conversionKind.IsImplicitConversion() && conversionKind != ConversionKind.MethodGroup && conversionKind != ConversionKind.NullLiteral && conversionKind != ConversionKind.DefaultLiteral)
|
||
|
|
{
|
||
|
|
return StackMergeType(boundConversion.Operand);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.AssignmentOperator:
|
||
|
|
{
|
||
|
|
BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)expr;
|
||
|
|
return StackMergeType(boundAssignmentOperator.Right);
|
||
|
|
}
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
{
|
||
|
|
BoundSequence boundSequence = (BoundSequence)expr;
|
||
|
|
return StackMergeType(boundSequence.Value);
|
||
|
|
}
|
||
|
|
case BoundKind.Local:
|
||
|
|
{
|
||
|
|
BoundLocal boundLocal = (BoundLocal)expr;
|
||
|
|
if (IsStackLocal(boundLocal.LocalSymbol))
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.Dup:
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return expr.Type;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool IsVarianceCast(TypeSymbol to, TypeSymbol from)
|
||
|
|
{
|
||
|
|
if (TypeSymbol.Equals(to, from, (TypeCompareKind)0))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if ((object)from == null)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (to.IsArray())
|
||
|
|
{
|
||
|
|
return IsVarianceCast(((ArrayTypeSymbol)to).ElementType, ((ArrayTypeSymbol)from).ElementType);
|
||
|
|
}
|
||
|
|
if (!to.IsDelegateType() || TypeSymbol.Equals(to, from, (TypeCompareKind)0))
|
||
|
|
{
|
||
|
|
if (to.IsInterfaceType() && from.IsInterfaceType())
|
||
|
|
{
|
||
|
|
return !from.InterfacesAndTheirBaseInterfacesNoUseSiteDiagnostics.ContainsKey((NamedTypeSymbol)to);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStaticCast(TypeSymbol to, SyntaxNode syntax)
|
||
|
|
{
|
||
|
|
LocalDefinition val = AllocateTemp(to, syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(val);
|
||
|
|
_builder.EmitLocalLoad(val);
|
||
|
|
FreeTemp(val);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBox(TypeSymbol type, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Box);
|
||
|
|
EmitSymbolToken(type, syntaxNode);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCalli(BoundFunctionPointerInvocation ptrInvocation, UseKind useKind)
|
||
|
|
{
|
||
|
|
EmitExpression(ptrInvocation.InvokedExpression, used: true);
|
||
|
|
LocalDefinition val = null;
|
||
|
|
if (ptrInvocation.Arguments.Length > 0)
|
||
|
|
{
|
||
|
|
val = AllocateTemp(ptrInvocation.InvokedExpression.Type, ptrInvocation.Syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(val);
|
||
|
|
}
|
||
|
|
FunctionPointerMethodSymbol signature = ptrInvocation.FunctionPointer.Signature;
|
||
|
|
EmitArguments(ptrInvocation.Arguments, signature.Parameters, ptrInvocation.ArgumentRefKindsOpt);
|
||
|
|
int callStackBehavior = GetCallStackBehavior(ptrInvocation.FunctionPointer.Signature, ptrInvocation.Arguments);
|
||
|
|
if (val != null)
|
||
|
|
{
|
||
|
|
_builder.EmitLocalLoad(val);
|
||
|
|
FreeTemp(val);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Calli, callStackBehavior);
|
||
|
|
EmitSignatureToken(ptrInvocation.FunctionPointer, ptrInvocation.Syntax);
|
||
|
|
EmitCallCleanup(ptrInvocation.Syntax, useKind, signature);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCallCleanup(SyntaxNode syntax, UseKind useKind, MethodSymbol method)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!method.ReturnsVoid)
|
||
|
|
{
|
||
|
|
EmitPopIfUnused(useKind != UseKind.Unused);
|
||
|
|
}
|
||
|
|
else if ((int)_ilEmitStyle == 0)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
if (useKind == UseKind.UsedAsValue && (int)method.RefKind != 0)
|
||
|
|
{
|
||
|
|
EmitLoadIndirect(method.ReturnType, syntax);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_ = 2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitLoadFunction(BoundFunctionPointerLoad load, bool used)
|
||
|
|
{
|
||
|
|
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003f: Invalid comparison between Unknown and I4
|
||
|
|
if (!used)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if ((load.TargetMethod.IsAbstract || load.TargetMethod.IsVirtual) && load.TargetMethod.IsStatic)
|
||
|
|
{
|
||
|
|
TypeSymbol constrainedToTypeOpt = load.ConstrainedToTypeOpt;
|
||
|
|
if ((object)constrainedToTypeOpt == null || (int)constrainedToTypeOpt.TypeKind != 11)
|
||
|
|
{
|
||
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs", 4073);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Constrained);
|
||
|
|
EmitSymbolToken(load.ConstrainedToTypeOpt, load.Syntax);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldftn);
|
||
|
|
EmitSymbolToken(load.TargetMethod, load.Syntax, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitUnaryOperatorExpression(BoundUnaryOperator expression, bool used)
|
||
|
|
{
|
||
|
|
UnaryOperatorKind operatorKind = expression.OperatorKind;
|
||
|
|
if (operatorKind.IsChecked())
|
||
|
|
{
|
||
|
|
EmitUnaryCheckedOperatorExpression(expression, used);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!used)
|
||
|
|
{
|
||
|
|
EmitExpression(expression.Operand, used: false);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (operatorKind == UnaryOperatorKind.BoolLogicalNegation)
|
||
|
|
{
|
||
|
|
EmitCondExpr(expression.Operand, sense: false);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
EmitExpression(expression.Operand, used: true);
|
||
|
|
switch (operatorKind.Operator())
|
||
|
|
{
|
||
|
|
case UnaryOperatorKind.UnaryMinus:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Neg);
|
||
|
|
break;
|
||
|
|
case UnaryOperatorKind.BitwiseComplement:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Not);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)operatorKind.Operator());
|
||
|
|
case UnaryOperatorKind.UnaryPlus:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBinaryOperatorExpression(BoundBinaryOperator expression, bool used)
|
||
|
|
{
|
||
|
|
BinaryOperatorKind operatorKind = expression.OperatorKind;
|
||
|
|
if (operatorKind.EmitsAsCheckedInstruction())
|
||
|
|
{
|
||
|
|
EmitBinaryOperator(expression);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!used && !operatorKind.IsLogical() && !OperatorHasSideEffects(operatorKind))
|
||
|
|
{
|
||
|
|
EmitExpression(expression.Left, used: false);
|
||
|
|
EmitExpression(expression.Right, used: false);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (IsConditional(operatorKind))
|
||
|
|
{
|
||
|
|
EmitBinaryCondOperator(expression, sense: true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitBinaryOperator(expression);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBinaryOperator(BoundBinaryOperator expression)
|
||
|
|
{
|
||
|
|
BoundExpression left = expression.Left;
|
||
|
|
if (left.Kind != BoundKind.BinaryOperator || left.ConstantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
EmitBinaryOperatorSimple(expression);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
BoundBinaryOperator boundBinaryOperator = (BoundBinaryOperator)left;
|
||
|
|
BinaryOperatorKind operatorKind = boundBinaryOperator.OperatorKind;
|
||
|
|
if (!operatorKind.EmitsAsCheckedInstruction() && IsConditional(operatorKind))
|
||
|
|
{
|
||
|
|
EmitBinaryOperatorSimple(expression);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ArrayBuilder<BoundBinaryOperator> instance = ArrayBuilder<BoundBinaryOperator>.GetInstance();
|
||
|
|
ArrayBuilderExtensions.Push<BoundBinaryOperator>(instance, expression);
|
||
|
|
do
|
||
|
|
{
|
||
|
|
ArrayBuilderExtensions.Push<BoundBinaryOperator>(instance, boundBinaryOperator);
|
||
|
|
left = boundBinaryOperator.Left;
|
||
|
|
if (left.Kind != BoundKind.BinaryOperator || left.ConstantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
boundBinaryOperator = (BoundBinaryOperator)left;
|
||
|
|
operatorKind = boundBinaryOperator.OperatorKind;
|
||
|
|
}
|
||
|
|
while (operatorKind.EmitsAsCheckedInstruction() || !IsConditional(operatorKind));
|
||
|
|
EmitExpression(left, used: true);
|
||
|
|
do
|
||
|
|
{
|
||
|
|
boundBinaryOperator = ArrayBuilderExtensions.Pop<BoundBinaryOperator>(instance);
|
||
|
|
EmitExpression(boundBinaryOperator.Right, used: true);
|
||
|
|
bool flag = boundBinaryOperator.OperatorKind.EmitsAsCheckedInstruction();
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
EmitBinaryCheckedOperatorInstruction(boundBinaryOperator);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitBinaryOperatorInstruction(boundBinaryOperator);
|
||
|
|
}
|
||
|
|
EmitConversionToEnumUnderlyingType(boundBinaryOperator, flag);
|
||
|
|
}
|
||
|
|
while (instance.Count > 0);
|
||
|
|
instance.Free();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBinaryOperatorSimple(BoundBinaryOperator expression)
|
||
|
|
{
|
||
|
|
EmitExpression(expression.Left, used: true);
|
||
|
|
EmitExpression(expression.Right, used: true);
|
||
|
|
bool flag = expression.OperatorKind.EmitsAsCheckedInstruction();
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
EmitBinaryCheckedOperatorInstruction(expression);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitBinaryOperatorInstruction(expression);
|
||
|
|
}
|
||
|
|
EmitConversionToEnumUnderlyingType(expression, flag);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBinaryOperatorInstruction(BoundBinaryOperator expression)
|
||
|
|
{
|
||
|
|
switch (expression.OperatorKind.Operator())
|
||
|
|
{
|
||
|
|
case BinaryOperatorKind.Multiplication:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Mul);
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.Addition:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Add);
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.Subtraction:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Sub);
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.Division:
|
||
|
|
if (IsUnsignedBinaryOperator(expression))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Div_un);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Div);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.Remainder:
|
||
|
|
if (IsUnsignedBinaryOperator(expression))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Rem_un);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Rem);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.LeftShift:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Shl);
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.RightShift:
|
||
|
|
if (IsUnsignedBinaryOperator(expression))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Shr_un);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Shr);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.UnsignedRightShift:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Shr_un);
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.And:
|
||
|
|
_builder.EmitOpCode(ILOpCode.And);
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.Xor:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Xor);
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.Or:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Or);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)expression.OperatorKind.Operator());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitShortCircuitingOperator(BoundBinaryOperator condition, bool sense, bool stopSense, bool stopValue)
|
||
|
|
{
|
||
|
|
object dest = null;
|
||
|
|
EmitCondBranch(condition.Left, ref dest, stopSense);
|
||
|
|
EmitCondExpr(condition.Right, sense);
|
||
|
|
if (dest != null)
|
||
|
|
{
|
||
|
|
object obj = new object();
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, obj, ILOpCode.Nop);
|
||
|
|
_builder.AdjustStack(-1);
|
||
|
|
_builder.MarkLabel(dest);
|
||
|
|
_builder.EmitBoolConstant(stopValue);
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBinaryCondOperator(BoundBinaryOperator binOp, bool sense)
|
||
|
|
{
|
||
|
|
bool flag = sense;
|
||
|
|
BinaryOperatorKind binaryOperatorKind = binOp.OperatorKind.OperatorWithLogical();
|
||
|
|
int num;
|
||
|
|
if (binaryOperatorKind <= BinaryOperatorKind.GreaterThanOrEqual)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind <= BinaryOperatorKind.NotEqual)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.Equal)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.NotEqual)
|
||
|
|
{
|
||
|
|
goto IL_01db;
|
||
|
|
}
|
||
|
|
sense = !sense;
|
||
|
|
}
|
||
|
|
ConstantValue constantValueOpt = binOp.Left.ConstantValueOpt;
|
||
|
|
BoundExpression boundExpression = binOp.Right;
|
||
|
|
if (constantValueOpt == (ConstantValue)null)
|
||
|
|
{
|
||
|
|
constantValueOpt = boundExpression.ConstantValueOpt;
|
||
|
|
boundExpression = binOp.Left;
|
||
|
|
}
|
||
|
|
if (constantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
if (constantValueOpt.IsDefaultValue)
|
||
|
|
{
|
||
|
|
if (!constantValueOpt.IsFloating)
|
||
|
|
{
|
||
|
|
if (sense)
|
||
|
|
{
|
||
|
|
EmitIsNullOrZero(boundExpression, constantValueOpt);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitIsNotNullOrZero(boundExpression, constantValueOpt);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (constantValueOpt.IsBoolean)
|
||
|
|
{
|
||
|
|
EmitExpression(boundExpression, used: true);
|
||
|
|
EmitIsSense(sense);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitBinaryCondOperatorHelper(ILOpCode.Ceq, binOp.Left, binOp.Right, sense);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.GreaterThan)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.LessThan)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.GreaterThanOrEqual)
|
||
|
|
{
|
||
|
|
goto IL_01db;
|
||
|
|
}
|
||
|
|
num = 3;
|
||
|
|
sense = !sense;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
num = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
num = 2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind > BinaryOperatorKind.Xor)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.Or)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.LogicalAnd)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.LogicalOr)
|
||
|
|
{
|
||
|
|
goto IL_01db;
|
||
|
|
}
|
||
|
|
flag = !flag;
|
||
|
|
}
|
||
|
|
if (!flag)
|
||
|
|
{
|
||
|
|
EmitShortCircuitingOperator(binOp, sense, sense, stopValue: true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitShortCircuitingOperator(binOp, sense, !sense, stopValue: false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitBinaryCondOperatorHelper(ILOpCode.Or, binOp.Left, binOp.Right, sense);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.LessThanOrEqual)
|
||
|
|
{
|
||
|
|
switch (binaryOperatorKind)
|
||
|
|
{
|
||
|
|
case BinaryOperatorKind.And:
|
||
|
|
EmitBinaryCondOperatorHelper(ILOpCode.And, binOp.Left, binOp.Right, sense);
|
||
|
|
return;
|
||
|
|
case BinaryOperatorKind.Xor:
|
||
|
|
if (sense)
|
||
|
|
{
|
||
|
|
EmitBinaryCondOperatorHelper(ILOpCode.Xor, binOp.Left, binOp.Right, sense: true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitBinaryCondOperatorHelper(ILOpCode.Ceq, binOp.Left, binOp.Right, sense: true);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
goto IL_01db;
|
||
|
|
}
|
||
|
|
num = 1;
|
||
|
|
sense = !sense;
|
||
|
|
}
|
||
|
|
if (IsUnsignedBinaryOperator(binOp))
|
||
|
|
{
|
||
|
|
num += 4;
|
||
|
|
}
|
||
|
|
else if (IsFloat(binOp.OperatorKind))
|
||
|
|
{
|
||
|
|
num += 8;
|
||
|
|
}
|
||
|
|
EmitBinaryCondOperatorHelper(s_compOpCodes[num], binOp.Left, binOp.Right, sense);
|
||
|
|
return;
|
||
|
|
IL_01db:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)binOp.OperatorKind.OperatorWithLogical());
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitIsNotNullOrZero(BoundExpression comparand, ConstantValue nullOrZero)
|
||
|
|
{
|
||
|
|
EmitExpression(comparand, used: true);
|
||
|
|
TypeSymbol type = comparand.Type;
|
||
|
|
if (type.IsReferenceType && !type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(type, comparand.Syntax);
|
||
|
|
}
|
||
|
|
_builder.EmitConstantValue(nullOrZero);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Cgt_un);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitIsNullOrZero(BoundExpression comparand, ConstantValue nullOrZero)
|
||
|
|
{
|
||
|
|
EmitExpression(comparand, used: true);
|
||
|
|
TypeSymbol type = comparand.Type;
|
||
|
|
if (type.IsReferenceType && !type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(type, comparand.Syntax);
|
||
|
|
}
|
||
|
|
_builder.EmitConstantValue(nullOrZero);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ceq);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBinaryCondOperatorHelper(ILOpCode opCode, BoundExpression left, BoundExpression right, bool sense)
|
||
|
|
{
|
||
|
|
EmitExpression(left, used: true);
|
||
|
|
EmitExpression(right, used: true);
|
||
|
|
_builder.EmitOpCode(opCode);
|
||
|
|
EmitIsSense(sense);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCondExpr(BoundExpression condition, bool sense)
|
||
|
|
{
|
||
|
|
RemoveNegation(ref condition, ref sense);
|
||
|
|
ConstantValue constantValueOpt = condition.ConstantValueOpt;
|
||
|
|
if (constantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
bool booleanValue = constantValueOpt.BooleanValue;
|
||
|
|
_builder.EmitBoolConstant(booleanValue == sense);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (condition.Kind == BoundKind.BinaryOperator)
|
||
|
|
{
|
||
|
|
BoundBinaryOperator boundBinaryOperator = (BoundBinaryOperator)condition;
|
||
|
|
if (IsConditional(boundBinaryOperator.OperatorKind))
|
||
|
|
{
|
||
|
|
EmitBinaryCondOperator(boundBinaryOperator, sense);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitExpression(condition, used: true);
|
||
|
|
EmitIsSense(sense);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool TryEmitComparison(BoundExpression condition, bool sense)
|
||
|
|
{
|
||
|
|
RemoveNegation(ref condition, ref sense);
|
||
|
|
ConstantValue constantValueOpt = condition.ConstantValueOpt;
|
||
|
|
if (constantValueOpt != null)
|
||
|
|
{
|
||
|
|
_builder.EmitBoolConstant(constantValueOpt.BooleanValue == sense);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (condition is BoundBinaryOperator boundBinaryOperator)
|
||
|
|
{
|
||
|
|
if (boundBinaryOperator.OperatorKind.IsComparison())
|
||
|
|
{
|
||
|
|
EmitBinaryCondOperator(boundBinaryOperator, sense);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (condition is BoundIsOperator isOp)
|
||
|
|
{
|
||
|
|
EmitIsExpression(isOp, used: true, omitBooleanConversion: true);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldnull);
|
||
|
|
_builder.EmitOpCode(sense ? ILOpCode.Cgt_un : ILOpCode.Ceq);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
EmitExpression(condition, used: true);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldc_i4_0);
|
||
|
|
_builder.EmitOpCode(sense ? ILOpCode.Cgt_un : ILOpCode.Ceq);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static void RemoveNegation(ref BoundExpression condition, ref bool sense)
|
||
|
|
{
|
||
|
|
while (condition is BoundUnaryOperator boundUnaryOperator)
|
||
|
|
{
|
||
|
|
condition = boundUnaryOperator.Operand;
|
||
|
|
sense = !sense;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitUnaryCheckedOperatorExpression(BoundUnaryOperator expression, bool used)
|
||
|
|
{
|
||
|
|
UnaryOperatorKind unaryOperatorKind = expression.OperatorKind.OperandTypes();
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldc_i4_0);
|
||
|
|
switch (unaryOperatorKind)
|
||
|
|
{
|
||
|
|
case UnaryOperatorKind.Long:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_i8);
|
||
|
|
break;
|
||
|
|
case UnaryOperatorKind.NInt:
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_i);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
EmitExpression(expression.Operand, used: true);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Sub_ovf);
|
||
|
|
EmitPopIfUnused(used);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConversionToEnumUnderlyingType(BoundBinaryOperator expression, bool @checked)
|
||
|
|
{
|
||
|
|
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b3: Expected I4, but got Unknown
|
||
|
|
TypeSymbol typeSymbol;
|
||
|
|
switch (expression.OperatorKind.Operator() | expression.OperatorKind.OperandTypes())
|
||
|
|
{
|
||
|
|
case BinaryOperatorKind.EnumAndUnderlyingAddition:
|
||
|
|
case BinaryOperatorKind.EnumSubtraction:
|
||
|
|
case BinaryOperatorKind.EnumAndUnderlyingSubtraction:
|
||
|
|
typeSymbol = expression.Left.Type;
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.EnumAnd:
|
||
|
|
case BinaryOperatorKind.EnumXor:
|
||
|
|
case BinaryOperatorKind.EnumOr:
|
||
|
|
typeSymbol = null;
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.UnderlyingAndEnumAddition:
|
||
|
|
case BinaryOperatorKind.UnderlyingAndEnumSubtraction:
|
||
|
|
typeSymbol = expression.Right.Type;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
typeSymbol = null;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if ((object)typeSymbol != null)
|
||
|
|
{
|
||
|
|
SpecialType specialType = typeSymbol.GetEnumUnderlyingType().SpecialType;
|
||
|
|
switch (specialType - 9)
|
||
|
|
{
|
||
|
|
case 1:
|
||
|
|
_builder.EmitNumericConversion((PrimitiveTypeCode)6, (PrimitiveTypeCode)12, @checked);
|
||
|
|
break;
|
||
|
|
case 0:
|
||
|
|
_builder.EmitNumericConversion((PrimitiveTypeCode)6, (PrimitiveTypeCode)2, @checked);
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
_builder.EmitNumericConversion((PrimitiveTypeCode)6, (PrimitiveTypeCode)5, @checked);
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
_builder.EmitNumericConversion((PrimitiveTypeCode)6, (PrimitiveTypeCode)13, @checked);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBinaryCheckedOperatorInstruction(BoundBinaryOperator expression)
|
||
|
|
{
|
||
|
|
bool flag = IsUnsignedBinaryOperator(expression);
|
||
|
|
switch (expression.OperatorKind.Operator())
|
||
|
|
{
|
||
|
|
case BinaryOperatorKind.Multiplication:
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Mul_ovf_un);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Mul_ovf);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.Addition:
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Add_ovf_un);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Add_ovf);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.Subtraction:
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Sub_ovf_un);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Sub_ovf);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)expression.OperatorKind.Operator());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool OperatorHasSideEffects(BinaryOperatorKind kind)
|
||
|
|
{
|
||
|
|
BinaryOperatorKind binaryOperatorKind = kind.Operator();
|
||
|
|
if (binaryOperatorKind == BinaryOperatorKind.Division || binaryOperatorKind == BinaryOperatorKind.Remainder)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return kind.IsChecked();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitIsSense(bool sense)
|
||
|
|
{
|
||
|
|
if (!sense)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldc_i4_0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ceq);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool IsUnsigned(SpecialType type)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0025: Expected I4, but got Unknown
|
||
|
|
switch (type - 10)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
case 2:
|
||
|
|
case 4:
|
||
|
|
case 6:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool IsUnsignedBinaryOperator(BoundBinaryOperator op)
|
||
|
|
{
|
||
|
|
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
switch (op.OperatorKind.OperandTypes())
|
||
|
|
{
|
||
|
|
case BinaryOperatorKind.Enum:
|
||
|
|
case BinaryOperatorKind.EnumAndUnderlying:
|
||
|
|
return IsUnsigned(Binder.GetEnumPromotedType(op.Left.Type.GetEnumUnderlyingType().SpecialType));
|
||
|
|
case BinaryOperatorKind.UnderlyingAndEnum:
|
||
|
|
return IsUnsigned(Binder.GetEnumPromotedType(op.Right.Type.GetEnumUnderlyingType().SpecialType));
|
||
|
|
case BinaryOperatorKind.UInt:
|
||
|
|
case BinaryOperatorKind.ULong:
|
||
|
|
case BinaryOperatorKind.NUInt:
|
||
|
|
case BinaryOperatorKind.Pointer:
|
||
|
|
case BinaryOperatorKind.PointerAndInt:
|
||
|
|
case BinaryOperatorKind.PointerAndUInt:
|
||
|
|
case BinaryOperatorKind.PointerAndLong:
|
||
|
|
case BinaryOperatorKind.PointerAndULong:
|
||
|
|
case BinaryOperatorKind.ULongAndPointer:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool IsConditional(BinaryOperatorKind opKind)
|
||
|
|
{
|
||
|
|
switch (opKind.OperatorWithLogical())
|
||
|
|
{
|
||
|
|
case BinaryOperatorKind.Equal:
|
||
|
|
case BinaryOperatorKind.NotEqual:
|
||
|
|
case BinaryOperatorKind.GreaterThan:
|
||
|
|
case BinaryOperatorKind.LessThan:
|
||
|
|
case BinaryOperatorKind.GreaterThanOrEqual:
|
||
|
|
case BinaryOperatorKind.LessThanOrEqual:
|
||
|
|
case BinaryOperatorKind.LogicalAnd:
|
||
|
|
case BinaryOperatorKind.LogicalOr:
|
||
|
|
return true;
|
||
|
|
case BinaryOperatorKind.And:
|
||
|
|
case BinaryOperatorKind.Xor:
|
||
|
|
case BinaryOperatorKind.Or:
|
||
|
|
return opKind.OperandTypes() == BinaryOperatorKind.Bool;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool IsFloat(BinaryOperatorKind opKind)
|
||
|
|
{
|
||
|
|
BinaryOperatorKind binaryOperatorKind = opKind.OperandTypes();
|
||
|
|
if ((uint)(binaryOperatorKind - 12) <= 1u)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStackAllocInitializers(TypeSymbol type, BoundArrayInitialization inits)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0008: Invalid comparison between Unknown and I4
|
||
|
|
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
TypeSymbol type2 = (((int)type.TypeKind == 9) ? ((PointerTypeSymbol)type).PointedAtTypeWithAnnotations : ((NamedTypeSymbol)type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0]).Type;
|
||
|
|
ImmutableArray<BoundExpression> initializers = inits.Initializers;
|
||
|
|
ArrayInitializerStyle arrayInitializerStyle = ShouldEmitBlockInitializerForStackAlloc(type2, initializers);
|
||
|
|
if (arrayInitializerStyle == ArrayInitializerStyle.Element)
|
||
|
|
{
|
||
|
|
EmitElementStackAllocInitializers(type2, initializers, includeConstants: true);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ImmutableArray<byte> data = GetRawData(initializers);
|
||
|
|
if (data.All((byte datum) => datum == data[0]))
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
_builder.EmitIntConstant((int)data[0]);
|
||
|
|
_builder.EmitIntConstant(data.Length);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Initblk, -3);
|
||
|
|
if (arrayInitializerStyle == ArrayInitializerStyle.Mixed)
|
||
|
|
{
|
||
|
|
EmitElementStackAllocInitializers(type2, initializers, includeConstants: false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (SpecialTypeExtensions.SizeInBytes(type2.EnumUnderlyingTypeOrSelf().SpecialType) == 1)
|
||
|
|
{
|
||
|
|
IFieldReference fieldForData = _builder.module.GetFieldForData(data, (ushort)1, inits.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldsflda);
|
||
|
|
_builder.EmitToken((IReference)(object)fieldForData, inits.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.EmitIntConstant(data.Length);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Cpblk, -3);
|
||
|
|
if (arrayInitializerStyle == ArrayInitializerStyle.Mixed)
|
||
|
|
{
|
||
|
|
EmitElementStackAllocInitializers(type2, initializers, includeConstants: false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitElementStackAllocInitializers(type2, initializers, includeConstants: true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private ArrayInitializerStyle ShouldEmitBlockInitializerForStackAlloc(TypeSymbol elementType, ImmutableArray<BoundExpression> inits)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (((CommonPEModuleBuilder)_module).IsEncDelta)
|
||
|
|
{
|
||
|
|
return ArrayInitializerStyle.Element;
|
||
|
|
}
|
||
|
|
if (SpecialTypeExtensions.IsBlittable(elementType.EnumUnderlyingTypeOrSelf().SpecialType))
|
||
|
|
{
|
||
|
|
int initCount = 0;
|
||
|
|
int constInits = 0;
|
||
|
|
StackAllocInitializerCount(inits, ref initCount, ref constInits);
|
||
|
|
if (initCount > 2)
|
||
|
|
{
|
||
|
|
if (initCount == constInits)
|
||
|
|
{
|
||
|
|
return ArrayInitializerStyle.Block;
|
||
|
|
}
|
||
|
|
int num = Math.Max(3, initCount / 3);
|
||
|
|
if (constInits >= num)
|
||
|
|
{
|
||
|
|
return ArrayInitializerStyle.Mixed;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return ArrayInitializerStyle.Element;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void StackAllocInitializerCount(ImmutableArray<BoundExpression> inits, ref int initCount, ref int constInits)
|
||
|
|
{
|
||
|
|
if (inits.Length == 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = inits.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundExpression current = enumerator.Current;
|
||
|
|
initCount++;
|
||
|
|
if (current.ConstantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
constInits++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitElementStackAllocInitializers(TypeSymbol elementType, ImmutableArray<BoundExpression> inits, bool includeConstants)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
int num = 0;
|
||
|
|
int elementTypeSizeInBytes = SpecialTypeExtensions.SizeInBytes(elementType.EnumUnderlyingTypeOrSelf().SpecialType);
|
||
|
|
ImmutableArray<BoundExpression>.Enumerator enumerator = inits.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundExpression current = enumerator.Current;
|
||
|
|
if (includeConstants || current.ConstantValueOpt == (ConstantValue)null)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
EmitPointerElementAccess(current, elementType, elementTypeSizeInBytes, num);
|
||
|
|
EmitExpression(current, used: true);
|
||
|
|
EmitIndirectStore(elementType, current.Syntax);
|
||
|
|
}
|
||
|
|
num++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitPointerElementAccess(BoundExpression init, TypeSymbol elementType, int elementTypeSizeInBytes, int index)
|
||
|
|
{
|
||
|
|
if (index != 0)
|
||
|
|
{
|
||
|
|
if (elementTypeSizeInBytes == 1)
|
||
|
|
{
|
||
|
|
_builder.EmitIntConstant(index);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Add);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (index == 1)
|
||
|
|
{
|
||
|
|
EmitIntConstantOrSizeOf(init, elementType, elementTypeSizeInBytes);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Add);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_builder.EmitIntConstant(index);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Conv_i);
|
||
|
|
EmitIntConstantOrSizeOf(init, elementType, elementTypeSizeInBytes);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Mul);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Add);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitIntConstantOrSizeOf(BoundExpression init, TypeSymbol elementType, int elementTypeSizeInBytes)
|
||
|
|
{
|
||
|
|
if (elementTypeSizeInBytes == 0)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Sizeof);
|
||
|
|
EmitSymbolToken(elementType, init.Syntax);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitIntConstant(elementTypeSizeInBytes);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStatement(BoundStatement statement)
|
||
|
|
{
|
||
|
|
switch (statement.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.Block:
|
||
|
|
EmitBlock((BoundBlock)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.Scope:
|
||
|
|
EmitScope((BoundScope)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.SequencePoint:
|
||
|
|
EmitSequencePointStatement((BoundSequencePoint)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.SequencePointWithSpan:
|
||
|
|
EmitSequencePointStatement((BoundSequencePointWithSpan)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.SavePreviousSequencePoint:
|
||
|
|
EmitSavePreviousSequencePoint((BoundSavePreviousSequencePoint)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.RestorePreviousSequencePoint:
|
||
|
|
EmitRestorePreviousSequencePoint((BoundRestorePreviousSequencePoint)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.StepThroughSequencePoint:
|
||
|
|
EmitStepThroughSequencePoint((BoundStepThroughSequencePoint)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.ExpressionStatement:
|
||
|
|
EmitExpression(((BoundExpressionStatement)statement).Expression, used: false);
|
||
|
|
break;
|
||
|
|
case BoundKind.StatementList:
|
||
|
|
EmitStatementList((BoundStatementList)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.ReturnStatement:
|
||
|
|
EmitReturnStatement((BoundReturnStatement)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.GotoStatement:
|
||
|
|
EmitGotoStatement((BoundGotoStatement)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.LabelStatement:
|
||
|
|
EmitLabelStatement((BoundLabelStatement)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.ConditionalGoto:
|
||
|
|
EmitConditionalGoto((BoundConditionalGoto)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.ThrowStatement:
|
||
|
|
EmitThrowStatement((BoundThrowStatement)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.TryStatement:
|
||
|
|
EmitTryStatement((BoundTryStatement)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.SwitchDispatch:
|
||
|
|
EmitSwitchDispatch((BoundSwitchDispatch)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.StateMachineScope:
|
||
|
|
EmitStateMachineScope((BoundStateMachineScope)statement);
|
||
|
|
break;
|
||
|
|
case BoundKind.NoOpStatement:
|
||
|
|
EmitNoOpStatement((BoundNoOpStatement)statement);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)statement.Kind);
|
||
|
|
}
|
||
|
|
ReleaseExpressionTemps();
|
||
|
|
}
|
||
|
|
|
||
|
|
private int EmitStatementAndCountInstructions(BoundStatement statement)
|
||
|
|
{
|
||
|
|
int instructionsEmitted = _builder.InstructionsEmitted;
|
||
|
|
EmitStatement(statement);
|
||
|
|
return _builder.InstructionsEmitted - instructionsEmitted;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStatementList(BoundStatementList list)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
for (int length = list.Statements.Length; i < length; i++)
|
||
|
|
{
|
||
|
|
EmitStatement(list.Statements[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitNoOpStatement(BoundNoOpStatement statement)
|
||
|
|
{
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
switch (statement.Flavor)
|
||
|
|
{
|
||
|
|
case NoOpStatementFlavor.Default:
|
||
|
|
if ((int)_ilEmitStyle == 0)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case NoOpStatementFlavor.AwaitYieldPoint:
|
||
|
|
if (_asyncYieldPoints == null)
|
||
|
|
{
|
||
|
|
_asyncYieldPoints = ArrayBuilder<int>.GetInstance();
|
||
|
|
_asyncResumePoints = ArrayBuilder<int>.GetInstance();
|
||
|
|
}
|
||
|
|
_asyncYieldPoints.Add(_builder.AllocateILMarker());
|
||
|
|
break;
|
||
|
|
case NoOpStatementFlavor.AwaitResumePoint:
|
||
|
|
_asyncResumePoints.Add(_builder.AllocateILMarker());
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)statement.Flavor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitThrowStatement(BoundThrowStatement node)
|
||
|
|
{
|
||
|
|
EmitThrow(node.ExpressionOpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitThrow(BoundExpression thrown)
|
||
|
|
{
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001d: Invalid comparison between Unknown and I4
|
||
|
|
if (thrown != null)
|
||
|
|
{
|
||
|
|
EmitExpression(thrown, used: true);
|
||
|
|
TypeSymbol type = thrown.Type;
|
||
|
|
if ((object)type != null && (int)type.TypeKind == 11)
|
||
|
|
{
|
||
|
|
EmitBox(type, thrown.Syntax);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_builder.EmitThrow(thrown == null);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitConditionalGoto(BoundConditionalGoto boundConditionalGoto)
|
||
|
|
{
|
||
|
|
object dest = boundConditionalGoto.Label;
|
||
|
|
EmitCondBranch(boundConditionalGoto.Condition, ref dest, boundConditionalGoto.JumpIfTrue);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool CanPassToBrfalse(TypeSymbol ts)
|
||
|
|
{
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Invalid comparison between Unknown and I4
|
||
|
|
if (ts.IsEnumType())
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
PrimitiveTypeCode primitiveTypeCode = ts.PrimitiveTypeCode;
|
||
|
|
if (primitiveTypeCode - 3 > 1)
|
||
|
|
{
|
||
|
|
if ((int)primitiveTypeCode == 18)
|
||
|
|
{
|
||
|
|
return ts.IsReferenceType;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static BoundExpression TryReduce(BoundBinaryOperator condition, ref bool sense)
|
||
|
|
{
|
||
|
|
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0076: Invalid comparison between Unknown and I4
|
||
|
|
BinaryOperatorKind binaryOperatorKind = condition.OperatorKind.Operator();
|
||
|
|
BoundExpression boundExpression = ((condition.Left.ConstantValueOpt != (ConstantValue)null) ? condition.Left : null);
|
||
|
|
BoundExpression boundExpression2;
|
||
|
|
if (boundExpression != null)
|
||
|
|
{
|
||
|
|
boundExpression2 = condition.Right;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
boundExpression = ((condition.Right.ConstantValueOpt != (ConstantValue)null) ? condition.Right : null);
|
||
|
|
if (boundExpression == null)
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
boundExpression2 = condition.Left;
|
||
|
|
}
|
||
|
|
TypeSymbol type = boundExpression2.Type;
|
||
|
|
if (!CanPassToBrfalse(type))
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
bool num = (int)type.PrimitiveTypeCode == 0;
|
||
|
|
bool isDefaultValue = boundExpression.ConstantValueOpt.IsDefaultValue;
|
||
|
|
if (!num && !isDefaultValue)
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (isDefaultValue)
|
||
|
|
{
|
||
|
|
sense = !sense;
|
||
|
|
}
|
||
|
|
if (binaryOperatorKind == BinaryOperatorKind.NotEqual)
|
||
|
|
{
|
||
|
|
sense = !sense;
|
||
|
|
}
|
||
|
|
return boundExpression2;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static ILOpCode CodeForJump(BoundBinaryOperator op, bool sense, out ILOpCode revOpCode)
|
||
|
|
{
|
||
|
|
int num;
|
||
|
|
switch (op.OperatorKind.Operator())
|
||
|
|
{
|
||
|
|
case BinaryOperatorKind.Equal:
|
||
|
|
revOpCode = ((!sense) ? ILOpCode.Beq : ILOpCode.Bne_un);
|
||
|
|
if (!sense)
|
||
|
|
{
|
||
|
|
return ILOpCode.Bne_un;
|
||
|
|
}
|
||
|
|
return ILOpCode.Beq;
|
||
|
|
case BinaryOperatorKind.NotEqual:
|
||
|
|
revOpCode = ((!sense) ? ILOpCode.Bne_un : ILOpCode.Beq);
|
||
|
|
if (!sense)
|
||
|
|
{
|
||
|
|
return ILOpCode.Beq;
|
||
|
|
}
|
||
|
|
return ILOpCode.Bne_un;
|
||
|
|
case BinaryOperatorKind.LessThan:
|
||
|
|
num = 0;
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.LessThanOrEqual:
|
||
|
|
num = 1;
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.GreaterThan:
|
||
|
|
num = 2;
|
||
|
|
break;
|
||
|
|
case BinaryOperatorKind.GreaterThanOrEqual:
|
||
|
|
num = 3;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)op.OperatorKind.Operator());
|
||
|
|
}
|
||
|
|
if (IsUnsignedBinaryOperator(op))
|
||
|
|
{
|
||
|
|
num += 8;
|
||
|
|
}
|
||
|
|
else if (IsFloat(op.OperatorKind))
|
||
|
|
{
|
||
|
|
num += 16;
|
||
|
|
}
|
||
|
|
int num2 = num;
|
||
|
|
if (!sense)
|
||
|
|
{
|
||
|
|
num += 4;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
num2 += 4;
|
||
|
|
}
|
||
|
|
revOpCode = s_condJumpOpCodes[num2];
|
||
|
|
return s_condJumpOpCodes[num];
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCondBranch(BoundExpression condition, ref object dest, bool sense)
|
||
|
|
{
|
||
|
|
_recursionDepth++;
|
||
|
|
if (_recursionDepth > 1)
|
||
|
|
{
|
||
|
|
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
|
||
|
|
EmitCondBranchCore(condition, ref dest, sense);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitCondBranchCoreWithStackGuard(condition, ref dest, sense);
|
||
|
|
}
|
||
|
|
_recursionDepth--;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCondBranchCoreWithStackGuard(BoundExpression condition, ref object dest, bool sense)
|
||
|
|
{
|
||
|
|
try
|
||
|
|
{
|
||
|
|
EmitCondBranchCore(condition, ref dest, sense);
|
||
|
|
}
|
||
|
|
catch (InsufficientExecutionStackException)
|
||
|
|
{
|
||
|
|
_diagnostics.Add(ErrorCode.ERR_InsufficientStack, BoundTreeVisitor.CancelledByStackGuardException.GetTooLongOrComplexExpressionErrorLocation(condition));
|
||
|
|
throw new EmitCancelledException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCondBranchCore(BoundExpression condition, ref object dest, bool sense)
|
||
|
|
{
|
||
|
|
BoundBinaryOperator boundBinaryOperator2 = default(BoundBinaryOperator);
|
||
|
|
ILOpCode iLOpCode;
|
||
|
|
while (true)
|
||
|
|
{
|
||
|
|
if (condition.ConstantValueOpt != (ConstantValue)null)
|
||
|
|
{
|
||
|
|
if (condition.ConstantValueOpt.IsDefaultValue != sense)
|
||
|
|
{
|
||
|
|
dest = dest ?? new object();
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, dest, ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
switch (condition.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.BinaryOperator:
|
||
|
|
{
|
||
|
|
BoundBinaryOperator boundBinaryOperator = (BoundBinaryOperator)condition;
|
||
|
|
BinaryOperatorKind binaryOperatorKind = boundBinaryOperator.OperatorKind.OperatorWithLogical();
|
||
|
|
if ((binaryOperatorKind == BinaryOperatorKind.LogicalAnd || binaryOperatorKind == BinaryOperatorKind.LogicalOr) ? true : false)
|
||
|
|
{
|
||
|
|
ArrayBuilder<(BoundExpression, StrongBox<object>, bool)> instance = ArrayBuilder<(BoundExpression, StrongBox<object>, bool)>.GetInstance();
|
||
|
|
StrongBox<object> strongBox = new StrongBox<object>(dest);
|
||
|
|
ArrayBuilderExtensions.Push<(BoundExpression, StrongBox<object>, bool)>(instance, ((BoundExpression)boundBinaryOperator, strongBox, sense));
|
||
|
|
(BoundExpression, StrongBox<object>, bool) tuple;
|
||
|
|
while (true)
|
||
|
|
{
|
||
|
|
tuple = ArrayBuilderExtensions.Pop<(BoundExpression, StrongBox<object>, bool)>(instance);
|
||
|
|
if (tuple.Item1 == null)
|
||
|
|
{
|
||
|
|
object value = tuple.Item2.Value;
|
||
|
|
if (value != null)
|
||
|
|
{
|
||
|
|
_builder.MarkLabel(value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int num;
|
||
|
|
if (tuple.Item1.ConstantValueOpt == null)
|
||
|
|
{
|
||
|
|
boundBinaryOperator2 = tuple.Item1 as BoundBinaryOperator;
|
||
|
|
num = ((boundBinaryOperator2 != null) ? 1 : 0);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
num = 0;
|
||
|
|
}
|
||
|
|
bool flag = (byte)num != 0;
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
binaryOperatorKind = boundBinaryOperator2.OperatorKind.OperatorWithLogical();
|
||
|
|
bool flag2 = ((binaryOperatorKind == BinaryOperatorKind.LogicalAnd || binaryOperatorKind == BinaryOperatorKind.LogicalOr) ? true : false);
|
||
|
|
flag = flag2;
|
||
|
|
}
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
if ((boundBinaryOperator2.OperatorKind.OperatorWithLogical() == BinaryOperatorKind.LogicalOr) ? (!tuple.Item3) : tuple.Item3)
|
||
|
|
{
|
||
|
|
StrongBox<object> item = new StrongBox<object>();
|
||
|
|
ArrayBuilderExtensions.Push<(BoundExpression, StrongBox<object>, bool)>(instance, ((BoundExpression)null, item, true));
|
||
|
|
ArrayBuilderExtensions.Push<(BoundExpression, StrongBox<object>, bool)>(instance, (boundBinaryOperator2.Right, tuple.Item2, tuple.Item3));
|
||
|
|
ArrayBuilderExtensions.Push<(BoundExpression, StrongBox<object>, bool)>(instance, (boundBinaryOperator2.Left, item, !tuple.Item3));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ArrayBuilderExtensions.Push<(BoundExpression, StrongBox<object>, bool)>(instance, (boundBinaryOperator2.Right, tuple.Item2, tuple.Item3));
|
||
|
|
ArrayBuilderExtensions.Push<(BoundExpression, StrongBox<object>, bool)>(instance, (boundBinaryOperator2.Left, tuple.Item2, tuple.Item3));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (instance.Count == 0 && strongBox == tuple.Item2)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
EmitCondBranch(tuple.Item1, ref tuple.Item2.Value, tuple.Item3);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (instance.Count == 0)
|
||
|
|
{
|
||
|
|
dest = strongBox.Value;
|
||
|
|
instance.Free();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
condition = tuple.Item1;
|
||
|
|
sense = tuple.Item3;
|
||
|
|
dest = strongBox.Value;
|
||
|
|
instance.Free();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
binaryOperatorKind = boundBinaryOperator.OperatorKind.OperatorWithLogical();
|
||
|
|
if (binaryOperatorKind <= BinaryOperatorKind.LessThan)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind <= BinaryOperatorKind.NotEqual)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.Equal && binaryOperatorKind != BinaryOperatorKind.NotEqual)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
BoundExpression boundExpression = TryReduce(boundBinaryOperator, ref sense);
|
||
|
|
if (boundExpression != null)
|
||
|
|
{
|
||
|
|
condition = boundExpression;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (binaryOperatorKind != BinaryOperatorKind.GreaterThan && binaryOperatorKind != BinaryOperatorKind.LessThan)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind > BinaryOperatorKind.LessThanOrEqual)
|
||
|
|
{
|
||
|
|
if (binaryOperatorKind == BinaryOperatorKind.LogicalAnd || binaryOperatorKind == BinaryOperatorKind.LogicalOr)
|
||
|
|
{
|
||
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs", 496);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (binaryOperatorKind != BinaryOperatorKind.GreaterThanOrEqual && binaryOperatorKind != BinaryOperatorKind.LessThanOrEqual)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitExpression(boundBinaryOperator.Left, used: true);
|
||
|
|
EmitExpression(boundBinaryOperator.Right, used: true);
|
||
|
|
iLOpCode = CodeForJump(boundBinaryOperator, sense, out var revOpCode);
|
||
|
|
dest = dest ?? new object();
|
||
|
|
_builder.EmitBranch(iLOpCode, dest, revOpCode);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
case BoundKind.LoweredConditionalAccess:
|
||
|
|
{
|
||
|
|
BoundLoweredConditionalAccess boundLoweredConditionalAccess = (BoundLoweredConditionalAccess)condition;
|
||
|
|
BoundExpression receiver = boundLoweredConditionalAccess.Receiver;
|
||
|
|
if (!receiver.Type.IsReferenceType || LocalRewriter.CanChangeValueBetweenReads(receiver, localsMayBeAssignedOrCaptured: false) || (receiver.Kind == BoundKind.Local && IsStackLocal(((BoundLocal)receiver).LocalSymbol)))
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
BoundExpression? whenNullOpt = boundLoweredConditionalAccess.WhenNullOpt;
|
||
|
|
if (whenNullOpt != null && !whenNullOpt.IsDefaultValue())
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (sense)
|
||
|
|
{
|
||
|
|
object dest2 = null;
|
||
|
|
EmitCondBranch(receiver, ref dest2, sense: false);
|
||
|
|
EmitReceiverRef(receiver, Binder.AddressKind.ReadOnly);
|
||
|
|
EmitCondBranch(boundLoweredConditionalAccess.WhenNotNull, ref dest, sense: true);
|
||
|
|
if (dest2 != null)
|
||
|
|
{
|
||
|
|
_builder.MarkLabel(dest2);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
EmitCondBranch(receiver, ref dest, sense: false);
|
||
|
|
EmitReceiverRef(receiver, Binder.AddressKind.ReadOnly);
|
||
|
|
condition = boundLoweredConditionalAccess.WhenNotNull;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
case BoundKind.UnaryOperator:
|
||
|
|
{
|
||
|
|
BoundUnaryOperator boundUnaryOperator = (BoundUnaryOperator)condition;
|
||
|
|
if (boundUnaryOperator.OperatorKind == UnaryOperatorKind.BoolLogicalNegation)
|
||
|
|
{
|
||
|
|
sense = !sense;
|
||
|
|
condition = boundUnaryOperator.Operand;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.IsOperator:
|
||
|
|
{
|
||
|
|
BoundIsOperator boundIsOperator = (BoundIsOperator)condition;
|
||
|
|
BoundExpression operand = boundIsOperator.Operand;
|
||
|
|
EmitExpression(operand, used: true);
|
||
|
|
if (!operand.Type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(operand.Type, operand.Syntax);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Isinst);
|
||
|
|
EmitSymbolToken(boundIsOperator.TargetType.Type, boundIsOperator.TargetType.Syntax);
|
||
|
|
iLOpCode = (sense ? ILOpCode.Brtrue : ILOpCode.Brfalse);
|
||
|
|
dest = dest ?? new object();
|
||
|
|
_builder.EmitBranch(iLOpCode, dest, ILOpCode.Nop);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
case BoundKind.Sequence:
|
||
|
|
{
|
||
|
|
BoundSequence sequence = (BoundSequence)condition;
|
||
|
|
EmitSequenceCondBranch(sequence, ref dest, sense);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
EmitExpression(condition, used: true);
|
||
|
|
TypeSymbol type = condition.Type;
|
||
|
|
if (type.IsReferenceType && !type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
EmitBox(type, condition.Syntax);
|
||
|
|
}
|
||
|
|
iLOpCode = (sense ? ILOpCode.Brtrue : ILOpCode.Brfalse);
|
||
|
|
dest = dest ?? new object();
|
||
|
|
_builder.EmitBranch(iLOpCode, dest, ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSequenceCondBranch(BoundSequence sequence, ref object dest, bool sense)
|
||
|
|
{
|
||
|
|
DefineLocals(sequence);
|
||
|
|
EmitSideEffects(sequence);
|
||
|
|
EmitCondBranch(sequence.Value, ref dest, sense);
|
||
|
|
FreeLocals(sequence);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitLabelStatement(BoundLabelStatement boundLabelStatement)
|
||
|
|
{
|
||
|
|
_builder.MarkLabel((object)boundLabelStatement.Label);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitGotoStatement(BoundGotoStatement boundGotoStatement)
|
||
|
|
{
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, (object)boundGotoStatement.Label, ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsLastBlockInMethod(BoundBlock block)
|
||
|
|
{
|
||
|
|
if (_boundBody == block)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (_boundBody is BoundStatementList boundStatementList && boundStatementList.Statements.LastOrDefault() == block)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitBlock(BoundBlock block)
|
||
|
|
{
|
||
|
|
if (block.Instrumentation != null)
|
||
|
|
{
|
||
|
|
EmitInstrumentedBlock(block.Instrumentation, block);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitUninstrumentedBlock(block);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitInstrumentedBlock(BoundBlockInstrumentation instrumentation, BoundBlock block)
|
||
|
|
{
|
||
|
|
_builder.OpenLocalScope((ScopeType)0, (ITypeReference)null);
|
||
|
|
DefineLocal(instrumentation.Local, block.Syntax);
|
||
|
|
if (_emitPdbSequencePoints)
|
||
|
|
{
|
||
|
|
EmitHiddenSequencePoint();
|
||
|
|
}
|
||
|
|
EmitStatement(instrumentation.Prologue);
|
||
|
|
_builder.OpenLocalScope((ScopeType)1, (ITypeReference)null);
|
||
|
|
_builder.OpenLocalScope((ScopeType)2, (ITypeReference)null);
|
||
|
|
EmitUninstrumentedBlock(block);
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
_builder.OpenLocalScope((ScopeType)5, (ITypeReference)null);
|
||
|
|
if (_emitPdbSequencePoints)
|
||
|
|
{
|
||
|
|
EmitHiddenSequencePoint();
|
||
|
|
}
|
||
|
|
EmitStatement(instrumentation.Epilogue);
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
FreeLocal(instrumentation.Local);
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitUninstrumentedBlock(BoundBlock block)
|
||
|
|
{
|
||
|
|
bool flag = !block.Locals.IsEmpty;
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
_builder.OpenLocalScope((ScopeType)0, (ITypeReference)null);
|
||
|
|
ImmutableArray<LocalSymbol>.Enumerator enumerator = block.Locals.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LocalSymbol current = enumerator.Current;
|
||
|
|
ImmutableArray<SyntaxReference> declaringSyntaxReferences = current.DeclaringSyntaxReferences;
|
||
|
|
DefineLocal(current, (SyntaxNode)(object)((!declaringSyntaxReferences.IsEmpty) ? ((CSharpSyntaxNode)(object)declaringSyntaxReferences[0].GetSyntax(default(CancellationToken))) : ((CSharpSyntaxNode)(object)block.Syntax)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitStatements(block.Statements);
|
||
|
|
if (_indirectReturnState == IndirectReturnState.Needed && IsLastBlockInMethod(block))
|
||
|
|
{
|
||
|
|
if (block.Instrumentation != null)
|
||
|
|
{
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, s_returnLabel, ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
HandleReturn();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
ImmutableArray<LocalSymbol>.Enumerator enumerator = block.Locals.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LocalSymbol current2 = enumerator.Current;
|
||
|
|
FreeLocal(current2);
|
||
|
|
}
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStatements(ImmutableArray<BoundStatement> statements)
|
||
|
|
{
|
||
|
|
ImmutableArray<BoundStatement>.Enumerator enumerator = statements.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundStatement current = enumerator.Current;
|
||
|
|
EmitStatement(current);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitScope(BoundScope block)
|
||
|
|
{
|
||
|
|
_builder.OpenLocalScope((ScopeType)0, (ITypeReference)null);
|
||
|
|
ImmutableArray<LocalSymbol>.Enumerator enumerator = block.Locals.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LocalSymbol current = enumerator.Current;
|
||
|
|
if (!current.IsConst && !IsStackLocal(current))
|
||
|
|
{
|
||
|
|
_builder.AddLocalToScope(_builder.LocalSlotManager.GetLocal((ILocalSymbolInternal)(object)current));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitStatements(block.Statements);
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStateMachineScope(BoundStateMachineScope scope)
|
||
|
|
{
|
||
|
|
_builder.OpenLocalScope((ScopeType)7, (ITypeReference)null);
|
||
|
|
ImmutableArray<StateMachineFieldSymbol>.Enumerator enumerator = scope.Fields.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
StateMachineFieldSymbol current = enumerator.Current;
|
||
|
|
if (current.SlotIndex >= 0)
|
||
|
|
{
|
||
|
|
_builder.DefineUserDefinedStateMachineHoistedLocal(current.SlotIndex);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitStatement(scope.Statement);
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool ShouldUseIndirectReturn()
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if ((int)_ilEmitStyle == 0 && _method.GenerateDebugInfo)
|
||
|
|
{
|
||
|
|
SyntaxNode methodBodySyntaxOpt = _methodBodySyntaxOpt;
|
||
|
|
if (methodBodySyntaxOpt != null && methodBodySyntaxOpt.IsKind(SyntaxKind.Block))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return _builder.InExceptionHandler;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool CanHandleReturnLabel(BoundReturnStatement boundReturnStatement)
|
||
|
|
{
|
||
|
|
if (boundReturnStatement.WasCompilerGenerated)
|
||
|
|
{
|
||
|
|
if (!boundReturnStatement.Syntax.IsKind(SyntaxKind.Block))
|
||
|
|
{
|
||
|
|
MethodSymbol method = _method;
|
||
|
|
if ((object)method == null || !method.IsImplicitConstructor)
|
||
|
|
{
|
||
|
|
goto IL_003d;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return !_builder.InExceptionHandler;
|
||
|
|
}
|
||
|
|
goto IL_003d;
|
||
|
|
IL_003d:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitReturnStatement(BoundReturnStatement boundReturnStatement)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0027: Invalid comparison between Unknown and I4
|
||
|
|
BoundExpression expressionOpt = boundReturnStatement.ExpressionOpt;
|
||
|
|
if ((int)boundReturnStatement.RefKind == 0)
|
||
|
|
{
|
||
|
|
EmitExpression(expressionOpt, used: true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitAddress(expressionOpt, ((int)_method.RefKind == 3) ? Binder.AddressKind.ReadOnlyStrict : Binder.AddressKind.Writeable);
|
||
|
|
}
|
||
|
|
if (ShouldUseIndirectReturn())
|
||
|
|
{
|
||
|
|
if (expressionOpt != null)
|
||
|
|
{
|
||
|
|
_builder.EmitLocalStore(LazyReturnTemp);
|
||
|
|
}
|
||
|
|
if (_indirectReturnState != IndirectReturnState.Emitted && CanHandleReturnLabel(boundReturnStatement))
|
||
|
|
{
|
||
|
|
HandleReturn();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, s_returnLabel, ILOpCode.Nop);
|
||
|
|
if (_indirectReturnState == IndirectReturnState.NotNeeded)
|
||
|
|
{
|
||
|
|
_indirectReturnState = IndirectReturnState.Needed;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (_indirectReturnState == IndirectReturnState.Needed && CanHandleReturnLabel(boundReturnStatement))
|
||
|
|
{
|
||
|
|
if (expressionOpt != null)
|
||
|
|
{
|
||
|
|
_builder.EmitLocalStore(LazyReturnTemp);
|
||
|
|
}
|
||
|
|
HandleReturn();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (expressionOpt != null)
|
||
|
|
{
|
||
|
|
((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(expressionOpt.Type, boundReturnStatement.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
_builder.EmitRet(expressionOpt == null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitTryStatement(BoundTryStatement statement, bool emitCatchesOnly = false)
|
||
|
|
{
|
||
|
|
bool num = !emitCatchesOnly && statement.CatchBlocks.Length > 0 && statement.FinallyBlockOpt != null;
|
||
|
|
_builder.OpenLocalScope((ScopeType)1, (ITypeReference)null);
|
||
|
|
_builder.OpenLocalScope((ScopeType)2, (ITypeReference)null);
|
||
|
|
_tryNestingLevel++;
|
||
|
|
if (num)
|
||
|
|
{
|
||
|
|
EmitTryStatement(statement, emitCatchesOnly: true);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitBlock(statement.TryBlock);
|
||
|
|
}
|
||
|
|
_tryNestingLevel--;
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
if (!num)
|
||
|
|
{
|
||
|
|
ImmutableArray<BoundCatchBlock>.Enumerator enumerator = statement.CatchBlocks.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
BoundCatchBlock current = enumerator.Current;
|
||
|
|
EmitCatchBlock(current);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!emitCatchesOnly && statement.FinallyBlockOpt != null)
|
||
|
|
{
|
||
|
|
_builder.OpenLocalScope((ScopeType)(statement.PreferFaultHandler ? 6 : 5), (ITypeReference)null);
|
||
|
|
EmitBlock(statement.FinallyBlockOpt);
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
if (statement.PreferFaultHandler)
|
||
|
|
{
|
||
|
|
BoundBlock block = FinallyCloner.MakeFinallyClone(statement);
|
||
|
|
EmitBlock(block);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCatchBlock(BoundCatchBlock catchBlock)
|
||
|
|
{
|
||
|
|
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
object obj = null;
|
||
|
|
_builder.AdjustStack(1);
|
||
|
|
if (catchBlock.ExceptionFilterOpt == null)
|
||
|
|
{
|
||
|
|
ITypeReference obj2;
|
||
|
|
if ((object)catchBlock.ExceptionTypeOpt == null)
|
||
|
|
{
|
||
|
|
ITypeReference specialType = (ITypeReference)(object)((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).GetSpecialType((SpecialType)1, catchBlock.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
obj2 = specialType;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
obj2 = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(catchBlock.ExceptionTypeOpt, catchBlock.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
ITypeReference val = obj2;
|
||
|
|
_builder.OpenLocalScope((ScopeType)3, val);
|
||
|
|
RecordAsyncCatchHandlerOffset(catchBlock);
|
||
|
|
if (_emitPdbSequencePoints && catchBlock.Syntax is CatchClauseSyntax catchClauseSyntax)
|
||
|
|
{
|
||
|
|
TextSpan span;
|
||
|
|
if (catchClauseSyntax.Declaration == null)
|
||
|
|
{
|
||
|
|
SyntaxToken catchKeyword = catchClauseSyntax.CatchKeyword;
|
||
|
|
span = ((SyntaxToken)(ref catchKeyword)).Span;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int spanStart = ((SyntaxNode)catchClauseSyntax).SpanStart;
|
||
|
|
TextSpan span2 = ((SyntaxNode)catchClauseSyntax.Declaration).Span;
|
||
|
|
span = TextSpan.FromBounds(spanStart, ((TextSpan)(ref span2)).End);
|
||
|
|
}
|
||
|
|
EmitSequencePoint(catchBlock.SyntaxTree, span);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.OpenLocalScope((ScopeType)4, (ITypeReference)null);
|
||
|
|
RecordAsyncCatchHandlerOffset(catchBlock);
|
||
|
|
object obj3 = new object();
|
||
|
|
obj = new object();
|
||
|
|
if ((object)catchBlock.ExceptionTypeOpt != null)
|
||
|
|
{
|
||
|
|
ITypeReference val2 = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(catchBlock.ExceptionTypeOpt, catchBlock.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Isinst);
|
||
|
|
_builder.EmitToken((IReference)(object)val2, catchBlock.Syntax, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Dup);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, obj3, ILOpCode.Nop);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Pop);
|
||
|
|
_builder.EmitIntConstant(0);
|
||
|
|
_builder.EmitBranch(ILOpCode.Br, obj, ILOpCode.Nop);
|
||
|
|
}
|
||
|
|
_builder.MarkLabel(obj3);
|
||
|
|
}
|
||
|
|
ImmutableArray<LocalSymbol>.Enumerator enumerator = catchBlock.Locals.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LocalSymbol current = enumerator.Current;
|
||
|
|
ImmutableArray<SyntaxReference> declaringSyntaxReferences = current.DeclaringSyntaxReferences;
|
||
|
|
SyntaxNode syntaxNode = (SyntaxNode)(object)((!declaringSyntaxReferences.IsEmpty) ? ((CSharpSyntaxNode)(object)declaringSyntaxReferences[0].GetSyntax(default(CancellationToken))) : ((CSharpSyntaxNode)(object)catchBlock.Syntax));
|
||
|
|
DefineLocal(current, syntaxNode);
|
||
|
|
}
|
||
|
|
BoundExpression exceptionSourceOpt = catchBlock.ExceptionSourceOpt;
|
||
|
|
if (exceptionSourceOpt != null)
|
||
|
|
{
|
||
|
|
if (!exceptionSourceOpt.Type.IsVerifierReference())
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Unbox_any);
|
||
|
|
EmitSymbolToken(exceptionSourceOpt.Type, exceptionSourceOpt.Syntax);
|
||
|
|
}
|
||
|
|
BoundExpression boundExpression = exceptionSourceOpt;
|
||
|
|
while (boundExpression.Kind == BoundKind.Sequence)
|
||
|
|
{
|
||
|
|
BoundSequence boundSequence = (BoundSequence)boundExpression;
|
||
|
|
EmitSideEffects(boundSequence);
|
||
|
|
boundExpression = boundSequence.Value;
|
||
|
|
}
|
||
|
|
switch (boundExpression.Kind)
|
||
|
|
{
|
||
|
|
case BoundKind.Local:
|
||
|
|
{
|
||
|
|
BoundLocal boundLocal = (BoundLocal)boundExpression;
|
||
|
|
if (!IsStackLocal(boundLocal.LocalSymbol))
|
||
|
|
{
|
||
|
|
_builder.EmitLocalStore(GetLocal(boundLocal));
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case BoundKind.FieldAccess:
|
||
|
|
{
|
||
|
|
BoundFieldAccess boundFieldAccess = (BoundFieldAccess)boundExpression;
|
||
|
|
if (boundFieldAccess.FieldSymbol is StateMachineFieldSymbol { SlotIndex: >=0 } stateMachineFieldSymbol)
|
||
|
|
{
|
||
|
|
_builder.DefineUserDefinedStateMachineHoistedLocal(stateMachineFieldSymbol.SlotIndex);
|
||
|
|
}
|
||
|
|
LocalDefinition val3 = AllocateTemp(boundExpression.Type, boundExpression.Syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(val3);
|
||
|
|
EmitReceiverRef(boundFieldAccess.ReceiverOpt, Binder.AddressKind.Writeable);
|
||
|
|
_builder.EmitLocalLoad(val3);
|
||
|
|
FreeTemp(val3);
|
||
|
|
EmitFieldStore(boundFieldAccess, refAssign: false);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)boundExpression.Kind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Pop);
|
||
|
|
}
|
||
|
|
if (catchBlock.ExceptionFilterPrologueOpt != null)
|
||
|
|
{
|
||
|
|
EmitStatements(catchBlock.ExceptionFilterPrologueOpt.Statements);
|
||
|
|
}
|
||
|
|
if (catchBlock.ExceptionFilterOpt != null)
|
||
|
|
{
|
||
|
|
EmitCondExpr(catchBlock.ExceptionFilterOpt, sense: true);
|
||
|
|
_builder.EmitIntConstant(0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Cgt_un);
|
||
|
|
_builder.MarkLabel(obj);
|
||
|
|
_builder.MarkFilterConditionEnd();
|
||
|
|
_builder.EmitOpCode(ILOpCode.Pop);
|
||
|
|
}
|
||
|
|
EmitBlock(catchBlock.Body);
|
||
|
|
_builder.CloseLocalScope();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void RecordAsyncCatchHandlerOffset(BoundCatchBlock catchBlock)
|
||
|
|
{
|
||
|
|
if (catchBlock.IsSynthesizedAsyncCatchAll)
|
||
|
|
{
|
||
|
|
_asyncCatchHandlerOffset = _builder.AllocateILMarker();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSwitchDispatch(BoundSwitchDispatch dispatch)
|
||
|
|
{
|
||
|
|
EmitSwitchHeader(dispatch.Expression, dispatch.Cases.Select<(ConstantValue, LabelSymbol), KeyValuePair<ConstantValue, object>>(((ConstantValue value, LabelSymbol label) p) => new KeyValuePair<ConstantValue, object>(p.value, p.label)).ToArray(), dispatch.DefaultLabel, dispatch.LengthBasedStringSwitchDataOpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitSwitchHeader(BoundExpression expression, KeyValuePair<ConstantValue, object>[] switchCaseLabels, LabelSymbol fallThroughLabel, LengthBasedStringSwitchData lengthBasedSwitchStringJumpTableOpt)
|
||
|
|
{
|
||
|
|
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00f8: Invalid comparison between Unknown and I4
|
||
|
|
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
LocalDefinition val = null;
|
||
|
|
BoundSequence boundSequence = null;
|
||
|
|
if (expression.Kind == BoundKind.Sequence)
|
||
|
|
{
|
||
|
|
boundSequence = (BoundSequence)expression;
|
||
|
|
DefineLocals(boundSequence);
|
||
|
|
EmitSideEffects(boundSequence);
|
||
|
|
expression = boundSequence.Value;
|
||
|
|
}
|
||
|
|
if (expression.Kind == BoundKind.SequencePointExpression)
|
||
|
|
{
|
||
|
|
BoundSequencePointExpression boundSequencePointExpression = (BoundSequencePointExpression)expression;
|
||
|
|
EmitSequencePoint(boundSequencePointExpression);
|
||
|
|
expression = boundSequencePointExpression.Expression;
|
||
|
|
}
|
||
|
|
BoundKind kind = expression.Kind;
|
||
|
|
LocalOrParameter val2;
|
||
|
|
if (kind != BoundKind.Local)
|
||
|
|
{
|
||
|
|
if (kind == BoundKind.Parameter)
|
||
|
|
{
|
||
|
|
BoundParameter boundParameter = (BoundParameter)expression;
|
||
|
|
if ((int)boundParameter.ParameterSymbol.RefKind == 0)
|
||
|
|
{
|
||
|
|
val2 = LocalOrParameter.op_Implicit(ParameterSlot(boundParameter));
|
||
|
|
goto IL_00eb;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
LocalSymbol localSymbol = ((BoundLocal)expression).LocalSymbol;
|
||
|
|
if ((int)localSymbol.RefKind == 0 && !IsStackLocal(localSymbol))
|
||
|
|
{
|
||
|
|
val2 = LocalOrParameter.op_Implicit(GetLocal(localSymbol));
|
||
|
|
goto IL_00eb;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EmitExpression(expression, used: true);
|
||
|
|
val = AllocateTemp(expression.Type, expression.Syntax, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(val);
|
||
|
|
val2 = LocalOrParameter.op_Implicit(val);
|
||
|
|
goto IL_00eb;
|
||
|
|
IL_00eb:
|
||
|
|
if ((int)expression.Type.SpecialType == 20 || expression.Type.IsSpanOrReadOnlySpanChar())
|
||
|
|
{
|
||
|
|
if (lengthBasedSwitchStringJumpTableOpt == null)
|
||
|
|
{
|
||
|
|
EmitStringSwitchJumpTable(switchCaseLabels, fallThroughLabel, val2, expression.Syntax, expression.Type);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitLengthBasedStringSwitchJumpTable(lengthBasedSwitchStringJumpTableOpt, fallThroughLabel, val2, expression.Syntax, expression.Type);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitIntegerSwitchJumpTable(switchCaseLabels, (object)fallThroughLabel, val2, expression.Type.EnumUnderlyingTypeOrSelf().PrimitiveTypeCode);
|
||
|
|
}
|
||
|
|
if (val != null)
|
||
|
|
{
|
||
|
|
FreeTemp(val);
|
||
|
|
}
|
||
|
|
if (boundSequence != null)
|
||
|
|
{
|
||
|
|
FreeLocals(boundSequence);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitLengthBasedStringSwitchJumpTable(LengthBasedStringSwitchData lengthBasedSwitchData, LabelSymbol fallThroughLabel, LocalOrParameter keyTemp, SyntaxNode syntaxNode, TypeSymbol keyType)
|
||
|
|
{
|
||
|
|
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
bool flag = keyType.IsSpanChar();
|
||
|
|
bool flag2 = keyType.IsReadOnlySpanChar();
|
||
|
|
bool isSpanOrReadOnlySpan = flag || flag2;
|
||
|
|
IMethodReference indexerRef = GetIndexerRef(syntaxNode, keyType, flag2, isSpanOrReadOnlySpan);
|
||
|
|
IMethodReference lengthMethodRef = GetLengthMethodRef(syntaxNode, keyType, flag2, isSpanOrReadOnlySpan);
|
||
|
|
emitLengthDispatch(lengthBasedSwitchData, keyTemp, fallThroughLabel, syntaxNode);
|
||
|
|
emitCharDispatches(lengthBasedSwitchData, keyTemp, fallThroughLabel, syntaxNode);
|
||
|
|
emitFinalDispatches(lengthBasedSwitchData, keyTemp, keyType, fallThroughLabel, syntaxNode);
|
||
|
|
void emitCharDispatches(LengthBasedStringSwitchData lengthBasedSwitchInfo, LocalOrParameter val3, LabelSymbol labelSymbol, SyntaxNode val)
|
||
|
|
{
|
||
|
|
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
NamedTypeSymbol specialType = Binder.GetSpecialType(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (SpecialType)8, val, _diagnostics);
|
||
|
|
LocalDefinition val2 = AllocateTemp(specialType, val, (LocalSlotConstraints)0);
|
||
|
|
ImmutableArray<LengthBasedStringSwitchData.CharJumpTable>.Enumerator enumerator = lengthBasedSwitchInfo.CharBasedJumpTables.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LengthBasedStringSwitchData.CharJumpTable current = enumerator.Current;
|
||
|
|
_builder.MarkLabel((object)current.Label);
|
||
|
|
if (isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
_builder.EmitLoadAddress(val3);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitLoad(val3);
|
||
|
|
}
|
||
|
|
_builder.EmitIntConstant(current.SelectedCharPosition);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, -1);
|
||
|
|
emitMethodRef(indexerRef);
|
||
|
|
if (isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
_builder.EmitOpCode(ILOpCode.Ldind_u2);
|
||
|
|
}
|
||
|
|
_builder.EmitLocalStore(val2);
|
||
|
|
_builder.EmitIntegerSwitchJumpTable(current.CharCaseLabels.Select<(char, LabelSymbol), KeyValuePair<ConstantValue, object>>(((char value, LabelSymbol label) p) => new KeyValuePair<ConstantValue, object>(ConstantValue.Create(p.value), p.label)).ToArray(), (object)labelSymbol, LocalOrParameter.op_Implicit(val2), specialType.PrimitiveTypeCode);
|
||
|
|
}
|
||
|
|
FreeTemp(val2);
|
||
|
|
}
|
||
|
|
void emitFinalDispatches(LengthBasedStringSwitchData lengthBasedSwitchInfo, LocalOrParameter key, TypeSymbol keyType2, LabelSymbol fallThroughLabel2, SyntaxNode syntaxNode2)
|
||
|
|
{
|
||
|
|
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
ImmutableArray<LengthBasedStringSwitchData.StringJumpTable>.Enumerator enumerator = lengthBasedSwitchInfo.StringBasedJumpTables.GetEnumerator();
|
||
|
|
while (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
LengthBasedStringSwitchData.StringJumpTable current = enumerator.Current;
|
||
|
|
_builder.MarkLabel((object)current.Label);
|
||
|
|
EmitStringSwitchJumpTable(current.StringCaseLabels.Select<(string, LabelSymbol), KeyValuePair<ConstantValue, object>>(((string value, LabelSymbol label) p) => new KeyValuePair<ConstantValue, object>(ConstantValue.Create(p.value), p.label)).ToArray(), fallThroughLabel2, key, syntaxNode2, keyType2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void emitLengthDispatch(LengthBasedStringSwitchData lengthBasedSwitchInfo, LocalOrParameter val, LabelSymbol labelSymbol, SyntaxNode val2)
|
||
|
|
{
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
_builder.EmitLoad(val);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brfalse, (object)(lengthBasedSwitchInfo.LengthBasedJumpTable.NullCaseLabel ?? labelSymbol), ILOpCode.Brtrue);
|
||
|
|
}
|
||
|
|
NamedTypeSymbol specialType = Binder.GetSpecialType(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (SpecialType)13, val2, _diagnostics);
|
||
|
|
LocalDefinition val3 = AllocateTemp(specialType, val2, (LocalSlotConstraints)0);
|
||
|
|
if (isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
_builder.EmitLoadAddress(val);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitLoad(val);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
emitMethodRef(lengthMethodRef);
|
||
|
|
_builder.EmitLocalStore(val3);
|
||
|
|
_builder.EmitIntegerSwitchJumpTable(lengthBasedSwitchInfo.LengthBasedJumpTable.LengthCaseLabels.Select<(int, LabelSymbol), KeyValuePair<ConstantValue, object>>(((int value, LabelSymbol label) p) => new KeyValuePair<ConstantValue, object>(ConstantValue.Create(p.value), p.label)).ToArray(), (object)labelSymbol, LocalOrParameter.op_Implicit(val3), specialType.PrimitiveTypeCode);
|
||
|
|
FreeTemp(val3);
|
||
|
|
}
|
||
|
|
void emitMethodRef(IMethodReference val)
|
||
|
|
{
|
||
|
|
DiagnosticBag instance = DiagnosticBag.GetInstance();
|
||
|
|
_builder.EmitToken((ISignature)(object)val, (SyntaxNode)null, instance);
|
||
|
|
instance.Free();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStringSwitchJumpTable(KeyValuePair<ConstantValue, object>[] switchCaseLabels, LabelSymbol fallThroughLabel, LocalOrParameter key, SyntaxNode syntaxNode, TypeSymbol keyType)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0251: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0258: Expected O, but got Unknown
|
||
|
|
//IL_0261: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0279: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_027e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0284: Expected O, but got Unknown
|
||
|
|
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
bool flag = keyType.IsSpanChar();
|
||
|
|
bool flag2 = keyType.IsReadOnlySpanChar();
|
||
|
|
bool isSpanOrReadOnlySpan = flag || flag2;
|
||
|
|
LocalDefinition val = null;
|
||
|
|
if (SwitchStringJumpTableEmitter.ShouldGenerateHashTableSwitch(switchCaseLabels.Length))
|
||
|
|
{
|
||
|
|
IReference method = (IReference)(object)((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).GetPrivateImplClass(syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag).GetMethod((!isSpanOrReadOnlySpan) ? "ComputeStringHash" : (flag2 ? "ComputeReadOnlySpanHash" : "ComputeSpanHash"));
|
||
|
|
if (method != null)
|
||
|
|
{
|
||
|
|
_builder.EmitLoad(key);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
_builder.EmitToken(method, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
NamedTypeSymbol specialType = Binder.GetSpecialType(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (SpecialType)14, syntaxNode, _diagnostics);
|
||
|
|
val = AllocateTemp(specialType, syntaxNode, (LocalSlotConstraints)0);
|
||
|
|
_builder.EmitLocalStore(val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
IMethodReference stringEqualityMethodRef = null;
|
||
|
|
IMethodReference sequenceEqualsMethodRef = null;
|
||
|
|
IMethodReference asSpanMethodRef = null;
|
||
|
|
if (isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
MethodSymbol methodSymbol = ((MethodSymbol)Binder.GetWellKnownTypeMember(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (WellKnownMember)(flag2 ? 474 : 473), _diagnostics, null, syntaxNode)).Construct(Binder.GetSpecialType(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (SpecialType)8, syntaxNode, _diagnostics));
|
||
|
|
sequenceEqualsMethodRef = _module.Translate(methodSymbol, null, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
MethodSymbol methodSymbol2 = (MethodSymbol)Binder.GetWellKnownTypeMember(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (WellKnownMember)475, _diagnostics, null, syntaxNode);
|
||
|
|
asSpanMethodRef = _module.Translate(methodSymbol2, null, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
MethodSymbol methodSymbol3 = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.GetSpecialTypeMember((SpecialMember)9) as MethodSymbol;
|
||
|
|
stringEqualityMethodRef = _module.Translate(methodSymbol3, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
IMethodReference lengthMethodRef = GetLengthMethodRef(syntaxNode, keyType, flag2, isSpanOrReadOnlySpan);
|
||
|
|
EmitStringCompareAndBranch val2 = (EmitStringCompareAndBranch)delegate(LocalOrParameter keyArg, ConstantValue stringConstant, object targetLabel)
|
||
|
|
{
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (stringConstant == ConstantValue.Null)
|
||
|
|
{
|
||
|
|
_builder.EmitLoad(keyArg);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brfalse, targetLabel, ILOpCode.Brtrue);
|
||
|
|
}
|
||
|
|
else if (stringConstant.StringValue.Length == 0 && lengthMethodRef != null)
|
||
|
|
{
|
||
|
|
object obj3 = new object();
|
||
|
|
if (isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
_builder.EmitLoadAddress(keyArg);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
_builder.EmitLoad(keyArg);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brfalse, obj3, ILOpCode.Brtrue);
|
||
|
|
_builder.EmitLoad(keyArg);
|
||
|
|
}
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
DiagnosticBag instance = DiagnosticBag.GetInstance();
|
||
|
|
_builder.EmitToken((ISignature)(object)lengthMethodRef, (SyntaxNode)null, instance);
|
||
|
|
instance.Free();
|
||
|
|
_builder.EmitBranch(ILOpCode.Brfalse, targetLabel, ILOpCode.Brtrue);
|
||
|
|
_builder.MarkLabel(obj3);
|
||
|
|
}
|
||
|
|
else if (isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
EmitCharCompareAndBranch(key, syntaxNode, stringConstant, targetLabel, (IReference)(object)sequenceEqualsMethodRef, (IReference)(object)asSpanMethodRef);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
EmitStringCompareAndBranch(key, syntaxNode, stringConstant, targetLabel, (IReference)(object)stringEqualityMethodRef);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
ILBuilder builder = _builder;
|
||
|
|
LocalOrParameter val3 = key;
|
||
|
|
LocalDefinition obj = val;
|
||
|
|
object obj2 = _003C_003EO._003C1_003E__ComputeStringHash;
|
||
|
|
if (obj2 == null)
|
||
|
|
{
|
||
|
|
GetStringHashCode val4 = SynthesizedStringSwitchHashMethod.ComputeStringHash;
|
||
|
|
_003C_003EO._003C1_003E__ComputeStringHash = val4;
|
||
|
|
obj2 = (object)val4;
|
||
|
|
}
|
||
|
|
builder.EmitStringSwitchJumpTable(switchCaseLabels, (object)fallThroughLabel, val3, obj, val2, (GetStringHashCode)obj2);
|
||
|
|
if (val != null)
|
||
|
|
{
|
||
|
|
FreeTemp(val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private IMethodReference? GetLengthMethodRef(SyntaxNode syntaxNode, TypeSymbol keyType, bool isReadOnlySpan, bool isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
if (isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
MethodSymbol methodSymbol = ((MethodSymbol)Binder.GetWellKnownTypeMember(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (WellKnownMember)(isReadOnlySpan ? 407 : 401), _diagnostics, null, syntaxNode)).AsMember((NamedTypeSymbol)keyType);
|
||
|
|
return _module.Translate(methodSymbol, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
MethodSymbol methodSymbol2 = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.GetSpecialTypeMember((SpecialMember)11) as MethodSymbol;
|
||
|
|
if (methodSymbol2 != null && !methodSymbol2.HasUseSiteError)
|
||
|
|
{
|
||
|
|
return _module.Translate(methodSymbol2, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private IMethodReference? GetIndexerRef(SyntaxNode syntaxNode, TypeSymbol keyType, bool isReadOnlySpan, bool isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
if (isSpanOrReadOnlySpan)
|
||
|
|
{
|
||
|
|
MethodSymbol methodSymbol = (MethodSymbol)Binder.GetWellKnownTypeMember(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation, (WellKnownMember)(isReadOnlySpan ? 406 : 400), _diagnostics, null, syntaxNode);
|
||
|
|
if (methodSymbol != null && !methodSymbol.HasUseSiteError)
|
||
|
|
{
|
||
|
|
MethodSymbol methodSymbol2 = methodSymbol.AsMember((NamedTypeSymbol)keyType);
|
||
|
|
return _module.Translate(methodSymbol2, null, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
MethodSymbol methodSymbol3 = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Compilation.GetSpecialTypeMember((SpecialMember)12) as MethodSymbol;
|
||
|
|
if (methodSymbol3 != null && !methodSymbol3.HasUseSiteError)
|
||
|
|
{
|
||
|
|
return _module.Translate(methodSymbol3, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitStringCompareAndBranch(LocalOrParameter key, SyntaxNode syntaxNode, ConstantValue stringConstant, object targetLabel, IReference stringEqualityMethodRef)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
_builder.EmitLoad(key);
|
||
|
|
_builder.EmitConstantValue(stringConstant);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, -1);
|
||
|
|
_builder.EmitToken(stringEqualityMethodRef, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, targetLabel, ILOpCode.Brfalse);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void EmitCharCompareAndBranch(LocalOrParameter key, SyntaxNode syntaxNode, ConstantValue stringConstant, object targetLabel, IReference sequenceEqualsRef, IReference asSpanRef)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
_builder.EmitLoad(key);
|
||
|
|
_builder.EmitConstantValue(stringConstant);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, 0);
|
||
|
|
_builder.EmitToken(asSpanRef, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.EmitOpCode(ILOpCode.Call, -1);
|
||
|
|
_builder.EmitToken(sequenceEqualsRef, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag, (RawTokenEncoding)0);
|
||
|
|
_builder.EmitBranch(ILOpCode.Brtrue, targetLabel, ILOpCode.Brfalse);
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition GetLocal(BoundLocal localExpression)
|
||
|
|
{
|
||
|
|
LocalSymbol localSymbol = localExpression.LocalSymbol;
|
||
|
|
return GetLocal(localSymbol);
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition GetLocal(LocalSymbol symbol)
|
||
|
|
{
|
||
|
|
return _builder.LocalSlotManager.GetLocal((ILocalSymbolInternal)(object)symbol);
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition DefineLocal(LocalSymbol local, SyntaxNode syntaxNode)
|
||
|
|
{
|
||
|
|
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0096: Expected O, but got Unknown
|
||
|
|
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0185: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_018a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0197: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_01a7: Invalid comparison between Unknown and I4
|
||
|
|
//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_01cf: Invalid comparison between Unknown and I4
|
||
|
|
ImmutableArray<bool> immutableArray = ((!local.IsCompilerGenerated && local.Type.ContainsDynamic()) ? CSharpCompilation.DynamicTransformsEncoder.Encode(local.Type, (RefKind)0, 0) : ImmutableArray<bool>.Empty);
|
||
|
|
ImmutableArray<string> immutableArray2 = ((!local.IsCompilerGenerated && local.Type.ContainsTupleNames()) ? CSharpCompilation.TupleNamesEncoder.Encode(local.Type) : ImmutableArray<string>.Empty);
|
||
|
|
if (local.IsConst)
|
||
|
|
{
|
||
|
|
MetadataConstant val = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).CreateConstant(local.Type, local.ConstantValue, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
LocalConstantDefinition val2 = new LocalConstantDefinition(local.Name, local.GetFirstLocationOrNone(), val, immutableArray, immutableArray2);
|
||
|
|
_builder.AddLocalConstantToScope(val2);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (IsStackLocal(local))
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
LocalSlotConstraints val3;
|
||
|
|
ITypeReference val4;
|
||
|
|
if (local.DeclarationKind == LocalDeclarationKind.FixedVariable && local.IsPinned)
|
||
|
|
{
|
||
|
|
val3 = (LocalSlotConstraints)3;
|
||
|
|
TypeSymbol pointedAtType = ((PointerTypeSymbol)local.Type).PointedAtType;
|
||
|
|
ITypeReference obj;
|
||
|
|
if (!pointedAtType.IsVoidType())
|
||
|
|
{
|
||
|
|
obj = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(pointedAtType, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ITypeReference specialType = (ITypeReference)(object)((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).GetSpecialType((SpecialType)21, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
obj = specialType;
|
||
|
|
}
|
||
|
|
val4 = obj;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
val3 = (LocalSlotConstraints)((local.IsPinned ? 2 : 0) | (((int)local.RefKind != 0) ? 1 : 0));
|
||
|
|
val4 = ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(local.Type, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
}
|
||
|
|
((CommonPEModuleBuilder)_module).GetFakeSymbolTokenForIL((IReference)(object)val4, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag);
|
||
|
|
LocalDebugId localId;
|
||
|
|
string localDebugName = GetLocalDebugName((ILocalSymbolInternal)(object)local, out localId);
|
||
|
|
LocalDefinition val5 = _builder.LocalSlotManager.DeclareLocal(val4, (ILocalSymbolInternal)(object)local, localDebugName, local.SynthesizedKind, localId, SynthesizedLocalKindExtensions.PdbAttributes(local.SynthesizedKind), val3, immutableArray, immutableArray2, SynthesizedLocalKindExtensions.IsSlotReusable(local.SynthesizedKind, (int)_ilEmitStyle != 2));
|
||
|
|
bool flag = val5.Name != null;
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
bool flag2 = (int)local.SynthesizedKind == 0;
|
||
|
|
if (flag2)
|
||
|
|
{
|
||
|
|
bool flag3;
|
||
|
|
switch (local.ScopeDesignatorOpt?.Kind())
|
||
|
|
{
|
||
|
|
case SyntaxKind.SwitchSection:
|
||
|
|
case SyntaxKind.SwitchExpressionArm:
|
||
|
|
flag3 = true;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
flag3 = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
flag2 = flag3;
|
||
|
|
}
|
||
|
|
flag = !flag2;
|
||
|
|
}
|
||
|
|
if (flag)
|
||
|
|
{
|
||
|
|
_builder.AddLocalToScope(val5);
|
||
|
|
}
|
||
|
|
return val5;
|
||
|
|
}
|
||
|
|
|
||
|
|
private string GetLocalDebugName(ILocalSymbolInternal local, out LocalDebugId localId)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002c: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
localId = LocalDebugId.None;
|
||
|
|
if (local.IsImportedFromMetadata)
|
||
|
|
{
|
||
|
|
return ((ISymbolInternal)local).Name;
|
||
|
|
}
|
||
|
|
SynthesizedLocalKind synthesizedKind = local.SynthesizedKind;
|
||
|
|
if (!SynthesizedLocalKindExtensions.IsLongLived(synthesizedKind) || (int)synthesizedKind == 34)
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if ((int)_ilEmitStyle == 0)
|
||
|
|
{
|
||
|
|
SyntaxNode declaratorSyntax = local.GetDeclaratorSyntax();
|
||
|
|
int num = _method.CalculateLocalSyntaxOffset(LambdaUtilities.GetDeclaratorPosition(declaratorSyntax), declaratorSyntax.SyntaxTree);
|
||
|
|
int num2 = _synthesizedLocalOrdinals.AssignLocalOrdinal(synthesizedKind, num);
|
||
|
|
localId = new LocalDebugId(num, num2);
|
||
|
|
}
|
||
|
|
return ((ISymbolInternal)local).Name ?? GeneratedNames.MakeSynthesizedLocalName(synthesizedKind, ref _uniqueNameId);
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsSlotReusable(LocalSymbol local)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Invalid comparison between Unknown and I4
|
||
|
|
return SynthesizedLocalKindExtensions.IsSlotReusable(local.SynthesizedKind, (int)_ilEmitStyle != 2);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void FreeLocal(LocalSymbol local)
|
||
|
|
{
|
||
|
|
if (local.Name == null && IsSlotReusable(local) && !IsStackLocal(local))
|
||
|
|
{
|
||
|
|
_builder.LocalSlotManager.FreeLocal((ILocalSymbolInternal)(object)local);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private LocalDefinition AllocateTemp(TypeSymbol type, SyntaxNode syntaxNode, LocalSlotConstraints slotConstraints = (LocalSlotConstraints)0)
|
||
|
|
{
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return _builder.LocalSlotManager.AllocateSlot(((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)_module).Translate(type, syntaxNode, ((BindingDiagnosticBag)_diagnostics).DiagnosticBag), slotConstraints, default(ImmutableArray<bool>), default(ImmutableArray<string>));
|
||
|
|
}
|
||
|
|
|
||
|
|
private void FreeTemp(LocalDefinition temp)
|
||
|
|
{
|
||
|
|
_builder.LocalSlotManager.FreeSlot(temp);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void FreeOptTemp(LocalDefinition temp)
|
||
|
|
{
|
||
|
|
if (temp != null)
|
||
|
|
{
|
||
|
|
FreeTemp(temp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|