[deliverable/binutils-gdb.git] / sim / testsuite / sim / or1k / load.S

/* Tests the load and store instructions.

   Copyright (C) 2017-2020 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

# mach: or1k
# output: report(0xdeadbeef);\n
# output: report(0x00000000);\n
# output: report(0x7fffffff);\n
# output: report(0x80000000);\n
# output: report(0xffffffff);\n
# output: report(0x00000000);\n
# output: report(0x7fffffff);\n
# output: report(0x80000000);\n
# output: report(0xffffffff);\n
# output: report(0xdeadbeef);\n
# output: report(0x00000000);\n
# output: report(0x7fffffff);\n
# output: report(0x80000000);\n
# output: report(0xdeadbeef);\n
# output: report(0x00000000);\n
# output: report(0x7fffffff);\n
# output: report(0x80000000);\n
# output: report(0xffffffff);\n
# output: report(0x00000000);\n
# output: report(0x7fffffff);\n
# output: report(0x80000000);\n
# output: report(0xffffffff);\n
# output: report(0xdeadbeef);\n
# output: report(0x00000000);\n
# output: report(0x7fffffff);\n
# output: report(0x80000000);\n
# output: report(0x000000de);\n
# output: report(0x000000ad);\n
# output: report(0x000000be);\n
# output: report(0x000000ef);\n
# output: report(0x000000ef);\n
# output: report(0x000000be);\n
# output: report(0x000000ad);\n
# output: report(0x000000de);\n
# output: report(0xffffffde);\n
# output: report(0xffffffad);\n
# output: report(0xffffffbe);\n
# output: report(0xffffffef);\n
# output: report(0xffffffef);\n
# output: report(0xffffffbe);\n
# output: report(0xffffffad);\n
# output: report(0xffffffde);\n
# output: report(0x0000dead);\n
# output: report(0x0000beef);\n
# output: report(0x0000beef);\n
# output: report(0x0000dead);\n
# output: report(0xffffdead);\n
# output: report(0xffffbeef);\n
# output: report(0xffffbeef);\n
# output: report(0xffffdead);\n
# output: report(0xa1a2a3a4);\n
# output: report(0xb4b3b2b1);\n
# output: report(0x81828384);\n
# output: report(0x53545152);\n
# output: report(0xa0b0c0d0);\n
# output: report(0xa1b1c1d1);\n
# output: report(0xa3b3c3d3);\n
# output: report(0xa2b2c2d2);\n
# output: exit(0)\n

#include "or1k-asm-test-helpers.h"

	.macro TEST_LW  opcode, label, offset
	LOAD_IMMEDIATE r5, \label
	\opcode  r4, \offset(r5)
	REPORT_REG_TO_CONSOLE r4
	.endm

	STANDARD_TEST_ENVIRONMENT

	.section .rodata
	.balign 4

50:     .word   0xdeadbeef
51:     .word   0x00000000
52:     .word   0x7fffffff
53:     .word   0x80000000
54:     .word   0xffffffff

	.section .data
	.balign 4

buffer1:  .word 0x00000000
buffer2:  .word 0x00000000
buffer3:  .word 0x00000000
buffer4:  .word 0x00000000
buffer5:

	.section .text
start_tests:
	PUSH LINK_REGISTER_R9

	/* Test instruction l.lws  */

	/* Load with zero offset.  */
	TEST_LW l.lws 50b, 0
	TEST_LW l.lws 51b, 0
	TEST_LW l.lws 52b, 0
	TEST_LW l.lws 53b, 0
	TEST_LW l.lws 54b, 0

	/* Load with positive offset.  */
	TEST_LW l.lws 50b,  4
	TEST_LW l.lws 50b,  8
	TEST_LW l.lws 50b, 12
	TEST_LW l.lws 50b, 16

	/* Load with negative offset.  */
	TEST_LW l.lws 54b, -16
	TEST_LW l.lws 54b, -12
	TEST_LW l.lws 54b,  -8
	TEST_LW l.lws 54b,  -4

	/* TODO: add here test cases to cover unaligned memory accesses
	   with l.lws.  */

	/* Test instruction l.lwz */

	/* Load with zero offset.  */
	TEST_LW l.lwz 50b, 0
	TEST_LW l.lwz 51b, 0
	TEST_LW l.lwz 52b, 0
	TEST_LW l.lwz 53b, 0
	TEST_LW l.lwz 54b, 0

	/* Load with positive offset.  */
	TEST_LW l.lwz 50b,  4
	TEST_LW l.lwz 50b,  8
	TEST_LW l.lwz 50b, 12
	TEST_LW l.lwz 50b, 16

	/* Load with negative offset.  */
	TEST_LW l.lwz 54b, -16
	TEST_LW l.lwz 54b, -12
	TEST_LW l.lwz 54b,  -8
	TEST_LW l.lwz 54b,  -4

	/* TODO: add here test cases to cover unaligned memory accesses
	   with l.lwz.  */

	/* Test instruction l.lbz  */

	/* Read data at label 50, forwards, byte by byte.  */
	LOAD_IMMEDIATE r5, 50b

	l.lbz r4, 0(r5)
	REPORT_REG_TO_CONSOLE r4

	l.lbz r4, 1(r5)
	REPORT_REG_TO_CONSOLE r4

	l.lbz r4, 2(r5)
	REPORT_REG_TO_CONSOLE r4

	l.lbz r4, 3(r5)
	REPORT_REG_TO_CONSOLE r4

	/* Read data at label 50, backwards, byte by byte.  */
	LOAD_IMMEDIATE r31, 51b

	l.lbz r3, -1(r31)
	REPORT_REG_TO_CONSOLE r3

	l.lbz r3, -2(r31)
	REPORT_REG_TO_CONSOLE r3

	l.lbz r3, -3(r31)
	REPORT_REG_TO_CONSOLE r3

	l.lbz r3, -4(r31)
	REPORT_REG_TO_CONSOLE r3

	/* Test instruction l.lbs  */

	/* Read data at label 50, forwards, byte by byte.  */
	LOAD_IMMEDIATE r5, 50b

	l.lbs r4, 0(r5)
	REPORT_REG_TO_CONSOLE r4

	l.lbs r4, 1(r5)
	REPORT_REG_TO_CONSOLE r4

	l.lbs r4, 2(r5)
	REPORT_REG_TO_CONSOLE r4

	l.lbs r4, 3(r5)
	REPORT_REG_TO_CONSOLE r4

	/* Read data at label 50, backwards, byte by byte.  */
	LOAD_IMMEDIATE r31, 51b

	l.lbs r3, -1(r31)
	REPORT_REG_TO_CONSOLE r3

	l.lbs r3, -2(r31)
	REPORT_REG_TO_CONSOLE r3

	l.lbs r3, -3(r31)
	REPORT_REG_TO_CONSOLE r3

	l.lbs r3, -4(r31)
	REPORT_REG_TO_CONSOLE r3

	/* Test instruction l.lhz  */

	/* Read data at label 50, forwards, half-word by half-word.  */
	LOAD_IMMEDIATE r5, 50b

	l.lhz r4, 0(r5)
	REPORT_REG_TO_CONSOLE r4

	l.lhz r4, 2(r5)
	REPORT_REG_TO_CONSOLE r4

	/* Read data at label 50, backwards, half-word by half-word.  */
	LOAD_IMMEDIATE r31, 51b

	l.lhz r3, -2(r31)
	REPORT_REG_TO_CONSOLE r3

	l.lhz r3, -4(r31)
	REPORT_REG_TO_CONSOLE r3

	/* TODO: add here test cases to cover unaligned memory accesses
	   with l.lhz.  */

	/* Test instruction l.lhs  */

	/* Read data at label 50, forwards, half-word by half-word.  */
	LOAD_IMMEDIATE r5, 50b

	l.lhs r4, 0(r5)
	REPORT_REG_TO_CONSOLE r4

	l.lhs r4, 2(r5)
	REPORT_REG_TO_CONSOLE r4

	/* Read data at label 50, backwards, half-word by half-word.  */
	LOAD_IMMEDIATE r31, 51b

	l.lhs r3, -2(r31)
	REPORT_REG_TO_CONSOLE r3

	l.lhs r3, -4(r31)
	REPORT_REG_TO_CONSOLE r3

	/* TODO: add here test cases to cover unaligned memory accesses
	   with l.lhs.  */

	/* Test instruction l.sb  */

	/* Write 32-bits forwards, byte-to-byte.  */
	LOAD_IMMEDIATE r5, buffer1

	LOAD_IMMEDIATE r10, 0xA1
	LOAD_IMMEDIATE r11, 0xA2
	LOAD_IMMEDIATE r12, 0xA3
	LOAD_IMMEDIATE r13, 0xA4

	l.sb 0(r5), r10
	l.sb 1(r5), r11
	l.sb 2(r5), r12
	l.sb 3(r5), r13

	l.lwz r3, 0(r5)
	REPORT_REG_TO_CONSOLE r3

	/* Write 32-bits backwards, byte-to-byte.  */
	LOAD_IMMEDIATE r6, buffer2

	LOAD_IMMEDIATE r10, 0xB1
	LOAD_IMMEDIATE r11, 0xB2
	LOAD_IMMEDIATE r12, 0xB3
	LOAD_IMMEDIATE r13, 0xB4

	l.sb -1(r6), r10
	l.sb -2(r6), r11
	l.sb -3(r6), r12
	l.sb -4(r6), r13

	l.lwz r3, 0(r5)
	REPORT_REG_TO_CONSOLE r3

	/* TODO: add here test cases to cover unaligned memory accesses
	   with l.sb.  */

	/* Test instruction l.sh  */

	/* Write 32-bits forwards, one half-word at a time.  */
	LOAD_IMMEDIATE r5, buffer1

	LOAD_IMMEDIATE r10, 0x8182
	LOAD_IMMEDIATE r11, 0x8384

	l.sh 0(r5), r10
	l.sh 2(r5), r11

	l.lwz r3, 0(r5)
	REPORT_REG_TO_CONSOLE r3

	/* Write 32-bits backwards, one half-word at a time.  */
	LOAD_IMMEDIATE r6, buffer2

	LOAD_IMMEDIATE r10, 0x5152
	LOAD_IMMEDIATE r11, 0x5354

	l.sh -2(r6), r10
	l.sh -4(r6), r11

	l.lwz r3, 0(r5)
	REPORT_REG_TO_CONSOLE r3

	/* TODO: add here test cases to cover unaligned memory accesses
	   with l.sh.  */

	/* Test instruction l.sw  */
	LOAD_IMMEDIATE r5, buffer1
	LOAD_IMMEDIATE r6, buffer5

	LOAD_IMMEDIATE r10, 0xA0B0C0D0
	LOAD_IMMEDIATE r11, 0xA1B1C1D1
	LOAD_IMMEDIATE r12, 0xA2B2C2D2
	LOAD_IMMEDIATE r13, 0xA3B3C3D3

	l.sw  0(r5), r10
	l.sw  4(r5), r11
	l.sw -4(r6), r12
	l.sw -8(r6), r13

	TEST_LW l.lwz buffer1, 0
	TEST_LW l.lwz buffer2, 0
	TEST_LW l.lwz buffer3, 0
	TEST_LW l.lwz buffer4, 0

	/* TODO: add here test cases to cover unaligned memory accesses
	   with l.sw.  */

	POP LINK_REGISTER_R9
	RETURN_TO_LINK_REGISTER_R9
