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

Subversion Repositories fwrisc

[/] [fwrisc/] [trunk/] [ve/] [fwrisc/] [tests/] [riscv-compliance/] [riscv-test-suite/] [rv32i/] [src/] [I-IO.S] - Blame information for rev 2

Details | Compare with Previous | View Log


# RISC-V Compliance Test I-IO-01
#
# Additions Copyright (c) 2005-2018 Imperas Software Ltd., www.imperas.com
#
# Copyright (c) 2017, Codasip Ltd.
# Copyright (c) 2018, Imperas Software Ltd. Additions
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#      * Redistributions of source code must retain the above copyright
#        notice, this list of conditions and the following disclaimer.
#      * Redistributions in binary form must reproduce the above copyright
#        notice, this list of conditions and the following disclaimer in the
#        documentation and/or other materials provided with the distribution.
#      * Neither the name of the Codasip Ltd., Imperas Software Ltd. nor the
#        names of its contributors may be used to endorse or promote products
#        derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Codasip Ltd., Imperas Software Ltd.
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Specification: RV32I Base Integer Instruction Set, Version 2.0
# Description: Testing instruction IO-S.
 
 
#include "compliance_test.h"
#include "compliance_io.h"
#include "test_macros.h"
 
# Test Virtual Machine (TVM) used by program.
RV_COMPLIANCE_RV32M
 
