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

Subversion Repositories raytrac

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

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;
                                shiftslab(23 downto 0)<=(others=>s3sma(24));
                                case s3udelta is
                                        when x"3" => s3ssma <= (s3sma(24)&shiftslab(23 downto 0));
                                        when x"2" => s3ssma <= (s3sma(24)&shiftslab(15 downto 0)&s3sma(23 downto 16));
                                        when x"1" => s3ssma <= (s3sma(24)&shiftslab(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)&shiftslab(23 downto 0));
                                        when x"2" => s3ssmb <= (s3smb(24)&shiftslab(15 downto 0)&s3smb(23 downto 16));
                                        when x"1" => s3ssmb <= (s3smb(24)&shiftslab(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
117
118
119			`end if;`
120
121	108	jguarin200	`end process;`
122
123
124	109	jguarin200	`--! Etapa 1`
125	107	jguarin200	`--! Decodificar la magnitud del corrimiento`
126	108	jguarin200	`denormshiftmagnitude:`
127	109	jguarin200	`process (s1sdelta(7),s1sdelta(4 downto 0),s1signa,s1signb)`
128	106	jguarin200	`begin`
129	107	jguarin200	`for i in 4 downto 0 loop`
130	109	jguarin200	`s1xdelta(i) <= s1sdelta(i) xor s1sdelta(7);`
131	107	jguarin200	`end loop;`
132	109	jguarin200	`s1udelta <= s1xdelta+("0000"&s1sdelta(7));`
133			`if s1sdelta(7) = '1' then`
134			`s1shiftslab <= (others=> s1signa);--!b>a`
135	108	jguarin200	`else`
136	109	jguarin200	`s1shiftslab <= (others=> s1signb);--!a>=b`
137	107	jguarin200	`end if;`
138			`end process;`
139			`--! Decodificar el factor de corrimiento`
140	108	jguarin200	`denormfactor:`
141	109	jguarin200	`process (s1shiftslab,s1udelta)`
142	107	jguarin200	`begin`
143	109	jguarin200	`case s1udelta(2 downto 0) is`
144			`when x"0" => s1factor(8 downto 0) <= s1shiftslab(0 downto 0) & "10000000";`
145			`when x"1" => s1factor(8 downto 0) <= s1shiftslab(1 downto 0) & "1000000";`
146			`when x"2" => s1factor(8 downto 0) <= s1shiftslab(2 downto 0) & "100000";`
147			`when x"3" => s1factor(8 downto 0) <= s1shiftslab(3 downto 0) & "10000";`
148			`when x"4" => s1factor(8 downto 0) <= s1shiftslab(4 downto 0) & "1000";`
149			`when x"5" => s1factor(8 downto 0) <= s1shiftslab(5 downto 0) & "100";`
150			`when x"6" => s1factor(8 downto 0) <= s1shiftslab(6 downto 0) & "10";`
151			`when others => s1factor(8 downto 0) <=s1shiftslab(7 downto 0) &"1";`
152	106	jguarin200	`end case;`
153			`end process;`
154	109	jguarin200
155			`--! Etapa2`
156	107	jguarin200	`--! Asignar el factor de corrimiento las mantissas`
157	108	jguarin200	`denomrselectmantissa2shift:`
158	109	jguarin200	`process (s2bgta,s2signa,s2signb,s2factor)`
159	106	jguarin200	`begin`
160	109	jguarin200	`case s2bgta is`
161	107	jguarin200	`when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto`
162	109	jguarin200	`s2factorb <= s2signb&"10000000";`
163			`s2factora <= s2factor;`
164	107	jguarin200	`when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto`
165	109	jguarin200	`s2factorb <= s2factor;`
166			`s2factora <= s2signa&"10000000";`
167	107	jguarin200	`end case;`
168	109	jguarin200
169	108	jguarin200	`end process;`
170	107	jguarin200
171
172
173			`--! Correr las mantissas y calcularlas.`
174			`hmulta: lpm_mult`
175			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,18,27)`
176	109	jguarin200	`port map (s2factora,s2signa&'1'&s2data24a(22 downto 0),s2pha);`
177	107	jguarin200	`lmulta: lpm_mult`
178			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,9,27)`
179	109	jguarin200	`port map (s2factora,s2signa&'1'&s2dataa(6 downto 0),s2pla);`
180	107	jguarin200	`hmultb: lpm_mult`
181			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,18,27)`
182	109	jguarin200	`port map (s2factorb,s2signb&'1'&s2datab(22 downto 0),s2phb);`
183	107	jguarin200	`lmultb: lpm_mult`
184			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,9,27)`
185	109	jguarin200	`port map (s2factorb,s2signb&'1'&s2datab(6 downto 0),s2plb);`
186			`mantissadenormslabcalc:`
187			`process(s2signa,s2signb)`
188	108	jguarin200	`begin`
189	109	jguarin200	`s2slaba <= (others => s2signa);`
190			`s2slabb <= (others => s2signb);`
191	108	jguarin200	`end process;`
192	107	jguarin200
193			`--! Sumar las mantissas signadas y colocar los 0's que hagan falta`
194	108	jguarin200	`mantissaadding:`
195	109	jguarin200	`process (s3bgta,s3sma,s3smb,s3udelta,zero)`
196	107	jguarin200	`begin`
197
198	109	jguarin200	`case s3bgta is`
199	107	jguarin200	`when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto`
200	109	jguarin200	`s3ssmb <= s3smb;`
201			`shiftslab(23 downto 0)<=(others=>s3sma(24));`
202			`case s3udelta is`
203			`when x"3" => s3ssma <= (s3sma(24)&shiftslab(23 downto 0));`
204			`when x"2" => s3ssma <= (s3sma(24)&shiftslab(15 downto 0)&s3sma(23 downto 16));`
205			`when x"1" => s3ssma <= (s3sma(24)&shiftslab(7 downto 0)&s3sma(23 downto 8));`
206			`when others => s3ssma <= s3sma;`
207	107	jguarin200	`end case;`
208			`when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto`
209	109	jguarin200	`s3ssma <= s3sma;`
210			`shiftslab(23 downto 0)<=(others=>s3smb(24));`
211			`case s3udelta is`
212			`when x"3" => s3ssmb <= (s3smb(24)&shiftslab(23 downto 0));`
213			`when x"2" => s3ssmb <= (s3smb(24)&shiftslab(15 downto 0)&s3smb(23 downto 16));`
214			`when x"1" => s3ssmb <= (s3smb(24)&shiftslab(7 downto 0)&s3smb(23 downto 8));`
215			`when others => s3ssmb <= s3smb;`
216	107	jguarin200	`end case;`
217			`end case;`
218	109	jguarin200	`if s3zero='0' then`
219			`s3ssm <= (s3ssma(24)&s3ssma)+(s3ssmb(24)&s3ssmb);`
220	108	jguarin200	`else`
221	109	jguarin200	`s3ssm <= (s3ssma(24)&s3ssma)or(s3ssmb(24)&s3ssmb);`
222	108	jguarin200	`end if;`
223			`end process;`
224	107	jguarin200
225	108	jguarin200	`--! Mantissas sumadas, designar`
226			`unsignmantissa:`
227	109	jguarin200	`process(s4ssm)`
228	108	jguarin200	`begin`
229			`for i in 24 downto 0 loop`
230	109	jguarin200	`s4usm(i) <= s4ssm(25) xor s4ssm(i);`
231	108	jguarin200	`end loop;`
232	109	jguarin200	`s4sign <=s4ssm(25);`
233			`s4uxm <= s4usm+(x"000000"&s4ssm(25));`
234	106	jguarin200	`end process;`
235
236	109	jguarin200	`--!Normalizar el exponente y calcular el factor de corrimiento para la normalización de la mantissa`
237			`process (s4uxm,expunrm)`
238	108	jguarin200	`variable xshift : integer range 24 downto 0;`
239			`begin`
240			`for i in 24 downto 0 loop`
241	109	jguarin200	`if s4uxm(i)='1' then`
242	108	jguarin200	`xshift:=24-i;`
243			`end of;`
244			`end loop;`
245	109	jguarin200	`s4expnrm <= s4expunrm-(( "000"&conv_std_logic_vector(xshift,5) )+x"ff");`
246	108	jguarin200	`end process;`
247	106	jguarin200
248	109	jguarin200	`normantissafactor:`
249			`process (s4expnrm)`
250			`begin`
251			`s4factor(0)<=s4expnrm(7);`
252			`case s4expnrm(7) is`
253			`when '1' => s4factor(8 downto 1)<=(others=>'0');`
254			`when others =>`
255			`case s4expnrm(3 downto 1) is`
256			`when "000" => s4factor(8 downto 1)<="'00000001";`
257			`when "001" => s4factor(8 downto 1)<="'00000010";`
258			`when "010" => s4factor(8 downto 1)<="'00000100";`
259			`when "011" => s4factor(8 downto 1)<="'00001000";`
260			`when "100" => s4factor(8 downto 1)<="'00010000";`
261			`when "101" => s4factor(8 downto 1)<="'00100000";`
262			`when "110" => s4factor(8 downto 1)<="'01000000";`
263			`when others => s4factor(8 downto 1)<="'10000000";`
264			`end case;`
265			`end case;`
266			`end process;`
267	107	jguarin200
268	106	jguarin200
269
270	108	jguarin200	`end fadd32_arch;`
271	106	jguarin200
272
273
274
275
276
277
278	108	jguarin200

Browse

Tools

Subversion Repositories raytrac

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