diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundLoweredIsPatternExpression.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundLoweredIsPatternExpression.cs
index 68fed229791af..ed17eba2d8f05 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundLoweredIsPatternExpression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundLoweredIsPatternExpression.cs
@@ -14,3 +14,12 @@ private partial void Validate()
Debug.Assert(this.Statements is [.., BoundGotoStatement or BoundSwitchDispatch]);
}
}
+
+partial class BoundLoweredSwitchExpression
+{
+ private partial void Validate()
+ {
+ Debug.Assert(this.Statements is [.., BoundGotoStatement or BoundSwitchDispatch]);
+ Debug.Assert(!this.SwitchArms.IsEmpty);
+ }
+}
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index 44f8f7eacde5b..22007532f9441 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -1525,6 +1525,18 @@
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
index bc5aaaf5b90fb..81f34c9de9f98 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
@@ -325,6 +325,10 @@ private void EmitExpressionCore(BoundExpression expression, bool used)
EmitRefValueOperator((BoundRefValueOperator)expression, used);
break;
+ case BoundKind.LoweredSwitchExpression:
+ EmitLoweredSwitchExpression((BoundLoweredSwitchExpression)expression, used);
+ break;
+
case BoundKind.LoweredIsPatternExpression:
EmitLoweredIsPatternExpression((BoundLoweredIsPatternExpression)expression, used);
break;
@@ -366,6 +370,42 @@ private void EmitExpressionCore(BoundExpression expression, bool used)
}
}
+ private void EmitLoweredSwitchExpression(BoundLoweredSwitchExpression node, bool used)
+ {
+ EmitSideEffects(node.Statements);
+
+ var doneLabel = new object();
+ for (int i = 0, n = node.SwitchArms.Length; i < n; i++)
+ {
+ var switchArm = node.SwitchArms[i];
+ if (!switchArm.Locals.IsEmpty)
+ {
+ _builder.OpenLocalScope();
+ DefineScopeLocals(switchArm.Locals);
+ }
+
+ EmitSideEffects(switchArm.Statements);
+ EmitExpression(switchArm.Value, used);
+ if (used)
+ {
+ EmitStaticCastIfNeeded(node, switchArm.Value);
+ }
+
+ if (!switchArm.Locals.IsEmpty)
+ {
+ _builder.CloseLocalScope();
+ }
+
+ _builder.EmitBranch(ILOpCode.Br, doneLabel);
+ if (used && i != n - 1)
+ {
+ _builder.AdjustStack(-1);
+ }
+ }
+
+ _builder.MarkLabel(doneLabel);
+ }
+
private void EmitLoweredIsPatternExpression(BoundLoweredIsPatternExpression node, bool used, bool sense = true)
{
EmitSideEffects(node.Statements);
@@ -3814,18 +3854,9 @@ private void EmitConditionalOperator(BoundConditionalOperator expr, bool used)
// it seems that either PEVerify or the runtime/JIT verifier will complain at you if you try to remove
// either of the casts.
//
- var mergeTypeOfAlternative = StackMergeType(expr.Alternative);
if (used)
{
- if (IsVarianceCast(expr.Type, mergeTypeOfAlternative))
- {
- EmitStaticCast(expr.Type, expr.Syntax);
- mergeTypeOfAlternative = expr.Type;
- }
- else if (expr.Type.IsInterfaceType() && !TypeSymbol.Equals(expr.Type, mergeTypeOfAlternative, TypeCompareKind.ConsiderEverything2))
- {
- EmitStaticCast(expr.Type, expr.Syntax);
- }
+ EmitStaticCastIfNeeded(expr, expr.Alternative);
}
_builder.EmitBranch(ILOpCode.Br, doneLabel);
@@ -3840,21 +3871,23 @@ private void EmitConditionalOperator(BoundConditionalOperator expr, bool used)
if (used)
{
- var mergeTypeOfConsequence = StackMergeType(expr.Consequence);
- if (IsVarianceCast(expr.Type, mergeTypeOfConsequence))
- {
- EmitStaticCast(expr.Type, expr.Syntax);
- mergeTypeOfConsequence = expr.Type;
- }
- else if (expr.Type.IsInterfaceType() && !TypeSymbol.Equals(expr.Type, mergeTypeOfConsequence, TypeCompareKind.ConsiderEverything2))
- {
- EmitStaticCast(expr.Type, expr.Syntax);
- }
+ EmitStaticCastIfNeeded(expr, expr.Consequence);
}
_builder.MarkLabel(doneLabel);
}
+ private void EmitStaticCastIfNeeded(BoundExpression node, BoundExpression expression)
+ {
+ Debug.Assert(node.Type is not null);
+ TypeSymbol stackMergeType = StackMergeType(expression);
+ if (IsVarianceCast(node.Type, stackMergeType) ||
+ (node.Type.IsInterfaceType() && !TypeSymbol.Equals(node.Type, stackMergeType, TypeCompareKind.ConsiderEverything2)))
+ {
+ EmitStaticCast(node.Type, node.Syntax);
+ }
+ }
+
///
/// Emit code for a null-coalescing operator.
///
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
index a7a6d10585731..0d80a620861b2 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
@@ -821,7 +821,16 @@ private void EmitScope(BoundScope block)
_builder.OpenLocalScope();
- foreach (var local in block.Locals)
+ DefineScopeLocals(block.Locals);
+
+ EmitStatements(block.Statements);
+
+ _builder.CloseLocalScope();
+ }
+
+ private void DefineScopeLocals(ImmutableArray locals)
+ {
+ foreach (var local in locals)
{
Debug.Assert(local.Name != null);
Debug.Assert(local.SynthesizedKind == SynthesizedLocalKind.UserDefined &&
@@ -831,10 +840,6 @@ private void EmitScope(BoundScope block)
_builder.AddLocalToScope(_builder.LocalSlotManager.GetLocal(local));
}
}
-
- EmitStatements(block.Statements);
-
- _builder.CloseLocalScope();
}
private void EmitStateMachineScope(BoundStateMachineScope scope)
diff --git a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
index 7f2f6797a29a0..6f7295916c6c2 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
@@ -575,7 +575,7 @@ public BoundNode VisitStatement(BoundNode node)
return VisitSideEffect(node);
}
- public ImmutableArray VisitSideEffects(ImmutableArray statements)
+ public ImmutableArray VisitSideEffects(ImmutableArray statements) where T : BoundNode
{
#if DEBUG
int prevStack = _expectedStackDepth;
@@ -1467,6 +1467,26 @@ public override BoundNode VisitSwitchDispatch(BoundSwitchDispatch node)
return node.Update(boundExpression, node.Cases, node.DefaultLabel, node.LengthBasedStringSwitchDataOpt);
}
+#if DEBUG
+ public override BoundNode VisitLoweredSwitchExpression(BoundLoweredSwitchExpression node)
+ {
+ return node.Update(
+ VisitSideEffects(node.Statements),
+ VisitSideEffects(node.SwitchArms),
+ VisitType(node.Type));
+ }
+#endif
+
+ public override BoundNode VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node)
+ {
+ var statements = VisitSideEffects(node.Statements);
+ var value = VisitExpression(node.Value, ExprContext.Value);
+ PopEvalStack();
+ _counter++;
+ EnsureOnlyEvalStack();
+ return node.Update(node.Locals, statements, value);
+ }
+
public override BoundNode VisitLoweredIsPatternExpression(BoundLoweredIsPatternExpression node)
{
var statements = VisitSideEffects(node.Statements);
@@ -2300,6 +2320,13 @@ BoundExpression visitArgumentsAndUpdateCall(BoundCall node, BoundExpression? rec
}
#nullable disable
+ public override BoundNode VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm switchArm)
+ {
+ var result = base.VisitLoweredSwitchExpressionArm(switchArm);
+ _nodeCounter++;
+ return result;
+ }
+
public override BoundNode VisitCatchBlock(BoundCatchBlock node)
{
var exceptionSource = node.ExceptionSourceOpt;
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass_Switch.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass_Switch.cs
index 1a9e95047fcdd..054ef166e71bc 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass_Switch.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass_Switch.cs
@@ -181,5 +181,22 @@ private BoundNode VisitSwitchExpression(BoundSwitchExpression node)
SetState(endState);
return node;
}
+
+ public override BoundNode VisitLoweredSwitchExpression(BoundLoweredSwitchExpression node)
+ {
+ var initialState = this.State.Clone();
+ var endState = UnreachableState();
+ VisitStatements(node.Statements);
+ foreach (var switchArm in node.SwitchArms)
+ {
+ SetState(initialState.Clone());
+ VisitStatements(switchArm.Statements);
+ VisitRvalue(switchArm.Value);
+ Join(ref endState, ref this.State);
+ }
+
+ SetState(endState);
+ return node;
+ }
}
}
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index 631541624abc9..2fcfa2e292515 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -149,6 +149,8 @@ internal enum BoundKind : byte
SwitchExpressionArm,
UnconvertedSwitchExpression,
ConvertedSwitchExpression,
+ LoweredSwitchExpression,
+ LoweredSwitchExpressionArm,
DecisionDag,
EvaluationDecisionDagNode,
TestDecisionDagNode,
@@ -4969,6 +4971,77 @@ public BoundConvertedSwitchExpression Update(TypeSymbol? naturalTypeOpt, bool wa
}
}
+ internal sealed partial class BoundLoweredSwitchExpression : BoundExpression
+ {
+ public BoundLoweredSwitchExpression(SyntaxNode syntax, ImmutableArray statements, ImmutableArray switchArms, TypeSymbol type, bool hasErrors = false)
+ : base(BoundKind.LoweredSwitchExpression, syntax, type, hasErrors || statements.HasErrors() || switchArms.HasErrors())
+ {
+
+ RoslynDebug.Assert(!statements.IsDefault, "Field 'statements' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
+ RoslynDebug.Assert(!switchArms.IsDefault, "Field 'switchArms' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
+ RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+ this.Statements = statements;
+ this.SwitchArms = switchArms;
+ Validate();
+ }
+
+ [Conditional("DEBUG")]
+ private partial void Validate();
+
+ public new TypeSymbol Type => base.Type!;
+ public ImmutableArray Statements { get; }
+ public ImmutableArray SwitchArms { get; }
+
+ [DebuggerStepThrough]
+ public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitLoweredSwitchExpression(this);
+
+ public BoundLoweredSwitchExpression Update(ImmutableArray statements, ImmutableArray switchArms, TypeSymbol type)
+ {
+ if (statements != this.Statements || switchArms != this.SwitchArms || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+ {
+ var result = new BoundLoweredSwitchExpression(this.Syntax, statements, switchArms, type, this.HasErrors);
+ result.CopyAttributes(this);
+ return result;
+ }
+ return this;
+ }
+ }
+
+ internal sealed partial class BoundLoweredSwitchExpressionArm : BoundNode
+ {
+ public BoundLoweredSwitchExpressionArm(SyntaxNode syntax, ImmutableArray locals, ImmutableArray statements, BoundExpression value, bool hasErrors = false)
+ : base(BoundKind.LoweredSwitchExpressionArm, syntax, hasErrors || statements.HasErrors() || value.HasErrors())
+ {
+
+ RoslynDebug.Assert(!locals.IsDefault, "Field 'locals' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
+ RoslynDebug.Assert(!statements.IsDefault, "Field 'statements' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
+ RoslynDebug.Assert(value is object, "Field 'value' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+ this.Locals = locals;
+ this.Statements = statements;
+ this.Value = value;
+ }
+
+ public ImmutableArray Locals { get; }
+ public ImmutableArray Statements { get; }
+ public BoundExpression Value { get; }
+
+ [DebuggerStepThrough]
+ public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitLoweredSwitchExpressionArm(this);
+
+ public BoundLoweredSwitchExpressionArm Update(ImmutableArray locals, ImmutableArray statements, BoundExpression value)
+ {
+ if (locals != this.Locals || statements != this.Statements || value != this.Value)
+ {
+ var result = new BoundLoweredSwitchExpressionArm(this.Syntax, locals, statements, value, this.HasErrors);
+ result.CopyAttributes(this);
+ return result;
+ }
+ return this;
+ }
+ }
+
internal sealed partial class BoundDecisionDag : BoundNode
{
public BoundDecisionDag(SyntaxNode syntax, BoundDecisionDagNode rootNode, bool hasErrors = false)
@@ -9093,6 +9166,10 @@ internal R VisitInternal(BoundNode node, A arg)
return VisitUnconvertedSwitchExpression((BoundUnconvertedSwitchExpression)node, arg);
case BoundKind.ConvertedSwitchExpression:
return VisitConvertedSwitchExpression((BoundConvertedSwitchExpression)node, arg);
+ case BoundKind.LoweredSwitchExpression:
+ return VisitLoweredSwitchExpression((BoundLoweredSwitchExpression)node, arg);
+ case BoundKind.LoweredSwitchExpressionArm:
+ return VisitLoweredSwitchExpressionArm((BoundLoweredSwitchExpressionArm)node, arg);
case BoundKind.DecisionDag:
return VisitDecisionDag((BoundDecisionDag)node, arg);
case BoundKind.EvaluationDecisionDagNode:
@@ -9436,6 +9513,8 @@ internal abstract partial class BoundTreeVisitor
public virtual R VisitSwitchExpressionArm(BoundSwitchExpressionArm node, A arg) => this.DefaultVisit(node, arg);
public virtual R VisitUnconvertedSwitchExpression(BoundUnconvertedSwitchExpression node, A arg) => this.DefaultVisit(node, arg);
public virtual R VisitConvertedSwitchExpression(BoundConvertedSwitchExpression node, A arg) => this.DefaultVisit(node, arg);
+ public virtual R VisitLoweredSwitchExpression(BoundLoweredSwitchExpression node, A arg) => this.DefaultVisit(node, arg);
+ public virtual R VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node, A arg) => this.DefaultVisit(node, arg);
public virtual R VisitDecisionDag(BoundDecisionDag node, A arg) => this.DefaultVisit(node, arg);
public virtual R VisitEvaluationDecisionDagNode(BoundEvaluationDecisionDagNode node, A arg) => this.DefaultVisit(node, arg);
public virtual R VisitTestDecisionDagNode(BoundTestDecisionDagNode node, A arg) => this.DefaultVisit(node, arg);
@@ -9672,6 +9751,8 @@ internal abstract partial class BoundTreeVisitor
public virtual BoundNode? VisitSwitchExpressionArm(BoundSwitchExpressionArm node) => this.DefaultVisit(node);
public virtual BoundNode? VisitUnconvertedSwitchExpression(BoundUnconvertedSwitchExpression node) => this.DefaultVisit(node);
public virtual BoundNode? VisitConvertedSwitchExpression(BoundConvertedSwitchExpression node) => this.DefaultVisit(node);
+ public virtual BoundNode? VisitLoweredSwitchExpression(BoundLoweredSwitchExpression node) => this.DefaultVisit(node);
+ public virtual BoundNode? VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node) => this.DefaultVisit(node);
public virtual BoundNode? VisitDecisionDag(BoundDecisionDag node) => this.DefaultVisit(node);
public virtual BoundNode? VisitEvaluationDecisionDagNode(BoundEvaluationDecisionDagNode node) => this.DefaultVisit(node);
public virtual BoundNode? VisitTestDecisionDagNode(BoundTestDecisionDagNode node) => this.DefaultVisit(node);
@@ -10281,6 +10362,18 @@ internal abstract partial class BoundTreeWalker : BoundTreeVisitor
this.VisitList(node.SwitchArms);
return null;
}
+ public override BoundNode? VisitLoweredSwitchExpression(BoundLoweredSwitchExpression node)
+ {
+ this.VisitList(node.Statements);
+ this.VisitList(node.SwitchArms);
+ return null;
+ }
+ public override BoundNode? VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node)
+ {
+ this.VisitList(node.Statements);
+ this.Visit(node.Value);
+ return null;
+ }
public override BoundNode? VisitDecisionDag(BoundDecisionDag node)
{
this.Visit(node.RootNode);
@@ -11540,6 +11633,19 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
TypeSymbol? type = this.VisitType(node.Type);
return node.Update(naturalTypeOpt, node.WasTargetTyped, expression, switchArms, reachabilityDecisionDag, node.DefaultLabel, node.ReportedNotExhaustive, type);
}
+ public override BoundNode? VisitLoweredSwitchExpression(BoundLoweredSwitchExpression node)
+ {
+ ImmutableArray statements = this.VisitList(node.Statements);
+ ImmutableArray switchArms = this.VisitList(node.SwitchArms);
+ TypeSymbol? type = this.VisitType(node.Type);
+ return node.Update(statements, switchArms, type);
+ }
+ public override BoundNode? VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node)
+ {
+ ImmutableArray statements = this.VisitList(node.Statements);
+ BoundExpression value = (BoundExpression)this.Visit(node.Value);
+ return node.Update(node.Locals, statements, value);
+ }
public override BoundNode? VisitDecisionDag(BoundDecisionDag node)
{
BoundDecisionDagNode rootNode = (BoundDecisionDagNode)this.Visit(node.RootNode);
@@ -13659,6 +13765,32 @@ public NullabilityRewriter(ImmutableDictionary statements = this.VisitList(node.Statements);
+ ImmutableArray switchArms = this.VisitList(node.SwitchArms);
+ BoundLoweredSwitchExpression updatedNode;
+
+ if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
+ {
+ updatedNode = node.Update(statements, switchArms, infoAndType.Type!);
+ updatedNode.TopLevelNullability = infoAndType.Info;
+ }
+ else
+ {
+ updatedNode = node.Update(statements, switchArms, node.Type);
+ }
+ return updatedNode;
+ }
+
+ public override BoundNode? VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node)
+ {
+ ImmutableArray locals = GetUpdatedArray(node, node.Locals);
+ ImmutableArray statements = this.VisitList(node.Statements);
+ BoundExpression value = (BoundExpression)this.Visit(node.Value);
+ return node.Update(locals, statements, value);
+ }
+
public override BoundNode? VisitDagDeconstructEvaluation(BoundDagDeconstructEvaluation node)
{
MethodSymbol deconstructMethod = GetUpdatedSymbol(node, node.DeconstructMethod);
@@ -16097,6 +16229,23 @@ private BoundTreeDumperNodeProducer()
new TreeDumperNode("hasErrors", node.HasErrors, null)
}
);
+ public override TreeDumperNode VisitLoweredSwitchExpression(BoundLoweredSwitchExpression node, object? arg) => new TreeDumperNode("loweredSwitchExpression", null, new TreeDumperNode[]
+ {
+ new TreeDumperNode("statements", null, from x in node.Statements select Visit(x, null)),
+ new TreeDumperNode("switchArms", null, from x in node.SwitchArms select Visit(x, null)),
+ new TreeDumperNode("type", node.Type, null),
+ new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
+ new TreeDumperNode("hasErrors", node.HasErrors, null)
+ }
+ );
+ public override TreeDumperNode VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node, object? arg) => new TreeDumperNode("loweredSwitchExpressionArm", null, new TreeDumperNode[]
+ {
+ new TreeDumperNode("locals", node.Locals, null),
+ new TreeDumperNode("statements", null, from x in node.Statements select Visit(x, null)),
+ new TreeDumperNode("value", null, new TreeDumperNode[] { Visit(node.Value, null) }),
+ new TreeDumperNode("hasErrors", node.HasErrors, null)
+ }
+ );
public override TreeDumperNode VisitDecisionDag(BoundDecisionDag node, object? arg) => new TreeDumperNode("decisionDag", null, new TreeDumperNode[]
{
new TreeDumperNode("rootNode", null, new TreeDumperNode[] { Visit(node.RootNode, null) }),
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.DecisionDagRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.DecisionDagRewriter.cs
index 830adb8f55a26..8ad3001552e7e 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.DecisionDagRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.DecisionDagRewriter.cs
@@ -337,7 +337,7 @@ public override BoundNode VisitDynamicIndexerAccess(BoundDynamicIndexerAccess no
protected BoundDecisionDag ShareTempsIfPossibleAndEvaluateInput(
BoundDecisionDag decisionDag,
BoundExpression loweredSwitchGoverningExpression,
- ArrayBuilder result,
+ Action addCode,
out BoundExpression savedInputExpression)
{
// Note that a when-clause can contain an assignment to a
@@ -352,14 +352,14 @@ protected BoundDecisionDag ShareTempsIfPossibleAndEvaluateInput(
if (canShareTemps)
{
- decisionDag = ShareTempsAndEvaluateInput(loweredSwitchGoverningExpression, decisionDag, expr => result.Add(_factory.ExpressionStatement(expr)), out savedInputExpression);
+ decisionDag = ShareTempsAndEvaluateInput(loweredSwitchGoverningExpression, decisionDag, addCode, out savedInputExpression);
}
else
{
// assign the input expression to its temp.
BoundExpression inputTemp = _tempAllocator.GetTemp(BoundDagTemp.ForOriginalInput(loweredSwitchGoverningExpression));
Debug.Assert(inputTemp != loweredSwitchGoverningExpression);
- result.Add(_factory.Assignment(inputTemp, loweredSwitchGoverningExpression));
+ addCode(_factory.AssignmentExpression(inputTemp, loweredSwitchGoverningExpression));
savedInputExpression = inputTemp;
}
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
index bdf567dc9f3e0..3659d4f5206e2 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
@@ -97,7 +97,7 @@ private BoundStatement LowerSwitchStatement(BoundSwitchStatement node)
// Evaluate the input and set up sharing for dag temps with user variables
BoundDecisionDag decisionDag = ShareTempsIfPossibleAndEvaluateInput(
node.GetDecisionDagForLowering(_factory.Compilation),
- loweredSwitchGoverningExpression, result, out _);
+ loweredSwitchGoverningExpression, expr => result.Add(_factory.ExpressionStatement(expr)), out _);
// In a switch statement, there is a hidden sequence point after evaluating the input at the start of
// the code to handle the decision dag. This is necessary so that jumps back from a `when` clause into
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_SwitchExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_SwitchExpression.cs
index 922ea77aa9675..1096739fb3123 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_SwitchExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_SwitchExpression.cs
@@ -16,35 +16,44 @@ internal partial class LocalRewriter
{
public override BoundNode VisitConvertedSwitchExpression(BoundConvertedSwitchExpression node)
{
- // The switch expression is lowered to an expression that involves the use of side-effects
- // such as jumps and labels, therefore it is represented by a BoundSpillSequence and
- // the resulting nodes will need to be "spilled" to move such statements to the top
- // level (i.e. into the enclosing statement list).
- this._needsSpilling = true;
return SwitchExpressionLocalRewriter.Rewrite(this, node);
}
private sealed class SwitchExpressionLocalRewriter : BaseSwitchLocalRewriter
{
- private SwitchExpressionLocalRewriter(BoundConvertedSwitchExpression node, LocalRewriter localRewriter)
+ private SwitchExpressionLocalRewriter(BoundConvertedSwitchExpression node, LocalRewriter localRewriter, bool generateInstrumentation)
: base(node.Syntax, localRewriter, node.SwitchArms.SelectAsArray(arm => arm.Syntax),
- generateInstrumentation: !node.WasCompilerGenerated && localRewriter.Instrument)
+ generateInstrumentation: generateInstrumentation)
{
}
public static BoundExpression Rewrite(LocalRewriter localRewriter, BoundConvertedSwitchExpression node)
{
- var rewriter = new SwitchExpressionLocalRewriter(node, localRewriter);
- BoundExpression result = rewriter.LowerSwitchExpression(node);
- rewriter.Free();
- return result;
+ var generateInstrumentation = !node.WasCompilerGenerated && localRewriter.Instrument;
+ // When compiling for Debug (not Release), we produce the most detailed sequence points.
+ var produceDetailedSequencePoints = generateInstrumentation && localRewriter._compilation.Options.OptimizationLevel != OptimizationLevel.Release;
+
+ if (produceDetailedSequencePoints)
+ {
+ localRewriter._needsSpilling = true;
+ var rewriter = new SwitchExpressionLocalRewriter(node, localRewriter, generateInstrumentation: true);
+ BoundExpression result = rewriter.LowerSwitchExpressionForDebug(node);
+ rewriter.Free();
+ return result;
+ }
+ else
+ {
+ var rewriter = new SwitchExpressionLocalRewriter(node, localRewriter, generateInstrumentation: false);
+ BoundExpression result = rewriter.LowerSwitchExpressionForRelease(node);
+ rewriter.Free();
+ return result;
+ }
}
- private BoundExpression LowerSwitchExpression(BoundConvertedSwitchExpression node)
+ private BoundExpression LowerSwitchExpressionForDebug(BoundConvertedSwitchExpression node)
{
- // When compiling for Debug (not Release), we produce the most detailed sequence points.
- var produceDetailedSequencePoints =
- GenerateInstrumentation && _localRewriter._compilation.Options.OptimizationLevel != OptimizationLevel.Release;
+ const bool produceDetailedSequencePoints = true;
+
_factory.Syntax = node.Syntax;
var result = ArrayBuilder.GetInstance();
var outerVariables = ArrayBuilder.GetInstance();
@@ -52,7 +61,7 @@ private BoundExpression LowerSwitchExpression(BoundConvertedSwitchExpression nod
BoundDecisionDag decisionDag = ShareTempsIfPossibleAndEvaluateInput(
node.GetDecisionDagForLowering(_factory.Compilation, out LabelSymbol? defaultLabel),
- loweredSwitchGoverningExpression, result, out BoundExpression savedInputExpression);
+ loweredSwitchGoverningExpression, expr => result.Add(_factory.ExpressionStatement(expr)), out BoundExpression savedInputExpression);
Debug.Assert(savedInputExpression != null);
@@ -123,16 +132,8 @@ private BoundExpression LowerSwitchExpression(BoundConvertedSwitchExpression nod
result.Add(_factory.Label(defaultLabel));
if (produceDetailedSequencePoints)
result.Add(new BoundRestorePreviousSequencePoint(node.Syntax, restorePointForSwitchBody));
- var objectType = _factory.SpecialType(SpecialType.System_Object);
- var throwCall =
- (implicitConversionExists(savedInputExpression, objectType) &&
- _factory.WellKnownMember(WellKnownMember.System_Runtime_CompilerServices_SwitchExpressionException__ctorObject, isOptional: true) is MethodSymbol)
- ? ConstructThrowSwitchExpressionExceptionHelperCall(_factory, _factory.Convert(objectType, savedInputExpression)) :
- (_factory.WellKnownMember(WellKnownMember.System_Runtime_CompilerServices_SwitchExpressionException__ctor, isOptional: true) is MethodSymbol)
- ? ConstructThrowSwitchExpressionExceptionParameterlessHelperCall(_factory) :
- ConstructThrowInvalidOperationExceptionHelperCall(_factory);
-
- result.Add(throwCall);
+ BoundExpression throwCall = ConstructThrowHelperCall(savedInputExpression);
+ result.Add(_factory.HiddenSequencePoint(_factory.ExpressionStatement(throwCall)));
}
if (GenerateInstrumentation)
@@ -144,6 +145,24 @@ private BoundExpression LowerSwitchExpression(BoundConvertedSwitchExpression nod
outerVariables.Add(resultTemp);
outerVariables.AddRange(_tempAllocator.AllTemps());
return _factory.SpillSequence(outerVariables.ToImmutableAndFree(), result.ToImmutableAndFree(), _factory.Local(resultTemp));
+ }
+
+ private BoundExpression ConstructThrowHelperCall(BoundExpression savedInputExpression)
+ {
+ var objectType = _factory.SpecialType(SpecialType.System_Object);
+ if (implicitConversionExists(savedInputExpression, objectType) &&
+ _factory.WellKnownMember(WellKnownMember.System_Runtime_CompilerServices_SwitchExpressionException__ctorObject, isOptional: true) is MethodSymbol)
+ {
+ return ConstructThrowSwitchExpressionExceptionHelperCall(_factory, _factory.Convert(objectType, savedInputExpression));
+ }
+ else if (_factory.WellKnownMember(WellKnownMember.System_Runtime_CompilerServices_SwitchExpressionException__ctor, isOptional: true) is MethodSymbol)
+ {
+ return ConstructThrowSwitchExpressionExceptionParameterlessHelperCall(_factory);
+ }
+ else
+ {
+ return ConstructThrowInvalidOperationExceptionHelperCall(_factory);
+ }
bool implicitConversionExists(BoundExpression expression, TypeSymbol type)
{
@@ -153,7 +172,69 @@ bool implicitConversionExists(BoundExpression expression, TypeSymbol type)
}
}
- private static BoundStatement ConstructThrowSwitchExpressionExceptionHelperCall(SyntheticBoundNodeFactory factory, BoundExpression unmatchedValue)
+ private BoundExpression LowerSwitchExpressionForRelease(BoundConvertedSwitchExpression node)
+ {
+ var outerVariables = ArrayBuilder.GetInstance();
+ var loweredSwitchGoverningExpression = _localRewriter.VisitExpression(node.Expression);
+ var sideEffectsBuilder = ArrayBuilder.GetInstance();
+
+ BoundDecisionDag decisionDag = ShareTempsIfPossibleAndEvaluateInput(
+ node.GetDecisionDagForLowering(_factory.Compilation, out LabelSymbol? defaultLabel),
+ loweredSwitchGoverningExpression, sideEffectsBuilder.Add, out BoundExpression savedInputExpression);
+
+ Debug.Assert(savedInputExpression != null);
+
+ // lower the decision dag.
+ (ImmutableArray loweredDag, ImmutableDictionary> switchSections) =
+ LowerDecisionDag(decisionDag);
+
+ if (_whenNodeIdentifierLocal is not null)
+ {
+ outerVariables.Add(_whenNodeIdentifierLocal);
+ }
+
+ // Lower each switch expression arm
+ var switchArmsBuilder = ArrayBuilder.GetInstance(node.SwitchArms.Length + (defaultLabel is null ? 0 : 1));
+ foreach (BoundSwitchExpressionArm arm in node.SwitchArms)
+ {
+ _factory.Syntax = arm.Syntax;
+ ImmutableArray statements = switchSections[arm.Syntax];
+ BoundExpression loweredValue = _localRewriter.VisitExpression(arm.Value);
+
+ // Lifetime of these locals is expanded to the entire switch body, as it is possible to
+ // share them as temps in the decision dag.
+ outerVariables.AddRange(arm.Locals);
+ switchArmsBuilder.Add(new BoundLoweredSwitchExpressionArm(
+ arm.Syntax, arm.Locals, statements.Add(_factory.Label(arm.Label)), loweredValue));
+ }
+
+ _factory.Syntax = node.Syntax;
+ if (defaultLabel is not null)
+ {
+ BoundExpression throwCall = ConstructThrowHelperCall(savedInputExpression);
+ BoundStatement labelStatement = _factory.Label(defaultLabel);
+ switchArmsBuilder.Add(new BoundLoweredSwitchExpressionArm(
+ syntax: node.Syntax,
+ locals: ImmutableArray.Empty,
+ statements: ImmutableArray.Create(labelStatement),
+ value: _factory.Sequence(
+ locals: ImmutableArray.Empty,
+ sideEffects: ImmutableArray.Create(throwCall),
+ result: _factory.Default(node.Type))));
+ }
+
+ outerVariables.AddRange(_tempAllocator.AllTemps());
+ return _factory.Sequence(
+ outerVariables.ToImmutableAndFree(),
+ sideEffectsBuilder.ToImmutableAndFree(),
+ new BoundLoweredSwitchExpression(
+ syntax: node.Syntax,
+ statements: loweredDag,
+ switchArmsBuilder.ToImmutableAndFree(),
+ type: node.Type));
+ }
+
+ private static BoundExpression ConstructThrowSwitchExpressionExceptionHelperCall(SyntheticBoundNodeFactory factory, BoundExpression unmatchedValue)
{
Debug.Assert(factory.ModuleBuilderOpt is not null);
var module = factory.ModuleBuilderOpt;
@@ -161,14 +242,13 @@ private static BoundStatement ConstructThrowSwitchExpressionExceptionHelperCall(
var diagnostics = factory.Diagnostics.DiagnosticBag;
Debug.Assert(diagnostics is not null);
var throwSwitchExpressionExceptionMethod = module.EnsureThrowSwitchExpressionExceptionExists(diagnosticSyntax, factory, diagnostics);
- var call = factory.Call(
+ return factory.Call(
receiver: null,
throwSwitchExpressionExceptionMethod,
arg0: unmatchedValue);
- return factory.HiddenSequencePoint(factory.ExpressionStatement(call));
}
- private static BoundStatement ConstructThrowSwitchExpressionExceptionParameterlessHelperCall(SyntheticBoundNodeFactory factory)
+ private static BoundExpression ConstructThrowSwitchExpressionExceptionParameterlessHelperCall(SyntheticBoundNodeFactory factory)
{
Debug.Assert(factory.ModuleBuilderOpt is not null);
var module = factory.ModuleBuilderOpt!;
@@ -176,13 +256,12 @@ private static BoundStatement ConstructThrowSwitchExpressionExceptionParameterle
var diagnostics = factory.Diagnostics.DiagnosticBag;
Debug.Assert(diagnostics is not null);
var throwSwitchExpressionExceptionMethod = module.EnsureThrowSwitchExpressionExceptionParameterlessExists(diagnosticSyntax, factory, diagnostics);
- var call = factory.Call(
+ return factory.Call(
receiver: null,
throwSwitchExpressionExceptionMethod);
- return factory.HiddenSequencePoint(factory.ExpressionStatement(call));
}
- private static BoundStatement ConstructThrowInvalidOperationExceptionHelperCall(SyntheticBoundNodeFactory factory)
+ private static BoundExpression ConstructThrowInvalidOperationExceptionHelperCall(SyntheticBoundNodeFactory factory)
{
Debug.Assert(factory.ModuleBuilderOpt is not null);
var module = factory.ModuleBuilderOpt!;
@@ -190,10 +269,9 @@ private static BoundStatement ConstructThrowInvalidOperationExceptionHelperCall(
var diagnostics = factory.Diagnostics.DiagnosticBag;
Debug.Assert(diagnostics is not null);
var throwMethod = module.EnsureThrowInvalidOperationExceptionExists(diagnosticSyntax, factory, diagnostics);
- var call = factory.Call(
+ return factory.Call(
receiver: null,
throwMethod);
- return factory.HiddenSequencePoint(factory.ExpressionStatement(call));
}
}
}
diff --git a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
index 49236fa2a3a89..47a1af74e2d56 100644
--- a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
@@ -124,6 +124,14 @@ private ImmutableArray RewriteLocals(ImmutableArray lo
return newLocals.ToImmutableAndFree();
}
+ public override BoundNode VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node)
+ {
+ return node.Update(
+ RewriteLocals(node.Locals),
+ VisitList(node.Statements),
+ (BoundExpression)Visit(node.Value));
+ }
+
public override BoundNode VisitCatchBlock(BoundCatchBlock node)
{
if (!node.Locals.IsDefaultOrEmpty)
diff --git a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
index e7e37a01f8a69..db5f97526a88c 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
@@ -718,6 +718,7 @@ public override BoundNode VisitCatchBlock(BoundCatchBlock node)
Debug.Assert(builder.Value is null);
locals = locals.AddRange(builder.GetLocals());
exceptionFilterPrologueOpt = new BoundStatementList(node.Syntax, builder.GetStatements());
+ builder.Free();
}
BoundBlock body = (BoundBlock)this.Visit(node.Body);
@@ -737,6 +738,72 @@ public override BoundNode DefaultVisit(BoundNode node)
#region Expression Visitors
+ public override BoundNode VisitLoweredSwitchExpressionArm(BoundLoweredSwitchExpressionArm node)
+ {
+ var statements = VisitList(node.Statements);
+ BoundSpillSequenceBuilder valueBuilder = null;
+ var value = VisitExpression(ref valueBuilder, node.Value);
+ if (valueBuilder is null && statements == node.Statements)
+ {
+ return node.Update(node.Locals, statements, value);
+ }
+
+ var builder = new BoundSpillSequenceBuilder(node.Syntax);
+ builder.AddStatements(statements);
+ builder.Include(valueBuilder);
+ return builder.Update(value);
+ }
+
+ public override BoundNode VisitLoweredSwitchExpression(BoundLoweredSwitchExpression node)
+ {
+ var statements = VisitList(node.Statements);
+ Debug.Assert(statements == node.Statements);
+
+ var switchArms = ImmutableArray.CastUp(node.SwitchArms);
+ var rewrittenArms = VisitList(switchArms);
+ if (rewrittenArms == switchArms)
+ {
+ return node;
+ }
+
+ Debug.Assert(rewrittenArms.Length == switchArms.Length);
+ int count = rewrittenArms.Length;
+
+ _F.Syntax = node.Syntax;
+ var tmp = _F.SynthesizedLocal(node.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax);
+ var switchBuilder = new BoundSpillSequenceBuilder(node.Syntax);
+ var switchArmsBuilder = ArrayBuilder.GetInstance(count);
+
+ for (int i = 0; i < count; i++)
+ {
+ switch (rewrittenArms[i])
+ {
+ case BoundLoweredSwitchExpressionArm visitedArm:
+ switchArmsBuilder.Add(visitedArm.Update(
+ visitedArm.Locals, visitedArm.Statements,
+ _F.AssignmentExpression(_F.Local(tmp), visitedArm.Value)));
+ break;
+
+ case BoundSpillSequenceBuilder newBuilder:
+ var switchArm = node.SwitchArms[i];
+ switchBuilder.AddLocals(newBuilder.GetLocals());
+ switchArmsBuilder.Add(switchArm.Update(
+ switchArm.Locals, newBuilder.GetStatements(),
+ _F.AssignmentExpression(_F.Local(tmp), newBuilder.Value)));
+ newBuilder.Free();
+ break;
+
+ case var v:
+ throw ExceptionUtilities.UnexpectedValue(v);
+ }
+ }
+
+ var newNode = node.Update(statements, switchArmsBuilder.ToImmutableAndFree(), node.Type);
+ switchBuilder.AddStatement(_F.ExpressionStatement(newNode));
+ switchBuilder.AddLocal(tmp);
+ return switchBuilder.Update(_F.Local(tmp));
+ }
+
#if DEBUG
public override BoundNode VisitLoweredIsPatternExpression(BoundLoweredIsPatternExpression node)
{
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncSpillTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncSpillTests.cs
index 0a7f649ff7d64..f0adcdc6a5495 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncSpillTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncSpillTests.cs
@@ -3903,9 +3903,12 @@ public ref struct S
Diagnostic(ErrorCode.ERR_SpecialByRefInLambda, "F").WithArguments("S").WithLocation(9, 17)
);
CreateCompilation(source, options: TestOptions.ReleaseDll).VerifyDiagnostics().VerifyEmitDiagnostics(
- // (9,17): error CS4013: Instance of type 'S' cannot be used inside a nested function, query expression, iterator block or async method
- // Q { F: { P1: true } } when await c => r, // error: cached Q.F is alive
- Diagnostic(ErrorCode.ERR_SpecialByRefInLambda, "F").WithArguments("S").WithLocation(9, 17)
+ Diagnostic(ErrorCode.ERR_ByRefTypeAndAwait, @"o switch
+ {
+ Q { F: { P1: true } } when await c => r, // error: cached Q.F is alive
+ Q { F: { P2: true } } => 2,
+ _ => 3,
+ }").WithArguments("S").WithLocation(7, 16)
);
}
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenCheckedTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenCheckedTests.cs
index 3e4a8bfc0f93e..b652f879b9173 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenCheckedTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenCheckedTests.cs
@@ -2851,39 +2851,31 @@ public static int AddInSwitchExpression2(int x, int y, bool condition)
verifier.VerifyIL("C.AddInSwitchExpression", @"
{
- // Code size 13 (0xd)
+ // Code size 9 (0x9)
.maxstack 2
- .locals init (int V_0)
IL_0000: ldarg.2
- IL_0001: brfalse.s IL_0009
+ IL_0001: brfalse.s IL_0007
IL_0003: ldarg.0
IL_0004: ldarg.1
IL_0005: add.ovf
- IL_0006: stloc.0
- IL_0007: br.s IL_000b
- IL_0009: ldnull
- IL_000a: throw
- IL_000b: ldloc.0
- IL_000c: ret
+ IL_0006: ret
+ IL_0007: ldnull
+ IL_0008: throw
}
");
verifier.VerifyIL("C.AddInSwitchExpression2", @"
{
- // Code size 13 (0xd)
+ // Code size 9 (0x9)
.maxstack 2
- .locals init (int V_0)
IL_0000: ldarg.2
- IL_0001: brfalse.s IL_0009
+ IL_0001: brfalse.s IL_0007
IL_0003: ldarg.0
IL_0004: ldarg.1
IL_0005: add.ovf
- IL_0006: stloc.0
- IL_0007: br.s IL_000b
- IL_0009: ldnull
- IL_000a: throw
- IL_000b: ldloc.0
- IL_000c: ret
+ IL_0006: ret
+ IL_0007: ldnull
+ IL_0008: throw
}
");
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs
index 73f912f5b7d23..a2f6a91da7cf7 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs
@@ -12338,33 +12338,26 @@ public void SwitchExpression_01()
";
var verifier = CompileAndVerifyFunctionPointers(code, expectedOutput: "true");
- verifier.VerifyIL("", @"
+ verifier.VerifyIL("", """
{
- // Code size 36 (0x24)
+ // Code size 31 (0x1f)
.maxstack 2
- .locals init (delegate* V_0, //ptr
- delegate* V_1,
- string V_2,
- delegate* V_3)
- IL_0000: ldftn ""void Program.<$>g__M|0_0(string)""
- IL_0006: stloc.0
- IL_0007: ldc.i4.1
- IL_0008: ldloc.0
- IL_0009: stloc.1
- IL_000a: brfalse.s IL_0014
- IL_000c: ldstr ""true""
- IL_0011: stloc.2
- IL_0012: br.s IL_001a
- IL_0014: ldstr ""false""
- IL_0019: stloc.2
- IL_001a: ldloc.1
- IL_001b: stloc.3
- IL_001c: ldloc.2
- IL_001d: ldloc.3
- IL_001e: calli ""delegate*""
- IL_0023: ret
+ .locals init (bool V_0, //b
+ delegate* V_1)
+ IL_0000: ldftn "void Program.<$>g__M|0_0(string)"
+ IL_0006: ldc.i4.1
+ IL_0007: stloc.0
+ IL_0008: stloc.1
+ IL_0009: ldloc.0
+ IL_000a: brfalse.s IL_0013
+ IL_000c: ldstr "true"
+ IL_0011: br.s IL_0018
+ IL_0013: ldstr "false"
+ IL_0018: ldloc.1
+ IL_0019: calli "delegate*"
+ IL_001e: ret
}
-");
+""");
}
[Fact, WorkItem(55394, "https://github.com/dotnet/roslyn/issues/55394")]
@@ -12386,29 +12379,25 @@ public void SwitchExpression_02()
var verifier = CompileAndVerifyFunctionPointers(code, expectedOutput: "true");
verifier.VerifyIL("", @"
{
- // Code size 37 (0x25)
+ // Code size 34 (0x22)
.maxstack 2
.locals init (delegate* V_0, //ptr1
delegate* V_1, //ptr2
- delegate* V_2,
- delegate* V_3)
+ delegate* V_2)
IL_0000: ldftn ""void Program.<$>g__M1|0_0(string)""
IL_0006: stloc.0
IL_0007: ldftn ""void Program.<$>g__M2|0_1(string)""
IL_000d: stloc.1
IL_000e: ldc.i4.1
- IL_000f: brfalse.s IL_0015
+ IL_000f: brfalse.s IL_0014
IL_0011: ldloc.0
- IL_0012: stloc.2
- IL_0013: br.s IL_0017
- IL_0015: ldloc.1
- IL_0016: stloc.2
- IL_0017: ldloc.2
- IL_0018: stloc.3
- IL_0019: ldstr ""true""
- IL_001e: ldloc.3
- IL_001f: calli ""delegate*""
- IL_0024: ret
+ IL_0012: br.s IL_0015
+ IL_0014: ldloc.1
+ IL_0015: stloc.2
+ IL_0016: ldstr ""true""
+ IL_001b: ldloc.2
+ IL_001c: calli ""delegate*""
+ IL_0021: ret
}
");
}
@@ -12432,29 +12421,25 @@ public void SwitchExpression_03()
var verifier = CompileAndVerifyFunctionPointers(code, expectedOutput: "true");
verifier.VerifyIL("", @"
{
- // Code size 37 (0x25)
+ // Code size 34 (0x22)
.maxstack 2
.locals init (delegate* V_0, //ptr1
delegate* V_1, //ptr2
- delegate* V_2,
- delegate* V_3)
+ delegate* V_2)
IL_0000: ldftn ""void Program.<$>g__M1|0_0(string)""
IL_0006: stloc.0
IL_0007: ldftn ""void Program.<$>g__M2|0_1(object)""
IL_000d: stloc.1
IL_000e: ldc.i4.1
- IL_000f: brfalse.s IL_0015
+ IL_000f: brfalse.s IL_0014
IL_0011: ldloc.0
- IL_0012: stloc.2
- IL_0013: br.s IL_0017
- IL_0015: ldloc.1
- IL_0016: stloc.2
- IL_0017: ldloc.2
- IL_0018: stloc.3
- IL_0019: ldstr ""true""
- IL_001e: ldloc.3
- IL_001f: calli ""delegate*""
- IL_0024: ret
+ IL_0012: br.s IL_0015
+ IL_0014: ldloc.1
+ IL_0015: stloc.2
+ IL_0016: ldstr ""true""
+ IL_001b: ldloc.2
+ IL_001c: calli ""delegate*""
+ IL_0021: ret
}
");
}
@@ -12478,14 +12463,12 @@ public void SwitchExpression_04()
var verifier = CompileAndVerifyFunctionPointers(code, expectedOutput: "true");
verifier.VerifyIL("", @"
{
- // Code size 57 (0x39)
+ // Code size 46 (0x2e)
.maxstack 2
.locals init (delegate* V_0, //ptr1
delegate* V_1, //ptr2
bool V_2, //b
- delegate* V_3,
- string V_4,
- delegate* V_5)
+ delegate* V_3)
IL_0000: ldftn ""void Program.<$>g__M1|0_0(string)""
IL_0006: stloc.0
IL_0007: ldftn ""void Program.<$>g__M2|0_1(string)""
@@ -12493,25 +12476,19 @@ .locals init (delegate* V_0, //ptr1
IL_000e: ldc.i4.1
IL_000f: stloc.2
IL_0010: ldloc.2
- IL_0011: brfalse.s IL_0017
+ IL_0011: brfalse.s IL_0016
IL_0013: ldloc.0
- IL_0014: stloc.3
- IL_0015: br.s IL_0019
- IL_0017: ldloc.1
- IL_0018: stloc.3
- IL_0019: ldloc.3
- IL_001a: ldloc.2
- IL_001b: brfalse.s IL_0026
- IL_001d: ldstr ""true""
- IL_0022: stloc.s V_4
- IL_0024: br.s IL_002d
- IL_0026: ldstr ""false""
- IL_002b: stloc.s V_4
- IL_002d: stloc.s V_5
- IL_002f: ldloc.s V_4
- IL_0031: ldloc.s V_5
- IL_0033: calli ""delegate*""
- IL_0038: ret
+ IL_0014: br.s IL_0017
+ IL_0016: ldloc.1
+ IL_0017: stloc.3
+ IL_0018: ldloc.2
+ IL_0019: brfalse.s IL_0022
+ IL_001b: ldstr ""true""
+ IL_0020: br.s IL_0027
+ IL_0022: ldstr ""false""
+ IL_0027: ldloc.3
+ IL_0028: calli ""delegate*""
+ IL_002d: ret
}
");
}
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenThrowTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenThrowTests.cs
index d655680930914..ec857508bb338 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenThrowTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenThrowTests.cs
@@ -366,22 +366,18 @@ static void M(bool c)
compilation.VerifyDiagnostics();
compilation.VerifyIL("C.M",
-@"
+"""
{
- // Code size 19 (0x13)
- .maxstack 1
- .locals init (System.Exception V_0)
- IL_0000: ldarg.0
- IL_0001: brfalse.s IL_000b
- IL_0003: newobj ""System.NullReferenceException..ctor()""
- IL_0008: stloc.0
- IL_0009: br.s IL_0011
- IL_000b: newobj ""System.ArgumentException..ctor()""
- IL_0010: stloc.0
- IL_0011: ldloc.0
- IL_0012: throw
+ // Code size 16 (0x10)
+ .maxstack 1
+ IL_0000: ldarg.0
+ IL_0001: brfalse.s IL_000a
+ IL_0003: newobj "System.NullReferenceException..ctor()"
+ IL_0008: br.s IL_000f
+ IL_000a: newobj "System.ArgumentException..ctor()"
+ IL_000f: throw
}
-");
+""");
}
[Fact]
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/PatternTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/PatternTests.cs
index a6085f5fdb588..21ac5f589996d 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/PatternTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/PatternTests.cs
@@ -1659,11 +1659,10 @@ public string M(Person p) {
var compVerifier = CompileAndVerify(compilation);
compVerifier.VerifyIL("C.M",
@"{
- // Code size 51 (0x33)
+ // Code size 45 (0x2d)
.maxstack 2
- .locals init (string V_0)
IL_0000: ldarg.1
- IL_0001: brfalse.s IL_002f
+ IL_0001: brfalse.s IL_002b
IL_0003: ldarg.1
IL_0004: callvirt ""string Person.Name.get""
IL_0009: ldstr ""Bill""
@@ -1671,18 +1670,14 @@ .locals init (string V_0)
IL_0013: brtrue.s IL_001f
IL_0015: ldarg.1
IL_0016: isinst ""Student""
- IL_001b: brtrue.s IL_0027
- IL_001d: br.s IL_002f
+ IL_001b: brtrue.s IL_0025
+ IL_001d: br.s IL_002b
IL_001f: ldstr ""Hey Bill!""
- IL_0024: stloc.0
- IL_0025: br.s IL_0031
- IL_0027: ldstr ""Hello student { name}!""
- IL_002c: stloc.0
- IL_002d: br.s IL_0031
- IL_002f: ldnull
- IL_0030: stloc.0
- IL_0031: ldloc.0
- IL_0032: ret
+ IL_0024: ret
+ IL_0025: ldstr ""Hello student { name}!""
+ IL_002a: ret
+ IL_002b: ldnull
+ IL_002c: ret
}");
}
@@ -2450,57 +2445,52 @@ .locals init (Door.DoorState V_0, //oldState
IL_003c: ret
}");
compVerifier.VerifyIL("Door.ChangeState1",
-@"{
- // Code size 71 (0x47)
+"""
+{
+ // Code size 61 (0x3d)
.maxstack 2
.locals init (Door.DoorState V_0,
- Door.DoorState V_1,
- Door.Action V_2)
+ Door.Action V_1)
IL_0000: ldarg.0
- IL_0001: stloc.1
+ IL_0001: stloc.0
IL_0002: ldarg.1
- IL_0003: stloc.2
- IL_0004: ldloc.1
+ IL_0003: stloc.1
+ IL_0004: ldloc.0
IL_0005: switch (
IL_0018,
IL_001e,
IL_0027)
- IL_0016: br.s IL_0043
- IL_0018: ldloc.2
+ IL_0016: br.s IL_003b
+ IL_0018: ldloc.1
IL_0019: ldc.i4.1
IL_001a: beq.s IL_002d
- IL_001c: br.s IL_0043
- IL_001e: ldloc.2
- IL_001f: brfalse.s IL_0031
- IL_0021: ldloc.2
+ IL_001c: br.s IL_003b
+ IL_001e: ldloc.1
+ IL_001f: brfalse.s IL_002f
+ IL_0021: ldloc.1
IL_0022: ldc.i4.2
- IL_0023: beq.s IL_0035
- IL_0025: br.s IL_0043
- IL_0027: ldloc.2
+ IL_0023: beq.s IL_0031
+ IL_0025: br.s IL_003b
+ IL_0027: ldloc.1
IL_0028: ldc.i4.3
- IL_0029: beq.s IL_003c
- IL_002b: br.s IL_0043
+ IL_0029: beq.s IL_0036
+ IL_002b: br.s IL_003b
IL_002d: ldc.i4.1
- IL_002e: stloc.0
- IL_002f: br.s IL_0045
- IL_0031: ldc.i4.0
- IL_0032: stloc.0
- IL_0033: br.s IL_0045
- IL_0035: ldarg.2
- IL_0036: brfalse.s IL_0043
- IL_0038: ldc.i4.2
- IL_0039: stloc.0
- IL_003a: br.s IL_0045
- IL_003c: ldarg.2
- IL_003d: brfalse.s IL_0043
- IL_003f: ldc.i4.1
- IL_0040: stloc.0
- IL_0041: br.s IL_0045
- IL_0043: ldarg.0
- IL_0044: stloc.0
- IL_0045: ldloc.0
- IL_0046: ret
-}");
+ IL_002e: ret
+ IL_002f: ldc.i4.0
+ IL_0030: ret
+ IL_0031: ldarg.2
+ IL_0032: brfalse.s IL_003b
+ IL_0034: ldc.i4.2
+ IL_0035: ret
+ IL_0036: ldarg.2
+ IL_0037: brfalse.s IL_003b
+ IL_0039: ldc.i4.1
+ IL_003a: ret
+ IL_003b: ldarg.0
+ IL_003c: ret
+}
+""");
}
[Fact]
@@ -2840,18 +2830,18 @@ public static void Main()
compilation.VerifyDiagnostics();
var compVerifier = CompileAndVerify(compilation, expectedOutput: "TrueFalse");
compVerifier.VerifyIL("C.Equals(object)",
-@"{
- // Code size 25 (0x19)
+"""
+{
+ // Code size 21 (0x15)
.maxstack 2
.locals init (C V_0, //x1
C V_1, //x2
- C V_2, //x3
- bool V_3)
+ C V_2) //x3
IL_0000: ldarg.1
- IL_0001: isinst ""C""
+ IL_0001: isinst "C"
IL_0006: stloc.0
IL_0007: ldloc.0
- IL_0008: brfalse.s IL_0015
+ IL_0008: brfalse.s IL_0013
IL_000a: ldloc.0
IL_000b: stloc.1
IL_000c: ldloc.1
@@ -2859,13 +2849,11 @@ .locals init (C V_0, //x1
IL_000e: ldloc.2
IL_000f: ldnull
IL_0010: cgt.un
- IL_0012: stloc.3
- IL_0013: br.s IL_0017
- IL_0015: ldc.i4.0
- IL_0016: stloc.3
- IL_0017: ldloc.3
- IL_0018: ret
-}");
+ IL_0012: ret
+ IL_0013: ldc.i4.0
+ IL_0014: ret
+}
+""");
}
[Fact, WorkItem(26387, "https://github.com/dotnet/roslyn/issues/26387")]
@@ -3593,23 +3581,19 @@ .locals init (bool V_0,
{
compVerifier.VerifyIL("Class1.M",
@"{
- // Code size 26 (0x1a)
+ // Code size 22 (0x16)
.maxstack 2
- .locals init (bool V_0)
IL_0000: ldarg.0
IL_0001: isinst ""int""
- IL_0006: brfalse.s IL_0016
+ IL_0006: brfalse.s IL_0014
IL_0008: ldarg.0
IL_0009: unbox.any ""int""
IL_000e: ldc.i4.s 42
- IL_0010: bne.un.s IL_0016
+ IL_0010: bne.un.s IL_0014
IL_0012: ldc.i4.1
- IL_0013: stloc.0
- IL_0014: br.s IL_0018
- IL_0016: ldc.i4.0
- IL_0017: stloc.0
- IL_0018: ldloc.0
- IL_0019: ret
+ IL_0013: ret
+ IL_0014: ldc.i4.0
+ IL_0015: ret
}");
}
}
@@ -4139,24 +4123,20 @@ .maxstack 2
IL_000b: ret
}
");
- compVerifier.VerifyIL("C.M3(string)", @"
+ compVerifier.VerifyIL("C.M3(string)", """
{
- // Code size 21 (0x15)
+ // Code size 17 (0x11)
.maxstack 2
- .locals init (bool V_0)
IL_0000: ldarg.0
- IL_0001: ldstr ""Frog""
- IL_0006: call ""bool string.op_Equality(string, string)""
- IL_000b: brfalse.s IL_0011
+ IL_0001: ldstr "Frog"
+ IL_0006: call "bool string.op_Equality(string, string)"
+ IL_000b: brfalse.s IL_000f
IL_000d: ldc.i4.1
- IL_000e: stloc.0
- IL_000f: br.s IL_0013
- IL_0011: ldc.i4.0
- IL_0012: stloc.0
- IL_0013: ldloc.0
- IL_0014: ret
+ IL_000e: ret
+ IL_000f: ldc.i4.0
+ IL_0010: ret
}
-");
+""");
}
[Fact, WorkItem(31494, "https://github.com/dotnet/roslyn/issues/31494")]
@@ -4173,9 +4153,8 @@ public void NoRedundantNullCheckForStringConstantPattern_02()
var compVerifier = CompileAndVerify(compilation);
compVerifier.VerifyIL("C.M1(string)", @"
{
- // Code size 40 (0x28)
+ // Code size 34 (0x22)
.maxstack 2
- .locals init (bool V_0)
IL_0000: ldarg.0
IL_0001: ldstr ""Frog""
IL_0006: call ""bool string.op_Equality(string, string)""
@@ -4183,18 +4162,14 @@ .locals init (bool V_0)
IL_000d: ldarg.0
IL_000e: ldstr ""Newt""
IL_0013: call ""bool string.op_Equality(string, string)""
- IL_0018: brtrue.s IL_0020
- IL_001a: br.s IL_0024
+ IL_0018: brtrue.s IL_001e
+ IL_001a: br.s IL_0020
IL_001c: ldc.i4.1
- IL_001d: stloc.0
- IL_001e: br.s IL_0026
- IL_0020: ldc.i4.1
- IL_0021: stloc.0
- IL_0022: br.s IL_0026
- IL_0024: ldc.i4.0
- IL_0025: stloc.0
- IL_0026: ldloc.0
- IL_0027: ret
+ IL_001d: ret
+ IL_001e: ldc.i4.1
+ IL_001f: ret
+ IL_0020: ldc.i4.0
+ IL_0021: ret
}
");
}
@@ -4413,16 +4388,15 @@ .locals init (System.Exception V_0, //e
{
compVerifier.VerifyIL("C.M(string)", @"
{
- // Code size 89 (0x59)
+ // Code size 85 (0x55)
.maxstack 2
.locals init (System.Exception V_0, //e
- bool V_1,
- string V_2)
+ string V_1)
.try
{
IL_0000: ldarg.0
IL_0001: call ""void C.T(string)""
- IL_0006: leave.s IL_0058
+ IL_0006: leave.s IL_0054
}
filter
{
@@ -4431,46 +4405,42 @@ .locals init (System.Exception V_0, //e
IL_000e: brtrue.s IL_0014
IL_0010: pop
IL_0011: ldc.i4.0
- IL_0012: br.s IL_0046
+ IL_0012: br.s IL_0042
IL_0014: stloc.0
IL_0015: ldloc.0
IL_0016: callvirt ""string System.Exception.Message.get""
- IL_001b: stloc.2
- IL_001c: ldloc.2
+ IL_001b: stloc.1
+ IL_001c: ldloc.1
IL_001d: ldstr ""frog""
IL_0022: call ""bool string.op_Equality(string, string)""
IL_0027: brtrue.s IL_0038
- IL_0029: ldloc.2
+ IL_0029: ldloc.1
IL_002a: ldstr ""toad""
IL_002f: call ""bool string.op_Equality(string, string)""
- IL_0034: brtrue.s IL_003c
- IL_0036: br.s IL_0040
+ IL_0034: brtrue.s IL_003b
+ IL_0036: br.s IL_003e
IL_0038: ldc.i4.1
- IL_0039: stloc.1
- IL_003a: br.s IL_0042
- IL_003c: ldc.i4.1
- IL_003d: stloc.1
- IL_003e: br.s IL_0042
- IL_0040: ldc.i4.0
- IL_0041: stloc.1
- IL_0042: ldloc.1
- IL_0043: ldc.i4.0
- IL_0044: cgt.un
- IL_0046: endfilter
+ IL_0039: br.s IL_003f
+ IL_003b: ldc.i4.1
+ IL_003c: br.s IL_003f
+ IL_003e: ldc.i4.0
+ IL_003f: ldc.i4.0
+ IL_0040: cgt.un
+ IL_0042: endfilter
} // end filter
{ // handler
- IL_0048: pop
- IL_0049: ldloc.0
- IL_004a: callvirt ""string System.Exception.Message.get""
- IL_004f: newobj ""System.Exception..ctor(string)""
- IL_0054: throw
+ IL_0044: pop
+ IL_0045: ldloc.0
+ IL_0046: callvirt ""string System.Exception.Message.get""
+ IL_004b: newobj ""System.Exception..ctor(string)""
+ IL_0050: throw
}
catch object
{
- IL_0055: pop
- IL_0056: leave.s IL_0058
+ IL_0051: pop
+ IL_0052: leave.s IL_0054
}
- IL_0058: ret
+ IL_0054: ret
}
");
}
@@ -4670,20 +4640,16 @@ static void Check(nint i)
False");
verifier.VerifyIL("Program.EqualNull",
@"{
- // Code size 13 (0xd)
+ // Code size 9 (0x9)
.maxstack 2
- .locals init (bool V_0)
IL_0000: ldarg.0
IL_0001: ldc.i4.0
IL_0002: conv.u
- IL_0003: bne.un.s IL_0009
+ IL_0003: bne.un.s IL_0007
IL_0005: ldc.i4.1
- IL_0006: stloc.0
- IL_0007: br.s IL_000b
- IL_0009: ldc.i4.0
- IL_000a: stloc.0
- IL_000b: ldloc.0
- IL_000c: ret
+ IL_0006: ret
+ IL_0007: ldc.i4.0
+ IL_0008: ret
}");
}
@@ -4716,23 +4682,19 @@ static void Check(nint i)
False");
verifier.VerifyIL("Program.EqualNull",
@"{
- // Code size 21 (0x15)
+ // Code size 17 (0x11)
.maxstack 2
- .locals init (bool V_0)
IL_0000: ldarg.0
- IL_0001: brfalse.s IL_0011
+ IL_0001: brfalse.s IL_000f
IL_0003: ldarg.0
IL_0004: ldfld ""char* C.P""
IL_0009: ldc.i4.0
IL_000a: conv.u
- IL_000b: bne.un.s IL_0011
+ IL_000b: bne.un.s IL_000f
IL_000d: ldc.i4.1
- IL_000e: stloc.0
- IL_000f: br.s IL_0013
- IL_0011: ldc.i4.0
- IL_0012: stloc.0
- IL_0013: ldloc.0
- IL_0014: ret
+ IL_000e: ret
+ IL_000f: ldc.i4.0
+ IL_0010: ret
}");
}
@@ -6695,59 +6657,58 @@ red should not be null
verifier.VerifyIL("", """
{
- // Code size 186 (0xba)
- .maxstack 4
+ // Code size 185 (0xb9)
+ .maxstack 3
.locals init (double V_0, //val
- string V_1)
+ Obj V_1) //obj
IL_0000: ldc.r8 0.1
IL_0009: stloc.0
IL_000a: newobj "Obj..ctor()"
- IL_000f: dup
- IL_0010: call "Obj Program.<$>g__ThrowWhenNull|0_0(Obj)"
- IL_0015: ldloc.0
- IL_0016: ldc.r8 0
- IL_001f: bne.un.s IL_0029
- IL_0021: ldstr "green"
- IL_0026: stloc.1
- IL_0027: br.s IL_002f
- IL_0029: ldstr "red"
- IL_002e: stloc.1
- IL_002f: ldflda "Wrapper Obj.Color"
- IL_0034: ldloc.1
- IL_0035: call "void Wrapper.Value.set"
- IL_003a: dup
- IL_003b: ldflda "Wrapper Obj.Color"
- IL_0040: call "string Wrapper.Value.get"
- IL_0045: dup
- IL_0046: brtrue.s IL_004e
- IL_0048: pop
- IL_0049: ldstr "null"
- IL_004e: ldstr " should not be null"
- IL_0053: call "string string.Concat(string, string)"
- IL_0058: call "void System.Console.WriteLine(string)"
- IL_005d: dup
- IL_005e: call "Obj Program.<$>g__ThrowWhenNull|0_0(Obj)"
- IL_0063: ldflda "Wrapper Obj.Color"
- IL_0068: ldstr "yikes"
- IL_006d: call "void Wrapper.Value.set"
- IL_0072: dup
- IL_0073: ldflda "Wrapper Obj.Color"
- IL_0078: call "string Wrapper.Value.get"
- IL_007d: call "void System.Console.WriteLine(string)"
- IL_0082: dup
- IL_0083: call "Obj Program.<$>g__ThrowWhenNull|0_0(Obj)"
- IL_0088: ldflda "Wrapper Obj.Color"
- IL_008d: ldloc.0
- IL_008e: ldc.r8 0
- IL_0097: beq.s IL_00a0
- IL_0099: ldstr "red"
- IL_009e: br.s IL_00a5
- IL_00a0: ldstr "green"
- IL_00a5: call "void Wrapper.Value.set"
- IL_00aa: ldflda "Wrapper Obj.Color"
- IL_00af: call "string Wrapper.Value.get"
- IL_00b4: call "void System.Console.WriteLine(string)"
- IL_00b9: ret
+ IL_000f: stloc.1
+ IL_0010: ldloc.1
+ IL_0011: call "Obj Program.<$>g__ThrowWhenNull|0_0(Obj)"
+ IL_0016: ldflda "Wrapper Obj.Color"
+ IL_001b: ldloc.0
+ IL_001c: ldc.r8 0
+ IL_0025: bne.un.s IL_002e
+ IL_0027: ldstr "green"
+ IL_002c: br.s IL_0033
+ IL_002e: ldstr "red"
+ IL_0033: call "void Wrapper.Value.set"
+ IL_0038: ldloc.1
+ IL_0039: ldflda "Wrapper Obj.Color"
+ IL_003e: call "string Wrapper.Value.get"
+ IL_0043: dup
+ IL_0044: brtrue.s IL_004c
+ IL_0046: pop
+ IL_0047: ldstr "null"
+ IL_004c: ldstr " should not be null"
+ IL_0051: call "string string.Concat(string, string)"
+ IL_0056: call "void System.Console.WriteLine(string)"
+ IL_005b: ldloc.1
+ IL_005c: call "Obj Program.<$>g__ThrowWhenNull|0_0(Obj)"
+ IL_0061: ldflda "Wrapper Obj.Color"
+ IL_0066: ldstr "yikes"
+ IL_006b: call "void Wrapper.Value.set"
+ IL_0070: ldloc.1
+ IL_0071: ldflda "Wrapper Obj.Color"
+ IL_0076: call "string Wrapper.Value.get"
+ IL_007b: call "void System.Console.WriteLine(string)"
+ IL_0080: ldloc.1
+ IL_0081: call "Obj Program.<$>g__ThrowWhenNull|0_0(Obj)"
+ IL_0086: ldflda "Wrapper Obj.Color"
+ IL_008b: ldloc.0
+ IL_008c: ldc.r8 0
+ IL_0095: beq.s IL_009e
+ IL_0097: ldstr "red"
+ IL_009c: br.s IL_00a3
+ IL_009e: ldstr "green"
+ IL_00a3: call "void Wrapper.Value.set"
+ IL_00a8: ldloc.1
+ IL_00a9: ldflda "Wrapper Obj.Color"
+ IL_00ae: call "string Wrapper.Value.get"
+ IL_00b3: call "void System.Console.WriteLine(string)"
+ IL_00b8: ret
}
""");
}
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
index c038526b59fb5..46c55b488f0f1 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
@@ -5989,576 +5989,6 @@ internal static class InternalErrorCode
}
""";
var compVerifier = CompileAndVerify(text);
- var codeForExpression = @"
-{
- // Code size 1893 (0x765)
- .maxstack 2
- .locals init (bool V_0)
- IL_0000: ldarg.0
- IL_0001: ldc.i4 0x32b
- IL_0006: bgt IL_0300
- IL_000b: ldarg.0
- IL_000c: ldc.i4 0x1ad
- IL_0011: bgt IL_0154
- IL_0016: ldarg.0
- IL_0017: ldc.i4 0xb8
- IL_001c: bgt IL_00a9
- IL_0021: ldarg.0
- IL_0022: ldc.i4.s 109
- IL_0024: bgt.s IL_005f
- IL_0026: ldarg.0
- IL_0027: ldc.i4.s 67
- IL_0029: bgt.s IL_0040
- IL_002b: ldarg.0
- IL_002c: ldc.i4.s 28
- IL_002e: beq IL_075d
- IL_0033: ldarg.0
- IL_0034: ldc.i4.s 67
- IL_0036: beq IL_075d
- IL_003b: br IL_0761
- IL_0040: ldarg.0
- IL_0041: ldc.i4.s 78
- IL_0043: beq IL_075d
- IL_0048: ldarg.0
- IL_0049: ldc.i4.s 105
- IL_004b: beq IL_075d
- IL_0050: ldarg.0
- IL_0051: ldc.i4.s 108
- IL_0053: sub
- IL_0054: ldc.i4.1
- IL_0055: ble.un IL_075d
- IL_005a: br IL_0761
- IL_005f: ldarg.0
- IL_0060: ldc.i4 0xa2
- IL_0065: bgt.s IL_007f
- IL_0067: ldarg.0
- IL_0068: ldc.i4.s 114
- IL_006a: beq IL_075d
- IL_006f: ldarg.0
- IL_0070: ldc.i4 0xa2
- IL_0075: beq IL_075d
- IL_007a: br IL_0761
- IL_007f: ldarg.0
- IL_0080: ldc.i4 0xa4
- IL_0085: beq IL_075d
- IL_008a: ldarg.0
- IL_008b: ldc.i4 0xa8
- IL_0090: sub
- IL_0091: ldc.i4.1
- IL_0092: ble.un IL_075d
- IL_0097: ldarg.0
- IL_0098: ldc.i4 0xb7
- IL_009d: sub
- IL_009e: ldc.i4.1
- IL_009f: ble.un IL_075d
- IL_00a4: br IL_0761
- IL_00a9: ldarg.0
- IL_00aa: ldc.i4 0x118
- IL_00af: bgt.s IL_00fe
- IL_00b1: ldarg.0
- IL_00b2: ldc.i4 0xcf
- IL_00b7: bgt.s IL_00d4
- IL_00b9: ldarg.0
- IL_00ba: ldc.i4 0xc5
- IL_00bf: beq IL_075d
- IL_00c4: ldarg.0
- IL_00c5: ldc.i4 0xcf
- IL_00ca: beq IL_075d
- IL_00cf: br IL_0761
- IL_00d4: ldarg.0
- IL_00d5: ldc.i4 0xdb
- IL_00da: beq IL_075d
- IL_00df: ldarg.0
- IL_00e0: ldc.i4 0xfb
- IL_00e5: sub
- IL_00e6: ldc.i4.2
- IL_00e7: ble.un IL_075d
- IL_00ec: ldarg.0
- IL_00ed: ldc.i4 0x116
- IL_00f2: sub
- IL_00f3: ldc.i4.2
- IL_00f4: ble.un IL_075d
- IL_00f9: br IL_0761
- IL_00fe: ldarg.0
- IL_00ff: ldc.i4 0x19e
- IL_0104: bgt.s IL_012c
- IL_0106: ldarg.0
- IL_0107: ldc.i4 0x11a
- IL_010c: beq IL_075d
- IL_0111: ldarg.0
- IL_0112: ldc.i4 0x192
- IL_0117: beq IL_075d
- IL_011c: ldarg.0
- IL_011d: ldc.i4 0x19e
- IL_0122: beq IL_075d
- IL_0127: br IL_0761
- IL_012c: ldarg.0
- IL_012d: ldc.i4 0x1a3
- IL_0132: sub
- IL_0133: ldc.i4.1
- IL_0134: ble.un IL_075d
- IL_0139: ldarg.0
- IL_013a: ldc.i4 0x1a6
- IL_013f: beq IL_075d
- IL_0144: ldarg.0
- IL_0145: ldc.i4 0x1ad
- IL_014a: beq IL_075d
- IL_014f: br IL_0761
- IL_0154: ldarg.0
- IL_0155: ldc.i4 0x274
- IL_015a: bgt IL_0224
- IL_015f: ldarg.0
- IL_0160: ldc.i4 0x1d9
- IL_0165: bgt.s IL_01db
- IL_0167: ldarg.0
- IL_0168: ldc.i4 0x1b8
- IL_016d: bgt.s IL_018c
- IL_016f: ldarg.0
- IL_0170: ldc.i4 0x1b3
- IL_0175: sub
- IL_0176: ldc.i4.2
- IL_0177: ble.un IL_075d
- IL_017c: ldarg.0
- IL_017d: ldc.i4 0x1b8
- IL_0182: beq IL_075d
- IL_0187: br IL_0761
- IL_018c: ldarg.0
- IL_018d: ldc.i4 0x1bc
- IL_0192: beq IL_075d
- IL_0197: ldarg.0
- IL_0198: ldc.i4 0x1ca
- IL_019d: beq IL_075d
- IL_01a2: ldarg.0
- IL_01a3: ldc.i4 0x1d0
- IL_01a8: sub
- IL_01a9: switch (
- IL_075d,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_075d)
- IL_01d6: br IL_0761
- IL_01db: ldarg.0
- IL_01dc: ldc.i4 0x264
- IL_01e1: bgt.s IL_01fe
- IL_01e3: ldarg.0
- IL_01e4: ldc.i4 0x25a
- IL_01e9: beq IL_075d
- IL_01ee: ldarg.0
- IL_01ef: ldc.i4 0x264
- IL_01f4: beq IL_075d
- IL_01f9: br IL_0761
- IL_01fe: ldarg.0
- IL_01ff: ldc.i4 0x26a
- IL_0204: beq IL_075d
- IL_0209: ldarg.0
- IL_020a: ldc.i4 0x272
- IL_020f: beq IL_075d
- IL_0214: ldarg.0
- IL_0215: ldc.i4 0x274
- IL_021a: beq IL_075d
- IL_021f: br IL_0761
- IL_0224: ldarg.0
- IL_0225: ldc.i4 0x2a3
- IL_022a: bgt.s IL_02aa
- IL_022c: ldarg.0
- IL_022d: ldc.i4 0x295
- IL_0232: bgt.s IL_0284
- IL_0234: ldarg.0
- IL_0235: ldc.i4 0x282
- IL_023a: beq IL_075d
- IL_023f: ldarg.0
- IL_0240: ldc.i4 0x289
- IL_0245: sub
- IL_0246: switch (
- IL_075d,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d)
- IL_027f: br IL_0761
- IL_0284: ldarg.0
- IL_0285: ldc.i4 0x299
- IL_028a: beq IL_075d
- IL_028f: ldarg.0
- IL_0290: ldc.i4 0x2a0
- IL_0295: beq IL_075d
- IL_029a: ldarg.0
- IL_029b: ldc.i4 0x2a3
- IL_02a0: beq IL_075d
- IL_02a5: br IL_0761
- IL_02aa: ldarg.0
- IL_02ab: ldc.i4 0x2b5
- IL_02b0: bgt.s IL_02da
- IL_02b2: ldarg.0
- IL_02b3: ldc.i4 0x2a7
- IL_02b8: sub
- IL_02b9: ldc.i4.1
- IL_02ba: ble.un IL_075d
- IL_02bf: ldarg.0
- IL_02c0: ldc.i4 0x2ac
- IL_02c5: beq IL_075d
- IL_02ca: ldarg.0
- IL_02cb: ldc.i4 0x2b5
- IL_02d0: beq IL_075d
- IL_02d5: br IL_0761
- IL_02da: ldarg.0
- IL_02db: ldc.i4 0x2d8
- IL_02e0: beq IL_075d
- IL_02e5: ldarg.0
- IL_02e6: ldc.i4 0x329
- IL_02eb: beq IL_075d
- IL_02f0: ldarg.0
- IL_02f1: ldc.i4 0x32b
- IL_02f6: beq IL_075d
- IL_02fb: br IL_0761
- IL_0300: ldarg.0
- IL_0301: ldc.i4 0x7bd
- IL_0306: bgt IL_05d1
- IL_030b: ldarg.0
- IL_030c: ldc.i4 0x663
- IL_0311: bgt IL_0451
- IL_0316: ldarg.0
- IL_0317: ldc.i4 0x5f2
- IL_031c: bgt.s IL_038e
- IL_031e: ldarg.0
- IL_031f: ldc.i4 0x406
- IL_0324: bgt.s IL_0341
- IL_0326: ldarg.0
- IL_0327: ldc.i4 0x338
- IL_032c: beq IL_075d
- IL_0331: ldarg.0
- IL_0332: ldc.i4 0x406
- IL_0337: beq IL_075d
- IL_033c: br IL_0761
- IL_0341: ldarg.0
- IL_0342: ldc.i4 0x422
- IL_0347: sub
- IL_0348: switch (
- IL_075d,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_075d)
- IL_0371: ldarg.0
- IL_0372: ldc.i4 0x4b0
- IL_0377: sub
- IL_0378: ldc.i4.4
- IL_0379: ble.un IL_075d
- IL_037e: ldarg.0
- IL_037f: ldc.i4 0x5f2
- IL_0384: beq IL_075d
- IL_0389: br IL_0761
- IL_038e: ldarg.0
- IL_038f: ldc.i4 0x647
- IL_0394: bgt IL_0429
- IL_0399: ldarg.0
- IL_039a: ldc.i4 0x622
- IL_039f: sub
- IL_03a0: switch (
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_075d)
- IL_0419: ldarg.0
- IL_041a: ldc.i4 0x647
- IL_041f: beq IL_075d
- IL_0424: br IL_0761
- IL_0429: ldarg.0
- IL_042a: ldc.i4 0x64a
- IL_042f: beq IL_075d
- IL_0434: ldarg.0
- IL_0435: ldc.i4 0x650
- IL_043a: beq IL_075d
- IL_043f: ldarg.0
- IL_0440: ldc.i4 0x661
- IL_0445: sub
- IL_0446: ldc.i4.2
- IL_0447: ble.un IL_075d
- IL_044c: br IL_0761
- IL_0451: ldarg.0
- IL_0452: ldc.i4 0x6c7
- IL_0457: bgt IL_057b
- IL_045c: ldarg.0
- IL_045d: ldc.i4 0x67b
- IL_0462: bgt.s IL_0481
- IL_0464: ldarg.0
- IL_0465: ldc.i4 0x66d
- IL_046a: beq IL_075d
- IL_046f: ldarg.0
- IL_0470: ldc.i4 0x67a
- IL_0475: sub
- IL_0476: ldc.i4.1
- IL_0477: ble.un IL_075d
- IL_047c: br IL_0761
- IL_0481: ldarg.0
- IL_0482: ldc.i4 0x684
- IL_0487: sub
- IL_0488: switch (
- IL_075d,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d)
- IL_0541: ldarg.0
- IL_0542: ldc.i4 0x6b5
- IL_0547: sub
- IL_0548: switch (
- IL_075d,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_0761,
- IL_0761,
- IL_075d)
- IL_0569: ldarg.0
- IL_056a: ldc.i4 0x6c6
- IL_056f: sub
- IL_0570: ldc.i4.1
- IL_0571: ble.un IL_075d
- IL_0576: br IL_0761
- IL_057b: ldarg.0
- IL_057c: ldc.i4 0x787
- IL_0581: bgt.s IL_05a9
- IL_0583: ldarg.0
- IL_0584: ldc.i4 0x6e2
- IL_0589: beq IL_075d
- IL_058e: ldarg.0
- IL_058f: ldc.i4 0x6e5
- IL_0594: beq IL_075d
- IL_0599: ldarg.0
- IL_059a: ldc.i4 0x787
- IL_059f: beq IL_075d
- IL_05a4: br IL_0761
- IL_05a9: ldarg.0
- IL_05aa: ldc.i4 0x7a4
- IL_05af: sub
- IL_05b0: ldc.i4.1
- IL_05b1: ble.un IL_075d
- IL_05b6: ldarg.0
- IL_05b7: ldc.i4 0x7b6
- IL_05bc: beq IL_075d
- IL_05c1: ldarg.0
- IL_05c2: ldc.i4 0x7bd
- IL_05c7: beq IL_075d
- IL_05cc: br IL_0761
- IL_05d1: ldarg.0
- IL_05d2: ldc.i4 0xfba
- IL_05d7: bgt IL_06e3
- IL_05dc: ldarg.0
- IL_05dd: ldc.i4 0x7e7
- IL_05e2: bgt.s IL_062d
- IL_05e4: ldarg.0
- IL_05e5: ldc.i4 0x7d2
- IL_05ea: bgt.s IL_0607
- IL_05ec: ldarg.0
- IL_05ed: ldc.i4 0x7ce
- IL_05f2: beq IL_075d
- IL_05f7: ldarg.0
- IL_05f8: ldc.i4 0x7d2
- IL_05fd: beq IL_075d
- IL_0602: br IL_0761
- IL_0607: ldarg.0
- IL_0608: ldc.i4 0x7d8
- IL_060d: beq IL_075d
- IL_0612: ldarg.0
- IL_0613: ldc.i4 0x7de
- IL_0618: beq IL_075d
- IL_061d: ldarg.0
- IL_061e: ldc.i4 0x7e7
- IL_0623: beq IL_075d
- IL_0628: br IL_0761
- IL_062d: ldarg.0
- IL_062e: ldc.i4 0x7f6
- IL_0633: bgt.s IL_0650
- IL_0635: ldarg.0
- IL_0636: ldc.i4 0x7ed
- IL_063b: beq IL_075d
- IL_0640: ldarg.0
- IL_0641: ldc.i4 0x7f6
- IL_0646: beq IL_075d
- IL_064b: br IL_0761
- IL_0650: ldarg.0
- IL_0651: ldc.i4 0xbb8
- IL_0656: sub
- IL_0657: switch (
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_075d,
- IL_0761,
- IL_075d,
- IL_075d)
- IL_06cc: ldarg.0
- IL_06cd: ldc.i4 0xfae
- IL_06d2: beq IL_075d
- IL_06d7: ldarg.0
- IL_06d8: ldc.i4 0xfb8
- IL_06dd: sub
- IL_06de: ldc.i4.2
- IL_06df: ble.un.s IL_075d
- IL_06e1: br.s IL_0761
- IL_06e3: ldarg.0
- IL_06e4: ldc.i4 0x1b7b
- IL_06e9: bgt.s IL_071f
- IL_06eb: ldarg.0
- IL_06ec: ldc.i4 0x1b65
- IL_06f1: bgt.s IL_0705
- IL_06f3: ldarg.0
- IL_06f4: ldc.i4 0x1388
- IL_06f9: beq.s IL_075d
- IL_06fb: ldarg.0
- IL_06fc: ldc.i4 0x1b65
- IL_0701: beq.s IL_075d
- IL_0703: br.s IL_0761
- IL_0705: ldarg.0
- IL_0706: ldc.i4 0x1b6e
- IL_070b: beq.s IL_075d
- IL_070d: ldarg.0
- IL_070e: ldc.i4 0x1b79
- IL_0713: beq.s IL_075d
- IL_0715: ldarg.0
- IL_0716: ldc.i4 0x1b7b
- IL_071b: beq.s IL_075d
- IL_071d: br.s IL_0761
- IL_071f: ldarg.0
- IL_0720: ldc.i4 0x1f41
- IL_0725: bgt.s IL_0743
- IL_0727: ldarg.0
- IL_0728: ldc.i4 0x1ba8
- IL_072d: sub
- IL_072e: ldc.i4.2
- IL_072f: ble.un.s IL_075d
- IL_0731: ldarg.0
- IL_0732: ldc.i4 0x1bb2
- IL_0737: beq.s IL_075d
- IL_0739: ldarg.0
- IL_073a: ldc.i4 0x1f41
- IL_073f: beq.s IL_075d
- IL_0741: br.s IL_0761
- IL_0743: ldarg.0
- IL_0744: ldc.i4 0x1f49
- IL_0749: beq.s IL_075d
- IL_074b: ldarg.0
- IL_074c: ldc.i4 0x1f4c
- IL_0751: beq.s IL_075d
- IL_0753: ldarg.0
- IL_0754: ldc.i4 0x2710
- IL_0759: sub
- IL_075a: ldc.i4.2
- IL_075b: bgt.un.s IL_0761
- IL_075d: ldc.i4.1
- IL_075e: stloc.0
- IL_075f: br.s IL_0763
- IL_0761: ldc.i4.0
- IL_0762: stloc.0
- IL_0763: ldloc.0
- IL_0764: ret
-}
-";
var codeForSwitchStatement = @"
{
// Code size 1889 (0x761)
@@ -7126,7 +6556,7 @@ .maxstack 2
}";
compVerifier.VerifyIL("ConsoleApplication24.Program.IsWarning", codeForSwitchStatement);
compVerifier.VerifyIL("ConsoleApplication24.Program.IsWarning_IsExpression", codeForSwitchStatement);
- compVerifier.VerifyIL("ConsoleApplication24.Program.IsWarning_SwitchExpression", codeForExpression);
+ compVerifier.VerifyIL("ConsoleApplication24.Program.IsWarning_SwitchExpression", codeForSwitchStatement);
}
[Fact]
@@ -10697,12 +10127,11 @@ .locals init (System.IO.StringReader V_0, //sr
compVerifier = CompileAndVerify(compilation, expectedOutput: "Yep, all good!");
compVerifier.VerifyIL("Program.Main", @"
{
- // Code size 122 (0x7a)
+ // Code size 119 (0x77)
.maxstack 4
.locals init (System.IO.StringReader V_0, //sr
string V_1, //a
- string V_2, //b
- string V_3)
+ string V_2) //b
IL_0000: ldstr ""fiz
bar""
IL_0005: newobj ""System.IO.StringReader..ctor(string)""
@@ -10718,51 +10147,48 @@ .locals init (System.IO.StringReader V_0, //sr
IL_0019: ldloc.1
IL_001a: ldstr ""fiz""
IL_001f: call ""bool string.op_Equality(string, string)""
- IL_0024: brfalse.s IL_003b
+ IL_0024: brfalse.s IL_003a
IL_0026: ldloc.2
IL_0027: ldstr ""bar""
IL_002c: call ""bool string.op_Equality(string, string)""
- IL_0031: brfalse.s IL_003b
+ IL_0031: brfalse.s IL_003a
IL_0033: ldstr ""Yep, all good!""
- IL_0038: stloc.3
- IL_0039: br.s IL_0067
- IL_003b: ldc.i4.5
- IL_003c: newarr ""string""
- IL_0041: dup
- IL_0042: ldc.i4.0
- IL_0043: ldstr ""Wait, what? I got (""
- IL_0048: stelem.ref
- IL_0049: dup
- IL_004a: ldc.i4.1
- IL_004b: ldloc.1
- IL_004c: stelem.ref
- IL_004d: dup
- IL_004e: ldc.i4.2
- IL_004f: ldstr "", ""
- IL_0054: stelem.ref
- IL_0055: dup
- IL_0056: ldc.i4.3
- IL_0057: ldloc.2
- IL_0058: stelem.ref
- IL_0059: dup
- IL_005a: ldc.i4.4
- IL_005b: ldstr "")!""
- IL_0060: stelem.ref
- IL_0061: call ""string string.Concat(params string[])""
- IL_0066: stloc.3
- IL_0067: ldloc.3
- IL_0068: call ""void System.Console.WriteLine(string)""
- IL_006d: leave.s IL_0079
+ IL_0038: br.s IL_0065
+ IL_003a: ldc.i4.5
+ IL_003b: newarr ""string""
+ IL_0040: dup
+ IL_0041: ldc.i4.0
+ IL_0042: ldstr ""Wait, what? I got (""
+ IL_0047: stelem.ref
+ IL_0048: dup
+ IL_0049: ldc.i4.1
+ IL_004a: ldloc.1
+ IL_004b: stelem.ref
+ IL_004c: dup
+ IL_004d: ldc.i4.2
+ IL_004e: ldstr "", ""
+ IL_0053: stelem.ref
+ IL_0054: dup
+ IL_0055: ldc.i4.3
+ IL_0056: ldloc.2
+ IL_0057: stelem.ref
+ IL_0058: dup
+ IL_0059: ldc.i4.4
+ IL_005a: ldstr "")!""
+ IL_005f: stelem.ref
+ IL_0060: call ""string string.Concat(params string[])""
+ IL_0065: call ""void System.Console.WriteLine(string)""
+ IL_006a: leave.s IL_0076
}
finally
{
+ IL_006c: ldloc.0
+ IL_006d: brfalse.s IL_0075
IL_006f: ldloc.0
- IL_0070: brfalse.s IL_0078
- IL_0072: ldloc.0
- IL_0073: callvirt ""void System.IDisposable.Dispose()""
- IL_0078: endfinally
+ IL_0070: callvirt ""void System.IDisposable.Dispose()""
+ IL_0075: endfinally
}
- IL_0079: ret
+ IL_0076: ret
}
");
}
@@ -10869,9 +10295,8 @@ .locals init (int V_0)
compVerifier = CompileAndVerify(compilation, expectedOutput: "123333456");
compVerifier.VerifyIL("Program.M2", @"
{
- // Code size 64 (0x40)
+ // Code size 52 (0x34)
.maxstack 2
- .locals init (int V_0)
IL_0000: ldarg.0
IL_0001: ldc.i4.1
IL_0002: bne.un.s IL_001e
@@ -10888,37 +10313,30 @@ .locals init (int V_0)
IL_0012: br.s IL_0018
IL_0014: ldarg.2
IL_0015: ldc.i4.6
- IL_0016: beq.s IL_002c
+ IL_0016: beq.s IL_002a
IL_0018: ldarg.2
IL_0019: ldc.i4.3
- IL_001a: beq.s IL_0030
- IL_001c: br.s IL_0034
+ IL_001a: beq.s IL_002c
+ IL_001c: br.s IL_002e
IL_001e: ldarg.2
IL_001f: ldc.i4.3
- IL_0020: beq.s IL_0030
+ IL_0020: beq.s IL_002c
IL_0022: ldarg.1
IL_0023: ldc.i4.1
- IL_0024: beq.s IL_0038
- IL_0026: br.s IL_003c
+ IL_0024: beq.s IL_0030
+ IL_0026: br.s IL_0032
IL_0028: ldc.i4.1
- IL_0029: stloc.0
- IL_002a: br.s IL_003e
- IL_002c: ldc.i4.2
- IL_002d: stloc.0
- IL_002e: br.s IL_003e
- IL_0030: ldc.i4.3
- IL_0031: stloc.0
- IL_0032: br.s IL_003e
- IL_0034: ldc.i4.4
- IL_0035: stloc.0
- IL_0036: br.s IL_003e
- IL_0038: ldc.i4.5
- IL_0039: stloc.0
- IL_003a: br.s IL_003e
- IL_003c: ldc.i4.6
- IL_003d: stloc.0
- IL_003e: ldloc.0
- IL_003f: ret
+ IL_0029: ret
+ IL_002a: ldc.i4.2
+ IL_002b: ret
+ IL_002c: ldc.i4.3
+ IL_002d: ret
+ IL_002e: ldc.i4.4
+ IL_002f: ret
+ IL_0030: ldc.i4.5
+ IL_0031: ret
+ IL_0032: ldc.i4.6
+ IL_0033: ret
}
");
}
@@ -11030,9 +10448,8 @@ static int M(double d)
expectedOutput: expectedOutput);
compVerifier.VerifyIL("C.M", @"
{
- // Code size 478 (0x1de)
+ // Code size 436 (0x1b4)
.maxstack 2
- .locals init (int V_0)
IL_0000: ldarg.0
IL_0001: ldc.r8 27.1
IL_000a: blt.un.s IL_002f
@@ -11041,145 +10458,123 @@ .locals init (int V_0)
IL_0016: blt IL_017e
IL_001b: ldarg.0
IL_001c: ldc.r8 29.1
- IL_0025: beq IL_019e
- IL_002a: br IL_01da
+ IL_0025: beq IL_0190
+ IL_002a: br IL_01b2
IL_002f: ldarg.0
IL_0030: ldc.r8 26.1
- IL_0039: beq IL_0183
+ IL_0039: beq IL_0181
IL_003e: ldarg.0
IL_003f: ldc.r8 9.1
- IL_0048: beq IL_0188
+ IL_0048: beq IL_0184
IL_004d: ldarg.0
IL_004e: ldc.r8 2.1
- IL_0057: blt.un IL_01da
+ IL_0057: blt.un IL_01b2
IL_005c: ldarg.0
IL_005d: ldc.r8 4.1
- IL_0066: blt IL_018c
+ IL_0066: blt IL_0186
IL_006b: ldarg.0
IL_006c: ldc.r8 12.1
- IL_0075: beq IL_0190
+ IL_0075: beq IL_0188
IL_007a: ldarg.0
IL_007b: ldc.r8 21.1
IL_0084: blt.un.s IL_00b8
IL_0086: ldarg.0
IL_0087: ldc.r8 23.1
- IL_0090: blt IL_0194
+ IL_0090: blt IL_018a
IL_0095: ldarg.0
IL_0096: ldc.r8 25.1
- IL_009f: blt IL_01be
+ IL_009f: blt IL_01a2
IL_00a4: ldarg.0
IL_00a5: ldc.r8 25.1
- IL_00ae: beq IL_01cc
- IL_00b3: br IL_01da
+ IL_00ae: beq IL_01aa
+ IL_00b3: br IL_01b2
IL_00b8: ldarg.0
IL_00b9: ldc.r8 19.1
- IL_00c2: beq IL_0199
+ IL_00c2: beq IL_018d
IL_00c7: ldarg.0
IL_00c8: ldc.r8 13.1
IL_00d1: blt.un.s IL_0132
IL_00d3: ldarg.0
IL_00d4: ldc.r8 15.1
- IL_00dd: blt IL_01a3
+ IL_00dd: blt IL_0193
IL_00e2: ldarg.0
IL_00e3: ldc.r8 15.1
- IL_00ec: beq IL_01ac
+ IL_00ec: beq IL_0198
IL_00f1: ldarg.0
IL_00f2: ldc.r8 16.1
- IL_00fb: blt.un IL_01da
+ IL_00fb: blt.un IL_01b2
IL_0100: ldarg.0
IL_0101: ldc.r8 18.1
- IL_010a: blt IL_01b9
+ IL_010a: blt IL_019f
IL_010f: ldarg.0
IL_0110: ldc.r8 18.1
- IL_0119: beq IL_01c3
+ IL_0119: beq IL_01a5
IL_011e: ldarg.0
IL_011f: ldc.r8 20.1
- IL_0128: beq IL_01d1
- IL_012d: br IL_01da
+ IL_0128: beq IL_01ad
+ IL_012d: br IL_01b2
IL_0132: ldarg.0
IL_0133: ldc.r8 10.1
- IL_013c: beq.s IL_01a8
+ IL_013c: beq.s IL_0196
IL_013e: ldarg.0
IL_013f: ldc.r8 11.1
- IL_0148: beq.s IL_01b1
+ IL_0148: beq.s IL_019b
IL_014a: ldarg.0
IL_014b: ldc.r8 4.1
- IL_0154: beq.s IL_01b5
+ IL_0154: beq.s IL_019d
IL_0156: ldarg.0
IL_0157: ldc.r8 7.1
IL_0160: blt.un.s IL_0170
IL_0162: ldarg.0
IL_0163: ldc.r8 9.1
- IL_016c: blt.s IL_01c8
- IL_016e: br.s IL_01da
+ IL_016c: blt.s IL_01a8
+ IL_016e: br.s IL_01b2
IL_0170: ldarg.0
IL_0171: ldc.r8 5.1
- IL_017a: bge.s IL_01d6
- IL_017c: br.s IL_01da
+ IL_017a: bge.s IL_01b0
+ IL_017c: br.s IL_01b2
IL_017e: ldc.i4.s 19
- IL_0180: stloc.0
- IL_0181: br.s IL_01dc
- IL_0183: ldc.i4.s 18
- IL_0185: stloc.0
- IL_0186: br.s IL_01dc
- IL_0188: ldc.i4.5
- IL_0189: stloc.0
- IL_018a: br.s IL_01dc
- IL_018c: ldc.i4.1
- IL_018d: stloc.0
- IL_018e: br.s IL_01dc
- IL_0190: ldc.i4.8
- IL_0191: stloc.0
- IL_0192: br.s IL_01dc
- IL_0194: ldc.i4.s 15
- IL_0196: stloc.0
- IL_0197: br.s IL_01dc
- IL_0199: ldc.i4.s 13
- IL_019b: stloc.0
- IL_019c: br.s IL_01dc
- IL_019e: ldc.i4.s 20
- IL_01a0: stloc.0
- IL_01a1: br.s IL_01dc
- IL_01a3: ldc.i4.s 9
- IL_01a5: stloc.0
- IL_01a6: br.s IL_01dc
- IL_01a8: ldc.i4.6
- IL_01a9: stloc.0
- IL_01aa: br.s IL_01dc
- IL_01ac: ldc.i4.s 10
- IL_01ae: stloc.0
- IL_01af: br.s IL_01dc
- IL_01b1: ldc.i4.7
- IL_01b2: stloc.0
- IL_01b3: br.s IL_01dc
- IL_01b5: ldc.i4.2
- IL_01b6: stloc.0
- IL_01b7: br.s IL_01dc
- IL_01b9: ldc.i4.s 11
- IL_01bb: stloc.0
- IL_01bc: br.s IL_01dc
- IL_01be: ldc.i4.s 16
- IL_01c0: stloc.0
- IL_01c1: br.s IL_01dc
- IL_01c3: ldc.i4.s 12
- IL_01c5: stloc.0
- IL_01c6: br.s IL_01dc
- IL_01c8: ldc.i4.4
- IL_01c9: stloc.0
- IL_01ca: br.s IL_01dc
- IL_01cc: ldc.i4.s 17
- IL_01ce: stloc.0
- IL_01cf: br.s IL_01dc
- IL_01d1: ldc.i4.s 14
- IL_01d3: stloc.0
- IL_01d4: br.s IL_01dc
- IL_01d6: ldc.i4.3
- IL_01d7: stloc.0
- IL_01d8: br.s IL_01dc
- IL_01da: ldc.i4.0
- IL_01db: stloc.0
- IL_01dc: ldloc.0
- IL_01dd: ret
+ IL_0180: ret
+ IL_0181: ldc.i4.s 18
+ IL_0183: ret
+ IL_0184: ldc.i4.5
+ IL_0185: ret
+ IL_0186: ldc.i4.1
+ IL_0187: ret
+ IL_0188: ldc.i4.8
+ IL_0189: ret
+ IL_018a: ldc.i4.s 15
+ IL_018c: ret
+ IL_018d: ldc.i4.s 13
+ IL_018f: ret
+ IL_0190: ldc.i4.s 20
+ IL_0192: ret
+ IL_0193: ldc.i4.s 9
+ IL_0195: ret
+ IL_0196: ldc.i4.6
+ IL_0197: ret
+ IL_0198: ldc.i4.s 10
+ IL_019a: ret
+ IL_019b: ldc.i4.7
+ IL_019c: ret
+ IL_019d: ldc.i4.2
+ IL_019e: ret
+ IL_019f: ldc.i4.s 11
+ IL_01a1: ret
+ IL_01a2: ldc.i4.s 16
+ IL_01a4: ret
+ IL_01a5: ldc.i4.s 12
+ IL_01a7: ret
+ IL_01a8: ldc.i4.4
+ IL_01a9: ret
+ IL_01aa: ldc.i4.s 17
+ IL_01ac: ret
+ IL_01ad: ldc.i4.s 14
+ IL_01af: ret
+ IL_01b0: ldc.i4.3
+ IL_01b1: ret
+ IL_01b2: ldc.i4.0
+ IL_01b3: ret
}
"
);
@@ -11288,156 +10683,133 @@ static int M(float d)
expectedOutput: expectedOutput);
compVerifier.VerifyIL("C.M", @"
{
- // Code size 374 (0x176)
+ // Code size 314 (0x13a)
.maxstack 2
- .locals init (int V_0)
IL_0000: ldarg.0
IL_0001: ldc.r4 27.1
IL_0006: blt.un.s IL_0023
IL_0008: ldarg.0
IL_0009: ldc.r4 29.1
- IL_000e: blt IL_0116
+ IL_000e: blt IL_0104
IL_0013: ldarg.0
IL_0014: ldc.r4 29.1
- IL_0019: beq IL_0136
- IL_001e: br IL_0172
+ IL_0019: beq IL_0116
+ IL_001e: br IL_0138
IL_0023: ldarg.0
IL_0024: ldc.r4 26.1
- IL_0029: beq IL_011b
+ IL_0029: beq IL_0107
IL_002e: ldarg.0
IL_002f: ldc.r4 9.1
- IL_0034: beq IL_0120
+ IL_0034: beq IL_010a
IL_0039: ldarg.0
IL_003a: ldc.r4 2.1
- IL_003f: blt.un IL_0172
+ IL_003f: blt.un IL_0138
IL_0044: ldarg.0
IL_0045: ldc.r4 4.1
- IL_004a: blt IL_0124
+ IL_004a: blt IL_010c
IL_004f: ldarg.0
IL_0050: ldc.r4 12.1
- IL_0055: beq IL_0128
+ IL_0055: beq IL_010e
IL_005a: ldarg.0
IL_005b: ldc.r4 21.1
IL_0060: blt.un.s IL_0088
IL_0062: ldarg.0
IL_0063: ldc.r4 23.1
- IL_0068: blt IL_012c
+ IL_0068: blt IL_0110
IL_006d: ldarg.0
IL_006e: ldc.r4 25.1
- IL_0073: blt IL_0156
+ IL_0073: blt IL_0128
IL_0078: ldarg.0
IL_0079: ldc.r4 25.1
- IL_007e: beq IL_0164
- IL_0083: br IL_0172
+ IL_007e: beq IL_0130
+ IL_0083: br IL_0138
IL_0088: ldarg.0
IL_0089: ldc.r4 19.1
- IL_008e: beq IL_0131
+ IL_008e: beq IL_0113
IL_0093: ldarg.0
IL_0094: ldc.r4 13.1
- IL_0099: blt.un.s IL_00e2
+ IL_0099: blt.un.s IL_00d0
IL_009b: ldarg.0
IL_009c: ldc.r4 15.1
- IL_00a1: blt IL_013b
- IL_00a6: ldarg.0
- IL_00a7: ldc.r4 15.1
- IL_00ac: beq IL_0144
- IL_00b1: ldarg.0
- IL_00b2: ldc.r4 16.1
- IL_00b7: blt.un IL_0172
- IL_00bc: ldarg.0
- IL_00bd: ldc.r4 18.1
- IL_00c2: blt IL_0151
- IL_00c7: ldarg.0
- IL_00c8: ldc.r4 18.1
- IL_00cd: beq IL_015b
- IL_00d2: ldarg.0
- IL_00d3: ldc.r4 20.1
- IL_00d8: beq IL_0169
- IL_00dd: br IL_0172
- IL_00e2: ldarg.0
- IL_00e3: ldc.r4 10.1
- IL_00e8: beq.s IL_0140
- IL_00ea: ldarg.0
- IL_00eb: ldc.r4 11.1
- IL_00f0: beq.s IL_0149
- IL_00f2: ldarg.0
- IL_00f3: ldc.r4 4.1
- IL_00f8: beq.s IL_014d
+ IL_00a1: blt.s IL_0119
+ IL_00a3: ldarg.0
+ IL_00a4: ldc.r4 15.1
+ IL_00a9: beq.s IL_011e
+ IL_00ab: ldarg.0
+ IL_00ac: ldc.r4 16.1
+ IL_00b1: blt.un IL_0138
+ IL_00b6: ldarg.0
+ IL_00b7: ldc.r4 18.1
+ IL_00bc: blt.s IL_0125
+ IL_00be: ldarg.0
+ IL_00bf: ldc.r4 18.1
+ IL_00c4: beq.s IL_012b
+ IL_00c6: ldarg.0
+ IL_00c7: ldc.r4 20.1
+ IL_00cc: beq.s IL_0133
+ IL_00ce: br.s IL_0138
+ IL_00d0: ldarg.0
+ IL_00d1: ldc.r4 10.1
+ IL_00d6: beq.s IL_011c
+ IL_00d8: ldarg.0
+ IL_00d9: ldc.r4 11.1
+ IL_00de: beq.s IL_0121
+ IL_00e0: ldarg.0
+ IL_00e1: ldc.r4 4.1
+ IL_00e6: beq.s IL_0123
+ IL_00e8: ldarg.0
+ IL_00e9: ldc.r4 7.1
+ IL_00ee: blt.un.s IL_00fa
+ IL_00f0: ldarg.0
+ IL_00f1: ldc.r4 9.1
+ IL_00f6: blt.s IL_012e
+ IL_00f8: br.s IL_0138
IL_00fa: ldarg.0
- IL_00fb: ldc.r4 7.1
- IL_0100: blt.un.s IL_010c
- IL_0102: ldarg.0
- IL_0103: ldc.r4 9.1
- IL_0108: blt.s IL_0160
- IL_010a: br.s IL_0172
- IL_010c: ldarg.0
- IL_010d: ldc.r4 5.1
- IL_0112: bge.s IL_016e
- IL_0114: br.s IL_0172
- IL_0116: ldc.i4.s 19
- IL_0118: stloc.0
- IL_0119: br.s IL_0174
- IL_011b: ldc.i4.s 18
- IL_011d: stloc.0
- IL_011e: br.s IL_0174
- IL_0120: ldc.i4.5
- IL_0121: stloc.0
- IL_0122: br.s IL_0174
- IL_0124: ldc.i4.1
- IL_0125: stloc.0
- IL_0126: br.s IL_0174
- IL_0128: ldc.i4.8
- IL_0129: stloc.0
- IL_012a: br.s IL_0174
- IL_012c: ldc.i4.s 15
- IL_012e: stloc.0
- IL_012f: br.s IL_0174
- IL_0131: ldc.i4.s 13
- IL_0133: stloc.0
- IL_0134: br.s IL_0174
- IL_0136: ldc.i4.s 20
- IL_0138: stloc.0
- IL_0139: br.s IL_0174
- IL_013b: ldc.i4.s 9
- IL_013d: stloc.0
- IL_013e: br.s IL_0174
- IL_0140: ldc.i4.6
- IL_0141: stloc.0
- IL_0142: br.s IL_0174
- IL_0144: ldc.i4.s 10
- IL_0146: stloc.0
- IL_0147: br.s IL_0174
- IL_0149: ldc.i4.7
- IL_014a: stloc.0
- IL_014b: br.s IL_0174
- IL_014d: ldc.i4.2
- IL_014e: stloc.0
- IL_014f: br.s IL_0174
- IL_0151: ldc.i4.s 11
- IL_0153: stloc.0
- IL_0154: br.s IL_0174
- IL_0156: ldc.i4.s 16
- IL_0158: stloc.0
- IL_0159: br.s IL_0174
- IL_015b: ldc.i4.s 12
- IL_015d: stloc.0
- IL_015e: br.s IL_0174
- IL_0160: ldc.i4.4
- IL_0161: stloc.0
- IL_0162: br.s IL_0174
- IL_0164: ldc.i4.s 17
- IL_0166: stloc.0
- IL_0167: br.s IL_0174
- IL_0169: ldc.i4.s 14
- IL_016b: stloc.0
- IL_016c: br.s IL_0174
- IL_016e: ldc.i4.3
- IL_016f: stloc.0
- IL_0170: br.s IL_0174
- IL_0172: ldc.i4.0
- IL_0173: stloc.0
- IL_0174: ldloc.0
- IL_0175: ret
+ IL_00fb: ldc.r4 5.1
+ IL_0100: bge.s IL_0136
+ IL_0102: br.s IL_0138
+ IL_0104: ldc.i4.s 19
+ IL_0106: ret
+ IL_0107: ldc.i4.s 18
+ IL_0109: ret
+ IL_010a: ldc.i4.5
+ IL_010b: ret
+ IL_010c: ldc.i4.1
+ IL_010d: ret
+ IL_010e: ldc.i4.8
+ IL_010f: ret
+ IL_0110: ldc.i4.s 15
+ IL_0112: ret
+ IL_0113: ldc.i4.s 13
+ IL_0115: ret
+ IL_0116: ldc.i4.s 20
+ IL_0118: ret
+ IL_0119: ldc.i4.s 9
+ IL_011b: ret
+ IL_011c: ldc.i4.6
+ IL_011d: ret
+ IL_011e: ldc.i4.s 10
+ IL_0120: ret
+ IL_0121: ldc.i4.7
+ IL_0122: ret
+ IL_0123: ldc.i4.2
+ IL_0124: ret
+ IL_0125: ldc.i4.s 11
+ IL_0127: ret
+ IL_0128: ldc.i4.s 16
+ IL_012a: ret
+ IL_012b: ldc.i4.s 12
+ IL_012d: ret
+ IL_012e: ldc.i4.4
+ IL_012f: ret
+ IL_0130: ldc.i4.s 17
+ IL_0132: ret
+ IL_0133: ldc.i4.s 14
+ IL_0135: ret
+ IL_0136: ldc.i4.3
+ IL_0137: ret
+ IL_0138: ldc.i4.0
+ IL_0139: ret
}
"
);
@@ -11546,9 +10918,8 @@ static int M(decimal d)
expectedOutput: expectedOutput);
compVerifier.VerifyIL("C.M", @"
{
- // Code size 751 (0x2ef)
+ // Code size 706 (0x2c2)
.maxstack 6
- .locals init (int V_0)
IL_0000: ldarg.0
IL_0001: ldc.i4 0x83
IL_0006: ldc.i4.0
@@ -11584,7 +10955,7 @@ .locals init (int V_0)
IL_0051: ldc.i4.1
IL_0052: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_0057: call ""bool decimal.op_LessThan(decimal, decimal)""
- IL_005c: brtrue IL_028f
+ IL_005c: brtrue IL_028c
IL_0061: ldarg.0
IL_0062: ldc.i4 0x123
IL_0067: ldc.i4.0
@@ -11593,8 +10964,8 @@ .locals init (int V_0)
IL_006a: ldc.i4.1
IL_006b: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_0070: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_0075: brtrue IL_02af
- IL_007a: br IL_02eb
+ IL_0075: brtrue IL_029e
+ IL_007a: br IL_02c0
IL_007f: ldarg.0
IL_0080: ldc.i4 0xe7
IL_0085: ldc.i4.0
@@ -11603,7 +10974,7 @@ .locals init (int V_0)
IL_0088: ldc.i4.1
IL_0089: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_008e: call ""bool decimal.op_LessThan(decimal, decimal)""
- IL_0093: brtrue IL_02a5
+ IL_0093: brtrue IL_0298
IL_0098: ldarg.0
IL_0099: ldc.i4 0xfb
IL_009e: ldc.i4.0
@@ -11612,7 +10983,7 @@ .locals init (int V_0)
IL_00a1: ldc.i4.1
IL_00a2: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_00a7: call ""bool decimal.op_LessThan(decimal, decimal)""
- IL_00ac: brtrue IL_02cf
+ IL_00ac: brtrue IL_02b0
IL_00b1: ldarg.0
IL_00b2: ldc.i4 0xfb
IL_00b7: ldc.i4.0
@@ -11621,7 +10992,7 @@ .locals init (int V_0)
IL_00ba: ldc.i4.1
IL_00bb: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_00c0: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_00c5: brtrue IL_02dd
+ IL_00c5: brtrue IL_02b8
IL_00ca: ldarg.0
IL_00cb: ldc.i4 0x105
IL_00d0: ldc.i4.0
@@ -11630,8 +11001,8 @@ .locals init (int V_0)
IL_00d3: ldc.i4.1
IL_00d4: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_00d9: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_00de: brtrue IL_0294
- IL_00e3: br IL_02eb
+ IL_00de: brtrue IL_028f
+ IL_00e3: br IL_02c0
IL_00e8: ldarg.0
IL_00e9: ldc.i4 0xa1
IL_00ee: ldc.i4.0
@@ -11649,7 +11020,7 @@ .locals init (int V_0)
IL_0107: ldc.i4.1
IL_0108: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_010d: call ""bool decimal.op_LessThan(decimal, decimal)""
- IL_0112: brtrue IL_02ca
+ IL_0112: brtrue IL_02ad
IL_0117: ldarg.0
IL_0118: ldc.i4 0xb5
IL_011d: ldc.i4.0
@@ -11658,7 +11029,7 @@ .locals init (int V_0)
IL_0120: ldc.i4.1
IL_0121: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_0126: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_012b: brtrue IL_02d4
+ IL_012b: brtrue IL_02b3
IL_0130: ldarg.0
IL_0131: ldc.i4 0xbf
IL_0136: ldc.i4.0
@@ -11667,7 +11038,7 @@ .locals init (int V_0)
IL_0139: ldc.i4.1
IL_013a: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_013f: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_0144: brtrue IL_02aa
+ IL_0144: brtrue IL_029b
IL_0149: ldarg.0
IL_014a: ldc.i4 0xc9
IL_014f: ldc.i4.0
@@ -11676,8 +11047,8 @@ .locals init (int V_0)
IL_0152: ldc.i4.1
IL_0153: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_0158: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_015d: brtrue IL_02e2
- IL_0162: br IL_02eb
+ IL_015d: brtrue IL_02bb
+ IL_0162: br IL_02c0
IL_0167: ldarg.0
IL_0168: ldc.i4 0x97
IL_016d: ldc.i4.0
@@ -11686,7 +11057,7 @@ .locals init (int V_0)
IL_0170: ldc.i4.1
IL_0171: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_0176: call ""bool decimal.op_LessThan(decimal, decimal)""
- IL_017b: brtrue IL_02b4
+ IL_017b: brtrue IL_02a1
IL_0180: ldarg.0
IL_0181: ldc.i4 0x97
IL_0186: ldc.i4.0
@@ -11695,8 +11066,8 @@ .locals init (int V_0)
IL_0189: ldc.i4.1
IL_018a: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_018f: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_0194: brtrue IL_02bd
- IL_0199: br IL_02eb
+ IL_0194: brtrue IL_02a6
+ IL_0199: br IL_02c0
IL_019e: ldarg.0
IL_019f: ldc.i4.s 71
IL_01a1: ldc.i4.0
@@ -11714,7 +11085,7 @@ .locals init (int V_0)
IL_01ba: ldc.i4.1
IL_01bb: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_01c0: call ""bool decimal.op_LessThan(decimal, decimal)""
- IL_01c5: brtrue IL_02d9
+ IL_01c5: brtrue IL_02b6
IL_01ca: ldarg.0
IL_01cb: ldc.i4.s 101
IL_01cd: ldc.i4.0
@@ -11732,7 +11103,7 @@ .locals init (int V_0)
IL_01e3: ldc.i4.1
IL_01e4: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_01e9: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_01ee: brtrue IL_0299
+ IL_01ee: brtrue IL_0292
IL_01f3: ldarg.0
IL_01f4: ldc.i4.s 101
IL_01f6: ldc.i4.0
@@ -11741,8 +11112,8 @@ .locals init (int V_0)
IL_01f9: ldc.i4.1
IL_01fa: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_01ff: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_0204: brtrue IL_02b9
- IL_0209: br IL_02eb
+ IL_0204: brtrue IL_02a4
+ IL_0209: br IL_02c0
IL_020e: ldarg.0
IL_020f: ldc.i4.s 111
IL_0211: ldc.i4.0
@@ -11751,7 +11122,7 @@ .locals init (int V_0)
IL_0214: ldc.i4.1
IL_0215: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_021a: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_021f: brtrue IL_02c2
+ IL_021f: brtrue IL_02a9
IL_0224: ldarg.0
IL_0225: ldc.i4.s 121
IL_0227: ldc.i4.0
@@ -11760,8 +11131,8 @@ .locals init (int V_0)
IL_022a: ldc.i4.1
IL_022b: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_0230: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_0235: brtrue.s IL_02a1
- IL_0237: br IL_02eb
+ IL_0235: brtrue.s IL_0296
+ IL_0237: br IL_02c0
IL_023c: ldarg.0
IL_023d: ldc.i4.s 41
IL_023f: ldc.i4.0
@@ -11770,7 +11141,7 @@ .locals init (int V_0)
IL_0242: ldc.i4.1
IL_0243: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_0248: call ""bool decimal.op_LessThan(decimal, decimal)""
- IL_024d: brfalse.s IL_0267
+ IL_024d: brfalse.s IL_0264
IL_024f: ldarg.0
IL_0250: ldc.i4.s 21
IL_0252: ldc.i4.0
@@ -11779,91 +11150,69 @@ .locals init (int V_0)
IL_0255: ldc.i4.1
IL_0256: newobj ""decimal..ctor(int, int, int, bool, byte)""
IL_025b: call ""bool decimal.op_GreaterThanOrEqual(decimal, decimal)""
- IL_0260: brtrue.s IL_029d
- IL_0262: br IL_02eb
- IL_0267: ldarg.0
- IL_0268: ldc.i4.s 51
- IL_026a: ldc.i4.0
- IL_026b: ldc.i4.0
- IL_026c: ldc.i4.0
- IL_026d: ldc.i4.1
- IL_026e: newobj ""decimal..ctor(int, int, int, bool, byte)""
- IL_0273: call ""bool decimal.op_GreaterThanOrEqual(decimal, decimal)""
- IL_0278: brtrue.s IL_02e7
- IL_027a: ldarg.0
- IL_027b: ldc.i4.s 41
- IL_027d: ldc.i4.0
- IL_027e: ldc.i4.0
- IL_027f: ldc.i4.0
- IL_0280: ldc.i4.1
- IL_0281: newobj ""decimal..ctor(int, int, int, bool, byte)""
- IL_0286: call ""bool decimal.op_Equality(decimal, decimal)""
- IL_028b: brtrue.s IL_02c6
- IL_028d: br.s IL_02eb
- IL_028f: ldc.i4.s 19
- IL_0291: stloc.0
- IL_0292: br.s IL_02ed
- IL_0294: ldc.i4.s 18
- IL_0296: stloc.0
- IL_0297: br.s IL_02ed
- IL_0299: ldc.i4.5
- IL_029a: stloc.0
- IL_029b: br.s IL_02ed
- IL_029d: ldc.i4.1
- IL_029e: stloc.0
- IL_029f: br.s IL_02ed
- IL_02a1: ldc.i4.8
- IL_02a2: stloc.0
- IL_02a3: br.s IL_02ed
- IL_02a5: ldc.i4.s 15
- IL_02a7: stloc.0
- IL_02a8: br.s IL_02ed
- IL_02aa: ldc.i4.s 13
- IL_02ac: stloc.0
- IL_02ad: br.s IL_02ed
- IL_02af: ldc.i4.s 20
- IL_02b1: stloc.0
- IL_02b2: br.s IL_02ed
- IL_02b4: ldc.i4.s 9
- IL_02b6: stloc.0
- IL_02b7: br.s IL_02ed
- IL_02b9: ldc.i4.6
- IL_02ba: stloc.0
- IL_02bb: br.s IL_02ed
- IL_02bd: ldc.i4.s 10
- IL_02bf: stloc.0
- IL_02c0: br.s IL_02ed
- IL_02c2: ldc.i4.7
- IL_02c3: stloc.0
- IL_02c4: br.s IL_02ed
- IL_02c6: ldc.i4.2
- IL_02c7: stloc.0
- IL_02c8: br.s IL_02ed
- IL_02ca: ldc.i4.s 11
- IL_02cc: stloc.0
- IL_02cd: br.s IL_02ed
- IL_02cf: ldc.i4.s 16
- IL_02d1: stloc.0
- IL_02d2: br.s IL_02ed
- IL_02d4: ldc.i4.s 12
- IL_02d6: stloc.0
- IL_02d7: br.s IL_02ed
- IL_02d9: ldc.i4.4
- IL_02da: stloc.0
- IL_02db: br.s IL_02ed
- IL_02dd: ldc.i4.s 17
- IL_02df: stloc.0
- IL_02e0: br.s IL_02ed
- IL_02e2: ldc.i4.s 14
- IL_02e4: stloc.0
- IL_02e5: br.s IL_02ed
- IL_02e7: ldc.i4.3
- IL_02e8: stloc.0
- IL_02e9: br.s IL_02ed
- IL_02eb: ldc.i4.0
- IL_02ec: stloc.0
- IL_02ed: ldloc.0
- IL_02ee: ret
+ IL_0260: brtrue.s IL_0294
+ IL_0262: br.s IL_02c0
+ IL_0264: ldarg.0
+ IL_0265: ldc.i4.s 51
+ IL_0267: ldc.i4.0
+ IL_0268: ldc.i4.0
+ IL_0269: ldc.i4.0
+ IL_026a: ldc.i4.1
+ IL_026b: newobj ""decimal..ctor(int, int, int, bool, byte)""
+ IL_0270: call ""bool decimal.op_GreaterThanOrEqual(decimal, decimal)""
+ IL_0275: brtrue.s IL_02be
+ IL_0277: ldarg.0
+ IL_0278: ldc.i4.s 41
+ IL_027a: ldc.i4.0
+ IL_027b: ldc.i4.0
+ IL_027c: ldc.i4.0
+ IL_027d: ldc.i4.1
+ IL_027e: newobj ""decimal..ctor(int, int, int, bool, byte)""
+ IL_0283: call ""bool decimal.op_Equality(decimal, decimal)""
+ IL_0288: brtrue.s IL_02ab
+ IL_028a: br.s IL_02c0
+ IL_028c: ldc.i4.s 19
+ IL_028e: ret
+ IL_028f: ldc.i4.s 18
+ IL_0291: ret
+ IL_0292: ldc.i4.5
+ IL_0293: ret
+ IL_0294: ldc.i4.1
+ IL_0295: ret
+ IL_0296: ldc.i4.8
+ IL_0297: ret
+ IL_0298: ldc.i4.s 15
+ IL_029a: ret
+ IL_029b: ldc.i4.s 13
+ IL_029d: ret
+ IL_029e: ldc.i4.s 20
+ IL_02a0: ret
+ IL_02a1: ldc.i4.s 9
+ IL_02a3: ret
+ IL_02a4: ldc.i4.6
+ IL_02a5: ret
+ IL_02a6: ldc.i4.s 10
+ IL_02a8: ret
+ IL_02a9: ldc.i4.7
+ IL_02aa: ret
+ IL_02ab: ldc.i4.2
+ IL_02ac: ret
+ IL_02ad: ldc.i4.s 11
+ IL_02af: ret
+ IL_02b0: ldc.i4.s 16
+ IL_02b2: ret
+ IL_02b3: ldc.i4.s 12
+ IL_02b5: ret
+ IL_02b6: ldc.i4.4
+ IL_02b7: ret
+ IL_02b8: ldc.i4.s 17
+ IL_02ba: ret
+ IL_02bb: ldc.i4.s 14
+ IL_02bd: ret
+ IL_02be: ldc.i4.3
+ IL_02bf: ret
+ IL_02c0: ldc.i4.0
+ IL_02c1: ret
}
"
);
@@ -11975,139 +11324,116 @@ static int M(uint d)
expectedOutput: expectedOutput);
compVerifier.VerifyIL("C.M", @"
{
- // Code size 243 (0xf3)
+ // Code size 177 (0xb1)
.maxstack 2
- .locals init (int V_0)
IL_0000: ldarg.0
IL_0001: ldc.i4.s 21
- IL_0003: blt.un.s IL_0039
+ IL_0003: blt.un.s IL_002a
IL_0005: ldarg.0
IL_0006: ldc.i4.s 27
- IL_0008: blt.un.s IL_001f
+ IL_0008: blt.un.s IL_0019
IL_000a: ldarg.0
IL_000b: ldc.i4.s 29
- IL_000d: blt.un IL_0093
- IL_0012: ldarg.0
- IL_0013: ldc.i4.s 29
- IL_0015: beq IL_00b3
- IL_001a: br IL_00ef
- IL_001f: ldarg.0
- IL_0020: ldc.i4.s 23
- IL_0022: blt.un IL_00a9
- IL_0027: ldarg.0
- IL_0028: ldc.i4.s 25
- IL_002a: blt.un IL_00d3
+ IL_000d: blt.un.s IL_007b
+ IL_000f: ldarg.0
+ IL_0010: ldc.i4.s 29
+ IL_0012: beq.s IL_008d
+ IL_0014: br IL_00af
+ IL_0019: ldarg.0
+ IL_001a: ldc.i4.s 23
+ IL_001c: blt.un.s IL_0087
+ IL_001e: ldarg.0
+ IL_001f: ldc.i4.s 25
+ IL_0021: blt.un.s IL_009f
+ IL_0023: ldarg.0
+ IL_0024: ldc.i4.s 26
+ IL_0026: beq.s IL_007e
+ IL_0028: br.s IL_00a7
+ IL_002a: ldarg.0
+ IL_002b: ldc.i4.s 13
+ IL_002d: blt.un.s IL_004c
IL_002f: ldarg.0
- IL_0030: ldc.i4.s 26
- IL_0032: beq.s IL_0098
- IL_0034: br IL_00e1
+ IL_0030: ldc.i4.s 15
+ IL_0032: blt.un.s IL_0090
+ IL_0034: ldarg.0
+ IL_0035: ldc.i4.s 18
+ IL_0037: bge.un.s IL_0040
IL_0039: ldarg.0
- IL_003a: ldc.i4.s 13
- IL_003c: blt.un.s IL_0061
- IL_003e: ldarg.0
- IL_003f: ldc.i4.s 15
- IL_0041: blt.un.s IL_00b8
- IL_0043: ldarg.0
- IL_0044: ldc.i4.s 18
- IL_0046: bge.un.s IL_004f
- IL_0048: ldarg.0
- IL_0049: ldc.i4.s 15
- IL_004b: beq.s IL_00c1
- IL_004d: br.s IL_00ce
- IL_004f: ldarg.0
- IL_0050: ldc.i4.s 18
- IL_0052: beq IL_00d8
- IL_0057: ldarg.0
- IL_0058: ldc.i4.s 19
- IL_005a: beq.s IL_00ae
- IL_005c: br IL_00e6
- IL_0061: ldarg.0
- IL_0062: ldc.i4.4
- IL_0063: bge.un.s IL_006e
- IL_0065: ldarg.0
- IL_0066: ldc.i4.2
- IL_0067: bge.un.s IL_00a1
- IL_0069: br IL_00ef
- IL_006e: ldarg.0
- IL_006f: ldc.i4.7
- IL_0070: blt.un.s IL_008d
- IL_0072: ldarg.0
- IL_0073: ldc.i4.s 9
- IL_0075: sub
- IL_0076: switch (
- IL_009d,
- IL_00bd,
- IL_00c6,
- IL_00a5)
- IL_008b: br.s IL_00dd
- IL_008d: ldarg.0
- IL_008e: ldc.i4.4
- IL_008f: beq.s IL_00ca
- IL_0091: br.s IL_00eb
- IL_0093: ldc.i4.s 19
- IL_0095: stloc.0
- IL_0096: br.s IL_00f1
- IL_0098: ldc.i4.s 18
- IL_009a: stloc.0
- IL_009b: br.s IL_00f1
- IL_009d: ldc.i4.5
- IL_009e: stloc.0
- IL_009f: br.s IL_00f1
- IL_00a1: ldc.i4.1
- IL_00a2: stloc.0
- IL_00a3: br.s IL_00f1
- IL_00a5: ldc.i4.8
- IL_00a6: stloc.0
- IL_00a7: br.s IL_00f1
- IL_00a9: ldc.i4.s 15
- IL_00ab: stloc.0
- IL_00ac: br.s IL_00f1
- IL_00ae: ldc.i4.s 13
- IL_00b0: stloc.0
- IL_00b1: br.s IL_00f1
- IL_00b3: ldc.i4.s 20
- IL_00b5: stloc.0
- IL_00b6: br.s IL_00f1
- IL_00b8: ldc.i4.s 9
- IL_00ba: stloc.0
- IL_00bb: br.s IL_00f1
- IL_00bd: ldc.i4.6
- IL_00be: stloc.0
- IL_00bf: br.s IL_00f1
- IL_00c1: ldc.i4.s 10
- IL_00c3: stloc.0
- IL_00c4: br.s IL_00f1
- IL_00c6: ldc.i4.7
- IL_00c7: stloc.0
- IL_00c8: br.s IL_00f1
- IL_00ca: ldc.i4.2
- IL_00cb: stloc.0
- IL_00cc: br.s IL_00f1
- IL_00ce: ldc.i4.s 11
- IL_00d0: stloc.0
- IL_00d1: br.s IL_00f1
- IL_00d3: ldc.i4.s 16
- IL_00d5: stloc.0
- IL_00d6: br.s IL_00f1
- IL_00d8: ldc.i4.s 12
- IL_00da: stloc.0
- IL_00db: br.s IL_00f1
- IL_00dd: ldc.i4.4
- IL_00de: stloc.0
- IL_00df: br.s IL_00f1
- IL_00e1: ldc.i4.s 17
- IL_00e3: stloc.0
- IL_00e4: br.s IL_00f1
- IL_00e6: ldc.i4.s 14
- IL_00e8: stloc.0
- IL_00e9: br.s IL_00f1
- IL_00eb: ldc.i4.3
- IL_00ec: stloc.0
- IL_00ed: br.s IL_00f1
- IL_00ef: ldc.i4.0
- IL_00f0: stloc.0
- IL_00f1: ldloc.0
- IL_00f2: ret
+ IL_003a: ldc.i4.s 15
+ IL_003c: beq.s IL_0095
+ IL_003e: br.s IL_009c
+ IL_0040: ldarg.0
+ IL_0041: ldc.i4.s 18
+ IL_0043: beq.s IL_00a2
+ IL_0045: ldarg.0
+ IL_0046: ldc.i4.s 19
+ IL_0048: beq.s IL_008a
+ IL_004a: br.s IL_00aa
+ IL_004c: ldarg.0
+ IL_004d: ldc.i4.4
+ IL_004e: bge.un.s IL_0056
+ IL_0050: ldarg.0
+ IL_0051: ldc.i4.2
+ IL_0052: bge.un.s IL_0083
+ IL_0054: br.s IL_00af
+ IL_0056: ldarg.0
+ IL_0057: ldc.i4.7
+ IL_0058: blt.un.s IL_0075
+ IL_005a: ldarg.0
+ IL_005b: ldc.i4.s 9
+ IL_005d: sub
+ IL_005e: switch (
+ IL_0081,
+ IL_0093,
+ IL_0098,
+ IL_0085)
+ IL_0073: br.s IL_00a5
+ IL_0075: ldarg.0
+ IL_0076: ldc.i4.4
+ IL_0077: beq.s IL_009a
+ IL_0079: br.s IL_00ad
+ IL_007b: ldc.i4.s 19
+ IL_007d: ret
+ IL_007e: ldc.i4.s 18
+ IL_0080: ret
+ IL_0081: ldc.i4.5
+ IL_0082: ret
+ IL_0083: ldc.i4.1
+ IL_0084: ret
+ IL_0085: ldc.i4.8
+ IL_0086: ret
+ IL_0087: ldc.i4.s 15
+ IL_0089: ret
+ IL_008a: ldc.i4.s 13
+ IL_008c: ret
+ IL_008d: ldc.i4.s 20
+ IL_008f: ret
+ IL_0090: ldc.i4.s 9
+ IL_0092: ret
+ IL_0093: ldc.i4.6
+ IL_0094: ret
+ IL_0095: ldc.i4.s 10
+ IL_0097: ret
+ IL_0098: ldc.i4.7
+ IL_0099: ret
+ IL_009a: ldc.i4.2
+ IL_009b: ret
+ IL_009c: ldc.i4.s 11
+ IL_009e: ret
+ IL_009f: ldc.i4.s 16
+ IL_00a1: ret
+ IL_00a2: ldc.i4.s 12
+ IL_00a4: ret
+ IL_00a5: ldc.i4.4
+ IL_00a6: ret
+ IL_00a7: ldc.i4.s 17
+ IL_00a9: ret
+ IL_00aa: ldc.i4.s 14
+ IL_00ac: ret
+ IL_00ad: ldc.i4.3
+ IL_00ae: ret
+ IL_00af: ldc.i4.0
+ IL_00b0: ret
}
"
);
diff --git a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenLengthBasedSwitchTests.cs b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenLengthBasedSwitchTests.cs
index c0b12384d7d97..0e0185da60f87 100644
--- a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenLengthBasedSwitchTests.cs
+++ b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenLengthBasedSwitchTests.cs
@@ -80,188 +80,168 @@ public static string M(string o)
verifier.VerifyMemberInIL(PrivateImplementationDetails.SynthesizedStringHashFunctionName + "(string)", expected: false);
verifier.VerifyIL("C.M", """
{
- // Code size 584 (0x248)
+ // Code size 530 (0x212)
.maxstack 2
- .locals init (string V_0,
- int V_1,
- char V_2)
+ .locals init (int V_0,
+ char V_1)
IL_0000: ldarg.0
- IL_0001: brfalse IL_0240
+ IL_0001: brfalse IL_020c
IL_0006: ldarg.0
IL_0007: call "int string.Length.get"
- IL_000c: stloc.1
- IL_000d: ldloc.1
+ IL_000c: stloc.0
+ IL_000d: ldloc.0
IL_000e: switch (
- IL_01b5,
+ IL_01a6,
IL_0030,
IL_00ae,
IL_00c3,
IL_00d8,
IL_0052)
- IL_002b: br IL_0240
+ IL_002b: br IL_020c
IL_0030: ldarg.0
IL_0031: ldc.i4.0
IL_0032: call "char string.this[int].get"
- IL_0037: stloc.2
- IL_0038: ldloc.2
+ IL_0037: stloc.1
+ IL_0038: ldloc.1
IL_0039: ldc.i4.s 97
IL_003b: sub
IL_003c: switch (
- IL_01c0,
- IL_01c8,
- IL_01d0)
- IL_004d: br IL_0240
+ IL_01ac,
+ IL_01b2,
+ IL_01b8)
+ IL_004d: br IL_020c
IL_0052: ldarg.0
IL_0053: ldc.i4.0
IL_0054: call "char string.this[int].get"
- IL_0059: stloc.2
- IL_005a: ldloc.2
+ IL_0059: stloc.1
+ IL_005a: ldloc.1
IL_005b: ldc.i4.s 104
IL_005d: bgt.un.s IL_007c
- IL_005f: ldloc.2
+ IL_005f: ldloc.1
IL_0060: ldc.i4.s 97
IL_0062: beq IL_00ed
- IL_0067: ldloc.2
+ IL_0067: ldloc.1
IL_0068: ldc.i4.s 98
IL_006a: beq IL_0102
- IL_006f: ldloc.2
+ IL_006f: ldloc.1
IL_0070: ldc.i4.s 104
IL_0072: beq IL_0117
- IL_0077: br IL_0240
- IL_007c: ldloc.2
+ IL_0077: br IL_020c
+ IL_007c: ldloc.1
IL_007d: ldc.i4.s 108
IL_007f: beq IL_012c
- IL_0084: ldloc.2
+ IL_0084: ldloc.1
IL_0085: ldc.i4.s 110
IL_0087: beq IL_0161
- IL_008c: ldloc.2
+ IL_008c: ldloc.1
IL_008d: ldc.i4.s 115
IL_008f: sub
IL_0090: switch (
IL_0176,
- IL_018b,
- IL_0240,
- IL_0240,
- IL_01a0)
- IL_00a9: br IL_0240
+ IL_0188,
+ IL_020c,
+ IL_020c,
+ IL_0197)
+ IL_00a9: br IL_020c
IL_00ae: ldarg.0
IL_00af: ldstr "no"
IL_00b4: call "bool string.op_Equality(string, string)"
- IL_00b9: brtrue IL_01d8
- IL_00be: br IL_0240
+ IL_00b9: brtrue IL_01be
+ IL_00be: br IL_020c
IL_00c3: ldarg.0
IL_00c4: ldstr "yes"
IL_00c9: call "bool string.op_Equality(string, string)"
- IL_00ce: brtrue IL_01e0
- IL_00d3: br IL_0240
+ IL_00ce: brtrue IL_01c4
+ IL_00d3: br IL_020c
IL_00d8: ldarg.0
IL_00d9: ldstr "four"
IL_00de: call "bool string.op_Equality(string, string)"
- IL_00e3: brtrue IL_01e8
- IL_00e8: br IL_0240
+ IL_00e3: brtrue IL_01ca
+ IL_00e8: br IL_020c
IL_00ed: ldarg.0
IL_00ee: ldstr "alice"
IL_00f3: call "bool string.op_Equality(string, string)"
- IL_00f8: brtrue IL_01f0
- IL_00fd: br IL_0240
+ IL_00f8: brtrue IL_01d0
+ IL_00fd: br IL_020c
IL_0102: ldarg.0
IL_0103: ldstr "blurb"
IL_0108: call "bool string.op_Equality(string, string)"
- IL_010d: brtrue IL_01f8
- IL_0112: br IL_0240
+ IL_010d: brtrue IL_01d6
+ IL_0112: br IL_020c
IL_0117: ldarg.0
IL_0118: ldstr "hello"
IL_011d: call "bool string.op_Equality(string, string)"
- IL_0122: brtrue IL_0200
- IL_0127: br IL_0240
+ IL_0122: brtrue IL_01dc
+ IL_0127: br IL_020c
IL_012c: ldarg.0
IL_012d: ldstr "lamps"
IL_0132: call "bool string.op_Equality(string, string)"
- IL_0137: brtrue IL_0208
+ IL_0137: brtrue IL_01e2
IL_013c: ldarg.0
IL_013d: ldstr "lambs"
IL_0142: call "bool string.op_Equality(string, string)"
- IL_0147: brtrue IL_0210
+ IL_0147: brtrue IL_01e8
IL_014c: ldarg.0
IL_014d: ldstr "lower"
IL_0152: call "bool string.op_Equality(string, string)"
- IL_0157: brtrue IL_0218
- IL_015c: br IL_0240
+ IL_0157: brtrue IL_01ee
+ IL_015c: br IL_020c
IL_0161: ldarg.0
IL_0162: ldstr "names"
IL_0167: call "bool string.op_Equality(string, string)"
- IL_016c: brtrue IL_0220
- IL_0171: br IL_0240
+ IL_016c: brtrue IL_01f4
+ IL_0171: br IL_020c
IL_0176: ldarg.0
IL_0177: ldstr "slurp"
IL_017c: call "bool string.op_Equality(string, string)"
- IL_0181: brtrue IL_0228
- IL_0186: br IL_0240
- IL_018b: ldarg.0
- IL_018c: ldstr "towed"
- IL_0191: call "bool string.op_Equality(string, string)"
- IL_0196: brtrue IL_0230
- IL_019b: br IL_0240
- IL_01a0: ldarg.0
- IL_01a1: ldstr "words"
- IL_01a6: call "bool string.op_Equality(string, string)"
- IL_01ab: brtrue IL_0238
- IL_01b0: br IL_0240
- IL_01b5: ldstr "blank"
- IL_01ba: stloc.0
- IL_01bb: br IL_0246
- IL_01c0: ldstr "a"
- IL_01c5: stloc.0
- IL_01c6: br.s IL_0246
- IL_01c8: ldstr "b"
- IL_01cd: stloc.0
- IL_01ce: br.s IL_0246
- IL_01d0: ldstr "c"
- IL_01d5: stloc.0
- IL_01d6: br.s IL_0246
- IL_01d8: ldstr "no"
- IL_01dd: stloc.0
- IL_01de: br.s IL_0246
- IL_01e0: ldstr "yes"
- IL_01e5: stloc.0
- IL_01e6: br.s IL_0246
- IL_01e8: ldstr "four"
- IL_01ed: stloc.0
- IL_01ee: br.s IL_0246
- IL_01f0: ldstr "alice"
- IL_01f5: stloc.0
- IL_01f6: br.s IL_0246
- IL_01f8: ldstr "blurb"
- IL_01fd: stloc.0
- IL_01fe: br.s IL_0246
- IL_0200: ldstr "hello"
- IL_0205: stloc.0
- IL_0206: br.s IL_0246
- IL_0208: ldstr "lamps"
- IL_020d: stloc.0
- IL_020e: br.s IL_0246
- IL_0210: ldstr "lambs"
- IL_0215: stloc.0
- IL_0216: br.s IL_0246
- IL_0218: ldstr "lower"
- IL_021d: stloc.0
- IL_021e: br.s IL_0246
- IL_0220: ldstr "names"
- IL_0225: stloc.0
- IL_0226: br.s IL_0246
- IL_0228: ldstr "slurp"
- IL_022d: stloc.0
- IL_022e: br.s IL_0246
- IL_0230: ldstr "towed"
- IL_0235: stloc.0
- IL_0236: br.s IL_0246
- IL_0238: ldstr "words"
- IL_023d: stloc.0
- IL_023e: br.s IL_0246
- IL_0240: ldstr "default"
- IL_0245: stloc.0
- IL_0246: ldloc.0
- IL_0247: ret
+ IL_0181: brtrue.s IL_01fa
+ IL_0183: br IL_020c
+ IL_0188: ldarg.0
+ IL_0189: ldstr "towed"
+ IL_018e: call "bool string.op_Equality(string, string)"
+ IL_0193: brtrue.s IL_0200
+ IL_0195: br.s IL_020c
+ IL_0197: ldarg.0
+ IL_0198: ldstr "words"
+ IL_019d: call "bool string.op_Equality(string, string)"
+ IL_01a2: brtrue.s IL_0206
+ IL_01a4: br.s IL_020c
+ IL_01a6: ldstr "blank"
+ IL_01ab: ret
+ IL_01ac: ldstr "a"
+ IL_01b1: ret
+ IL_01b2: ldstr "b"
+ IL_01b7: ret
+ IL_01b8: ldstr "c"
+ IL_01bd: ret
+ IL_01be: ldstr "no"
+ IL_01c3: ret
+ IL_01c4: ldstr "yes"
+ IL_01c9: ret
+ IL_01ca: ldstr "four"
+ IL_01cf: ret
+ IL_01d0: ldstr "alice"
+ IL_01d5: ret
+ IL_01d6: ldstr "blurb"
+ IL_01db: ret
+ IL_01dc: ldstr "hello"
+ IL_01e1: ret
+ IL_01e2: ldstr "lamps"
+ IL_01e7: ret
+ IL_01e8: ldstr "lambs"
+ IL_01ed: ret
+ IL_01ee: ldstr "lower"
+ IL_01f3: ret
+ IL_01f4: ldstr "names"
+ IL_01f9: ret
+ IL_01fa: ldstr "slurp"
+ IL_01ff: ret
+ IL_0200: ldstr "towed"
+ IL_0205: ret
+ IL_0206: ldstr "words"
+ IL_020b: ret
+ IL_020c: ldstr "default"
+ IL_0211: ret
}
""");
comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview.WithDisableLengthBasedSwitch());
@@ -271,234 +251,214 @@ .locals init (string V_0,
verifier.VerifyIL("C.M", """
{
- // Code size 786 (0x312)
+ // Code size 732 (0x2dc)
.maxstack 2
- .locals init (string V_0,
- uint V_1)
+ .locals init (uint V_0)
IL_0000: ldarg.0
IL_0001: call "uint .ComputeStringHash(string)"
- IL_0006: stloc.1
- IL_0007: ldloc.1
+ IL_0006: stloc.0
+ IL_0007: ldloc.0
IL_0008: ldc.i4 0x62366ffa
IL_000d: bgt.un IL_0096
- IL_0012: ldloc.1
+ IL_0012: ldloc.0
IL_0013: ldc.i4 0x3ec721c0
IL_0018: bgt.un.s IL_0058
- IL_001a: ldloc.1
+ IL_001a: ldloc.0
IL_001b: ldc.i4 0x2f69f5a5
IL_0020: bgt.un.s IL_003d
- IL_0022: ldloc.1
+ IL_0022: ldloc.0
IL_0023: ldc.i4 0x242602e6
IL_0028: beq IL_0201
- IL_002d: ldloc.1
+ IL_002d: ldloc.0
IL_002e: ldc.i4 0x2f69f5a5
IL_0033: beq IL_0198
- IL_0038: br IL_030a
- IL_003d: ldloc.1
+ IL_0038: br IL_02d6
+ IL_003d: ldloc.0
IL_003e: ldc.i4 0x3448ae58
IL_0043: beq IL_01ec
- IL_0048: ldloc.1
+ IL_0048: ldloc.0
IL_0049: ldc.i4 0x3ec721c0
- IL_004e: beq IL_0255
- IL_0053: br IL_030a
- IL_0058: ldloc.1
+ IL_004e: beq IL_0252
+ IL_0053: br IL_02d6
+ IL_0058: ldloc.0
IL_0059: ldc.i4 0x4f9f2cab
IL_005e: bgt.un.s IL_007b
- IL_0060: ldloc.1
+ IL_0060: ldloc.0
IL_0061: ldc.i4 0x4e9f3590
IL_0066: beq IL_0183
- IL_006b: ldloc.1
+ IL_006b: ldloc.0
IL_006c: ldc.i4 0x4f9f2cab
IL_0071: beq IL_01d7
- IL_0076: br IL_030a
- IL_007b: ldloc.1
+ IL_0076: br IL_02d6
+ IL_007b: ldloc.0
IL_007c: ldc.i4 0x5cb7aa8a
- IL_0081: beq IL_026a
- IL_0086: ldloc.1
+ IL_0081: beq IL_0261
+ IL_0086: ldloc.0
IL_0087: ldc.i4 0x62366ffa
IL_008c: beq IL_016e
- IL_0091: br IL_030a
- IL_0096: ldloc.1
+ IL_0091: br IL_02d6
+ IL_0096: ldloc.0
IL_0097: ldc.i4 0xb51d04ba
IL_009c: bgt.un.s IL_00d9
- IL_009e: ldloc.1
+ IL_009e: ldloc.0
IL_009f: ldc.i4 0x811c9dc5
IL_00a4: bgt.un.s IL_00be
- IL_00a6: ldloc.1
+ IL_00a6: ldloc.0
IL_00a7: ldc.i4 0x63cb5a27
IL_00ac: beq IL_0240
- IL_00b1: ldloc.1
+ IL_00b1: ldloc.0
IL_00b2: ldc.i4 0x811c9dc5
IL_00b7: beq.s IL_0119
- IL_00b9: br IL_030a
- IL_00be: ldloc.1
+ IL_00b9: br IL_02d6
+ IL_00be: ldloc.0
IL_00bf: ldc.i4 0x872213e7
IL_00c4: beq IL_01ad
- IL_00c9: ldloc.1
+ IL_00c9: ldloc.0
IL_00ca: ldc.i4 0xb51d04ba
IL_00cf: beq IL_0216
- IL_00d4: br IL_030a
- IL_00d9: ldloc.1
+ IL_00d4: br IL_02d6
+ IL_00d9: ldloc.0
IL_00da: ldc.i4 0xe60c2c52
IL_00df: bgt.un.s IL_00f6
- IL_00e1: ldloc.1
+ IL_00e1: ldloc.0
IL_00e2: ldc.i4 0xe40c292c
IL_00e7: beq.s IL_012f
- IL_00e9: ldloc.1
+ IL_00e9: ldloc.0
IL_00ea: ldc.i4 0xe60c2c52
IL_00ef: beq.s IL_0159
- IL_00f1: br IL_030a
- IL_00f6: ldloc.1
+ IL_00f1: br IL_02d6
+ IL_00f6: ldloc.0
IL_00f7: ldc.i4 0xe6e5718f
IL_00fc: beq IL_022b
- IL_0101: ldloc.1
+ IL_0101: ldloc.0
IL_0102: ldc.i4 0xe70c2de5
IL_0107: beq.s IL_0144
- IL_0109: ldloc.1
+ IL_0109: ldloc.0
IL_010a: ldc.i4 0xf76b8c8e
IL_010f: beq IL_01c2
- IL_0114: br IL_030a
+ IL_0114: br IL_02d6
IL_0119: ldarg.0
- IL_011a: brfalse IL_030a
+ IL_011a: brfalse IL_02d6
IL_011f: ldarg.0
IL_0120: call "int string.Length.get"
- IL_0125: brfalse IL_027f
- IL_012a: br IL_030a
+ IL_0125: brfalse IL_0270
+ IL_012a: br IL_02d6
IL_012f: ldarg.0
IL_0130: ldstr "a"
IL_0135: call "bool string.op_Equality(string, string)"
- IL_013a: brtrue IL_028a
- IL_013f: br IL_030a
+ IL_013a: brtrue IL_0276
+ IL_013f: br IL_02d6
IL_0144: ldarg.0
IL_0145: ldstr "b"
IL_014a: call "bool string.op_Equality(string, string)"
- IL_014f: brtrue IL_0292
- IL_0154: br IL_030a
+ IL_014f: brtrue IL_027c
+ IL_0154: br IL_02d6
IL_0159: ldarg.0
IL_015a: ldstr "c"
IL_015f: call "bool string.op_Equality(string, string)"
- IL_0164: brtrue IL_029a
- IL_0169: br IL_030a
+ IL_0164: brtrue IL_0282
+ IL_0169: br IL_02d6
IL_016e: ldarg.0
IL_016f: ldstr "no"
IL_0174: call "bool string.op_Equality(string, string)"
- IL_0179: brtrue IL_02a2
- IL_017e: br IL_030a
+ IL_0179: brtrue IL_0288
+ IL_017e: br IL_02d6
IL_0183: ldarg.0
IL_0184: ldstr "yes"
IL_0189: call "bool string.op_Equality(string, string)"
- IL_018e: brtrue IL_02aa
- IL_0193: br IL_030a
+ IL_018e: brtrue IL_028e
+ IL_0193: br IL_02d6
IL_0198: ldarg.0
IL_0199: ldstr "four"
IL_019e: call "bool string.op_Equality(string, string)"
- IL_01a3: brtrue IL_02b2
- IL_01a8: br IL_030a
+ IL_01a3: brtrue IL_0294
+ IL_01a8: br IL_02d6
IL_01ad: ldarg.0
IL_01ae: ldstr "alice"
IL_01b3: call "bool string.op_Equality(string, string)"
- IL_01b8: brtrue IL_02ba
- IL_01bd: br IL_030a
+ IL_01b8: brtrue IL_029a
+ IL_01bd: br IL_02d6
IL_01c2: ldarg.0
IL_01c3: ldstr "blurb"
IL_01c8: call "bool string.op_Equality(string, string)"
- IL_01cd: brtrue IL_02c2
- IL_01d2: br IL_030a
+ IL_01cd: brtrue IL_02a0
+ IL_01d2: br IL_02d6
IL_01d7: ldarg.0
IL_01d8: ldstr "hello"
IL_01dd: call "bool string.op_Equality(string, string)"
- IL_01e2: brtrue IL_02ca
- IL_01e7: br IL_030a
+ IL_01e2: brtrue IL_02a6
+ IL_01e7: br IL_02d6
IL_01ec: ldarg.0
IL_01ed: ldstr "lamps"
IL_01f2: call "bool string.op_Equality(string, string)"
- IL_01f7: brtrue IL_02d2
- IL_01fc: br IL_030a
+ IL_01f7: brtrue IL_02ac
+ IL_01fc: br IL_02d6
IL_0201: ldarg.0
IL_0202: ldstr "lambs"
IL_0207: call "bool string.op_Equality(string, string)"
- IL_020c: brtrue IL_02da
- IL_0211: br IL_030a
+ IL_020c: brtrue IL_02b2
+ IL_0211: br IL_02d6
IL_0216: ldarg.0
IL_0217: ldstr "lower"
IL_021c: call "bool string.op_Equality(string, string)"
- IL_0221: brtrue IL_02e2
- IL_0226: br IL_030a
+ IL_0221: brtrue IL_02b8
+ IL_0226: br IL_02d6
IL_022b: ldarg.0
IL_022c: ldstr "names"
IL_0231: call "bool string.op_Equality(string, string)"
- IL_0236: brtrue IL_02ea
- IL_023b: br IL_030a
+ IL_0236: brtrue IL_02be
+ IL_023b: br IL_02d6
IL_0240: ldarg.0
IL_0241: ldstr "slurp"
IL_0246: call "bool string.op_Equality(string, string)"
- IL_024b: brtrue IL_02f2
- IL_0250: br IL_030a
- IL_0255: ldarg.0
- IL_0256: ldstr "towed"
- IL_025b: call "bool string.op_Equality(string, string)"
- IL_0260: brtrue IL_02fa
- IL_0265: br IL_030a
- IL_026a: ldarg.0
- IL_026b: ldstr "words"
- IL_0270: call "bool string.op_Equality(string, string)"
- IL_0275: brtrue IL_0302
- IL_027a: br IL_030a
- IL_027f: ldstr "blank"
- IL_0284: stloc.0
- IL_0285: br IL_0310
- IL_028a: ldstr "a"
- IL_028f: stloc.0
- IL_0290: br.s IL_0310
- IL_0292: ldstr "b"
- IL_0297: stloc.0
- IL_0298: br.s IL_0310
- IL_029a: ldstr "c"
- IL_029f: stloc.0
- IL_02a0: br.s IL_0310
- IL_02a2: ldstr "no"
- IL_02a7: stloc.0
- IL_02a8: br.s IL_0310
- IL_02aa: ldstr "yes"
- IL_02af: stloc.0
- IL_02b0: br.s IL_0310
- IL_02b2: ldstr "four"
- IL_02b7: stloc.0
- IL_02b8: br.s IL_0310
- IL_02ba: ldstr "alice"
- IL_02bf: stloc.0
- IL_02c0: br.s IL_0310
- IL_02c2: ldstr "blurb"
- IL_02c7: stloc.0
- IL_02c8: br.s IL_0310
- IL_02ca: ldstr "hello"
- IL_02cf: stloc.0
- IL_02d0: br.s IL_0310
- IL_02d2: ldstr "lamps"
- IL_02d7: stloc.0
- IL_02d8: br.s IL_0310
- IL_02da: ldstr "lambs"
- IL_02df: stloc.0
- IL_02e0: br.s IL_0310
- IL_02e2: ldstr "lower"
- IL_02e7: stloc.0
- IL_02e8: br.s IL_0310
- IL_02ea: ldstr "names"
- IL_02ef: stloc.0
- IL_02f0: br.s IL_0310
- IL_02f2: ldstr "slurp"
- IL_02f7: stloc.0
- IL_02f8: br.s IL_0310
- IL_02fa: ldstr "towed"
- IL_02ff: stloc.0
- IL_0300: br.s IL_0310
- IL_0302: ldstr "words"
- IL_0307: stloc.0
- IL_0308: br.s IL_0310
- IL_030a: ldstr "default"
- IL_030f: stloc.0
- IL_0310: ldloc.0
- IL_0311: ret
+ IL_024b: brtrue.s IL_02c4
+ IL_024d: br IL_02d6
+ IL_0252: ldarg.0
+ IL_0253: ldstr "towed"
+ IL_0258: call "bool string.op_Equality(string, string)"
+ IL_025d: brtrue.s IL_02ca
+ IL_025f: br.s IL_02d6
+ IL_0261: ldarg.0
+ IL_0262: ldstr "words"
+ IL_0267: call "bool string.op_Equality(string, string)"
+ IL_026c: brtrue.s IL_02d0
+ IL_026e: br.s IL_02d6
+ IL_0270: ldstr "blank"
+ IL_0275: ret
+ IL_0276: ldstr "a"
+ IL_027b: ret
+ IL_027c: ldstr "b"
+ IL_0281: ret
+ IL_0282: ldstr "c"
+ IL_0287: ret
+ IL_0288: ldstr "no"
+ IL_028d: ret
+ IL_028e: ldstr "yes"
+ IL_0293: ret
+ IL_0294: ldstr "four"
+ IL_0299: ret
+ IL_029a: ldstr "alice"
+ IL_029f: ret
+ IL_02a0: ldstr "blurb"
+ IL_02a5: ret
+ IL_02a6: ldstr "hello"
+ IL_02ab: ret
+ IL_02ac: ldstr "lamps"
+ IL_02b1: ret
+ IL_02b2: ldstr "lambs"
+ IL_02b7: ret
+ IL_02b8: ldstr "lower"
+ IL_02bd: ret
+ IL_02be: ldstr "names"
+ IL_02c3: ret
+ IL_02c4: ldstr "slurp"
+ IL_02c9: ret
+ IL_02ca: ldstr "towed"
+ IL_02cf: ret
+ IL_02d0: ldstr "words"
+ IL_02d5: ret
+ IL_02d6: ldstr "default"
+ IL_02db: ret
}
""");
@@ -833,201 +793,181 @@ public static string M({{keyType}} o)
verifier.VerifyMemberInIL(PrivateImplementationDetails.SynthesizedStringHashFunctionName + "(string)", expected: false);
verifier.VerifyIL("C.M", $$"""
{
- // Code size 648 (0x288)
+ // Code size 597 (0x255)
.maxstack 2
- .locals init (string V_0,
- int V_1,
- char V_2)
+ .locals init (int V_0,
+ char V_1)
IL_0000: ldarga.s V_0
IL_0002: call "int {{keyType}}.Length.get"
- IL_0007: stloc.1
- IL_0008: ldloc.1
+ IL_0007: stloc.0
+ IL_0008: ldloc.0
IL_0009: switch (
- IL_01f5,
+ IL_01e9,
IL_002b,
IL_00ad,
IL_00c7,
IL_00e1,
IL_004f)
- IL_0026: br IL_0280
+ IL_0026: br IL_024f
IL_002b: ldarga.s V_0
IL_002d: ldc.i4.0
IL_002e: call "{{indexer}}"
IL_0033: ldind.u2
- IL_0034: stloc.2
- IL_0035: ldloc.2
+ IL_0034: stloc.1
+ IL_0035: ldloc.1
IL_0036: ldc.i4.s 97
IL_0038: sub
IL_0039: switch (
- IL_0200,
- IL_0208,
- IL_0210)
- IL_004a: br IL_0280
+ IL_01ef,
+ IL_01f5,
+ IL_01fb)
+ IL_004a: br IL_024f
IL_004f: ldarga.s V_0
IL_0051: ldc.i4.0
IL_0052: call "{{indexer}}"
IL_0057: ldind.u2
- IL_0058: stloc.2
- IL_0059: ldloc.2
+ IL_0058: stloc.1
+ IL_0059: ldloc.1
IL_005a: ldc.i4.s 104
IL_005c: bgt.un.s IL_007b
- IL_005e: ldloc.2
+ IL_005e: ldloc.1
IL_005f: ldc.i4.s 97
IL_0061: beq IL_00fb
- IL_0066: ldloc.2
+ IL_0066: ldloc.1
IL_0067: ldc.i4.s 98
IL_0069: beq IL_0115
- IL_006e: ldloc.2
+ IL_006e: ldloc.1
IL_006f: ldc.i4.s 104
IL_0071: beq IL_012f
- IL_0076: br IL_0280
- IL_007b: ldloc.2
+ IL_0076: br IL_024f
+ IL_007b: ldloc.1
IL_007c: ldc.i4.s 108
IL_007e: beq IL_0149
- IL_0083: ldloc.2
+ IL_0083: ldloc.1
IL_0084: ldc.i4.s 110
IL_0086: beq IL_018d
- IL_008b: ldloc.2
+ IL_008b: ldloc.1
IL_008c: ldc.i4.s 115
IL_008e: sub
IL_008f: switch (
IL_01a7,
IL_01c1,
- IL_0280,
- IL_0280,
- IL_01db)
- IL_00a8: br IL_0280
+ IL_024f,
+ IL_024f,
+ IL_01d5)
+ IL_00a8: br IL_024f
IL_00ad: ldarg.0
IL_00ae: ldstr "no"
IL_00b3: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_00b8: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_00bd: brtrue IL_0218
- IL_00c2: br IL_0280
+ IL_00bd: brtrue IL_0201
+ IL_00c2: br IL_024f
IL_00c7: ldarg.0
IL_00c8: ldstr "yes"
IL_00cd: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_00d2: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_00d7: brtrue IL_0220
- IL_00dc: br IL_0280
+ IL_00d7: brtrue IL_0207
+ IL_00dc: br IL_024f
IL_00e1: ldarg.0
IL_00e2: ldstr "four"
IL_00e7: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_00ec: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_00f1: brtrue IL_0228
- IL_00f6: br IL_0280
+ IL_00f1: brtrue IL_020d
+ IL_00f6: br IL_024f
IL_00fb: ldarg.0
IL_00fc: ldstr "alice"
IL_0101: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0106: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_010b: brtrue IL_0230
- IL_0110: br IL_0280
+ IL_010b: brtrue IL_0213
+ IL_0110: br IL_024f
IL_0115: ldarg.0
IL_0116: ldstr "blurb"
IL_011b: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0120: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_0125: brtrue IL_0238
- IL_012a: br IL_0280
+ IL_0125: brtrue IL_0219
+ IL_012a: br IL_024f
IL_012f: ldarg.0
IL_0130: ldstr "hello"
IL_0135: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_013a: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_013f: brtrue IL_0240
- IL_0144: br IL_0280
+ IL_013f: brtrue IL_021f
+ IL_0144: br IL_024f
IL_0149: ldarg.0
IL_014a: ldstr "lamps"
IL_014f: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0154: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_0159: brtrue IL_0248
+ IL_0159: brtrue IL_0225
IL_015e: ldarg.0
IL_015f: ldstr "lambs"
IL_0164: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0169: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_016e: brtrue IL_0250
+ IL_016e: brtrue IL_022b
IL_0173: ldarg.0
IL_0174: ldstr "lower"
IL_0179: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_017e: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_0183: brtrue IL_0258
- IL_0188: br IL_0280
+ IL_0183: brtrue IL_0231
+ IL_0188: br IL_024f
IL_018d: ldarg.0
IL_018e: ldstr "names"
IL_0193: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0198: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_019d: brtrue IL_0260
- IL_01a2: br IL_0280
+ IL_019d: brtrue IL_0237
+ IL_01a2: br IL_024f
IL_01a7: ldarg.0
IL_01a8: ldstr "slurp"
IL_01ad: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_01b2: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_01b7: brtrue IL_0268
- IL_01bc: br IL_0280
+ IL_01b7: brtrue IL_023d
+ IL_01bc: br IL_024f
IL_01c1: ldarg.0
IL_01c2: ldstr "towed"
IL_01c7: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_01cc: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_01d1: brtrue IL_0270
- IL_01d6: br IL_0280
- IL_01db: ldarg.0
- IL_01dc: ldstr "words"
- IL_01e1: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
- IL_01e6: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_01eb: brtrue IL_0278
- IL_01f0: br IL_0280
- IL_01f5: ldstr "blank"
- IL_01fa: stloc.0
- IL_01fb: br IL_0286
- IL_0200: ldstr "a"
- IL_0205: stloc.0
- IL_0206: br.s IL_0286
- IL_0208: ldstr "b"
- IL_020d: stloc.0
- IL_020e: br.s IL_0286
- IL_0210: ldstr "c"
- IL_0215: stloc.0
- IL_0216: br.s IL_0286
- IL_0218: ldstr "no"
- IL_021d: stloc.0
- IL_021e: br.s IL_0286
- IL_0220: ldstr "yes"
- IL_0225: stloc.0
- IL_0226: br.s IL_0286
- IL_0228: ldstr "four"
- IL_022d: stloc.0
- IL_022e: br.s IL_0286
- IL_0230: ldstr "alice"
- IL_0235: stloc.0
- IL_0236: br.s IL_0286
- IL_0238: ldstr "blurb"
- IL_023d: stloc.0
- IL_023e: br.s IL_0286
- IL_0240: ldstr "hello"
- IL_0245: stloc.0
- IL_0246: br.s IL_0286
- IL_0248: ldstr "lamps"
- IL_024d: stloc.0
- IL_024e: br.s IL_0286
- IL_0250: ldstr "lambs"
- IL_0255: stloc.0
- IL_0256: br.s IL_0286
- IL_0258: ldstr "lower"
- IL_025d: stloc.0
- IL_025e: br.s IL_0286
- IL_0260: ldstr "names"
- IL_0265: stloc.0
- IL_0266: br.s IL_0286
- IL_0268: ldstr "slurp"
- IL_026d: stloc.0
- IL_026e: br.s IL_0286
- IL_0270: ldstr "towed"
- IL_0275: stloc.0
- IL_0276: br.s IL_0286
- IL_0278: ldstr "words"
- IL_027d: stloc.0
- IL_027e: br.s IL_0286
- IL_0280: ldstr "default"
- IL_0285: stloc.0
- IL_0286: ldloc.0
- IL_0287: ret
+ IL_01d1: brtrue.s IL_0243
+ IL_01d3: br.s IL_024f
+ IL_01d5: ldarg.0
+ IL_01d6: ldstr "words"
+ IL_01db: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
+ IL_01e0: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
+ IL_01e5: brtrue.s IL_0249
+ IL_01e7: br.s IL_024f
+ IL_01e9: ldstr "blank"
+ IL_01ee: ret
+ IL_01ef: ldstr "a"
+ IL_01f4: ret
+ IL_01f5: ldstr "b"
+ IL_01fa: ret
+ IL_01fb: ldstr "c"
+ IL_0200: ret
+ IL_0201: ldstr "no"
+ IL_0206: ret
+ IL_0207: ldstr "yes"
+ IL_020c: ret
+ IL_020d: ldstr "four"
+ IL_0212: ret
+ IL_0213: ldstr "alice"
+ IL_0218: ret
+ IL_0219: ldstr "blurb"
+ IL_021e: ret
+ IL_021f: ldstr "hello"
+ IL_0224: ret
+ IL_0225: ldstr "lamps"
+ IL_022a: ret
+ IL_022b: ldstr "lambs"
+ IL_0230: ret
+ IL_0231: ldstr "lower"
+ IL_0236: ret
+ IL_0237: ldstr "names"
+ IL_023c: ret
+ IL_023d: ldstr "slurp"
+ IL_0242: ret
+ IL_0243: ldstr "towed"
+ IL_0248: ret
+ IL_0249: ldstr "words"
+ IL_024e: ret
+ IL_024f: ldstr "default"
+ IL_0254: ret
}
""");
@@ -1038,248 +978,228 @@ .locals init (string V_0,
verifier.VerifyMemberInIL("." + helper, expected: true);
verifier.VerifyIL("C.M", $$"""
{
- // Code size 861 (0x35d)
+ // Code size 810 (0x32a)
.maxstack 2
- .locals init (string V_0,
- uint V_1)
+ .locals init (uint V_0)
IL_0000: ldarg.0
IL_0001: call "uint .{{helper}}"
- IL_0006: stloc.1
- IL_0007: ldloc.1
+ IL_0006: stloc.0
+ IL_0007: ldloc.0
IL_0008: ldc.i4 0x62366ffa
IL_000d: bgt.un IL_0096
- IL_0012: ldloc.1
+ IL_0012: ldloc.0
IL_0013: ldc.i4 0x3ec721c0
IL_0018: bgt.un.s IL_0058
- IL_001a: ldloc.1
+ IL_001a: ldloc.0
IL_001b: ldc.i4 0x2f69f5a5
IL_0020: bgt.un.s IL_003d
- IL_0022: ldloc.1
+ IL_0022: ldloc.0
IL_0023: ldc.i4 0x242602e6
IL_0028: beq IL_022e
- IL_002d: ldloc.1
+ IL_002d: ldloc.0
IL_002e: ldc.i4 0x2f69f5a5
IL_0033: beq IL_01ac
- IL_0038: br IL_0355
- IL_003d: ldloc.1
+ IL_0038: br IL_0324
+ IL_003d: ldloc.0
IL_003e: ldc.i4 0x3448ae58
IL_0043: beq IL_0214
- IL_0048: ldloc.1
+ IL_0048: ldloc.0
IL_0049: ldc.i4 0x3ec721c0
IL_004e: beq IL_0296
- IL_0053: br IL_0355
- IL_0058: ldloc.1
+ IL_0053: br IL_0324
+ IL_0058: ldloc.0
IL_0059: ldc.i4 0x4f9f2cab
IL_005e: bgt.un.s IL_007b
- IL_0060: ldloc.1
+ IL_0060: ldloc.0
IL_0061: ldc.i4 0x4e9f3590
IL_0066: beq IL_0192
- IL_006b: ldloc.1
+ IL_006b: ldloc.0
IL_006c: ldc.i4 0x4f9f2cab
IL_0071: beq IL_01fa
- IL_0076: br IL_0355
- IL_007b: ldloc.1
+ IL_0076: br IL_0324
+ IL_007b: ldloc.0
IL_007c: ldc.i4 0x5cb7aa8a
- IL_0081: beq IL_02b0
- IL_0086: ldloc.1
+ IL_0081: beq IL_02aa
+ IL_0086: ldloc.0
IL_0087: ldc.i4 0x62366ffa
IL_008c: beq IL_0178
- IL_0091: br IL_0355
- IL_0096: ldloc.1
+ IL_0091: br IL_0324
+ IL_0096: ldloc.0
IL_0097: ldc.i4 0xb51d04ba
IL_009c: bgt.un.s IL_00d9
- IL_009e: ldloc.1
+ IL_009e: ldloc.0
IL_009f: ldc.i4 0x811c9dc5
IL_00a4: bgt.un.s IL_00be
- IL_00a6: ldloc.1
+ IL_00a6: ldloc.0
IL_00a7: ldc.i4 0x63cb5a27
IL_00ac: beq IL_027c
- IL_00b1: ldloc.1
+ IL_00b1: ldloc.0
IL_00b2: ldc.i4 0x811c9dc5
IL_00b7: beq.s IL_0119
- IL_00b9: br IL_0355
- IL_00be: ldloc.1
+ IL_00b9: br IL_0324
+ IL_00be: ldloc.0
IL_00bf: ldc.i4 0x872213e7
IL_00c4: beq IL_01c6
- IL_00c9: ldloc.1
+ IL_00c9: ldloc.0
IL_00ca: ldc.i4 0xb51d04ba
IL_00cf: beq IL_0248
- IL_00d4: br IL_0355
- IL_00d9: ldloc.1
+ IL_00d4: br IL_0324
+ IL_00d9: ldloc.0
IL_00da: ldc.i4 0xe60c2c52
IL_00df: bgt.un.s IL_00f6
- IL_00e1: ldloc.1
+ IL_00e1: ldloc.0
IL_00e2: ldc.i4 0xe40c292c
IL_00e7: beq.s IL_012a
- IL_00e9: ldloc.1
+ IL_00e9: ldloc.0
IL_00ea: ldc.i4 0xe60c2c52
IL_00ef: beq.s IL_015e
- IL_00f1: br IL_0355
- IL_00f6: ldloc.1
+ IL_00f1: br IL_0324
+ IL_00f6: ldloc.0
IL_00f7: ldc.i4 0xe6e5718f
IL_00fc: beq IL_0262
- IL_0101: ldloc.1
+ IL_0101: ldloc.0
IL_0102: ldc.i4 0xe70c2de5
IL_0107: beq.s IL_0144
- IL_0109: ldloc.1
+ IL_0109: ldloc.0
IL_010a: ldc.i4 0xf76b8c8e
IL_010f: beq IL_01e0
- IL_0114: br IL_0355
+ IL_0114: br IL_0324
IL_0119: ldarga.s V_0
IL_011b: call "int {{keyType}}.Length.get"
- IL_0120: brfalse IL_02ca
- IL_0125: br IL_0355
+ IL_0120: brfalse IL_02be
+ IL_0125: br IL_0324
IL_012a: ldarg.0
IL_012b: ldstr "a"
IL_0130: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0135: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_013a: brtrue IL_02d5
- IL_013f: br IL_0355
+ IL_013a: brtrue IL_02c4
+ IL_013f: br IL_0324
IL_0144: ldarg.0
IL_0145: ldstr "b"
IL_014a: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_014f: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_0154: brtrue IL_02dd
- IL_0159: br IL_0355
+ IL_0154: brtrue IL_02ca
+ IL_0159: br IL_0324
IL_015e: ldarg.0
IL_015f: ldstr "c"
IL_0164: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0169: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_016e: brtrue IL_02e5
- IL_0173: br IL_0355
+ IL_016e: brtrue IL_02d0
+ IL_0173: br IL_0324
IL_0178: ldarg.0
IL_0179: ldstr "no"
IL_017e: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0183: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_0188: brtrue IL_02ed
- IL_018d: br IL_0355
+ IL_0188: brtrue IL_02d6
+ IL_018d: br IL_0324
IL_0192: ldarg.0
IL_0193: ldstr "yes"
IL_0198: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_019d: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_01a2: brtrue IL_02f5
- IL_01a7: br IL_0355
+ IL_01a2: brtrue IL_02dc
+ IL_01a7: br IL_0324
IL_01ac: ldarg.0
IL_01ad: ldstr "four"
IL_01b2: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_01b7: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_01bc: brtrue IL_02fd
- IL_01c1: br IL_0355
+ IL_01bc: brtrue IL_02e2
+ IL_01c1: br IL_0324
IL_01c6: ldarg.0
IL_01c7: ldstr "alice"
IL_01cc: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_01d1: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_01d6: brtrue IL_0305
- IL_01db: br IL_0355
+ IL_01d6: brtrue IL_02e8
+ IL_01db: br IL_0324
IL_01e0: ldarg.0
IL_01e1: ldstr "blurb"
IL_01e6: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_01eb: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_01f0: brtrue IL_030d
- IL_01f5: br IL_0355
+ IL_01f0: brtrue IL_02ee
+ IL_01f5: br IL_0324
IL_01fa: ldarg.0
IL_01fb: ldstr "hello"
IL_0200: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0205: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_020a: brtrue IL_0315
- IL_020f: br IL_0355
+ IL_020a: brtrue IL_02f4
+ IL_020f: br IL_0324
IL_0214: ldarg.0
IL_0215: ldstr "lamps"
IL_021a: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_021f: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_0224: brtrue IL_031d
- IL_0229: br IL_0355
+ IL_0224: brtrue IL_02fa
+ IL_0229: br IL_0324
IL_022e: ldarg.0
IL_022f: ldstr "lambs"
IL_0234: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0239: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_023e: brtrue IL_0325
- IL_0243: br IL_0355
+ IL_023e: brtrue IL_0300
+ IL_0243: br IL_0324
IL_0248: ldarg.0
IL_0249: ldstr "lower"
IL_024e: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0253: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_0258: brtrue IL_032d
- IL_025d: br IL_0355
+ IL_0258: brtrue IL_0306
+ IL_025d: br IL_0324
IL_0262: ldarg.0
IL_0263: ldstr "names"
IL_0268: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_026d: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_0272: brtrue IL_0335
- IL_0277: br IL_0355
+ IL_0272: brtrue IL_030c
+ IL_0277: br IL_0324
IL_027c: ldarg.0
IL_027d: ldstr "slurp"
IL_0282: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0287: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_028c: brtrue IL_033d
- IL_0291: br IL_0355
+ IL_028c: brtrue IL_0312
+ IL_0291: br IL_0324
IL_0296: ldarg.0
IL_0297: ldstr "towed"
IL_029c: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_02a1: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_02a6: brtrue IL_0345
- IL_02ab: br IL_0355
- IL_02b0: ldarg.0
- IL_02b1: ldstr "words"
- IL_02b6: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
- IL_02bb: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
- IL_02c0: brtrue IL_034d
- IL_02c5: br IL_0355
- IL_02ca: ldstr "blank"
- IL_02cf: stloc.0
- IL_02d0: br IL_035b
- IL_02d5: ldstr "a"
- IL_02da: stloc.0
- IL_02db: br.s IL_035b
- IL_02dd: ldstr "b"
- IL_02e2: stloc.0
- IL_02e3: br.s IL_035b
- IL_02e5: ldstr "c"
- IL_02ea: stloc.0
- IL_02eb: br.s IL_035b
- IL_02ed: ldstr "no"
- IL_02f2: stloc.0
- IL_02f3: br.s IL_035b
- IL_02f5: ldstr "yes"
- IL_02fa: stloc.0
- IL_02fb: br.s IL_035b
- IL_02fd: ldstr "four"
- IL_0302: stloc.0
- IL_0303: br.s IL_035b
- IL_0305: ldstr "alice"
- IL_030a: stloc.0
- IL_030b: br.s IL_035b
- IL_030d: ldstr "blurb"
- IL_0312: stloc.0
- IL_0313: br.s IL_035b
- IL_0315: ldstr "hello"
- IL_031a: stloc.0
- IL_031b: br.s IL_035b
- IL_031d: ldstr "lamps"
- IL_0322: stloc.0
- IL_0323: br.s IL_035b
- IL_0325: ldstr "lambs"
- IL_032a: stloc.0
- IL_032b: br.s IL_035b
- IL_032d: ldstr "lower"
- IL_0332: stloc.0
- IL_0333: br.s IL_035b
- IL_0335: ldstr "names"
- IL_033a: stloc.0
- IL_033b: br.s IL_035b
- IL_033d: ldstr "slurp"
- IL_0342: stloc.0
- IL_0343: br.s IL_035b
- IL_0345: ldstr "towed"
- IL_034a: stloc.0
- IL_034b: br.s IL_035b
- IL_034d: ldstr "words"
- IL_0352: stloc.0
- IL_0353: br.s IL_035b
- IL_0355: ldstr "default"
- IL_035a: stloc.0
- IL_035b: ldloc.0
- IL_035c: ret
+ IL_02a6: brtrue.s IL_0318
+ IL_02a8: br.s IL_0324
+ IL_02aa: ldarg.0
+ IL_02ab: ldstr "words"
+ IL_02b0: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
+ IL_02b5: call "bool System.MemoryExtensions.SequenceEqual({{keyType}}, System.ReadOnlySpan)"
+ IL_02ba: brtrue.s IL_031e
+ IL_02bc: br.s IL_0324
+ IL_02be: ldstr "blank"
+ IL_02c3: ret
+ IL_02c4: ldstr "a"
+ IL_02c9: ret
+ IL_02ca: ldstr "b"
+ IL_02cf: ret
+ IL_02d0: ldstr "c"
+ IL_02d5: ret
+ IL_02d6: ldstr "no"
+ IL_02db: ret
+ IL_02dc: ldstr "yes"
+ IL_02e1: ret
+ IL_02e2: ldstr "four"
+ IL_02e7: ret
+ IL_02e8: ldstr "alice"
+ IL_02ed: ret
+ IL_02ee: ldstr "blurb"
+ IL_02f3: ret
+ IL_02f4: ldstr "hello"
+ IL_02f9: ret
+ IL_02fa: ldstr "lamps"
+ IL_02ff: ret
+ IL_0300: ldstr "lambs"
+ IL_0305: ret
+ IL_0306: ldstr "lower"
+ IL_030b: ret
+ IL_030c: ldstr "names"
+ IL_0311: ret
+ IL_0312: ldstr "slurp"
+ IL_0317: ret
+ IL_0318: ldstr "towed"
+ IL_031d: ret
+ IL_031e: ldstr "words"
+ IL_0323: ret
+ IL_0324: ldstr "default"
+ IL_0329: ret
}
""");
}
@@ -1369,103 +1289,92 @@ public static string M(object o)
verifier.VerifyMemberInIL(PrivateImplementationDetails.SynthesizedStringHashFunctionName + "(string)", expected: false);
verifier.VerifyIL("C.M", """
{
- // Code size 272 (0x110)
+ // Code size 251 (0xfb)
.maxstack 2
.locals init (string V_0,
- string V_1,
- int V_2,
- char V_3)
+ int V_1,
+ char V_2)
IL_0000: ldarg.0
IL_0001: isinst "string"
- IL_0006: stloc.1
- IL_0007: ldloc.1
- IL_0008: brfalse IL_0108
- IL_000d: ldloc.1
- IL_000e: brfalse IL_0108
- IL_0013: ldloc.1
+ IL_0006: stloc.0
+ IL_0007: ldloc.0
+ IL_0008: brfalse IL_00f5
+ IL_000d: ldloc.0
+ IL_000e: brfalse IL_00f5
+ IL_0013: ldloc.0
IL_0014: call "int string.Length.get"
- IL_0019: stloc.2
- IL_001a: ldloc.2
+ IL_0019: stloc.1
+ IL_001a: ldloc.1
IL_001b: ldc.i4.1
IL_001c: sub
IL_001d: switch (
IL_0047,
IL_0059,
IL_006b,
- IL_007d,
- IL_008c,
- IL_009b,
- IL_00aa,
- IL_00b9)
- IL_0042: br IL_0108
- IL_0047: ldloc.1
+ IL_007a,
+ IL_0089,
+ IL_0098,
+ IL_00a7,
+ IL_00b6)
+ IL_0042: br IL_00f5
+ IL_0047: ldloc.0
IL_0048: ldstr "a"
IL_004d: call "bool string.op_Equality(string, string)"
- IL_0052: brtrue.s IL_00c8
- IL_0054: br IL_0108
- IL_0059: ldloc.1
+ IL_0052: brtrue.s IL_00c5
+ IL_0054: br IL_00f5
+ IL_0059: ldloc.0
IL_005a: ldstr "ab"
IL_005f: call "bool string.op_Equality(string, string)"
- IL_0064: brtrue.s IL_00d0
- IL_0066: br IL_0108
- IL_006b: ldloc.1
+ IL_0064: brtrue.s IL_00cb
+ IL_0066: br IL_00f5
+ IL_006b: ldloc.0
IL_006c: ldstr "abc"
IL_0071: call "bool string.op_Equality(string, string)"
- IL_0076: brtrue.s IL_00d8
- IL_0078: br IL_0108
- IL_007d: ldloc.1
- IL_007e: ldstr "abcd"
- IL_0083: call "bool string.op_Equality(string, string)"
- IL_0088: brtrue.s IL_00e0
- IL_008a: br.s IL_0108
- IL_008c: ldloc.1
- IL_008d: ldstr "abcde"
- IL_0092: call "bool string.op_Equality(string, string)"
- IL_0097: brtrue.s IL_00e8
- IL_0099: br.s IL_0108
- IL_009b: ldloc.1
- IL_009c: ldstr "abcdef"
- IL_00a1: call "bool string.op_Equality(string, string)"
- IL_00a6: brtrue.s IL_00f0
- IL_00a8: br.s IL_0108
- IL_00aa: ldloc.1
- IL_00ab: ldstr "abcdefg"
- IL_00b0: call "bool string.op_Equality(string, string)"
- IL_00b5: brtrue.s IL_00f8
- IL_00b7: br.s IL_0108
- IL_00b9: ldloc.1
- IL_00ba: ldstr "abcdefgh"
- IL_00bf: call "bool string.op_Equality(string, string)"
- IL_00c4: brtrue.s IL_0100
- IL_00c6: br.s IL_0108
- IL_00c8: ldstr "a"
- IL_00cd: stloc.0
- IL_00ce: br.s IL_010e
- IL_00d0: ldstr "ab"
- IL_00d5: stloc.0
- IL_00d6: br.s IL_010e
- IL_00d8: ldstr "abc"
- IL_00dd: stloc.0
- IL_00de: br.s IL_010e
- IL_00e0: ldstr "abcd"
- IL_00e5: stloc.0
- IL_00e6: br.s IL_010e
- IL_00e8: ldstr "abcde"
- IL_00ed: stloc.0
- IL_00ee: br.s IL_010e
- IL_00f0: ldstr "abcdef"
- IL_00f5: stloc.0
- IL_00f6: br.s IL_010e
- IL_00f8: ldstr "abcdefg"
- IL_00fd: stloc.0
- IL_00fe: br.s IL_010e
- IL_0100: ldstr "abcdefgh"
- IL_0105: stloc.0
- IL_0106: br.s IL_010e
- IL_0108: ldstr "default"
- IL_010d: stloc.0
- IL_010e: ldloc.0
- IL_010f: ret
+ IL_0076: brtrue.s IL_00d1
+ IL_0078: br.s IL_00f5
+ IL_007a: ldloc.0
+ IL_007b: ldstr "abcd"
+ IL_0080: call "bool string.op_Equality(string, string)"
+ IL_0085: brtrue.s IL_00d7
+ IL_0087: br.s IL_00f5
+ IL_0089: ldloc.0
+ IL_008a: ldstr "abcde"
+ IL_008f: call "bool string.op_Equality(string, string)"
+ IL_0094: brtrue.s IL_00dd
+ IL_0096: br.s IL_00f5
+ IL_0098: ldloc.0
+ IL_0099: ldstr "abcdef"
+ IL_009e: call "bool string.op_Equality(string, string)"
+ IL_00a3: brtrue.s IL_00e3
+ IL_00a5: br.s IL_00f5
+ IL_00a7: ldloc.0
+ IL_00a8: ldstr "abcdefg"
+ IL_00ad: call "bool string.op_Equality(string, string)"
+ IL_00b2: brtrue.s IL_00e9
+ IL_00b4: br.s IL_00f5
+ IL_00b6: ldloc.0
+ IL_00b7: ldstr "abcdefgh"
+ IL_00bc: call "bool string.op_Equality(string, string)"
+ IL_00c1: brtrue.s IL_00ef
+ IL_00c3: br.s IL_00f5
+ IL_00c5: ldstr "a"
+ IL_00ca: ret
+ IL_00cb: ldstr "ab"
+ IL_00d0: ret
+ IL_00d1: ldstr "abc"
+ IL_00d6: ret
+ IL_00d7: ldstr "abcd"
+ IL_00dc: ret
+ IL_00dd: ldstr "abcde"
+ IL_00e2: ret
+ IL_00e3: ldstr "abcdef"
+ IL_00e8: ret
+ IL_00e9: ldstr "abcdefg"
+ IL_00ee: ret
+ IL_00ef: ldstr "abcdefgh"
+ IL_00f4: ret
+ IL_00f5: ldstr "default"
+ IL_00fa: ret
}
""");
@@ -1475,124 +1384,113 @@ .locals init (string V_0,
verifier.VerifyMemberInIL("." + PrivateImplementationDetails.SynthesizedStringHashFunctionName + "(string)", expected: true);
verifier.VerifyIL("C.M", """
{
- // Code size 335 (0x14f)
+ // Code size 314 (0x13a)
.maxstack 2
.locals init (string V_0,
- string V_1,
- uint V_2)
+ uint V_1)
IL_0000: ldarg.0
IL_0001: isinst "string"
- IL_0006: stloc.1
- IL_0007: ldloc.1
- IL_0008: brfalse IL_0147
- IL_000d: ldloc.1
+ IL_0006: stloc.0
+ IL_0007: ldloc.0
+ IL_0008: brfalse IL_0134
+ IL_000d: ldloc.0
IL_000e: call "uint .ComputeStringHash(string)"
- IL_0013: stloc.2
- IL_0014: ldloc.2
+ IL_0013: stloc.1
+ IL_0014: ldloc.1
IL_0015: ldc.i4 0x749bcf08
IL_001a: bgt.un.s IL_0051
- IL_001c: ldloc.2
+ IL_001c: ldloc.1
IL_001d: ldc.i4 0x2a9eb737
IL_0022: bgt.un.s IL_003c
- IL_0024: ldloc.2
+ IL_0024: ldloc.1
IL_0025: ldc.i4 0x1a47e90b
IL_002a: beq.s IL_00aa
- IL_002c: ldloc.2
+ IL_002c: ldloc.1
IL_002d: ldc.i4 0x2a9eb737
- IL_0032: beq IL_00e9
- IL_0037: br IL_0147
- IL_003c: ldloc.2
+ IL_0032: beq IL_00e6
+ IL_0037: br IL_0134
+ IL_003c: ldloc.1
IL_003d: ldc.i4 0x4d2505ca
IL_0042: beq.s IL_0098
- IL_0044: ldloc.2
+ IL_0044: ldloc.1
IL_0045: ldc.i4 0x749bcf08
- IL_004a: beq.s IL_00cb
- IL_004c: br IL_0147
- IL_0051: ldloc.2
+ IL_004a: beq.s IL_00c8
+ IL_004c: br IL_0134
+ IL_0051: ldloc.1
IL_0052: ldc.i4 0xce3479bd
IL_0057: bgt.un.s IL_0071
- IL_0059: ldloc.2
+ IL_0059: ldloc.1
IL_005a: ldc.i4 0x76daaa8d
- IL_005f: beq IL_00f8
- IL_0064: ldloc.2
+ IL_005f: beq IL_00f5
+ IL_0064: ldloc.1
IL_0065: ldc.i4 0xce3479bd
- IL_006a: beq.s IL_00bc
- IL_006c: br IL_0147
- IL_0071: ldloc.2
+ IL_006a: beq.s IL_00b9
+ IL_006c: br IL_0134
+ IL_0071: ldloc.1
IL_0072: ldc.i4 0xe40c292c
IL_0077: beq.s IL_0086
- IL_0079: ldloc.2
+ IL_0079: ldloc.1
IL_007a: ldc.i4 0xff478a2a
- IL_007f: beq.s IL_00da
- IL_0081: br IL_0147
- IL_0086: ldloc.1
+ IL_007f: beq.s IL_00d7
+ IL_0081: br IL_0134
+ IL_0086: ldloc.0
IL_0087: ldstr "a"
IL_008c: call "bool string.op_Equality(string, string)"
- IL_0091: brtrue.s IL_0107
- IL_0093: br IL_0147
- IL_0098: ldloc.1
+ IL_0091: brtrue.s IL_0104
+ IL_0093: br IL_0134
+ IL_0098: ldloc.0
IL_0099: ldstr "ab"
IL_009e: call "bool string.op_Equality(string, string)"
- IL_00a3: brtrue.s IL_010f
- IL_00a5: br IL_0147
- IL_00aa: ldloc.1
+ IL_00a3: brtrue.s IL_010a
+ IL_00a5: br IL_0134
+ IL_00aa: ldloc.0
IL_00ab: ldstr "abc"
IL_00b0: call "bool string.op_Equality(string, string)"
- IL_00b5: brtrue.s IL_0117
- IL_00b7: br IL_0147
- IL_00bc: ldloc.1
- IL_00bd: ldstr "abcd"
- IL_00c2: call "bool string.op_Equality(string, string)"
- IL_00c7: brtrue.s IL_011f
- IL_00c9: br.s IL_0147
- IL_00cb: ldloc.1
- IL_00cc: ldstr "abcde"
- IL_00d1: call "bool string.op_Equality(string, string)"
- IL_00d6: brtrue.s IL_0127
- IL_00d8: br.s IL_0147
- IL_00da: ldloc.1
- IL_00db: ldstr "abcdef"
- IL_00e0: call "bool string.op_Equality(string, string)"
- IL_00e5: brtrue.s IL_012f
- IL_00e7: br.s IL_0147
- IL_00e9: ldloc.1
- IL_00ea: ldstr "abcdefg"
- IL_00ef: call "bool string.op_Equality(string, string)"
- IL_00f4: brtrue.s IL_0137
- IL_00f6: br.s IL_0147
- IL_00f8: ldloc.1
- IL_00f9: ldstr "abcdefgh"
- IL_00fe: call "bool string.op_Equality(string, string)"
- IL_0103: brtrue.s IL_013f
- IL_0105: br.s IL_0147
- IL_0107: ldstr "a"
- IL_010c: stloc.0
- IL_010d: br.s IL_014d
- IL_010f: ldstr "ab"
- IL_0114: stloc.0
- IL_0115: br.s IL_014d
- IL_0117: ldstr "abc"
- IL_011c: stloc.0
- IL_011d: br.s IL_014d
- IL_011f: ldstr "abcd"
- IL_0124: stloc.0
- IL_0125: br.s IL_014d
- IL_0127: ldstr "abcde"
- IL_012c: stloc.0
- IL_012d: br.s IL_014d
- IL_012f: ldstr "abcdef"
- IL_0134: stloc.0
- IL_0135: br.s IL_014d
- IL_0137: ldstr "abcdefg"
- IL_013c: stloc.0
- IL_013d: br.s IL_014d
- IL_013f: ldstr "abcdefgh"
- IL_0144: stloc.0
- IL_0145: br.s IL_014d
- IL_0147: ldstr "default"
- IL_014c: stloc.0
- IL_014d: ldloc.0
- IL_014e: ret
+ IL_00b5: brtrue.s IL_0110
+ IL_00b7: br.s IL_0134
+ IL_00b9: ldloc.0
+ IL_00ba: ldstr "abcd"
+ IL_00bf: call "bool string.op_Equality(string, string)"
+ IL_00c4: brtrue.s IL_0116
+ IL_00c6: br.s IL_0134
+ IL_00c8: ldloc.0
+ IL_00c9: ldstr "abcde"
+ IL_00ce: call "bool string.op_Equality(string, string)"
+ IL_00d3: brtrue.s IL_011c
+ IL_00d5: br.s IL_0134
+ IL_00d7: ldloc.0
+ IL_00d8: ldstr "abcdef"
+ IL_00dd: call "bool string.op_Equality(string, string)"
+ IL_00e2: brtrue.s IL_0122
+ IL_00e4: br.s IL_0134
+ IL_00e6: ldloc.0
+ IL_00e7: ldstr "abcdefg"
+ IL_00ec: call "bool string.op_Equality(string, string)"
+ IL_00f1: brtrue.s IL_0128
+ IL_00f3: br.s IL_0134
+ IL_00f5: ldloc.0
+ IL_00f6: ldstr "abcdefgh"
+ IL_00fb: call "bool string.op_Equality(string, string)"
+ IL_0100: brtrue.s IL_012e
+ IL_0102: br.s IL_0134
+ IL_0104: ldstr "a"
+ IL_0109: ret
+ IL_010a: ldstr "ab"
+ IL_010f: ret
+ IL_0110: ldstr "abc"
+ IL_0115: ret
+ IL_0116: ldstr "abcd"
+ IL_011b: ret
+ IL_011c: ldstr "abcde"
+ IL_0121: ret
+ IL_0122: ldstr "abcdef"
+ IL_0127: ret
+ IL_0128: ldstr "abcdefg"
+ IL_012d: ret
+ IL_012e: ldstr "abcdefgh"
+ IL_0133: ret
+ IL_0134: ldstr "default"
+ IL_0139: ret
}
""");
}
@@ -1650,113 +1548,101 @@ public static string M(object o)
verifier.VerifyMemberInIL(PrivateImplementationDetails.SynthesizedStringHashFunctionName + "(string)", expected: false);
verifier.VerifyIL("C.M", """
{
- // Code size 310 (0x136)
+ // Code size 284 (0x11c)
.maxstack 2
.locals init (string V_0,
- string V_1,
- int V_2,
- char V_3)
+ int V_1,
+ char V_2)
IL_0000: ldarg.0
IL_0001: isinst "string"
- IL_0006: stloc.1
- IL_0007: ldloc.1
- IL_0008: brfalse IL_00d4
- IL_000d: ldloc.1
- IL_000e: brfalse IL_012e
- IL_0013: ldloc.1
+ IL_0006: stloc.0
+ IL_0007: ldloc.0
+ IL_0008: brfalse IL_00ce
+ IL_000d: ldloc.0
+ IL_000e: brfalse IL_0116
+ IL_0013: ldloc.0
IL_0014: call "int string.Length.get"
- IL_0019: stloc.2
- IL_001a: ldloc.2
+ IL_0019: stloc.1
+ IL_001a: ldloc.1
IL_001b: ldc.i4.1
IL_001c: sub
IL_001d: switch (
IL_0047,
IL_005c,
- IL_0071,
- IL_0083,
- IL_0095,
- IL_00a7,
- IL_00b6,
- IL_00c5)
- IL_0042: br IL_012e
- IL_0047: ldloc.1
+ IL_006e,
+ IL_0080,
+ IL_0092,
+ IL_00a1,
+ IL_00b0,
+ IL_00bf)
+ IL_0042: br IL_0116
+ IL_0047: ldloc.0
IL_0048: ldstr "a"
IL_004d: call "bool string.op_Equality(string, string)"
- IL_0052: brtrue IL_00e6
- IL_0057: br IL_012e
- IL_005c: ldloc.1
+ IL_0052: brtrue IL_00e0
+ IL_0057: br IL_0116
+ IL_005c: ldloc.0
IL_005d: ldstr "ab"
IL_0062: call "bool string.op_Equality(string, string)"
- IL_0067: brtrue IL_00ee
- IL_006c: br IL_012e
- IL_0071: ldloc.1
- IL_0072: ldstr "abc"
- IL_0077: call "bool string.op_Equality(string, string)"
- IL_007c: brtrue.s IL_00f6
- IL_007e: br IL_012e
- IL_0083: ldloc.1
- IL_0084: ldstr "abcd"
- IL_0089: call "bool string.op_Equality(string, string)"
- IL_008e: brtrue.s IL_00fe
- IL_0090: br IL_012e
- IL_0095: ldloc.1
- IL_0096: ldstr "abcde"
- IL_009b: call "bool string.op_Equality(string, string)"
- IL_00a0: brtrue.s IL_0106
- IL_00a2: br IL_012e
- IL_00a7: ldloc.1
- IL_00a8: ldstr "abcdef"
- IL_00ad: call "bool string.op_Equality(string, string)"
- IL_00b2: brtrue.s IL_010e
- IL_00b4: br.s IL_012e
- IL_00b6: ldloc.1
- IL_00b7: ldstr "abcdefg"
- IL_00bc: call "bool string.op_Equality(string, string)"
- IL_00c1: brtrue.s IL_0116
- IL_00c3: br.s IL_012e
- IL_00c5: ldloc.1
- IL_00c6: ldstr "abcdefgh"
- IL_00cb: call "bool string.op_Equality(string, string)"
- IL_00d0: brtrue.s IL_011e
- IL_00d2: br.s IL_012e
- IL_00d4: ldarg.0
- IL_00d5: isinst "int"
- IL_00da: brfalse.s IL_012e
- IL_00dc: ldarg.0
- IL_00dd: unbox.any "int"
- IL_00e2: brfalse.s IL_0126
- IL_00e4: br.s IL_012e
- IL_00e6: ldstr "a"
- IL_00eb: stloc.0
- IL_00ec: br.s IL_0134
- IL_00ee: ldstr "ab"
- IL_00f3: stloc.0
- IL_00f4: br.s IL_0134
- IL_00f6: ldstr "abc"
- IL_00fb: stloc.0
- IL_00fc: br.s IL_0134
- IL_00fe: ldstr "abcd"
- IL_0103: stloc.0
- IL_0104: br.s IL_0134
- IL_0106: ldstr "abcde"
- IL_010b: stloc.0
- IL_010c: br.s IL_0134
- IL_010e: ldstr "abcdef"
- IL_0113: stloc.0
- IL_0114: br.s IL_0134
- IL_0116: ldstr "abcdefg"
- IL_011b: stloc.0
- IL_011c: br.s IL_0134
- IL_011e: ldstr "abcdefgh"
- IL_0123: stloc.0
- IL_0124: br.s IL_0134
- IL_0126: ldstr "0"
- IL_012b: stloc.0
- IL_012c: br.s IL_0134
- IL_012e: ldstr "default"
- IL_0133: stloc.0
- IL_0134: ldloc.0
- IL_0135: ret
+ IL_0067: brtrue.s IL_00e6
+ IL_0069: br IL_0116
+ IL_006e: ldloc.0
+ IL_006f: ldstr "abc"
+ IL_0074: call "bool string.op_Equality(string, string)"
+ IL_0079: brtrue.s IL_00ec
+ IL_007b: br IL_0116
+ IL_0080: ldloc.0
+ IL_0081: ldstr "abcd"
+ IL_0086: call "bool string.op_Equality(string, string)"
+ IL_008b: brtrue.s IL_00f2
+ IL_008d: br IL_0116
+ IL_0092: ldloc.0
+ IL_0093: ldstr "abcde"
+ IL_0098: call "bool string.op_Equality(string, string)"
+ IL_009d: brtrue.s IL_00f8
+ IL_009f: br.s IL_0116
+ IL_00a1: ldloc.0
+ IL_00a2: ldstr "abcdef"
+ IL_00a7: call "bool string.op_Equality(string, string)"
+ IL_00ac: brtrue.s IL_00fe
+ IL_00ae: br.s IL_0116
+ IL_00b0: ldloc.0
+ IL_00b1: ldstr "abcdefg"
+ IL_00b6: call "bool string.op_Equality(string, string)"
+ IL_00bb: brtrue.s IL_0104
+ IL_00bd: br.s IL_0116
+ IL_00bf: ldloc.0
+ IL_00c0: ldstr "abcdefgh"
+ IL_00c5: call "bool string.op_Equality(string, string)"
+ IL_00ca: brtrue.s IL_010a
+ IL_00cc: br.s IL_0116
+ IL_00ce: ldarg.0
+ IL_00cf: isinst "int"
+ IL_00d4: brfalse.s IL_0116
+ IL_00d6: ldarg.0
+ IL_00d7: unbox.any "int"
+ IL_00dc: brfalse.s IL_0110
+ IL_00de: br.s IL_0116
+ IL_00e0: ldstr "a"
+ IL_00e5: ret
+ IL_00e6: ldstr "ab"
+ IL_00eb: ret
+ IL_00ec: ldstr "abc"
+ IL_00f1: ret
+ IL_00f2: ldstr "abcd"
+ IL_00f7: ret
+ IL_00f8: ldstr "abcde"
+ IL_00fd: ret
+ IL_00fe: ldstr "abcdef"
+ IL_0103: ret
+ IL_0104: ldstr "abcdefg"
+ IL_0109: ret
+ IL_010a: ldstr "abcdefgh"
+ IL_010f: ret
+ IL_0110: ldstr "0"
+ IL_0115: ret
+ IL_0116: ldstr "default"
+ IL_011b: ret
}
""");
}
@@ -1832,9 +1718,8 @@ public static string M(string o)
verifier.VerifyMemberInIL(PrivateImplementationDetails.SynthesizedStringHashFunctionName + "(string)", expected: false);
verifier.VerifyIL("C.M", """
{
- // Code size 178 (0xb2)
+ // Code size 160 (0xa0)
.maxstack 2
- .locals init (string V_0)
IL_0000: ldarg.0
IL_0001: ldstr "a"
IL_0006: call "bool string.op_Equality(string, string)"
@@ -1842,60 +1727,50 @@ .locals init (string V_0)
IL_000d: ldarg.0
IL_000e: ldstr "ab"
IL_0013: call "bool string.op_Equality(string, string)"
- IL_0018: brtrue.s IL_0072
+ IL_0018: brtrue.s IL_0070
IL_001a: ldarg.0
IL_001b: ldstr "abc"
IL_0020: call "bool string.op_Equality(string, string)"
- IL_0025: brtrue.s IL_007a
+ IL_0025: brtrue.s IL_0076
IL_0027: ldarg.0
IL_0028: ldstr "abcd"
IL_002d: call "bool string.op_Equality(string, string)"
- IL_0032: brtrue.s IL_0082
+ IL_0032: brtrue.s IL_007c
IL_0034: ldarg.0
IL_0035: ldstr "abcde"
IL_003a: call "bool string.op_Equality(string, string)"
- IL_003f: brtrue.s IL_008a
+ IL_003f: brtrue.s IL_0082
IL_0041: ldarg.0
IL_0042: ldstr "abcdef"
IL_0047: call "bool string.op_Equality(string, string)"
- IL_004c: brtrue.s IL_0092
+ IL_004c: brtrue.s IL_0088
IL_004e: ldarg.0
IL_004f: ldstr "abcdefg"
IL_0054: call "bool string.op_Equality(string, string)"
- IL_0059: brtrue.s IL_009a
+ IL_0059: brtrue.s IL_008e
IL_005b: ldarg.0
IL_005c: ldstr "abcdefgh"
IL_0061: call "bool string.op_Equality(string, string)"
- IL_0066: brtrue.s IL_00a2
- IL_0068: br.s IL_00aa
+ IL_0066: brtrue.s IL_0094
+ IL_0068: br.s IL_009a
IL_006a: ldstr "a"
- IL_006f: stloc.0
- IL_0070: br.s IL_00b0
- IL_0072: ldstr "ab"
- IL_0077: stloc.0
- IL_0078: br.s IL_00b0
- IL_007a: ldstr "abc"
- IL_007f: stloc.0
- IL_0080: br.s IL_00b0
- IL_0082: ldstr "abcd"
- IL_0087: stloc.0
- IL_0088: br.s IL_00b0
- IL_008a: ldstr "abcde"
- IL_008f: stloc.0
- IL_0090: br.s IL_00b0
- IL_0092: ldstr "abcdef"
- IL_0097: stloc.0
- IL_0098: br.s IL_00b0
- IL_009a: ldstr "abcdefg"
- IL_009f: stloc.0
- IL_00a0: br.s IL_00b0
- IL_00a2: ldstr "abcdefgh"
- IL_00a7: stloc.0
- IL_00a8: br.s IL_00b0
- IL_00aa: ldstr "default"
- IL_00af: stloc.0
- IL_00b0: ldloc.0
- IL_00b1: ret
+ IL_006f: ret
+ IL_0070: ldstr "ab"
+ IL_0075: ret
+ IL_0076: ldstr "abc"
+ IL_007b: ret
+ IL_007c: ldstr "abcd"
+ IL_0081: ret
+ IL_0082: ldstr "abcde"
+ IL_0087: ret
+ IL_0088: ldstr "abcdef"
+ IL_008d: ret
+ IL_008e: ldstr "abcdefg"
+ IL_0093: ret
+ IL_0094: ldstr "abcdefgh"
+ IL_0099: ret
+ IL_009a: ldstr "default"
+ IL_009f: ret
}
""");
}
@@ -1983,9 +1858,8 @@ public static string M(System.Span o)
var verifier = CompileAndVerify(comp, verify: Verification.Skipped);
verifier.VerifyIL("C.M", """
{
- // Code size 221 (0xdd)
+ // Code size 203 (0xcb)
.maxstack 2
- .locals init (string V_0)
IL_0000: ldarg.0
IL_0001: ldstr "a"
IL_0006: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
@@ -1995,66 +1869,56 @@ .locals init (string V_0)
IL_0016: ldstr "ab"
IL_001b: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0020: call "bool System.MemoryExtensions.SequenceEqual(System.Span, System.ReadOnlySpan)"
- IL_0025: brtrue.s IL_009d
+ IL_0025: brtrue.s IL_009b
IL_0027: ldarg.0
IL_0028: ldstr "abc"
IL_002d: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0032: call "bool System.MemoryExtensions.SequenceEqual(System.Span, System.ReadOnlySpan)"
- IL_0037: brtrue.s IL_00a5
+ IL_0037: brtrue.s IL_00a1
IL_0039: ldarg.0
IL_003a: ldstr "abcd"
IL_003f: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0044: call "bool System.MemoryExtensions.SequenceEqual(System.Span, System.ReadOnlySpan)"
- IL_0049: brtrue.s IL_00ad
+ IL_0049: brtrue.s IL_00a7
IL_004b: ldarg.0
IL_004c: ldstr "abcde"
IL_0051: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0056: call "bool System.MemoryExtensions.SequenceEqual(System.Span, System.ReadOnlySpan)"
- IL_005b: brtrue.s IL_00b5
+ IL_005b: brtrue.s IL_00ad
IL_005d: ldarg.0
IL_005e: ldstr "abcdef"
IL_0063: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0068: call "bool System.MemoryExtensions.SequenceEqual(System.Span, System.ReadOnlySpan)"
- IL_006d: brtrue.s IL_00bd
+ IL_006d: brtrue.s IL_00b3
IL_006f: ldarg.0
IL_0070: ldstr "abcdefg"
IL_0075: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_007a: call "bool System.MemoryExtensions.SequenceEqual(System.Span, System.ReadOnlySpan)"
- IL_007f: brtrue.s IL_00c5
+ IL_007f: brtrue.s IL_00b9
IL_0081: ldarg.0
IL_0082: ldstr "abcdefgh"
IL_0087: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_008c: call "bool System.MemoryExtensions.SequenceEqual(System.Span, System.ReadOnlySpan)"
- IL_0091: brtrue.s IL_00cd
- IL_0093: br.s IL_00d5
+ IL_0091: brtrue.s IL_00bf
+ IL_0093: br.s IL_00c5
IL_0095: ldstr "a"
- IL_009a: stloc.0
- IL_009b: br.s IL_00db
- IL_009d: ldstr "ab"
- IL_00a2: stloc.0
- IL_00a3: br.s IL_00db
- IL_00a5: ldstr "abc"
- IL_00aa: stloc.0
- IL_00ab: br.s IL_00db
- IL_00ad: ldstr "abcd"
- IL_00b2: stloc.0
- IL_00b3: br.s IL_00db
- IL_00b5: ldstr "abcde"
- IL_00ba: stloc.0
- IL_00bb: br.s IL_00db
- IL_00bd: ldstr "abcdef"
- IL_00c2: stloc.0
- IL_00c3: br.s IL_00db
- IL_00c5: ldstr "abcdefg"
- IL_00ca: stloc.0
- IL_00cb: br.s IL_00db
- IL_00cd: ldstr "abcdefgh"
- IL_00d2: stloc.0
- IL_00d3: br.s IL_00db
- IL_00d5: ldstr "default"
- IL_00da: stloc.0
- IL_00db: ldloc.0
- IL_00dc: ret
+ IL_009a: ret
+ IL_009b: ldstr "ab"
+ IL_00a0: ret
+ IL_00a1: ldstr "abc"
+ IL_00a6: ret
+ IL_00a7: ldstr "abcd"
+ IL_00ac: ret
+ IL_00ad: ldstr "abcde"
+ IL_00b2: ret
+ IL_00b3: ldstr "abcdef"
+ IL_00b8: ret
+ IL_00b9: ldstr "abcdefg"
+ IL_00be: ret
+ IL_00bf: ldstr "abcdefgh"
+ IL_00c4: ret
+ IL_00c5: ldstr "default"
+ IL_00ca: ret
}
""");
}
@@ -2089,9 +1953,8 @@ public static string M(System.ReadOnlySpan o)
var verifier = CompileAndVerify(comp, verify: Verification.Skipped);
verifier.VerifyIL("C.M", """
{
- // Code size 221 (0xdd)
+ // Code size 203 (0xcb)
.maxstack 2
- .locals init (string V_0)
IL_0000: ldarg.0
IL_0001: ldstr "a"
IL_0006: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
@@ -2101,66 +1964,56 @@ .locals init (string V_0)
IL_0016: ldstr "ab"
IL_001b: call "System.ReadOnlySpan System.MemoryExtensions.AsSpan(string)"
IL_0020: call "bool System.MemoryExtensions.SequenceEqual(System.ReadOnlySpan, System.ReadOnlySpan