URL https://opencores.org/ocsvn/raytrac/raytrac/trunk

Subversion Repositories raytrac

[/] [raytrac/] [trunk/] [fpbranch/] [unrm/] [shftr.vhd] - Blame information for rev 114

Go to most recent revision | Details | Compare with Previous | View Log


 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use ieee.std_logic_arith.all;
 
 
 
 
entity fadd32 is
        port (
                a32,b32: in std_logic_vector(31 downto 0);
                dpc,clk:in std_logic;
                c32:out std_logic_vector(31 downto 0)
        );
end fadd32;
architecture fadd32_arch of fadd32 is
 
        component lpm_mult
        generic (
                lpm_hint                        : string;
                lpm_representation      : string;
                lpm_type                        : string;
                lpm_widtha                      : natural;
                lpm_widthb                      : natural;
                lpm_widthp                      : natural
        );
        port (
                dataa   : in std_logic_vector ( lpm_widtha-1 downto 0 );
                datab   : in std_logic_vector ( lpm_widthb-1 downto 0 );
                result  : out std_logic_vector( lpm_widthp-1 downto 0 )
        );
        end component;
 
        signal s0signa,s0signb : std_logic;
        signal s0ea,s0eb: std_logic_vector(7 downto 0);
        signal s0uma,s0umb:std_logic_vector(22 downto 0);
 
        signal s1signa, s1signb: std_logic;
        signal s1sdelta,s1expunrm: std_logic_vector(7 downto 0);
        signal s1udelta,s1xorslab: std_logic_vector(4 downto 0);
        signal s1uma,s1umb:std_logic_vector(22 downto 0);
        signal s1factor: std_logic_vector(8 downto 0);
 
        signal s2signa,s2signb,s2bgta : std_logic;
        signal s2exp : std_logic_vector(7 downto 0);
        signal s2udelta : std_logic_vector (1 downto 0);
        signal s2um0,s2uma,s2umb,s2smshift : std_logic_vector(22 downto 0);
        signal s2xorslab : std_logic_vector(23 downto 0);
        signal s2factor : std_logic_vector(8 downto 0);
        signal s2psh:std_logic_vector(26 downto 0);
        signal s2psl:std_logic_vector(17 downto 0);
 
        signal s2asign,s2azero,s2abgta:std_logic;
        signal s2asm0,s2asm1 : std_logic_vector(24 downto 0);
        signal s2asm : std_logic_vector(25 downto 0);
        signal s2aum1 : std_logic_vector(23 downto 0);
        signal s2aexp : std_logic_vector(7 downto 0);
        signal s2audelta : std_logic_vector (1 downto 0);
        signal s2axorslab: std_logic_vector(23 downto 0);
 
        signal s3sign: std_logic;
        signal s3um,s3xorslab: std_logic_vector(24 downto 0);
        signal s3sm: std_logic_vector(25 downto 0);
        signal s3exp:std_logic_vector(7 downto 0);
 
        signal s3asign:std_logic;
        signal s3ashift:std_logic_vector(7 downto 0);
        signal s3afactor,s3aexp: std_logic_vector(7 downto 0);
        signal s3aum,s3afactorhot:std_logic_vector(24 downto 0);
 
        signal s4sign: std_logic;
        signal s4shift: std_logic_vector(7 downto 0);
        signal s4exp: std_logic_vector(7 downto 0);
        signal s4factorhot9: std_logic_vector(8 downto 0);
        signal s4pl: std_logic_vector(17 downto 0);
        signal s4postshift: std_logic_vector(22 downto 0);
        signal s4um,s4factorhot: std_logic_vector(24 downto 0);
        signal s4ph: std_logic_vector(26 downto 0);
 
begin
 
