m5ops.isa (9687:22e9258c06bb) m5ops.isa (10037:5cac77888310)
1//
1//
2// Copyright (c) 2010 ARM Limited
2// Copyright (c) 2010, 2012-2013 ARM Limited
3// All rights reserved
4//
5// The license below extends only to copyright in the software and shall
6// not be construed as granting a license to any other intellectual
7// property including but not limited to intellectual property relating
8// to a hardware implementation of the functionality of the software
9// licensed hereunder. You may use the software subject to the license
10// terms below provided that you ensure that this notice is replicated

--- 42 unchanged lines hidden (view full) ---

53 exec_output = '''
54 uint64_t join32to64(uint32_t r1, uint32_t r0);
55 '''
56
57
58 armCode = '''
59 PseudoInst::arm(xc->tcBase());
60 '''
3// All rights reserved
4//
5// The license below extends only to copyright in the software and shall
6// not be construed as granting a license to any other intellectual
7// property including but not limited to intellectual property relating
8// to a hardware implementation of the functionality of the software
9// licensed hereunder. You may use the software subject to the license
10// terms below provided that you ensure that this notice is replicated

--- 42 unchanged lines hidden (view full) ---

53 exec_output = '''
54 uint64_t join32to64(uint32_t r1, uint32_t r0);
55 '''
56
57
58 armCode = '''
59 PseudoInst::arm(xc->tcBase());
60 '''
61
61 armIop = InstObjParams("arm", "Arm", "PredOp",
62 { "code": armCode,
63 "predicate_test": predicateTest },
64 ["IsNonSpeculative"])
65 header_output += BasicDeclare.subst(armIop)
66 decoder_output += BasicConstructor.subst(armIop)
67 exec_output += PredOpExecute.subst(armIop)
68
69 quiesceCode = '''
70 PseudoInst::quiesce(xc->tcBase());
71 '''
62 armIop = InstObjParams("arm", "Arm", "PredOp",
63 { "code": armCode,
64 "predicate_test": predicateTest },
65 ["IsNonSpeculative"])
66 header_output += BasicDeclare.subst(armIop)
67 decoder_output += BasicConstructor.subst(armIop)
68 exec_output += PredOpExecute.subst(armIop)
69
70 quiesceCode = '''
71 PseudoInst::quiesce(xc->tcBase());
72 '''
73
72 quiesceIop = InstObjParams("quiesce", "Quiesce", "PredOp",
73 { "code": quiesceCode,
74 "predicate_test": predicateTest },
75 ["IsNonSpeculative", "IsQuiesce"])
76 header_output += BasicDeclare.subst(quiesceIop)
77 decoder_output += BasicConstructor.subst(quiesceIop)
78 exec_output += QuiescePredOpExecute.subst(quiesceIop)
79
80 quiesceNsCode = '''
81 PseudoInst::quiesceNs(xc->tcBase(), join32to64(R1, R0));
82 '''
83
74 quiesceIop = InstObjParams("quiesce", "Quiesce", "PredOp",
75 { "code": quiesceCode,
76 "predicate_test": predicateTest },
77 ["IsNonSpeculative", "IsQuiesce"])
78 header_output += BasicDeclare.subst(quiesceIop)
79 decoder_output += BasicConstructor.subst(quiesceIop)
80 exec_output += QuiescePredOpExecute.subst(quiesceIop)
81
82 quiesceNsCode = '''
83 PseudoInst::quiesceNs(xc->tcBase(), join32to64(R1, R0));
84 '''
85
86 quiesceNsCode64 = '''
87 PseudoInst::quiesceNs(xc->tcBase(), X0);
88 '''
89
84 quiesceNsIop = InstObjParams("quiesceNs", "QuiesceNs", "PredOp",
85 { "code": quiesceNsCode,
86 "predicate_test": predicateTest },
87 ["IsNonSpeculative", "IsQuiesce"])
88 header_output += BasicDeclare.subst(quiesceNsIop)
89 decoder_output += BasicConstructor.subst(quiesceNsIop)
90 exec_output += QuiescePredOpExecute.subst(quiesceNsIop)
91
90 quiesceNsIop = InstObjParams("quiesceNs", "QuiesceNs", "PredOp",
91 { "code": quiesceNsCode,
92 "predicate_test": predicateTest },
93 ["IsNonSpeculative", "IsQuiesce"])
94 header_output += BasicDeclare.subst(quiesceNsIop)
95 decoder_output += BasicConstructor.subst(quiesceNsIop)
96 exec_output += QuiescePredOpExecute.subst(quiesceNsIop)
97
98 quiesceNsIop = InstObjParams("quiesceNs", "QuiesceNs64", "PredOp",
99 { "code": quiesceNsCode64,
100 "predicate_test": predicateTest },
101 ["IsNonSpeculative", "IsQuiesce"])
102 header_output += BasicDeclare.subst(quiesceNsIop)
103 decoder_output += BasicConstructor.subst(quiesceNsIop)
104 exec_output += QuiescePredOpExecute.subst(quiesceNsIop)
105
92 quiesceCyclesCode = '''
93 PseudoInst::quiesceCycles(xc->tcBase(), join32to64(R1, R0));
94 '''
95
106 quiesceCyclesCode = '''
107 PseudoInst::quiesceCycles(xc->tcBase(), join32to64(R1, R0));
108 '''
109
110 quiesceCyclesCode64 = '''
111 PseudoInst::quiesceCycles(xc->tcBase(), X0);
112 '''
113
96 quiesceCyclesIop = InstObjParams("quiesceCycles", "QuiesceCycles", "PredOp",
97 { "code": quiesceCyclesCode,
98 "predicate_test": predicateTest },
99 ["IsNonSpeculative", "IsQuiesce", "IsUnverifiable"])
100 header_output += BasicDeclare.subst(quiesceCyclesIop)
101 decoder_output += BasicConstructor.subst(quiesceCyclesIop)
102 exec_output += QuiescePredOpExecute.subst(quiesceCyclesIop)
103
114 quiesceCyclesIop = InstObjParams("quiesceCycles", "QuiesceCycles", "PredOp",
115 { "code": quiesceCyclesCode,
116 "predicate_test": predicateTest },
117 ["IsNonSpeculative", "IsQuiesce", "IsUnverifiable"])
118 header_output += BasicDeclare.subst(quiesceCyclesIop)
119 decoder_output += BasicConstructor.subst(quiesceCyclesIop)
120 exec_output += QuiescePredOpExecute.subst(quiesceCyclesIop)
121
122 quiesceCyclesIop = InstObjParams("quiesceCycles", "QuiesceCycles64", "PredOp",
123 { "code": quiesceCyclesCode64,
124 "predicate_test": predicateTest },
125 ["IsNonSpeculative", "IsQuiesce", "IsUnverifiable"])
126 header_output += BasicDeclare.subst(quiesceCyclesIop)
127 decoder_output += BasicConstructor.subst(quiesceCyclesIop)
128 exec_output += QuiescePredOpExecute.subst(quiesceCyclesIop)
129
104 quiesceTimeCode = '''
105 uint64_t qt_val = PseudoInst::quiesceTime(xc->tcBase());
106 R0 = bits(qt_val, 31, 0);
107 R1 = bits(qt_val, 63, 32);
108 '''
109
130 quiesceTimeCode = '''
131 uint64_t qt_val = PseudoInst::quiesceTime(xc->tcBase());
132 R0 = bits(qt_val, 31, 0);
133 R1 = bits(qt_val, 63, 32);
134 '''
135
136 quiesceTimeCode64 = '''
137 X0 = PseudoInst::quiesceTime(xc->tcBase());
138 '''
110 quiesceTimeIop = InstObjParams("quiesceTime", "QuiesceTime", "PredOp",
111 { "code": quiesceTimeCode,
112 "predicate_test": predicateTest },
113 ["IsNonSpeculative", "IsUnverifiable"])
114 header_output += BasicDeclare.subst(quiesceTimeIop)
115 decoder_output += BasicConstructor.subst(quiesceTimeIop)
116 exec_output += PredOpExecute.subst(quiesceTimeIop)
117
139 quiesceTimeIop = InstObjParams("quiesceTime", "QuiesceTime", "PredOp",
140 { "code": quiesceTimeCode,
141 "predicate_test": predicateTest },
142 ["IsNonSpeculative", "IsUnverifiable"])
143 header_output += BasicDeclare.subst(quiesceTimeIop)
144 decoder_output += BasicConstructor.subst(quiesceTimeIop)
145 exec_output += PredOpExecute.subst(quiesceTimeIop)
146
147 quiesceTimeIop = InstObjParams("quiesceTime", "QuiesceTime64", "PredOp",
148 { "code": quiesceTimeCode64,
149 "predicate_test": predicateTest },
150 ["IsNonSpeculative", "IsUnverifiable"])
151 header_output += BasicDeclare.subst(quiesceTimeIop)
152 decoder_output += BasicConstructor.subst(quiesceTimeIop)
153 exec_output += PredOpExecute.subst(quiesceTimeIop)
154
118 rpnsCode = '''
119 uint64_t rpns_val = PseudoInst::rpns(xc->tcBase());
120 R0 = bits(rpns_val, 31, 0);
121 R1 = bits(rpns_val, 63, 32);
122 '''
123
155 rpnsCode = '''
156 uint64_t rpns_val = PseudoInst::rpns(xc->tcBase());
157 R0 = bits(rpns_val, 31, 0);
158 R1 = bits(rpns_val, 63, 32);
159 '''
160
161 rpnsCode64 = '''
162 X0 = PseudoInst::rpns(xc->tcBase());
163 '''
124 rpnsIop = InstObjParams("rpns", "Rpns", "PredOp",
125 { "code": rpnsCode,
126 "predicate_test": predicateTest },
127 ["IsNonSpeculative", "IsUnverifiable"])
128 header_output += BasicDeclare.subst(rpnsIop)
129 decoder_output += BasicConstructor.subst(rpnsIop)
130 exec_output += PredOpExecute.subst(rpnsIop)
131
164 rpnsIop = InstObjParams("rpns", "Rpns", "PredOp",
165 { "code": rpnsCode,
166 "predicate_test": predicateTest },
167 ["IsNonSpeculative", "IsUnverifiable"])
168 header_output += BasicDeclare.subst(rpnsIop)
169 decoder_output += BasicConstructor.subst(rpnsIop)
170 exec_output += PredOpExecute.subst(rpnsIop)
171
172 rpnsIop = InstObjParams("rpns", "Rpns64", "PredOp",
173 { "code": rpnsCode64,
174 "predicate_test": predicateTest },
175 ["IsNonSpeculative", "IsUnverifiable"])
176 header_output += BasicDeclare.subst(rpnsIop)
177 decoder_output += BasicConstructor.subst(rpnsIop)
178 exec_output += PredOpExecute.subst(rpnsIop)
179
132 wakeCpuCode = '''
133 PseudoInst::wakeCPU(xc->tcBase(), join32to64(R1,R0));
134 '''
135
180 wakeCpuCode = '''
181 PseudoInst::wakeCPU(xc->tcBase(), join32to64(R1,R0));
182 '''
183
184 wakeCpuCode64 = '''
185 PseudoInst::wakeCPU(xc->tcBase(), X0);
186 '''
187
136 wakeCPUIop = InstObjParams("wakeCPU", "WakeCPU", "PredOp",
137 { "code": wakeCpuCode,
138 "predicate_test": predicateTest },
139 ["IsNonSpeculative", "IsUnverifiable"])
140 header_output += BasicDeclare.subst(wakeCPUIop)
141 decoder_output += BasicConstructor.subst(wakeCPUIop)
142 exec_output += PredOpExecute.subst(wakeCPUIop)
143
188 wakeCPUIop = InstObjParams("wakeCPU", "WakeCPU", "PredOp",
189 { "code": wakeCpuCode,
190 "predicate_test": predicateTest },
191 ["IsNonSpeculative", "IsUnverifiable"])
192 header_output += BasicDeclare.subst(wakeCPUIop)
193 decoder_output += BasicConstructor.subst(wakeCPUIop)
194 exec_output += PredOpExecute.subst(wakeCPUIop)
195
196 wakeCPUIop = InstObjParams("wakeCPU", "WakeCPU64", "PredOp",
197 { "code": wakeCpuCode64,
198 "predicate_test": predicateTest },
199 ["IsNonSpeculative", "IsUnverifiable"])
200 header_output += BasicDeclare.subst(wakeCPUIop)
201 decoder_output += BasicConstructor.subst(wakeCPUIop)
202 exec_output += PredOpExecute.subst(wakeCPUIop)
203
144 deprecated_ivlbIop = InstObjParams("deprecated_ivlb", "Deprecated_ivlb", "PredOp",
145 { "code": '''warn_once("Obsolete M5 ivlb instruction encountered.\\n");''',
146 "predicate_test": predicateTest })
147 header_output += BasicDeclare.subst(deprecated_ivlbIop)
148 decoder_output += BasicConstructor.subst(deprecated_ivlbIop)
149 exec_output += PredOpExecute.subst(deprecated_ivlbIop)
150
151 deprecated_ivleIop = InstObjParams("deprecated_ivle", "Deprecated_ivle", "PredOp",

--- 14 unchanged lines hidden (view full) ---

166 ["No_OpClass", "IsNonSpeculative"])
167 header_output += BasicDeclare.subst(deprecated_exitIop)
168 decoder_output += BasicConstructor.subst(deprecated_exitIop)
169 exec_output += PredOpExecute.subst(deprecated_exitIop)
170
171 m5exit_code = '''
172 PseudoInst::m5exit(xc->tcBase(), join32to64(R1, R0));
173 '''
204 deprecated_ivlbIop = InstObjParams("deprecated_ivlb", "Deprecated_ivlb", "PredOp",
205 { "code": '''warn_once("Obsolete M5 ivlb instruction encountered.\\n");''',
206 "predicate_test": predicateTest })
207 header_output += BasicDeclare.subst(deprecated_ivlbIop)
208 decoder_output += BasicConstructor.subst(deprecated_ivlbIop)
209 exec_output += PredOpExecute.subst(deprecated_ivlbIop)
210
211 deprecated_ivleIop = InstObjParams("deprecated_ivle", "Deprecated_ivle", "PredOp",

--- 14 unchanged lines hidden (view full) ---

226 ["No_OpClass", "IsNonSpeculative"])
227 header_output += BasicDeclare.subst(deprecated_exitIop)
228 decoder_output += BasicConstructor.subst(deprecated_exitIop)
229 exec_output += PredOpExecute.subst(deprecated_exitIop)
230
231 m5exit_code = '''
232 PseudoInst::m5exit(xc->tcBase(), join32to64(R1, R0));
233 '''
234
235 m5exit_code64 = '''
236 PseudoInst::m5exit(xc->tcBase(), X0);
237 '''
238
174 m5exitIop = InstObjParams("m5exit", "M5exit", "PredOp",
175 { "code": m5exit_code,
176 "predicate_test": predicateTest },
177 ["No_OpClass", "IsNonSpeculative"])
178 header_output += BasicDeclare.subst(m5exitIop)
179 decoder_output += BasicConstructor.subst(m5exitIop)
180 exec_output += PredOpExecute.subst(m5exitIop)
181
182 m5fail_code = '''
183 PseudoInst::m5fail(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
184 '''
185 m5failIop = InstObjParams("m5fail", "M5fail", "PredOp",
186 { "code": m5fail_code,
187 "predicate_test": predicateTest },
188 ["No_OpClass", "IsNonSpeculative"])
189 header_output += BasicDeclare.subst(m5failIop)
190 decoder_output += BasicConstructor.subst(m5failIop)
191 exec_output += PredOpExecute.subst(m5failIop)
192
239 m5exitIop = InstObjParams("m5exit", "M5exit", "PredOp",
240 { "code": m5exit_code,
241 "predicate_test": predicateTest },
242 ["No_OpClass", "IsNonSpeculative"])
243 header_output += BasicDeclare.subst(m5exitIop)
244 decoder_output += BasicConstructor.subst(m5exitIop)
245 exec_output += PredOpExecute.subst(m5exitIop)
246
247 m5fail_code = '''
248 PseudoInst::m5fail(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
249 '''
250 m5failIop = InstObjParams("m5fail", "M5fail", "PredOp",
251 { "code": m5fail_code,
252 "predicate_test": predicateTest },
253 ["No_OpClass", "IsNonSpeculative"])
254 header_output += BasicDeclare.subst(m5failIop)
255 decoder_output += BasicConstructor.subst(m5failIop)
256 exec_output += PredOpExecute.subst(m5failIop)
257
258 m5exitIop = InstObjParams("m5exit", "M5exit64", "PredOp",
259 { "code": m5exit_code64,
260 "predicate_test": predicateTest },
261 ["No_OpClass", "IsNonSpeculative"])
262 header_output += BasicDeclare.subst(m5exitIop)
263 decoder_output += BasicConstructor.subst(m5exitIop)
264 exec_output += PredOpExecute.subst(m5exitIop)
265
193 loadsymbolCode = '''
194 PseudoInst::loadsymbol(xc->tcBase());
195 '''
196
197 loadsymbolIop = InstObjParams("loadsymbol", "Loadsymbol", "PredOp",
198 { "code": loadsymbolCode,
199 "predicate_test": predicateTest },
200 ["No_OpClass", "IsNonSpeculative"])
201 header_output += BasicDeclare.subst(loadsymbolIop)
202 decoder_output += BasicConstructor.subst(loadsymbolIop)
203 exec_output += PredOpExecute.subst(loadsymbolIop)
204
205 initparamCode = '''
206 uint64_t ip_val = PseudoInst::initParam(xc->tcBase());
207 R0 = bits(ip_val, 31, 0);
208 R1 = bits(ip_val, 63, 32);
209 '''
210
266 loadsymbolCode = '''
267 PseudoInst::loadsymbol(xc->tcBase());
268 '''
269
270 loadsymbolIop = InstObjParams("loadsymbol", "Loadsymbol", "PredOp",
271 { "code": loadsymbolCode,
272 "predicate_test": predicateTest },
273 ["No_OpClass", "IsNonSpeculative"])
274 header_output += BasicDeclare.subst(loadsymbolIop)
275 decoder_output += BasicConstructor.subst(loadsymbolIop)
276 exec_output += PredOpExecute.subst(loadsymbolIop)
277
278 initparamCode = '''
279 uint64_t ip_val = PseudoInst::initParam(xc->tcBase());
280 R0 = bits(ip_val, 31, 0);
281 R1 = bits(ip_val, 63, 32);
282 '''
283
284 initparamCode64 = '''
285 X0 = PseudoInst::initParam(xc->tcBase());
286 '''
287
211 initparamIop = InstObjParams("initparam", "Initparam", "PredOp",
212 { "code": initparamCode,
213 "predicate_test": predicateTest },
214 ["IsNonSpeculative"])
215 header_output += BasicDeclare.subst(initparamIop)
216 decoder_output += BasicConstructor.subst(initparamIop)
217 exec_output += PredOpExecute.subst(initparamIop)
218
288 initparamIop = InstObjParams("initparam", "Initparam", "PredOp",
289 { "code": initparamCode,
290 "predicate_test": predicateTest },
291 ["IsNonSpeculative"])
292 header_output += BasicDeclare.subst(initparamIop)
293 decoder_output += BasicConstructor.subst(initparamIop)
294 exec_output += PredOpExecute.subst(initparamIop)
295
296 initparamIop = InstObjParams("initparam", "Initparam64", "PredOp",
297 { "code": initparamCode64,
298 "predicate_test": predicateTest },
299 ["IsNonSpeculative"])
300 header_output += BasicDeclare.subst(initparamIop)
301 decoder_output += BasicConstructor.subst(initparamIop)
302 exec_output += PredOpExecute.subst(initparamIop)
303
219 resetstats_code = '''
220 PseudoInst::resetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
221 '''
222
304 resetstats_code = '''
305 PseudoInst::resetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
306 '''
307
308 resetstats_code64 = '''
309 PseudoInst::resetstats(xc->tcBase(), X0, X1);
310 '''
223 resetstatsIop = InstObjParams("resetstats", "Resetstats", "PredOp",
224 { "code": resetstats_code,
225 "predicate_test": predicateTest },
226 ["IsNonSpeculative"])
227 header_output += BasicDeclare.subst(resetstatsIop)
228 decoder_output += BasicConstructor.subst(resetstatsIop)
229 exec_output += PredOpExecute.subst(resetstatsIop)
230
311 resetstatsIop = InstObjParams("resetstats", "Resetstats", "PredOp",
312 { "code": resetstats_code,
313 "predicate_test": predicateTest },
314 ["IsNonSpeculative"])
315 header_output += BasicDeclare.subst(resetstatsIop)
316 decoder_output += BasicConstructor.subst(resetstatsIop)
317 exec_output += PredOpExecute.subst(resetstatsIop)
318
319 resetstatsIop = InstObjParams("resetstats", "Resetstats64", "PredOp",
320 { "code": resetstats_code64,
321 "predicate_test": predicateTest },
322 ["IsNonSpeculative"])
323 header_output += BasicDeclare.subst(resetstatsIop)
324 decoder_output += BasicConstructor.subst(resetstatsIop)
325 exec_output += PredOpExecute.subst(resetstatsIop)
326
231 dumpstats_code = '''
232 PseudoInst::dumpstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
233 '''
327 dumpstats_code = '''
328 PseudoInst::dumpstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
329 '''
330
331 dumpstats_code64 = '''
332 PseudoInst::dumpstats(xc->tcBase(), X0, X1);
333 '''
334
234 dumpstatsIop = InstObjParams("dumpstats", "Dumpstats", "PredOp",
235 { "code": dumpstats_code,
236 "predicate_test": predicateTest },
237 ["IsNonSpeculative"])
238 header_output += BasicDeclare.subst(dumpstatsIop)
239 decoder_output += BasicConstructor.subst(dumpstatsIop)
240 exec_output += PredOpExecute.subst(dumpstatsIop)
241
335 dumpstatsIop = InstObjParams("dumpstats", "Dumpstats", "PredOp",
336 { "code": dumpstats_code,
337 "predicate_test": predicateTest },
338 ["IsNonSpeculative"])
339 header_output += BasicDeclare.subst(dumpstatsIop)
340 decoder_output += BasicConstructor.subst(dumpstatsIop)
341 exec_output += PredOpExecute.subst(dumpstatsIop)
342
343 dumpstatsIop = InstObjParams("dumpstats", "Dumpstats64", "PredOp",
344 { "code": dumpstats_code64,
345 "predicate_test": predicateTest },
346 ["IsNonSpeculative"])
347 header_output += BasicDeclare.subst(dumpstatsIop)
348 decoder_output += BasicConstructor.subst(dumpstatsIop)
349 exec_output += PredOpExecute.subst(dumpstatsIop)
350
242 dumpresetstats_code = '''
243 PseudoInst::dumpresetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
244 '''
351 dumpresetstats_code = '''
352 PseudoInst::dumpresetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
353 '''
354
355 dumpresetstats_code64 = '''
356 PseudoInst::dumpresetstats(xc->tcBase(), X0, X1);
357 '''
358
245 dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats", "PredOp",
246 { "code": dumpresetstats_code,
247 "predicate_test": predicateTest },
248 ["IsNonSpeculative"])
249 header_output += BasicDeclare.subst(dumpresetstatsIop)
250 decoder_output += BasicConstructor.subst(dumpresetstatsIop)
251 exec_output += PredOpExecute.subst(dumpresetstatsIop)
252
359 dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats", "PredOp",
360 { "code": dumpresetstats_code,
361 "predicate_test": predicateTest },
362 ["IsNonSpeculative"])
363 header_output += BasicDeclare.subst(dumpresetstatsIop)
364 decoder_output += BasicConstructor.subst(dumpresetstatsIop)
365 exec_output += PredOpExecute.subst(dumpresetstatsIop)
366
367 dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats64", "PredOp",
368 { "code": dumpresetstats_code64,
369 "predicate_test": predicateTest },
370 ["IsNonSpeculative"])
371 header_output += BasicDeclare.subst(dumpresetstatsIop)
372 decoder_output += BasicConstructor.subst(dumpresetstatsIop)
373 exec_output += PredOpExecute.subst(dumpresetstatsIop)
374
253 m5checkpoint_code = '''
254 PseudoInst::m5checkpoint(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
255 '''
375 m5checkpoint_code = '''
376 PseudoInst::m5checkpoint(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
377 '''
378
379 m5checkpoint_code64 = '''
380 PseudoInst::m5checkpoint(xc->tcBase(), X0, X1);
381 '''
382
256 m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint", "PredOp",
257 { "code": m5checkpoint_code,
258 "predicate_test": predicateTest },
259 ["IsNonSpeculative", "IsUnverifiable"])
260 header_output += BasicDeclare.subst(m5checkpointIop)
261 decoder_output += BasicConstructor.subst(m5checkpointIop)
262 exec_output += PredOpExecute.subst(m5checkpointIop)
263
383 m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint", "PredOp",
384 { "code": m5checkpoint_code,
385 "predicate_test": predicateTest },
386 ["IsNonSpeculative", "IsUnverifiable"])
387 header_output += BasicDeclare.subst(m5checkpointIop)
388 decoder_output += BasicConstructor.subst(m5checkpointIop)
389 exec_output += PredOpExecute.subst(m5checkpointIop)
390
391 m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint64", "PredOp",
392 { "code": m5checkpoint_code64,
393 "predicate_test": predicateTest },
394 ["IsNonSpeculative", "IsUnverifiable"])
395 header_output += BasicDeclare.subst(m5checkpointIop)
396 decoder_output += BasicConstructor.subst(m5checkpointIop)
397 exec_output += PredOpExecute.subst(m5checkpointIop)
398
264 m5readfileCode = '''
265 int n = 4;
266 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false);
267 R0 = PseudoInst::readfile(xc->tcBase(), R0, join32to64(R3,R2), offset);
268 '''
399 m5readfileCode = '''
400 int n = 4;
401 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false);
402 R0 = PseudoInst::readfile(xc->tcBase(), R0, join32to64(R3,R2), offset);
403 '''
404
405 m5readfileCode64 = '''
406 int n = 4;
407 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false);
408 n = 6;
409 X0 = PseudoInst::readfile(xc->tcBase(), (uint32_t)X0, X1, offset);
410 '''
411
269 m5readfileIop = InstObjParams("m5readfile", "M5readfile", "PredOp",
270 { "code": m5readfileCode,
271 "predicate_test": predicateTest },
272 ["IsNonSpeculative", "IsUnverifiable"])
273 header_output += BasicDeclare.subst(m5readfileIop)
274 decoder_output += BasicConstructor.subst(m5readfileIop)
275 exec_output += PredOpExecute.subst(m5readfileIop)
276
412 m5readfileIop = InstObjParams("m5readfile", "M5readfile", "PredOp",
413 { "code": m5readfileCode,
414 "predicate_test": predicateTest },
415 ["IsNonSpeculative", "IsUnverifiable"])
416 header_output += BasicDeclare.subst(m5readfileIop)
417 decoder_output += BasicConstructor.subst(m5readfileIop)
418 exec_output += PredOpExecute.subst(m5readfileIop)
419
420 m5readfileIop = InstObjParams("m5readfile", "M5readfile64", "PredOp",
421 { "code": m5readfileCode64,
422 "predicate_test": predicateTest },
423 ["IsNonSpeculative", "IsUnverifiable"])
424 header_output += BasicDeclare.subst(m5readfileIop)
425 decoder_output += BasicConstructor.subst(m5readfileIop)
426 exec_output += PredOpExecute.subst(m5readfileIop)
427
277 m5writefileCode = '''
278 int n = 4;
279 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false);
280 n = 6;
281 Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false);
282 R0 = PseudoInst::writefile(xc->tcBase(), R0, join32to64(R3,R2), offset,
283 filenameAddr);
284 '''
428 m5writefileCode = '''
429 int n = 4;
430 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false);
431 n = 6;
432 Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false);
433 R0 = PseudoInst::writefile(xc->tcBase(), R0, join32to64(R3,R2), offset,
434 filenameAddr);
435 '''
436
437 m5writefileCode64 = '''
438 int n = 4;
439 uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false);
440 n = 6;
441 Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false);
442 X0 = PseudoInst::writefile(xc->tcBase(), (uint32_t)X0, X1, offset,
443 filenameAddr);
444 '''
445
285 m5writefileIop = InstObjParams("m5writefile", "M5writefile", "PredOp",
286 { "code": m5writefileCode,
287 "predicate_test": predicateTest },
288 ["IsNonSpeculative"])
289 header_output += BasicDeclare.subst(m5writefileIop)
290 decoder_output += BasicConstructor.subst(m5writefileIop)
291 exec_output += PredOpExecute.subst(m5writefileIop)
292
446 m5writefileIop = InstObjParams("m5writefile", "M5writefile", "PredOp",
447 { "code": m5writefileCode,
448 "predicate_test": predicateTest },
449 ["IsNonSpeculative"])
450 header_output += BasicDeclare.subst(m5writefileIop)
451 decoder_output += BasicConstructor.subst(m5writefileIop)
452 exec_output += PredOpExecute.subst(m5writefileIop)
453
454 m5writefileIop = InstObjParams("m5writefile", "M5writefile64", "PredOp",
455 { "code": m5writefileCode64,
456 "predicate_test": predicateTest },
457 ["IsNonSpeculative"])
458 header_output += BasicDeclare.subst(m5writefileIop)
459 decoder_output += BasicConstructor.subst(m5writefileIop)
460 exec_output += PredOpExecute.subst(m5writefileIop)
461
293 m5breakIop = InstObjParams("m5break", "M5break", "PredOp",
294 { "code": "PseudoInst::debugbreak(xc->tcBase());",
295 "predicate_test": predicateTest },
296 ["IsNonSpeculative"])
297 header_output += BasicDeclare.subst(m5breakIop)
298 decoder_output += BasicConstructor.subst(m5breakIop)
299 exec_output += PredOpExecute.subst(m5breakIop)
300
301 m5switchcpuIop = InstObjParams("m5switchcpu", "M5switchcpu", "PredOp",
302 { "code": "PseudoInst::switchcpu(xc->tcBase());",
303 "predicate_test": predicateTest },
304 ["IsNonSpeculative"])
305 header_output += BasicDeclare.subst(m5switchcpuIop)
306 decoder_output += BasicConstructor.subst(m5switchcpuIop)
307 exec_output += PredOpExecute.subst(m5switchcpuIop)
308
309 m5addsymbolCode = '''
310 PseudoInst::addsymbol(xc->tcBase(), join32to64(R1, R0), R2);
311 '''
462 m5breakIop = InstObjParams("m5break", "M5break", "PredOp",
463 { "code": "PseudoInst::debugbreak(xc->tcBase());",
464 "predicate_test": predicateTest },
465 ["IsNonSpeculative"])
466 header_output += BasicDeclare.subst(m5breakIop)
467 decoder_output += BasicConstructor.subst(m5breakIop)
468 exec_output += PredOpExecute.subst(m5breakIop)
469
470 m5switchcpuIop = InstObjParams("m5switchcpu", "M5switchcpu", "PredOp",
471 { "code": "PseudoInst::switchcpu(xc->tcBase());",
472 "predicate_test": predicateTest },
473 ["IsNonSpeculative"])
474 header_output += BasicDeclare.subst(m5switchcpuIop)
475 decoder_output += BasicConstructor.subst(m5switchcpuIop)
476 exec_output += PredOpExecute.subst(m5switchcpuIop)
477
478 m5addsymbolCode = '''
479 PseudoInst::addsymbol(xc->tcBase(), join32to64(R1, R0), R2);
480 '''
481 m5addsymbolCode64 = '''
482 PseudoInst::addsymbol(xc->tcBase(), X0, (uint32_t)X1);
483 '''
312 m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol", "PredOp",
313 { "code": m5addsymbolCode,
314 "predicate_test": predicateTest },
315 ["IsNonSpeculative"])
316 header_output += BasicDeclare.subst(m5addsymbolIop)
317 decoder_output += BasicConstructor.subst(m5addsymbolIop)
318 exec_output += PredOpExecute.subst(m5addsymbolIop)
319
484 m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol", "PredOp",
485 { "code": m5addsymbolCode,
486 "predicate_test": predicateTest },
487 ["IsNonSpeculative"])
488 header_output += BasicDeclare.subst(m5addsymbolIop)
489 decoder_output += BasicConstructor.subst(m5addsymbolIop)
490 exec_output += PredOpExecute.subst(m5addsymbolIop)
491
492 m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol64", "PredOp",
493 { "code": m5addsymbolCode64,
494 "predicate_test": predicateTest },
495 ["IsNonSpeculative"])
496 header_output += BasicDeclare.subst(m5addsymbolIop)
497 decoder_output += BasicConstructor.subst(m5addsymbolIop)
498 exec_output += PredOpExecute.subst(m5addsymbolIop)
499
320 m5panicCode = '''panic("M5 panic instruction called at pc=%#x.",
321 xc->pcState().pc());'''
500 m5panicCode = '''panic("M5 panic instruction called at pc=%#x.",
501 xc->pcState().pc());'''
502
322 m5panicIop = InstObjParams("m5panic", "M5panic", "PredOp",
323 { "code": m5panicCode,
324 "predicate_test": predicateTest },
325 ["IsNonSpeculative"])
326 header_output += BasicDeclare.subst(m5panicIop)
327 decoder_output += BasicConstructor.subst(m5panicIop)
328 exec_output += PredOpExecute.subst(m5panicIop)
329
330 m5workbeginCode = '''PseudoInst::workbegin(
331 xc->tcBase(),
332 join32to64(R1, R0),
333 join32to64(R3, R2)
334 );'''
503 m5panicIop = InstObjParams("m5panic", "M5panic", "PredOp",
504 { "code": m5panicCode,
505 "predicate_test": predicateTest },
506 ["IsNonSpeculative"])
507 header_output += BasicDeclare.subst(m5panicIop)
508 decoder_output += BasicConstructor.subst(m5panicIop)
509 exec_output += PredOpExecute.subst(m5panicIop)
510
511 m5workbeginCode = '''PseudoInst::workbegin(
512 xc->tcBase(),
513 join32to64(R1, R0),
514 join32to64(R3, R2)
515 );'''
516
517 m5workbeginCode64 = '''PseudoInst::workbegin(
518 xc->tcBase(),
519 X0,
520 X1
521 );'''
522
335 m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin", "PredOp",
336 { "code": m5workbeginCode,
337 "predicate_test": predicateTest },
338 ["IsNonSpeculative"])
339 header_output += BasicDeclare.subst(m5workbeginIop)
340 decoder_output += BasicConstructor.subst(m5workbeginIop)
341 exec_output += PredOpExecute.subst(m5workbeginIop)
342
523 m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin", "PredOp",
524 { "code": m5workbeginCode,
525 "predicate_test": predicateTest },
526 ["IsNonSpeculative"])
527 header_output += BasicDeclare.subst(m5workbeginIop)
528 decoder_output += BasicConstructor.subst(m5workbeginIop)
529 exec_output += PredOpExecute.subst(m5workbeginIop)
530
531 m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin64", "PredOp",
532 { "code": m5workbeginCode64,
533 "predicate_test": predicateTest },
534 ["IsNonSpeculative"])
535 header_output += BasicDeclare.subst(m5workbeginIop)
536 decoder_output += BasicConstructor.subst(m5workbeginIop)
537 exec_output += PredOpExecute.subst(m5workbeginIop)
538
343 m5workendCode = '''PseudoInst::workend(
344 xc->tcBase(),
345 join32to64(R1, R0),
346 join32to64(R3, R2)
347 );'''
539 m5workendCode = '''PseudoInst::workend(
540 xc->tcBase(),
541 join32to64(R1, R0),
542 join32to64(R3, R2)
543 );'''
544
545 m5workendCode64 = '''PseudoInst::workend(
546 xc->tcBase(),
547 X0,
548 X1
549 );'''
550
348 m5workendIop = InstObjParams("m5workend", "M5workend", "PredOp",
349 { "code": m5workendCode,
350 "predicate_test": predicateTest },
351 ["IsNonSpeculative"])
352 header_output += BasicDeclare.subst(m5workendIop)
353 decoder_output += BasicConstructor.subst(m5workendIop)
354 exec_output += PredOpExecute.subst(m5workendIop)
355
551 m5workendIop = InstObjParams("m5workend", "M5workend", "PredOp",
552 { "code": m5workendCode,
553 "predicate_test": predicateTest },
554 ["IsNonSpeculative"])
555 header_output += BasicDeclare.subst(m5workendIop)
556 decoder_output += BasicConstructor.subst(m5workendIop)
557 exec_output += PredOpExecute.subst(m5workendIop)
558
559 m5workendIop = InstObjParams("m5workend", "M5workend64", "PredOp",
560 { "code": m5workendCode64,
561 "predicate_test": predicateTest },
562 ["IsNonSpeculative"])
563 header_output += BasicDeclare.subst(m5workendIop)
564 decoder_output += BasicConstructor.subst(m5workendIop)
565 exec_output += PredOpExecute.subst(m5workendIop)
356}};
566}};