3 ms·

> Are you saying this isn't quite true? It is not. The presence of UB in an execution path renders that execution path invalid. UBs are behaviours, essentially

> Are you saying this isn't quite true? It is not. The presence of UB in an execution path renders that execution path invalid. UBs are behaviours, essentially partial functions which are allowed to arbitrarily corrupt program state rather than error. However "that execution path" can be extensive in the face of aggressive advanced optimisations. The "time travel" issue is generally that the compiler can prove some paths can't be valid (they always lead to UB), so trims out those paths entirely, possibly leaving just a poison (a crash). Thus although the undefined behaviour which causes the crash "should" occur after an observable side-effect, because the program is considered corrupt from the point where it will inevitably encounter an UB the side-effect gets suppressed, and it looks like the program executes non linearly (because the error condition which follows the side effect triggers before the side effect executes).

LoganDark 2y ago
Hmm, it could be that once UB is encountered the entire program becomes invalid, then. In practice, a lot of UB is quite subtle and may not necessarily result in complete disaster, but of course once it's occurred you could end up in any number of completely invalid states and that would be the fault of the UB.
- masklinn 2y ago
  > Hmm, it could be that once UB is encountered the entire program becomes invalid, then. The UB doesn't actually need to be encountered, just guaranteed to be encountered eventually (in a non-statistical meaning), that is where the time travel comes from e.g. if you have if (condition) { printf("thing\n"); 1/0; } else { // other thing } the compiler can turn this into if (condition) { // crash } else { // other thing } as well as // other thing In the first case you have "time travel" because the crash occurs before the print, even though in a sequentially consistent world where division by zero was defined as a crash (e.g. in python) you should see the print first.
  - LoganDark 2y ago
    > The UB doesn't actually need to be encountered, just guaranteed to be encountered eventually That's what I meant. Anything that leads to UB itself has UB.
uecker 2y ago
Note that C++ has time-travel, C has not. A printf on a path which later encounters an operation with UB needs to be preserved.

LoganDark 2y ago

Hmm, it could be that once UB is encountered the entire program becomes invalid, then. In practice, a lot of UB is quite subtle and may not necessarily result in complete disaster, but of course once it's occurred you could end up in any number of completely invalid states and that would be the fault of the UB.

masklinn 2y ago
> Hmm, it could be that once UB is encountered the entire program becomes invalid, then. The UB doesn't actually need to be encountered, just guaranteed to be encountered eventually (in a non-statistical meaning), that is where the time travel comes from e.g. if you have if (condition) { printf("thing\n"); 1/0; } else { // other thing } the compiler can turn this into if (condition) { // crash } else { // other thing } as well as // other thing In the first case you have "time travel" because the crash occurs before the print, even though in a sequentially consistent world where division by zero was defined as a crash (e.g. in python) you should see the print first.
- LoganDark 2y ago
  > The UB doesn't actually need to be encountered, just guaranteed to be encountered eventually That's what I meant. Anything that leads to UB itself has UB.

uecker 2y ago

Note that C++ has time-travel, C has not. A printf on a path which later encounters an operation with UB needs to be preserved.