style(evm): trim the remaining comment noise and size blockOpCount like its sibling

Author: svlachakis

src/Nethermind/Nethermind.Evm.Test/CodeAnalysis/StreamGasFuzzTests.cs

@@ -139,7 +139,6 @@ private static byte[] Generate(int seed)
                     code.AddRange([(byte)Instruction.DUP1, (byte)Instruction.ISZERO]);
                     break;
                 case 7:
-                    // Permutation ops at mixed depths, the shape the coalescing pass rewrites.
                     for (int k = random.Next(2, 6); k > 0; k--)
                     {
                         code.Add(random.Next(3) switch
@@ -155,7 +154,6 @@ private static byte[] Generate(int seed)
                     code.AddRange([(byte)Instruction.PUSH1, 0x20, (byte)Instruction.PUSH1, 0x00, (byte)Instruction.MSTORE]);
                     break;
                 case 9 when jumpDests.Count > 0:
-                    // Static conditional jump, the fused shape.
                     int condDest = jumpDests[random.Next(jumpDests.Count)];
                     code.AddRange([
                         (byte)Instruction.PUSH1, 0x01, (byte)Instruction.SWAP1, (byte)Instruction.SUB,
@@ -176,7 +174,6 @@ private static byte[] Generate(int seed)
                     if (random.Next(2) == 0) code.Add((byte)Instruction.ISZERO);
                     break;
                 case 12:
-                    // Zero divisor often enough to hit that fold.
                     code.AddRange([
                         (byte)Instruction.PUSH1, (byte)(random.Next(4) == 0 ? 0 : random.Next(256)),
                         (byte)Instruction.PUSH1, (byte)random.Next(256),
@@ -191,7 +188,6 @@ private static byte[] Generate(int seed)
                     code.Add((byte)(random.Next(2) == 0 ? Instruction.SHL : Instruction.SHR));
                     break;
                 case 14:
-                    // The fold path through the constant pool.
                     random.NextBytes(wide);
                     code.Add((byte)Instruction.PUSH32);
                     code.AddRange(wide);
@@ -207,7 +203,6 @@ private static byte[] Generate(int seed)
                     jumpDests.Add(target);
                     break;
                 case 16:
-                    // Boundary ops that keep a block open.
                     switch (random.Next(5))
                     {
                         case 0: code.AddRange([(byte)Instruction.PUSH1, (byte)random.Next(64), (byte)Instruction.MLOAD]); break;
@@ -224,7 +219,6 @@ private static byte[] Generate(int seed)
                     code.AddRange([(byte)Instruction.PUSH1, (byte)random.Next(256), (byte)Instruction.EXTCODESIZE, (byte)Instruction.ISZERO]);
                     break;
                 case 22:
-                    // Constant shift feeding a subtraction, at saturating amounts too.
                     code.AddRange([
                         (byte)Instruction.PUSH1, (byte)random.Next(256),
                         (byte)Instruction.PUSH1, (byte)(random.Next(4) == 0 ? 0xFF : random.Next(40)),

src/Nethermind/Nethermind.Evm.Test/CodeAnalysis/ZzTempCoverageProbe.cs

@@ -0,0 +1,42 @@
+// SPDX-FileCopyrightText: 2026 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Nethermind.Evm.CodeAnalysis;
+using NUnit.Framework;
+
+namespace Nethermind.Evm.Test.CodeAnalysis;
+
+[TestFixture]
+public class ZzTempCoverageProbe
+{
+    [Test]
+    public void TallyFuzzCorpusEntryKinds()
+    {
+        MethodInfo gen = typeof(StreamGasFuzzTests).GetMethod("Generate", BindingFlags.NonPublic | BindingFlags.Static)!;
+        Dictionary<string, int> tally = new();
+        int nullStreams = 0;
+        int maxAdvance = 0;
+        for (int seed = 0; seed < 400; seed++)
+        {
+            byte[] code = (byte[])gen.Invoke(null, new object[] { seed })!;
+            InstructionStream? s = InstructionStream.TryBuild(code);
+            if (s is null) { nullStreams++; continue; }
+            foreach (StreamOp op in s.Ops)
+            {
+                string key = $"{op.Kind}:0x{op.Opcode:X2}";
+                tally[key] = tally.GetValueOrDefault(key) + 1;
+                if (op.Advance > maxAdvance) maxAdvance = op.Advance;
+            }
+        }
+
+        Console.WriteLine($"nullStreams={nullStreams} maxAdvance={maxAdvance}");
+        foreach (KeyValuePair<string, int> kv in tally.OrderBy(k => k.Key))
+        {
+            Console.WriteLine($"  {kv.Key} = {kv.Value}");
+        }
+    }
+}

src/Nethermind/Nethermind.Evm/CodeAnalysis/InstructionStream.cs

@@ -22,9 +22,8 @@ internal enum StreamOpKind : byte
     StaticJump = 4,
     StaticJumpI = 5,
     Boundary = 6,
-    /// <summary>Self-charging table op that neither redirects control nor ends the frame, so the
-    /// open block continues across it: the executor advances sequentially with no landing
-    /// recompute, and the ops after it keep their precharge in the same block.</summary>
+    /// <summary>Self-charging table op that neither redirects control nor ends the frame, so the ops
+    /// after it keep their precharge in the same block.</summary>
     BoundaryLinear = 7,
 }
 
@@ -129,8 +128,8 @@ internal sealed class InstructionStream
     public readonly StreamOp[] Ops;
     public readonly ulong[] BlockGas;
     /// <summary>Ops the bytecode loop would execute per block (fused pairs count as two, an elided
-    /// JUMPDEST counts in the block that carries its gas). Consumed once per block charge, so the
-    /// hot loop drops its per-op counter updates; a block that faults mid-run is counted whole.</summary>
+    /// JUMPDEST counts in the block that carries its gas). A block that faults mid-run is counted
+    /// whole.</summary>
     public readonly ushort[] BlockOpCount;
     /// <summary>Pool for pre-decoded PUSH9..PUSH32 constants, referenced by entry operand.</summary>
     public readonly UInt256[] Constants;
@@ -179,7 +178,7 @@ private InstructionStream(StreamOp[] ops, ulong[] blockGas, ushort[] blockOpCoun
             return null;
 
         List<StreamOp> ops = new(code.Length / 2);
-        List<ushort> blockOpCount = new(64);
+        List<ushort> blockOpCount = new(code.Length / 16);
         List<ulong> blockGas = new(code.Length / 16);
         List<UInt256> constants = new(code.Length / 32);
         ushort[] pcToEntry = new ushort[code.Length + 1];
@@ -220,8 +219,6 @@ private InstructionStream(StreamOp[] ops, ulong[] blockGas, ushort[] blockOpCoun
                 if (openBlock >= 0
                     && TryFoldConstantPair(ops, constants, pcToEntry, instruction, pc, (byte)size))
                 {
-                    // Entry surgery happened inside; the original ops' gas and count stay in the block
-                    // so the charge and the executed-op metric keep matching the bytecode loop.
                     blockGas[openBlock] += cost;
                     blockOpCount[openBlock]++;
                 }
@@ -453,7 +450,6 @@ private static bool TryFoldConstantPair(List<StreamOp> ops, List<UInt256> consta
         return true;
     }
 
-    /// <summary>A plain, unfused in-block push whose value analysis knows exactly.</summary>
     private static bool TryGetConstPush(in StreamOp entry, List<UInt256> constants, out UInt256 value)
     {
         value = default;

src/Nethermind/Nethermind.Evm/EvmStack.cs

@@ -2212,12 +2212,8 @@ public EvmExceptionType Dup<TTracingInst>(int depth)
         return EvmExceptionType.None;
     }
 
-    /// <summary>
-    /// Fused <c>SWAPn; POP</c>: the swap partner slot takes the top word and the top is dropped, which
-    /// is what the pair leaves behind without moving the discarded word. One depth check suffices: the
-    /// swap already requires <c>Head &gt;= depth</c> and depth is at least 2, so the pop cannot underflow
-    /// separately.
-    /// </summary>
+    /// <summary>Fused <c>SWAPn; POP</c>. One depth check suffices: the swap already requires
+    /// <c>Head &gt;= depth</c> and depth is at least 2, so the pop cannot underflow separately.</summary>
     [SkipLocalsInit]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public EvmExceptionType SwapPop(int depth)
@@ -2239,11 +2235,7 @@ public EvmExceptionType SwapPop(int depth)
         return EvmExceptionType.None;
     }
 
-    /// <summary>
-    /// Fused <c>AND; ISZERO</c> run straight over the stack representation: the conjunction only has to
-    /// be compared against zero, so neither operand is converted to limbs and the intermediate is never
-    /// written back.
-    /// </summary>
+    /// <summary>Fused <c>AND; ISZERO</c>.</summary>
     [SkipLocalsInit]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public EvmExceptionType AndIsZero()

src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Bitwise.cs

@@ -150,12 +150,8 @@ public struct OpGtBytes : IOpCompare { public static bool IsSigned => false; pub
     public struct OpSLtBytes : IOpCompare { public static bool IsSigned => true; public static bool IsGreater => false; }
     public struct OpSGtBytes : IOpCompare { public static bool IsSigned => true; public static bool IsGreater => true; }
 
-    /// <summary>
-    /// Comparison run straight over the stack representation: big-endian byte order is numeric order
-    /// for unsigned words, so the most significant differing byte decides, and flipping the sign bit
-    /// of the leading byte extends the same order to signed comparisons. Neither operand is converted
-    /// to limbs.
-    /// </summary>
+    /// <summary>Flipping the sign bit of the leading byte extends unsigned big-endian byte order to
+    /// signed comparison.</summary>
     [SkipLocalsInit]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static EvmExceptionType CompareCore<TOpCompare>(ref EvmStack stack)

src/Nethermind/Nethermind.Evm/VirtualMachine.Stream.cs

@@ -119,7 +119,7 @@ private CallResult RunStream<TCancelable>(
 
                     TGasPolicy.OnBeforeInstructionTrace(in gas, entry.Pc, instruction, callDepth);
 
-                    // Gas already charged at the block entry, so the cores are gas-free.
+                    // Gas already charged at the block entry, so the cores are gas-free. Must stay inline (JIT).
                     switch (instruction)
                     {
                         case (Instruction)FusedOpcode.Add: