Debian Codegraph @

gcc/testsuite/gcc.target/mips/mips16e2.c

raw
1 /* { dg-options "-mno-abicalls -mgpopt -G8 -mabi=32 -mips16 -mmips16e2" } */
2 /* { dg-skip-if "per-function expected output" { *-*-* } { "-flto" } { "" } } */
3
4 /* ANDI is a two operand instruction. Hence, it won't be generated if src and
5 * dest are in different registers. */
6
7 /* { dg-final { scan-assembler "test01:.*\tandi\t.*test01\n" } } */
8 unsigned int
9 test01 (unsigned int a)
10 {
11 return ((a + 0x2) & 0x3ff);
12 }
13
14 /* Test EXT */
15
16 /* { dg-final { scan-assembler "test02:.*\text\t.*test02\n" } } */
17 struct
18 {
19 unsigned int a:9;
20 unsigned int d:31;
21 unsigned int e:9;
22 unsigned int f:10;
23 } t02;
24
25 unsigned int
26 test02 (void)
27 {
28 return t02.f;
29 }
30
31 /* Use EXT when ANDing with low-order bitmasks. */
32
33 /* { dg-final { scan-assembler "test03:.*\text\t.*test03\n" } } */
34 /* { dg-final { scan-assembler-not "test03.*\tandi?\t.*test03\n" } } */
35 unsigned int
36 test03 (unsigned int x)
37 {
38 return (x & 0x1fffffff);
39 }
40
41 /* Test INS */
42
43 /* { dg-final { scan-assembler "test04:.*\tins\t.*test04\n" } } */
44 struct
45 {
46 unsigned int i : 9;
47 unsigned int j : 15;
48 unsigned int k : 4;
49 } s04;
50
51 void
52 test04 (void)
53 {
54 s04.j = 1;
55 }
56
57 /* Use INS with hardcoded $0. */
58
59 /* { dg-final { scan-assembler "test05:.*\tins\t\\\$.*,\\\$0.*test05\n" } } */
60 struct
61 {
62 unsigned int i : 8;
63 unsigned int j : 9;
64 unsigned int k : 10;
65 } __attribute__ ((packed)) s05 __attribute__((aligned(1)));
66
67 void
68 test05 (void)
69 {
70 s05.k = 0;
71 }
72
73 /* Use INS when ANDing to clear only one consecutive chunk of bits. */
74
75 /* { dg-final { scan-assembler "test06:.*\tins\t\\\$.*,\\\$0,11,5.*test06\n" } } */
76 /* { dg-final { scan-assembler-not "test06:.*\tandi?\t.*test06\n" } } */
77 unsigned int
78 test06 (unsigned int x)
79 {
80 return (x & 0xffff07ff);
81 }
82
83 /* ORI is a two operand instruction. Hence, it won't be generated if src and
84 dest are in different registers. */
85
86 /* { dg-final { scan-assembler "test07:.*\tori\t.*test07\n" } } */
87 unsigned int
88 test07 (unsigned int a)
89 {
90 return (a + 0x2) | 0x7f0;
91 }
92
93 /* XORI is a two operand instruction. Hence, it won't be generated if src and
94 dest are in different registers. */
95
96 /* { dg-final { scan-assembler "test08:.*\txori\t.*test08\n" } } */
97 unsigned int
98 test08 (unsigned int a)
99 {
100 return ((a + 0x2) ^ 0x3f0);
101 }
102
103 /* Test LUI. */
104
105 /* { dg-final { scan-assembler "test09:.*\tlui\t.*test09\n" } } */
106 int
107 test09 (void)
108 {
109 return 0x44440000;
110 }
111
112 /* Test LUI relocation sequence chang. */
113
114 /* { dg-final { scan-assembler "test10:.*\tlui\t.*test10\n" } } */
115 int *a10;
116
117 int
118 test10 (int i)
119 {
120 a10 = &i;
121 *a10 = 0x44440000;
122 return i;
123 }
124
125 /* Test 32bit unaligned load. */
126
127 /* { dg-final { scan-assembler "test11:.*\tlwl\t.*test11\n" } } */
128 /* { dg-final { scan-assembler "test11:.*\tlwr\t.*test11\n" } } */
129 struct node11
130 {
131 char c;
132 int i;
133 } __attribute__ ((packed)) obj11 __attribute__((aligned(1)));
134
135 int
136 test11 (void)
137 {
138 return obj11.i;
139 }
140
141 /* Test 32bit unaligned load. */
142
143 /* { dg-final { scan-assembler "test12:.*\tlwl\t.*test12\n" } } */
144 /* { dg-final { scan-assembler "test12:.*\tlwr\t.*test12\n" } } */
145 struct node12
146 {
147 unsigned int i : 8;
148 unsigned int j : 32;
149 } __attribute__ ((packed)) obj12 __attribute__((aligned(16)));
150
151 int
152 test12 (void)
153 {
154 return obj12.j;
155 }
156
157 /* Test 32bit unaligned store with non-zero constant */
158
159 /* { dg-final { scan-assembler "test13:.*\tswl\t.*test13\n" } } */
160 /* { dg-final { scan-assembler "test13:.*\tswr\t.*test13\n" } } */
161 struct node13
162 {
163 char c;
164 int i;
165 } __attribute__ ((packed)) obj13 __attribute__((aligned(1)));
166
167 void
168 test13 (void)
169 {
170 obj13.i = 1234;
171 }
172
173 /* Test 32bit unaligned store with zero constant. */
174
175 /* { dg-final { scan-assembler "test14:.*\tswl\t.*test14\n" } } */
176 /* { dg-final { scan-assembler "test14:.*\tswr\t.*test14\n" } } */
177 /* { dg-final { scan-assembler-not "test14:.*\tswl\t\\\$0,.*test14\n" } } */
178 /* { dg-final { scan-assembler-not "test14:.*\tswr\t\\\$0,.*test14\n" } } */
179 struct node14
180 {
181 char c;
182 int i;
183 } __attribute__ ((packed)) obj14 __attribute__((aligned(1)));
184
185 void
186 test14 (void)
187 {
188 obj14.i = 0;
189 }
190
191 /* Test 32bit unaligned store with non-constant. */
192
193 /* { dg-final { scan-assembler "test15:.*\tswl\t.*test15\n" } } */
194 /* { dg-final { scan-assembler "test15:.*\tswr\t.*test15\n" } } */
195 struct node15
196 {
197 char c;
198 int i;
199 } __attribute__ ((packed)) obj15 __attribute__((aligned(1)));
200
201 int i15 = 1234;
202
203 void
204 test15 (void)
205 {
206 obj15.i = i15;
207 }
208
209 /* Test 32bit unaligned store with non-constant */
210
211 /* { dg-final { scan-assembler "test16:.*\tswl\t.*test16\n" } } */
212 /* { dg-final { scan-assembler "test16:.*\tswr\t.*test16\n" } } */
213 struct node16
214 {
215 char c;
216 int i;
217 } __attribute__ ((packed)) obj16 __attribute__((aligned(1)));
218
219 void
220 test16 (int i)
221 {
222 obj16.i = i;
223 }
224
225 /* Test 32bit unaligned store with non-constant. */
226
227 /* { dg-final { scan-assembler "test17:.*\tswl\t.*test17\n" } } */
228 /* { dg-final { scan-assembler "test17:.*\tswr\t.*test17\n" } } */
229 struct node17
230 {
231 unsigned int i : 8;
232 unsigned int j : 32;
233 } __attribute__ ((packed)) obj17 __attribute__((aligned(16)));
234
235 void
236 test17 (int i)
237 {
238 obj17.j = i;
239 }
240