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

Subversion Repositories raytrac

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

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
                        s2asm0          <= (s2xorslab(23)&(('1'&s2um0(22 downto 0))xor(s2xorslab)))+(x"000000"&s2xorslab(23));
                        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 17);
                                        s2aum1(05 downto 00)    <= s2sph(16 downto 11);
                                when "10" =>
                                        s2aum1(23 downto 06)    <= x"0000"&s2psh(25);
                                        s2aum1(05 downto 00)    <= s2sph(24 downto 19);
                                when others =>
                                        s2aum1                                  <= (others => '0');
                        end case;
                        s2asign         <= (s2bgta and s2signa) or (not(s2bgta) and s2signb);
 
 
                        end case;
                        s2aexpnurm      <= s2expnurm;
                        s2azero         <= s2zero;
                        s2abgta         <= s2bgta;
                        s2audelta       <= s2udelta;
                        --! 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
        unsigneddelta: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,9,27)
        port    map (s1sdelta(7)&x"80",s1sdelta(7)&s1sdelta,s1pudelta);
        s1udelta(4 downto 0) <= s1pudelta(11 downto 7);
        denormshiftmagnitude:
        --! Decodificar el factor de corrimiento
        denormfactor:
        process (s1shiftslab,s1udelta)
        begin
                s1factor(8 downto 0) <= (others => s1sdelta(7));
                case s1udelta(2 downto 0) is
                        when x"0" => s1factor(8 downto 0)         <= "100000000";
                        when x"1" => s1factor(8 downto 0)        <= "010000000";
                        when x"2" => s1factor(8 downto 0)        <= "001000000";
                        when x"3" => s1factor(8 downto 0)        <= "000100000";
                        when x"4" => s1factor(8 downto 0)        <= "000010000";
                        when x"5" => s1factor(8 downto 0)        <= "000001000";
                        when x"6" => s1factor(8 downto 0)        <= "000000100";
                        when others => s1factor(0)                       <= "000000010";
                end case;
        end process;
