[scorchin]

The patches to the Kernel are in review and can be seen here: https://patchwork.kernel.org/project/linux-input/patch/20201...

[iso8859-1]

Good to see they are still using GOTO. Straight-forward and performant.

[pizza234]

I spent to some time to check and analyze the code.

The author uses it in a clear pattern, specifically, as a sibiling post mentions, in order to achieve error handling (additionally, with fall-through); the labels are indeed neatly placed at the end of the function, after the `ret` exit.

The problem is consistency - the upper half of that function performs error handling without goto, and the lower half with it.

I personally prefer all-or-none solutions, since I highly value consistency, but on the other hand, I do consider this solution acceptable, since it still has a tidy (enough) structure.

[centimeter]

Goto doesn't have a performance benefit over other control flow structures with a modern compiler.

[the_duke]

In C GOTO is often by far the cleanest solution for error handling.

Everything else turns into an ugly, unreadable mess in functions that need to free resources or do some kind of cleanup.

[Uptrenda]

I've seen the goto error-handling approach used now in SDKs written by developers from companies like Microsoft, Nvidia, and Nordic Semiconductor. It really does seem to be the best way to do it. And it's simple. Mess something up... goto cleanup... Seems fine to me!

[centimeter]

My comment has nothing to do with error handling. I was addressing a false claim about performance.

[akira2501]

Yes, but it does reduce the level of indentation required in most functions that use it. That consideration is part of the kernel style guidelines.

[slashdev]

In system C code its usually used for error and retry logic to make the code more readable. It's rarely ever used for performance.

[asddubs]

that's definitely not categorically true

[mhh__]

Can you think of a counterexample? I wouldn't be surprised if you could trick a compiler with a goto but optimizing control flow is very much the type of optimization that Knuth was referring to. Now that almost all compilers use SSA I'd be surprised if it was the case outside of fairly deep control flow

[Out_of_Characte]

Error handling was already mentioned ITT. Goto use seems like a litmus test for bad programming. The presence of it doesn't prove bad programmings but lots of goto statements could be reasonably be expected to be replaced with safer switch statements. Extremely nested functions are another area that is best served with a goto. Breaking out of many functions has performance implications I believe.

[viraptor]

The question was about performance, not necessarily other aspects.

[anonunivgrad]

If you’re criticizing goto in kernel source, you don’t know what you’re talking about. It’s incredible how many people just regurgitate this anti-goto meme without any experience writing system C code. There are various highly structured uses of goto used for systems programming in C, most prominently for error handling but also for things like retry logic.

[gregoryl]

You built a strawman and burnt it down!

[eloff]

Yes, you're right.

[will4274]

I checked (just for you). All four gotos are reasonable forward gotos and not what the article "goto considered harmful" was referring to. As an aside, why did you write goto in all caps in your comment? While your comment was quite basic, it wasn't BASIC, so no such caps are required. Please don't shout.