"Undefined behaviour" in Julia; does it e.g. apply to signed overflow addition?

Compared to e.g. C and C++20 - Wikipedia, how much undefined behavior does Julia have?

signed integers are now defined to be represented using two’s complement (signed integer overflow remains undefined behavior)

Julia is also defined to use two’s complement (since always), as it’s pretty much used in all non-ancient platforms, at least on all Julia’s currently supported platforms. I suspect that in C++ overflows being UB (except for unsigned) is because some platforms do trap, or could in theory. I don’t think any of Julia’s current platforms do, so it seems Julia could define it as NOT undefined behavior.

I see only “undefined” mentioned here in one comment (and I’m not sure how know or official it is as Julia doesn’t have a standard):

What’s the reason for it in general? Is it because LLVM has UB? Or because we mostly use C++ rules? Should those be assumed if otherwise not known?

FYI: In C++ you CAN avoid UB for this above example, so in case we need to enforce in Julia (while I’m not sure if this is possible in C, or even if either applies, we use C more but really LLVM is the only thing here that matters?):

A particular implementation may define signed integer overflow to wrap as an extension to the standard. Support for this would be indicated via the std::numeric_limits<T>::is_modulo template. Otherwise, it is undefined behavior.

“Undefined behaviour” in Julia; does it e.g. apply to signed overflow addition?

Nope