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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [alpha/] [lib/] [fpreg.c] - Blame information for rev 1275

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


/*
 * arch/alpha/lib/fpreg.c
 *
 * (C) Copyright 1998 Linus Torvalds
 */
 
#if defined(__alpha_cix__) || defined(__alpha_fix__)
#define STT(reg,val)  asm volatile ("ftoit $f"#reg",%0" : "=r"(val));
#else
#define STT(reg,val)  asm volatile ("stt $f"#reg",%0" : "=m"(val));
#endif
 
unsigned long
alpha_read_fp_reg (unsigned long reg)
{
        unsigned long val;
 
        switch (reg) {
              case  0: STT( 0, val); break;
              case  1: STT( 1, val); break;
              case  2: STT( 2, val); break;
              case  3: STT( 3, val); break;
              case  4: STT( 4, val); break;
              case  5: STT( 5, val); break;
              case  6: STT( 6, val); break;
              case  7: STT( 7, val); break;
              case  8: STT( 8, val); break;
              case  9: STT( 9, val); break;
              case 10: STT(10, val); break;
              case 11: STT(11, val); break;
              case 12: STT(12, val); break;
              case 13: STT(13, val); break;
              case 14: STT(14, val); break;
              case 15: STT(15, val); break;
              case 16: STT(16, val); break;
              case 17: STT(17, val); break;
              case 18: STT(18, val); break;
              case 19: STT(19, val); break;
              case 20: STT(20, val); break;
              case 21: STT(21, val); break;
              case 22: STT(22, val); break;
              case 23: STT(23, val); break;
              case 24: STT(24, val); break;
              case 25: STT(25, val); break;
              case 26: STT(26, val); break;
              case 27: STT(27, val); break;
              case 28: STT(28, val); break;
              case 29: STT(29, val); break;
              case 30: STT(30, val); break;
              case 31: STT(31, val); break;
        }
        return val;
}
 
#if defined(__alpha_cix__) || defined(__alpha_fix__)
#define LDT(reg,val)  asm volatile ("itoft %0,$f"#reg : : "r"(val));
#else
#define LDT(reg,val)  asm volatile ("ldt $f"#reg",%0" : : "m"(val));
#endif
 
void
alpha_write_fp_reg (unsigned long reg, unsigned long val)
{
        switch (reg) {
              case  0: LDT( 0, val); break;
              case  1: LDT( 1, val); break;
              case  2: LDT( 2, val); break;
              case  3: LDT( 3, val); break;
              case  4: LDT( 4, val); break;
              case  5: LDT( 5, val); break;
              case  6: LDT( 6, val); break;
              case  7: LDT( 7, val); break;
              case  8: LDT( 8, val); break;
              case  9: LDT( 9, val); break;
              case 10: LDT(10, val); break;
              case 11: LDT(11, val); break;
              case 12: LDT(12, val); break;
              case 13: LDT(13, val); break;
              case 14: LDT(14, val); break;
              case 15: LDT(15, val); break;
              case 16: LDT(16, val); break;
              case 17: LDT(17, val); break;
              case 18: LDT(18, val); break;
              case 19: LDT(19, val); break;
              case 20: LDT(20, val); break;
              case 21: LDT(21, val); break;
              case 22: LDT(22, val); break;
              case 23: LDT(23, val); break;
              case 24: LDT(24, val); break;
              case 25: LDT(25, val); break;
              case 26: LDT(26, val); break;
              case 27: LDT(27, val); break;
              case 28: LDT(28, val); break;
              case 29: LDT(29, val); break;
              case 30: LDT(30, val); break;
              case 31: LDT(31, val); break;
        }
}
 
#if defined(__alpha_cix__) || defined(__alpha_fix__)
#define STS(reg,val)  asm volatile ("ftois $f"#reg",%0" : "=r"(val));
#else
#define STS(reg,val)  asm volatile ("sts $f"#reg",%0" : "=m"(val));
#endif
 