Commit	Line	Data
702d582e PG	1	/* Tests the load and store instructions.
702d582e PG	2
b811d2c2	3	Copyright (C) 2017-2020 Free Software Foundation, Inc.
702d582e PG	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	17
	18	# mach: or1k
	19	# output: report(0xdeadbeef);\n
	20	# output: report(0x00000000);\n
	21	# output: report(0x7fffffff);\n
	22	# output: report(0x80000000);\n
	23	# output: report(0xffffffff);\n
	24	# output: report(0x00000000);\n
	25	# output: report(0x7fffffff);\n
	26	# output: report(0x80000000);\n
	27	# output: report(0xffffffff);\n
	28	# output: report(0xdeadbeef);\n
	29	# output: report(0x00000000);\n
	30	# output: report(0x7fffffff);\n
	31	# output: report(0x80000000);\n
	32	# output: report(0xdeadbeef);\n
	33	# output: report(0x00000000);\n
	34	# output: report(0x7fffffff);\n
	35	# output: report(0x80000000);\n
	36	# output: report(0xffffffff);\n
	37	# output: report(0x00000000);\n
	38	# output: report(0x7fffffff);\n
	39	# output: report(0x80000000);\n
	40	# output: report(0xffffffff);\n
	41	# output: report(0xdeadbeef);\n
	42	# output: report(0x00000000);\n
	43	# output: report(0x7fffffff);\n
	44	# output: report(0x80000000);\n
	45	# output: report(0x000000de);\n
	46	# output: report(0x000000ad);\n
	47	# output: report(0x000000be);\n
	48	# output: report(0x000000ef);\n
	49	# output: report(0x000000ef);\n
	50	# output: report(0x000000be);\n
	51	# output: report(0x000000ad);\n
	52	# output: report(0x000000de);\n
	53	# output: report(0xffffffde);\n
	54	# output: report(0xffffffad);\n
	55	# output: report(0xffffffbe);\n
	56	# output: report(0xffffffef);\n
	57	# output: report(0xffffffef);\n
	58	# output: report(0xffffffbe);\n
	59	# output: report(0xffffffad);\n
	60	# output: report(0xffffffde);\n
	61	# output: report(0x0000dead);\n
	62	# output: report(0x0000beef);\n
	63	# output: report(0x0000beef);\n
	64	# output: report(0x0000dead);\n
	65	# output: report(0xffffdead);\n
	66	# output: report(0xffffbeef);\n
	67	# output: report(0xffffbeef);\n
68	# output: report(0xffffdead);\n
69	# output: report(0xa1a2a3a4);\n
70	# output: report(0xb4b3b2b1);\n
71	# output: report(0x81828384);\n
72	# output: report(0x53545152);\n
73	# output: report(0xa0b0c0d0);\n
74	# output: report(0xa1b1c1d1);\n
75	# output: report(0xa3b3c3d3);\n
76	# output: report(0xa2b2c2d2);\n
77	# output: exit(0)\n
78
79	#include "or1k-asm-test-helpers.h"
80
81	.macro TEST_LW opcode, label, offset
82	LOAD_IMMEDIATE r5, \label
83	\opcode r4, \offset(r5)
84	REPORT_REG_TO_CONSOLE r4
85	.endm
86
87	STANDARD_TEST_ENVIRONMENT
88
89	.section .rodata
90	.balign 4
91
92	50: .word 0xdeadbeef
93	51: .word 0x00000000
94	52: .word 0x7fffffff
95	53: .word 0x80000000
96	54: .word 0xffffffff
97
98	.section .data
99	.balign 4
100
101	buffer1: .word 0x00000000
102	buffer2: .word 0x00000000
103	buffer3: .word 0x00000000
104	buffer4: .word 0x00000000
105	buffer5:
106
107	.section .text
108	start_tests:
109	PUSH LINK_REGISTER_R9
110
111	/* Test instruction l.lws */
112
113	/* Load with zero offset. */
114	TEST_LW l.lws 50b, 0
115	TEST_LW l.lws 51b, 0
116	TEST_LW l.lws 52b, 0
117	TEST_LW l.lws 53b, 0
118	TEST_LW l.lws 54b, 0
119
120	/* Load with positive offset. */
121	TEST_LW l.lws 50b, 4
122	TEST_LW l.lws 50b, 8
123	TEST_LW l.lws 50b, 12
124	TEST_LW l.lws 50b, 16
125
126	/* Load with negative offset. */
127	TEST_LW l.lws 54b, -16
128	TEST_LW l.lws 54b, -12
129	TEST_LW l.lws 54b, -8
130	TEST_LW l.lws 54b, -4
131
132	/* TODO: add here test cases to cover unaligned memory accesses
133	with l.lws. */
134
135	/* Test instruction l.lwz */
136
137	/* Load with zero offset. */
138	TEST_LW l.lwz 50b, 0
139	TEST_LW l.lwz 51b, 0
140	TEST_LW l.lwz 52b, 0
141	TEST_LW l.lwz 53b, 0
142	TEST_LW l.lwz 54b, 0
143
144	/* Load with positive offset. */
145	TEST_LW l.lwz 50b, 4
146	TEST_LW l.lwz 50b, 8
147	TEST_LW l.lwz 50b, 12
148	TEST_LW l.lwz 50b, 16
149
150	/* Load with negative offset. */
151	TEST_LW l.lwz 54b, -16
152	TEST_LW l.lwz 54b, -12
153	TEST_LW l.lwz 54b, -8
154	TEST_LW l.lwz 54b, -4
155
156	/* TODO: add here test cases to cover unaligned memory accesses
157	with l.lwz. */
158
159	/* Test instruction l.lbz */
160
161	/* Read data at label 50, forwards, byte by byte. */
162	LOAD_IMMEDIATE r5, 50b
163
164	l.lbz r4, 0(r5)
165	REPORT_REG_TO_CONSOLE r4
166
167	l.lbz r4, 1(r5)
168	REPORT_REG_TO_CONSOLE r4
169
170	l.lbz r4, 2(r5)
171	REPORT_REG_TO_CONSOLE r4
172
173	l.lbz r4, 3(r5)
174	REPORT_REG_TO_CONSOLE r4
175
176	/* Read data at label 50, backwards, byte by byte. */
177	LOAD_IMMEDIATE r31, 51b
178
179	l.lbz r3, -1(r31)
180	REPORT_REG_TO_CONSOLE r3
181
182	l.lbz r3, -2(r31)
183	REPORT_REG_TO_CONSOLE r3
184
185	l.lbz r3, -3(r31)
186	REPORT_REG_TO_CONSOLE r3
187
188	l.lbz r3, -4(r31)
189	REPORT_REG_TO_CONSOLE r3
190
191	/* Test instruction l.lbs */
192
193	/* Read data at label 50, forwards, byte by byte. */
194	LOAD_IMMEDIATE r5, 50b
195
196	l.lbs r4, 0(r5)
197	REPORT_REG_TO_CONSOLE r4
198
199	l.lbs r4, 1(r5)
200	REPORT_REG_TO_CONSOLE r4
201
202	l.lbs r4, 2(r5)
203	REPORT_REG_TO_CONSOLE r4
204
205	l.lbs r4, 3(r5)
206	REPORT_REG_TO_CONSOLE r4
207
208	/* Read data at label 50, backwards, byte by byte. */
209	LOAD_IMMEDIATE r31, 51b
210
211	l.lbs r3, -1(r31)
212	REPORT_REG_TO_CONSOLE r3
213
214	l.lbs r3, -2(r31)
215	REPORT_REG_TO_CONSOLE r3
216
217	l.lbs r3, -3(r31)
218	REPORT_REG_TO_CONSOLE r3
219
220	l.lbs r3, -4(r31)
221	REPORT_REG_TO_CONSOLE r3
222
223	/* Test instruction l.lhz */
224
225	/* Read data at label 50, forwards, half-word by half-word. */
226	LOAD_IMMEDIATE r5, 50b
227
228	l.lhz r4, 0(r5)
229	REPORT_REG_TO_CONSOLE r4
230
231	l.lhz r4, 2(r5)
232	REPORT_REG_TO_CONSOLE r4
233
234	/* Read data at label 50, backwards, half-word by half-word. */
235	LOAD_IMMEDIATE r31, 51b
236
237	l.lhz r3, -2(r31)
238	REPORT_REG_TO_CONSOLE r3
239
240	l.lhz r3, -4(r31)
241	REPORT_REG_TO_CONSOLE r3
242
243	/* TODO: add here test cases to cover unaligned memory accesses
244	with l.lhz. */
245
246	/* Test instruction l.lhs */
247
248	/* Read data at label 50, forwards, half-word by half-word. */
249	LOAD_IMMEDIATE r5, 50b
250
251	l.lhs r4, 0(r5)
252	REPORT_REG_TO_CONSOLE r4
253
254	l.lhs r4, 2(r5)
255	REPORT_REG_TO_CONSOLE r4
256
257	/* Read data at label 50, backwards, half-word by half-word. */
258	LOAD_IMMEDIATE r31, 51b
259
260	l.lhs r3, -2(r31)
261	REPORT_REG_TO_CONSOLE r3
262
263	l.lhs r3, -4(r31)
264	REPORT_REG_TO_CONSOLE r3
265
266	/* TODO: add here test cases to cover unaligned memory accesses
267	with l.lhs. */
268
269	/* Test instruction l.sb */
270
271	/* Write 32-bits forwards, byte-to-byte. */
272	LOAD_IMMEDIATE r5, buffer1
273
274	LOAD_IMMEDIATE r10, 0xA1
275	LOAD_IMMEDIATE r11, 0xA2
276	LOAD_IMMEDIATE r12, 0xA3
277	LOAD_IMMEDIATE r13, 0xA4
278
279	l.sb 0(r5), r10
280	l.sb 1(r5), r11
281	l.sb 2(r5), r12
282	l.sb 3(r5), r13
283
284	l.lwz r3, 0(r5)
285	REPORT_REG_TO_CONSOLE r3
286
287	/* Write 32-bits backwards, byte-to-byte. */
288	LOAD_IMMEDIATE r6, buffer2
289
290	LOAD_IMMEDIATE r10, 0xB1
291	LOAD_IMMEDIATE r11, 0xB2
292	LOAD_IMMEDIATE r12, 0xB3
293	LOAD_IMMEDIATE r13, 0xB4
294
295	l.sb -1(r6), r10
296	l.sb -2(r6), r11
297	l.sb -3(r6), r12
298	l.sb -4(r6), r13
299
300	l.lwz r3, 0(r5)
301	REPORT_REG_TO_CONSOLE r3
302
303	/* TODO: add here test cases to cover unaligned memory accesses
304	with l.sb. */
305
306	/* Test instruction l.sh */
307
308	/* Write 32-bits forwards, one half-word at a time. */
309	LOAD_IMMEDIATE r5, buffer1
310
311	LOAD_IMMEDIATE r10, 0x8182
312	LOAD_IMMEDIATE r11, 0x8384
313
314	l.sh 0(r5), r10
315	l.sh 2(r5), r11
316
317	l.lwz r3, 0(r5)
318	REPORT_REG_TO_CONSOLE r3
319
320	/* Write 32-bits backwards, one half-word at a time. */
321	LOAD_IMMEDIATE r6, buffer2
322
323	LOAD_IMMEDIATE r10, 0x5152
324	LOAD_IMMEDIATE r11, 0x5354
325
326	l.sh -2(r6), r10
327	l.sh -4(r6), r11
328
329	l.lwz r3, 0(r5)
330	REPORT_REG_TO_CONSOLE r3
331
332	/* TODO: add here test cases to cover unaligned memory accesses
333	with l.sh. */
334
335	/* Test instruction l.sw */
336	LOAD_IMMEDIATE r5, buffer1
337	LOAD_IMMEDIATE r6, buffer5
338
339	LOAD_IMMEDIATE r10, 0xA0B0C0D0
340	LOAD_IMMEDIATE r11, 0xA1B1C1D1
341	LOAD_IMMEDIATE r12, 0xA2B2C2D2
342	LOAD_IMMEDIATE r13, 0xA3B3C3D3
343
344	l.sw 0(r5), r10
345	l.sw 4(r5), r11
346	l.sw -4(r6), r12
347	l.sw -8(r6), r13
348
349	TEST_LW l.lwz buffer1, 0
350	TEST_LW l.lwz buffer2, 0
351	TEST_LW l.lwz buffer3, 0
352	TEST_LW l.lwz buffer4, 0
353
354	/* TODO: add here test cases to cover unaligned memory accesses
355	with l.sw. */
356
357	POP LINK_REGISTER_R9
358	RETURN_TO_LINK_REGISTER_R9