Question

Today I opened one of Microsoft’ .Net regex implementations and it hit me that this may be the only reason for the existence of the goto statement in a language like C# (which puts major emphasis on the ‘clarity for the developer’ concept where goto seems to have no place at all) and possibly also the sole reason why Microsoft use it the CLR libraries implementations – for performance boosts. I also remember seeing similar optimization in the Microsoft’s ASP.NET page/control rendering in System.Web.UI.dll as well. Would that be a valid (or documented maybe ?) assumption to make? Have you seen it used by Microsoft under any other circumstances except to improve code execution time? Thanks.

Below is an excerpt (NOT MEANT TO EXAMINED IN DETAIL JUST SCAN OVER IT) from Microsoft’s own regex implementation where they again use goto extensively for what appears to be only performance boost:

public override void Go() 
{
    int num4;
    int num5;
    string runtext = base.runtext;
    int runtextstart = base.runtextstart;
    int runtextbeg = base.runtextbeg;
    int runtextend = base.runtextend;
    int runtextpos = base.runtextpos;
    int[] runtrack = base.runtrack;
    int runtrackpos = base.runtrackpos;
    int[] runstack = base.runstack;
    int runstackpos = base.runstackpos;
    runtrack[--runtrackpos] = runtextpos;
    runtrack[--runtrackpos] = 0;
    runstack[--runstackpos] = runtextpos;
    runtrack[--runtrackpos] = 1;
    if ((((runtextpos != base.runtextstart) || 
       (4 > (runtextend - runtextpos))) || 
       ((runtext[runtextpos] != '<') || 
       (runtext[runtextpos + 1] != '%'))) || 
       ((runtext[runtextpos + 2] != '-') || 
       (runtext[runtextpos + 3] != '-')))
    {
        goto Label_02F8;
    }
    runtextpos += 4;
    runstack[--runstackpos] = -1;
    runtrack[--runtrackpos] = 1;
    goto Label_0213;
Label_0161:
    if (num5 > num4)
    {
        runtrack[--runtrackpos] = (num5 - num4) - 1;
        runtrack[--runtrackpos] = runtextpos - 1;
        runtrack[--runtrackpos] = 2;
    }
Label_0194:
    num4 = runstack[runstackpos++];
    this.Capture(2, num4, runtextpos);
    runtrack[--runtrackpos] = num4;
    runtrack[--runtrackpos] = 3;
    if (runtextpos >= runtextend)
    {
        goto Label_02F8;
    }
    runtextpos++;
    if (runtext[runtextpos] != '-')
    {
        goto Label_02F8;
    }
    num4 = runstack[runstackpos++];
    this.Capture(1, num4, runtextpos);
    runtrack[--runtrackpos] = num4;
    runtrack[--runtrackpos] = 3;
Label_0213:
    if (num4 != -1)
    {
        runtrack[--runtrackpos] = num4;
    }
    else
    {
        runtrack[--runtrackpos] = runtextpos;
    }
    if ((num4 = runstack[runstackpos++]) != runtextpos)
    {
        runtrack[--runtrackpos] = runtextpos;
        runtrack[--runtrackpos] = 4;
    }
    else
    {
        runstack[--runstackpos] = num4;
        runtrack[--runtrackpos] = 5;
    }
    if (((3 > (runtextend - runtextpos)) || 
    (runtext[runtextpos] != '-')) || 
    ((runtext[runtextpos + 1] != '%') || 
    (runtext[runtextpos + 2] != '>')))
    {
        goto Label_02F8;
    }
    runtextpos += 3;
    num4 = runstack[runstackpos++];
    this.Capture(0, num4, runtextpos);
    runtrack[--runtrackpos] = num4;
    runtrack[--runtrackpos] = 3;
Label_02EF:
    base.runtextpos = runtextpos;
    return;
Label_02F8:
    base.runtrackpos = runtrackpos;
    base.runstackpos = runstackpos;
    this.EnsureStorage();
    runtrackpos = base.runtrackpos;
    runstackpos = base.runstackpos;
    runtrack = base.runtrack;
    runstack = base.runstack;
    switch (runtrack[runtrackpos++])
    {
        case 1:
            runstackpos++;
            goto Label_02F8;

        case 2:
            runtextpos = runtrack[runtrackpos++];
            num4 = runtrack[runtrackpos++];
            if (num4 > 0)
            {
                runtrack[--runtrackpos] = num4 - 1;
                runtrack[--runtrackpos] = runtextpos - 1;
                runtrack[--runtrackpos] = 2;
            }
            goto Label_0194;

        case 3:
            runstack[--runstackpos] = runtrack[runtrackpos++];
            this.Uncapture();
            goto Label_02F8;

        case 4:
            runtextpos = runtrack[runtrackpos++];
            runstack[--runstackpos] = runtextpos;
            runtrack[--runtrackpos] = 5;
            if ((runtrackpos > 40) && (runstackpos > 30))
            {
                runstack[--runstackpos] = runtextpos;
                runtrack[--runtrackpos] = 1;
                runstack[--runstackpos] = runtextpos;
                runtrack[--runtrackpos] = 1;
                num4 = (num5 = runtextend - runtextpos) + 1;
                do
                {
                    if (--num4 <= 0)
                    {
                        goto Label_0161;
                    }
                    runtextpos++;
                }
                while (runtext[runtextpos] != '-');
                runtextpos--;
                goto Label_0161;
            }
            runtrack[--runtrackpos] = 6;
            goto Label_02F8;

        case 5:
            runstack[runstackpos] = runtrack[runtrackpos++];
            goto Label_02F8;
    }
    runtextpos = runtrack[runtrackpos++];
    goto Label_02EF;
}

Answer 1

One use-case I see is auto-generated code. The high-level control flow constructs are easy for us humans, but not necessarily convenient as output of code generation algorithms.

And is your code decompiled? In that case it might just be written in a way that the decompiler can’t deal with without using gotos. On IL level all control flow constructs are translated to gotos, and the decompiler tries to guess what they were. And in complicated cases it might not figure out a good way to represent it using high-level constructs and thus resorts to gotos.

Another use-case are state-machines. You have a number of states, and after each one it can transit to a new state using goto statements. Parsers are a common application of state-machines.