--! ******************************************************************************************************************************
        --! Pipeline
        pipeline:
        process(clk)
        begin
 
                if clk='1' and clk'event then
 
                        --! Registro de entrada
 
                        s0ea    <=      a32(30 downto 23);
                        s0uma   <=      a32(22 downto 0);
                        s0signa <=      a32(31);
                        s0eb    <=      b32(30 downto 23);
                        s0umb   <=      b32(22 downto 0);
                        s0signb <=      a32(31) xor dpc;
 
                        --! Etapa 0
                        --! I3E754ZERO y calculo del delta entre exponentes     
                        if s0ea="00" then
                                s1signa <= '0';
                        else
                                s1signa <= s0signa;
                        end if;
                        if s0eb="00" then
                                s1signb <= '0';
                                s1expunrm <= s0ea;
                        else
                                s1signb <= s0signb;
                                s1expunrm <= s0eb;
                        end if;
                        if s0ea=x"00" or s0eb=x"00" then
                                s1sdelta <= x"00";
                        else
                                s1sdelta <= s0ea-s0eb;
                        end if;
                        --! Buffers
                        s1uma           <=      s0uma;
                        s1umb           <=      s0umb;
 
                        --! Etapa 1
                        --! Manejo de exponente, previo a la denormalizacion
                        --! Calulo del Factor de corrimiento 
                        s2exp   <= s1expunrm+s1sdelta;
                        s2factor        <= s1factor;
 
                        --! Otras se&ntilde;ales de soporte
                        s2signa         <= s1signa;
                        s2signb         <= s1signb;
                        s2bgta          <= s1sdelta(7);
                        s2uma           <= s1uma;
                        s2umb           <= s1umb;
                        s2udelta        <= s1udelta(4 downto 3);
 
                        --! Etapa 2 Realizar los corrimientos, denormalizacion parcial y signar la mantissa que se queda fija
                        --! Mantissa Fija
                        s2asm0          <= (s2xorslab(23)&(('1'&s2um0(22 downto 0))xor(s2xorslab)))+(x"000000"&s2xorslab(23));
                        --! Mantissa Corrida no signada
                        case s2udelta is
                                when "00" =>
                                        s2aum1(23 downto 06)    <= s2psh(25 downto 08);
                                        s2aum1(05 downto 00)    <= s2psh(07 downto 02) or (s2psl(16 downto 11));
                                when "01" =>
                                        s2aum1(23 downto 06)    <= x"00"&s2psh(25 downto 16);
                                        s2aum1(05 downto 00)    <= s2psh(15 downto 10);
                                when "10" =>
                                        s2aum1(23 downto 06)    <= x"0000"&s2psh(25 downto 24);
                                        s2aum1(05 downto 00)    <= s2psh(23 downto 18);
                                when others =>
                                        s2aum1                                  <= (others => '0');
                        end case;
                        s2asign         <= (s2bgta and s2signa) or (not(s2bgta) and s2signb);
                        --! Exponente normalizado
                        s2aexp          <= s2exp;
                        --! Uno de los sumandos es 0.
                        s2azero         <= (not(s2signb)) or (not(s2signa));
 
 
                        --! Etapa 2a signar la mantissa corrida y sumarlas con la no corrida
                        s3sm <= s2asm;
                        s3exp <= s2aexp;
 
 
                        --! Etapa 3 quitar el signo a la mantissa.
                        s3asign <= s3sign;
                        s3aum <= s3um;
                        s3aexp <= s3exp;
 
 
                        --! Eatapa 3a calcular el factor de corrimiento para la normalizacion y el delta del exponente.
                        s4sign <= s3asign;
                        s4exp  <= s3aexp;
                        s4shift<= s3ashift;
                        s4factorhot <= s3afactorhot;
                        s4um <= s3aum;
 
                        --! Etapa 4 Normalizar la mantissa resultado y renormalizar el exponente. Entregar el resultado!
                        c32(31) <= s4sign;
                        c32(30 downto 23) <= s4exp-s4shift;
                        case s4shift(4 downto 3) is
                                when "01"  =>  c32(22 downto 0) <= x"00"&s4postshift(22 downto 8);
                                when "10"  =>  c32(22 downto 0) <= x"0000"&s4postshift(22 downto 16);
                                when others => c32(22 downto 0) <= s4postshift(22 downto 0);
                        end case;
 
                end if;
        end process;
 
--! ******************************************************************************************************************************
 
        --! Etapa 1
        --! Decodificar la magnitud del corrimiento
        decodermag:
        process (s1udelta(7), s1udelta(4 downto 0))
        begin
                s1xorslab       <= (others => s1sdelta(7));
                s1udelta        <= (s1sdelta(4 downto 0) xor s1xorslab)+(x"0"&s1sdelta(7));
        end process;
 
        --! Decodificar el factor de corrimiento
        denormfactor:
        process (s1udelta(2 downto 0),s1sdelta(7))
        begin
                s1factor(8 downto 0) <= (others => s1sdelta(7));
                case s1udelta(2 downto 0) is
                        when "000" => s1factor(8 downto 0)       <= "100000000";
                        when "001" => s1factor(8 downto 0)       <= "010000000";
                        when "010" => s1factor(8 downto 0)       <= "001000000";
                        when "011" => s1factor(8 downto 0)       <= "000100000";
                        when "100" => s1factor(8 downto 0)       <= "000010000";
                        when "101" => s1factor(8 downto 0)       <= "000001000";
                        when "110" => s1factor(8 downto 0)       <= "000000100";
                        when others => s1factor(8 downto 0) <= "000000010";
                end case;
        end process;