# Test code region.
RV_COMPLIANCE_CODE_BEGIN
 
    RVTEST_IO_INIT
    RVTEST_IO_ASSERT_GPR_EQ(x0, 0x00000000)
    RVTEST_IO_WRITE_STR("# Test Begin Reserved regs ra(x1) a0(x10) t0(x5)\n")
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part A1 - general test of value 0 with 0, 1, -1, MIN, MAX register values\n");
 
    # Addresses for test data and results
    la      x1, test_A1_data
    la      x2, test_A1_res
 
    # Load testdata
    lw      x3, 0(x1)
 
    # Register initialization
    li      x4, 0
    li      x5, 1
    li      x6, -1
    li      x7, 0x7FFFFFFF
    li      x8, 0x80000000
 
    # Test
    add     x4, x3, x4
    add     x5, x3, x5
    add     x6, x3, x6
    add     x7, x3, x7
    add     x8, x3, x8
 
    # Store results
    sw      x3, 0(x2)
    sw      x4, 4(x2)
    sw      x5, 8(x2)
    sw      x6, 12(x2)
    sw      x7, 16(x2)
    sw      x8, 20(x2)
 
    //
    // Assert
    //
    RVTEST_IO_CHECK()
    RVTEST_IO_ASSERT_GPR_EQ(x3, 0x00000000)
    RVTEST_IO_ASSERT_GPR_EQ(x4, 0x00000000)
    RVTEST_IO_ASSERT_GPR_EQ(x5, 0x00000000)
    RVTEST_IO_ASSERT_GPR_EQ(x6, 0xFFFFFFFF)
    RVTEST_IO_ASSERT_GPR_EQ(x7, 0x7FFFFFFF)
    RVTEST_IO_ASSERT_GPR_EQ(x8, 0x80000000)
    RVTEST_IO_WRITE_STR("# Test part A1 - Complete\n");
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part A2 - general test of value 1 with 0, 1, -1, MIN, MAX register values\n");
 
    # Addresses for test data and results
    la      x1, test_A2_data
    la      x2, test_A2_res
 
    # Load testdata
    lw      x8, 0(x1)
 
    # Register initialization
    li      x9, 0
    li      x10, 1
    li      x11, -1
    li      x12, 0x7FFFFFFF
    li      x13, 0x80000000
 
    # Test
    add     x9, x8, x9
    add     x10, x8, x10
    add     x11, x8, x11
    add     x12, x8, x12
    add     x13, x8, x13
 
    # Store results
    sw      x8, 0(x2)
    sw      x9, 4(x2)
    sw      x10, 8(x2)
    sw      x11, 12(x2)
    sw      x12, 16(x2)
    sw      x13, 20(x2)
 
    RVTEST_IO_ASSERT_GPR_EQ(x8,  0x00000001)
    RVTEST_IO_ASSERT_GPR_EQ(x9,  0x00000001)
  //RVTEST_IO_ASSERT_GPR_EQ(x10, 0x00000000)
    RVTEST_IO_ASSERT_GPR_EQ(x11, 0x00000000)
    RVTEST_IO_ASSERT_GPR_EQ(x12, 0x80000000)
    RVTEST_IO_ASSERT_GPR_EQ(x13, 0x80000001)
    RVTEST_IO_WRITE_STR("# Test part A2 - Complete\n");
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part A3 - general test of value -1 with 0, 1, -1, MIN, MAX register values\n");
 
    # Addresses for test data and results
    la      x1, test_A3_data
    la      x2, test_A3_res
 
    # Load testdata
    lw      x13, 0(x1)
 
    # Register initialization
    li      x14, 0
    li      x15, 1
    li      x16, -1
    li      x17, 0x7FFFFFFF
    li      x18, 0x80000000
 
    # Test
    add     x14, x13, x14
    add     x15, x13, x15
    add     x16, x13, x16
    add     x17, x13, x17
    add     x18, x13, x18
 
    # Store results
    sw      x13, 0(x2)
    sw      x14, 4(x2)
    sw      x15, 8(x2)
    sw      x16, 12(x2)
    sw      x17, 16(x2)
    sw      x18, 20(x2)
 
    RVTEST_IO_ASSERT_GPR_EQ(x13, 0xFFFFFFFF)
    RVTEST_IO_ASSERT_GPR_EQ(x14, 0xFFFFFFFF)
    RVTEST_IO_ASSERT_GPR_EQ(x15, 0x00000000)
    RVTEST_IO_ASSERT_GPR_EQ(x16, 0xFFFFFFFE)
    RVTEST_IO_ASSERT_GPR_EQ(x17, 0x7FFFFFFE)
    RVTEST_IO_ASSERT_GPR_EQ(x18, 0x7FFFFFFF)
    RVTEST_IO_WRITE_STR("# Test part A3 - Complete\n");
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part A4 - general test of value 0x7FFFFFFF with 0, 1, -1, MIN, MAX register values\n");
 
    # Addresses for test data and results
    la      x1, test_A4_data
    la      x2, test_A4_res
 
    # Load testdata
    lw      x18, 0(x1)
 
    # Register initialization
    li      x19, 0
    li      x20, 1
    li      x21, -1
    li      x22, 0x7FFFFFFF
    li      x23, 0x80000000
 
    # Test execution
    add     x19, x18, x19
    add     x20, x18, x20
    add     x21, x18, x21
    add     x22, x18, x22
    add     x23, x18, x23
 
    # Store results
    sw      x18, 0(x2)
    sw      x19, 4(x2)
    sw      x20, 8(x2)
    sw      x21, 12(x2)
    sw      x22, 16(x2)
    sw      x23, 20(x2)
 
    RVTEST_IO_ASSERT_GPR_EQ(x18, 0x7FFFFFFF)
    RVTEST_IO_ASSERT_GPR_EQ(x19, 0x7FFFFFFF)
    RVTEST_IO_ASSERT_GPR_EQ(x20, 0x80000000)
    RVTEST_IO_ASSERT_GPR_EQ(x21, 0x7FFFFFFE)
    RVTEST_IO_ASSERT_GPR_EQ(x22, 0xFFFFFFFE)
    RVTEST_IO_ASSERT_GPR_EQ(x23, 0xFFFFFFFF)
    RVTEST_IO_WRITE_STR("# Test part A4 - Complete\n");
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part A5 - general test of value 0x80000000 with 0, 1, -1, MIN, MAX register values\n");
 
    # Addresses for test data and results
    la      x1, test_A5_data
    la      x2, test_A5_res
 
    # Load testdata
    lw      x23, 0(x1)
 
    # Register initialization
    li      x24, 0
    li      x25, 1
    li      x26, -1
    li      x27, 0x7FFFFFFF
    li      x28, 0x80000000
 
    # Test
    add     x24, x23, x24
    add     x25, x23, x25
    add     x26, x23, x26
    add     x27, x23, x27
    add     x28, x23, x28
 
    # Store results
    sw      x23, 0(x2)
    sw      x24, 4(x2)
    sw      x25, 8(x2)
    sw      x26, 12(x2)
    sw      x27, 16(x2)
    sw      x28, 20(x2)
 
    RVTEST_IO_ASSERT_GPR_EQ(x23, 0x80000000)
    RVTEST_IO_ASSERT_GPR_EQ(x24, 0x80000000)
    RVTEST_IO_ASSERT_GPR_EQ(x25, 0x80000001)
    RVTEST_IO_ASSERT_GPR_EQ(x26, 0x7FFFFFFF)
    RVTEST_IO_ASSERT_GPR_EQ(x27, 0xFFFFFFFF)
    RVTEST_IO_ASSERT_GPR_EQ(x28, 0x00000000)
    RVTEST_IO_WRITE_STR("# Test part A5 - Complete\n");
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part B - testing forwarding between instructions\n");
 
    # Addresses for test data and results
    la      x25, test_B_data
    la      x26, test_B_res
 
    # Load testdata
    lw      x28, 0(x25)
 
    # Register initialization
    li      x27, 0x1
 
    # Test
    add     x29, x28, x27
    add     x30, x29, x27
    add     x31, x30, x27
    add     x1, x31, x27
    add     x2, x1, x27
    add     x3, x2, x27
 
    # store results
    sw      x27, 0(x26)
    sw      x28, 4(x26)
    sw      x29, 8(x26)
    sw      x30, 12(x26)
    sw      x31, 16(x26)
    sw      x1, 20(x26)
    sw      x2, 24(x26)
    sw      x3, 28(x26)
 
    RVTEST_IO_ASSERT_GPR_EQ(x27, 0x00000001)
    RVTEST_IO_ASSERT_GPR_EQ(x28, 0x0000ABCD)
    RVTEST_IO_ASSERT_GPR_EQ(x29, 0x0000ABCE)
    RVTEST_IO_ASSERT_GPR_EQ(x30, 0x0000ABCF)
    RVTEST_IO_ASSERT_GPR_EQ(x31, 0x0000ABD0)
    RVTEST_IO_ASSERT_GPR_EQ(x1,  0x0000ABD1)
    RVTEST_IO_ASSERT_GPR_EQ(x2,  0x0000ABD2)
    RVTEST_IO_ASSERT_GPR_EQ(x3,  0x0000ABD3)
    RVTEST_IO_WRITE_STR("# Test part B - Complete\n");
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part C - testing writing to x0\n");
 
    # Addresses for test data and results
    la      x1, test_C_data
    la      x2, test_C_res
 
    # Load testdata
    lw      x28, 0(x1)
 
    # Register initialization
    li      x27, 0xF7FF8818
 
    # Test
    add     x0, x28, x27
 
    # store results
    sw      x0, 0(x2)
 
    RVTEST_IO_ASSERT_GPR_EQ(x0,  0x00000000)
    RVTEST_IO_WRITE_STR("# Test part C - Complete\n");
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part D - testing forwarding throught x0\n");
 
    # Addresses for test data and results
    la      x1, test_D_data
    la      x2, test_D_res
 
    # Load testdata
    lw      x28, 0(x1)
 
    # Register initialization
    li      x27, 0xF7FF8818
 
    # Test
    add     x0, x28, x27
    add     x5, x0, x0
 
    # store results
    sw      x0, 0(x2)
    sw      x5, 4(x2)
 
    RVTEST_IO_ASSERT_GPR_EQ(x0,  0x00000000)
  //RVTEST_IO_ASSERT_GPR_EQ(x5,  0x00000000)
    RVTEST_IO_WRITE_STR("# Test part D - Complete\n");
 
    # ---------------------------------------------------------------------------------------------
    RVTEST_IO_WRITE_STR("# Test part E - testing moving (add with x0)\n");
 
    # Addresses for test data and results
    la      x1, test_E_data
    la      x2, test_E_res
 
    # Load testdata
    lw      x3, 0(x1)
 
    # Test
    add     x4, x3, x0
    add     x5, x4, x0
    add     x6, x0, x5
    add     x14, x6, x0
    add     x15, x14, x0
    add     x16, x15, x0
    add     x25, x0, x16
    add     x26, x0, x25
    add     x27, x26, x0
 
    # Store results
    sw      x4, 0(x2)
    sw      x26, 4(x2)
    sw      x27, 8(x2)
 
    RVTEST_IO_ASSERT_GPR_EQ(x4,  0x36925814)
    RVTEST_IO_ASSERT_GPR_EQ(x26, 0x36925814)
    RVTEST_IO_ASSERT_GPR_EQ(x27, 0x36925814)
    RVTEST_IO_WRITE_STR("# Test part E - Complete\n");
 
    RVTEST_IO_WRITE_STR("# Test End\n")
 
    # ---------------------------------------------------------------------------------------------
    # HALT
    RV_COMPLIANCE_HALT
 
