RE: RISC

["Beard, Frank" <beardf@spawar.navy.mil>]

Chris,

I haven't been following the thread and someone may have
already suggested this, but, along the lines of what Martin
was suggesting, can't you do the following:

   For addition:

      Register := ...

      New_Value := Register + delta;

      if (New_Value < Register) then
         -- overflow
      else
         Register := New_Value;
      end if;

   For subtraction:

      Register := ...

      New_Value := Register - delta;

      if (New_Value > Register) then
         -- underflow
      else
         Register := New_Value;
      end if;

   For multiplication:

      Register := ...

      New_Value := Register * delta;

      if (New_Value < Register) then
         -- overflow
       else
         Register := New_Value;
      end if;

   For division:

      Register := ...

      New_Value := Register / delta;

      if (New_Value > Register) then
         -- underflow
       else
         Register := New_Value;
      end if;

I know this isn't ideal, but it seems like it should work.


Another option might be (assuming a 32 bit register):

   type Bit_Array is array (1..32) of boolean;
   pragma Pack(Bit_Array);

   Register_Bits : Bit_Array;
   for Register_Bits use Register'address;

   High_Order_Bit_Set := Register_Bits(32);

   -- After addition and multiplication

   -- If the high order bit was set and is now clear
   if High_Order_Bit_Set and then not Register_Bits(32) then
      -- overflow
   end if;

   -- After subtraction and division

   -- If the high order bit was clear and is now set
   if not High_Order_Bit_Set and then Register_Bits(32) then
      -- underflow
   end if;

Or, something like that.  It's late and I'm not thinking too
clearly.

Frank

PS.
If someone else has already suggested this, and you know
of problems, then by all means disregard it.

-----Original Message-----
From: chris.danx [mailto:chris.danx@ntlworld.com]
Sent: Wednesday, March 28, 2001 5:24 PM
To: comp.lang.ada@ada.eu.org
Subject: Re: RISC 


mod types have made some parts of the machine simple but are making
arithmetic operations a nightmare.

I need to support 2s compliment integers (floats will not feature at all)
hence mod types.  Taking not of X and add 1, then it's negative.  no probs!
Problem is with sign and overflow on add, sub, mul, div.

Each one must cope with signed nums and unsigned ones -- signal a carry or
overflow.  I think you can just do add/sub and no worries.  Problems arise
when i detect overflow, i tried thinking this out, and Martin Dowie pointed
out a possible solution that might work but only for unsigned nums.  I don't
know how to go about this signed ones.

I really need to know how to detect overflow for multiplication and
division.  I also need a way to detect it for add and sub.  Maybe Ada has an
attribute for this or something,

    e.g. ...
            type X is mod 256;
            ...
            a :    x := 128;
            a := x + x;
            ...
            if a'overflow then
                ...
            end if;

{i doubt it though!}

Can anyone help,


Thanks,
Chris Campbell

"Martin Dowie" <martin.dowie@gecm.com> wrote in message
news:3ab5d2a4$1@pull.gecm.com...
> I had a similar problem recently when I had to mimic unsigned 64 bits with
> only
> unsigned 32 bits available.
>
> For addition and subtract it is fairly easy. e.g.
>
> a = 255, b = 1
> c = a + b
> if c < a then overflow as it has wrapped
>
> similarly for subtraction with > instead of <.
>
> I only required +/- support, so I'm afraid I have no solutions for * or /
> :-(
>
> The long-hand way for multiplications would be to add e.g.
> a = 90, b = 3
> c = 0
> for I in 1 .. b loop
>   c = c + a
>   if c < a then overflow as it has wrapped
> end loop
>
> not very efficient...
>
> Sorry, no ideas spring to mind for division...
>
> chris.danx <chris.danx@ntlworld.com> wrote in message
> news:qrws6.3335$bL.360000@news6-win.server.ntlworld.com...
> > Two quickies! I hope!
> >
> >[snip]
> >
> > I'm using mod types to simulate registers in the RISC machine.  I'm
about
> to
> > implement arithmetic operations but i've thought of a problem.  How do i
> > detect overflow?
> >
> > e.g.
> >     say it was 1 byte reg
> >
> >     25*158 is too big.
> >
> >     12+254 is too big also.
>
>
>


_______________________________________________
comp.lang.ada mailing list
comp.lang.ada@ada.eu.org
http://ada.eu.org/mailman/listinfo/comp.lang.ada