--! ******************************************************************************************************************************
        --! Etapa2
        --! Correr las mantissas
        denomrselectmantissa2shift:
        process (s2bgta,s2signa,s2signb,s2uma,s2umb)
        begin
 
                case s2bgta is
                        when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto
                                s2um0                   <= s2umb;
                                s2xorslab               <= (others => s2signb);
 
                                s2smshift               <= s2uma;
 
                        when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto
                                s2um0                   <= s2uma;
                                s2xorslab               <= (others => s2signa);
 
                                s2smshift               <= s2umb;
 
                end case;
        end process;
 
 
        --! Correr las mantissas y calcularlas.
        hshiftdenorm: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,18,27)
        port    map (s2factor,'1'&s2smshift(22 downto 06),s2psh);
        lshiftdenorm: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,9,18)
        port    map (s2factor,s2smshift(05 downto 00)&"000",s2psl);
 
 
--! ******************************************************************************************************************************
        --! Etapa2a signar las mantissas y sumarlas.
        signmantissa:
        process(s2asign,s2aum1,s2asm0,s2azero)
        begin
                s2axorslab      <= (others => s2asign);
                s2asm1          <= (s2axorslab(23)&(s2aum1 xor (s2axorslab)))+(x"000000"&s2axorslab(23));
                case s2azero is
                        when '0'         => s2asm <= (s2asm1(s2asm1'high)&s2asm1) +  (s2asm0(s2asm0'high)&s2asm0);
                        when others     => s2asm <= (s2asm1(s2asm1'high)&s2asm1) or (s2asm0(s2asm0'high)&s2asm0);
                end case;
        end process;
 
--! ******************************************************************************************************************************
        --! Etapa3 : Quitar el signo a las mantissa.