unsigned long
alpha_read_fp_reg_s (unsigned long reg)
{
        unsigned long val;
 
        switch (reg) {
              case  0: STS( 0, val); break;
              case  1: STS( 1, val); break;
              case  2: STS( 2, val); break;
              case  3: STS( 3, val); break;
              case  4: STS( 4, val); break;
              case  5: STS( 5, val); break;
              case  6: STS( 6, val); break;
              case  7: STS( 7, val); break;
              case  8: STS( 8, val); break;
              case  9: STS( 9, val); break;
              case 10: STS(10, val); break;
              case 11: STS(11, val); break;
              case 12: STS(12, val); break;
              case 13: STS(13, val); break;
              case 14: STS(14, val); break;
              case 15: STS(15, val); break;
              case 16: STS(16, val); break;
              case 17: STS(17, val); break;
              case 18: STS(18, val); break;
              case 19: STS(19, val); break;
              case 20: STS(20, val); break;
              case 21: STS(21, val); break;
              case 22: STS(22, val); break;
              case 23: STS(23, val); break;
              case 24: STS(24, val); break;
              case 25: STS(25, val); break;
              case 26: STS(26, val); break;
              case 27: STS(27, val); break;
              case 28: STS(28, val); break;
              case 29: STS(29, val); break;
              case 30: STS(30, val); break;
              case 31: STS(31, val); break;
        }
        return val;
}
 
#if defined(__alpha_cix__) || defined(__alpha_fix__)
#define LDS(reg,val)  asm volatile ("itofs %0,$f"#reg : : "r"(val));
#else
#define LDS(reg,val)  asm volatile ("lds $f"#reg",%0" : : "m"(val));
#endif
 