RV_COMPLIANCE_CODE_END
 
# Input data section.
    .data
 
test_A1_data:
    .word 0
test_A2_data:
    .word 1
test_A3_data:
    .word -1
test_A4_data:
    .word 0x7FFFFFFF
test_A5_data:
    .word 0x80000000
test_B_data:
    .word 0x0000ABCD
test_C_data:
    .word 0x12345678
test_D_data:
    .word 0xFEDCBA98
test_E_data:
    .word 0x36925814
 
# Output data section.
RV_COMPLIANCE_DATA_BEGIN
 
test_A1_res:
    .fill 6, 4, -1
test_A2_res:
    .fill 6, 4, -1
test_A3_res:
    .fill 6, 4, -1
test_A4_res:
    .fill 6, 4, -1
test_A5_res:
    .fill 6, 4, -1
test_B_res:
    .fill 8, 4, -1
test_C_res:
    .fill 1, 4, -1
test_D_res:
    .fill 2, 4, -1
test_E_res:
    .fill 3, 4, -1
 
RV_COMPLIANCE_DATA_END

Browse

Tools

Subversion Repositories fwrisc

[/] [fwrisc/] [trunk/] [ve/] [fwrisc/] [tests/] [riscv-compliance/] [riscv-test-suite/] [rv32i/] [src/] [I-IO.S] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	mballance	`# RISC-V Compliance Test I-IO-01`
2			`#`
3			`# Additions Copyright (c) 2005-2018 Imperas Software Ltd., www.imperas.com`
4			`#`
5			`# Copyright (c) 2017, Codasip Ltd.`
6			`# Copyright (c) 2018, Imperas Software Ltd. Additions`
7			`# All rights reserved.`
8			`#`
9			`# Redistribution and use in source and binary forms, with or without`
10			`# modification, are permitted provided that the following conditions are met:`
11			`# * Redistributions of source code must retain the above copyright`
12			`# notice, this list of conditions and the following disclaimer.`
13			`# * Redistributions in binary form must reproduce the above copyright`
14			`# notice, this list of conditions and the following disclaimer in the`
15			`# documentation and/or other materials provided with the distribution.`
16			`# * Neither the name of the Codasip Ltd., Imperas Software Ltd. nor the`
17			`# names of its contributors may be used to endorse or promote products`
18			`# derived from this software without specific prior written permission.`
19			`#`
20			`# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS`
21			`# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,`
22			`# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR`
23			`# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Codasip Ltd., Imperas Software Ltd.`
24			`# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL`
25			`# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;`
26			`# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND`
27			`# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT`
28			`# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF`
29			`# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`
30			`#`
31			`# Specification: RV32I Base Integer Instruction Set, Version 2.0`
32			`# Description: Testing instruction IO-S.`
33
34
35			`#include "compliance_test.h"`
36			`#include "compliance_io.h"`
37			`#include "test_macros.h"`
38
39			`# Test Virtual Machine (TVM) used by program.`
40			`RV_COMPLIANCE_RV32M`
41
42			`# Test code region.`
43			`RV_COMPLIANCE_CODE_BEGIN`
44
45			`RVTEST_IO_INIT`
46			`RVTEST_IO_ASSERT_GPR_EQ(x0, 0x00000000)`
47			`RVTEST_IO_WRITE_STR("# Test Begin Reserved regs ra(x1) a0(x10) t0(x5)\n")`
48
49			`# ---------------------------------------------------------------------------------------------`
50			`RVTEST_IO_WRITE_STR("# Test part A1 - general test of value 0 with 0, 1, -1, MIN, MAX register values\n");`
51
52			`# Addresses for test data and results`
53			`la x1, test_A1_data`
54			`la x2, test_A1_res`
55
56			`# Load testdata`
57			`lw x3, 0(x1)`
58
59			`# Register initialization`
60			`li x4, 0`
61			`li x5, 1`
62			`li x6, -1`
63			`li x7, 0x7FFFFFFF`
64			`li x8, 0x80000000`
65
66			`# Test`
67			`add x4, x3, x4`
68			`add x5, x3, x5`
69			`add x6, x3, x6`
70			`add x7, x3, x7`
71			`add x8, x3, x8`
72
73			`# Store results`
74			`sw x3, 0(x2)`
75			`sw x4, 4(x2)`
76			`sw x5, 8(x2)`
77			`sw x6, 12(x2)`
78			`sw x7, 16(x2)`
79			`sw x8, 20(x2)`
80
81			`//`
82			`// Assert`
83			`//`
84			`RVTEST_IO_CHECK()`
85			`RVTEST_IO_ASSERT_GPR_EQ(x3, 0x00000000)`
86			`RVTEST_IO_ASSERT_GPR_EQ(x4, 0x00000000)`
87			`RVTEST_IO_ASSERT_GPR_EQ(x5, 0x00000000)`
88			`RVTEST_IO_ASSERT_GPR_EQ(x6, 0xFFFFFFFF)`
89			`RVTEST_IO_ASSERT_GPR_EQ(x7, 0x7FFFFFFF)`
90			`RVTEST_IO_ASSERT_GPR_EQ(x8, 0x80000000)`
91			`RVTEST_IO_WRITE_STR("# Test part A1 - Complete\n");`
92
93			`# ---------------------------------------------------------------------------------------------`
94			`RVTEST_IO_WRITE_STR("# Test part A2 - general test of value 1 with 0, 1, -1, MIN, MAX register values\n");`
95
96			`# Addresses for test data and results`
97			`la x1, test_A2_data`
98			`la x2, test_A2_res`
99
100			`# Load testdata`
101			`lw x8, 0(x1)`
102
103			`# Register initialization`
104			`li x9, 0`
105			`li x10, 1`
106			`li x11, -1`
107			`li x12, 0x7FFFFFFF`
108			`li x13, 0x80000000`
109
110			`# Test`
111			`add x9, x8, x9`
112			`add x10, x8, x10`
113			`add x11, x8, x11`
114			`add x12, x8, x12`
115			`add x13, x8, x13`
116
117			`# Store results`
118			`sw x8, 0(x2)`
119			`sw x9, 4(x2)`
120			`sw x10, 8(x2)`
121			`sw x11, 12(x2)`
122			`sw x12, 16(x2)`
123			`sw x13, 20(x2)`
124
125			`RVTEST_IO_ASSERT_GPR_EQ(x8, 0x00000001)`
126			`RVTEST_IO_ASSERT_GPR_EQ(x9, 0x00000001)`
127			`//RVTEST_IO_ASSERT_GPR_EQ(x10, 0x00000000)`
128			`RVTEST_IO_ASSERT_GPR_EQ(x11, 0x00000000)`
129			`RVTEST_IO_ASSERT_GPR_EQ(x12, 0x80000000)`
130			`RVTEST_IO_ASSERT_GPR_EQ(x13, 0x80000001)`
131			`RVTEST_IO_WRITE_STR("# Test part A2 - Complete\n");`
132
133			`# ---------------------------------------------------------------------------------------------`
134			`RVTEST_IO_WRITE_STR("# Test part A3 - general test of value -1 with 0, 1, -1, MIN, MAX register values\n");`
135
136			`# Addresses for test data and results`
137			`la x1, test_A3_data`
138			`la x2, test_A3_res`
139
140			`# Load testdata`
141			`lw x13, 0(x1)`
142
143			`# Register initialization`
144			`li x14, 0`
145			`li x15, 1`
146			`li x16, -1`
147			`li x17, 0x7FFFFFFF`
148			`li x18, 0x80000000`
149
150			`# Test`
151			`add x14, x13, x14`
152			`add x15, x13, x15`
153			`add x16, x13, x16`
154			`add x17, x13, x17`
155			`add x18, x13, x18`
156
157			`# Store results`
158			`sw x13, 0(x2)`
159			`sw x14, 4(x2)`
160			`sw x15, 8(x2)`
161			`sw x16, 12(x2)`
162			`sw x17, 16(x2)`
163			`sw x18, 20(x2)`
164
165			`RVTEST_IO_ASSERT_GPR_EQ(x13, 0xFFFFFFFF)`
166			`RVTEST_IO_ASSERT_GPR_EQ(x14, 0xFFFFFFFF)`
167			`RVTEST_IO_ASSERT_GPR_EQ(x15, 0x00000000)`
168			`RVTEST_IO_ASSERT_GPR_EQ(x16, 0xFFFFFFFE)`
169			`RVTEST_IO_ASSERT_GPR_EQ(x17, 0x7FFFFFFE)`
170			`RVTEST_IO_ASSERT_GPR_EQ(x18, 0x7FFFFFFF)`
171			`RVTEST_IO_WRITE_STR("# Test part A3 - Complete\n");`
172
173			`# ---------------------------------------------------------------------------------------------`
174			`RVTEST_IO_WRITE_STR("# Test part A4 - general test of value 0x7FFFFFFF with 0, 1, -1, MIN, MAX register values\n");`
175
176			`# Addresses for test data and results`
177			`la x1, test_A4_data`
178			`la x2, test_A4_res`
179
180			`# Load testdata`
181			`lw x18, 0(x1)`
182
183			`# Register initialization`
184			`li x19, 0`
185			`li x20, 1`
186			`li x21, -1`
187			`li x22, 0x7FFFFFFF`
188			`li x23, 0x80000000`
189
190			`# Test execution`
191			`add x19, x18, x19`
192			`add x20, x18, x20`
193			`add x21, x18, x21`
194			`add x22, x18, x22`
195			`add x23, x18, x23`
196
197			`# Store results`
198			`sw x18, 0(x2)`
199			`sw x19, 4(x2)`
200			`sw x20, 8(x2)`
201			`sw x21, 12(x2)`
202			`sw x22, 16(x2)`
203			`sw x23, 20(x2)`
204
205			`RVTEST_IO_ASSERT_GPR_EQ(x18, 0x7FFFFFFF)`
206			`RVTEST_IO_ASSERT_GPR_EQ(x19, 0x7FFFFFFF)`
207			`RVTEST_IO_ASSERT_GPR_EQ(x20, 0x80000000)`
208			`RVTEST_IO_ASSERT_GPR_EQ(x21, 0x7FFFFFFE)`
209			`RVTEST_IO_ASSERT_GPR_EQ(x22, 0xFFFFFFFE)`
210			`RVTEST_IO_ASSERT_GPR_EQ(x23, 0xFFFFFFFF)`
211			`RVTEST_IO_WRITE_STR("# Test part A4 - Complete\n");`
212
213			`# ---------------------------------------------------------------------------------------------`
214			`RVTEST_IO_WRITE_STR("# Test part A5 - general test of value 0x80000000 with 0, 1, -1, MIN, MAX register values\n");`
215
216			`# Addresses for test data and results`
217			`la x1, test_A5_data`
218			`la x2, test_A5_res`
219
220			`# Load testdata`
221			`lw x23, 0(x1)`
222
223			`# Register initialization`
224			`li x24, 0`
225			`li x25, 1`
226			`li x26, -1`
227			`li x27, 0x7FFFFFFF`
228			`li x28, 0x80000000`
229
230			`# Test`
231			`add x24, x23, x24`
232			`add x25, x23, x25`
233			`add x26, x23, x26`
234			`add x27, x23, x27`
235			`add x28, x23, x28`
236
237			`# Store results`
238			`sw x23, 0(x2)`
239			`sw x24, 4(x2)`
240			`sw x25, 8(x2)`
241			`sw x26, 12(x2)`
242			`sw x27, 16(x2)`
243			`sw x28, 20(x2)`
244
245			`RVTEST_IO_ASSERT_GPR_EQ(x23, 0x80000000)`
246			`RVTEST_IO_ASSERT_GPR_EQ(x24, 0x80000000)`
247			`RVTEST_IO_ASSERT_GPR_EQ(x25, 0x80000001)`
248			`RVTEST_IO_ASSERT_GPR_EQ(x26, 0x7FFFFFFF)`
249			`RVTEST_IO_ASSERT_GPR_EQ(x27, 0xFFFFFFFF)`
250			`RVTEST_IO_ASSERT_GPR_EQ(x28, 0x00000000)`
251			`RVTEST_IO_WRITE_STR("# Test part A5 - Complete\n");`
252
253			`# ---------------------------------------------------------------------------------------------`
254			`RVTEST_IO_WRITE_STR("# Test part B - testing forwarding between instructions\n");`
255
256			`# Addresses for test data and results`
257			`la x25, test_B_data`
258			`la x26, test_B_res`
259
260			`# Load testdata`
261			`lw x28, 0(x25)`
262
263			`# Register initialization`
264			`li x27, 0x1`
265
266			`# Test`
267			`add x29, x28, x27`
268			`add x30, x29, x27`
269			`add x31, x30, x27`
270			`add x1, x31, x27`
271			`add x2, x1, x27`
272			`add x3, x2, x27`
273
274			`# store results`
275			`sw x27, 0(x26)`
276			`sw x28, 4(x26)`
277			`sw x29, 8(x26)`
278			`sw x30, 12(x26)`
279			`sw x31, 16(x26)`
280			`sw x1, 20(x26)`
281			`sw x2, 24(x26)`
282			`sw x3, 28(x26)`
283
284			`RVTEST_IO_ASSERT_GPR_EQ(x27, 0x00000001)`
285			`RVTEST_IO_ASSERT_GPR_EQ(x28, 0x0000ABCD)`
286			`RVTEST_IO_ASSERT_GPR_EQ(x29, 0x0000ABCE)`
287			`RVTEST_IO_ASSERT_GPR_EQ(x30, 0x0000ABCF)`
288			`RVTEST_IO_ASSERT_GPR_EQ(x31, 0x0000ABD0)`
289			`RVTEST_IO_ASSERT_GPR_EQ(x1, 0x0000ABD1)`
290			`RVTEST_IO_ASSERT_GPR_EQ(x2, 0x0000ABD2)`
291			`RVTEST_IO_ASSERT_GPR_EQ(x3, 0x0000ABD3)`
292			`RVTEST_IO_WRITE_STR("# Test part B - Complete\n");`
293
294			`# ---------------------------------------------------------------------------------------------`
295			`RVTEST_IO_WRITE_STR("# Test part C - testing writing to x0\n");`
296
297			`# Addresses for test data and results`
298			`la x1, test_C_data`
299			`la x2, test_C_res`
300
301			`# Load testdata`
302			`lw x28, 0(x1)`
303
304			`# Register initialization`
305			`li x27, 0xF7FF8818`
306
307			`# Test`
308			`add x0, x28, x27`
309
310			`# store results`
311			`sw x0, 0(x2)`
312
313			`RVTEST_IO_ASSERT_GPR_EQ(x0, 0x00000000)`
314			`RVTEST_IO_WRITE_STR("# Test part C - Complete\n");`
315
316			`# ---------------------------------------------------------------------------------------------`
317			`RVTEST_IO_WRITE_STR("# Test part D - testing forwarding throught x0\n");`
318
319			`# Addresses for test data and results`
320			`la x1, test_D_data`
321			`la x2, test_D_res`
322
323			`# Load testdata`
324			`lw x28, 0(x1)`
325
326			`# Register initialization`
327			`li x27, 0xF7FF8818`
328
329			`# Test`
330			`add x0, x28, x27`
331			`add x5, x0, x0`
332
333			`# store results`
334			`sw x0, 0(x2)`
335			`sw x5, 4(x2)`
336
337			`RVTEST_IO_ASSERT_GPR_EQ(x0, 0x00000000)`
338			`//RVTEST_IO_ASSERT_GPR_EQ(x5, 0x00000000)`
339			`RVTEST_IO_WRITE_STR("# Test part D - Complete\n");`
340
341			`# ---------------------------------------------------------------------------------------------`
342			`RVTEST_IO_WRITE_STR("# Test part E - testing moving (add with x0)\n");`
343
344			`# Addresses for test data and results`
345			`la x1, test_E_data`
346			`la x2, test_E_res`
347
348			`# Load testdata`
349			`lw x3, 0(x1)`
350
351			`# Test`
352			`add x4, x3, x0`
353			`add x5, x4, x0`
354			`add x6, x0, x5`
355			`add x14, x6, x0`
356			`add x15, x14, x0`
357			`add x16, x15, x0`
358			`add x25, x0, x16`
359			`add x26, x0, x25`
360			`add x27, x26, x0`
361
362			`# Store results`
363			`sw x4, 0(x2)`
364			`sw x26, 4(x2)`
365			`sw x27, 8(x2)`
366
367			`RVTEST_IO_ASSERT_GPR_EQ(x4, 0x36925814)`
368			`RVTEST_IO_ASSERT_GPR_EQ(x26, 0x36925814)`
369			`RVTEST_IO_ASSERT_GPR_EQ(x27, 0x36925814)`
370			`RVTEST_IO_WRITE_STR("# Test part E - Complete\n");`
371
372			`RVTEST_IO_WRITE_STR("# Test End\n")`
373
374			`# ---------------------------------------------------------------------------------------------`
375			`# HALT`
376			`RV_COMPLIANCE_HALT`
377
378			`RV_COMPLIANCE_CODE_END`
379
380			`# Input data section.`
381			`.data`
382
383			`test_A1_data:`
384			`.word 0`
385			`test_A2_data:`
386			`.word 1`
387			`test_A3_data:`
388			`.word -1`
389			`test_A4_data:`
390			`.word 0x7FFFFFFF`
391			`test_A5_data:`
392			`.word 0x80000000`
393			`test_B_data:`
394			`.word 0x0000ABCD`
395			`test_C_data:`
396			`.word 0x12345678`
397			`test_D_data:`
398			`.word 0xFEDCBA98`
399			`test_E_data:`
400			`.word 0x36925814`
401
402			`# Output data section.`
403			`RV_COMPLIANCE_DATA_BEGIN`
404
405			`test_A1_res:`
406			`.fill 6, 4, -1`
407			`test_A2_res:`
408			`.fill 6, 4, -1`
409			`test_A3_res:`
410			`.fill 6, 4, -1`
411			`test_A4_res:`
412			`.fill 6, 4, -1`
413			`test_A5_res:`
414			`.fill 6, 4, -1`
415			`test_B_res:`
416			`.fill 8, 4, -1`
417			`test_C_res:`
418			`.fill 1, 4, -1`
419			`test_D_res:`
420			`.fill 2, 4, -1`
421			`test_E_res:`
422			`.fill 3, 4, -1`
423
424			`RV_COMPLIANCE_DATA_END`