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

Subversion Repositories raytrac

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

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;
 
 
 
entity fadd32 is
        port (
                a32,b32: in std_logic_vector(31 downto 0);
                dpc: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 sdelta,expunrm,expnrm: std_logic_vector(7 downto 0);
        signal pha,phb : std_logic_vector(26 downto 0);
        signal sfactora,sfactorb,sfactor : std_logic_vector(8 downto 0);
        signal sma,smb,ssma,ssmb,usm,uxm: std_logic_vector(24 downto 0);
        signal ssm: std_logic_vector(25 downto 0);
 
        signal slaba,slabb : std_logic_vector(14 downto 0);
        signal shiftslab : std_logic_vector(23 downto 0);
        signal xplaces,s1udelta : std_logic_vector (4 downto 0);
        signal sign : std_logic;
 
 
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
                                s1zero='1';
                                s1sdelta <= x"00";
                        else
                                s1zero='0';
                                s1sdelta <= s0ea-s0eb;
                        end if;
                        --! Buffers
                        s1uma           <=      s0uma;
                        s1umb           <=      s0umb;
 
 
                        --! Etapa 1
                        --! Manejo de exponente, previo a la denormalizacion
                        --! Calulo del Factor de corrimiento 
                        s2expunrm       <= 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);
                        s2zero                  <= s1zero;
 
 
                        --! Etapa 2 Realizar los corrimientos, denormalizacion parcial
                        s3sma                   <= s2pha(24 downto 0) + (s2slaba&s2pla(17 downto 8));
                        s3smb                   <= s2phb(24 downto 0) + (s2slabb&s2plb(17 downto 8));
                        s3expnurm       <= s2expnurm;
                        s3zero                  <= s2zero;
                        s3bgta          <= s2bgta;
                        s3udelta                <= s2udelta;
 
                        --! Etapa 3, finalizar la denormalizacion y realizar la suma
                        s4ssm                   <= s3ssm;
                        s4expnurm       <= s3expnurm;
 
 
 
 
 
                end if;
 
        end process;
 
 
        --! Etapa 1
        --! Decodificar la magnitud del corrimiento
        denormshiftmagnitude:
        process (s1sdelta(7),s1sdelta(4 downto 0),s1signa,s1signb)
        begin
                for i in 4 downto 0 loop
                        s1xdelta(i) <= s1sdelta(i) xor s1sdelta(7);
                end loop;
                s1udelta  <= s1xdelta+("0000"&s1sdelta(7));
                if s1sdelta(7) = '1' then
                        s1shiftslab     <=      (others=> s1signa);--!b>a
                else
                        s1shiftslab     <=      (others=> s1signb);--!a>=b
                end if;
        end process;
        --! Decodificar el factor de corrimiento
        denormfactor:
        process (s1shiftslab,s1udelta)
        begin
                case s1udelta(2 downto 0) is
                        when x"0" => s1factor(8 downto 0) <= s1shiftslab(0 downto 0) & "10000000";
                        when x"1" => s1factor(8 downto 0) <= s1shiftslab(1 downto 0) & "1000000";
                        when x"2" => s1factor(8 downto 0) <= s1shiftslab(2 downto 0) & "100000";
                        when x"3" => s1factor(8 downto 0) <= s1shiftslab(3 downto 0) & "10000";
                        when x"4" => s1factor(8 downto 0) <= s1shiftslab(4 downto 0) & "1000";
                        when x"5" => s1factor(8 downto 0) <= s1shiftslab(5 downto 0) & "100";
                        when x"6" => s1factor(8 downto 0) <= s1shiftslab(6 downto 0) & "10";
                        when others => s1factor(8 downto 0) <=s1shiftslab(7 downto 0) &"1";
                end case;
        end process;
 
        --! Etapa2
        --! Asignar el factor de corrimiento  las mantissas
        denomrselectmantissa2shift:
        process (s2bgta,s2signa,s2signb,s2factor)
        begin
                case s2bgta is
                        when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto
                                s2factorb <= s2signb&"10000000";
                                s2factora <= s2factor;
                        when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto
                                s2factorb <= s2factor;
                                s2factora <= s2signa&"10000000";
                end case;
 
        end process;
 
 
 
        --! Correr las mantissas y calcularlas.
        hmulta: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,18,27)
        port    map (s2factora,s2signa&'1'&s2data24a(22 downto 0),s2pha);
        lmulta: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,9,27)
        port    map (s2factora,s2signa&'1'&s2dataa(6 downto 0),s2pla);
        hmultb: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,18,27)
        port    map (s2factorb,s2signb&'1'&s2datab(22 downto 0),s2phb);
        lmultb: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,9,27)
        port    map (s2factorb,s2signb&'1'&s2datab(6 downto 0),s2plb);
        mantissadenormslabcalc:
        process(s2signa,s2signb)
        begin
                s2slaba <= (others => s2signa);
                s2slabb <= (others => s2signb);
        end process;
 
        --! Sumar las mantissas signadas y colocar los 0's que hagan falta 
        mantissaadding:
        process (s3bgta,s3sma,s3smb,s3udelta,zero)
        begin
 
                case s3bgta is
                        when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto 
                                s3ssmb <= s3smb;
                                s3shiftslab(23 downto 0)<=(others=>s3sma(24));
                                case s3udelta is
                                        when x"3" => s3ssma <= (s3sma(24)&s3shiftslab(23 downto 0));
                                        when x"2" => s3ssma <= (s3sma(24)&s3shiftslab(15 downto 0)&s3sma(23 downto 16));
                                        when x"1" => s3ssma <= (s3sma(24)&s3shiftslab(7 downto 0)&s3sma(23 downto 8));
                                        when others => s3ssma <= s3sma;
                                end case;
                        when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto
                                s3ssma <= s3sma;
                                shiftslab(23 downto 0)<=(others=>s3smb(24));
                                case s3udelta is
                                        when x"3" => s3ssmb <= (s3smb(24)&s3shiftslab(23 downto 0));
                                        when x"2" => s3ssmb <= (s3smb(24)&s3shiftslab(15 downto 0)&s3smb(23 downto 16));
                                        when x"1" => s3ssmb <= (s3smb(24)&s3shiftslab(7 downto 0)&s3smb(23 downto 8));
                                        when others => s3ssmb <= s3smb;
                                end case;
                end case;
                if s3zero='0' then
                        s3ssm <= (s3ssma(24)&s3ssma)+(s3ssmb(24)&s3ssmb);
                else
                        s3ssm <= (s3ssma(24)&s3ssma)or(s3ssmb(24)&s3ssmb);
                end if;
        end process;
 
        --! Mantissas sumadas, designar
        unsignmantissa:
        process(s4ssm)
        begin
                for i in 24 downto 0 loop
                        s4usm(i) <= s4ssm(25) xor s4ssm(i);
                end loop;
                s4sign <=s4ssm(25);
                s4uxm <= s4usm+(x"000000"&s4ssm(25));
        end process;
 
        --!Normalizar el  exponente y calcular el factor de corrimiento para la normalizaci&oacute;n de la mantissa
        process (s4uxm,expunrm)
                variable xshift : integer range 24 downto 0;
        begin
                for i in 24 downto 0 loop
                        if s4uxm(i)='1' then
                                xshift:=24-i;
                        end of;
                end loop;
                s4expnrm <= s4expunrm-((  "000"&conv_std_logic_vector(xshift,5) )+x"ff");
        end process;
 
        normantissafactor:
        process (s4expnrm)
        begin
                s4factor(0)<=s4expnrm(7);
                case s4expnrm(7) is
                        when '1' => s4factor(8 downto 1)<=(others=>'0');
                        when others =>
                                case s4expnrm(3 downto 1) is
                                        when "000" => s4factor(8 downto 1)<="'00000001";
                                        when "001" => s4factor(8 downto 1)<="'00000010";
                                        when "010" => s4factor(8 downto 1)<="'00000100";
                                        when "011" => s4factor(8 downto 1)<="'00001000";
                                        when "100" => s4factor(8 downto 1)<="'00010000";
                                        when "101" => s4factor(8 downto 1)<="'00100000";
                                        when "110" => s4factor(8 downto 1)<="'01000000";
                                        when others  => s4factor(8 downto 1)<="'10000000";
                                end case;
                end case;
        end process;
 
 
 
 
