Print this page
de-linting of .s files
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/sun4u/ml/mach_xc.s
+++ new/usr/src/uts/sun4u/ml/mach_xc.s
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 -#if defined(lint)
27 -#include <sys/types.h>
28 -#include <sys/cpuvar.h>
29 -#else /*lint */
30 26 #include "assym.h"
31 -#endif /* lint */
32 27
33 28 #include <sys/asm_linkage.h>
34 29 #include <sys/privregs.h>
35 30 #include <sys/x_call.h>
36 31 #include <sys/xc_impl.h>
37 32
38 33 #ifdef TRAPTRACE
39 34 #include <sys/traptrace.h>
40 35 #endif /* TRAPTRACE */
41 36
42 37
43 -#if defined(lint)
44 -
45 -/* ARGSUSED */
46 -void
47 -self_xcall(struct cpu *cpu, uint64_t arg1, uint64_t arg2, xcfunc_t *func)
48 -{}
49 -
50 -#else
51 -
52 38 /*
53 39 * Entered by the software trap (TT=ST_SELFXCALL, TL>0) thru send_self_xcall().
54 40 * Emulate the mondo handler - vec_interrupt().
55 41 *
56 42 * Global registers are the Alternate Globals.
57 43 * Arguments:
58 44 * %o0 - CPU
59 45 * ILP32 kernel:
60 46 * %o5 - function to call
61 47 * %o1, %o2, %o3, %o4 - arguments
62 48 * LP64 kernel:
63 49 * %o3 - function to call
64 50 * %o1, %o2 - arguments
65 51 */
66 52 ENTRY_NP(self_xcall)
67 53 !
68 54 ! TL>0 handlers are expected to do "retry"
69 55 ! prepare their return PC and nPC now
70 56 !
71 57 rdpr %tnpc, %g1
72 58 wrpr %g1, %tpc ! PC <- TNPC[TL]
73 59 add %g1, 4, %g1
74 60 wrpr %g1, %tnpc ! nPC <- TNPC[TL] + 4
75 61
76 62 #ifdef TRAPTRACE
77 63 TRACE_PTR(%g4, %g6)
78 64 GET_TRACE_TICK(%g6, %g3)
79 65 stxa %g6, [%g4 + TRAP_ENT_TICK]%asi
80 66 rdpr %tl, %g6
81 67 stha %g6, [%g4 + TRAP_ENT_TL]%asi
82 68 rdpr %tt, %g6
83 69 stha %g6, [%g4 + TRAP_ENT_TT]%asi
84 70 stna %o3, [%g4 + TRAP_ENT_TR]%asi ! pc of the TL>0 handler
85 71 rdpr %tpc, %g6
86 72 stna %g6, [%g4 + TRAP_ENT_TPC]%asi
87 73 rdpr %tstate, %g6
88 74 stxa %g6, [%g4 + TRAP_ENT_TSTATE]%asi
89 75 stna %sp, [%g4 + TRAP_ENT_SP]%asi
90 76 stna %o1, [%g4 + TRAP_ENT_F1]%asi ! arg 1
91 77 stna %o2, [%g4 + TRAP_ENT_F2]%asi ! arg 2
92 78 stna %g0, [%g4 + TRAP_ENT_F3]%asi
93 79 stna %g0, [%g4 + TRAP_ENT_F4]%asi
94 80 TRACE_NEXT(%g4, %g6, %g3)
|
↓ open down ↓ |
33 lines elided |
↑ open up ↑ |
95 81 #endif /* TRAPTRACE */
96 82 !
97 83 ! Load the arguments for the fast trap handler.
98 84 !
99 85 mov %o1, %g1
100 86 jmp %o3 ! call the fast trap handler
101 87 mov %o2, %g2
102 88 /* Not Reached */
103 89 SET_SIZE(self_xcall)
104 90
105 -#endif /* lint */
106 -
107 91 #ifdef TRAPTRACE
108 -#if defined(lint)
109 -
110 -/* ARGSUSED */
111 -void
112 -xc_trace(u_int traptype, cpuset_t *cpu_set, xcfunc_t *func,
113 - uint64_t arg1, uint64_t arg2)
114 -{}
115 -
116 -#else /* lint */
117 92 ENTRY(xc_trace)
118 93 rdpr %pstate, %g1
119 94 andn %g1, PSTATE_IE | PSTATE_AM, %g2
120 95 wrpr %g0, %g2, %pstate /* disable interrupts */
121 96 TRACE_PTR(%g3, %g4)
122 97 GET_TRACE_TICK(%g6, %g4)
123 98 stxa %g6, [%g3 + TRAP_ENT_TICK]%asi
124 99 stha %g0, [%g3 + TRAP_ENT_TL]%asi
125 100 set TT_XCALL, %g2
126 101 or %o0, %g2, %g4
127 102 stha %g4, [%g3 + TRAP_ENT_TT]%asi
128 103 stna %o7, [%g3 + TRAP_ENT_TPC]%asi
129 104 ldn [%o1], %g2
130 105 stna %g2, [%g3 + TRAP_ENT_SP]%asi /* sp = cpuset */
131 106 stna %o2, [%g3 + TRAP_ENT_TR]%asi /* tr = func */
132 107 stna %o3, [%g3 + TRAP_ENT_F1]%asi /* f1 = arg1 */
133 108 stna %o4, [%g3 + TRAP_ENT_F2]%asi /* f2 = arg2 */
134 109 stna %g0, [%g3 + TRAP_ENT_F3]%asi /* f3 = 0 */
135 110 stna %i7, [%g3 + TRAP_ENT_F4]%asi /* f4 = xcall caller */
136 111 stxa %g1, [%g3 + TRAP_ENT_TSTATE]%asi /* tstate = pstate */
137 112 TRACE_NEXT(%g2, %g3, %g4)
138 113 /*
139 114 * In the case of a cpuset of greater size than a long we
140 115 * grab extra trace buffers just to store the cpuset.
141 116 * Seems like a waste but popular opinion opted for this
142 117 * rather than increase the size of the buffer.
143 118 */
144 119 #if CPUSET_SIZE > CLONGSIZE
145 120 add %o1, CPUSET_SIZE, %g5 /* end of cpuset */
146 121 clr %o2
147 122 1:
148 123 TRACE_PTR(%g3, %g4)
149 124 stha %g0, [%g3 + TRAP_ENT_TL]%asi
150 125 set TT_XCALL_CONT, %g2
151 126 or %g2, %o2, %g2 /* continuation # */
152 127 stha %g2, [%g3 + TRAP_ENT_TT]%asi
153 128 stxa %g6, [%g3 + TRAP_ENT_TICK]%asi /* same tick */
154 129 stna %g0, [%g3 + TRAP_ENT_TPC]%asi /* clr unused fields */
155 130 stna %g0, [%g3 + TRAP_ENT_SP]%asi
156 131 stna %g0, [%g3 + TRAP_ENT_TR]%asi
157 132 stxa %g0, [%g3 + TRAP_ENT_TSTATE]%asi
158 133 stna %g0, [%g3 + TRAP_ENT_F2]%asi
159 134 stna %g0, [%g3 + TRAP_ENT_F3]%asi
160 135 stna %g0, [%g3 + TRAP_ENT_F4]%asi
161 136 ldn [%o1], %g2
162 137 stna %g2, [%g3 + TRAP_ENT_F1]%asi
163 138 add %o1, CLONGSIZE, %o1
164 139 cmp %o1, %g5
165 140 bge 2f
166 141 ldn [%o1], %g2
167 142 stna %g2, [%g3 + TRAP_ENT_F2]%asi
168 143 add %o1, CLONGSIZE, %o1
169 144 cmp %o1, %g5
170 145 bge 2f
171 146 ldn [%o1], %g2
172 147 stna %g2, [%g3 + TRAP_ENT_F3]%asi
173 148 add %o1, CLONGSIZE, %o1
174 149 cmp %o1, %g5
175 150 bge 2f
176 151 ldn [%o1], %g2
177 152 stna %g2, [%g3 + TRAP_ENT_F4]%asi
178 153 add %o1, CLONGSIZE, %o1
|
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
179 154 2:
180 155 TRACE_NEXT(%g2, %g3, %g4)
181 156 cmp %o1, %g5
182 157 bl 1b
183 158 inc %o2
184 159 #endif /* CPUSET_SIZE */
185 160 retl
186 161 wrpr %g0, %g1, %pstate /* enable interrupts */
187 162 SET_SIZE(xc_trace)
188 163
189 -#endif /* lint */
190 164 #endif /* TRAPTRACE */
191 165
192 -#if defined(lint)
193 -
194 -/* ARGSUSED */
195 -void
196 -xt_sync_tl1(uint64_t *cpu_sync_addr)
197 -{}
198 -
199 -#else
200 166 /*
201 167 * This dummy tl1 function is there to ensure that previously called
202 168 * xtrap handlers have exececuted. The hardware (mondo dispatch
203 169 * mechanism) is such that return from xtrap doesn't guarantee execution
204 170 * of xtrap handler. So, callers can call this xtrap-handler to ensure
205 171 * that the previous one is complete. This is because the hardware only
206 172 * can handle 1 mondo at a time - when this mondo is handled, we are sure
207 173 * that the mondo for the previous xtrap must have been handled.
208 174 */
209 175 ENTRY_NP(xt_sync_tl1)
210 176 retry
211 177 SET_SIZE(xt_sync_tl1)
212 178
213 -#endif /* lint */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX