<div dir="ltr"><div><div><div>Makes sense, but I am curious, how do you see adding this post-1.0?   Would you:<br></div>- add overflow-checked int types and tell everybody to use them instead of the default ones from that point on<br>
</div>- declare that in Rust2 integers are overflow-checked, and have everybody port their Rust1 code.  (Well, in reality, I would expect that most existing code would just continue to work, but some testing will be needed).<br>
</div><div>Both sound somewhat painful.<br></div><div><br></div><div class="gmail_extra">I still think it would be a good idea to provide explicitly wrapping int types (which aren't the default ones) from get-go and point out in documentation that those are the ones to be used when writing hashes, etc.  Even if they are just aliases of the default int types.  If nothing else, this will allow people to document in their code whether the ints were supposed to wrap around or not.<br>
<br>Vadim<br><br><div class="gmail_quote">On Sun, Jun 22, 2014 at 4:12 PM, Patrick Walton <span dir="ltr"><<a href="mailto:pcwalton@mozilla.com" target="_blank">pcwalton@mozilla.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div>On 6/22/14 2:12 PM, Cameron Zwarich wrote:<br>
<blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">
For some applications, Rust’s bounds checks and the inability of rustc<br>
to eliminate them in nontrivial cases will already be too much of a<br>
performance sacrifice. What do we say to those people? Is it just that<br>
memory safety is important because of its security implications, and<br>
other forms of program correctness are not?<br>
<br>
I am wary of circling around on this topic again, but I feel that the<br>
biggest mistake in this discussion js that checked overflow in a<br>
language requires a potential trap on every single integer operation.<br>
Languages like Ada (and Swift, to a lesser extent), allow for slightly<br>
imprecise exceptions in the case of integer overflow.<br>
</blockquote>
<br></div>
I believe that it is possible that the overhead of integer overflow will be negligible in the future, and that paper is exciting to me too! But I feel that:<br>
<br>
1. Integer overflow is primarily a security concern when it compromises memory safety. Quoting OWASP [1], emphasis mine:<br>
<br>
"An integer overflow condition exists when an integer, which has not been properly sanity checked, is used in the *determination of an offset or size for memory allocation, copying, concatenation, or similarly*."<br>


<br>
Other features in Rust, such as bounds checks, unsigned indexing, and the borrow check, defend against the memory safety problems. So the benefits of defending against memory safety are likely to be quite different in Rust from in C. It's a question of costs versus benefits, as always.<br>


<br>
2. Signed integer overflow is not undefined behavior in Rust as it is in C. This mitigates some of the more frightening risks associated with it.<br>
<br>
3. The As-If-Infinitely-Ranged paper is research. Like all research, the risk of adopting integer overflow checks is somewhat high; it might still not work out to be acceptable in practice when we've exhausted all potential compiler optimizations that it allows. That risk has to be compared against the potential reward, which is likely to be lesser in Rust than in C because of the reasons outlined in (1) and (2).<br>


<br>
4. We have a pretty tight shipping schedule at this point: 1.0, which is the backwards compatible release, is on track to be released this year. We are making excellent progress on backwards incompatible language changes (closed 10 out of 45 issues over the past 2 weeks!), but we must be consciously fighting scope creep in order to release a product.<br>


<br>
5. It's not clear to me that integer overflow cannot be added backwards compatibly: we can lexically scope checked arithmetic in much the same way C# lexically scopes unchecked arithmetic. It's not in line with Rust's philosophy of safe-by-default, but saying that we might introduce a safer opt-in version of Rust in the future strikes me as a fairly pragmatic compromise, and one that is not without successful precedent: for example, C, has, for all intents and purposes, successfully shed the baggage of its "variables without an annotated type default to int" design mistake via a bog-standard compiler warning.<br>


<br>
For these reasons, I'm pretty comfortable with not making any changes for 1.0, and deferring this issue to later.<br>
<br>
Patrick<br>
<br>
[1]: <a href="https://www.owasp.org/index.php/Integer_overflow" target="_blank">https://www.owasp.org/index.php/Integer_overflow</a><div><div><br>
<br>
_______________________________________________<br>
Rust-dev mailing list<br>
<a href="mailto:Rust-dev@mozilla.org" target="_blank">Rust-dev@mozilla.org</a><br>
<a href="https://mail.mozilla.org/listinfo/rust-dev" target="_blank">https://mail.mozilla.org/listinfo/rust-dev</a><br>
</div></div></blockquote></div><br></div></div>