end fadd32_arch;
 
 
 
 
 
 
 
 

Line No.	Rev	Author	Line
1	106	jguarin200	`library ieee;`
2			`use ieee.std_logic_1164.all;`
3	108	jguarin200	`use ieee.std_logic_unsigned.all;`
4	106	jguarin200
5
6
7	108	jguarin200	`entity fadd32 is`
8	106	jguarin200	`port (`
9	108	jguarin200	`a32,b32: in std_logic_vector(31 downto 0);`
10			`dpc:in std_logic;`
11			`c32:out std_logic_vector(31 downto 0);`
12	106	jguarin200	`);`
13	108	jguarin200	`end fadd32;`
14	106	jguarin200
15
16	108	jguarin200	`architecture fadd32_arch of fadd32 is`
17	106	jguarin200
18			`component lpm_mult`
19			`generic (`
20			`lpm_hint : string;`
21			`lpm_representation : string;`
22			`lpm_type : string;`
23			`lpm_widtha : natural;`
24			`lpm_widthb : natural;`
25			`lpm_widthp : natural`
26			`);`
27			`port (`
28			`dataa : in std_logic_vector ( lpm_widtha-1 downto 0 );`
29			`datab : in std_logic_vector ( lpm_widthb-1 downto 0 );`
30			`result : out std_logic_vector( lpm_widthp-1 downto 0 )`
31			`);`
32			`end component;`
33	108	jguarin200	`signal sdelta,expunrm,expnrm: std_logic_vector(7 downto 0);`
34	107	jguarin200	`signal pha,phb : std_logic_vector(26 downto 0);`
35			`signal sfactora,sfactorb,sfactor : std_logic_vector(8 downto 0);`
36	108	jguarin200	`signal sma,smb,ssma,ssmb,usm,uxm: std_logic_vector(24 downto 0);`
37			`signal ssm: std_logic_vector(25 downto 0);`
38
39	107	jguarin200	`signal slaba,slabb : std_logic_vector(14 downto 0);`
40			`signal shiftslab : std_logic_vector(23 downto 0);`
41	109	jguarin200	`signal xplaces,s1udelta : std_logic_vector (4 downto 0);`
42	108	jguarin200	`signal sign : std_logic;`
43
44	106	jguarin200
45			`begin`
46	109	jguarin200	`--! Pipeline`
47			`pipeline:`
48			`process(clk)`
49	108	jguarin200	`begin`
50	109	jguarin200
51			`if clk='1' and clk'event then`
52	108	jguarin200
53	109	jguarin200	`--! Registro de entrada`
54	108	jguarin200
55	109	jguarin200	`s0ea <= a32(30 downto 23);`
56			`s0uma <= a32(22 downto 0);`
57			`s0signa <= a32(31);`
58			`s0eb <= b32(30 downto 23);`
59			`s0umb <= b32(22 downto 0);`
60			`s0signb <= a32(31) xor dpc;`
61
62			`--! Etapa 0`
63			`--! I3E754ZERO y calculo del delta entre exponentes`
64			`if s0ea="00" then`
65			`s1signa <= '0';`
66			`else`
67			`s1signa <= s0signa;`
68			`end if;`
69			`if s0eb="00" then`
70			`s1signb <= '0';`
71			`s1expunrm <= s0ea;`
72			`else`
73			`s1signb <= s0signb;`
74			`s1expunrm <= s0eb;`
75			`end if;`
76			`if s0ea=x"00" or s0eb=x"00" then`
77			`s1zero='1';`
78			`s1sdelta <= x"00";`
79			`else`
80			`s1zero='0';`
81			`s1sdelta <= s0ea-s0eb;`
82			`end if;`
83			`--! Buffers`
84			`s1uma <= s0uma;`
85			`s1umb <= s0umb;`
86	108	jguarin200
87	109	jguarin200
88			`--! Etapa 1`
89			`--! Manejo de exponente, previo a la denormalizacion`
90			`--! Calulo del Factor de corrimiento`
91			`s2expunrm <= s1expunrm+s1sdelta;`
92			`s2factor <= s1factor;`
93
94			`--! Otras señales de soporte`
95			`s2signa <= s1signa;`
96			`s2signb <= s1signb;`
97			`s2bgta <= s1sdelta(7);`
98			`s2uma <= s1uma;`
99			`s2umb <= s1umb;`
100			`s2udelta <= s1udelta(4 downto 3);`
101			`s2zero <= s1zero;`
102
103
104			`--! Etapa 2 Realizar los corrimientos, denormalizacion parcial`
105			`s3sma <= s2pha(24 downto 0) + (s2slaba&s2pla(17 downto 8));`
106			`s3smb <= s2phb(24 downto 0) + (s2slabb&s2plb(17 downto 8));`
107			`s3expnurm <= s2expnurm;`
108			`s3zero <= s2zero;`
109			`s3bgta <= s2bgta;`
110			`s3udelta <= s2udelta;`
111
112			`--! Etapa 3, finalizar la denormalizacion y realizar la suma`
113			`s4ssm <= s3ssm;`
114			`s4expnurm <= s3expnurm;`
115
116	110	jguarin200
117	109	jguarin200
118
119
120			`end if;`
121
122	108	jguarin200	`end process;`
123
124
125	109	jguarin200	`--! Etapa 1`
126	107	jguarin200	`--! Decodificar la magnitud del corrimiento`
127	108	jguarin200	`denormshiftmagnitude:`
128	109	jguarin200	`process (s1sdelta(7),s1sdelta(4 downto 0),s1signa,s1signb)`
129	106	jguarin200	`begin`
130	107	jguarin200	`for i in 4 downto 0 loop`
131	109	jguarin200	`s1xdelta(i) <= s1sdelta(i) xor s1sdelta(7);`
132	107	jguarin200	`end loop;`
133	109	jguarin200	`s1udelta <= s1xdelta+("0000"&s1sdelta(7));`
134			`if s1sdelta(7) = '1' then`
135			`s1shiftslab <= (others=> s1signa);--!b>a`
136	108	jguarin200	`else`
137	109	jguarin200	`s1shiftslab <= (others=> s1signb);--!a>=b`
138	107	jguarin200	`end if;`
139			`end process;`
140			`--! Decodificar el factor de corrimiento`
141	108	jguarin200	`denormfactor:`
142	109	jguarin200	`process (s1shiftslab,s1udelta)`
143	107	jguarin200	`begin`
144	109	jguarin200	`case s1udelta(2 downto 0) is`
145			`when x"0" => s1factor(8 downto 0) <= s1shiftslab(0 downto 0) & "10000000";`
146			`when x"1" => s1factor(8 downto 0) <= s1shiftslab(1 downto 0) & "1000000";`
147			`when x"2" => s1factor(8 downto 0) <= s1shiftslab(2 downto 0) & "100000";`
148			`when x"3" => s1factor(8 downto 0) <= s1shiftslab(3 downto 0) & "10000";`
149			`when x"4" => s1factor(8 downto 0) <= s1shiftslab(4 downto 0) & "1000";`
150			`when x"5" => s1factor(8 downto 0) <= s1shiftslab(5 downto 0) & "100";`
151			`when x"6" => s1factor(8 downto 0) <= s1shiftslab(6 downto 0) & "10";`
152			`when others => s1factor(8 downto 0) <=s1shiftslab(7 downto 0) &"1";`
153	106	jguarin200	`end case;`
154			`end process;`
155	109	jguarin200
156			`--! Etapa2`
157	107	jguarin200	`--! Asignar el factor de corrimiento las mantissas`
158	108	jguarin200	`denomrselectmantissa2shift:`
159	109	jguarin200	`process (s2bgta,s2signa,s2signb,s2factor)`
160	106	jguarin200	`begin`
161	109	jguarin200	`case s2bgta is`
162	107	jguarin200	`when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto`
163	109	jguarin200	`s2factorb <= s2signb&"10000000";`
164			`s2factora <= s2factor;`
165	107	jguarin200	`when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto`
166	109	jguarin200	`s2factorb <= s2factor;`
167			`s2factora <= s2signa&"10000000";`
168	107	jguarin200	`end case;`
169	109	jguarin200
170	108	jguarin200	`end process;`
171	107	jguarin200
172
173
174			`--! Correr las mantissas y calcularlas.`
175			`hmulta: lpm_mult`
176			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,18,27)`
177	109	jguarin200	`port map (s2factora,s2signa&'1'&s2data24a(22 downto 0),s2pha);`
178	107	jguarin200	`lmulta: lpm_mult`
179			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,9,27)`
180	109	jguarin200	`port map (s2factora,s2signa&'1'&s2dataa(6 downto 0),s2pla);`
181	107	jguarin200	`hmultb: lpm_mult`
182			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,18,27)`
183	109	jguarin200	`port map (s2factorb,s2signb&'1'&s2datab(22 downto 0),s2phb);`
184	107	jguarin200	`lmultb: lpm_mult`
185			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,9,27)`
186	109	jguarin200	`port map (s2factorb,s2signb&'1'&s2datab(6 downto 0),s2plb);`
187			`mantissadenormslabcalc:`
188			`process(s2signa,s2signb)`
189	108	jguarin200	`begin`
190	109	jguarin200	`s2slaba <= (others => s2signa);`
191			`s2slabb <= (others => s2signb);`
192	108	jguarin200	`end process;`
193	107	jguarin200
194			`--! Sumar las mantissas signadas y colocar los 0's que hagan falta`
195	108	jguarin200	`mantissaadding:`
196	109	jguarin200	`process (s3bgta,s3sma,s3smb,s3udelta,zero)`
197	107	jguarin200	`begin`
198
199	109	jguarin200	`case s3bgta is`
200	107	jguarin200	`when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto`
201	109	jguarin200	`s3ssmb <= s3smb;`
202	110	jguarin200	`s3shiftslab(23 downto 0)<=(others=>s3sma(24));`
203	109	jguarin200	`case s3udelta is`
204	110	jguarin200	`when x"3" => s3ssma <= (s3sma(24)&s3shiftslab(23 downto 0));`
205			`when x"2" => s3ssma <= (s3sma(24)&s3shiftslab(15 downto 0)&s3sma(23 downto 16));`
206			`when x"1" => s3ssma <= (s3sma(24)&s3shiftslab(7 downto 0)&s3sma(23 downto 8));`
207	109	jguarin200	`when others => s3ssma <= s3sma;`
208	107	jguarin200	`end case;`
209			`when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto`
210	109	jguarin200	`s3ssma <= s3sma;`
211			`shiftslab(23 downto 0)<=(others=>s3smb(24));`
212			`case s3udelta is`
213	110	jguarin200	`when x"3" => s3ssmb <= (s3smb(24)&s3shiftslab(23 downto 0));`
214			`when x"2" => s3ssmb <= (s3smb(24)&s3shiftslab(15 downto 0)&s3smb(23 downto 16));`
215			`when x"1" => s3ssmb <= (s3smb(24)&s3shiftslab(7 downto 0)&s3smb(23 downto 8));`
216	109	jguarin200	`when others => s3ssmb <= s3smb;`
217	107	jguarin200	`end case;`
218			`end case;`
219	109	jguarin200	`if s3zero='0' then`
220			`s3ssm <= (s3ssma(24)&s3ssma)+(s3ssmb(24)&s3ssmb);`
221	108	jguarin200	`else`
222	109	jguarin200	`s3ssm <= (s3ssma(24)&s3ssma)or(s3ssmb(24)&s3ssmb);`
223	108	jguarin200	`end if;`
224			`end process;`
225	107	jguarin200
226	108	jguarin200	`--! Mantissas sumadas, designar`
227			`unsignmantissa:`
228	109	jguarin200	`process(s4ssm)`
229	108	jguarin200	`begin`
230			`for i in 24 downto 0 loop`
231	109	jguarin200	`s4usm(i) <= s4ssm(25) xor s4ssm(i);`
232	108	jguarin200	`end loop;`
233	109	jguarin200	`s4sign <=s4ssm(25);`
234			`s4uxm <= s4usm+(x"000000"&s4ssm(25));`
235	106	jguarin200	`end process;`
236
237	109	jguarin200	`--!Normalizar el exponente y calcular el factor de corrimiento para la normalización de la mantissa`
238			`process (s4uxm,expunrm)`
239	108	jguarin200	`variable xshift : integer range 24 downto 0;`
240			`begin`
241			`for i in 24 downto 0 loop`
242	109	jguarin200	`if s4uxm(i)='1' then`
243	108	jguarin200	`xshift:=24-i;`
244			`end of;`
245			`end loop;`
246	109	jguarin200	`s4expnrm <= s4expunrm-(( "000"&conv_std_logic_vector(xshift,5) )+x"ff");`
247	108	jguarin200	`end process;`
248	106	jguarin200
249	109	jguarin200	`normantissafactor:`
250			`process (s4expnrm)`
251			`begin`
252			`s4factor(0)<=s4expnrm(7);`
253			`case s4expnrm(7) is`
254			`when '1' => s4factor(8 downto 1)<=(others=>'0');`
255			`when others =>`
256			`case s4expnrm(3 downto 1) is`
257			`when "000" => s4factor(8 downto 1)<="'00000001";`
258			`when "001" => s4factor(8 downto 1)<="'00000010";`
259			`when "010" => s4factor(8 downto 1)<="'00000100";`
260			`when "011" => s4factor(8 downto 1)<="'00001000";`
261			`when "100" => s4factor(8 downto 1)<="'00010000";`
262			`when "101" => s4factor(8 downto 1)<="'00100000";`
263			`when "110" => s4factor(8 downto 1)<="'01000000";`
264			`when others => s4factor(8 downto 1)<="'10000000";`
265			`end case;`
266			`end case;`
267			`end process;`
268	110	jguarin200
269	107	jguarin200
270	106	jguarin200
271
272	108	jguarin200	`end fadd32_arch;`
273	106	jguarin200
274
275
276
277
278
279
280	108	jguarin200

Browse

Tools

Subversion Repositories raytrac

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