www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Re: Not just for cryptography

reply Era Scarecrow <rtcvb32 yahoo.com> writes:
 From: Don <nospam nospam.com.au>
 Era Scarecrow wrote:
 From: Sean Kelly <sean invisibleduck.org>

 bearophile wrote:
 Another little story for people that think the

 Avoiding computation overflow is never a bad thing

 Actually that's (sort of) implemented in most hardware
 (X86, for 
 instance). The overflow flag is set if you get an int
 overflow (signed 
 ints). The carry flag is set if you get a uint overflow.
 There are several branch instructions which make use of it.
  Internally (Assembly) it would look something like

  if (a+b > 0){
  xor edx,edx        ;clear upper 32bits
  mov eax, [esp-12]  ;int a
  add eax, [esp-8]   ;int b
  adc edx, 0         ;add with carry

 --then following the compare 
  cmp edx,0
  jg inside_if  ;jump if greater than 0. More likely?
  jb outside_if ;below 0, so it's false
  cmp eax,0
  jbe outside_if

mov eax, [esp-12]; add eax, [esp-8]; jo error; jbe outside_if; error: throw IntegerOverflowException. Could be added in debug builds, at least.

Sounds promising. From what i know in C, that is never brought up, so if i wanted to handle a overflow or a carry flag i'd have to use a long long. (For a unsigned unlimited Integer math library i made, but has problems) Would it be possible, to have a couple operators or a special inline functions we can use to be able to use those possible overflows? I'd rather not ASM in lines where it won't be portable :( int carry, a = int.umax; b = a + a; if (Register.Overflow || Register.Carry){...} //possible? math_overflow{...} //or math_carryOn{...} //or?? ASM(Intel) { jno notOverFlow ... } notOverFlow: //or?? long long carry, a = int.umax; b = a + a; if (b>int.umax) {...} Era
Aug 04 2008
parent bearophile <bearophileHUGS lycos.com> writes:
Era Scarecrow Wrote:

An idea is for DMD to:
- when in release mode perform as now
- When not in release mode use 4 byte numbers (or 8 byte on 64 bit CPUs) to
compute operations among integral values represented in 1 or 2 bytes, use 8
bytes to perform operations among integral values represented in 4 bytes, and
use 16 bytes to perform operations performed among 8 byte integral values. And
control if the result can fit in the right range. I think Delphi works almost
this way. In Delphi you also can define types of integer intervals:
Smally = 1 .. 25;
so the compiler (if not in release mode) controls if values are in those bounds
(In D you can perform something similar adding pre/post that test if that value
is in the interval, but such control is done less often and you have to do it
yourself manually in many parts of the code, so you don't spot the bug as soon
you go out of the bounds).
In some points the compiler doesn't need to control the bounds because it can
infer the value will not go out of bounds.

Aug 04 2008