--! ******************************************************************************************************************************
        --! Etapa2
        --! Correr las mantissas
        denomrselectmantissa2shift:
        process (s2bgta,s2signa,s2signb,s2factor,s2sma,s2smb)
        begin
 
                case s2bgta is
                        when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto
                                s2factorshift   <= s2factor;
                                s2um0                   <= s2umb;
                                s2smshift               <= s2uma;
                                s2xorslab               <= (others => s2signb);
                        when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto
                                s2factorshift   <= s2factor;
                                s2smshift               <= s2umb;
                                s2um0                   <= s2uma;
                                s2xorslab               <= (others => s2signa);
                end case;
        end process;
 
 
        --! Correr las mantissas y calcularlas.
        hshift: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,18,27)
        port    map (s2factorshift,"01"&s2smshift(22 downto 0),s2psh);
        lshift: lpm_mult
        generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,9,18)
        port    map (s2factorshift,"0"&s2smshift(06 downto 0)&'0,s2psl);
 
 
--! ******************************************************************************************************************************
        --! Etapa2a signar las mantissas y sumarlas.
        signmantissa:
        process(s2asign,s2aum1,s2asm0,s2azero)
        begin
                s2axorslab      <= (others => s2asign);
                s2asm1          <= (s2axorslab(23)&((s2um1(23 downto 0))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;
 
 
        --! Mantissas sumadas, designar y normalizar
        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);
                s3factor <= x"000000"&'0';
                s3count  <= '1'&x"f";
                s3unrmexp <=
                for i in 24 downto 0 loop
                        if s3sm(i)='1' then
                                s3factor(24-i)<='1';
                                exit;
                        end if;
                        s3count<=s3count+1;
                end loop;
                s3nrmexpo<=s3unrmexpo+s3count;
        end process;
 
 
 
        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	111	jguarin200
47			`--! ******************************************************************************************************************************`
48	109	jguarin200	`--! Pipeline`
49			`pipeline:`
50			`process(clk)`
51	108	jguarin200	`begin`
52	109	jguarin200
53			`if clk='1' and clk'event then`
54	108	jguarin200
55	109	jguarin200	`--! Registro de entrada`
56	108	jguarin200
57	109	jguarin200	`s0ea <= a32(30 downto 23);`
58			`s0uma <= a32(22 downto 0);`
59			`s0signa <= a32(31);`
60			`s0eb <= b32(30 downto 23);`
61			`s0umb <= b32(22 downto 0);`
62			`s0signb <= a32(31) xor dpc;`
63
64			`--! Etapa 0`
65			`--! I3E754ZERO y calculo del delta entre exponentes`
66			`if s0ea="00" then`
67			`s1signa <= '0';`
68			`else`
69			`s1signa <= s0signa;`
70			`end if;`
71			`if s0eb="00" then`
72			`s1signb <= '0';`
73			`s1expunrm <= s0ea;`
74			`else`
75			`s1signb <= s0signb;`
76			`s1expunrm <= s0eb;`
77			`end if;`
78			`if s0ea=x"00" or s0eb=x"00" then`
79			`s1zero='1';`
80			`s1sdelta <= x"00";`
81			`else`
82			`s1zero='0';`
83			`s1sdelta <= s0ea-s0eb;`
84			`end if;`
85			`--! Buffers`
86			`s1uma <= s0uma;`
87			`s1umb <= s0umb;`
88	108	jguarin200
89	109	jguarin200
90			`--! Etapa 1`
91			`--! Manejo de exponente, previo a la denormalizacion`
92			`--! Calulo del Factor de corrimiento`
93			`s2expunrm <= s1expunrm+s1sdelta;`
94	111	jguarin200	`s2factor <= s1factor;`
95	109	jguarin200
96			`--! Otras señales de soporte`
97			`s2signa <= s1signa;`
98			`s2signb <= s1signb;`
99	111	jguarin200	`s2bgta <= s1sdelta(7);`
100			`s2uma <= s1uma;`
101			`s2umb <= s1umb;`
102			`s2udelta <= s1udelta(4 downto 3);`
103			`s2zero <= s1zero;`
104	109	jguarin200
105
106			`--! Etapa 2 Realizar los corrimientos, denormalizacion parcial`
107	111	jguarin200	`s2asm0 <= (s2xorslab(23)&(('1'&s2um0(22 downto 0))xor(s2xorslab)))+(x"000000"&s2xorslab(23));`
108			`case s2udelta is`
109			`when "00" =>`
110			`s2aum1(23 downto 06) <= s2psh(25 downto 08);`
111			`s2aum1(05 downto 00) <= s2psh(07 downto 02) or (s2psl(16 downto 11));`
112			`when "01" =>`
113			`s2aum1(23 downto 06) <= x"00"&s2psh(25 downto 17);`
114			`s2aum1(05 downto 00) <= s2sph(16 downto 11);`
115			`when "10" =>`
116			`s2aum1(23 downto 06) <= x"0000"&s2psh(25);`
117			`s2aum1(05 downto 00) <= s2sph(24 downto 19);`
118			`when others =>`
119			`s2aum1 <= (others => '0');`
120			`end case;`
121			`s2asign <= (s2bgta and s2signa) or (not(s2bgta) and s2signb);`
122
123
124			`end case;`
125			`s2aexpnurm <= s2expnurm;`
126			`s2azero <= s2zero;`
127			`s2abgta <= s2bgta;`
128			`s2audelta <= s2udelta;`
129			`--! Etapa 2 Realizar los corrimientos, denormalizacion parcial`
130			`s3sma <= s2pha(24 downto 0) + (s2slaba&s2pla(17 downto 8));`
131			`s3smb <= s2phb(24 downto 0) + (s2slabb&s2plb(17 downto 8));`
132	109	jguarin200	`s3expnurm <= s2expnurm;`
133	111	jguarin200	`s3zero <= s2zero;`
134	109	jguarin200	`s3bgta <= s2bgta;`
135	111	jguarin200	`s3udelta <= s2udelta;`
136	109	jguarin200
137			`--! Etapa 3, finalizar la denormalizacion y realizar la suma`
138	111	jguarin200	`s4ssm <= s3ssm;`
139	109	jguarin200	`s4expnurm <= s3expnurm;`
140			`end if;`
141	108	jguarin200	`end process;`
142
143	111	jguarin200	`--! ******************************************************************************************************************************`
144	108	jguarin200
145	109	jguarin200	`--! Etapa 1`
146	107	jguarin200	`--! Decodificar la magnitud del corrimiento`
147	111	jguarin200	`unsigneddelta: lpm_mult`
148			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","SIGNED","LPM_MULT",9,9,27)`
149			`port map (s1sdelta(7)&x"80",s1sdelta(7)&s1sdelta,s1pudelta);`
150			`s1udelta(4 downto 0) <= s1pudelta(11 downto 7);`
151	108	jguarin200	`denormshiftmagnitude:`
152	107	jguarin200	`--! Decodificar el factor de corrimiento`
153	108	jguarin200	`denormfactor:`
154	109	jguarin200	`process (s1shiftslab,s1udelta)`
155	107	jguarin200	`begin`
156	111	jguarin200	`s1factor(8 downto 0) <= (others => s1sdelta(7));`
157	109	jguarin200	`case s1udelta(2 downto 0) is`
158	111	jguarin200	`when x"0" => s1factor(8 downto 0) <= "100000000";`
159			`when x"1" => s1factor(8 downto 0) <= "010000000";`
160			`when x"2" => s1factor(8 downto 0) <= "001000000";`
161			`when x"3" => s1factor(8 downto 0) <= "000100000";`
162			`when x"4" => s1factor(8 downto 0) <= "000010000";`
163			`when x"5" => s1factor(8 downto 0) <= "000001000";`
164			`when x"6" => s1factor(8 downto 0) <= "000000100";`
165			`when others => s1factor(0) <= "000000010";`
166	106	jguarin200	`end case;`
167	111	jguarin200	`end process;`
168			`--! ******************************************************************************************************************************`
169	109	jguarin200	`--! Etapa2`
170	111	jguarin200	`--! Correr las mantissas`
171	108	jguarin200	`denomrselectmantissa2shift:`
172	111	jguarin200	`process (s2bgta,s2signa,s2signb,s2factor,s2sma,s2smb)`
173	106	jguarin200	`begin`
174	111	jguarin200
175	109	jguarin200	`case s2bgta is`
176	107	jguarin200	`when '1' => -- Negativo b>a : se corre a delta espacios a la derecha y b se queda quieto`
177	111	jguarin200	`s2factorshift <= s2factor;`
178			`s2um0 <= s2umb;`
179			`s2smshift <= s2uma;`
180			`s2xorslab <= (others => s2signb);`
181	107	jguarin200	`when others => -- Positivo a>=b : se corre a delta espacios a la derecha y a se queda quieto`
182	111	jguarin200	`s2factorshift <= s2factor;`
183			`s2smshift <= s2umb;`
184			`s2um0 <= s2uma;`
185			`s2xorslab <= (others => s2signa);`
186	107	jguarin200	`end case;`
187	111	jguarin200	`end process;`
188	109	jguarin200
189	107	jguarin200
190			`--! Correr las mantissas y calcularlas.`
191	111	jguarin200	`hshift: lpm_mult`
192			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,18,27)`
193			`port map (s2factorshift,"01"&s2smshift(22 downto 0),s2psh);`
194			`lshift: lpm_mult`
195			`generic map ("DEDICATED_MULTIPLIER_CIRCUITRY=YES,MAXIMIZE_SPEED=9","UNSIGNED","LPM_MULT",9,9,18)`
196			`port map (s2factorshift,"0"&s2smshift(06 downto 0)&'0,s2psl);`
197	107	jguarin200
198
199	111	jguarin200	`--! ******************************************************************************************************************************`
200			`--! Etapa2a signar las mantissas y sumarlas.`
201			`signmantissa:`
202			`process(s2asign,s2aum1,s2asm0,s2azero)`
203			`begin`
204			`s2axorslab <= (others => s2asign);`
205			`s2asm1 <= (s2axorslab(23)&((s2um1(23 downto 0))xor(s2axorslab)))+(x"000000"&s2axorslab(23));`
206			`case s2azero is`
207			`when '0' => s2asm <= (s2asm1(s2asm1'high)&s2asm1) + (s2asm0(s2asm0'high)&s2asm0);`
208			`when others => s2asm <= (s2asm1(s2asm1'high)&s2asm1) or (s2asm0(s2asm0'high)&s2asm0);`
209	107	jguarin200	`end case;`
210	111	jguarin200	`end process;`
211	107	jguarin200
212	111	jguarin200
213			`--! Mantissas sumadas, designar y normalizar`
214	108	jguarin200	`unsignmantissa:`
215	111	jguarin200	`process(s3sm)`
216
217	108	jguarin200	`begin`
218	111	jguarin200	`s3xorslab <= ( others => s3sm(s3sm'high) );`
219			`s3um(24 downto 0) <= ( s3sm(24 downto 0) xor s3xorslab ) + (x"000000"&s3xorslab(24));`
220			`s3sign <= s3sm(s3sm'high);`
221			`s3factor <= x"000000"&'0';`
222			`s3count <= '1'&x"f";`
223			`s3unrmexp <=`
224			`for i in 24 downto 0 loop`
225			`if s3sm(i)='1' then`
226			`s3factor(24-i)<='1';`
227			`exit;`
228			`end if;`
229			`s3count<=s3count+1;`
230	108	jguarin200	`end loop;`
231	111	jguarin200	`s3nrmexpo<=s3unrmexpo+s3count;`
232			`end process;`
233
234
235
236	106	jguarin200	`end process;`
237
238	109	jguarin200	`--!Normalizar el exponente y calcular el factor de corrimiento para la normalización de la mantissa`
239			`process (s4uxm,expunrm)`
240	108	jguarin200	`variable xshift : integer range 24 downto 0;`
241			`begin`
242			`for i in 24 downto 0 loop`
243	109	jguarin200	`if s4uxm(i)='1' then`
244	108	jguarin200	`xshift:=24-i;`
245			`end of;`
246			`end loop;`
247	109	jguarin200	`s4expnrm <= s4expunrm-(( "000"&conv_std_logic_vector(xshift,5) )+x"ff");`
248	108	jguarin200	`end process;`
249	106	jguarin200
250	109	jguarin200	`normantissafactor:`
251			`process (s4expnrm)`
252			`begin`
253			`s4factor(0)<=s4expnrm(7);`
254			`case s4expnrm(7) is`
255			`when '1' => s4factor(8 downto 1)<=(others=>'0');`
256			`when others =>`
257			`case s4expnrm(3 downto 1) is`
258			`when "000" => s4factor(8 downto 1)<="'00000001";`
259			`when "001" => s4factor(8 downto 1)<="'00000010";`
260			`when "010" => s4factor(8 downto 1)<="'00000100";`
261			`when "011" => s4factor(8 downto 1)<="'00001000";`
262			`when "100" => s4factor(8 downto 1)<="'00010000";`
263			`when "101" => s4factor(8 downto 1)<="'00100000";`
264			`when "110" => s4factor(8 downto 1)<="'01000000";`
265			`when others => s4factor(8 downto 1)<="'10000000";`
266			`end case;`
267			`end case;`
268			`end process;`
269	110	jguarin200
270	107	jguarin200
271	106	jguarin200
272
273	108	jguarin200	`end fadd32_arch;`
274	106	jguarin200
275
276
277
278
279
280
281	108	jguarin200

Browse

Tools

Subversion Repositories raytrac

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