--! ******************************************************************************************************************************
        unsignmantissa:
        process(s3sm)
        begin
                s3xorslab       <= ( others => s3sm(s3sm'high) );
                s3um(24 downto 0)        <= ( s3sm(24 downto 0) xor s3xorslab ) + (x"000000"&s3xorslab(24));
                s3sign <= s3sm(s3sm'high);
        end process;
--! ******************************************************************************************************************************
        --! Etapa3a : Decodificar el factor de corrimiento y calcular el exponente normalizado. 
--! ******************************************************************************************************************************
        redentioform:
        process(s3aum,s3asign)
        begin
                s3ashift <= s3aexp;
                s3afactorhot <= (others => '0');
                for i in 24 downto 0 loop
                        if s3aum(i)='1' then
                                s3ashift <= conv_std_logic_vector(24-i,8)+x"ff";
                                s3afactorhot(24-i) <= '1';
                                exit;
                        end if;
                end loop;
        end process;
--! ******************************************************************************************************************************
        --! Etapa4 : Normalizar la mantissa y calcular el exponente. Entregar el resultado 
--! ******************************************************************************************************************************
        --!Normalizacion mediante multiplicacion
        process (s4ph,s4pl,s4factorhot,s4um)
        begin
                s4postshift(22 downto 15) <= s4ph(16 downto 9);
                s4postshift(14 downto 06) <= s4ph(08 downto 0) or s4pl(17 downto 9);
                s4postshift(05 downto 00) <= s4pl(08 downto 3);
                case s4shift(4 downto 3) is
                        when "00"  =>
                                s4factorhot9 <= s4factorhot(08 downto 01)&'0';
                        when "01"  =>
                                s4factorhot9 <= s4factorhot(16 downto 09)&'0';
                        when "10"  =>
                                s4factorhot9 <= s4factorhot(24 downto 17)&'0';
                        when others =>
                                s4factorhot9 <= s4factorhot(08 downto 00);
                end case;
        end process;
        hshiftnorm: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,18,27)
        port    map (s4factorhot9,s4um(24 downto 07),s4ph);
        lshiftnorm: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,9,18)
        port    map (s4factorhot9,s4um(06 downto 00)&"00",s4pl);
 
 
 
 
 
 
 
 
 
 
 
end fadd32_arch;
 
 
 
 
 
 
 
 

Line No.	Rev	Author	Line
1	114	jguarin200
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26	106	jguarin200	`library ieee;`
27			`use ieee.std_logic_1164.all;`
28	108	jguarin200	`use ieee.std_logic_unsigned.all;`
29	114	jguarin200	`use ieee.std_logic_arith.all;`
30	106	jguarin200
31
32
33	114	jguarin200
34	108	jguarin200	`entity fadd32 is`
35	106	jguarin200	`port (`
36	108	jguarin200	`a32,b32: in std_logic_vector(31 downto 0);`
37	114	jguarin200	`dpc,clk:in std_logic;`
38			`c32:out std_logic_vector(31 downto 0)`
39	106	jguarin200	`);`
40	108	jguarin200	`end fadd32;`
41			`architecture fadd32_arch of fadd32 is`
42	106	jguarin200
43			`component lpm_mult`
44			`generic (`
45			`lpm_hint : string;`
46			`lpm_representation : string;`
47			`lpm_type : string;`
48			`lpm_widtha : natural;`
49			`lpm_widthb : natural;`
50			`lpm_widthp : natural`
51			`);`
52			`port (`
53			`dataa : in std_logic_vector ( lpm_widtha-1 downto 0 );`
54			`datab : in std_logic_vector ( lpm_widthb-1 downto 0 );`
55			`result : out std_logic_vector( lpm_widthp-1 downto 0 )`
56			`);`
57			`end component;`
58	108	jguarin200
59	114	jguarin200	`signal s0signa,s0signb : std_logic;`
60			`signal s0ea,s0eb: std_logic_vector(7 downto 0);`
61			`signal s0uma,s0umb:std_logic_vector(22 downto 0);`
62	108	jguarin200
63	114	jguarin200	`signal s1signa, s1signb: std_logic;`
64			`signal s1sdelta,s1expunrm: std_logic_vector(7 downto 0);`
65			`signal s1udelta,s1xorslab: std_logic_vector(4 downto 0);`
66			`signal s1uma,s1umb:std_logic_vector(22 downto 0);`
67			`signal s1factor: std_logic_vector(8 downto 0);`
68
69			`signal s2signa,s2signb,s2bgta : std_logic;`
70			`signal s2exp : std_logic_vector(7 downto 0);`
71			`signal s2udelta : std_logic_vector (1 downto 0);`
72			`signal s2um0,s2uma,s2umb,s2smshift : std_logic_vector(22 downto 0);`
73			`signal s2xorslab : std_logic_vector(23 downto 0);`
74			`signal s2factor : std_logic_vector(8 downto 0);`
75			`signal s2psh:std_logic_vector(26 downto 0);`
76			`signal s2psl:std_logic_vector(17 downto 0);`
77
78			`signal s2asign,s2azero,s2abgta:std_logic;`
79			`signal s2asm0,s2asm1 : std_logic_vector(24 downto 0);`
80			`signal s2asm : std_logic_vector(25 downto 0);`
81			`signal s2aum1 : std_logic_vector(23 downto 0);`
82			`signal s2aexp : std_logic_vector(7 downto 0);`
83			`signal s2audelta : std_logic_vector (1 downto 0);`
84			`signal s2axorslab: std_logic_vector(23 downto 0);`
85
86			`signal s3sign: std_logic;`
87			`signal s3um,s3xorslab: std_logic_vector(24 downto 0);`
88			`signal s3sm: std_logic_vector(25 downto 0);`
89			`signal s3exp:std_logic_vector(7 downto 0);`
90
91			`signal s3asign:std_logic;`
92			`signal s3ashift:std_logic_vector(7 downto 0);`
93			`signal s3afactor,s3aexp: std_logic_vector(7 downto 0);`
94			`signal s3aum,s3afactorhot:std_logic_vector(24 downto 0);`
95
96			`signal s4sign: std_logic;`
97			`signal s4shift: std_logic_vector(7 downto 0);`
98			`signal s4exp: std_logic_vector(7 downto 0);`
99			`signal s4factorhot9: std_logic_vector(8 downto 0);`
100			`signal s4pl: std_logic_vector(17 downto 0);`
101			`signal s4postshift: std_logic_vector(22 downto 0);`
102			`signal s4um,s4factorhot: std_logic_vector(24 downto 0);`
103			`signal s4ph: std_logic_vector(26 downto 0);`
104
105	106	jguarin200	`begin`
106	111	jguarin200
107			`--! ******************************************************************************************************************************`
108	109	jguarin200	`--! Pipeline`
109			`pipeline:`
110			`process(clk)`
111	108	jguarin200	`begin`
112	109	jguarin200
113			`if clk='1' and clk'event then`
114	108	jguarin200
115	109	jguarin200	`--! Registro de entrada`
116	114	jguarin200
117			`s0ea <= a32(30 downto 23);`
118			`s0uma <= a32(22 downto 0);`
119	109	jguarin200	`s0signa <= a32(31);`
120	114	jguarin200	`s0eb <= b32(30 downto 23);`
121			`s0umb <= b32(22 downto 0);`
122	109	jguarin200	`s0signb <= a32(31) xor dpc;`
123
124			`--! Etapa 0`
125			`--! I3E754ZERO y calculo del delta entre exponentes`
126			`if s0ea="00" then`
127			`s1signa <= '0';`
128			`else`
129			`s1signa <= s0signa;`
130			`end if;`
131			`if s0eb="00" then`
132			`s1signb <= '0';`
133			`s1expunrm <= s0ea;`
134			`else`
135			`s1signb <= s0signb;`
136			`s1expunrm <= s0eb;`
137			`end if;`
138			`if s0ea=x"00" or s0eb=x"00" then`
139			`s1sdelta <= x"00";`
140			`else`
141			`s1sdelta <= s0ea-s0eb;`
142			`end if;`
143			`--! Buffers`
144			`s1uma <= s0uma;`
145			`s1umb <= s0umb;`
146	108	jguarin200
147	109	jguarin200	`--! Etapa 1`
148			`--! Manejo de exponente, previo a la denormalizacion`
149			`--! Calulo del Factor de corrimiento`
150	114	jguarin200	`s2exp <= s1expunrm+s1sdelta;`
151	111	jguarin200	`s2factor <= s1factor;`
152	109	jguarin200
153			`--! Otras señales de soporte`
154			`s2signa <= s1signa;`
155			`s2signb <= s1signb;`
156	111	jguarin200	`s2bgta <= s1sdelta(7);`
157			`s2uma <= s1uma;`
158			`s2umb <= s1umb;`
159			`s2udelta <= s1udelta(4 downto 3);`
160	109	jguarin200
161	114	jguarin200	`--! Etapa 2 Realizar los corrimientos, denormalizacion parcial y signar la mantissa que se queda fija`
162			`--! Mantissa Fija`
163	111	jguarin200	`s2asm0 <= (s2xorslab(23)&(('1'&s2um0(22 downto 0))xor(s2xorslab)))+(x"000000"&s2xorslab(23));`
164	114	jguarin200	`--! Mantissa Corrida no signada`
165	111	jguarin200	`case s2udelta is`
166			`when "00" =>`
167			`s2aum1(23 downto 06) <= s2psh(25 downto 08);`
168			`s2aum1(05 downto 00) <= s2psh(07 downto 02) or (s2psl(16 downto 11));`
169			`when "01" =>`
170	114	jguarin200	`s2aum1(23 downto 06) <= x"00"&s2psh(25 downto 16);`
171			`s2aum1(05 downto 00) <= s2psh(15 downto 10);`
172	111	jguarin200	`when "10" =>`
173	114	jguarin200	`s2aum1(23 downto 06) <= x"0000"&s2psh(25 downto 24);`
174			`s2aum1(05 downto 00) <= s2psh(23 downto 18);`
175	111	jguarin200	`when others =>`
176			`s2aum1 <= (others => '0');`
177			`end case;`
178			`s2asign <= (s2bgta and s2signa) or (not(s2bgta) and s2signb);`
179	114	jguarin200	`--! Exponente normalizado`
180			`s2aexp <= s2exp;`
181			`--! Uno de los sumandos es 0.`
182			`s2azero <= (not(s2signb)) or (not(s2signa));`
183	109	jguarin200
184	114	jguarin200
185			`--! Etapa 2a signar la mantissa corrida y sumarlas con la no corrida`
186			`s3sm <= s2asm;`
187			`s3exp <= s2aexp;`
188
189
190			`--! Etapa 3 quitar el signo a la mantissa.`
191			`s3asign <= s3sign;`
192			`s3aum <= s3um;`
193			`s3aexp <= s3exp;`
194
195
196			`--! Eatapa 3a calcular el factor de corrimiento para la normalizacion y el delta del exponente.`
197			`s4sign <= s3asign;`
198			`s4exp <= s3aexp;`
199			`s4shift<= s3ashift;`
200			`s4factorhot <= s3afactorhot;`
201			`s4um <= s3aum;`
202
203			`--! Etapa 4 Normalizar la mantissa resultado y renormalizar el exponente. Entregar el resultado!`
204			`c32(31) <= s4sign;`
205			`c32(30 downto 23) <= s4exp-s4shift;`
206			`case s4shift(4 downto 3) is`
207			`when "01" => c32(22 downto 0) <= x"00"&s4postshift(22 downto 8);`
208			`when "10" => c32(22 downto 0) <= x"0000"&s4postshift(22 downto 16);`
209			`when others => c32(22 downto 0) <= s4postshift(22 downto 0);`
210			`end case;`
211
212	109	jguarin200	`end if;`
213	108	jguarin200	`end process;`
214
215	111	jguarin200	`--! ******************************************************************************************************************************`
216	108	jguarin200
217	109	jguarin200	`--! Etapa 1`
218	107	jguarin200	`--! Decodificar la magnitud del corrimiento`
219	114	jguarin200	`decodermag:`
220			`process (s1udelta(7), s1udelta(4 downto 0))`
221			`begin`
222			`s1xorslab <= (others => s1sdelta(7));`
223			`s1udelta <= (s1sdelta(4 downto 0) xor s1xorslab)+(x"0"&s1sdelta(7));`
224			`end process;`
225
226	107	jguarin200	`--! Decodificar el factor de corrimiento`
227	108	jguarin200	`denormfactor:`
228	114	jguarin200	`process (s1udelta(2 downto 0),s1sdelta(7))`
229	107	jguarin200	`begin`
230	111	jguarin200	`s1factor(8 downto 0) <= (others => s1sdelta(7));`
231	109	jguarin200	`case s1udelta(2 downto 0) is`
232	114	jguarin200	`when "000" => s1factor(8 downto 0) <= "100000000";`
233			`when "001" => s1factor(8 downto 0) <= "010000000";`
234			`when "010" => s1factor(8 downto 0) <= "001000000";`
235			`when "011" => s1factor(8 downto 0) <= "000100000";`
236			`when "100" => s1factor(8 downto 0) <= "000010000";`
237			`when "101" => s1factor(8 downto 0) <= "000001000";`
238			`when "110" => s1factor(8 downto 0) <= "000000100";`
239			`when others => s1factor(8 downto 0) <= "000000010";`
240	106	jguarin200	`end case;`
241	111	jguarin200	`end process;`
242			`--! ******************************************************************************************************************************`
243	109	jguarin200	`--! Etapa2`
244	111	jguarin200	`--! Correr las mantissas`
245	108	jguarin200	`denomrselectmantissa2shift:`
246	114	jguarin200	`process (s2bgta,s2signa,s2signb,s2uma,s2umb)`
247	106	jguarin200	`begin`
248	111	jguarin200
249	109	jguarin200	`case s2bgta is`
250	107	jguarin200	`when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto`
251	111	jguarin200	`s2um0 <= s2umb;`
252	114	jguarin200	`s2xorslab <= (others => s2signb);`
253
254	111	jguarin200	`s2smshift <= s2uma;`
255	114	jguarin200
256	107	jguarin200	`when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto`
257	111	jguarin200	`s2um0 <= s2uma;`
258			`s2xorslab <= (others => s2signa);`
259	114	jguarin200
260			`s2smshift <= s2umb;`
261
262	107	jguarin200	`end case;`
263	111	jguarin200	`end process;`
264	109	jguarin200
265	107	jguarin200
266			`--! Correr las mantissas y calcularlas.`
267	114	jguarin200	`hshiftdenorm: lpm_mult`
268	111	jguarin200	`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,18,27)`
269	114	jguarin200	`port map (s2factor,'1'&s2smshift(22 downto 06),s2psh);`
270			`lshiftdenorm: lpm_mult`
271	111	jguarin200	`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,9,18)`
272	114	jguarin200	`port map (s2factor,s2smshift(05 downto 00)&"000",s2psl);`
273	107	jguarin200
274
275	111	jguarin200	`--! ******************************************************************************************************************************`
276			`--! Etapa2a signar las mantissas y sumarlas.`
277			`signmantissa:`
278			`process(s2asign,s2aum1,s2asm0,s2azero)`
279			`begin`
280			`s2axorslab <= (others => s2asign);`
281	114	jguarin200	`s2asm1 <= (s2axorslab(23)&(s2aum1 xor (s2axorslab)))+(x"000000"&s2axorslab(23));`
282	111	jguarin200	`case s2azero is`
283			`when '0' => s2asm <= (s2asm1(s2asm1'high)&s2asm1) + (s2asm0(s2asm0'high)&s2asm0);`
284			`when others => s2asm <= (s2asm1(s2asm1'high)&s2asm1) or (s2asm0(s2asm0'high)&s2asm0);`
285	107	jguarin200	`end case;`
286	111	jguarin200	`end process;`
287	107	jguarin200
288	112	jguarin200	`--! ******************************************************************************************************************************`
289	114	jguarin200	`--! Etapa3 : Quitar el signo a las mantissa.`
290			`--! ******************************************************************************************************************************`
291	108	jguarin200	`unsignmantissa:`
292	111	jguarin200	`process(s3sm)`
293	108	jguarin200	`begin`
294	111	jguarin200	`s3xorslab <= ( others => s3sm(s3sm'high) );`
295			`s3um(24 downto 0) <= ( s3sm(24 downto 0) xor s3xorslab ) + (x"000000"&s3xorslab(24));`
296			`s3sign <= s3sm(s3sm'high);`
297	114	jguarin200	`end process;`
298			`--! ******************************************************************************************************************************`
299			`--! Etapa3a : Decodificar el factor de corrimiento y calcular el exponente normalizado.`
300			`--! ******************************************************************************************************************************`
301			`redentioform:`
302			`process(s3aum,s3asign)`
303			`begin`
304			`s3ashift <= s3aexp;`
305			`s3afactorhot <= (others => '0');`
306			`for i in 24 downto 0 loop`
307			`if s3aum(i)='1' then`
308			`s3ashift <= conv_std_logic_vector(24-i,8)+x"ff";`
309			`s3afactorhot(24-i) <= '1';`
310	111	jguarin200	`exit;`
311			`end if;`
312	108	jguarin200	`end loop;`
313	112	jguarin200	`end process;`
314	113	jguarin200	`--! ******************************************************************************************************************************`
315	114	jguarin200	`--! Etapa4 : Normalizar la mantissa y calcular el exponente. Entregar el resultado`
316	113	jguarin200	`--! ******************************************************************************************************************************`
317	114	jguarin200	`--!Normalizacion mediante multiplicacion`
318			`process (s4ph,s4pl,s4factorhot,s4um)`
319			`begin`
320			`s4postshift(22 downto 15) <= s4ph(16 downto 9);`
321			`s4postshift(14 downto 06) <= s4ph(08 downto 0) or s4pl(17 downto 9);`
322			`s4postshift(05 downto 00) <= s4pl(08 downto 3);`
323			`case s4shift(4 downto 3) is`
324			`when "00" =>`
325			`s4factorhot9 <= s4factorhot(08 downto 01)&'0';`
326			`when "01" =>`
327			`s4factorhot9 <= s4factorhot(16 downto 09)&'0';`
328			`when "10" =>`
329			`s4factorhot9 <= s4factorhot(24 downto 17)&'0';`
330			`when others =>`
331			`s4factorhot9 <= s4factorhot(08 downto 00);`
332	113	jguarin200	`end case;`
333			`end process;`
334	114	jguarin200	`hshiftnorm: lpm_mult`
335	113	jguarin200	`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,18,27)`
336	114	jguarin200	`port map (s4factorhot9,s4um(24 downto 07),s4ph);`
337			`lshiftnorm: lpm_mult`
338	113	jguarin200	`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,9,18)`
339	114	jguarin200	`port map (s4factorhot9,s4um(06 downto 00)&"00",s4pl);`
340
341	111	jguarin200
342	114	jguarin200
343	111	jguarin200
344
345	106	jguarin200
346
347	110	jguarin200
348	107	jguarin200
349	106	jguarin200
350
351	108	jguarin200	`end fadd32_arch;`
352	106	jguarin200
353
354
355
356
357
358
359	108	jguarin200

Browse

Tools

Subversion Repositories raytrac

[/] [raytrac/] [trunk/] [fpbranch/] [unrm/] [shftr.vhd] - Blame information for rev 114