------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- This file is part of 'Finite Field Arithmetic', aka 'FFA'.               --
--                                                                          --
-- (C) 2018 Stanislav Datskovskiy ( www.loper-os.org )                      --
-- http://wot.deedbot.org/17215D118B7239507FAFED98B98228A001ABFFC7.html     --
--                                                                          --
-- You do not have, nor can you ever acquire the right to use, copy or      --
-- distribute this software ; Should you use this software for any purpose, --
-- or copy and distribute it to anyone or in any manner, you are breaking   --
-- the laws of whatever soi-disant jurisdiction, and you promise to         --
-- continue doing so for the indefinite future. In any case, please         --
-- always : read and understand any software ; verify any PGP signatures    --
-- that you use - for any purpose.                                          --
--                                                                          --
-- See also http://trilema.com/2015/a-new-software-licensing-paradigm .     --
------------------------------------------------------------------------------
------------------------------------------------------------------------------

with W_Shifts; use W_Shifts;


package body W_Mul is
   
   -- Multiply half-words X and Y, producing a Word-sized product
   function Mul_HalfWord(X : in HalfWord; Y : in HalfWord) return Word is
      
      -- X-Slide
      XS : Word := X;
      
      -- Y-Slide
      YS : Word := Y;
      
      -- Gate Mask
      GM : Word;
      
      -- The Product
      XY : Word := 0;
      
      -- Performed for each bit of HalfWord's bitness:
      procedure Bit is
      begin
         
         -- Compute the gate mask
         GM := 0 - (YS and 1);
         
         -- Perform the gated addition
         XY := XY + (XS and GM);
         
         -- Crank the next Y-slide bit into position
         YS := Shift_Right(YS, 1);
         
         -- Advance the X-slide by 1 bit
         XS := Shift_Left(XS, 1);
         
      end Bit;
      pragma Inline_Always(Bit);
      
   begin
      
      -- For each bit of the Y-Slide (unrolled) :
      for b in 1 .. HalfByteness loop
         
         Bit; Bit; Bit; Bit; Bit; Bit; Bit; Bit;
         
      end loop;
      
      -- Return the Product
      return XY;
      
   end Mul_HalfWord;
   pragma Inline_Always(Mul_HalfWord);
   
   
   -- Get the bottom half of a Word
   function BottomHW(W : in Word) return HalfWord is
   begin
      return W and (2**HalfBitness - 1);
   end BottomHW;
   pragma Inline_Always(BottomHW);
   
   
   -- Get the top half of a Word
   function TopHW(W : in Word) return HalfWord is
   begin
      return Shift_Right(W, HalfBitness);
   end TopHW;
   pragma Inline_Always(TopHW);
   
   
   -- Carry out X*Y mult, return lower word XY_LW and upper word XY_HW.
   procedure Mul_Word(X       : in  Word;
                      Y       : in  Word;
                      XY_LW   : out Word;
                      XY_HW   : out Word) is
      
      -- Bottom half of multiplicand X
      XL : constant HalfWord := BottomHW(X);
      
      -- Top half of multiplicand X
      XH : constant HalfWord := TopHW(X);
      
      -- Bottom half of multiplicand Y
      YL : constant HalfWord := BottomHW(Y);
      
      -- Top half of multiplicand Y
      YH : constant HalfWord := TopHW(Y);
      
      -- XL * YL
      LL : constant Word := Mul_HalfWord(XL, YL);
      
      -- XL * YH
      LH : constant Word := Mul_HalfWord(XL, YH);
      
      -- XH * YL
      HL : constant Word := Mul_HalfWord(XH, YL);
      
      -- XH * YH
      HH : constant Word := Mul_HalfWord(XH, YH);
      
      -- Carry
      CL : constant Word := TopHW(TopHW(LL) + BottomHW(LH) + BottomHW(HL));
      
   begin
      
      -- Get the bottom half of the Product:
      XY_LW := LL + Shift_Left(LH + HL, HalfBitness);
      
      -- Get the top half of the Product:
      XY_HW := HH + TopHW(HL) + TopHW(LH) + CL;
      
   end Mul_Word;
   pragma Inline_Always(Mul_Word);
   
end W_Mul;