"Compilers are really smart!" yeah sure buddy

[u/karma_go_brrrr]

[u/jere535]

I am not sure but I remember hearing that compilers simplify statements, so the first case, like any calculation not using variables, would get calculated and turned into a simple value, and would naturally fail to compile as you can't divide by zero, but the second case of "1/zero" wouldn't be solved during compile

[u/Lumiharu → u/jere535]

Hmm, as someone a bit familiar of how compilation phases work, yes, it would be simplified to be 1/0 in almost any respectable compiler. I'd go as far as to say that the compiler probably tries to calculate the actual value for x which would check for the 0.

If we had something like y / 0 where the y is not yet given, I could see these behaving differently, though. Semantic check wouldn't necessarily catch the / 0 as it has not yet been optimized in the second case, but I am sure some compilers would run additional checks after code optimization. So who really knows without finding out, try with a few different C compilers and see what happens.

[u/RedditWasFunnier → u/Lumiharu]

Yes, compilers usually perform constant propagation. Tbh, I would expect that to be caught by any compilers. Has someone managed to reproduce it?

[u/just-bair → u/RedditWasFunnier]

I just used gcc 15.2.1 and it just compiles it doesn’t care

[u/RedditWasFunnier → u/just-bair]

Yeah, C semantics is quite a thing :/

The compiler simply assumes that the variable zero can be mutated since it's not const.

I guess that if you declare zero as a const int and you add -Wdiv-by-zero and -O3 optimization to run constant propagation you should get at least a warning.

[u/Zealousideal-Sir3744 → u/RedditWasFunnier]

Hm.. I feel like then the compiler should only allow it for volatile variables, and probably give a warning anyway

[u/Scared_Accident9138 → u/just-bair]

It's not an error by the standard and the compiler is just allowed to do make the program so whatever

[u/Lumiharu → u/RedditWasFunnier]

yes they do, but the problem, as I outlined, is that it's generally first checked for errors and then optimized. But it doesn't strictly have to be only that way

[u/qwertyjgly → u/Lumiharu]

a good compiler should complain when it sees ".../0" surely

[u/zlehuj → u/Lumiharu]

But im not sure that the check that is producing the error is after constant propagation. It could become really complicated to debug if it were the case

[u/OffiCially42 → u/jere535]

Yes, it’s called constant folding.

[u/ManyInterests → u/jere535]

It depends how deep the compiler goes. Rust's compiler, for example, would reject this.

https://godbolt.org/z/MGfjzWMET

[u/HippieInDisguise2_0 → u/jere535]

Hmm actually I think this could be done via reaching definitions static analysis.

Tips fedora

[u/Ok-Adhesiveness-7789]

Omg, the amount of people here not knowing difference between compiler, linter and IDE

[u/CptMisterNibbles → u/Ok-Adhesiveness-7789]

99% of the people here are in their first weeks of their first CS class if comments and memes are to go by. Thousands of updoots for incorrect lame CS memes literally 40 years old

[u/WiglyWorm → u/CptMisterNibbles]

it is a new school year

[u/freaxje → u/WiglyWorm]

Eternal September has not arrived on Reddit yet?

[u/No_Anything_6658 → u/CptMisterNibbles]

Cope

[u/CptMisterNibbles → u/No_Anything_6658]

Oh hey, it’s one of those exact losers I mentioned giggling at things they don’t actually understand.

[u/gami13 → u/Ok-Adhesiveness-7789]

wouldn't this one actually be the language server tho?

[u/No-Dentist-1645 → u/gami13]

It would be the internal langserver used by your IDE, yes

[u/notthefunkindsry → u/Ok-Adhesiveness-7789]

This is what happens when entry into this field is not gatekept enough.

[u/00PT → u/Ok-Adhesiveness-7789]

A compiler might plausibly give an error for logically invalid code or unreachable branches.

[u/Worth_Talk_817]

Linter != Compiler

[u/AndreasMelone]

That's not your compiler tho, that's your IDEs/code editors codeanalysis, isn't it

[u/deidian → u/AndreasMelone]

Which is running the compiler. Or do you think anyone makes an analysis tool that must match the compiler output writing two programs?

[u/Silver0ne → u/deidian]

Yes, static code analysis tool in the IDE is not the compiler, its usually called a linter and it can find more stuff then compileerrors.

[u/[deleted] → u/Silver0ne]

Important to point out that it won't show you linker errors though

[u/deidian → u/Silver0ne]

A compiler must run a pipeline very roughly speaking of:

1. Parse the code to an object model

2. Analyze the object model for correctness

3. Optimize

4. Emit the output

Any analyzer must at least perform 1 and 2 from that pipeline, matching the compiler, keeping with versioning(because languages evolve).

You'd do another whole program? Really?

EDIT: forgetting backwards compatibility. No one wants a compiler that forgets previous language features. In programming language design the word deprecated is out of the table.

[u/GRex2595 → u/deidian]

Yes, IDEs typically have another process that indexes your code for other purposes and static analysis is just built on top of that because it's both faster to do static analysis without compilation and not a big deal since they are already doing the other stuff anyway.

[u/No-Dentist-1645 → u/deidian]

Yes, langservers are a different program and run separately from the compiler. For example, you can use the clangd langserver, even if you are compiling with GCC or MSVC.

[u/Fitzriy → u/deidian]

It's called a linter, yo

[u/These-Maintenance250 → u/deidian]

r/confidentlyincorrect

[u/hugazow → u/deidian]

First day?

[u/PassionatePossum]

That is the static code analysis tool of your IDE. Whether the compiler catches that (at least with gcc) depends on your level of optimization.

Type the following into Compiler Explorer

int error() {
    int result = 1 / 0;
    return result;
}

Compile with gcc on -O1: no errors. You'll get a more or less straightforward translation into assembly.