void
alpha_write_fp_reg_s (unsigned long reg, unsigned long val)
{
        switch (reg) {
              case  0: LDS( 0, val); break;
              case  1: LDS( 1, val); break;
              case  2: LDS( 2, val); break;
              case  3: LDS( 3, val); break;
              case  4: LDS( 4, val); break;
              case  5: LDS( 5, val); break;
              case  6: LDS( 6, val); break;
              case  7: LDS( 7, val); break;
              case  8: LDS( 8, val); break;
              case  9: LDS( 9, val); break;
              case 10: LDS(10, val); break;
              case 11: LDS(11, val); break;
              case 12: LDS(12, val); break;
              case 13: LDS(13, val); break;
              case 14: LDS(14, val); break;
              case 15: LDS(15, val); break;
              case 16: LDS(16, val); break;
              case 17: LDS(17, val); break;
              case 18: LDS(18, val); break;
              case 19: LDS(19, val); break;
              case 20: LDS(20, val); break;
              case 21: LDS(21, val); break;
              case 22: LDS(22, val); break;
              case 23: LDS(23, val); break;
              case 24: LDS(24, val); break;
              case 25: LDS(25, val); break;
              case 26: LDS(26, val); break;
              case 27: LDS(27, val); break;
              case 28: LDS(28, val); break;
              case 29: LDS(29, val); break;
              case 30: LDS(30, val); break;
              case 31: LDS(31, val); break;
        }
}

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* arch/alpha/lib/fpreg.c`
3			`*`
4			`* (C) Copyright 1998 Linus Torvalds`
5			`*/`
6
7			`#if defined(__alpha_cix__) \|\| defined(__alpha_fix__)`
8			`#define STT(reg,val) asm volatile ("ftoit $f"#reg",%0" : "=r"(val));`
9			`#else`
10			`#define STT(reg,val) asm volatile ("stt $f"#reg",%0" : "=m"(val));`
11			`#endif`
12
13			`unsigned long`
14			`alpha_read_fp_reg (unsigned long reg)`
15			`{`
16			`unsigned long val;`
17
18			`switch (reg) {`
19			`case 0: STT( 0, val); break;`
20			`case 1: STT( 1, val); break;`
21			`case 2: STT( 2, val); break;`
22			`case 3: STT( 3, val); break;`
23			`case 4: STT( 4, val); break;`
24			`case 5: STT( 5, val); break;`
25			`case 6: STT( 6, val); break;`
26			`case 7: STT( 7, val); break;`
27			`case 8: STT( 8, val); break;`
28			`case 9: STT( 9, val); break;`
29			`case 10: STT(10, val); break;`
30			`case 11: STT(11, val); break;`
31			`case 12: STT(12, val); break;`
32			`case 13: STT(13, val); break;`
33			`case 14: STT(14, val); break;`
34			`case 15: STT(15, val); break;`
35			`case 16: STT(16, val); break;`
36			`case 17: STT(17, val); break;`
37			`case 18: STT(18, val); break;`
38			`case 19: STT(19, val); break;`
39			`case 20: STT(20, val); break;`
40			`case 21: STT(21, val); break;`
41			`case 22: STT(22, val); break;`
42			`case 23: STT(23, val); break;`
43			`case 24: STT(24, val); break;`
44			`case 25: STT(25, val); break;`
45			`case 26: STT(26, val); break;`
46			`case 27: STT(27, val); break;`
47			`case 28: STT(28, val); break;`
48			`case 29: STT(29, val); break;`
49			`case 30: STT(30, val); break;`
50			`case 31: STT(31, val); break;`
51			`}`
52			`return val;`
53			`}`
54
55			`#if defined(__alpha_cix__) \|\| defined(__alpha_fix__)`
56			`#define LDT(reg,val) asm volatile ("itoft %0,$f"#reg : : "r"(val));`
57			`#else`
58			`#define LDT(reg,val) asm volatile ("ldt $f"#reg",%0" : : "m"(val));`
59			`#endif`
60
61			`void`
62			`alpha_write_fp_reg (unsigned long reg, unsigned long val)`
63			`{`
64			`switch (reg) {`
65			`case 0: LDT( 0, val); break;`
66			`case 1: LDT( 1, val); break;`
67			`case 2: LDT( 2, val); break;`
68			`case 3: LDT( 3, val); break;`
69			`case 4: LDT( 4, val); break;`
70			`case 5: LDT( 5, val); break;`
71			`case 6: LDT( 6, val); break;`
72			`case 7: LDT( 7, val); break;`
73			`case 8: LDT( 8, val); break;`
74			`case 9: LDT( 9, val); break;`
75			`case 10: LDT(10, val); break;`
76			`case 11: LDT(11, val); break;`
77			`case 12: LDT(12, val); break;`
78			`case 13: LDT(13, val); break;`
79			`case 14: LDT(14, val); break;`
80			`case 15: LDT(15, val); break;`
81			`case 16: LDT(16, val); break;`
82			`case 17: LDT(17, val); break;`
83			`case 18: LDT(18, val); break;`
84			`case 19: LDT(19, val); break;`
85			`case 20: LDT(20, val); break;`
86			`case 21: LDT(21, val); break;`
87			`case 22: LDT(22, val); break;`
88			`case 23: LDT(23, val); break;`
89			`case 24: LDT(24, val); break;`
90			`case 25: LDT(25, val); break;`
91			`case 26: LDT(26, val); break;`
92			`case 27: LDT(27, val); break;`
93			`case 28: LDT(28, val); break;`
94			`case 29: LDT(29, val); break;`
95			`case 30: LDT(30, val); break;`
96			`case 31: LDT(31, val); break;`
97			`}`
98			`}`
99
100			`#if defined(__alpha_cix__) \|\| defined(__alpha_fix__)`
101			`#define STS(reg,val) asm volatile ("ftois $f"#reg",%0" : "=r"(val));`
102			`#else`
103			`#define STS(reg,val) asm volatile ("sts $f"#reg",%0" : "=m"(val));`
104			`#endif`
105
106			`unsigned long`
107			`alpha_read_fp_reg_s (unsigned long reg)`
108			`{`
109			`unsigned long val;`
110
111			`switch (reg) {`
112			`case 0: STS( 0, val); break;`
113			`case 1: STS( 1, val); break;`
114			`case 2: STS( 2, val); break;`
115			`case 3: STS( 3, val); break;`
116			`case 4: STS( 4, val); break;`
117			`case 5: STS( 5, val); break;`
118			`case 6: STS( 6, val); break;`
119			`case 7: STS( 7, val); break;`
120			`case 8: STS( 8, val); break;`
121			`case 9: STS( 9, val); break;`
122			`case 10: STS(10, val); break;`
123			`case 11: STS(11, val); break;`
124			`case 12: STS(12, val); break;`
125			`case 13: STS(13, val); break;`
126			`case 14: STS(14, val); break;`
127			`case 15: STS(15, val); break;`
128			`case 16: STS(16, val); break;`
129			`case 17: STS(17, val); break;`
130			`case 18: STS(18, val); break;`
131			`case 19: STS(19, val); break;`
132			`case 20: STS(20, val); break;`
133			`case 21: STS(21, val); break;`
134			`case 22: STS(22, val); break;`
135			`case 23: STS(23, val); break;`
136			`case 24: STS(24, val); break;`
137			`case 25: STS(25, val); break;`
138			`case 26: STS(26, val); break;`
139			`case 27: STS(27, val); break;`
140			`case 28: STS(28, val); break;`
141			`case 29: STS(29, val); break;`
142			`case 30: STS(30, val); break;`
143			`case 31: STS(31, val); break;`
144			`}`
145			`return val;`
146			`}`
147
148			`#if defined(__alpha_cix__) \|\| defined(__alpha_fix__)`
149			`#define LDS(reg,val) asm volatile ("itofs %0,$f"#reg : : "r"(val));`
150			`#else`
151			`#define LDS(reg,val) asm volatile ("lds $f"#reg",%0" : : "m"(val));`
152			`#endif`
153
154			`void`
155			`alpha_write_fp_reg_s (unsigned long reg, unsigned long val)`
156			`{`
157			`switch (reg) {`
158			`case 0: LDS( 0, val); break;`
159			`case 1: LDS( 1, val); break;`
160			`case 2: LDS( 2, val); break;`
161			`case 3: LDS( 3, val); break;`
162			`case 4: LDS( 4, val); break;`
163			`case 5: LDS( 5, val); break;`
164			`case 6: LDS( 6, val); break;`
165			`case 7: LDS( 7, val); break;`
166			`case 8: LDS( 8, val); break;`
167			`case 9: LDS( 9, val); break;`
168			`case 10: LDS(10, val); break;`
169			`case 11: LDS(11, val); break;`
170			`case 12: LDS(12, val); break;`
171			`case 13: LDS(13, val); break;`
172			`case 14: LDS(14, val); break;`
173			`case 15: LDS(15, val); break;`
174			`case 16: LDS(16, val); break;`
175			`case 17: LDS(17, val); break;`
176			`case 18: LDS(18, val); break;`
177			`case 19: LDS(19, val); break;`
178			`case 20: LDS(20, val); break;`
179			`case 21: LDS(21, val); break;`
180			`case 22: LDS(22, val); break;`
181			`case 23: LDS(23, val); break;`
182			`case 24: LDS(24, val); break;`
183			`case 25: LDS(25, val); break;`
184			`case 26: LDS(26, val); break;`
185			`case 27: LDS(27, val); break;`
186			`case 28: LDS(28, val); break;`
187			`case 29: LDS(29, val); break;`
188			`case 30: LDS(30, val); break;`
189			`case 31: LDS(31, val); break;`
190			`}`
191			`}`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [alpha/] [lib/] [fpreg.c] - Blame information for rev 1275