3 // Enough stack to store every register in case a trap handler is executed,
4 // plus 33 more values.
5 #define STACK_SIZE (64 * XLEN / 8)
29 // If misa doesn't exist (or is following an old spec where it has a
30 // different number), skip the next block.
35 // make sure these registers exist by seeing if either S or U bits
36 // are set before attempting to zero them out.
39 slli t2, t2, 20 // U_EXTENSION
43 slli t2, t2, 18 // S_EXTENSION
57 # initialize global pointer
60 la gp, __global_pointer$
63 # Initialize stack pointer.
64 # Give each hart STACK_SIZE of stack.
65 # Assume hart IDs are contiguous and start at 0.
73 # Clear all hardware triggers
84 bnez t0, wait_until_initialized
100 wait_until_initialized: # Wait for hart 0 to perform initialization.
107 # perform the rest of initialization in C
112 addi sp, sp, -32*REGBYTES
114 SREG x1, 1*REGBYTES(sp)
115 SREG x2, 2*REGBYTES(sp)
116 SREG x3, 3*REGBYTES(sp)
117 SREG x4, 4*REGBYTES(sp)
118 SREG x5, 5*REGBYTES(sp)
119 SREG x6, 6*REGBYTES(sp)
120 SREG x7, 7*REGBYTES(sp)
121 SREG x8, 8*REGBYTES(sp)
122 SREG x9, 9*REGBYTES(sp)
123 SREG x10, 10*REGBYTES(sp)
124 SREG x11, 11*REGBYTES(sp)
125 SREG x12, 12*REGBYTES(sp)
126 SREG x13, 13*REGBYTES(sp)
127 SREG x14, 14*REGBYTES(sp)
128 SREG x15, 15*REGBYTES(sp)
129 SREG x16, 16*REGBYTES(sp)
130 SREG x17, 17*REGBYTES(sp)
131 SREG x18, 18*REGBYTES(sp)
132 SREG x19, 19*REGBYTES(sp)
133 SREG x20, 20*REGBYTES(sp)
134 SREG x21, 21*REGBYTES(sp)
135 SREG x22, 22*REGBYTES(sp)
136 SREG x23, 23*REGBYTES(sp)
137 SREG x24, 24*REGBYTES(sp)
138 SREG x25, 25*REGBYTES(sp)
139 SREG x26, 26*REGBYTES(sp)
140 SREG x27, 27*REGBYTES(sp)
141 SREG x28, 28*REGBYTES(sp)
142 SREG x29, 29*REGBYTES(sp)
143 SREG x30, 30*REGBYTES(sp)
144 SREG x31, 31*REGBYTES(sp)
152 # Remain in M-mode after mret
156 LREG x1, 1*REGBYTES(sp)
157 LREG x2, 2*REGBYTES(sp)
158 LREG x3, 3*REGBYTES(sp)
159 LREG x4, 4*REGBYTES(sp)
160 LREG x5, 5*REGBYTES(sp)
161 LREG x6, 6*REGBYTES(sp)
162 LREG x7, 7*REGBYTES(sp)
163 LREG x8, 8*REGBYTES(sp)
164 LREG x9, 9*REGBYTES(sp)
165 LREG x10, 10*REGBYTES(sp)
166 LREG x11, 11*REGBYTES(sp)
167 LREG x12, 12*REGBYTES(sp)
168 LREG x13, 13*REGBYTES(sp)
169 LREG x14, 14*REGBYTES(sp)
170 LREG x15, 15*REGBYTES(sp)
171 LREG x16, 16*REGBYTES(sp)
172 LREG x17, 17*REGBYTES(sp)
173 LREG x18, 18*REGBYTES(sp)
174 LREG x19, 19*REGBYTES(sp)
175 LREG x20, 20*REGBYTES(sp)
176 LREG x21, 21*REGBYTES(sp)
177 LREG x22, 22*REGBYTES(sp)
178 LREG x23, 23*REGBYTES(sp)
179 LREG x24, 24*REGBYTES(sp)
180 LREG x25, 25*REGBYTES(sp)
181 LREG x26, 26*REGBYTES(sp)
182 LREG x27, 27*REGBYTES(sp)
183 LREG x28, 28*REGBYTES(sp)
184 LREG x29, 29*REGBYTES(sp)
185 LREG x30, 30*REGBYTES(sp)
186 LREG x31, 31*REGBYTES(sp)
188 addi sp, sp, 32*REGBYTES
194 // Fill the stack with data so we can see if it was overrun.
197 .fill NHARTS * STACK_SIZE/4, 4, 0x22446688