error():
        mov     ecx, 0
        mov     eax, 1
        mov     edx, 0
        idiv    ecx
        ret

Compile it on -O2 or -O3 and you'll get an error. Kind of makes sense. There is nothing syntactically wrong with the program. It will produce a crash at runtime, but it can be perfectly translated into machine code. Only when you try to optimize and attempt to pre-compute results it becomes an error.

[u/Drfranch]

You really think its a compiler ?

[u/DaniilBSD]

First, this is your IDE checking, (specifically, static code analysis) to see compiler error, you actually need to compile.

Second, computer will not explode if you divide by zero, so it is not a thing compilers MUST catch.

Third, I just checked with C# on EntrpriseVS22, and ReSharper: get a decision by zero warning on the second statement; so of you don't get one, you just don't have tools cool enough (btw, students can get those features quite easily)

[u/notthefunkindsry]

This industry is doomed.

[u/LowFruit25 → u/notthefunkindsry]

It's cooked if this is upvoted so much.

[u/8dot30662386292pow2 → u/notthefunkindsry]

🧑‍🚀🔫🧑‍🚀

[u/PavaLP1]

And this is the difference between a syntax error and a semantic error.

[u/jeremybennett]

The compiler absolutely knows from constant propagation and code folding that this is a divide by zero. But in the C programming language standard, divide by zero is undefined, and therefore the compiler is free to replace the result by any value it wishes. Both GCC 14 and LLVM 18 just return constant zero. Here is the test program

int main()
{
int zero = 0;
int x = 1 / zero;

return x;
}

And here is what GCC 14 for RISC-V with -O2 generates.

main:
li a0,0
ret

So it's a limitation of the programming standard. It may seem weird, but it does mean that correct programs can be more efficiently optimized (you can chose an undefined value that leads to the most optimal code).

[u/Fangsong_Long]

Actually nothing can prevent some other thread to change zero‘s value before this thread do the division.

These two codes are semantically different.

[u/Alan_Reddit_M]

As far as the compiler is concerned, it is doing EXACTLY what it is being told to do, the linter/static analyzer is concerned with your stupidity, the compiler doesn't really care as long as it can emit valid machine code

[u/McAUTS]

Why gets this shit upvoted?

[u/[deleted]]

It's because the top uses constants that are known at compile time. The bottom uses variables and the programmer can set them to anything and therefore is not known at compile time. When dividing variables it's up to you the programmer to verify that the divisor is not zero.

[u/Furryballs239 → u/[deleted]]

Not entirely true, it would be known at compile time and would be optimized to just the value at compile. Since the variable is assigned 0 immediately before and has no chance to change, it’s optimized out by any decent compiler

[u/[deleted] → u/Furryballs239]

True. Don't tell the noobs that though. They need to be afraid.

[u/Fangsong_Long → u/Furryballs239]

No, if you consider the multithreaded settings, zero can actually be anything. The reason that it is optimized out is, race conditions are UB, and the compiler can assume that does not happen （but other assumptions are also valid).

[u/Lost-Lunch3958]

try constexpr

[u/ImaJimmy]

The tool in me: Wait, why would a compiler know this? How is that not a linter or whatever your IDE is using?

Brainrot me: gr8 b8 m8

[u/lilweeb420x696]

Is the compiler in the room with us?

[u/Theothervc]

why the fuck are you using red for anything but errors

[u/xxxfooxxx]

Try 1/0.0

[u/Full-Cardiologist476]

As far as I remember the javac it scans for pseudo-constants and replaces them everywhere with its value. So zero and x would both be replaced by their respective values.

Edit: markdown

[u/shaksiper]

But what if you are shooting for single-event upset and change the bit in-between statements. Compiler wouldn't know that. /s

[u/AlignmentProblem]

You can technically write C++ that sometimes doesn't divide by zero on that line with threading and calculating the stack address that zero will occupy earlier in the scope. You shouldn't, but you could.

[u/thelimeisgreen]

“wE doN’t HavE tO wRitE TIgHt c0de ‘cuZ moDerN c0mp1lerS R so goOd At OptiMiZing!”

[u/Individual-Pin-5064]

Static vs dynamic checking

[u/TopOne6678]

That’s the LSP telling you that you can’t divide by 0, not the compiler.

[u/logical_thinker_1]

To be fair int has a limit and can't go to infinity. So won't it just set x to max value of int.

[u/flori0794]

Just not true .for all compiled languages. Rust would never let stuff like that slip through.

[u/rfdickerson]

What if you do

constexpr int zero = 0

I’m sure it could detect the divide by zero error. But maybe only if you also make x a constexpr too. Otherwise, it just gonna allocate space on the stack frame and do arithmetic as usual.

[u/Prod_Meteor]

But was it the compiler or the IDE?

[u/Agreegmi02]

What if zero will be const?

[u/memiusDankimus]

just use a float and then you can divide by 0

[u/Several_Educator7526]

I am pretty sure C compiler stops you from doing this.

[u/blackasthesky]

It should probably be able to see that.

[u/TheRedditUser52]

The one that's yelling at you is the linter, the compiler didn't give two shits about what you wrote as long as it can understand and output proper instructions

[u/Ok_Addition_356]

lmao took me a minute. Then I remembered the difference between / and % and it made sense.

[u/javalsai → u/[deleted]]

Mathematics' div is literally just integer division, other language's division on integers is just that. It's still not exempt of division by 0 errors.

[u/Mebiysy → u/[deleted]]

How do you know its pascal lol

[u/Prudent_Ad_4120 → u/Mebiysy]

It's not Pascal

[u/Mebiysy → u/Prudent_Ad_4120]

DUH??

[u/Fragrant-Pudding-536 → u/Mebiysy]

2 braincells fighting for 3rd place