Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | # ========== Copyright Header Begin ========================================== |
2 | # | |
3 | # OpenSPARC T2 Processor File: CmdParserNi.py | |
4 | # Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved. | |
5 | # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES. | |
6 | # | |
7 | # The above named program is free software; you can redistribute it and/or | |
8 | # modify it under the terms of the GNU General Public | |
9 | # License version 2 as published by the Free Software Foundation. | |
10 | # | |
11 | # The above named program is distributed in the hope that it will be | |
12 | # useful, but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | # General Public License for more details. | |
15 | # | |
16 | # You should have received a copy of the GNU General Public | |
17 | # License along with this work; if not, write to the Free Software | |
18 | # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. | |
19 | # | |
20 | # ========== Copyright Header End ============================================ | |
21 | """Niagara command parser | |
22 | """ | |
23 | ||
24 | import re, string, sys, types | |
25 | ||
26 | ## # if nasAPI is not available (which is the case in MOM mode), we can make do | |
27 | ## # without it. | |
28 | ## try: | |
29 | ## import nasAPI | |
30 | ## except: | |
31 | ## #sys.stderr.write('WARNING: nasAPI module is not available\n') | |
32 | ## pass | |
33 | ||
34 | import RegisterMap | |
35 | from CmdParserNiCmd import * | |
36 | ||
37 | # the following breakpoint constants (BP_*) must be consistent with | |
38 | # include/system/BreakpointEntry.h | |
39 | BP_PC = 1 | |
40 | BP_VA = 2 | |
41 | BP_PA = 3 | |
42 | ||
43 | hexRE = re.compile('^0[xX][0-9A-Fa-f]+$') | |
44 | octRE = re.compile('^0[0-7]+$') | |
45 | # split command line to locate any % variable, e.g., %pc | |
46 | splitRE = re.compile('[^%_\w]') | |
47 | ||
48 | ### need to support the following commands: | |
49 | ||
50 | SYM_PA = 'p:' | |
51 | SYM_RA = 'r:' | |
52 | SYM_VA = 'v:' | |
53 | ||
54 | NAME_CPU = 'cpu' | |
55 | NAME_CORE = 'core' | |
56 | NAME_UCORE = 'ucore' | |
57 | NAME_STRAND = 'strand' | |
58 | ||
59 | NAME_breakpoint = 'phys_mem' | |
60 | NAME_context = 'TODO' | |
61 | NAME_image = 'TODO' | |
62 | NAME_memory_space = 'phys_mem' | |
63 | NAME_port_space = 'TODO' | |
64 | NAME_processor = 'th' | |
65 | NAME_rtl_intf = 'TODO' | |
66 | NAME_swerver_memory = 'swvmem' | |
67 | NAME_swerver_proc_mmu = 'swmmu' | |
68 | NAME_swerver_thread_mmu = 'stmmu' | |
69 | ||
70 | CMD_action = 'action' | |
71 | CMD_add_directory = 'add-directory' | |
72 | CMD_api_apropos = 'api-apropos' | |
73 | CMD_api_help = 'api-help' | |
74 | CMD_apropos = 'apropos' | |
75 | CMD_break_cr = 'break-cr' | |
76 | CMD_break_exception = 'break-exception' | |
77 | CMD_break_hap = 'break-hap' | |
78 | CMD_break_io = 'break-io' | |
79 | CMD_breakpoint_break = 'break' | |
80 | CMD_catch_exception = 'catch-exception' | |
81 | CMD_clear_directories = 'clear-directories' | |
82 | CMD_cmpregs = 'cmpregs' | |
83 | CMD_command_list = 'command-list' | |
84 | CMD_context_off = 'off' | |
85 | CMD_context_on = 'on' | |
86 | CMD_cycle_break = 'cycle-break' | |
87 | CMD_cycle_break_absolute = 'cycle-break-absolute' | |
88 | CMD_debug_level = 'debug-level' | |
89 | CMD_delete = 'delete' | |
90 | CMD_device_interrupt = 'device-interrupt' | |
91 | CMD_devs = 'devs' | |
92 | CMD_disable = 'disable' | |
93 | CMD_disable_real_time_mode = 'disable-real-time-mode' | |
94 | CMD_disassemble = 'disassemble' | |
95 | CMD_display = 'display' | |
96 | CMD_dstc_disable = 'dstc-disable' | |
97 | CMD_dstc_enable = 'dstc-enable' | |
98 | CMD_echo = 'echo' | |
99 | CMD_enable = 'enable' | |
100 | CMD_enable_external_commands = 'enable-external-commands' | |
101 | CMD_enable_real_time_mode = 'enable-real-time-mode' | |
102 | CMD_eosl = 'eosl' | |
103 | CMD_expect = 'expect' | |
104 | CMD_gdb_remote = 'gdb-remote' | |
105 | CMD_get = 'get' | |
106 | CMD_help = 'help' | |
107 | CMD_hex = 'hex' | |
108 | CMD_ignore = 'ignore' | |
109 | CMD_image_add_diff_file = 'add-diff-file' | |
110 | CMD_image_add_partial_diff_file = 'add-partial-diff-file' | |
111 | CMD_image_commit = 'commit' | |
112 | CMD_image_limit_memory = 'limit-memory' | |
113 | CMD_image_save = 'save' | |
114 | CMD_image_x = 'x' | |
115 | CMD_instruction_profile_mode = 'instruction-profile-mode' | |
116 | CMD_io = 'io' | |
117 | CMD_io_buffer = 'io-buffer' | |
118 | CMD_istc_disable = 'istc-disable' | |
119 | CMD_istc_enable = 'istc-enable' | |
120 | CMD_le_checksum = 'le-checksum' | |
121 | CMD_le_permissions = 'le-permissions' | |
122 | CMD_list_attributes = 'list-attributes' | |
123 | CMD_list_breakpoints = 'list-breakpoints' | |
124 | CMD_list_classes = 'list-classes' | |
125 | CMD_list_failed_modules = 'list-failed-modules' | |
126 | CMD_list_haps = 'list-haps' | |
127 | CMD_list_modules = 'list-modules' | |
128 | CMD_list_namespaces = 'list-namespaces' | |
129 | CMD_list_profilers = 'list-profilers' | |
130 | CMD_list_vars = 'list-vars' | |
131 | CMD_load_binary = 'load-binary' | |
132 | CMD_load_file = 'load-file' | |
133 | CMD_load_module = 'load-module' | |
134 | CMD_load_veri_file = 'load-veri-file' | |
135 | CMD_logical_to_physical = 'logical-to-physical' | |
136 | CMD_magic_break_disable = 'magic-break-disable' | |
137 | CMD_magic_break_enable = 'magic-break-enable' | |
138 | CMD_memory_profile = 'memory-profile' | |
139 | CMD_memory_space_map = 'map' | |
140 | CMD_module_list_refresh = 'module-list-refresh' | |
141 | CMD_mmuregs = 'mmuregs' | |
142 | CMD_native_path = 'native-path' | |
143 | CMD_new_command = 'new_command' | |
144 | CMD_new_context = 'new-context' | |
145 | CMD_output_radix = 'output-radix' | |
146 | CMD_pdisable = 'pdisable' | |
147 | CMD_pdisassemble = 'pdisassemble' | |
148 | CMD_penable = 'penable' | |
149 | CMD_pio = 'pio' | |
150 | CMD_pipe = 'pipe' | |
151 | CMD_pli_run = 'pli-run' | |
152 | CMD_port_space_map = 'map' | |
153 | CMD_pregs = 'pregs' | |
154 | CMD_fpregs = 'fpregs' | |
155 | CMD_pregs_all = 'pregs-all' | |
156 | CMD_pregs_hyper = 'pregs-hyper' | |
157 | #CMD_print = 'print' | |
158 | CMD_print_directories = 'print-directories' | |
159 | CMD_print_double_regs = 'print-double-regs' | |
160 | CMD_print_event_queue = 'print-event-queue' | |
161 | CMD_print_float_regs = 'print-float-regs' | |
162 | CMD_print_float_regs_raw = 'print-float-regs-raw' | |
163 | CMD_print_instruction_queue = 'print-instruction-queue' | |
164 | CMD_print_profile = 'print-profile' | |
165 | CMD_print_statistics = 'print-statistics' | |
166 | CMD_print_time = 'print-time' | |
167 | CMD_prof_page_details = 'prof-page-details' | |
168 | CMD_prof_page_map = 'prof-page-map' | |
169 | CMD_prof_weight = 'prof-weight' | |
170 | CMD_pselect = 'pselect' | |
171 | CMD_quit = 'quit' | |
172 | CMD_read_configuration = 'read-configuration' | |
173 | CMD_read_fp_reg_i = 'read-fp-reg-i' | |
174 | CMD_read_fp_reg_x = 'read-fp-reg-x' | |
175 | CMD_read_reg = 'read-reg' | |
176 | CMD_read_sw_pcs = 'read-sw-pcs' | |
177 | CMD_read_th_ctl_reg = 'read-th-ctl-reg' | |
178 | CMD_read_th_fp_reg_i = 'read-th-fp-reg-i' | |
179 | CMD_read_th_fp_reg_x = 'read-th-fp-reg-x' | |
180 | CMD_read_thread_status = 'read-thread-status' | |
181 | CMD_read_th_reg = 'read-th-reg' | |
182 | CMD_resolve_file = 'resolve-file' | |
183 | CMD_rtl_cycle = 'rtl_cycle' | |
184 | CMD_rtl_intf_info = 'info' | |
185 | CMD_run = 'run' | |
186 | CMD_runfast = 'runfast' | |
187 | CMD_whatis = 'whatis' | |
188 | CMD_run_command_file = 'run-command-file' | |
189 | CMD_run_python_file = 'run-python-file' | |
190 | CMD_set = 'set' | |
191 | CMD_set_context = 'set-context' | |
192 | CMD_set_pattern = 'set-pattern' | |
193 | CMD_set_pc = 'set-pc' | |
194 | CMD_set_prefix = 'set-prefix' | |
195 | CMD_set_prof_weight = 'set-prof-weight' | |
196 | CMD_set_substr = 'set-substr' | |
197 | CMD_special_interrupt = 'special-interrupt' | |
198 | CMD_sstepi = 'sstepi' | |
199 | CMD_stc_status = 'stc-status' | |
200 | CMD_step_break = 'step-break' | |
201 | CMD_step_break_absolute = 'step-break-absolute' | |
202 | CMD_step_cycle = 'step-cycle' | |
203 | CMD_step_instruction = 'step-instruction' | |
204 | CMD_stop = 'stop' | |
205 | CMD_swerver_memory_debug = 'debug' | |
206 | CMD_swerver_memory_info = 'info' | |
207 | CMD_swerver_proc_mmu_i_tlb_entry = 'i-tlb-entry' | |
208 | CMD_swerver_proc_mmu_probe = 'probe' | |
209 | CMD_swerver_proc_mmu_regs = 'regs' | |
210 | CMD_swerver_proc_mmu_tlb = 'tlb' | |
211 | CMD_swerver_proc_mmu_trace = 'trace' | |
212 | CMD_swerver_thread_mmu_probe = 'probe' | |
213 | CMD_swerver_thread_mmu_regs = 'regs' | |
214 | CMD_swerver_thread_mmu_trace = 'trace' | |
215 | CMD_swrun = 'swrun' | |
216 | CMD_trace_cr = 'trace-cr' | |
217 | CMD_trace_exception = 'trace-exception' | |
218 | CMD_trace_hap = 'trace-hap' | |
219 | CMD_trace_io = 'trace-io' | |
220 | CMD_trap_info = 'trap-info' | |
221 | CMD_unbreak = 'unbreak' | |
222 | CMD_undisplay = 'undisplay' | |
223 | CMD_unload_module = 'unload-module' | |
224 | CMD_write_configuration = 'write-configuration' | |
225 | CMD_write_fp_reg_i = 'write-fp-reg-i' | |
226 | CMD_write_fp_reg_x = 'write-fp-reg-x' | |
227 | CMD_write_reg = 'write-reg' | |
228 | CMD_write_th_ctl_reg = 'write-th-ctl-reg' | |
229 | CMD_write_th_fp_reg_i = 'write-th-fp-reg-i' | |
230 | CMD_write_th_fp_reg_x = 'write-th-fp-reg-x' | |
231 | CMD_write_thread_status = 'write-thread-status' | |
232 | CMD_x = 'x' | |
233 | CMD_xp = 'xp' | |
234 | ||
235 | # extra commands | |
236 | CMD_ssi = 'ssi' | |
237 | CMD_ALIAS = 'alias' | |
238 | CMD_UNALIAS = 'unalias' | |
239 | #CMD_RESET = 'reset' | |
240 | ||
241 | ||
242 | class BreakPoint: | |
243 | """ | |
244 | """ | |
245 | def __init__ (self, id, sid, addr, cmd, type): | |
246 | """ | |
247 | """ | |
248 | self.id = id | |
249 | self.sid = sid | |
250 | self.addr = addr | |
251 | self.hitCount = 0 | |
252 | self.ignore = 0 | |
253 | self.enable = 1 | |
254 | self.justHit = 0 | |
255 | self.type = type | |
256 | self.action = [] | |
257 | i = cmd.find('{') | |
258 | if i > -1: | |
259 | j = cmd.rfind('}') | |
260 | tokens = cmd[i+1:j].split(';') | |
261 | #print 'DBX: cmd=%s, tokens=%s' % (cmd, tokens) #DBX | |
262 | k = 0 | |
263 | while k < len(tokens): | |
264 | self.action.append(tokens[k].strip()) | |
265 | k += 1 | |
266 | ||
267 | ||
268 | def __str__ (self): | |
269 | """ | |
270 | """ | |
271 | return 'breakpoint=%d, sid=%d, addr=%#x, type=%s, enable=%d, hit=%d, ignore=%d, action=%s' % (self.id, self.sid, self.addr, self.type, self.enable, self.hitCount, self.ignore, self.action) | |
272 | ||
273 | ||
274 | def isHit (self, pc): | |
275 | """ | |
276 | TODO we don't really use this any more, as of 5/10/05, and this | |
277 | function only handle PC | |
278 | """ | |
279 | if self.enable == 1 and self.addr == pc: | |
280 | # a hit, is there an ignore count or do we just hit this same pc | |
281 | # in the previous step? | |
282 | self.hitCount += 1 | |
283 | if ((self.ignore == 0 and self.justHit == 0) or | |
284 | (self.ignore > 0 and self.hitCount > self.ignore)): | |
285 | hit = 1 | |
286 | self.justHit = 1 | |
287 | self.hitCount = 0 | |
288 | else: | |
289 | hit = 0 | |
290 | self.justHit = 0 | |
291 | ||
292 | ## if self.hitCount > self.ignore: | |
293 | ## self.hitCount = 0 | |
294 | ## if (self.justHit == 1) and (self.ignore > 0): | |
295 | ## self.justHit = 0 | |
296 | ## else: | |
297 | ## self.justHit = 1 | |
298 | ## hit = 1 | |
299 | ## else: | |
300 | ## self.justHit = 1 | |
301 | ||
302 | else: | |
303 | hit = 0 | |
304 | self.justHit = 0 | |
305 | ||
306 | return hit | |
307 | ||
308 | ||
309 | class CmdParserNi: | |
310 | """ | |
311 | """ | |
312 | ||
313 | def __init__ (self, riesReposit): | |
314 | """ | |
315 | """ | |
316 | self.riesReposit = riesReposit | |
317 | ||
318 | self.topName = self.riesReposit.topName | |
319 | self.ncpus = self.riesReposit.ncpus | |
320 | self.ncores = self.riesReposit.ncores | |
321 | self.nucores = self.riesReposit.nucores | |
322 | self.nstrands = self.riesReposit.nstrands | |
323 | ||
324 | self.nSpregs = self.riesReposit.nSpregs | |
325 | self.nDpregs = self.riesReposit.nDpregs | |
326 | self.nQpregs = self.riesReposit.nQpregs | |
327 | self.nWinregs = 16 #************CONSTANTS*********** | |
328 | self.nWin = 8 #XXX there should be a better way to initialize from backend | |
329 | ||
330 | ||
331 | #sys.stderr.write('***config\n'); | |
332 | #sys.stderr.write(str(self.topName+' ')) | |
333 | #sys.stderr.write(str(self.ncpus)) | |
334 | #sys.stderr.write(str(self.ncores)) | |
335 | #sys.stderr.write(str(self.nstrands)) | |
336 | #sys.stderr.write('\nend config***\n') | |
337 | ||
338 | if self.nucores == 0: | |
339 | self.cpusize = self.ncores * self.nstrands | |
340 | self.coresize = self.nstrands | |
341 | self.ucoresize = 1 | |
342 | else: | |
343 | self.cpusize = self.ncores * self.nucores * self.nstrands | |
344 | self.coresize = self.nucores * self.nstrands | |
345 | self.ucoresize = self.nstrands | |
346 | ||
347 | self.nstrandObjs = self.cpusize * self.ncpus | |
348 | ||
349 | # thread state: 1 == enabled | |
350 | self.thdEnable = { 0:1 } | |
351 | # instr executed on each strand | |
352 | self.instrCount = { 0:0 } | |
353 | ||
354 | # breakpoint, id:vaddr (in uint64 format) | |
355 | self.bpoint = { } | |
356 | # next breakpoint id | |
357 | self.nextBpoint = 0 | |
358 | ||
359 | # the last strand that issued 'ssi'. | |
360 | # TODO if a user call backend step() directly, it will bypass this | |
361 | # lastTid tracking, it will also bypass breakpoint handling. | |
362 | # ---> with breakpoint set in backend strand.step(), we can catch | |
363 | # breakpoint now. 4/13/05 | |
364 | self.lastTid = 0 | |
365 | # thread/core/cpu mapping | |
366 | self.strandMap = { } | |
367 | self.ucoreMap = { } | |
368 | self.coreMap = { } | |
369 | self.cpuMap = { } | |
370 | # command alias | |
371 | self.alias = { } | |
372 | ||
373 | self.regmap = RegisterMap.RegisterMap(riesReposit.optdir['--ar']) | |
374 | # command mapping | |
375 | self.cmdRE = { } | |
376 | # docs | |
377 | self.DOCS = { } | |
378 | # command extension | |
379 | self.cmdExt = { } | |
380 | # register interactive commands | |
381 | self.initCmd() | |
382 | # allow registration of a command map to re-direct commands to | |
383 | # a different command parser. | |
384 | self.cmdMap = None | |
385 | ||
386 | ||
387 | ####################################### | |
388 | #Function to check the argument types | |
389 | ||
390 | self.intStr = '(^[0-9]+[lL]?$)|(^0[xX][0-9a-fA-F]+[lL]?$)' | |
391 | self.intStrRE = re.compile(self.intStr) | |
392 | ||
393 | try: | |
394 | # import XX_Main.cc as nas, if available | |
395 | if self.riesReposit.arch == 'n2': | |
396 | import n2 as nas | |
397 | else: | |
398 | sys.stderr.write('ERROR: %s not a supported cpu type\n' % (self.riesReposit.arch)) | |
399 | self.nas = nas | |
400 | except: | |
401 | self.nas = None | |
402 | ||
403 | try: | |
404 | # import backend | |
405 | if self.riesReposit.arch == 'n2': | |
406 | import _N2_Python as vonk | |
407 | else: | |
408 | sys.stderr.write('ERROR: %s not a supported cpu type\n' % (self.riesReposit.arch)) | |
409 | self.vonk = vonk | |
410 | except: | |
411 | self.vonk = None | |
412 | ||
413 | ||
414 | def checkArgs(self,Args): | |
415 | """Return a list of boolean values. | |
416 | True if the arg is an int/long | |
417 | False otherwise | |
418 | """ | |
419 | retval = [] | |
420 | for arg in Args: | |
421 | matchOb = self.intStrRE.match(arg) | |
422 | if matchOb == None: | |
423 | retval.append(False) | |
424 | else: | |
425 | retval.append(True) | |
426 | return retval | |
427 | ||
428 | ||
429 | # Function to code double and quad precision | |
430 | # register numbers | |
431 | def codeFpreg(self,regnum, type): | |
432 | """type = 0, code double precision | |
433 | = 1, code quad precision | |
434 | """ | |
435 | val = int(regnum) | |
436 | if type == 0: | |
437 | return str(val << 1) # | (val & 0x10 >> 4)) | |
438 | else: | |
439 | return str(val << 2) # & ~0x3) << 1) | (val & 0x10 >> 4)) | |
440 | ||
441 | ||
442 | def truncVal(self, val, type): | |
443 | """truncate string if larger than | |
444 | 16 or 8 bytes depending on | |
445 | whether type is 1 or 0 | |
446 | """ | |
447 | #sys.stderr.write('DB: truncVal(): <%s>\n' % val) | |
448 | if val.startswith('0X') or val.startswith('0x'): | |
449 | intval = long(val,16) | |
450 | else: | |
451 | intval = long(val,10) | |
452 | ||
453 | # append 'L' to value to quiet complain about larger than 32bit value | |
454 | hexval = '%xL' % intval | |
455 | length = len(hexval) - 1 | |
456 | #sys.stderr.write('DBX: truncVal(): int=%#x, hex=%s, len=%d\n' % (intval, hexval, length)) #DBX | |
457 | if type == 0 and length > 8: | |
458 | return '0x'+hexval[length-8:] | |
459 | elif type == 1 and length > 16: | |
460 | return '0x'+hexval[length-16:] | |
461 | else: | |
462 | return '0x'+hexval | |
463 | ||
464 | ||
465 | def myInt(self,val): | |
466 | val = val.upper() | |
467 | if val.startswith('0X'): | |
468 | return int(val,16) | |
469 | else: | |
470 | return int(val) | |
471 | ||
472 | def polishCommand (self, cmd): | |
473 | """append 'L' to hex values and remove the command's trailing comment | |
474 | """ | |
475 | #sys.stderr.write('DBX: polishCommand: cmd=<%s>\n' % (cmd)) #DBX | |
476 | ||
477 | # TODO be aware that if '#' is part of a valid expression, this will | |
478 | # cause problem. | |
479 | ## i = cmd.find('#') | |
480 | ## if i > -1: | |
481 | ## cmd = cmd[:i] | |
482 | #print 'input cmd=%s' % cmd #DBX | |
483 | prev = 0 | |
484 | i = cmd.find('#') | |
485 | while i > -1: | |
486 | # make sure the # is not embedded in '...' or "..." | |
487 | # 'break' command can have {action...}, so don't remove the # in | |
488 | # there either. | |
489 | j1 = cmd.rfind("'", prev, i) | |
490 | j2 = cmd.find("'", i) | |
491 | k1 = cmd.rfind('"', prev, i) | |
492 | k2 = cmd.find('"', i) | |
493 | l1 = cmd.rfind('{', 0, i) | |
494 | l2 = cmd.find('}', i) | |
495 | #print 'i=%d j1=%d j2=%d k1=%d k2=%d l1=%d l2=%d' % (i, j1, j2, k1, k2, l1, l2) #DBX | |
496 | if (((j1 > -1) and (j2 > -1) and (j1 < i) and (i < j2)) or | |
497 | ((k1 > -1) and (k2 > -1) and (k1 < i) and (i < k2)) or | |
498 | ((l1 > -1) and (l2 > -1) and (l1 < i) and (i < l2))): | |
499 | # this one is embedded in '...' or "...", not a comment sign | |
500 | # let's look for the next one | |
501 | prev = i | |
502 | i = cmd.find('#', i+1) | |
503 | else: | |
504 | break | |
505 | #print 'i=%d before cmd=%s' % (i, cmd) #DBX | |
506 | if i > -1: | |
507 | cmd = cmd[:i] | |
508 | #print ' after cmd=%s' % cmd #DBX | |
509 | ||
510 | # append 'L' to any hex value that has at least 32 bits, no, just | |
511 | # do it to all hex is simplier. Be aware of the overhead involved. | |
512 | # TODO take this out once python 2.4 fix the problem, i.e., | |
513 | # treats number like 0x80000000 as negative int32. | |
514 | tokens = cmd.split() | |
515 | i = 1 | |
516 | while i < len(tokens): | |
517 | if re.match(hexRE, tokens[i]) and tokens[i][-1].upper() != 'L': | |
518 | tokens[i] = tokens[i] + 'L' | |
519 | i += 1 | |
520 | ||
521 | #sys.stderr.write('DBX: polishCommand: cmd2=<%s>\n' % ' '.join(tokens)) #DBX | |
522 | return ' '.join(tokens) | |
523 | ||
524 | ||
525 | def initCmd (self): | |
526 | """ | |
527 | """ | |
528 | #self.dbx('enter initCmd\n') | |
529 | ||
530 | # NAME | |
531 | # % - read register by name | |
532 | # SYNOPSIS | |
533 | # % "reg-name" | |
534 | cmdSyntax = '^%[a-zA-Z]+[a-zA-Z_\d]*' | |
535 | cmdRE = re.compile(cmdSyntax) | |
536 | self.cmdRE[cmdRE] = self.handleRegName | |
537 | ||
538 | # NAME | |
539 | # <breakpoint>.break, <breakpoint>.tbreak, break - set breakpoint | |
540 | # SYNOPSIS | |
541 | # <breakpoint>.break address [length] [-r] [-w] [-x] | |
542 | # <breakpoint>.tbreak address [length] [-r] [-w] [-x] | |
543 | # break address [length] [-r] [-w] [-x] | |
544 | #cmdSyntax = '^(%s\d+\.)?(t)?%s\s+0[Xx][\dA-Fa-f]+' % (NAME_breakpoint, CMD_breakpoint_break) | |
545 | cmdSyntax = '^(%s\d+\.)?(t)?%s\s+' % (NAME_breakpoint, CMD_breakpoint_break) | |
546 | cmdRE = re.compile(cmdSyntax) | |
547 | self.cmdRE[cmdRE] = self.handleBreak | |
548 | ||
549 | # NAME | |
550 | # <context>.on, <context>.off - switch on context object | |
551 | # SYNOPSIS | |
552 | # <context>.off | |
553 | # <context>.on | |
554 | cmdSyntax = '^%s\d+\.(%s|%s)' % (NAME_context, CMD_context_on, CMD_context_off) | |
555 | cmdRE = re.compile(cmdSyntax) | |
556 | #self.cmdRE[cmdRE] = self.handleTodo | |
557 | ||
558 | # NAME | |
559 | # <image>.add-diff-file - add a diff file to the image | |
560 | # SYNOPSIS | |
561 | # <image>.add-diff-file filename | |
562 | # <image>: memory0_image, memory_cache_image, memory_ciop_image | |
563 | cmdSyntax = '^%s\d+\.%s' % (NAME_image, CMD_image_add_diff_file) | |
564 | cmdRE = re.compile(cmdSyntax) | |
565 | #self.cmdRE[cmdRE] = self.handleTodo | |
566 | ||
567 | # NAME | |
568 | # <image>.add-partial-diff-file - add a partial diff file to the image | |
569 | # SYNOPSIS | |
570 | # <image>.add-partial-diff-file filename start size | |
571 | cmdSyntax = '^%s\d+\.%s' % (NAME_image, CMD_image_add_partial_diff_file) | |
572 | cmdRE = re.compile(cmdSyntax) | |
573 | #self.cmdRE[cmdRE] = self.handleTodo | |
574 | ||
575 | # NAME | |
576 | # <image>.commit - commit modifies pages | |
577 | # SYNOPSIS | |
578 | # <image>.commit | |
579 | cmdSyntax = '^%s\d+\.%s' % (NAME_image, CMD_image_commit) | |
580 | cmdRE = re.compile(cmdSyntax) | |
581 | #self.cmdRE[cmdRE] = self.handleTodo | |
582 | ||
583 | # NAME | |
584 | # <image>.limit-memory - limit memory usage | |
585 | # SYNOPSIS | |
586 | # <image>.limit-memory [Mb] ["swapfile"] ["swapdir"] [-k] [-r] | |
587 | cmdSyntax = '^%s\d+\.%s' % (NAME_image, CMD_image_limit_memory) | |
588 | cmdRE = re.compile(cmdSyntax) | |
589 | #self.cmdRE[cmdRE] = self.handleTodo | |
590 | ||
591 | # NAME | |
592 | # <image>.save - save image to disk | |
593 | # SYNOPSIS | |
594 | # <image>.save filename [start-byte] [length] | |
595 | cmdSyntax = '^%s\d+\.%s' % (NAME_image, CMD_image_save) | |
596 | cmdRE = re.compile(cmdSyntax) | |
597 | #self.cmdRE[cmdRE] = self.handleTodo | |
598 | ||
599 | # NAME | |
600 | # <image>.x - examine image data | |
601 | # SYNOPSIS | |
602 | # <image>.x offset [size] | |
603 | cmdSyntax = '^%s\d+\.%s' % (NAME_image, CMD_image_x) | |
604 | cmdRE = re.compile(cmdSyntax) | |
605 | #self.cmdRE[cmdRE] = self.handleTodo | |
606 | ||
607 | # NAME | |
608 | # <memory-space>.map - list memory map | |
609 | # SYNOPSIS | |
610 | # <memory-space>.map | |
611 | cmdSyntax = '^%s\d+\.%s' % (NAME_memory_space, CMD_memory_space_map) | |
612 | cmdRE = re.compile(cmdSyntax) | |
613 | #self.cmdRE[cmdRE] = self.handleTodo | |
614 | ||
615 | # NAME | |
616 | # <port-space>.map - list port map | |
617 | # SYNOPSIS | |
618 | # <port-space>.map | |
619 | cmdSyntax = '^%s\d+\.%s' % (NAME_port_space, CMD_port_space_map) | |
620 | cmdRE = re.compile(cmdSyntax) | |
621 | #self.cmdRE[cmdRE] = self.handleTodo | |
622 | ||
623 | # NAME | |
624 | # <rtl-intf>.info - Drive and expect of rtl | |
625 | # SYNOPSIS | |
626 | # <rtl-intf>.info | |
627 | cmdSyntax = '^%s\d+\.%s' % (NAME_rtl_intf, CMD_rtl_intf_info) | |
628 | cmdRE = re.compile(cmdSyntax) | |
629 | #self.cmdRE[cmdRE] = self.handleTodo | |
630 | ||
631 | # NAME | |
632 | # <swerver-memory>.debug - setup the memory modeling debug level | |
633 | # SYNOPSIS | |
634 | # <swerver-memory>.debug debug_level | |
635 | cmdSyntax = '^%s\d+\.%s' % (NAME_swerver_memory, CMD_swerver_memory_debug) | |
636 | cmdRE = re.compile(cmdSyntax) | |
637 | #self.cmdRE[cmdRE] = self.handleTodo | |
638 | ||
639 | # NAME | |
640 | # <swerver-memory>.info - print information about swerver-memory model | |
641 | # SYNOPSIS | |
642 | # <swerver-memory>.info | |
643 | cmdSyntax = '^%s\d+\.%s' % (NAME_swerver_memory, CMD_swerver_memory_info) | |
644 | cmdRE = re.compile(cmdSyntax) | |
645 | #self.cmdRE[cmdRE] = self.handleTodo | |
646 | ||
647 | # NAME | |
648 | # <swerver-proc-mmu>.d-probe, <swerver-proc-mmu>.i-probe - check data tlb for | |
649 | # translation | |
650 | # SYNOPSIS | |
651 | # <swerver-proc-mmu>.d-probe address | |
652 | # <swerver-proc-mmu>.i-probe address | |
653 | cmdSyntax = '^%s\d+\.[di]-%s' % (NAME_swerver_proc_mmu, CMD_swerver_proc_mmu_probe) | |
654 | cmdRE = re.compile(cmdSyntax) | |
655 | #self.cmdRE[cmdRE] = self.handleTodo | |
656 | ||
657 | # NAME | |
658 | # <swerver-proc-mmu>.d-tlb, <swerver-proc-mmu>.i-tlb, < | |
659 | # swerver-proc-mmu>.i-tlb-entry - print data tlb contents | |
660 | # SYNOPSIS | |
661 | # <swerver-proc-mmu>.d-tlb | |
662 | # <swerver-proc-mmu>.i-tlb | |
663 | # <swerver-proc-mmu>.i-tlb-entry idx | |
664 | cmdSyntax = '^%s\d+\.[di]-%s' % (NAME_swerver_proc_mmu, CMD_swerver_proc_mmu_tlb) | |
665 | cmdRE = re.compile(cmdSyntax) | |
666 | self.cmdRE[cmdRE] = self.handleTLB | |
667 | ||
668 | cmdSyntax = '^%s\d+\.%s' % (NAME_swerver_proc_mmu, CMD_swerver_proc_mmu_i_tlb_entry) | |
669 | cmdRE = re.compile(cmdSyntax) | |
670 | self.cmdRE[cmdRE] = self.handleTLB | |
671 | ||
672 | # NAME | |
673 | # <swerver-proc-mmu>.regs - print mmu registers | |
674 | # SYNOPSIS | |
675 | # <swerver-proc-mmu>.regs | |
676 | cmdSyntax = '^%s\d+\.%s' % (NAME_swerver_proc_mmu, CMD_swerver_proc_mmu_regs) | |
677 | cmdRE = re.compile(cmdSyntax) | |
678 | #self.cmdRE[cmdRE] = self.handleTodo | |
679 | ||
680 | # NAME | |
681 | # <swerver-proc-mmu>.trace - toggle trace functionality | |
682 | # SYNOPSIS | |
683 | # <swerver-proc-mmu>.trace | |
684 | cmdSyntax = '^%s\d+\.%s' % (NAME_swerver_proc_mmu, CMD_swerver_proc_mmu_trace) | |
685 | cmdRE = re.compile(cmdSyntax) | |
686 | #self.cmdRE[cmdRE] = self.handleTodo | |
687 | ||
688 | # NAME | |
689 | # <swerver-thread-mmu>.d-probe, <swerver-thread-mmu>.i-probe - check data tlb | |
690 | # for translation | |
691 | # SYNOPSIS | |
692 | # <swerver-thread-mmu>.d-probe address | |
693 | # <swerver-thread-mmu>.i-probe address | |
694 | cmdSyntax = '^%s\d+\.[di]-%s' % (NAME_swerver_thread_mmu, CMD_swerver_thread_mmu_probe) | |
695 | cmdRE = re.compile(cmdSyntax) | |
696 | #self.cmdRE[cmdRE] = self.handleTodo | |
697 | ||
698 | # NAME | |
699 | # <swerver-thread-mmu>.regs - print mmu registers | |
700 | # SYNOPSIS | |
701 | # <swerver-thread-mmu>.regs | |
702 | cmdSyntax = '^%s\d+\.%s' % (NAME_swerver_thread_mmu, CMD_swerver_thread_mmu_regs) | |
703 | cmdRE = re.compile(cmdSyntax) | |
704 | self.cmdRE[cmdRE] = self.handleMmu | |
705 | ||
706 | # NAME | |
707 | # <swerver-thread-mmu>.trace - toggle trace functionality | |
708 | # SYNOPSIS | |
709 | # <swerver-thread-mmu>.trace | |
710 | cmdSyntax = '^%s\d+\.%s' % (NAME_swerver_thread_mmu, CMD_swerver_thread_mmu_trace) | |
711 | cmdRE = re.compile(cmdSyntax) | |
712 | #self.cmdRE[cmdRE] = self.handleTodo | |
713 | ||
714 | # NAME | |
715 | # action - bind action to breakpoint | |
716 | # SYNOPSIS | |
717 | # action id "action" | |
718 | cmdSyntax = '^%s\s+\d+' % (CMD_action) | |
719 | cmdRE = re.compile(cmdSyntax) | |
720 | #self.cmdRE[cmdRE] = self.handleTodo | |
721 | ||
722 | # NAME | |
723 | # add-directory, clear-directories, print-directories - add a directory to | |
724 | # the search path | |
725 | # SYNOPSIS | |
726 | # add-directory "path" [-prepend] | |
727 | # clear-directories | |
728 | # print-directories | |
729 | cmdSyntax = '^%s' % (CMD_add_directory) | |
730 | cmdRE = re.compile(cmdSyntax) | |
731 | #self.cmdRE[cmdRE] = self.handleTodo | |
732 | ||
733 | cmdSyntax = '^%s' % (CMD_clear_directories) | |
734 | cmdRE = re.compile(cmdSyntax) | |
735 | #self.cmdRE[cmdRE] = self.handleTodo | |
736 | ||
737 | cmdSyntax = '^%s' % (CMD_print_directories) | |
738 | cmdRE = re.compile(cmdSyntax) | |
739 | #self.cmdRE[cmdRE] = self.handleTodo | |
740 | ||
741 | # NAME | |
742 | # api-apropos - search API help | |
743 | # SYNOPSIS | |
744 | # api-apropos "search-string" | |
745 | cmdSyntax = '^%s' % (CMD_api_apropos) | |
746 | cmdRE = re.compile(cmdSyntax) | |
747 | #self.cmdRE[cmdRE] = self.handleTodo | |
748 | ||
749 | # NAME | |
750 | # api-help - get API help | |
751 | # SYNOPSIS | |
752 | # api-help "help-string" | |
753 | cmdSyntax = '^%s' % (CMD_api_help) | |
754 | cmdRE = re.compile(cmdSyntax) | |
755 | #self.cmdRE[cmdRE] = self.handleTodo | |
756 | ||
757 | # NAME | |
758 | # apropos - search for text in documentation | |
759 | # SYNOPSIS | |
760 | # apropos [-r] "string" | |
761 | cmdSyntax = '^%s' % (CMD_apropos) | |
762 | cmdRE = re.compile(cmdSyntax) | |
763 | #self.cmdRE[cmdRE] = self.handleTodo | |
764 | ||
765 | # NAME | |
766 | # break-cr, unbreak-cr - break on control register updates | |
767 | # SYNOPSIS | |
768 | # break-cr ("register"|-all|-list) | |
769 | # unbreak-cr ("register"|-all|-list) | |
770 | cmdSyntax = '^(un)?%s' % (CMD_break_cr) | |
771 | cmdRE = re.compile(cmdSyntax) | |
772 | #self.cmdRE[cmdRE] = self.handleTodo | |
773 | ||
774 | # NAME | |
775 | # break-exception, unbreak-exception - break on control register updates | |
776 | # SYNOPSIS | |
777 | # break-exception ("name"|number|-all|-list) | |
778 | # unbreak-exception ("name"|number|-all|-list) | |
779 | cmdSyntax = '^(un)?%s' % (CMD_break_exception) | |
780 | cmdRE = re.compile(cmdSyntax) | |
781 | #self.cmdRE[cmdRE] = self.handleTodo | |
782 | ||
783 | # NAME | |
784 | # break-hap, unbreak-hap - break on haps | |
785 | # SYNOPSIS | |
786 | # break-hap ("hap"|-all|-list) | |
787 | # unbreak-hap ("hap"|-all|-list) | |
788 | cmdSyntax = '^(un)?%s' % (CMD_break_hap) | |
789 | cmdRE = re.compile(cmdSyntax) | |
790 | #self.cmdRE[cmdRE] = self.handleTodo | |
791 | ||
792 | # NAME | |
793 | # break-io, unbreak-io - break on device accesses | |
794 | # SYNOPSIS | |
795 | # break-io ("device"|-all|-list) | |
796 | # unbreak-io ("device"|-all|-list) | |
797 | cmdSyntax = '^(un)?%s' % (CMD_break_io) | |
798 | cmdRE = re.compile(cmdSyntax) | |
799 | #self.cmdRE[cmdRE] = self.handleTodo | |
800 | ||
801 | # NAME | |
802 | # catch-exception, uncatch-exception - catch exceptions | |
803 | # SYNOPSIS | |
804 | # catch-exception [("name"|number|-all)] | |
805 | # uncatch-exception [("name"|vector|-all)] | |
806 | cmdSyntax = '^(un)?%s' % (CMD_catch_exception) | |
807 | cmdRE = re.compile(cmdSyntax) | |
808 | #self.cmdRE[cmdRE] = self.handleTodo | |
809 | ||
810 | # NAME | |
811 | # command-list - generate html document describing commands | |
812 | # SYNOPSIS | |
813 | # command-list file | |
814 | #cmdSyntax = '^%s\s+\S+' % (CMD_command_list) | |
815 | cmdSyntax = '^%s' % (CMD_command_list) | |
816 | cmdRE = re.compile(cmdSyntax) | |
817 | #self.cmdRE[cmdRE] = self.handleTodo | |
818 | ||
819 | # NAME | |
820 | # cycle-break-absolute, <processor>.cycle-break, < | |
821 | # processor>.cycle-break-absolute, cycle-break - set absolute cycle | |
822 | # breakpoint | |
823 | # SYNOPSIS | |
824 | # <processor>.cycle-break cycles | |
825 | # <processor>.cycle-break-absolute cycles | |
826 | # cycle-break ["cpu-name"] cycles | |
827 | # cycle-break-absolute ["cpu-name"] cycles | |
828 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_cycle_break_absolute) | |
829 | cmdRE = re.compile(cmdSyntax) | |
830 | #self.cmdRE[cmdRE] = self.handleTodo | |
831 | ||
832 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_cycle_break) | |
833 | cmdRE = re.compile(cmdSyntax) | |
834 | #self.cmdRE[cmdRE] = self.handleTodo | |
835 | ||
836 | # NAME | |
837 | # debug-level - set or get the debug level | |
838 | # SYNOPSIS | |
839 | # debug-level "object-name" [level] | |
840 | cmdSyntax = '^%s' % (CMD_debug_level) | |
841 | cmdRE = re.compile(cmdSyntax) | |
842 | #self.cmdRE[cmdRE] = self.handleTodo | |
843 | ||
844 | # NAME | |
845 | # delete - remove a breakpoint | |
846 | # SYNOPSIS | |
847 | # delete (-all|id) | |
848 | #cmdSyntax = '^%s\s+(-all|\d+(\s+\d+)*)' % (CMD_delete) | |
849 | cmdSyntax = '^%s\s+' % (CMD_delete) | |
850 | cmdRE = re.compile(cmdSyntax) | |
851 | self.cmdRE[cmdRE] = self.handleDelete | |
852 | ||
853 | # NAME | |
854 | # device-interrupt - Device interrupt | |
855 | # SYNOPSIS | |
856 | # device-interrupt issue-device target-thread intvec | |
857 | cmdSyntax = '^%s' % (CMD_device_interrupt) | |
858 | cmdRE = re.compile(cmdSyntax) | |
859 | #self.cmdRE[cmdRE] = self.handleTodo | |
860 | ||
861 | # NAME | |
862 | # devs - list all devices in system | |
863 | # SYNOPSIS | |
864 | # devs ["object-name"] | |
865 | cmdSyntax = '^%s' % (CMD_devs) | |
866 | cmdRE = re.compile(cmdSyntax) | |
867 | #self.cmdRE[cmdRE] = self.handleTodo | |
868 | ||
869 | # NAME | |
870 | # disassemble, <processor>.disassemble - disassemble instructions | |
871 | # SYNOPSIS | |
872 | # <processor>.disassemble [address] [count] | |
873 | # disassemble ["cpu-name"] [address] [count] | |
874 | cmdSyntax ='^(%s\d+\.%s\s*)|^(%s(\s*%s\d+)?\s*)' % (NAME_processor, CMD_disassemble,CMD_disassemble,NAME_processor) | |
875 | cmdRE = re.compile(cmdSyntax) | |
876 | self.cmdRE[cmdRE] = self.handleDisassemble | |
877 | ||
878 | # NAME | |
879 | # display - print expression at prompt | |
880 | # SYNOPSIS | |
881 | # display ["expression"] [-l] [-p] [-t] | |
882 | cmdSyntax = '^%s' % (CMD_display) | |
883 | cmdRE = re.compile(cmdSyntax) | |
884 | #self.cmdRE[cmdRE] = self.handleTodo | |
885 | ||
886 | # NAME | |
887 | # echo - echo a value to screen | |
888 | # SYNOPSIS | |
889 | # echo [("string"|integer|float)] | |
890 | #cmdSyntax = '^(%s|%s\s+.*)' % (CMD_echo, CMD_echo) | |
891 | cmdSyntax = '^%s' % (CMD_echo) | |
892 | cmdRE = re.compile(cmdSyntax) | |
893 | self.cmdRE[cmdRE] = self.handleEcho | |
894 | ||
895 | # NAME | |
896 | # enable, disable - enable/disable breakpoint | |
897 | # SYNOPSIS | |
898 | # disable (-all|id) | |
899 | # enable (-all|id) | |
900 | #cmdSyntax = '^%s\s+(-all|\d+)' % (CMD_enable) | |
901 | cmdSyntax = '^(%s|%s\s+.*)' % (CMD_enable, CMD_enable) | |
902 | cmdRE = re.compile(cmdSyntax) | |
903 | self.cmdRE[cmdRE] = self.handleEnable | |
904 | ||
905 | cmdSyntax = '^(%s|%s\s+.*)' % (CMD_disable, CMD_disable) | |
906 | cmdRE = re.compile(cmdSyntax) | |
907 | self.cmdRE[cmdRE] = self.handleDisable | |
908 | ||
909 | # NAME | |
910 | # enable-external-commands - enable external command port | |
911 | # SYNOPSIS | |
912 | # enable-external-commands [port] | |
913 | cmdSyntax = '^%s' % (CMD_enable_external_commands) | |
914 | cmdRE = re.compile(cmdSyntax) | |
915 | #self.cmdRE[cmdRE] = self.handleTodo | |
916 | ||
917 | # NAME | |
918 | # enable-real-time-mode, disable-real-time-mode - set real time mode | |
919 | # SYNOPSIS | |
920 | # disable-real-time-mode | |
921 | # enable-real-time-mode [speed] [check_interval] | |
922 | cmdSyntax = '^%s' % (CMD_enable_real_time_mode) | |
923 | cmdRE = re.compile(cmdSyntax) | |
924 | #self.cmdRE[cmdRE] = self.handleTodo | |
925 | ||
926 | cmdSyntax = '^%s' % (CMD_disable_real_time_mode) | |
927 | cmdRE = re.compile(cmdSyntax) | |
928 | #self.cmdRE[cmdRE] = self.handleTodo | |
929 | ||
930 | # NAME | |
931 | # eosl - end-of-sas-line | |
932 | # SYNOPSIS | |
933 | # eosl | |
934 | cmdSyntax = '^%s' % (CMD_eosl) | |
935 | cmdRE = re.compile(cmdSyntax) | |
936 | #self.cmdRE[cmdRE] = self.handleTodo | |
937 | ||
938 | # NAME | |
939 | # expect - fail if not equal | |
940 | # SYNOPSIS | |
941 | # expect i1 i2 [-v] | |
942 | #cmdSyntax = '^%s\s+(\(.+\)\s+(\d+|0[Xx][\dA-Fa-f]+)|(\d+|0[Xx][\dA-Fa-f]+)\s+(\d+|0[Xx][\dA-Fa-f]+))' % (CMD_expect) | |
943 | cmdSyntax = '^%s\s+\S+' % (CMD_expect) | |
944 | cmdRE = re.compile(cmdSyntax) | |
945 | self.cmdRE[cmdRE] = self.handleExpect | |
946 | ||
947 | # NAME | |
948 | # gdb-remote - start gdb-remote | |
949 | # SYNOPSIS | |
950 | # gdb-remote [port] | |
951 | cmdSyntax = '^%s' % (CMD_gdb_remote) | |
952 | cmdRE = re.compile(cmdSyntax) | |
953 | #self.cmdRE[cmdRE] = self.handleTodo | |
954 | ||
955 | # NAME | |
956 | # get, <memory-space>.get - get value of physical address | |
957 | # SYNOPSIS | |
958 | # <memory-space>.get address [size] [-l] [-b] | |
959 | # get address [size] [-l] [-b] | |
960 | #cmdSyntax = '^(%s\d+\.)?%s\s+0[Xx][\dA-Fa-f]+' % (NAME_memory_space, CMD_get) | |
961 | cmdSyntax = '^(%s\d+\.)?%s\s+' % (NAME_memory_space, CMD_get) | |
962 | cmdRE = re.compile(cmdSyntax) | |
963 | self.cmdRE[cmdRE] = self.handleGet | |
964 | ||
965 | # NAME | |
966 | # help - help command | |
967 | # SYNOPSIS | |
968 | # help [("help-string"|-all)] | |
969 | cmdSyntax = '^(%s\s*$|%s\s+\S+)' % (CMD_help, CMD_help) | |
970 | cmdRE = re.compile(cmdSyntax) | |
971 | self.cmdRE[cmdRE] = self.handleHelp | |
972 | ||
973 | # NAME | |
974 | # hex - display integer in hexadecimal notation | |
975 | # SYNOPSIS | |
976 | # hex value | |
977 | cmdSyntax = '^%s\s+\d+' % (CMD_hex) | |
978 | cmdRE = re.compile(cmdSyntax) | |
979 | #self.cmdRE[cmdRE] = self.handleTodo | |
980 | ||
981 | # NAME | |
982 | # ignore - set ignore count for a breakpoint | |
983 | # SYNOPSIS | |
984 | # ignore id num | |
985 | #cmdSyntax = '^%s\s+\d+\s+\d+' % (CMD_ignore) | |
986 | cmdSyntax = '^%s\s+' % (CMD_ignore) | |
987 | cmdRE = re.compile(cmdSyntax) | |
988 | self.cmdRE[cmdRE] = self.handleIgnore | |
989 | ||
990 | # NAME | |
991 | # instruction-profile-mode - set or get current mode for instruction | |
992 | # profiling | |
993 | # SYNOPSIS | |
994 | # instruction-profile-mode ["mode"] | |
995 | cmdSyntax = '^%s' % (CMD_instruction_profile_mode) | |
996 | cmdRE = re.compile(cmdSyntax) | |
997 | #self.cmdRE[cmdRE] = self.handleTodo | |
998 | ||
999 | # NAME | |
1000 | # io - print I/O trace | |
1001 | # SYNOPSIS | |
1002 | # io ["object-name"] [count] | |
1003 | cmdSyntax = '^%s' % (CMD_io) | |
1004 | cmdRE = re.compile(cmdSyntax) | |
1005 | #self.cmdRE[cmdRE] = self.handleTodo | |
1006 | ||
1007 | # NAME | |
1008 | # io-buffer - set I/O buffer size | |
1009 | # SYNOPSIS | |
1010 | # io-buffer ["object-name"] [size] | |
1011 | cmdSyntax = '^%s' % (CMD_io_buffer) | |
1012 | cmdRE = re.compile(cmdSyntax) | |
1013 | #self.cmdRE[cmdRE] = self.handleTodo | |
1014 | ||
1015 | # NAME | |
1016 | # istc-enable, dstc-disable, dstc-enable, istc-disable, stc-status - enable | |
1017 | # or disable internal caches | |
1018 | # SYNOPSIS | |
1019 | # dstc-disable | |
1020 | # dstc-enable | |
1021 | # istc-disable | |
1022 | # istc-enable | |
1023 | # stc-status | |
1024 | cmdSyntax = '^%s' % (CMD_dstc_disable) | |
1025 | cmdRE = re.compile(cmdSyntax) | |
1026 | #self.cmdRE[cmdRE] = self.handleTodo | |
1027 | ||
1028 | cmdSyntax = '^%s' % (CMD_dstc_enable) | |
1029 | cmdRE = re.compile(cmdSyntax) | |
1030 | #self.cmdRE[cmdRE] = self.handleTodo | |
1031 | ||
1032 | cmdSyntax = '^%s' % (CMD_istc_disable) | |
1033 | cmdRE = re.compile(cmdSyntax) | |
1034 | #self.cmdRE[cmdRE] = self.handleTodo | |
1035 | ||
1036 | cmdSyntax = '^%s' % (CMD_istc_enable) | |
1037 | cmdRE = re.compile(cmdSyntax) | |
1038 | #self.cmdRE[cmdRE] = self.handleTodo | |
1039 | ||
1040 | cmdSyntax = '^%s' % (CMD_stc_status) | |
1041 | cmdRE = re.compile(cmdSyntax) | |
1042 | #self.cmdRE[cmdRE] = self.handleTodo | |
1043 | ||
1044 | # NAME | |
1045 | # le-checksum - display the checksum of the module-list attribute | |
1046 | # SYNOPSIS | |
1047 | # le-checksum ["obj"] | |
1048 | cmdSyntax = '^%s' % (CMD_le_checksum) | |
1049 | cmdRE = re.compile(cmdSyntax) | |
1050 | #self.cmdRE[cmdRE] = self.handleTodo | |
1051 | ||
1052 | # NAME | |
1053 | # le-permissions - describe the current 'Limited Edition' permissions | |
1054 | # SYNOPSIS | |
1055 | # le-permissions ["obj"] | |
1056 | cmdSyntax = '^%s' % (CMD_le_permissions) | |
1057 | cmdRE = re.compile(cmdSyntax) | |
1058 | #self.cmdRE[cmdRE] = self.handleTodo | |
1059 | ||
1060 | # NAME | |
1061 | # list-attributes - list all attributes | |
1062 | # SYNOPSIS | |
1063 | # list-attributes "object-name" ["attribute-name"] | |
1064 | cmdSyntax = '^%s' % (CMD_list_attributes) | |
1065 | cmdRE = re.compile(cmdSyntax) | |
1066 | #self.cmdRE[cmdRE] = self.handleTodo | |
1067 | ||
1068 | # NAME | |
1069 | # list-breakpoints - print information about breakpoints | |
1070 | # SYNOPSIS | |
1071 | # list-breakpoints [-all] | |
1072 | cmdSyntax = '^%s' % (CMD_list_breakpoints) | |
1073 | cmdRE = re.compile(cmdSyntax) | |
1074 | self.cmdRE[cmdRE] = self.handleListBreak | |
1075 | ||
1076 | # NAME | |
1077 | # list-classes - list all configuration classes | |
1078 | # SYNOPSIS | |
1079 | # list-classes | |
1080 | cmdSyntax = '^%s' % (CMD_list_classes) | |
1081 | cmdRE = re.compile(cmdSyntax) | |
1082 | #self.cmdRE[cmdRE] = self.handleTodo | |
1083 | ||
1084 | # NAME | |
1085 | # list-failed-modules - show list of failed modules | |
1086 | # SYNOPSIS | |
1087 | # list-failed-modules ["substr"] [-v] | |
1088 | cmdSyntax = '^%s' % (CMD_list_failed_modules) | |
1089 | cmdRE = re.compile(cmdSyntax) | |
1090 | #self.cmdRE[cmdRE] = self.handleTodo | |
1091 | ||
1092 | # NAME | |
1093 | # list-haps - print list of haps | |
1094 | # SYNOPSIS | |
1095 | # list-haps ["substring"] | |
1096 | cmdSyntax = '^%s' % (CMD_list_haps) | |
1097 | cmdRE = re.compile(cmdSyntax) | |
1098 | #self.cmdRE[cmdRE] = self.handleTodo | |
1099 | ||
1100 | # NAME | |
1101 | # list-modules - list loadable modules | |
1102 | # SYNOPSIS | |
1103 | # list-modules ["substr"] [-v] | |
1104 | cmdSyntax = '^%s' % (CMD_list_modules) | |
1105 | cmdRE = re.compile(cmdSyntax) | |
1106 | #self.cmdRE[cmdRE] = self.handleTodo | |
1107 | ||
1108 | # NAME | |
1109 | # list-namespaces - list all namespaces | |
1110 | # SYNOPSIS | |
1111 | # list-namespaces | |
1112 | cmdSyntax = '^%s' % (CMD_list_namespaces) | |
1113 | cmdRE = re.compile(cmdSyntax) | |
1114 | #self.cmdRE[cmdRE] = self.handleTodo | |
1115 | ||
1116 | # NAME | |
1117 | # list-profilers - list description of active profilers | |
1118 | # SYNOPSIS | |
1119 | # list-profilers | |
1120 | cmdSyntax = '^%s' % (CMD_list_profilers) | |
1121 | cmdRE = re.compile(cmdSyntax) | |
1122 | #self.cmdRE[cmdRE] = self.handleTodo | |
1123 | ||
1124 | # NAME | |
1125 | # list-vars - list environment variables | |
1126 | # SYNOPSIS | |
1127 | # list-vars | |
1128 | cmdSyntax = '^%s' % (CMD_list_vars) | |
1129 | cmdRE = re.compile(cmdSyntax) | |
1130 | #self.cmdRE[cmdRE] = self.handleTodo | |
1131 | ||
1132 | # NAME | |
1133 | # load-binary, <memory-space>.load-binary - load binary (executable) file | |
1134 | # into memory | |
1135 | # SYNOPSIS | |
1136 | # <memory-space>.load-binary filename [offset] [-v] [-pa] | |
1137 | # load-binary filename [offset] [-v] [-pa] | |
1138 | #cmdSyntax = '^(%s\d+\.)?%s\s+\S+' % (NAME_memory_space, CMD_load_binary) | |
1139 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_memory_space, CMD_load_binary) | |
1140 | cmdRE = re.compile(cmdSyntax) | |
1141 | #self.cmdRE[cmdRE] = self.handleTodo | |
1142 | ||
1143 | # NAME | |
1144 | # load-file, <memory-space>.load-file - load file into memory | |
1145 | # SYNOPSIS | |
1146 | # <memory-space>.load-file filename [offset] | |
1147 | # load-file filename [offset] | |
1148 | #cmdSyntax = '^(%s\d+\.)?%s\s+\S+' % (NAME_memory_space, CMD_load_file) | |
1149 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_memory_space, CMD_load_file) | |
1150 | cmdRE = re.compile(cmdSyntax) | |
1151 | #self.cmdRE[cmdRE] = self.handleTodo | |
1152 | ||
1153 | # NAME | |
1154 | # load-module - load module into system | |
1155 | # SYNOPSIS | |
1156 | # load-module "module" | |
1157 | cmdSyntax = '^%s' % (CMD_load_module) | |
1158 | cmdRE = re.compile(cmdSyntax) | |
1159 | #self.cmdRE[cmdRE] = self.handleTodo | |
1160 | ||
1161 | # NAME | |
1162 | # load-veri-file - load the physical addres from verilog memory format file | |
1163 | # SYNOPSIS | |
1164 | # load-veri-file "verilog-mem-format-file-name" | |
1165 | cmdSyntax = '^%s' % (CMD_load_veri_file) | |
1166 | cmdRE = re.compile(cmdSyntax) | |
1167 | #self.cmdRE[cmdRE] = self.handleTodo | |
1168 | ||
1169 | # NAME | |
1170 | # logical-to-physical, <processor>.logical-to-physical - translate logical | |
1171 | # address to physical | |
1172 | # SYNOPSIS | |
1173 | # <processor>.logical-to-physical address | |
1174 | # logical-to-physical ["cpu-name"] address | |
1175 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_logical_to_physical) | |
1176 | cmdRE = re.compile(cmdSyntax) | |
1177 | self.cmdRE[cmdRE] = self.handleVa2Pa | |
1178 | ||
1179 | # NAME | |
1180 | # magic-break-enable, magic-break-disable - install magic instruction hap | |
1181 | # handler | |
1182 | # SYNOPSIS | |
1183 | # magic-break-disable | |
1184 | # magic-break-enable | |
1185 | cmdSyntax = '^%s' % (CMD_magic_break_enable) | |
1186 | cmdRE = re.compile(cmdSyntax) | |
1187 | #self.cmdRE[cmdRE] = self.handleTodo | |
1188 | ||
1189 | cmdSyntax = '^%s' % (CMD_magic_break_disable) | |
1190 | cmdRE = re.compile(cmdSyntax) | |
1191 | #self.cmdRE[cmdRE] = self.handleTodo | |
1192 | ||
1193 | # NAME | |
1194 | # memory-profile - enable or disable memory profiling | |
1195 | # SYNOPSIS | |
1196 | # memory-profile ["mode"] | |
1197 | cmdSyntax = '^%s' % (CMD_memory_profile) | |
1198 | cmdRE = re.compile(cmdSyntax) | |
1199 | #self.cmdRE[cmdRE] = self.handleTodo | |
1200 | ||
1201 | # NAME | |
1202 | # module-list-refresh - create a new list of loadable modules | |
1203 | # SYNOPSIS | |
1204 | # module-list-refresh | |
1205 | cmdSyntax = '^%s' % (CMD_module_list_refresh) | |
1206 | cmdRE = re.compile(cmdSyntax) | |
1207 | #self.cmdRE[cmdRE] = self.handleTodo | |
1208 | ||
1209 | # NAME | |
1210 | # native-path - convert a filename to host native form | |
1211 | # SYNOPSIS | |
1212 | # native-path "filename" | |
1213 | cmdSyntax = '^%s' % (CMD_native_path) | |
1214 | cmdRE = re.compile(cmdSyntax) | |
1215 | #self.cmdRE[cmdRE] = self.handleTodo | |
1216 | ||
1217 | # NAME | |
1218 | # new-context - create a new context | |
1219 | # SYNOPSIS | |
1220 | # new-context "name" | |
1221 | cmdSyntax = '^%s' % (CMD_new_context) | |
1222 | cmdRE = re.compile(cmdSyntax) | |
1223 | #self.cmdRE[cmdRE] = self.handleTodo | |
1224 | ||
1225 | # NAME | |
1226 | # output-radix - change the default output radix | |
1227 | # SYNOPSIS | |
1228 | # output-radix [base] | |
1229 | cmdSyntax = '^%s' % (CMD_output_radix) | |
1230 | cmdRE = re.compile(cmdSyntax) | |
1231 | #self.cmdRE[cmdRE] = self.handleTodo | |
1232 | ||
1233 | # NAME | |
1234 | # pdisassemble - disassemble instructions in physical memory | |
1235 | # SYNOPSIS | |
1236 | # pdisassemble [address] [count] | |
1237 | cmdSyntax = '^%s' % (CMD_pdisassemble) | |
1238 | cmdRE = re.compile(cmdSyntax) | |
1239 | #self.cmdRE[cmdRE] = self.handleTodo | |
1240 | ||
1241 | # NAME | |
1242 | # penable, <processor>.disable, <processor>.enable, pdisable - switch | |
1243 | # processor on | |
1244 | # SYNOPSIS | |
1245 | # <processor>.disable | |
1246 | # <processor>.enable | |
1247 | # pdisable [("cpu-name"|-all)] | |
1248 | # penable [("cpu-name"|-all)] | |
1249 | cmdSyntax = '^(%s|%s\d+\.%s)' % (CMD_penable, NAME_processor, CMD_enable) | |
1250 | cmdRE = re.compile(cmdSyntax) | |
1251 | self.cmdRE[cmdRE] = self.handlePenable | |
1252 | ||
1253 | cmdSyntax = '^(%s|%s\d+\.%s)' % (CMD_pdisable, NAME_processor, CMD_disable) | |
1254 | cmdRE = re.compile(cmdSyntax) | |
1255 | self.cmdRE[cmdRE] = self.handlePdisable | |
1256 | ||
1257 | # NAME | |
1258 | # pio - print information about an object | |
1259 | # SYNOPSIS | |
1260 | # pio "object-name" | |
1261 | cmdSyntax = '^%s' % (CMD_pio) | |
1262 | cmdRE = re.compile(cmdSyntax) | |
1263 | #self.cmdRE[cmdRE] = self.handleTodo | |
1264 | ||
1265 | # NAME | |
1266 | # pipe - run commands through a pipe | |
1267 | # SYNOPSIS | |
1268 | # pipe "command" "pipe" | |
1269 | cmdSyntax = '^%s' % (CMD_pipe) | |
1270 | cmdRE = re.compile(cmdSyntax) | |
1271 | #self.cmdRE[cmdRE] = self.handleTodo | |
1272 | ||
1273 | # NAME | |
1274 | # pli-run - Run # of instruction through PLI command interface | |
1275 | # SYNOPSIS | |
1276 | # pli-run value | |
1277 | #cmdSyntax = '^%s\s+\d+' % (CMD_pli_run) | |
1278 | cmdSyntax = '^%s' % (CMD_pli_run) | |
1279 | cmdRE = re.compile(cmdSyntax) | |
1280 | #self.cmdRE[cmdRE] = self.handlePlirun | |
1281 | ||
1282 | # NAME | |
1283 | # pregs, <processor>.pregs - print cpu registers | |
1284 | # SYNOPSIS | |
1285 | # <processor>.pregs [-all] | |
1286 | # pregs ["cpu-name"] [-all] | |
1287 | cmdSyntax = '^(%s\d+\.)?%s$|^(%s\d+\.)?%s\s+' % (NAME_processor, CMD_pregs, NAME_processor, CMD_pregs) | |
1288 | cmdRE = re.compile(cmdSyntax) | |
1289 | self.cmdRE[cmdRE] = self.handlePregs | |
1290 | ||
1291 | # NAME | |
1292 | # fpregs, <processor>.fpregs - print cpu fp registers | |
1293 | # SYNOPSIS | |
1294 | # <processor>.fpregs | |
1295 | # fpregs ["cpu-name"] | |
1296 | cmdSyntax = '^(%s\d+\.)?%s$|^(%s\d+\.)?%s\s+' % (NAME_processor, CMD_fpregs, NAME_processor, CMD_fpregs) | |
1297 | cmdRE = re.compile(cmdSyntax) | |
1298 | self.cmdRE[cmdRE] = self.handleFpregs | |
1299 | ||
1300 | # NAME | |
1301 | # cmpregs, <processor>.cmpregs - print cmp registers | |
1302 | # SYNOPSIS | |
1303 | # <processor>.cmpregs | |
1304 | # cmpregs ["cpu-name"] | |
1305 | cmdSyntax = '^(%s\d+\.)?%s$|^(%s\d+\.)?%s\s+' % (NAME_processor, CMD_cmpregs, NAME_processor, CMD_cmpregs) | |
1306 | cmdRE = re.compile(cmdSyntax) | |
1307 | self.cmdRE[cmdRE] = self.handleCmpregs | |
1308 | ||
1309 | # NAME | |
1310 | # mmuregs, <processor>.mmuregs - print mmu registers | |
1311 | # SYNOPSIS | |
1312 | # <processor>.mmuregs | |
1313 | # mmuregs ["cpu-name"] | |
1314 | cmdSyntax = '^(%s\d+\.)?%s$|^(%s\d+\.)?%s\s+' % (NAME_processor, CMD_mmuregs, NAME_processor, CMD_mmuregs) | |
1315 | cmdRE = re.compile(cmdSyntax) | |
1316 | self.cmdRE[cmdRE] = self.handleMmuregs | |
1317 | ||
1318 | # NAME | |
1319 | # pregs-all - print all cpu registers | |
1320 | # SYNOPSIS | |
1321 | # pregs-all ["cpu-name"] | |
1322 | cmdSyntax = '^%s' % (CMD_pregs_all) | |
1323 | cmdRE = re.compile(cmdSyntax) | |
1324 | #self.cmdRE[cmdRE] = self.handleTodo | |
1325 | ||
1326 | # NAME | |
1327 | # pregs-hyper, <processor>.pregs-hyper - print hypervisor registers | |
1328 | # SYNOPSIS | |
1329 | # <processor>.pregs-hyper [-all] | |
1330 | # pregs-hyper ["cpu-name"] [-all] | |
1331 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_pregs_hyper) | |
1332 | cmdRE = re.compile(cmdSyntax) | |
1333 | #self.cmdRE[cmdRE] = self.handleTodo | |
1334 | ||
1335 | # NAME | |
1336 | # print - display integer in various bases | |
1337 | # SYNOPSIS | |
1338 | # print [(-x|-o|-b|-s|-d)] value [size] | |
1339 | #cmdSyntax = '^%s' % (CMD_print) | |
1340 | #cmdRE = re.compile(cmdSyntax) | |
1341 | #self.cmdRE[cmdRE] = self.handleTodo | |
1342 | ||
1343 | # NAME | |
1344 | # print-double-regs - print floating point registers as doubles | |
1345 | # SYNOPSIS | |
1346 | # print-double-regs | |
1347 | cmdSyntax = '^%s' % (CMD_print_double_regs) | |
1348 | cmdRE = re.compile(cmdSyntax) | |
1349 | #self.cmdRE[cmdRE] = self.handleTodo | |
1350 | ||
1351 | # NAME | |
1352 | # print-event-queue - print event queue for processor | |
1353 | # SYNOPSIS | |
1354 | # print-event-queue ["cpu-name"] [queue] | |
1355 | cmdSyntax = '^%s' % (CMD_print_event_queue) | |
1356 | cmdRE = re.compile(cmdSyntax) | |
1357 | #self.cmdRE[cmdRE] = self.handleTodo | |
1358 | ||
1359 | # NAME | |
1360 | # print-float-regs - print floating point registers | |
1361 | # SYNOPSIS | |
1362 | # print-float-regs | |
1363 | cmdSyntax = '^%s' % (CMD_print_float_regs) | |
1364 | cmdRE = re.compile(cmdSyntax) | |
1365 | #self.cmdRE[cmdRE] = self.handleTodo | |
1366 | ||
1367 | # NAME | |
1368 | # print-float-regs-raw - print raw floating point register contents | |
1369 | # SYNOPSIS | |
1370 | # print-float-regs-raw | |
1371 | cmdSyntax = '^%s' % (CMD_print_float_regs_raw) | |
1372 | cmdRE = re.compile(cmdSyntax) | |
1373 | #self.cmdRE[cmdRE] = self.handleTodo | |
1374 | ||
1375 | # NAME | |
1376 | # print-instruction-queue - print instruction queue | |
1377 | # SYNOPSIS | |
1378 | # print-instruction-queue [-v] | |
1379 | cmdSyntax = '^%s' % (CMD_print_instruction_queue) | |
1380 | cmdRE = re.compile(cmdSyntax) | |
1381 | #self.cmdRE[cmdRE] = self.handleTodo | |
1382 | ||
1383 | # NAME | |
1384 | # print-profile - print execution profile | |
1385 | # SYNOPSIS | |
1386 | # print-profile [address] [length] | |
1387 | cmdSyntax = '^%s' % (CMD_print_profile) | |
1388 | cmdRE = re.compile(cmdSyntax) | |
1389 | #self.cmdRE[cmdRE] = self.handleTodo | |
1390 | ||
1391 | # NAME | |
1392 | # print-statistics, <processor>.print-statistics - print various statistics | |
1393 | # SYNOPSIS | |
1394 | # <processor>.print-statistics | |
1395 | # print-statistics [("cpu-name"|-all)] | |
1396 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_print_statistics) | |
1397 | cmdRE = re.compile(cmdSyntax) | |
1398 | #self.cmdRE[cmdRE] = self.handleTodo | |
1399 | ||
1400 | # NAME | |
1401 | # print-time, <processor>.print-time - print simulated time | |
1402 | # SYNOPSIS | |
1403 | # <processor>.print-time | |
1404 | # print-time ["cpu-name"] | |
1405 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_print_time) | |
1406 | cmdRE = re.compile(cmdSyntax) | |
1407 | #self.cmdRE[cmdRE] = self.handleTodo | |
1408 | ||
1409 | # NAME | |
1410 | # prof-page-details - print profile details for a page | |
1411 | # SYNOPSIS | |
1412 | # prof-page-details [address] [strand] | |
1413 | cmdSyntax = '^%s' % (CMD_prof_page_details) | |
1414 | cmdRE = re.compile(cmdSyntax) | |
1415 | #self.cmdRE[cmdRE] = self.handleTodo | |
1416 | ||
1417 | # NAME | |
1418 | # prof-page-map - print summary profile statistics for each page | |
1419 | # SYNOPSIS | |
1420 | # prof-page-map | |
1421 | cmdSyntax = '^%s' % (CMD_prof_page_map) | |
1422 | cmdRE = re.compile(cmdSyntax) | |
1423 | #self.cmdRE[cmdRE] = self.handleTodo | |
1424 | ||
1425 | # NAME | |
1426 | # prof-weight, set-prof-weight - print weighted result of profilers | |
1427 | # SYNOPSIS | |
1428 | # prof-weight [block-size] [count] | |
1429 | # set-prof-weight profiler weight | |
1430 | cmdSyntax = '^%s' % (CMD_prof_weight) | |
1431 | cmdRE = re.compile(cmdSyntax) | |
1432 | #self.cmdRE[cmdRE] = self.handleTodo | |
1433 | ||
1434 | cmdSyntax = '^%s' % (CMD_set_prof_weight) | |
1435 | cmdRE = re.compile(cmdSyntax) | |
1436 | #self.cmdRE[cmdRE] = self.handleTodo | |
1437 | ||
1438 | # NAME | |
1439 | # pselect - select a processor | |
1440 | # SYNOPSIS | |
1441 | # pselect ["cpu-name"] | |
1442 | cmdSyntax = '^%s' % (CMD_pselect) | |
1443 | cmdRE = re.compile(cmdSyntax) | |
1444 | self.cmdRE[cmdRE] = self.handlePselect | |
1445 | ||
1446 | # NAME | |
1447 | # quit - quit from system | |
1448 | # SYNOPSIS | |
1449 | # quit [status] | |
1450 | cmdSyntax = '^%s(\s+\d+)?' % (CMD_quit) | |
1451 | cmdRE = re.compile(cmdSyntax) | |
1452 | self.cmdRE[cmdRE] = self.handleQuit | |
1453 | ||
1454 | # NAME | |
1455 | # read-configuration - restore configuration | |
1456 | # SYNOPSIS | |
1457 | # read-configuration file | |
1458 | cmdSyntax = '^%s' % (CMD_read_configuration) | |
1459 | cmdRE = re.compile(cmdSyntax) | |
1460 | #self.cmdRE[cmdRE] = self.handleTodo | |
1461 | ||
1462 | # NAME | |
1463 | # read-fp-reg-i - print floating point single register as integer | |
1464 | # SYNOPSIS | |
1465 | # read-fp-reg-i reg-num | |
1466 | #cmdSyntax = '^%s\s+\d+' % (CMD_read_fp_reg_i) | |
1467 | cmdSyntax = '^%s\s+' % (CMD_read_fp_reg_i) | |
1468 | cmdRE = re.compile(cmdSyntax) | |
1469 | self.cmdRE[cmdRE] = self.handleReadFpi | |
1470 | ||
1471 | # NAME | |
1472 | # read-fp-reg-x - print floating point double register as integer | |
1473 | # SYNOPSIS | |
1474 | # read-fp-reg-x reg-num | |
1475 | #cmdSyntax = '^%s\s+\d+' % (CMD_read_fp_reg_x) | |
1476 | cmdSyntax = '^%s\s+' % (CMD_read_fp_reg_x) | |
1477 | cmdRE = re.compile(cmdSyntax) | |
1478 | self.cmdRE[cmdRE] = self.handleReadFpx | |
1479 | ||
1480 | # NAME | |
1481 | # read-reg, <processor>.read-reg - read a register | |
1482 | # SYNOPSIS | |
1483 | # <processor>.read-reg "reg-name" | |
1484 | # read-reg ["cpu-name"] "reg-name" | |
1485 | #cmdSyntax = '^(%s\d+\.%s\s+\S+|%s(\s+%s\d+)?\s+\S+' % (NAME_processor, CMD_read_reg, CMD_read_reg, NAME_cpu) | |
1486 | cmdSyntax = '^(%s\d+\.)?%s\s+' % (NAME_processor, CMD_read_reg) | |
1487 | cmdRE = re.compile(cmdSyntax) | |
1488 | self.cmdRE[cmdRE] = self.handleReadReg | |
1489 | ||
1490 | # NAME | |
1491 | # read-sw-pcs - read all pc and npc of a swerver processor | |
1492 | # SYNOPSIS | |
1493 | # read-sw-pcs "swerver-num" | |
1494 | cmdSyntax = '^%s' % (CMD_read_sw_pcs) | |
1495 | cmdRE = re.compile(cmdSyntax) | |
1496 | #self.cmdRE[cmdRE] = self.handleTodo | |
1497 | ||
1498 | # NAME | |
1499 | # read-th-ctl-reg - Control Register value of a thread | |
1500 | # SYNOPSIS | |
1501 | # read-th-ctl-reg thread control-register-num | |
1502 | #cmdSyntax = '^%s\s+\d+\s+\d+' % (CMD_read_th_ctl_reg) | |
1503 | cmdSyntax = '^%s\s+' % (CMD_read_th_ctl_reg) | |
1504 | cmdRE = re.compile(cmdSyntax) | |
1505 | self.cmdRE[cmdRE] = self.handleReadCtlReg | |
1506 | ||
1507 | # NAME | |
1508 | # write-th-ctl-reg - Control Register value of a thread | |
1509 | # SYNOPSIS | |
1510 | # write-th-ctl-reg thread control-register-num value | |
1511 | cmdSyntax = '^%s\s+' % (CMD_write_th_ctl_reg) | |
1512 | cmdRE = re.compile(cmdSyntax) | |
1513 | self.cmdRE[cmdRE] = self.handleWriteCtlReg | |
1514 | ||
1515 | # NAME | |
1516 | # read-th-fp-reg-i - Read single Fp Register value of a thread | |
1517 | # SYNOPSIS | |
1518 | # read-th-fp-reg-i thread register-num | |
1519 | #cmdSyntax = '^%s\s+\d+\s+\d+' % (CMD_read_th_fp_reg_i) | |
1520 | cmdSyntax = '^%s\s+' % (CMD_read_th_fp_reg_i) | |
1521 | cmdRE = re.compile(cmdSyntax) | |
1522 | self.cmdRE[cmdRE] = self.handleReadThFpi | |
1523 | ||
1524 | # NAME | |
1525 | # read-th-fp-reg-x - Read double Fp Register value of a thread | |
1526 | # SYNOPSIS | |
1527 | # read-th-fp-reg-x thread register-num | |
1528 | #cmdSyntax = '^%s\s+\d+\s+\d+' % (CMD_read_th_fp_reg_x) | |
1529 | cmdSyntax = '^%s\s+' % (CMD_read_th_fp_reg_x) | |
1530 | cmdRE = re.compile(cmdSyntax) | |
1531 | self.cmdRE[cmdRE] = self.handleReadThFpx | |
1532 | ||
1533 | # NAME | |
1534 | # read-th-reg - Register value of a window on a thread | |
1535 | # SYNOPSIS | |
1536 | # read-th-reg thread window register-num | |
1537 | #cmdSyntax = '^%s\s+\d+\s+\d+\s+\d+' % (CMD_read_th_reg) | |
1538 | cmdSyntax = '^%s\s+' % (CMD_read_th_reg) | |
1539 | cmdRE = re.compile(cmdSyntax) | |
1540 | self.cmdRE[cmdRE] = self.handleReadThReg | |
1541 | ||
1542 | # NAME | |
1543 | # read-thread-status - Read Thread Status Register | |
1544 | # SYNOPSIS | |
1545 | # read-thread-status "thread" | |
1546 | cmdSyntax = '^%s' % (CMD_read_thread_status) | |
1547 | cmdRE = re.compile(cmdSyntax) | |
1548 | #self.cmdRE[cmdRE] = self.handleTodo | |
1549 | ||
1550 | # NAME | |
1551 | # resolve-file - resolve a filename | |
1552 | # SYNOPSIS | |
1553 | # resolve-file "filename" | |
1554 | cmdSyntax = '^%s' % (CMD_resolve_file) | |
1555 | cmdRE = re.compile(cmdSyntax) | |
1556 | #self.cmdRE[cmdRE] = self.handleTodo | |
1557 | ||
1558 | # NAME | |
1559 | # rtl_cycle - update the interface | |
1560 | # SYNOPSIS | |
1561 | # rtl_cycle | |
1562 | cmdSyntax = '^%s' % (CMD_rtl_cycle) | |
1563 | cmdRE = re.compile(cmdSyntax) | |
1564 | #self.cmdRE[cmdRE] = self.handleTodo | |
1565 | ||
1566 | # NAME | |
1567 | # run - start execution | |
1568 | # SYNOPSIS | |
1569 | # run [count] [sid] | |
1570 | cmdSyntax = '^(%s$|%s\s+\d+)' % (CMD_run, CMD_run) | |
1571 | cmdRE = re.compile(cmdSyntax) | |
1572 | self.cmdRE[cmdRE] = self.handleRun | |
1573 | ||
1574 | # NAME | |
1575 | # runfast - start execution | |
1576 | # SYNOPSIS | |
1577 | # runfast [count] [sid] | |
1578 | cmdSyntax = '^(%s$|%s\s+\d+)' % (CMD_runfast, CMD_runfast) | |
1579 | cmdRE = re.compile(cmdSyntax) | |
1580 | self.cmdRE[cmdRE] = self.handleRunfast | |
1581 | ||
1582 | # NAME | |
1583 | # whatis - map va to symbol | |
1584 | # SYNOPSIS | |
1585 | # whatis va | |
1586 | cmdSyntax = '^%s' % (CMD_whatis) | |
1587 | cmdRE = re.compile(cmdSyntax) | |
1588 | self.cmdRE[cmdRE] = self.handleWhatis | |
1589 | ||
1590 | # NAME | |
1591 | # run-command-file - run commands from a file | |
1592 | # SYNOPSIS | |
1593 | # run-command-file file | |
1594 | #cmdSyntax = '^%s\s+\S+' % (CMD_run_command_file) | |
1595 | cmdSyntax = '^%s\s+' % (CMD_run_command_file) | |
1596 | cmdRE = re.compile(cmdSyntax) | |
1597 | self.cmdRE[cmdRE] = self.handleRunCommandFile | |
1598 | ||
1599 | # NAME | |
1600 | # run-python-file - execute Python file | |
1601 | # SYNOPSIS | |
1602 | # run-python-file filename | |
1603 | #cmdSyntax = '^%s\s+\S+' % (CMD_run_python_file) | |
1604 | cmdSyntax = '^%s\s+' % (CMD_run_python_file) | |
1605 | cmdRE = re.compile(cmdSyntax) | |
1606 | self.cmdRE[cmdRE] = self.handleRunPythonFile | |
1607 | ||
1608 | # NAME | |
1609 | # set, <memory-space>.set - set physical address to specified value | |
1610 | # SYNOPSIS | |
1611 | # <memory-space>.set address value [size] [-l] [-b] | |
1612 | # set address value [size] [-l] [-b] | |
1613 | #cmdSyntax = '^(%s\d+\.)%s\s+0[xX][\dA-Fa-f]+\s+0[xX][\dA-Fa-f]+' % (NAME_memory_space, CMD_set) | |
1614 | cmdSyntax = '^(%s\d+\.)?%s\s+' % (NAME_memory_space, CMD_set) | |
1615 | cmdRE = re.compile(cmdSyntax) | |
1616 | self.cmdRE[cmdRE] = self.handleSet | |
1617 | ||
1618 | # NAME | |
1619 | # set-context, <processor>.set-context - set the current context of a cpu | |
1620 | # SYNOPSIS | |
1621 | # <processor>.set-context "context" | |
1622 | # set-context "context" | |
1623 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_set_context) | |
1624 | cmdRE = re.compile(cmdSyntax) | |
1625 | #self.cmdRE[cmdRE] = self.handleTodo | |
1626 | ||
1627 | # NAME | |
1628 | # set-pattern - set an instruction pattern for a breakpoint | |
1629 | # SYNOPSIS | |
1630 | # set-pattern id "pattern" "mask" | |
1631 | cmdSyntax = '^%s' % (CMD_set_pattern) | |
1632 | cmdRE = re.compile(cmdSyntax) | |
1633 | #self.cmdRE[cmdRE] = self.handleTodo | |
1634 | ||
1635 | # NAME | |
1636 | # set-pc, <processor>.set-pc - set the current processor's program counter | |
1637 | # SYNOPSIS | |
1638 | # <processor>.set-pc address | |
1639 | # set-pc address | |
1640 | cmdSyntax = '^(%s\d+\.)?%s\s+' % (NAME_processor, CMD_set_pc) | |
1641 | cmdRE = re.compile(cmdSyntax) | |
1642 | self.cmdRE[cmdRE] = self.handleSetPc | |
1643 | ||
1644 | # NAME | |
1645 | # set-prefix - set a syntax prefix for a breakpoint | |
1646 | # SYNOPSIS | |
1647 | # set-prefix id "prefix" | |
1648 | cmdSyntax = '^%s' % (CMD_set_prefix) | |
1649 | cmdRE = re.compile(cmdSyntax) | |
1650 | #self.cmdRE[cmdRE] = self.handleTodo | |
1651 | ||
1652 | # NAME | |
1653 | # set-substr - set a syntax substring for a breakpoint | |
1654 | # SYNOPSIS | |
1655 | # set-substr id "substr" | |
1656 | cmdSyntax = '^%s' % (CMD_set_substr) | |
1657 | cmdRE = re.compile(cmdSyntax) | |
1658 | #self.cmdRE[cmdRE] = self.handleTodo | |
1659 | ||
1660 | # NAME | |
1661 | # special-interrupt - Special interrupt | |
1662 | # SYNOPSIS | |
1663 | # special-interrupt reset-type target-thread rstvec | |
1664 | cmdSyntax = '^%s' % (CMD_special_interrupt) | |
1665 | cmdRE = re.compile(cmdSyntax) | |
1666 | #self.cmdRE[cmdRE] = self.handleTodo | |
1667 | ||
1668 | # NAME | |
1669 | # sstepi - step one instr of all swerver processor | |
1670 | # SYNOPSIS | |
1671 | # sstepi "thread_seq" | |
1672 | cmdSyntax = '^%s' % (CMD_sstepi) | |
1673 | cmdRE = re.compile(cmdSyntax) | |
1674 | #self.cmdRE[cmdRE] = self.handleTodo | |
1675 | ||
1676 | # NAME | |
1677 | # step-break-absolute, <processor>.step-break, < | |
1678 | # processor>.step-break-absolute, step-break - set step breakpoints | |
1679 | # SYNOPSIS | |
1680 | # <processor>.step-break instructions | |
1681 | # <processor>.step-break-absolute instructions | |
1682 | # step-break ["cpu-name"] instructions | |
1683 | # step-break-absolute ["cpu-name"] instructions | |
1684 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_step_break) | |
1685 | cmdRE = re.compile(cmdSyntax) | |
1686 | #self.cmdRE[cmdRE] = self.handleTodo | |
1687 | ||
1688 | cmdSyntax = '^(%s\d+\.)?%s' % (NAME_processor, CMD_step_break_absolute) | |
1689 | cmdRE = re.compile(cmdSyntax) | |
1690 | #self.cmdRE[cmdRE] = self.handleTodo | |
1691 | ||
1692 | # NAME | |
1693 | # step-cycle - step one or more cycles | |
1694 | # SYNOPSIS | |
1695 | # step-cycle [count] | |
1696 | #cmdSyntax = '^%s(\s+\d+)?' % (CMD_step_cycle) | |
1697 | cmdSyntax = '^%s' % (CMD_step_cycle) | |
1698 | cmdRE = re.compile(cmdSyntax) | |
1699 | #self.cmdRE[cmdRE] = self.handleTodo | |
1700 | ||
1701 | # NAME | |
1702 | # step-instruction - step one or more instructions | |
1703 | # SYNOPSIS | |
1704 | # step-instruction [count] | |
1705 | #cmdSyntax = '^%s(\s+\d+)?' % (CMD_step_instruction) | |
1706 | cmdSyntax = '^%s' % (CMD_step_instruction) | |
1707 | cmdRE = re.compile(cmdSyntax) | |
1708 | #self.cmdRE[cmdRE] = self.handleTodo | |
1709 | ||
1710 | # NAME | |
1711 | # stop - interrupt simulation | |
1712 | # SYNOPSIS | |
1713 | # stop | |
1714 | cmdSyntax = '^%s' % (CMD_stop) | |
1715 | cmdRE = re.compile(cmdSyntax) | |
1716 | #self.cmdRE[cmdRE] = self.handleTodo | |
1717 | ||
1718 | # NAME | |
1719 | # swrun - start execution | |
1720 | # SYNOPSIS | |
1721 | # swrun [count] | |
1722 | #cmdSyntax = '^%s(\s+\d+)?' % (CMD_swrun) | |
1723 | cmdSyntax = '^%s' % (CMD_swrun) | |
1724 | cmdRE = re.compile(cmdSyntax) | |
1725 | #self.cmdRE[cmdRE] = self.handleTodo | |
1726 | ||
1727 | # NAME | |
1728 | # trace-cr, untrace-cr - trace control register updates | |
1729 | # SYNOPSIS | |
1730 | # trace-cr ("register"|-all|-list) | |
1731 | # untrace-cr ("register"|-all|-list) | |
1732 | cmdSyntax = '^(un)?%s' % (CMD_trace_cr) | |
1733 | cmdRE = re.compile(cmdSyntax) | |
1734 | #self.cmdRE[cmdRE] = self.handleTodo | |
1735 | ||
1736 | # NAME | |
1737 | # trace-exception, untrace-exception - trace exceptions | |
1738 | # SYNOPSIS | |
1739 | # trace-exception ("name"|number|-all|-list) | |
1740 | # untrace-exception ("name"|number|-all|-list) | |
1741 | cmdSyntax = '^(un)?%s' % (CMD_trace_exception) | |
1742 | cmdRE = re.compile(cmdSyntax) | |
1743 | #self.cmdRE[cmdRE] = self.handleTodo | |
1744 | ||
1745 | # NAME | |
1746 | # trace-hap, untrace-hap - trace haps | |
1747 | # SYNOPSIS | |
1748 | # trace-hap ("hap"|-all|-list) | |
1749 | # untrace-hap ("hap"|-all|-list) | |
1750 | cmdSyntax = '^(un)?%s' % (CMD_trace_hap) | |
1751 | cmdRE = re.compile(cmdSyntax) | |
1752 | #self.cmdRE[cmdRE] = self.handleTodo | |
1753 | ||
1754 | # NAME | |
1755 | # trace-io, untrace-io - trace device accesses | |
1756 | # SYNOPSIS | |
1757 | # trace-io ("device"|-all|-list) | |
1758 | # untrace-io ("device"|-all|-list) | |
1759 | cmdSyntax = '^(un)?%s' % (CMD_trace_io) | |
1760 | cmdRE = re.compile(cmdSyntax) | |
1761 | #self.cmdRE[cmdRE] = self.handleTodo | |
1762 | ||
1763 | # NAME | |
1764 | # trap-info - print information about current traps | |
1765 | # SYNOPSIS | |
1766 | # trap-info | |
1767 | cmdSyntax = '^%s' % (CMD_trap_info) | |
1768 | cmdRE = re.compile(cmdSyntax) | |
1769 | #self.cmdRE[cmdRE] = self.handleTodo | |
1770 | ||
1771 | # NAME | |
1772 | # unbreak - remove breakpoint range | |
1773 | # SYNOPSIS | |
1774 | # unbreak (id|-all) address length [-r] [-w] [-x] | |
1775 | #cmdSyntax = '^%s\s+(\d+|-all)' % (CMD_unbreak) | |
1776 | cmdSyntax = '^%s' % (CMD_unbreak) | |
1777 | cmdRE = re.compile(cmdSyntax) | |
1778 | #self.cmdRE[cmdRE] = self.handleTodo | |
1779 | ||
1780 | # NAME | |
1781 | # undisplay - remove expression installed by display | |
1782 | # SYNOPSIS | |
1783 | # undisplay expression-id | |
1784 | cmdSyntax = '^%s' % (CMD_undisplay) | |
1785 | cmdRE = re.compile(cmdSyntax) | |
1786 | #self.cmdRE[cmdRE] = self.handleTodo | |
1787 | ||
1788 | # NAME | |
1789 | # unload-module - unload module | |
1790 | # SYNOPSIS | |
1791 | # unload-module "module" | |
1792 | cmdSyntax = '^%s' % (CMD_unload_module) | |
1793 | cmdRE = re.compile(cmdSyntax) | |
1794 | #self.cmdRE[cmdRE] = self.handleTodo | |
1795 | ||
1796 | # NAME | |
1797 | # write-configuration - save configuration | |
1798 | # SYNOPSIS | |
1799 | # write-configuration file | |
1800 | cmdSyntax = '^%s' % (CMD_write_configuration) | |
1801 | cmdRE = re.compile(cmdSyntax) | |
1802 | #self.cmdRE[cmdRE] = self.handleTodo | |
1803 | ||
1804 | # NAME | |
1805 | # write-fp-reg-i - write floating point single register as integer | |
1806 | # SYNOPSIS | |
1807 | # write-fp-reg-i reg-num value | |
1808 | #cmdSyntax = '^%s\s+\d+\s+(\d+|0[xX][\da-fA-F]+)' % (CMD_write_fp_reg_i) | |
1809 | cmdSyntax = '^%s\s+' % (CMD_write_fp_reg_i) | |
1810 | cmdRE = re.compile(cmdSyntax) | |
1811 | self.cmdRE[cmdRE] = self.handleWriteFpi | |
1812 | ||
1813 | # NAME | |
1814 | # write-fp-reg-x - write floating point double register as integer | |
1815 | # SYNOPSIS | |
1816 | # write-fp-reg-x reg-num value | |
1817 | #cmdSyntax = '^%s\s+\d+\s+(\d+|0[xX][\da-fA-F]+)' % (CMD_write_fp_reg_x) | |
1818 | cmdSyntax = '^%s\s+' % (CMD_write_fp_reg_x) | |
1819 | cmdRE = re.compile(cmdSyntax) | |
1820 | self.cmdRE[cmdRE] = self.handleWriteFpx | |
1821 | ||
1822 | # NAME | |
1823 | # write-reg, <processor>.write-reg - write to register | |
1824 | # SYNOPSIS | |
1825 | # <processor>.write-reg "reg-name" value | |
1826 | # write-reg ["cpu-name"] "reg-name" value | |
1827 | cmdSyntax = '^(%s\d+\.)?%s\s+' % (NAME_processor, CMD_write_reg) | |
1828 | cmdRE = re.compile(cmdSyntax) | |
1829 | self.cmdRE[cmdRE] = self.handleWriteReg | |
1830 | ||
1831 | # NAME | |
1832 | # write-th-fp-reg-i - Write double Fp Register value of a thread | |
1833 | # SYNOPSIS | |
1834 | # write-th-fp-reg-i thread register-num value | |
1835 | cmdSyntax = '^%s\s+' % (CMD_write_th_fp_reg_i) | |
1836 | cmdRE = re.compile(cmdSyntax) | |
1837 | self.cmdRE[cmdRE] = self.handleWriteThFpi | |
1838 | ||
1839 | # NAME | |
1840 | # write-th-fp-reg-x - Write double Fp Register value of a thread | |
1841 | # SYNOPSIS | |
1842 | # write-th-fp-reg-x thread register-num value | |
1843 | cmdSyntax = '^%s\s+' % (CMD_write_th_fp_reg_x) | |
1844 | cmdRE = re.compile(cmdSyntax) | |
1845 | self.cmdRE[cmdRE] = self.handleWriteThFpx | |
1846 | ||
1847 | # NAME | |
1848 | # write-thread-status - Write Thread Status Register | |
1849 | # SYNOPSIS | |
1850 | # write-thread-status "thread" value | |
1851 | cmdSyntax = '^%s' % (CMD_write_thread_status) | |
1852 | cmdRE = re.compile(cmdSyntax) | |
1853 | #self.cmdRE[cmdRE] = self.handleTodo | |
1854 | ||
1855 | # NAME | |
1856 | # x, <memory-space>.x, <processor>.x, xp - examine raw memory contents | |
1857 | # SYNOPSIS | |
1858 | # <memory-space>.x address [size] | |
1859 | # <processor>.x address [size] | |
1860 | # x ["cpu-name"] address [size] | |
1861 | # xp address [size] | |
1862 | cmdSyntax = '^(%s\d+|%s\d+)\.%s\s+0[xX][\da-fA-F]+' % (NAME_memory_space, NAME_processor, CMD_x) | |
1863 | cmdRE = re.compile(cmdSyntax) | |
1864 | #self.cmdRE[cmdRE] = self.handleTodo | |
1865 | ||
1866 | cmdSyntax = '^%s(\s+%s\d+)?\s+0[xX][\da-fA-F]+' % (CMD_x, NAME_processor) | |
1867 | cmdRE = re.compile(cmdSyntax) | |
1868 | #self.cmdRE[cmdRE] = self.handleTodo | |
1869 | ||
1870 | cmdSyntax = '^%s\s+0[xX][\da-fA-F]+' % (CMD_xp) | |
1871 | cmdRE = re.compile(cmdSyntax) | |
1872 | #self.cmdRE[cmdRE] = self.handleTodo | |
1873 | ||
1874 | ##### extra commands ##### | |
1875 | cmdSyntax = '^%s\s+' % (CMD_ssi) | |
1876 | cmdRE = re.compile(cmdSyntax) | |
1877 | self.cmdRE[cmdRE] = self.handleStep | |
1878 | ||
1879 | cmdSyntax = '^%s' % (CMD_ALIAS) | |
1880 | cmdRE = re.compile(cmdSyntax) | |
1881 | self.cmdRE[cmdRE] = self.handleAlias | |
1882 | ||
1883 | cmdSyntax = '^%s' % (CMD_UNALIAS) | |
1884 | cmdRE = re.compile(cmdSyntax) | |
1885 | self.cmdRE[cmdRE] = self.handleUnalias | |
1886 | ||
1887 | #TODO reset, in current form, does not work as intended. | |
1888 | ## cmdSyntax = '^%s' % (CMD_RESET) | |
1889 | ## cmdRE = re.compile(cmdSyntax) | |
1890 | ## self.cmdRE[cmdRE] = self.handleReset | |
1891 | ||
1892 | # keep a list of all the keys, do this AFTER all the commands are | |
1893 | # registered | |
1894 | self.cmdList = self.cmdRE.keys() | |
1895 | #self.dbx('cmdList=%s\n' % (self.cmdList)) | |
1896 | # init docs | |
1897 | self.initDoc() | |
1898 | ||
1899 | ||
1900 | def initDoc (self): | |
1901 | """ | |
1902 | """ | |
1903 | # DOCS[cmd]=('cmd syntax', 'CMD', 'short-desc', 'long-desc') | |
1904 | self.DOCS['set-pc'] = ("set-pc", 'CMD', "set a strand's pc", 'syntax: set-pc address') | |
1905 | self.DOCS['set'] = ("set", 'CMD', 'set value at a memory location', 'syntax: set [v:]address value [size]') | |
1906 | self.DOCS['get'] = ("get", 'CMD', 'get value from a memory location', 'syntax: get [v:]address [size]') | |
1907 | self.DOCS['write-th-fp-reg-i'] = ("write-th-fp-reg-i", 'CMD', 'write to a floating-point single register', 'syntax: write-th-fp-reg-i thread register-num value') | |
1908 | self.DOCS['write-th-fp-reg-x'] = ("write-th-fp-reg-x", 'CMD', 'write to a floating-point double register', 'syntax: write-th-fp-reg-x thread register-num value') | |
1909 | self.DOCS['read-th-fp-reg-i'] = ("read-th-fp-reg-i", 'CMD', 'read a floating-point single register', 'syntax: read-th-fp-reg-i thread reg-num') | |
1910 | self.DOCS['read-th-fp-reg-x'] = ("read-th-fp-reg-x", 'CMD', 'read a floating-point double register', 'syntax: read-th-fp-reg-x thread reg-num') | |
1911 | self.DOCS['write-fp-reg-i'] = ("write-fp-reg-i", 'CMD', 'write to a floating-point single register of current strand', 'syntax: write-fp-reg-i register-num value') | |
1912 | self.DOCS['write-fp-reg-x'] = ("write-fp-reg-x", 'CMD', 'write to a floating-point double register of current strand', 'syntax: write-fp-reg-x register-num value') | |
1913 | self.DOCS['read-fp-reg-i'] = ("read-fp-reg-i", 'CMD', 'read a floating-point single register of current strand', 'syntax: read-fp-reg-i register-num') | |
1914 | self.DOCS['read-fp-reg-x'] = ("read-fp-reg-x", 'CMD', 'read a floating-point double register of current strand', 'syntax: read-fp-reg-x register-num') | |
1915 | self.DOCS['write-reg'] = ("write-reg", 'CMD', 'write to a register', 'syntax: write-reg [cpu-name] reg-name value') | |
1916 | self.DOCS['read-reg'] = ("read-reg", 'CMD', 'read a register', 'syntax: read-reg [cpu-name] reg-name') | |
1917 | self.DOCS['read-th-reg'] = ("read-th-reg", 'CMD', 'read a register of a specified strand', 'syntax: read-th-reg thread window register-num') | |
1918 | self.DOCS['read-th-ctl-reg'] = ("read-th-ctl-reg", 'CMD', 'read a control register of a specified strand', 'syntax: read-th-ctl-reg thread control-register-num') | |
1919 | self.DOCS['write-th-ctl-reg'] = ("write-th-ctl-reg", 'CMD', 'write to a control register of a specified strand', 'syntax: write-th-ctl-reg thread control-register-num value') | |
1920 | self.DOCS['echo'] = ("echo", 'CMD', 'echo a string or value', 'syntax: echo [("string"|integer|float)]') | |
1921 | self.DOCS['expect'] = ("expect", 'CMD', 'compare two values, exit if the values do not match', 'syntax: expect i1 i2') | |
1922 | self.DOCS['%'] = ("%", 'CMD', 'read a register', 'syntax: %regname') | |
1923 | #self.DOCS['ssi'] = ("ssi", 'CMD', 'step instruction(s) on strand(s)', 'syntax: ssi cN, ssi sN, ssi lN') | |
1924 | self.DOCS['pregs'] = ("pregs", 'CMD', 'print out integer/floating-point/control registers', 'syntax: pregs [cpu-name] [-all]') | |
1925 | self.DOCS['fpregs'] = ("fpregs", 'CMD', 'print out floating-point registers', 'syntax: fpregs [cpu-name]') | |
1926 | self.DOCS['cmpregs'] = ("cmpregs", 'CMD', 'print out cmp registers', 'syntax: cmpregs [cpu-name]') | |
1927 | self.DOCS['mmuregs'] = ("mmuregs", 'CMD', 'print out mmu registers', 'syntax: mmuregs [cpu-name]') | |
1928 | self.DOCS['stmmuN.regs'] = ("stmmuN.regs", 'CMD', 'print out mmu registers', 'syntax: stmmuN.regs') | |
1929 | self.DOCS['swmmuN.d-tlb'] = ("swmmuN.d-tlb", 'CMD', 'print out d-tlb values', 'syntax: swmmuN.d-tlb') | |
1930 | self.DOCS['swmmuN.i-tlb'] = ("swmmuN.i-tlb", 'CMD', 'print out i-tlb values', 'syntax: swmmuN.i-tlb') | |
1931 | self.DOCS['break'] = ("break", 'CMD', 'set a breakpoint', 'syntax: break 0xpc|v:0xva|p:0xpa [sid=-1], break &symbol [sid=-1]') | |
1932 | self.DOCS['delete'] = ("delete", 'CMD', 'delete a breakpoint', 'syntax: delete (-all|id)') | |
1933 | self.DOCS['enable'] = ("enable", 'CMD', 'enable a breakpoint', 'syntax: enable (-all|id)') | |
1934 | self.DOCS['disable'] = ("disable", 'CMD', 'disable a breakpoint', 'syntax: disable (-all|id)') | |
1935 | self.DOCS['pdisable'] = ("pdisable", 'CMD', 'disable a strand', 'syntax: pdisable [(cpu-name|-all)]') | |
1936 | self.DOCS['penable'] = ("penable", 'CMD', 'enable one or more strands', 'syntax: penable [(cpu-name|-all|0x3210)]') | |
1937 | self.DOCS['pmask'] = ("pmask", 'CMD', 'control strand enabling in SAM setting', 'syntax: pmask [hex - one bit per strand, lowest bit as strand0]') | |
1938 | self.DOCS['run'] = ("run", 'CMD', 'continue to execute instructions, until hit breakpoint or exit', 'syntax: run [count] [strand-id]') | |
1939 | #self.DOCS['runfast'] = ("runfast", 'CMD', 'execute instructions in fast mode', 'syntax: runfast [count] [strand-id]') | |
1940 | self.DOCS['whatis'] = ("whatis", 'CMD', 'map a VA/PA to symbol+offset', 'syntax: whatis 0xva|p:0xpa') | |
1941 | self.DOCS['alias'] = ("alias", 'CMD', 'set an alias', 'syntax: alias zzz z1, e.g., alias pr print "%s=%#x" % ($1,$2)') | |
1942 | self.DOCS['unalias'] = ("unalias", 'CMD', 'unalias an alias', 'syntax: unalias zzz [zzz]* | -all') | |
1943 | #self.DOCS['reset'] = ("reset", 'CMD', "reset all strands' back to a system reset state", 'syntax: reset [traptype=0x1]') | |
1944 | #self.DOCS['ignore'] = ("ignore", 'CMD', 'ignore hitting breakpoint N times', 'syntax: ignore id num') | |
1945 | self.DOCS['list-breakpoints'] = ("list-breakpoints", 'CMD', 'list all breakpoints', 'syntax: list-breakpoints') | |
1946 | self.DOCS['pselect'] = ("pselect", 'CMD', 'select a strand to be the current strand', 'syntax: pselect [cpu-name]') | |
1947 | self.DOCS['quit'] = ("quit", 'CMD', 'terminate the execution', 'syntax: quit [status]') | |
1948 | self.DOCS['run-command-file'] = ("run-command-file", 'CMD', 'execute a command file', 'syntax: run-command-file file') | |
1949 | self.DOCS['run-python-file'] = ("run-python-file", 'CMD', 'execute a python file', 'syntax: run-python-file file') | |
1950 | self.DOCS['logical-to-physical'] = ("logical-to-physical", 'CMD', 'convert logical address to physical address', 'syntax: logical-to-physical [cpu-name] address') | |
1951 | self.DOCS['disassemble'] = ("disassemble", 'CMD', 'disassembler one or more instructions', 'syntax: [thN.]disassemble [address [count]]') | |
1952 | ||
1953 | ||
1954 | def showDoc (self, key=None): | |
1955 | """return 1 means a match is found, 0 means no match | |
1956 | """ | |
1957 | found = 0 | |
1958 | if key: | |
1959 | # strip off ' ', '(', or ')', they are not part of the key | |
1960 | i = key.find('(') | |
1961 | if i > -1: | |
1962 | key = key[:i] | |
1963 | key = key.strip() | |
1964 | if self.DOCS.has_key(key): | |
1965 | (func,type,shortd,longd) = self.DOCS[key] | |
1966 | print '%s: %s: \t%s' % (type, func, shortd) | |
1967 | if longd and longd != 'TODO': | |
1968 | print '\t\t%s' % (longd) | |
1969 | found = 1 | |
1970 | else: | |
1971 | found = 0 | |
1972 | else: | |
1973 | # show all docs | |
1974 | byType = { } | |
1975 | for (key2,(func,type,shortd,longd)) in self.DOCS.items(): | |
1976 | if not byType.has_key(type): | |
1977 | byType[type] = { } | |
1978 | byType[type][key2] = (func,type,shortd,longd) | |
1979 | klist = byType.keys() | |
1980 | klist.sort() | |
1981 | for key2 in klist: | |
1982 | klist3 = byType[key2].keys() | |
1983 | klist3.sort() | |
1984 | for key3 in klist3: | |
1985 | (func,type,shortd,longd) = byType[key2][key3] | |
1986 | #print '%s: %s: \t%s' % (type, func, shortd) | |
1987 | print '%s: %s' % (type, func) | |
1988 | # also show API docs | |
1989 | showApiDoc() | |
1990 | found = 1 | |
1991 | ||
1992 | if found == 0: | |
1993 | found = showApiDoc(key) | |
1994 | ||
1995 | return found | |
1996 | ||
1997 | ||
1998 | def registerCommand (self, key, cmdlist): | |
1999 | """ | |
2000 | """ | |
2001 | #@new_command("write-th-fp-reg-x", write_th_fp_reg_x_cmd, | |
2002 | # args = [arg(int_t, "thread"), arg(int_t, "register-num"), arg(integer_t, "value")], | |
2003 | # type = "niagara commands", | |
2004 | # short = "Write double Fp Register value of a thread", | |
2005 | # doc = """ | |
2006 | # Write double precision fp-reg. """) | |
2007 | ||
2008 | #self.dbx('key=%s, cmdlist=%s\n' % (key, cmdlist)) | |
2009 | if type(cmdlist) is types.ListType: | |
2010 | oneline = '' | |
2011 | for cmd in cmdlist: | |
2012 | oneline += ' ' + cmd.strip() | |
2013 | else: | |
2014 | oneline = cmdlist | |
2015 | #self.dbx('oneline=%s\n' % (oneline)) | |
2016 | ||
2017 | # function name | |
2018 | lindex = oneline.find(',') | |
2019 | rindex = oneline.find(',', lindex+1) | |
2020 | if lindex > -1 and rindex > -1: | |
2021 | func = oneline[lindex+1:rindex].strip() | |
2022 | else: | |
2023 | #self.wrongSyntax(oneline) | |
2024 | raise RuntimeError | |
2025 | ||
2026 | argcount = 0 | |
2027 | # TODO we don't keep track the following values yet | |
2028 | ctype = '' | |
2029 | short = '' | |
2030 | doc = '' | |
2031 | ||
2032 | more = 1 | |
2033 | ||
2034 | # args | |
2035 | lindex = oneline.find('[', rindex+1) | |
2036 | rindex = oneline.find(']', lindex+1) | |
2037 | if lindex > -1 and rindex > -1: | |
2038 | args = oneline[lindex+1:rindex].strip() | |
2039 | # squeeze out blank space(s) | |
2040 | tokens = args.split() | |
2041 | args = ''.join(tokens) | |
2042 | argcount = args.count('arg(') | |
2043 | else: | |
2044 | more = 0 | |
2045 | ||
2046 | # ctype | |
2047 | if more == 1: | |
2048 | lindex = oneline.find('"', rindex+1) | |
2049 | rindex = oneline.find('"', lindex+1) | |
2050 | if lindex > -1 and rindex > -1: | |
2051 | ctype = oneline[lindex+1:rindex].strip() | |
2052 | else: | |
2053 | more = 0 | |
2054 | ||
2055 | # short description | |
2056 | if more == 1: | |
2057 | lindex = oneline.find('"', rindex+1) | |
2058 | rindex = oneline.find('"', lindex+1) | |
2059 | if lindex > -1 and rindex > -1: | |
2060 | short = oneline[lindex+1:rindex].strip() | |
2061 | else: | |
2062 | more = 0 | |
2063 | ||
2064 | # long description | |
2065 | if more == 1: | |
2066 | lindex = oneline.find('"', rindex+1) | |
2067 | rindex = oneline.rfind('"', lindex+1) | |
2068 | if lindex > -1 and rindex > -1: | |
2069 | doc = oneline[lindex+1:rindex].strip('"').strip() | |
2070 | else: | |
2071 | more = 0 | |
2072 | ||
2073 | #self.dbx('key=%s\n' % (key)) | |
2074 | #self.dbx('func=%s\n' % (func)) | |
2075 | #self.dbx('args=%s\n' % (args)) | |
2076 | #self.dbx('argcount=%s\n' % (argcount)) | |
2077 | #self.dbx('ctype=%s\n' % (ctype)) | |
2078 | #self.dbx('short=%s\n' % (short)) | |
2079 | #self.dbx('doc=%s\n' % (doc)) | |
2080 | ||
2081 | if argcount > 0: | |
2082 | cmdSyntax = '^%s\s+' % (key) | |
2083 | else: | |
2084 | cmdSyntax = '^%s$' % (key) | |
2085 | cmdRE = re.compile(cmdSyntax) | |
2086 | self.cmdExt[cmdRE] = (func, argcount) | |
2087 | ||
2088 | # add entry in DOCS | |
2089 | self.registerDoc(key, key, 'CMD-EXT', short, doc) | |
2090 | ||
2091 | ||
2092 | def registerDoc (self, key, fname, type, shortdoc, longdoc): | |
2093 | """ | |
2094 | """ | |
2095 | self.DOCS[key] = (fname, type, shortdoc, longdoc) | |
2096 | ||
2097 | ||
2098 | def setNstrandObjs (self, count): | |
2099 | """ | |
2100 | """ | |
2101 | if self.nstrandObjs != count: | |
2102 | sys.stderr.write('WARNING: CmdParserNi: setNstrandObjs: self.nstrandObjs=%d, count=%d\n' % (self.nstrandObjs, count)) | |
2103 | ||
2104 | self.nstrandObjs = count | |
2105 | i = 0 | |
2106 | while i < self.nstrandObjs: | |
2107 | # 5/25/05: penable/pdisable will update CMP registers, and step() | |
2108 | # is controlled by core_running_status, so frontend thdEnable[] | |
2109 | # will always be true. | |
2110 | self.thdEnable[i] = 1 | |
2111 | self.instrCount[i] = 0 | |
2112 | i += 1 | |
2113 | ||
2114 | ||
2115 | def registerCmdMap (self, cmdMap): | |
2116 | """ | |
2117 | """ | |
2118 | self.cmdMap = cmdMap | |
2119 | ||
2120 | ||
2121 | def parseCmd (self, line, **parms): | |
2122 | """ | |
2123 | """ | |
2124 | #self.dbx('DBX: enter parseCmd(%s)\n' % (line)) #DBX | |
2125 | if not line: | |
2126 | return line | |
2127 | ||
2128 | try: | |
2129 | return self._parseCmd(line, **parms) | |
2130 | except SystemExit: | |
2131 | raise | |
2132 | except Exception, ex: | |
2133 | sys.stderr.write('Wrong command syntax: <%s>, ex=%s\n' % (line, ex)) | |
2134 | #self.showtraceback() | |
2135 | #return line | |
2136 | return None | |
2137 | ||
2138 | ||
2139 | def _parseCmd (self, line, **parms): | |
2140 | """ | |
2141 | """ | |
2142 | #self.dbx('DBX: enter _parseCmd(%s)\n' % (line)) #DBX | |
2143 | ||
2144 | # preserve leading white space | |
2145 | i, n = 0, len(line) | |
2146 | while (i < n) and (line[i] in string.whitespace): | |
2147 | i = i + 1 | |
2148 | indent = line[:i] | |
2149 | cmd = line[i:] | |
2150 | ||
2151 | if not cmd: | |
2152 | return line | |
2153 | ||
2154 | if self.riesReposit.running == 1: | |
2155 | # check to see if the 'run' non-blocking command has hit a bpoint | |
2156 | #bid = self.riesReposit.riesling.getBreakpointTablePtr().queryLast() | |
2157 | pass | |
2158 | ## bid = self.riesReposit.riesling.bp_table.hit_bp() | |
2159 | ## if (bid > 0): | |
2160 | ## #sid = self.riesReposit.riesling.getBreakpointTablePtr().queryLastSid() | |
2161 | ## sid = self.riesReposit.riesling.bp_table.hit_strand() | |
2162 | ## #TODO what to do if bpCmd is not none? | |
2163 | ## bpCmd = self.showBreakpoint(sid, bid) | |
2164 | ||
2165 | # resolve command alias | |
2166 | #print 'DBX: alias: cmd=%s' % cmd #DBX | |
2167 | tokens = cmd.split() | |
2168 | if self.alias.has_key(tokens[0]): | |
2169 | #cmd = self.alias[tokens[0]] + ' ' + ' '.join(tokens[1:]) | |
2170 | cmd = self.alias[tokens[0]] | |
2171 | #print 'DBX: alias: cmd0=%s' % cmd #DBX | |
2172 | if cmd.find('$') > -1: | |
2173 | # there are embedded parameters | |
2174 | for i in range(1, len(tokens)): | |
2175 | cmd = cmd.replace(('$%d' % i), tokens[i]) | |
2176 | #print 'DBX: alias: cmd%d=%s' % (i ,cmd) #DBX | |
2177 | while cmd.find('$') > -1: | |
2178 | # if there are extra (optional) $parameter, get rid of them | |
2179 | cmd = cmd.replace(('$%d' % i), '') | |
2180 | i += 1 | |
2181 | else: | |
2182 | cmd = cmd + ' ' + ' '.join(tokens[1:]) | |
2183 | #print 'DBX: alias: final cmd=%s' % cmd #DBX | |
2184 | ||
2185 | if tokens[0] == CMD_ALIAS: | |
2186 | self.handleAlias(cmd) | |
2187 | return None | |
2188 | ||
2189 | # replace % variable, e.g., %pc, with RS_read_register_name(), so they | |
2190 | # can be used in any expression, e.g., "print '%#x' % %pc", hex(%pc), | |
2191 | # hex(%pc+4), etc. | |
2192 | cmd = self.replaceToken(cmd) | |
2193 | ||
2194 | # TODO we would like to collect cmd ouput in variable 'cmdOut' so that | |
2195 | # the output can be processed, but current structure does not | |
2196 | # allow that. | |
2197 | if self.cmdMap != None: | |
2198 | # if the program is in running mode, accept only 'stop' or 'quit' | |
2199 | import sam | |
2200 | if (not sam.is_stopped()) and ((cmd != 'stop') and (cmd != 'quit') and (not cmd.startswith('mips'))): | |
2201 | sys.stderr.write("not in stop state, enter 'stop' first before issue the command\n") | |
2202 | return None | |
2203 | cmdOut = None | |
2204 | returnCmd = self.cmdMap.issueCmd(cmd, cmdOut, self.riesReposit) | |
2205 | if returnCmd == None: | |
2206 | # return of 'None' means the command has a match in cmdMap and | |
2207 | # had been executed, so go no further. | |
2208 | # for 'run N' and 'stepi N', we need to check if there is | |
2209 | # a breakpoint hit | |
2210 | #TODO if it is a 'run' command, cannot check it here, and it | |
2211 | # is hard to check whether a 'run' hit a breakpoint at | |
2212 | # all, so we won't be able to do showBreakpoint() for | |
2213 | # non-blocking 'run' command. | |
2214 | tokens = cmd.split() | |
2215 | bpCmd = None | |
2216 | if ((tokens[0] == 'run') or (tokens[0] == 'stepi')): | |
2217 | #bid = self.riesReposit.riesling.getBreakpointTablePtr().query() | |
2218 | pass | |
2219 | ## bid = self.riesReposit.riesling.bp_table.last_hit_bp() | |
2220 | ## if (bid > 0): | |
2221 | ## #sid = self.riesReposit.riesling.getBreakpointTablePtr().querySid() | |
2222 | ## sid = self.riesReposit.riesling.bp_table.last_hit_strand() | |
2223 | ## bpCmd = self.showBreakpoint(sid, bid) | |
2224 | return bpCmd | |
2225 | else: | |
2226 | # if no match, use the returned command (likely the original | |
2227 | # cmd) for further processing | |
2228 | cmd = returnCmd | |
2229 | ||
2230 | cmdkey = cmd.split()[0] | |
2231 | newCmd = None | |
2232 | #sys.stderr.write('DBX: line=<%s>, cmd=<%s>, cmdkey=<%s>\n' % (line, cmd, cmdkey)) #DBX | |
2233 | if cmdkey == CMD_pli_run and (parms['socketInit'] == 1): | |
2234 | # pli-run command is valid only if pli-socket layer is init'ed | |
2235 | try: | |
2236 | tokens = cmd.split() | |
2237 | if len(tokens) > 1: | |
2238 | self.riesReposit.socketAPI.plirun(int(tokens[1])) | |
2239 | else: | |
2240 | self.riesReposit.socketAPI.plirun() | |
2241 | except Exception, ex: | |
2242 | sys.stderr.write('WARNING: socketAPI exception, ex=%s\n' % (ex)) | |
2243 | return None | |
2244 | ||
2245 | elif cmdkey == '@def': | |
2246 | #sys.stderr.write('DBX: @def=<%s>\n' % (cmd)) #DBX | |
2247 | # simics uses @def foo() ---> @foo() syntax, bring | |
2248 | # it back to normal def foo() ---> foo() | |
2249 | newCmd = cmd[1:] | |
2250 | # register it in doc | |
2251 | lindex = cmd.find(' ') | |
2252 | mindex = cmd.find('(', lindex) | |
2253 | rindex = cmd.rfind(':') | |
2254 | fname = cmd[lindex+1:mindex].strip() | |
2255 | func = cmd[lindex+1:rindex].strip() | |
2256 | self.registerDoc(fname, func, '@DEF', '@def '+func, None) | |
2257 | ||
2258 | elif cmdkey.startswith('@new_command') or cmdkey.startswith('new_command'): | |
2259 | eindex = cmd.find(',') | |
2260 | lindex = cmd.find('"', 0, eindex) | |
2261 | rindex = cmd.find('"', lindex+1, eindex) | |
2262 | if lindex == -1 or rindex == -1: | |
2263 | #self.wrongSyntax(cmd) | |
2264 | raise RuntimeError | |
2265 | else: | |
2266 | key = cmd[lindex+1:rindex] | |
2267 | self.registerCommand(key, cmd) | |
2268 | return None | |
2269 | ||
2270 | else: | |
2271 | # match command extension first | |
2272 | for key in self.cmdExt.keys(): | |
2273 | if re.match(key, cmd): | |
2274 | cmd = self.polishCommand(cmd) | |
2275 | (func,argcount) = self.cmdExt[key] | |
2276 | return self.dispatcher(cmd, func, argcount) | |
2277 | ||
2278 | # if no match in extension, try matching registered commands | |
2279 | for key in self.cmdList: | |
2280 | # sys.stdout.write(cmd + '\n') | |
2281 | if re.match(key, cmd): | |
2282 | cmd = self.polishCommand(cmd) | |
2283 | newCmd = self.cmdRE[key](cmd) | |
2284 | if newCmd == None: | |
2285 | return None | |
2286 | else: | |
2287 | return indent + newCmd | |
2288 | ||
2289 | # get here only if we cannot find any match | |
2290 | newCmd = cmd | |
2291 | ||
2292 | if newCmd == None: | |
2293 | return None | |
2294 | else: | |
2295 | return indent + newCmd | |
2296 | ||
2297 | ||
2298 | def mapRS (self, tid, level): | |
2299 | """ | |
2300 | """ | |
2301 | if level == RegisterMap.LEVEL_STRAND: | |
2302 | return self.mapThdid(tid) | |
2303 | elif level == RegisterMap.LEVEL_UCORE: | |
2304 | return self.mapuCoreid(tid) | |
2305 | elif level == RegisterMap.LEVEL_CORE: | |
2306 | return self.mapCoreid(tid) | |
2307 | elif level == RegisterMap.LEVEL_CPU: | |
2308 | return self.mapCpuid(tid) | |
2309 | else: | |
2310 | return self.topName | |
2311 | ||
2312 | ||
2313 | def mapThdid (self, tid): | |
2314 | """ | |
2315 | """ | |
2316 | if tid >= self.nstrandObjs: | |
2317 | return None | |
2318 | ||
2319 | if not self.strandMap.has_key(tid): | |
2320 | self.strandMap[tid] = 'strands[%d]' % tid | |
2321 | ## cpuid = tid / self.cpusize | |
2322 | ## leftover = tid % self.cpusize | |
2323 | ## coreid = leftover / self.nstrands | |
2324 | ## strandid = leftover % self.nstrands | |
2325 | ## self.strandMap[tid] = '%s.%s%d.%s%d.%s%d' % (self.topName, NAME_CPU, cpuid, NAME_CORE, coreid, NAME_STRAND, strandid) | |
2326 | ||
2327 | return self.strandMap[tid] | |
2328 | ||
2329 | ||
2330 | def mapuCoreid (self, tid): | |
2331 | """ | |
2332 | """ | |
2333 | if tid >= self.nstrandObjs: | |
2334 | return None | |
2335 | ||
2336 | if not self.ucoreMap.has_key(tid): | |
2337 | ucoreid = tid / self.ucoresize | |
2338 | self.ucoreMap[tid] = 'ucores[%d]' % ucoreid | |
2339 | ## cpuid = tid / self.cpusize | |
2340 | ## leftover = tid % self.cpusize | |
2341 | ## coreid = leftover / self.nstrands | |
2342 | ## self.coreMap[tid] = '%s.%s%d.%s%d' % (self.topName, NAME_CPU, cpuid, NAME_CORE, coreid) | |
2343 | ||
2344 | return self.ucoreMap[tid] | |
2345 | ||
2346 | ||
2347 | def mapCoreid (self, tid): | |
2348 | """ | |
2349 | """ | |
2350 | if tid >= self.nstrandObjs: | |
2351 | return None | |
2352 | ||
2353 | if not self.coreMap.has_key(tid): | |
2354 | coreid = tid / self.coresize | |
2355 | self.coreMap[tid] = 'cores[%d]' % coreid | |
2356 | ## cpuid = tid / self.cpusize | |
2357 | ## leftover = tid % self.cpusize | |
2358 | ## coreid = leftover / self.nstrands | |
2359 | ## self.coreMap[tid] = '%s.%s%d.%s%d' % (self.topName, NAME_CPU, cpuid, NAME_CORE, coreid) | |
2360 | ||
2361 | return self.coreMap[tid] | |
2362 | ||
2363 | ||
2364 | def mapCpuid (self, tid): | |
2365 | """ | |
2366 | """ | |
2367 | if tid >= self.nstrandObjs: | |
2368 | return None | |
2369 | ||
2370 | if not self.cpuMap.has_key(tid): | |
2371 | cpuid = tid / self.cpusize | |
2372 | self.cpuMap[tid] = 'cpus[%d]' % cpuid | |
2373 | ## self.cpuMap[tid] = '%s.%s%d' % (self.topName, NAME_CPU, cpuid) | |
2374 | ||
2375 | return self.cpuMap[tid] | |
2376 | ||
2377 | ||
2378 | def dbx (self, msg): | |
2379 | """ | |
2380 | """ | |
2381 | sys.stderr.write('DBX: CmdParserNi.py: %s' % (msg)) | |
2382 | ||
2383 | ||
2384 | def todo (self, msg): | |
2385 | """ | |
2386 | """ | |
2387 | sys.stderr.write('TODO: CmdParserNi.py: %s' % (msg)) | |
2388 | ||
2389 | ||
2390 | def _eval (self, cmd): | |
2391 | """ | |
2392 | """ | |
2393 | return eval(cmd, self.riesReposit.globals) | |
2394 | ||
2395 | ||
2396 | def dispatcher (self, cmd, func, argcount): | |
2397 | """ | |
2398 | """ | |
2399 | if argcount == 0: | |
2400 | return self._eval('%s()' % (func)) | |
2401 | else: | |
2402 | tokens = cmd.split() | |
2403 | if len(tokens) != (argcount+1): | |
2404 | raise RuntimeError, 'input parameters do not match command syntax, cmd=<%s>' % (cmd) | |
2405 | else: | |
2406 | #self.dbx('%s(%s)\n' % (func, ','.join(tokens[1:]))) | |
2407 | return self._eval('%s(%s)' % (func, ','.join(tokens[1:]))) | |
2408 | ||
2409 | ||
2410 | def handleSetPc (self, cmd): | |
2411 | """ | |
2412 | <processor>.set-pc address | |
2413 | set-pc address | |
2414 | ||
2415 | e.g., set-pc 0x00010000 | |
2416 | """ | |
2417 | #self.dbx('handleSetPC(%s)\n' % (cmd)) | |
2418 | tokens = cmd.split() | |
2419 | if tokens[0].startswith(CMD_set_pc): | |
2420 | # set-pc 0x00010000 | |
2421 | # use current tid | |
2422 | tid = self.lastTid | |
2423 | else: | |
2424 | # <processor>.set-pc 0x00010000 | |
2425 | i = tokens[0].find('.') | |
2426 | tid = tokens[0][len(NAME_processor):i] | |
2427 | ||
2428 | retval = self.checkArgs([tokens[1]]) | |
2429 | if retval[0] ==False: | |
2430 | sys.stderr.write('ERROR: invalid argument\n') | |
2431 | return '' | |
2432 | ||
2433 | ## newCmd = '%s.s%s.pc=%s' % (self.topName,tid, tokens[1]) | |
2434 | ## #eval(newCmd, self.riesReposit.globals) | |
2435 | ## return newCmd | |
2436 | if tokens[1].startswith('0x'): | |
2437 | addr = long(tokens[1], 16) | |
2438 | else: | |
2439 | addr = long(tokens[1]) | |
2440 | self.riesReposit.riesling.s[tid].pc = addr | |
2441 | return None | |
2442 | ||
2443 | def handleSet (self, cmd): | |
2444 | """ | |
2445 | TODO <memory-space>.set address value size [-l] [-b] | |
2446 | set address value size [-l] [-b] | |
2447 | ||
2448 | 1 <= size [4] <= 8 | |
2449 | TODO -l/-b: little-endian/big-endian byte order | |
2450 | ||
2451 | e.g., set 0x00010004 0xafa0188b # fitos %f11, %f23 | |
2452 | """ | |
2453 | #print 'DBX: handleSet(): <%s>' % (cmd) #DBX | |
2454 | tokens = cmd.split() | |
2455 | addrStr = tokens[1] | |
2456 | tid = self.lastTid | |
2457 | ||
2458 | if addrStr.startswith(SYM_VA): | |
2459 | # logical address: v:0x... | |
2460 | # RS_logical_to_physical always check itlb, then dtlb | |
2461 | (addr,type) = RS_logical_to_physical(tid, eval(addrStr[len(SYM_VA):]), 2) | |
2462 | elif addrStr.startswith(SYM_PA): | |
2463 | addr = eval(addrStr[len(SYM_PA):]) | |
2464 | else: | |
2465 | if self.checkArgs([addrStr]) != [True]: | |
2466 | sys.stderr.write('ERROR: wrong addr argument\n') | |
2467 | return | |
2468 | else: | |
2469 | addr = eval(addrStr) | |
2470 | ||
2471 | ||
2472 | if self.checkArgs([tokens[2]]) != [True]: | |
2473 | sys.stderr.write('ERROR: wrong value argument\n') | |
2474 | return | |
2475 | ||
2476 | if len(tokens) >= 4 and self.checkArgs([tokens[3]]) != [True]: | |
2477 | sys.stderr.write('ERROR: wrong value or size argument\n') | |
2478 | return | |
2479 | ||
2480 | value = eval(self.truncVal(tokens[2],1)) | |
2481 | ||
2482 | # set 4 or 8 bytes | |
2483 | try: | |
2484 | size = eval(tokens[3]) | |
2485 | except: | |
2486 | # if size is not provided, or is not valid, use 4 bytes | |
2487 | #raise | |
2488 | size = 4 | |
2489 | ||
2490 | #print 'DBX: handleSet(): tid=%d, addr=%#x, value=%#x, size=%d' % (tid, addr, value, size) #DBX | |
2491 | if not size in [1,2,4,8]: | |
2492 | sys.stderr.write('ERROR: set: wrong size %d, must be 1,2,4,8-byte\n' % (size)) | |
2493 | elif (addr % size) != 0: | |
2494 | sys.stderr.write('ERROR: set: misaligned address\n') | |
2495 | else: | |
2496 | RS_write_phys_memory(tid, addr, value, size) | |
2497 | ||
2498 | return None | |
2499 | ||
2500 | ||
2501 | def handleGet (self, cmd): | |
2502 | """ | |
2503 | TODO <memory-space>.get address [size] [-l] [-b] | |
2504 | get address size [-l] [-b] | |
2505 | ||
2506 | 1 <= size [4] <= 8 | |
2507 | TODO -l/-b: little-endian/big-endian byte order | |
2508 | ||
2509 | e.g., get 0x00010004 | |
2510 | """ | |
2511 | tokens = cmd.split() | |
2512 | addrStr = tokens[1] | |
2513 | tid = self.lastTid | |
2514 | ||
2515 | if addrStr.startswith(SYM_VA): | |
2516 | # logical address: v:0x... | |
2517 | # RS_logical_to_physical() always check itlb, then dtlb. | |
2518 | (addr,type) = RS_logical_to_physical(tid, eval(addrStr[len(SYM_VA):]), 2) | |
2519 | elif addrStr.startswith(SYM_PA): | |
2520 | addr = eval(addrStr[len(SYM_PA):]) | |
2521 | else: | |
2522 | if self.checkArgs([addrStr]) != [True]: | |
2523 | sys.stderr.write('ERROR: wrong addr argument\n') | |
2524 | return | |
2525 | addr = eval(addrStr) | |
2526 | ||
2527 | if len(tokens) >=3 and self.checkArgs([tokens[2]]) != [True]: | |
2528 | sys.stderr.write('ERROR: wrong size argument\n') | |
2529 | return | |
2530 | ||
2531 | # retrieve 4 or 8 bytes | |
2532 | try: | |
2533 | size = eval(tokens[2]) | |
2534 | except: | |
2535 | # if tokens[2] is not provided or not valid, use 4 bytes | |
2536 | #raise | |
2537 | size = 4 | |
2538 | ||
2539 | if (not size in [1,2,4]) and ((size % 8) != 0): | |
2540 | sys.stderr.write('ERROR: get: wrong size %d, must be 1,2,4,8N-byte\n' % (size)) | |
2541 | return None | |
2542 | ||
2543 | if (size <= 8) and ((addr % size) != 0): | |
2544 | sys.stderr.write('ERROR: get: addr %#x is not aligned to %d\n' % (addr, size)) | |
2545 | return None | |
2546 | ||
2547 | if (size > 8) and ((addr % 8) != 0): | |
2548 | sys.stderr.write('ERROR: get: addr %#x is not aligned to %d\n' % (addr, 8)) | |
2549 | return None | |
2550 | ||
2551 | if size >= 8: | |
2552 | i = 0 | |
2553 | while i < size/8: | |
2554 | #newCmd = 'hex(%s)' % (RS_read_phys_memory(0, addr+8*i, 8)) | |
2555 | #print eval(newCmd) | |
2556 | sys.stdout.write('%#018x ' % (RS_read_phys_memory(tid, addr+8*i, 8))) | |
2557 | i += 1 | |
2558 | if (i % 4) == 0: | |
2559 | sys.stdout.write('\n'); | |
2560 | # make sure we finish off the last value with an EOL | |
2561 | if (i % 4) != 0: | |
2562 | sys.stdout.write('\n'); | |
2563 | return None | |
2564 | else: | |
2565 | #newCmd = 'hex(%s)' % (RS_read_phys_memory(0, addr, size)) | |
2566 | #return newCmd | |
2567 | print '%#010x' % (RS_read_phys_memory(tid, addr, size)) | |
2568 | return None | |
2569 | ||
2570 | ||
2571 | def handleWriteThFpi (self, cmd): | |
2572 | """ | |
2573 | write-th-fp-reg-i thread register-num value | |
2574 | ||
2575 | e.g., write-th-fp-reg-i 0 10 0x00000000fbff1391 | |
2576 | """ | |
2577 | tokens = cmd.split() | |
2578 | if self.checkArgs([tokens[1],tokens[2],tokens[3]]) != [True,True,True]: | |
2579 | sys.stderr.write('ERROR: wrong input paramters\n') | |
2580 | return '' | |
2581 | ||
2582 | tid = int(tokens[1]) | |
2583 | regid = tokens[2] | |
2584 | value = tokens[3] | |
2585 | ||
2586 | if tid < self.nstrandObjs and self.myInt(regid) < self.nSpregs: | |
2587 | value = self.truncVal(value,0) | |
2588 | newCmd = '%s.s%d.f%s=%s' % (self.topName,tid, regid, value) | |
2589 | # eval(newCmd, self.riesReposit.globals) | |
2590 | return newCmd | |
2591 | else: | |
2592 | sys.stderr.write('ERROR: out of bounds tid or regid\n') | |
2593 | return '' | |
2594 | ||
2595 | ||
2596 | def handleWriteThFpx (self, cmd): | |
2597 | """ | |
2598 | write-th-fp-reg-x thread register-num value | |
2599 | ||
2600 | e.g., write-th-fp-reg-x 0 10 0x00000000fbff1391 | |
2601 | """ | |
2602 | tokens = cmd.split() | |
2603 | if self.checkArgs([tokens[1],tokens[2],tokens[3]]) != [True,True,True]: | |
2604 | sys.stderr.write('ERROR: wrong input paramters\n') | |
2605 | return '' | |
2606 | ||
2607 | tid = int(tokens[1]) | |
2608 | regid = tokens[2] | |
2609 | value = tokens[3] | |
2610 | ||
2611 | if tid < self.nstrandObjs and self.myInt(regid) < self.nDpregs: | |
2612 | value = self.truncVal(value,1) | |
2613 | newCmd = '%s.s%d.d%s=%s' % (self.topName,tid, regid, value) | |
2614 | # eval(newCmd, self.riesReposit.globals) | |
2615 | # sys.stderr.write(newCmd + '\n') | |
2616 | return newCmd | |
2617 | else: | |
2618 | sys.stderr.write('ERROR: out of bounds tid or regid\n') | |
2619 | return '' | |
2620 | ||
2621 | ||
2622 | def handleReadThFpi (self, cmd): | |
2623 | """ | |
2624 | read-th-fp-reg-i thread reg-num | |
2625 | """ | |
2626 | tokens = cmd.split() | |
2627 | if self.checkArgs([tokens[1],tokens[2]]) != [True,True]: | |
2628 | system.stderr.write('ERROR: wrong input parameters\n') | |
2629 | return '' | |
2630 | ||
2631 | if (int(tokens[1]) < self.nstrandObjs) and (int(tokens[2]) < self.nSpregs): | |
2632 | # as the result will be passed through python interpreter, it must | |
2633 | # be in string format. | |
2634 | newCmd = '%s.s%s.f%s' % (self.topName,tokens[1], tokens[2]) | |
2635 | #return str(eval(newCmd, self.riesReposit.globals)) | |
2636 | return newCmd | |
2637 | else: | |
2638 | sys.stderr.write("ERROR: thread id or register number out of bounds\n") | |
2639 | return '' | |
2640 | ||
2641 | ||
2642 | def handleReadThFpx (self, cmd): | |
2643 | """ | |
2644 | read-th-fp-reg-x thread reg-num | |
2645 | """ | |
2646 | tokens = cmd.split() | |
2647 | if self.checkArgs([tokens[1],tokens[2]]) != [True,True]: | |
2648 | system.stderr.write('ERROR: wrong input parameters\n') | |
2649 | return '' | |
2650 | ||
2651 | if (int(tokens[1]) < self.nstrandObjs) and (int(tokens[2]) < self.nDpregs): | |
2652 | # as the result will be passed through python interpreter, it must | |
2653 | # be in string format. | |
2654 | newCmd = '%s.s%s.d%s' % (self.topName,tokens[1], tokens[2]) | |
2655 | #return str(eval(newCmd, self.riesReposit.globals)) | |
2656 | return newCmd | |
2657 | else: | |
2658 | sys.stderr.write("ERROR: thread id or register number out of bounds\n") | |
2659 | return '' | |
2660 | ||
2661 | ||
2662 | def handleWriteFpi (self, cmd): | |
2663 | """ | |
2664 | write-fp-reg-i register-num value | |
2665 | """ | |
2666 | tokens = cmd.split() | |
2667 | regid = tokens[1] | |
2668 | value = tokens[2] | |
2669 | if self.checkArgs([regid,value]) != [True, True]: | |
2670 | sys.stderr.write('ERROR: wrong command arguments\n') | |
2671 | return '' | |
2672 | ||
2673 | if int(regid) < self.nSpregs: | |
2674 | value = self.truncVal(value,0) | |
2675 | newCmd = '%s.s%d.f%s=%s' % (self.topName,self.lastTid, regid, value) | |
2676 | # eval(newCmd, self.riesReposit.globals) | |
2677 | return newCmd | |
2678 | else: | |
2679 | sys.stderr.write('ERROR: register index %s out of bound %s\n' % (regid,self.nSpregs - 1)) | |
2680 | return '' | |
2681 | ||
2682 | ||
2683 | def handleWriteFpx (self, cmd): | |
2684 | """ | |
2685 | write-fp-reg-x thread register-num value | |
2686 | """ | |
2687 | tokens = cmd.split() | |
2688 | regid = tokens[1] | |
2689 | value = tokens[2] | |
2690 | if self.checkArgs([regid,value]) != [True, True]: | |
2691 | sys.stderr.write('ERROR: wrong command arguments\n') | |
2692 | return '' | |
2693 | ||
2694 | if int(regid) < self.nDpregs: | |
2695 | value = self.truncVal(value,1) | |
2696 | newCmd = '%s.s%d.d%s=%s' % (self.topName,self.lastTid, regid, value) | |
2697 | #eval(newCmd, self.riesReposit.globals) | |
2698 | return newCmd | |
2699 | else: | |
2700 | sys.stderr.write('ERROR: register index %s out of bound %s\n' % (regid,self.nDpregs - 1)) | |
2701 | return '' | |
2702 | ||
2703 | ||
2704 | def handleReadFpi (self, cmd): | |
2705 | """ | |
2706 | read-fp-reg-i reg-num | |
2707 | ||
2708 | e.g., read-fp-reg-i 22 | |
2709 | """ | |
2710 | #self.dbx('handleReadFpx(%s)\n' % (cmd)) | |
2711 | tokens = cmd.split() | |
2712 | if self.checkArgs([tokens[1]]) != [True]: | |
2713 | sys.stderr.write('ERROR: wrong input argument\n') | |
2714 | return '' | |
2715 | ||
2716 | if int(tokens[1]) < self.nSpregs: | |
2717 | # as the result will be passed through python interpreter, it must | |
2718 | # be in string format. | |
2719 | newCmd = '%s.s%d.f%s' % (self.topName,self.lastTid, tokens[1]) | |
2720 | #return str(eval(newCmd, self.riesReposit.globals)) | |
2721 | return newCmd | |
2722 | else: | |
2723 | sys.stderr.write('ERROR: register index %s out of bound %s\n' % (tokens[1],self.nSpregs - 1)) | |
2724 | return '' | |
2725 | ||
2726 | ||
2727 | def handleReadFpx (self, cmd): | |
2728 | """ | |
2729 | read-fp-reg-x reg-num | |
2730 | ||
2731 | e.g., read-fp-reg-x 22 | |
2732 | """ | |
2733 | #self.dbx('handleReadFpx(%s)\n' % (cmd)) | |
2734 | tokens = cmd.split() | |
2735 | if self.checkArgs([tokens[1]]) != [True]: | |
2736 | sys.stdout.write('ERROR: wrong input argument\n') | |
2737 | return '' | |
2738 | ||
2739 | if int(tokens[1]) < self.nDpregs: | |
2740 | # as the result will be passed through python interpreter, it must | |
2741 | # be in string format. | |
2742 | newCmd = 'strands[%d].d%s' % (self.lastTid, tokens[1]) | |
2743 | #return str(eval(newCmd, self.riesReposit.globals)) | |
2744 | return newCmd | |
2745 | else: | |
2746 | sys.stdout.write('ERROR: register index %s out of bound %s\n' % (tokens[1],self.nDpregs - 1)) | |
2747 | return '' | |
2748 | ||
2749 | ||
2750 | def regMapSrch(self, reg_name): | |
2751 | name = self.regmap.feName2beName(reg_name) | |
2752 | if name == '': | |
2753 | sys.stderr.write('ERROR: unimplemented register access or unknown register\n') | |
2754 | return '' | |
2755 | else: | |
2756 | return name | |
2757 | ||
2758 | def handleWriteReg (self, cmd): | |
2759 | """ | |
2760 | <processor>.write-reg "reg-name" value | |
2761 | write-reg ["cpu-name"] "reg-name" value | |
2762 | ||
2763 | e.g., write-reg fsr 0x40000be0 | |
2764 | """ | |
2765 | tokens = cmd.split() | |
2766 | if tokens[0].startswith(CMD_write_reg): | |
2767 | # write-reg ['cpu-name'] fsr 0x40000be0 | |
2768 | if tokens[1].startswith(NAME_processor): | |
2769 | # use specified tid | |
2770 | tid = int(tokens[1][len(NAME_processor):]) | |
2771 | name = tokens[2] | |
2772 | value = tokens[3] | |
2773 | else: | |
2774 | # use current tid | |
2775 | tid = self.lastTid | |
2776 | name = tokens[1] | |
2777 | value = tokens[2] | |
2778 | else: | |
2779 | # <processor>.write-reg fsr 0x40000be0 | |
2780 | index = tokens[0].find('.') | |
2781 | tid = int(tokens[0][len(NAME_processor):index]) | |
2782 | name = tokens[1] | |
2783 | value = tokens[2] | |
2784 | ||
2785 | value = self.truncVal(value,1) | |
2786 | name = self.regMapSrch(name) | |
2787 | if name != '': | |
2788 | newCmd = '%s.s%d.%s=%s' % (self.topName,tid,name,value) | |
2789 | else: | |
2790 | newCmd = '' | |
2791 | ||
2792 | return newCmd | |
2793 | ||
2794 | ||
2795 | def handleReadReg (self, cmd): | |
2796 | """ | |
2797 | <processor>.read-reg "reg-name" | |
2798 | read-reg ["cpu-name"] "reg-name" | |
2799 | ||
2800 | e.g., read-reg fsr | |
2801 | """ | |
2802 | tokens = cmd.split() | |
2803 | if tokens[0].startswith(CMD_read_reg): | |
2804 | # read-reg ['cpu-name'] fsr | |
2805 | if tokens[1].startswith(NAME_processor): | |
2806 | # use specified tid | |
2807 | tid = int(tokens[1][len(NAME_processor):]) | |
2808 | name = tokens[2] | |
2809 | else: | |
2810 | # use current tid | |
2811 | tid = self.lastTid | |
2812 | name = tokens[1] | |
2813 | else: | |
2814 | # <processor>.read-reg fsr | |
2815 | i = tokens[0].find('.') | |
2816 | tid = int(tokens[0][len(NAME_processor):i]) | |
2817 | name = tokens[1] | |
2818 | ||
2819 | name = self.regMapSrch(name) | |
2820 | if name != '': | |
2821 | newCmd = '%s.s%d.%s' % (self.topName,tid,name) | |
2822 | else: | |
2823 | newCmd = '' | |
2824 | ||
2825 | return newCmd | |
2826 | ||
2827 | ||
2828 | def handleReadThReg (self, cmd): | |
2829 | """ | |
2830 | read-th-reg thread window register-num | |
2831 | """ | |
2832 | tokens = cmd.split() | |
2833 | if len(tokens) < 4: | |
2834 | sys.stderr.write('ERROR: wrong number of arguments\n') | |
2835 | return '' | |
2836 | ||
2837 | if self.checkArgs([tokens[1],tokens[2],tokens[3]]) != [True,True,True]: | |
2838 | sys.stderr.write('ERROR: wrong input argument\n') | |
2839 | return '' | |
2840 | ||
2841 | tid = int(tokens[1]) | |
2842 | win = tokens[2] | |
2843 | reg = tokens[3] | |
2844 | if tid >= self.nstrandObjs or int(reg) >= self.nWinregs + 8 or int(reg) < 8 or int(win) >= self.nWin: | |
2845 | sys.stderr.write('ERROR: thread id or register # or win # out of bounds\n') | |
2846 | return '' | |
2847 | ||
2848 | newCmd = '%s.s%d.w[%s][%s]' % (self.topName,tid, win, reg) | |
2849 | return newCmd | |
2850 | ||
2851 | ||
2852 | def handleReadCtlReg (self, cmd): | |
2853 | """ | |
2854 | read-th-ctl-reg thread control-register-num | |
2855 | """ | |
2856 | tokens = cmd.split() | |
2857 | tid = int(tokens[1]) | |
2858 | rid = int(tokens[2]) | |
2859 | reg = self.regmap.id2key(rid) | |
2860 | ||
2861 | if reg == '': | |
2862 | sys.stdout.write('no register mapped at id %d or UNIMP\n' % (rid,)) | |
2863 | return '' | |
2864 | newCmd = '%s.s%d.%s' % (self.topName,tid,reg) | |
2865 | return newCmd | |
2866 | ||
2867 | ||
2868 | def handleWriteCtlReg (self, cmd): | |
2869 | """ | |
2870 | write-th-ctl-reg thread control-register-num value | |
2871 | """ | |
2872 | tokens = cmd.split() | |
2873 | tid = int(tokens[1]) | |
2874 | rid = int(tokens[2]) | |
2875 | reg = self.regmap.id2key(rid) | |
2876 | value = tokens[3] | |
2877 | value = self.truncVal(value,1) | |
2878 | if reg == '': | |
2879 | sys.stdout.write('no register mapped at id %d or UNIMP\n' % (rid,)) | |
2880 | return '' | |
2881 | ||
2882 | newCmd = '%s.s%d.%s=%s' % (self.topName,tid,reg,value) | |
2883 | ||
2884 | #sys.stderr.write('DBX: handleWriteCtlReg: newCmd=%s\n' % (newCmd)) #DBX | |
2885 | return newCmd | |
2886 | ||
2887 | ||
2888 | def handleEcho (self, cmd): | |
2889 | """ | |
2890 | echo [("string"|integer|float)] | |
2891 | ||
2892 | e.g., echo ?Checking fsr ..? | |
2893 | """ | |
2894 | #self.dbx('handleEcho(%s)\n' % (cmd)) | |
2895 | cmd = cmd[len(CMD_echo):].strip() | |
2896 | if ((cmd.startswith("'") and cmd.endswith("'")) or | |
2897 | (cmd.startswith('"') and cmd.endswith('"'))): | |
2898 | cmd = cmd[1:-1] | |
2899 | cmd = cmd.replace("'", "\\'") | |
2900 | newCmd = 'print \'%s\'' % (cmd) | |
2901 | return newCmd | |
2902 | ||
2903 | ||
2904 | def handleExpect (self, cmd): | |
2905 | """ | |
2906 | expect i1 i2 [-v] | |
2907 | ||
2908 | e.g., expect (read-fp-reg-x 22) 0xb06dd828cc801d8d | |
2909 | """ | |
2910 | #self.dbx('handleExpect(%s)\n' % (cmd)) | |
2911 | lindex = cmd.find('(') | |
2912 | if lindex > -1: | |
2913 | # expect (expr) value2 | |
2914 | rindex = cmd.rfind(')') | |
2915 | expr1 = cmd[lindex+1:rindex].strip() | |
2916 | tokens = cmd[rindex+1:].split() | |
2917 | expr2 = tokens[0].strip() | |
2918 | else: | |
2919 | # expect value1 value2 | |
2920 | tokens = cmd.split() | |
2921 | expr1 = tokens[1] | |
2922 | expr2 = tokens[2] | |
2923 | ||
2924 | ## # make sure 0x87654321 does not turn into negative value | |
2925 | ## if re.match(hexRE, expr1) or re.match(octRE, expr1): | |
2926 | ## expr1 = expr1 + 'L' | |
2927 | ## if re.match(hexRE, expr2) or re.match(octRE, expr2): | |
2928 | ## expr2 = expr2 + 'L' | |
2929 | ||
2930 | value1 = self._eval(self.parseCmd(expr1)) | |
2931 | if type(value1) is types.StringType: | |
2932 | value1 = self._eval(value1) | |
2933 | value2 = self._eval(expr2) | |
2934 | ||
2935 | if value1 != value2: | |
2936 | sys.stdout.write('ERROR: EXPECT mismatch: (%s = %s) != (%s = %s)\n' % (expr1, value1, expr2, value2)) | |
2937 | sys.exit(1) | |
2938 | ||
2939 | return None | |
2940 | ||
2941 | ||
2942 | def handleRegName (self, cmd): | |
2943 | """ | |
2944 | % "reg-name" | |
2945 | """ | |
2946 | name = cmd[1:] | |
2947 | name = self.regmap.feName2beName(name) | |
2948 | tid = self.lastTid | |
2949 | if name == '': | |
2950 | sys.stderr.out("register %s unimplemented\n") | |
2951 | else: | |
2952 | print name | |
2953 | newCmd = '%s.s[%d].%s' % (self.riesReposit.topName,tid,name) | |
2954 | #sys.stderr.write('DBX: lastTid=%d newCmd=%s\n' % (self.lastTid, newCmd)) #DBX | |
2955 | return newCmd | |
2956 | ||
2957 | ||
2958 | def handleStep (self, cmd): | |
2959 | """ ssi cN, ssi sN, ssi lNN | |
2960 | """ | |
2961 | bpCmd = None | |
2962 | tokens = cmd.split() | |
2963 | if tokens[1].startswith('s'): | |
2964 | self.stepOverPreviousHit() | |
2965 | # every strand executes one instr in round-robin fashion, until | |
2966 | # every strand has executed N instrs. | |
2967 | count = int(tokens[1][1:]) | |
2968 | done = 0 | |
2969 | i = 0 | |
2970 | while done == 0 and i < count: | |
2971 | j = 0 | |
2972 | while done == 0 and j < self.nstrandObjs: | |
2973 | if self.thdEnable[j] == 1: | |
2974 | bid = self.riesReposit.strands[j].step() | |
2975 | if (bid > 0): | |
2976 | # hit a breakpoint | |
2977 | #self.lastTid = j | |
2978 | #self.handlePselect('pselect th%d' % j) | |
2979 | bpCmd = self.showBreakpoint(j, bid) | |
2980 | done = 1 | |
2981 | else: | |
2982 | self.instrCount[j] += 1 | |
2983 | #self.lastTid = j | |
2984 | j += 1 | |
2985 | i += 1 | |
2986 | return bpCmd | |
2987 | ||
2988 | elif tokens[1].startswith('c'): | |
2989 | self.stepOverPreviousHit() | |
2990 | # strand 0 in each core executes one instr in round-robin | |
2991 | # fashion, until every strand 0 has executed N instrs. | |
2992 | count = int(tokens[1][1:]) | |
2993 | done = 0 | |
2994 | i = 0 | |
2995 | while done == 0 and i < count: | |
2996 | j = 0 | |
2997 | while done == 0 and j < self.nstrandObjs: | |
2998 | if self.thdEnable[j] == 1: | |
2999 | bid = self.riesReposit.strands[j].step() | |
3000 | if (bid > 0): | |
3001 | # hit a breakpoint | |
3002 | #self.lastTid = j | |
3003 | #self.handlePselect('pselect th%d' % j) | |
3004 | bpCmd = self.showBreakpoint(j, bid) | |
3005 | done = 1 | |
3006 | else: | |
3007 | self.instrCount[j] += 1 | |
3008 | #self.lastTid = j | |
3009 | j += self.nstrands | |
3010 | i += 1 | |
3011 | return bpCmd | |
3012 | ||
3013 | elif tokens[1].startswith('l'): | |
3014 | tid = int(tokens[1][1:]) | |
3015 | if tid < self.nstrandObjs: | |
3016 | j = tid | |
3017 | if self.thdEnable[j] == 1: | |
3018 | bid = self.riesReposit.strands[j].step() | |
3019 | if (bid > 0): | |
3020 | # hit a breakpoint | |
3021 | #self.lastTid = j | |
3022 | #self.handlePselect('pselect th%d' % j) | |
3023 | bpCmd = self.showBreakpoint(j, bid) | |
3024 | done = 1 | |
3025 | else: | |
3026 | self.instrCount[j] += 1 | |
3027 | #self.lastTid = j | |
3028 | ||
3029 | return bpCmd | |
3030 | ||
3031 | # no longer used | |
3032 | # def showLastInstr (self, tid, thd, pc): no longer used | |
3033 | # no longer used | |
3034 | ||
3035 | ||
3036 | def handlePregs (self, cmd): | |
3037 | """ | |
3038 | <processor>.pregs [-all] | |
3039 | pregs ["cpu-name"] [-all] | |
3040 | ||
3041 | pregs, thNN.pregs | |
3042 | """ | |
3043 | tokens = cmd.split() | |
3044 | if cmd.startswith(CMD_pregs): | |
3045 | if len(tokens) > 1: | |
3046 | if tokens[1].startswith(NAME_processor): | |
3047 | tid = int(tokens[1][len(NAME_processor):]) | |
3048 | else: | |
3049 | tid = self.lastTid | |
3050 | ## sys.stderr.write('ERROR: wrong command argument, enter tid as thN\n') | |
3051 | ## return None | |
3052 | else: | |
3053 | tid = self.lastTid | |
3054 | else: | |
3055 | i = cmd.find('.pregs') | |
3056 | tid = int(cmd[len(NAME_processor):i]) | |
3057 | ||
3058 | all = '' | |
3059 | if cmd.find(' -all') > -1: | |
3060 | all = '-all' | |
3061 | ||
3062 | RS_print_archregs(tid, all) | |
3063 | ||
3064 | ||
3065 | def handleFpregs (self, cmd): | |
3066 | """ | |
3067 | <processor>.fpregs | |
3068 | fpregs ["cpu-name"] | |
3069 | ||
3070 | fpregs, thNN.fpregs | |
3071 | """ | |
3072 | tokens = cmd.split() | |
3073 | if cmd.startswith(CMD_fpregs): | |
3074 | if len(tokens) > 1: | |
3075 | if tokens[1].startswith(NAME_processor): | |
3076 | tid = int(tokens[1][len(NAME_processor):]) | |
3077 | else: | |
3078 | sys.stderr.write('ERROR: wrong command argument, enter tid as thN\n') | |
3079 | return | |
3080 | else: | |
3081 | tid = self.lastTid | |
3082 | else: | |
3083 | i = cmd.find('.fpregs') | |
3084 | tid = int(cmd[len(NAME_processor):i]) | |
3085 | sys.stderr.write('Strand %d\n' % (tid,)) | |
3086 | RS_print_fpregs(tid) | |
3087 | ||
3088 | ||
3089 | def handleMmu (self, cmd): | |
3090 | """ | |
3091 | <swerver-thread-mmu>.regs | |
3092 | """ | |
3093 | i = cmd.find('.regs') | |
3094 | tid = int(cmd[len(NAME_swerver_thread_mmu):i]) | |
3095 | print RS_print_mmuregs(tid) | |
3096 | ||
3097 | ||
3098 | def handleMmuregs (self, cmd): | |
3099 | """ | |
3100 | <processor>.mmuregs | |
3101 | mmuregs ["cpu-name"] | |
3102 | ||
3103 | mmuregs, thNN.mmuregs | |
3104 | """ | |
3105 | tokens = cmd.split() | |
3106 | if cmd.startswith(CMD_mmuregs): | |
3107 | if len(tokens) > 1: | |
3108 | if tokens[1].startswith(NAME_processor): | |
3109 | tid = int(tokens[1][len(NAME_processor):]) | |
3110 | else: | |
3111 | sys.stderr.write('ERROR: wrong command syntax\n') | |
3112 | return | |
3113 | else: | |
3114 | tid = self.lastTid | |
3115 | else: | |
3116 | i = cmd.find('.mmuregs') | |
3117 | tid = int(cmd[len(NAME_processor):i]) | |
3118 | ||
3119 | if tid >= self.nstrandObjs: | |
3120 | sys.stderr.write('ERRORL tid out of bound\n') | |
3121 | return | |
3122 | print RS_print_mmuregs(tid) | |
3123 | ||
3124 | ||
3125 | def handleCmpregs (self, cmd): | |
3126 | """ | |
3127 | <processor>.cmpregs | |
3128 | cmpregs ["cpu-name"] | |
3129 | ||
3130 | cmpregs, thNN.cmpregs | |
3131 | """ | |
3132 | tokens = cmd.split() | |
3133 | if cmd.startswith(CMD_cmpregs): | |
3134 | if len(tokens) > 1: | |
3135 | if tokens[1].startswith(NAME_processor): | |
3136 | tid = int(tokens[1][len(NAME_processor):]) | |
3137 | else: | |
3138 | sys.stderr.write('ERROR: wrong command syntax\n') | |
3139 | return | |
3140 | else: | |
3141 | tid = self.lastTid | |
3142 | else: | |
3143 | i = cmd.find('.cmpregs') | |
3144 | tid = int(cmd[len(NAME_processor):i]) | |
3145 | ||
3146 | if tid >= self.nstrandObjs: | |
3147 | sys.stderr.write('ERRORL tid out of bound\n') | |
3148 | return | |
3149 | print RS_print_cmpregs(tid) | |
3150 | ||
3151 | ||
3152 | def handleTLB (self, cmd): | |
3153 | """ | |
3154 | <swerver-proc-mmu>.d-tlb | |
3155 | <swerver-proc-mmu>.i-tlb | |
3156 | <swerver-proc-mmu>.i-tlb-entry idx | |
3157 | ||
3158 | swmmuN.i-tlb, swmmuN.d-tlb, N is strand-id | |
3159 | """ | |
3160 | if cmd.find(CMD_swerver_proc_mmu_i_tlb_entry) > -1: | |
3161 | raise RuntimeError | |
3162 | ||
3163 | index = cmd.find('.i-tlb') | |
3164 | if index > -1: | |
3165 | tid = int(cmd[len(NAME_swerver_proc_mmu):index]) | |
3166 | newCmd = 'print RS_dump_tlb(%d, 1, 1)' % (tid) | |
3167 | else: | |
3168 | index = cmd.find('.d-tlb') | |
3169 | if index > -1: | |
3170 | tid = int(cmd[len(NAME_swerver_proc_mmu):index]) | |
3171 | newCmd = 'print RS_dump_tlb(%d, 0, 1)' % (tid) | |
3172 | else: | |
3173 | # not an expected syntax, return to interpreter | |
3174 | raise RuntimeError | |
3175 | ||
3176 | return newCmd | |
3177 | ||
3178 | ||
3179 | def handleBreak (self, cmd): | |
3180 | """ | |
3181 | <breakpoint>.break address [length] [-r] [-w] [-x] | |
3182 | <breakpoint>.tbreak address [length] [-r] [-w] [-x] | |
3183 | break address [length] [-r] [-w] [-x] | |
3184 | ||
3185 | break v:0xaddr | |
3186 | break p:0xaddr | |
3187 | break symbol | |
3188 | ||
3189 | currently we support: (4/13/05) | |
3190 | break [0x]pc [sid] [{cmd;cmd;cmd}] | |
3191 | break v:[0x]vaddr [sid] [{cmd;cmd;cmd}] | |
3192 | break p:[0x]paddr [sid] [{cmd;cmd;cmd}] | |
3193 | break &symbol [sid] [{cmd;cmd;cmd}] | |
3194 | """ | |
3195 | # TODO we don't handle <breakpoint>.break, <breakpoint>.tbreak | |
3196 | # TODO we don't handle [length] [-r] [-w] [-x] | |
3197 | if not cmd.startswith(CMD_breakpoint_break): | |
3198 | raise RuntimeError | |
3199 | ||
3200 | # 'break' by itself is a python keyword, cannot use it alone for | |
3201 | # displaying the list of breakpoints, use enable|disable for that | |
3202 | tokens = cmd.split() | |
3203 | if len(tokens) >= 2: | |
3204 | if len(tokens) >= 3 and not tokens[2].startswith('{'): | |
3205 | # breakpoint ona specific strand | |
3206 | sid = int(tokens[2]) | |
3207 | else: | |
3208 | # breakpoint on all strands | |
3209 | sid = -1 | |
3210 | if tokens[1].startswith('&'): | |
3211 | # symbol is used, it is considered a vaddr for PC breakpoint | |
3212 | try: | |
3213 | if self.riesReposit.symTable: | |
3214 | va = self.riesReposit.symTable.symbol2va(tokens[1][1:]) | |
3215 | if va >= 0: | |
3216 | self.setBpoint(va, sid, cmd, 'PC') | |
3217 | else: | |
3218 | sys.stderr.write('WARNING: break: symbol %s not found\n' % (tokens[1][1:])) | |
3219 | return None | |
3220 | else: | |
3221 | sys.stderr.write('WARNING: break: symbol table is not available\n') | |
3222 | return None | |
3223 | except Exception, ex: | |
3224 | self.wrongSyntax('1 %s, ex=%s' % (cmd, ex)) | |
3225 | return None | |
3226 | else: | |
3227 | # if not symbol, then the value must be in hex format, | |
3228 | # with or without 0x | |
3229 | try: | |
3230 | if tokens[1].startswith('v:'): | |
3231 | addr = long(tokens[1][2:], 16) | |
3232 | self.setBpoint(addr, sid, cmd, 'VA') | |
3233 | elif tokens[1].startswith('p:'): | |
3234 | addr = long(tokens[1][2:], 16) | |
3235 | self.setBpoint(addr, sid, cmd, 'PA') | |
3236 | else: | |
3237 | addr = long(tokens[1], 16) | |
3238 | self.setBpoint(addr, sid, cmd, 'PC') | |
3239 | except Exception, ex: | |
3240 | self.wrongSyntax('2 %s, ex=%s' % (cmd, ex)) | |
3241 | return None | |
3242 | else: | |
3243 | self.wrongSyntax('3 %s' % (cmd)) | |
3244 | return None | |
3245 | ||
3246 | return None | |
3247 | ||
3248 | ||
3249 | def setBpoint (self, addr, sid, cmd, type): | |
3250 | """ | |
3251 | """ | |
3252 | ## if self.riesReposit.running == 1: | |
3253 | ## sys.stderr.write('Simulator is running, issue "stop" before adding breakpoint\n') | |
3254 | ## return | |
3255 | if addr % 4 != 0: | |
3256 | sys.stderr.write('ERROR: unaligned address\n') | |
3257 | return | |
3258 | ||
3259 | # right now we only support interval=1 | |
3260 | if type == 'PC': | |
3261 | if sid == -1: | |
3262 | for ss in self.riesReposit.riesling.s: | |
3263 | bid = ss.brk.on_inst_va(addr) | |
3264 | sys.stderr.write('%s breakpoint id=%d at %s=%#x\n' % (ss.ref, bid, type, addr)) | |
3265 | else: | |
3266 | try: | |
3267 | ss = self.riesReposit.riesling.s[sid] | |
3268 | bid = ss.brk.on_inst_va(addr) | |
3269 | sys.stderr.write('%s breakpoint id=%d at %s=%#x\n' % (ss.ref, bid, type, addr)) | |
3270 | except: | |
3271 | sys.stderr.write('Breakpoin on wrong strand-id %d\n' % (sid)) | |
3272 | else: | |
3273 | sys.stderr.write('Breakpoint on type %s not supported\n' % type) | |
3274 | ||
3275 | ## if self.riesReposit.symTable: | |
3276 | ## if type == 'PC': | |
3277 | ## bid = self.riesReposit.riesling.bp_table.add(sid, long(addr), 1, self.riesReposit.symTable.va2symbol(addr), BP_PC) | |
3278 | ## elif type == 'VA': | |
3279 | ## bid = self.riesReposit.riesling.bp_table.add(sid, long(addr), 1, self.riesReposit.symTable.va2symbol(addr), BP_VA) | |
3280 | ## else: | |
3281 | ## bid = self.riesReposit.riesling.bp_table.add(sid, long(addr), 1, self.riesReposit.symTable.pa2symbol(addr), BP_PA) | |
3282 | ||
3283 | ## else: | |
3284 | ## if type == 'PC': | |
3285 | ## bid = self.riesReposit.riesling.bp_table.add(sid, long(addr), int(1), '', BP_PC) | |
3286 | ## elif type == 'VA': | |
3287 | ## bid = self.riesReposit.riesling.bp_table.add(sid, long(addr), 1, '', BP_VA) | |
3288 | ## else: | |
3289 | ## bid = self.riesReposit.riesling.bp_table.add(sid, long(addr), 1, '', BP_PA) | |
3290 | ||
3291 | ## self.bpoint[bid] = BreakPoint(bid, sid, addr, cmd, type) | |
3292 | ## sys.stderr.write('Break id: %d at %#x\n' % (bid, addr)) | |
3293 | ## self.nextBpoint = bid + 1 | |
3294 | ||
3295 | ||
3296 | def handleDelete (self, cmd): | |
3297 | """ | |
3298 | delete (-all|id) | |
3299 | """ | |
3300 | if self.riesReposit.running == 1: | |
3301 | sys.stderr.write('Simulator is running, issue "stop" before deleting breakpoint\n') | |
3302 | return | |
3303 | ||
3304 | cmd = cmd.replace(',',' ') | |
3305 | tokens = cmd.split() | |
3306 | if tokens[1] == '-all': | |
3307 | # delete all | |
3308 | for ss in self.riesReposit.riesling.s: | |
3309 | keys = ss.brk.keys() | |
3310 | for key in keys: | |
3311 | del ss.brk[key] | |
3312 | ## self.bpoint = { } | |
3313 | ## self.riesReposit.riesling.bp_table.remove(-1) | |
3314 | else: | |
3315 | i = 1 | |
3316 | while i < len(tokens): | |
3317 | bid = eval(tokens[i]) | |
3318 | ## if tokens[i].lower().startswith('0x'): | |
3319 | ## bid = long(tokens[i],16) | |
3320 | ## else: | |
3321 | ## bid = long(tokens[i]) | |
3322 | found = 0 | |
3323 | for ss in self.riesReposit.riesling.s: | |
3324 | try: | |
3325 | del ss.brk[bid] | |
3326 | found = 1 | |
3327 | break | |
3328 | except: | |
3329 | pass | |
3330 | if found == 0: | |
3331 | sys.stderr.write('Breakpoint id %d not found\n' % (bid)) | |
3332 | ## if self.bpoint.has_key(bid): | |
3333 | ## del self.bpoint[bid] | |
3334 | ## self.riesReposit.riesling.bp_table.remove(bid) | |
3335 | ## else: | |
3336 | ## sys.stderr.write('break id %d not found\n' % (bid)) | |
3337 | i += 1 | |
3338 | return None | |
3339 | ||
3340 | ||
3341 | def handleEnable (self, cmd): | |
3342 | """ | |
3343 | """ | |
3344 | return self._handleEnable(cmd, 1) | |
3345 | ||
3346 | ||
3347 | def handleDisable (self, cmd): | |
3348 | """ | |
3349 | """ | |
3350 | return self._handleEnable(cmd, 0) | |
3351 | ||
3352 | ||
3353 | def _handleEnable (self, cmd, enable): | |
3354 | """ | |
3355 | disable (-all|id) | |
3356 | enable (-all|id) | |
3357 | """ | |
3358 | ## if self.riesReposit.running == 1: | |
3359 | ## sys.stderr.write('Simulator is running, issue "stop" before enabling/disabling breakpoint\n') | |
3360 | ## return | |
3361 | ||
3362 | cmd = cmd.replace(',',' ') | |
3363 | tokens = cmd.split() | |
3364 | if len(tokens) == 1: | |
3365 | # display all breakpoints, regardless it is enabled or not | |
3366 | self.handleListBreak(cmd) | |
3367 | #sys.stdout.write('%s\n' % (self.riesReposit.riesling.bp_table.list())) | |
3368 | ##########DBX | |
3369 | ## print 'DBX: DBX DBX DBX' #DBX | |
3370 | ## klist = self.bpoint.keys() | |
3371 | ## klist.sort() | |
3372 | ## for bid in klist: | |
3373 | ## if self.bpoint[bid].enable == enable: | |
3374 | ## sys.stdout.write('%s\n' % (self.bpoint[bid])) | |
3375 | ##########DBX | |
3376 | elif tokens[1] == '-all': | |
3377 | # enable/disable all | |
3378 | if enable == 1: | |
3379 | for ss in self.riesReposit.riesling.s: | |
3380 | for key in ss.brk.keys(): | |
3381 | ss.brk[key].enable() | |
3382 | #self.riesReposit.riesling.bp_table.enable(-1) | |
3383 | else: | |
3384 | for ss in self.riesReposit.riesling.s: | |
3385 | for key in ss.brk.keys(): | |
3386 | ss.brk[key].disable() | |
3387 | #self.riesReposit.riesling.bp_table.disable(-1) | |
3388 | ## # even though we no longer rely on the frontend bpoint[] for | |
3389 | ## # everthing, it is good to keep it updated | |
3390 | ## for bid in self.bpoint.keys(): | |
3391 | ## self.bpoint[bid].enable = enable | |
3392 | ## self.bpoint[bid].hitCount = 0 | |
3393 | ## self.bpoint[bid].justHit = 0 | |
3394 | else: | |
3395 | i = 1 | |
3396 | while i < len(tokens): | |
3397 | bid = eval(tokens[i]) | |
3398 | ## if tokens[i].lower().startswith('0x'): | |
3399 | ## bid = long(tokens[i],16) | |
3400 | ## else: | |
3401 | ## bid = long(tokens[i]) | |
3402 | found = 0 | |
3403 | for ss in self.riesReposit.riesling.s: | |
3404 | try: | |
3405 | if enable == 1: | |
3406 | ss.brk[bid].enable() | |
3407 | else: | |
3408 | ss.brk[bid].disable() | |
3409 | found = 1 | |
3410 | break | |
3411 | except: | |
3412 | pass | |
3413 | if found == 0: | |
3414 | sys.stderr.write('Breakpoint id %d not found\n' % (bid,)) | |
3415 | ## if self.bpoint.has_key(bid): | |
3416 | ## if enable == 1: | |
3417 | ## self.riesReposit.riesling.bp_table.enable(bid) | |
3418 | ## else: | |
3419 | ## self.riesReposit.riesling.bp_table.disable(bid) | |
3420 | ## # ditto, keep it updated | |
3421 | ## self.bpoint[bid].enable = enable | |
3422 | ## self.bpoint[bid].hitCount = 0 | |
3423 | ## self.bpoint[bid].justHit = 0 | |
3424 | ## else: | |
3425 | ## sys.stderr.write('break id %d not found\n' % (bid,)) | |
3426 | i += 1 | |
3427 | ||
3428 | return None | |
3429 | ||
3430 | ||
3431 | def handlePenable (self, cmd): | |
3432 | """ | |
3433 | """ | |
3434 | return self._handlePenable(cmd, 1) | |
3435 | ||
3436 | ||
3437 | def handlePdisable (self, cmd): | |
3438 | """ | |
3439 | """ | |
3440 | return self._handlePenable(cmd, 0) | |
3441 | ||
3442 | # XXX XXX XXX | |
3443 | def _handlePenable (self, cmd, enable): | |
3444 | """ | |
3445 | <processor>.disable | |
3446 | <processor>.enable | |
3447 | pdisable [("cpu-name"|-all)] | |
3448 | penable [("cpu-name"|-all|0x3210)] | |
3449 | """ | |
3450 | #sys.stderr.write('DBX: handlePenable(): cmd=%s enable=%d\n' % (cmd, enable)) #DBX | |
3451 | ||
3452 | if self.riesReposit.optdir['--ar'] == 'n1': | |
3453 | sys.stderr.write('no enable/disable support for n1\n') | |
3454 | return '' | |
3455 | ||
3456 | ||
3457 | if cmd.startswith(NAME_processor): | |
3458 | i = cmd.find('.') | |
3459 | tid = long(cmd[len(NAME_processor):i]) | |
3460 | #TODO this part never get called, somehow re cannot match | |
3461 | # thN.penable, thN.pdisable. 5/25/05 | |
3462 | #---> it works, 11/11/05 | |
3463 | if tid < self.nstrandObjs: | |
3464 | if enable: | |
3465 | newRunning = long(1L<<(tid%self.cpusize)) | self.riesReposit.strands[tid].rdasi(0x41, 0x50L) | |
3466 | else: | |
3467 | newRunning = ~long(1L<<(tid%self.cpusize)) & self.riesReposit.strands[tid].rdasi(0x41, 0x50L) | |
3468 | self.riesReposit.strands[tid].wrasi(0x41, 0x50L, newRunning) | |
3469 | else: | |
3470 | sys.stderr.write('ERROR: strand-id %d out of range\n' % (tid)) | |
3471 | else: | |
3472 | tokens = cmd.lower().split() | |
3473 | if len(tokens) == 1: | |
3474 | # list penable/pdisable | |
3475 | for ii in range(self.riesReposit.ncpus): | |
3476 | running = self.riesReposit.strands[ii*self.cpusize].rdasi(0x41, 0x50L) | |
3477 | i = 0 | |
3478 | while i < self.cpusize: | |
3479 | if ((running >> i) & 0x1L): | |
3480 | sys.stdout.write('strand%d enabled\n' % (i+(ii*self.cpusize))) | |
3481 | i += 1 | |
3482 | elif tokens[1] == '-all': | |
3483 | for ii in range(self.riesReposit.ncpus): | |
3484 | if enable: | |
3485 | # enable all, asiWrite will mask the value with core_avail | |
3486 | self.riesReposit.strands[ii*self.cpusize].wrasi(0x41, 0x50L, 0xffffffffffffffffL) | |
3487 | else: | |
3488 | # disable all, asiWrite will make sure one strand remains | |
3489 | # enabled. | |
3490 | self.riesReposit.strands[ii*self.cpusize].wrasi(0x41, 0x50L, 0x0L) | |
3491 | elif tokens[1].startswith('-mask='): | |
3492 | # make sure we don't replace 0x with 00 | |
3493 | ii = tokens[1].find(':') | |
3494 | if ii > -1: | |
3495 | # -mask=0:1234, -mask=0:0x1234 | |
3496 | jj = tokens[1].find('-mask=') | |
3497 | cpuid = int(tokens[1][jj+len('-mask='):ii]) | |
3498 | if cpuid+1 > self.ncpus: | |
3499 | sys.stderr.write('ERROR: cpuid %d out of range\n' % (cpuid)) | |
3500 | return None | |
3501 | else: | |
3502 | headStrand = cpuid * self.cpusize | |
3503 | if tokens[1][ii+1:].startswith('0x'): | |
3504 | mask = long(tokens[1][ii+3:].replace('x','0'),16) | |
3505 | else: | |
3506 | mask = long(tokens[1][ii+1:].replace('x','0'),16) | |
3507 | else: | |
3508 | # -mask=1234, -mask=0x1234, default to cpu0 | |
3509 | headStrand = 0 | |
3510 | if tokens[1].startswith('-mask=0x'): | |
3511 | mask = long(tokens[1][len('-mask=0x'):].replace('x','0'),16) | |
3512 | else: | |
3513 | mask = long(tokens[1][len('-mask='):].replace('x','0'),16) | |
3514 | if not enable: | |
3515 | mask = 0xffffffffffffffffL ^ mask | |
3516 | self.riesReposit.strands[headStrand].wrasi(0x41, 0x50L, mask) | |
3517 | elif tokens[1].startswith(NAME_processor): | |
3518 | # thN | |
3519 | tid = int(tokens[1][len(NAME_processor):]) | |
3520 | if tid < self.nstrandObjs: | |
3521 | if enable: | |
3522 | newRunning = long(1L<<(tid%self.cpusize)) | self.riesReposit.strands[tid].rdasi(0x41, 0x50L) | |
3523 | else: | |
3524 | newRunning = ~long(1L<<(tid%self.cpusize)) & self.riesReposit.strands[tid].rdasi(0x41, 0x50L) | |
3525 | self.riesReposit.strands[tid].wrasi(0x41, 0x50L, newRunning) | |
3526 | else: | |
3527 | sys.stderr.write('ERROR: strand-id %d out of range\n' % (tid)) | |
3528 | else: | |
3529 | ii = tokens[1].find(':') | |
3530 | if ii > -1: | |
3531 | # 0:1234, 0:0x1234 | |
3532 | cpuid = int(tokens[1][:ii]) | |
3533 | if cpuid+1 > self.ncpus: | |
3534 | sys.stderr.write('ERROR: cpuid %d out of range\n' % (cpuid)) | |
3535 | return None | |
3536 | headStrand = cpuid * self.cpusize | |
3537 | if tokens[1][ii+1:].lower().startswith('0x'): | |
3538 | mask = long(tokens[1][ii+3:],16) | |
3539 | else: | |
3540 | mask = long(tokens[1][ii+1:],16) | |
3541 | else: | |
3542 | # 1234, 0x1234 | |
3543 | headStrand = 0 | |
3544 | if tokens[1].lower().startswith('0x'): | |
3545 | mask = long(tokens[1][2:],16) | |
3546 | else: | |
3547 | mask = long(tokens[1],16) | |
3548 | ||
3549 | if not enable: | |
3550 | mask = 0xffffffffffffffffL ^ mask | |
3551 | self.riesReposit.strands[headStrand].wrasi(0x41, 0x50L, mask) | |
3552 | ||
3553 | return None | |
3554 | ||
3555 | ||
3556 | def handleRun (self, cmd): | |
3557 | """ | |
3558 | run [count] [strand-id] | |
3559 | """ | |
3560 | bpCmd = None | |
3561 | tokens = cmd.split() | |
3562 | if len(tokens) == 1: | |
3563 | # no #instr is specified, use max | |
3564 | ninstr = sys.maxint | |
3565 | else: | |
3566 | # run #instr | |
3567 | ninstr = int(tokens[1]) | |
3568 | ||
3569 | theTid = -1 | |
3570 | if len(tokens) >= 3: | |
3571 | # run on a particular strand only, otherwise round-rabin all | |
3572 | # strands (theTid == -1) | |
3573 | theTid = int(tokens[2]) | |
3574 | ||
3575 | if (theTid == -1): | |
3576 | self.stepOverPreviousHit() | |
3577 | tid = 0 | |
3578 | else: | |
3579 | tid = theTid | |
3580 | count = 0 | |
3581 | done = 0 | |
3582 | while (done == 0) and (count < ninstr): | |
3583 | doneOne = 0 | |
3584 | while (tid < self.nstrandObjs) and (doneOne == 0): | |
3585 | if self.thdEnable[tid] == 1: | |
3586 | bid = self.riesReposit.strands[tid].step() | |
3587 | if (bid > 0): | |
3588 | # hit a breakpoint | |
3589 | #self.lastTid = tid | |
3590 | #self.handlePselect('pselect th%d' % tid) | |
3591 | bpCmd = self.showBreakpoint(tid, bid) | |
3592 | done = 1 | |
3593 | doneOne = 1 | |
3594 | else: | |
3595 | self.instrCount[tid] += 1 | |
3596 | #self.lastTid = tid | |
3597 | ||
3598 | if (theTid == -1): | |
3599 | tid += 1 | |
3600 | else: | |
3601 | # only run on a particular strand, cut short of inner | |
3602 | # while loop | |
3603 | doneOne = 1 | |
3604 | ||
3605 | # out of inner while | |
3606 | if (theTid == -1): | |
3607 | tid = 0 | |
3608 | count += 1 | |
3609 | ||
3610 | return bpCmd | |
3611 | ||
3612 | ||
3613 | def handleRunfast (self, cmd): | |
3614 | """ | |
3615 | runfast [count] [strand-id] | |
3616 | ||
3617 | the difference between run and runfast is that with runfast, each | |
3618 | strand will execute the specified number of instructions before pass | |
3619 | the control to the next strand, unless a breakpoint is hit. 'run' will | |
3620 | have each strand run one instruciton at a time, in a round-rabin order, | |
3621 | until every strand has executed the specified number of instructions, | |
3622 | or until a breakpoint is hit. | |
3623 | ===> this function is no longer advertised | |
3624 | """ | |
3625 | bpCmd = None | |
3626 | tokens = cmd.split() | |
3627 | if (len(tokens) == 1): | |
3628 | # no #instr is specified, use 1, as control will not return | |
3629 | # until the specified number instructions have been executed, | |
3630 | # use sys.maxint here will send the execution into an endless loop | |
3631 | # ---> we have breakpoint in strand now, so treat it the same as | |
3632 | # run, which uses sys.maxint | |
3633 | ninstr = sys.maxint | |
3634 | else: | |
3635 | # run #instr | |
3636 | ninstr = int(tokens[1]) | |
3637 | ||
3638 | tid = -1 | |
3639 | if (len(tokens) >= 3): | |
3640 | # run on a particular strand only, otherwise round-rabin all | |
3641 | # strands (tid == -1), but each strand runs the specified number | |
3642 | # of instructions before passes the control to the next strand, | |
3643 | # which is different to run, where each strand run one instruciton | |
3644 | # at a time. | |
3645 | tid = int(tokens[2]) | |
3646 | ||
3647 | if (tid == -1): | |
3648 | self.stepOverPreviousHit() | |
3649 | i = 0 | |
3650 | done = 0 | |
3651 | while (done == 0 and i < self.nstrandObjs): | |
3652 | if (self.thdEnable[i] == 1): | |
3653 | bid = self.riesReposit.strands[i].step(ninstr) | |
3654 | if (bid > 0): | |
3655 | # hit a breakpoint, but we don't know how many | |
3656 | # instructions have been executed before the breakpoint | |
3657 | #self.lastTid = i | |
3658 | #self.handlePselect('pselect th%d' % i) | |
3659 | bpCmd = self.showBreakpoint(i, bid) | |
3660 | done = 1 | |
3661 | else: | |
3662 | self.instrCount[i] += ninstr | |
3663 | #self.lastTid = i | |
3664 | i += 1 | |
3665 | else: | |
3666 | if (self.thdEnable[tid] == 1): | |
3667 | bid = self.riesReposit.strands[tid].step(ninstr) | |
3668 | if (bid > 0): | |
3669 | # hit a breakpoint, but we don't know how many | |
3670 | # instructions have been executed before the breakpoint | |
3671 | #self.lastTid = tid | |
3672 | #self.handlePselect('pselect th%d' % tid) | |
3673 | bpCmd = self.showBreakpoint(tid, bid) | |
3674 | done = 1 | |
3675 | else: | |
3676 | self.instrCount[tid] += ninstr | |
3677 | #self.lastTid = tid | |
3678 | ||
3679 | return bpCmd | |
3680 | ||
3681 | ||
3682 | def handleWhatis (self, cmd): | |
3683 | """ | |
3684 | whatis va | |
3685 | """ | |
3686 | tokens = cmd.split() | |
3687 | va = 1 | |
3688 | if (len(tokens) == 1): | |
3689 | addr = 0 | |
3690 | else: | |
3691 | if tokens[1].startswith('p:'): | |
3692 | addr = tokens[1][2:] | |
3693 | va = 0 | |
3694 | else: | |
3695 | addr = tokens[1] | |
3696 | ||
3697 | if self.riesReposit.symTable: | |
3698 | #print 'addr=%s va=' % (addr, va) | |
3699 | if va == 1: | |
3700 | print '%s' % self.riesReposit.symTable.va2symbol(addr) | |
3701 | else: | |
3702 | print '%s' % self.riesReposit.symTable.pa2symbol(addr) | |
3703 | else: | |
3704 | print 'No symbol table is available' | |
3705 | ||
3706 | return None | |
3707 | ||
3708 | # no longer used | |
3709 | # def hitBreakpoint (self, tid, thd): no longer used | |
3710 | # no longer used | |
3711 | ||
3712 | def showBreakpoint (self, tid, bid): | |
3713 | """ | |
3714 | """ | |
3715 | #sys.stderr.write('DBX: showBreakpoint: strand-is=%d bpoint-id=%d\n' % (tid, bid)) #DBX | |
3716 | # a breakpoint is hit, switch command prompt to that strand, and set | |
3717 | # state in 'stop' | |
3718 | while tid < 0: | |
3719 | # maybe riesling backend does not complete the update of sid yet, | |
3720 | # wait for it. | |
3721 | #tid = self.riesReposit.riesling.getBreakpointTablePtr().queryLastSid() | |
3722 | tid = self.riesReposit.riesling.bp_table.hit_strand() | |
3723 | self.handlePselect('pselect th%d' % tid) | |
3724 | self.riesReposit.running = 0 | |
3725 | ||
3726 | #thd = self.mapThdid(tid) | |
3727 | #newCmd = '%s.getArchStatePtr().getPc()' % (thd) | |
3728 | #pc = eval(newCmd, self.riesReposit.globals) | |
3729 | #symbol = self.riesReposit.symTable.va2symbol(pc) | |
3730 | ||
3731 | # let instrCount includes the instruction supposed to be executed, | |
3732 | # but didn't because of the breakpoint | |
3733 | #sys.stdout.write('breakpoint %d: T%d, ic=%d, pc=<%s>\n' % (bid, tid, self.instrCount[tid]+1, symbol)) | |
3734 | # ---> ic won't be accurate when runfast is used, so might as well not | |
3735 | # showing it. | |
3736 | # ---> move the display to riesling backend, so that a basic breakpoint | |
3737 | # info is displayed there. | |
3738 | #sys.stdout.write('Hit breakpoint %d: T%d, pc=<%s>\n' % (bid, tid, symbol)) | |
3739 | ||
3740 | # take action(s) associated with the breakpoint | |
3741 | if self.bpoint[bid].action != None and len(self.bpoint[bid].action) > 0: | |
3742 | # if 'run' or 'step' is part of a breakpoint's action, we can | |
3743 | # get into a recursive call-chain, when hitting the breakpoint | |
3744 | # triggers the 'run' (or 'step'), which in turns hits the same | |
3745 | # breakpoint, and on and on, ... | |
3746 | BP_ACTION = '.breakpoint_action' | |
3747 | fd = open(BP_ACTION, 'w') | |
3748 | for action in self.bpoint[bid].action: | |
3749 | fd.write('%s\n' % action) | |
3750 | fd.close() | |
3751 | newCmd = 'execfile("%s")' % BP_ACTION | |
3752 | else: | |
3753 | newCmd = None | |
3754 | ||
3755 | return newCmd | |
3756 | ||
3757 | # we check for breakpoint hit before the instruction is fetched, | |
3758 | # so we don't have the instruction word yet. | |
3759 | #newCmd = '%s.lastInstr()' % (thd) | |
3760 | #lastInstr = eval(newCmd, self.riesReposit.globals) | |
3761 | #newCmd = '%s.lastInstrToString()' % (thd) | |
3762 | #lastInstrCode = eval(newCmd, self.riesReposit.globals) | |
3763 | ##sys.stdout.write('breakpoint: T%d, ic=%d, pc=<v:%#016x>[%s] [%08x] %s\n' % (tid, self.instrCount[tid], pc, symbol, lastInstr, lastInstrCode)) | |
3764 | #sys.stdout.write('breakpoint: T%d, ic=%d, pc=<%s> [%08x] %s\n' % (tid, self.instrCount[tid], symbol, lastInstr, lastInstrCode)) | |
3765 | ||
3766 | ||
3767 | def stepOverPreviousHit (self): | |
3768 | """ | |
3769 | every time before we step, we reset breakpoint hit status so | |
3770 | that we won't hit the same point twice in a row. If T1 hits a | |
3771 | breakpoint, then in the next step/run command T0 is executed first | |
3772 | T0 will reset the breakpoint hit status, so when T1 is to execute | |
3773 | again, it can hit the same breakpoint, which is not desirable, so we | |
3774 | want step over that first. If user chooses to step/run a particular | |
3775 | strand after a breakpoint hit, then we don't execute the function | |
3776 | first, even if that means T1 in the above example will hit the same | |
3777 | breakpoint twice in a row. One problem with this function is that | |
3778 | the strand which hit a breakpoint in the previous step/run will execute | |
3779 | one extra instruction than user specified. | |
3780 | """ | |
3781 | sid = self.riesReposit.riesling.bp_table.last_hit_strand() | |
3782 | if ((sid >= 0) and (self.thdEnable[sid] == 1)): | |
3783 | self.riesReposit.strands[sid].step() | |
3784 | self.instrCount[sid] += 1 | |
3785 | ||
3786 | ||
3787 | def handleAlias (self, cmd): | |
3788 | """alias | |
3789 | alias zzz z1 [z2]* | |
3790 | """ | |
3791 | tokens = cmd.split() | |
3792 | if len(tokens) == 1: | |
3793 | # list alias | |
3794 | klist = self.alias.keys() | |
3795 | klist.sort() | |
3796 | for key in klist: | |
3797 | sys.stdout.write('alias %s == %s\n' % (key, self.alias[key])) | |
3798 | elif len(tokens) >= 3: | |
3799 | # set alias | |
3800 | self.alias[tokens[1]] = ' '.join(tokens[2:]) | |
3801 | else: | |
3802 | self.wrongSyntax(cmd) | |
3803 | ||
3804 | return None | |
3805 | ||
3806 | ||
3807 | def handleUnalias (self, cmd): | |
3808 | """unalias zzz [zzz]* | |
3809 | """ | |
3810 | cmd = cmd.replace(',', ' ') | |
3811 | tokens = cmd.split() | |
3812 | if len(tokens) == 2 and tokens[1] == '-all': | |
3813 | self.alias = { } | |
3814 | else: | |
3815 | i = 1 | |
3816 | while i < len(tokens): | |
3817 | if self.alias.has_key(tokens[i]): | |
3818 | del self.alias[tokens[i]] | |
3819 | i += 1 | |
3820 | ||
3821 | return None | |
3822 | ||
3823 | ||
3824 | def handleHelp (self, cmd): | |
3825 | """ | |
3826 | """ | |
3827 | tokens = cmd.split() | |
3828 | if len(tokens) == 1: | |
3829 | # show high level help | |
3830 | self.showDoc() | |
3831 | print '\nTo use python help utility, enter help()' | |
3832 | else: | |
3833 | # get down to detail | |
3834 | if tokens[1] == 'regid' or tokens[1] == 'regname': | |
3835 | # show regid to regname mapping | |
3836 | __localMap = {} | |
3837 | for regname in self.regmap.regMap.keys(): | |
3838 | __localMap[self.regmap.regMap[regname][1]] = regname | |
3839 | for regname in self.regmap.regMapArch.keys(): | |
3840 | __localMap[self.regmap.regMapArch[regname][1]] = regname | |
3841 | keys = __localMap.keys() | |
3842 | keys.sort() | |
3843 | for key in keys: | |
3844 | print __localMap[key] + '\t\t\t\t' + str(key) | |
3845 | ||
3846 | else: | |
3847 | self.showDoc(tokens[1]) | |
3848 | ||
3849 | return None | |
3850 | ||
3851 | ||
3852 | ## def handleReset (self, cmd): | |
3853 | ## """handle system reset | |
3854 | ## syntax: reset [traptype=0x1] | |
3855 | ||
3856 | ## traptype=0x1: power_on_reset | |
3857 | ## """ | |
3858 | ## tokens = cmd.split() | |
3859 | ## traptype = 0x1 | |
3860 | ## if len(tokens) >= 2: | |
3861 | ## traptype = eval(tokens[2]) | |
3862 | ||
3863 | ## i = 0 | |
3864 | ## while i < self.nstrandObjs: | |
3865 | ## self.instrCount[i] = 0 | |
3866 | ## i += 1 | |
3867 | ||
3868 | ## RS_reset(traptype) | |
3869 | ## return None | |
3870 | ||
3871 | ## def handleReset (self, cmd): | |
3872 | ## """return every strand's pc to power-on-reset | |
3873 | ## """ | |
3874 | ## # .RED.Power_on_Reset fffffffff0000020 X fff0000020 | |
3875 | ## try: | |
3876 | ## pc = self.riesReposit.symTable.symbol2va('.RED.Power_on_Reset') | |
3877 | ## if pc == -1: | |
3878 | ## sys.stderr.write('symbol .RED.Power_on_Reset not found\n') | |
3879 | ## pc = 0xfffffffff0000020 | |
3880 | ## except: | |
3881 | ## pc = 0xfffffffff0000020 | |
3882 | ||
3883 | ## i = 0 | |
3884 | ## while i < self.nstrandObjs: | |
3885 | ## if self.thdEnable[i] == 1: | |
3886 | ## self.instrCount[i] = 0 | |
3887 | ## thd = self.mapThdid(i) | |
3888 | ## newCmd = '%s.getArchStatePtr().setPc(value=%u)' % (thd, pc) | |
3889 | ## eval(newCmd, self.riesReposit.globals) | |
3890 | ## newCmd = '%s.getArchStatePtr().setNpc(value=%u)' % (thd, pc+4) | |
3891 | ## eval(newCmd, self.riesReposit.globals) | |
3892 | ## i += 1 | |
3893 | ||
3894 | ## return None | |
3895 | ||
3896 | ||
3897 | def handleIgnore (self, cmd): | |
3898 | """ | |
3899 | ignore id num | |
3900 | sys.stderr.write('%s\n' % (newCmd,)) | |
3901 | """ | |
3902 | sys.stderr.write('"ignore" command is not supported\n') | |
3903 | return None | |
3904 | ||
3905 | tokens = cmd.split() | |
3906 | retval = self.checkArgs([tokens[1],tokens[2]]) | |
3907 | if not retval == [True,True]: | |
3908 | sys.stderr.write('ERROR: wrong i/p paramters\n') | |
3909 | return | |
3910 | id = int(tokens[1]) | |
3911 | num = int(tokens[2]) | |
3912 | if self.bpoint.has_key(id): | |
3913 | self.bpoint[id].ignore = num | |
3914 | self.bpoint[id].hitCount = 0 | |
3915 | self.bpoint[id].justHit = 0 | |
3916 | else: | |
3917 | sys.stderr.write('ERROR: Break id not found\n') | |
3918 | return None | |
3919 | ||
3920 | ||
3921 | def handleListBreak (self, cmd): | |
3922 | """ | |
3923 | list-breakpoints [-all] | |
3924 | """ | |
3925 | for ss in self.riesReposit.riesling.s: | |
3926 | if len(ss.brk): | |
3927 | print '%s: %s' % (ss.ref, ss.brk) | |
3928 | #sys.stdout.write('%s\n' % (self.riesReposit.riesling.bp_table.list())) | |
3929 | ## klist = self.bpoint.keys() | |
3930 | ## klist.sort() | |
3931 | ## for id in klist: | |
3932 | ## sys.stdout.write('%s\n' % (self.bpoint[id])) | |
3933 | ||
3934 | ||
3935 | def handlePselect (self, cmd): | |
3936 | """ | |
3937 | pselect ["cpu-name"] | |
3938 | """ | |
3939 | tokens = cmd.split() | |
3940 | if len(tokens) == 1: | |
3941 | sys.stdout.write('pselect: th%d\n' % (self.lastTid)) | |
3942 | else: | |
3943 | if tokens[1].startswith(NAME_processor): | |
3944 | tid = int(tokens[1][len(NAME_processor):]) | |
3945 | if tid < self.nstrandObjs: | |
3946 | self.lastTid = tid | |
3947 | sys.ps1 = "%s-th%d>>> " % (self.riesReposit.prompt, self.lastTid) | |
3948 | else: | |
3949 | sys.stderr.write('ERROR: tid value out of range\n') | |
3950 | else: | |
3951 | sys.stderr.write('ERROR: wrong input parameter, enter tid as thN\n') | |
3952 | ||
3953 | ||
3954 | def handleQuit (self, cmd): | |
3955 | """ | |
3956 | quit [status] | |
3957 | """ | |
3958 | tokens = cmd.split() | |
3959 | status = 0 | |
3960 | if len(tokens) > 1: | |
3961 | try: | |
3962 | status = int(tokens[1]) | |
3963 | except: | |
3964 | pass | |
3965 | ||
3966 | # if pli-socket does not present, we shouldn't make socketAPI calls | |
3967 | try: | |
3968 | self.riesReposit.socketAPI.fini() | |
3969 | except: | |
3970 | pass | |
3971 | ||
3972 | if (status == 0): | |
3973 | #sys.exit(self.riesReposit.riesling.bp_table.is_bad_trap()) | |
3974 | sys.exit(0) | |
3975 | else: | |
3976 | sys.exit(status) | |
3977 | ||
3978 | ||
3979 | def handleRunCommandFile (self, cmd): | |
3980 | """ | |
3981 | run-command-file file | |
3982 | """ | |
3983 | return self.handleRunPythonFile(cmd) | |
3984 | ||
3985 | ||
3986 | def handleRunPythonFile (self, cmd): | |
3987 | """ | |
3988 | run-python-file filename | |
3989 | """ | |
3990 | tokens = cmd.split() | |
3991 | newCmd = 'execfile("%s")' % (tokens[1]) | |
3992 | return newCmd | |
3993 | ||
3994 | ||
3995 | def handleVa2Pa (self, cmd): | |
3996 | """ | |
3997 | <processor>.logical-to-physical address | |
3998 | logical-to-physical ["cpu-name"] address | |
3999 | """ | |
4000 | tokens = cmd.split() | |
4001 | if cmd.startswith(NAME_processor): | |
4002 | i = cmd.find('.') | |
4003 | tid = int(cmd[len(NAME_processor):i]) | |
4004 | va = tokens[1] | |
4005 | else: | |
4006 | if tokens[1].startswith(NAME_processor): | |
4007 | tid = int(tokens[1][len(NAME_processor):]) | |
4008 | va = tokens[2] | |
4009 | else: | |
4010 | tid = self.lastTid | |
4011 | va = tokens[1] | |
4012 | ||
4013 | # remove leading 'v:' if any | |
4014 | if va.startswith(SYM_VA): | |
4015 | va = va[len(SYM_VA):] | |
4016 | ||
4017 | if tid >= self.nstrandObjs: | |
4018 | sys.stderr.write('ERROR: strand id out of bounds\n') | |
4019 | return '' | |
4020 | ||
4021 | (addr,type) = RS_logical_to_physical(tid, eval(va), 2) | |
4022 | print addr | |
4023 | return None | |
4024 | ||
4025 | ||
4026 | def decode_addr (self, addr): | |
4027 | """ | |
4028 | p:[0x]addr, r:[0x]addr, v:[0x]addr, [0x]addr | |
4029 | """ | |
4030 | # 0 - pa, 1 - ra, 2 - va | |
4031 | if addr.startswith(SYM_PA): | |
4032 | addr_type = AddrType.PA_TYPE | |
4033 | addr = eval(addr[len(SYM_PA):]) | |
4034 | elif addr.startswith(SYM_RA): | |
4035 | addr_type = AddrType.RA_TYPE | |
4036 | addr = eval(addr[len(SYM_RA):]) | |
4037 | elif addr.startswith(SYM_VA): | |
4038 | addr_type = AddrType.VA_TYPE | |
4039 | addr = eval(addr[len(SYM_VA):]) | |
4040 | else: | |
4041 | # default is VA | |
4042 | addr_type = AddrType.VA_TYPE | |
4043 | addr = eval(addr) | |
4044 | ||
4045 | return (addr_type,addr) | |
4046 | ||
4047 | ||
4048 | def handle_va2pa (self, cmd): | |
4049 | """ | |
4050 | syntax: va2pa [(p|r|v):][0x]addr [-p pid] [-c context] [strand-di] | |
4051 | """ | |
4052 | tokens = cmd.split() | |
4053 | (addr_type,addr) = self.decode_addr(tokens[1]) | |
4054 | pid = None | |
4055 | ctxt = None | |
4056 | tid = self.selectTid | |
4057 | i = 2 | |
4058 | while i < len(tokens): | |
4059 | if tokens[i] == '-p': | |
4060 | pid = eval(tokens[i+1]) | |
4061 | i += 2 | |
4062 | elif tokens[i] == '-c': | |
4063 | ctxt = eval(tokens[i+1]) | |
4064 | i += 2 | |
4065 | else: | |
4066 | try: | |
4067 | tid = eval(tokens[i]) | |
4068 | except: | |
4069 | pass | |
4070 | i += 1 | |
4071 | ||
4072 | (addr,type) = RS_logical_to_physical(tid, addr, addr_type, pid, ctxt) | |
4073 | print addr | |
4074 | return None | |
4075 | ||
4076 | ||
4077 | def handleDisassemble (self, cmd): | |
4078 | """ | |
4079 | <processor>.disassemble [address [count]] | |
4080 | disassemble [address [count]] | |
4081 | ||
4082 | 2/27/07: alias to dism | |
4083 | """ | |
4084 | count = '1' | |
4085 | addr = None | |
4086 | addr_type = AddrType.VA_TYPE # 0 - pa, 1 - ra, 2 - va, default is VA | |
4087 | tokens = cmd.split() | |
4088 | if cmd.startswith(NAME_processor): | |
4089 | i = cmd.find('.') | |
4090 | tid = int(cmd[len(NAME_processor):i]) | |
4091 | else: | |
4092 | #tid = self.selectTid | |
4093 | tid = self.lastTid | |
4094 | ||
4095 | if len(tokens) > 1: | |
4096 | addr = tokens[1] | |
4097 | if len(tokens) > 2: | |
4098 | count = tokens[2] | |
4099 | ||
4100 | if tid >= self.nstrandObjs: | |
4101 | sys.stderr.write('ERROR: strand id out of bounds\n') | |
4102 | return | |
4103 | ||
4104 | if addr.startswith(SYM_PA): | |
4105 | addr = addr[len(SYM_PA):] | |
4106 | ## if not addr.startswith('0x') and not addr.startswith('0X'): | |
4107 | ## addr = '0x' + addr | |
4108 | addr_type = AddrType.PA_TYPE | |
4109 | elif addr.startswith(SYM_RA): | |
4110 | addr = addr[len(SYM_RA):] | |
4111 | ## if not addr.startswith('0x') and not addr.startswith('0X'): | |
4112 | ## addr = '0x' + addr | |
4113 | addr_type = AddrType.RA_TYPE | |
4114 | elif addr.startswith(SYM_VA): | |
4115 | addr = addr[len(SYM_VA):] | |
4116 | ## if not addr.startswith('0x') and not addr.startswith('0X'): | |
4117 | ## addr = '0x' + addr | |
4118 | else: | |
4119 | # default is VA, if no addr is given, PC is used | |
4120 | if addr == None: | |
4121 | # use selected strand's pc | |
4122 | addr = str(self.riesReposit.riesling.s[tid].pc) | |
4123 | ||
4124 | if self.checkArgs([addr,count]) != [True, True]: | |
4125 | sys.stderr.write('ERROR: invalid address or count arguments\n') | |
4126 | return | |
4127 | ||
4128 | try: | |
4129 | addrv = eval(addr) | |
4130 | except: | |
4131 | sys.stderr.write('ERROR: %s is not a proper address, use prefix "0x" for hex value\n' % (addr)) | |
4132 | return | |
4133 | ||
4134 | if addr_type == AddrType.PA_TYPE: | |
4135 | return self.handle_dism('dism p:%#x -c %s %d' % (addrv, count, tid)) | |
4136 | elif addr_type == AddrType.RA_TYPE: | |
4137 | return self.handle_dism('dism r:%#x -c %s %d' % (addrv, count, tid)) | |
4138 | else: | |
4139 | return self.handle_dism('dism v:%#x -c %s %d' % (addrv, count, tid)) | |
4140 | ||
4141 | ||
4142 | def handle_dism (self, cmd): | |
4143 | """ | |
4144 | syntax: dism | |
4145 | dism pc [-c count] [strand-id] | |
4146 | dism [(p|r|v):]addr [-c count] [strand-id] | |
4147 | """ | |
4148 | tokens = cmd.split() | |
4149 | ||
4150 | if len(tokens) == 1: | |
4151 | # if no addr is specified, use the selected strand's PC | |
4152 | #addr = self.riesReposit.riesling.s[self.selectTid].pc | |
4153 | addr = self.riesReposit.riesling.s[self.lastTid].pc | |
4154 | addr_type = AddrType.VA_TYPE | |
4155 | else: | |
4156 | # special syntax, allow accessing PC of a different strand | |
4157 | if tokens[1] == 'pc': | |
4158 | addr = None | |
4159 | addr_type = AddrType.VA_TYPE | |
4160 | else: | |
4161 | (addr_type,addr) = self.decode_addr(tokens[1]) | |
4162 | ||
4163 | count = 1 | |
4164 | #tid = self.selectTid | |
4165 | tid = self.lastTid | |
4166 | i = 2 | |
4167 | while i < len(tokens): | |
4168 | if tokens[i] == '-c': | |
4169 | count = eval(tokens[i+1]) | |
4170 | i += 2 | |
4171 | else: | |
4172 | tid = eval(tokens[i]) | |
4173 | i += 1 | |
4174 | ||
4175 | if addr == None: | |
4176 | addr = self.riesReposit.riesling.s[tid].pc | |
4177 | ||
4178 | i = 0 | |
4179 | while i < count: | |
4180 | (size,iwStr,type) = RS_disassemble(tid, addr, addr_type, self.vonk) | |
4181 | if type == AddrType.PA_TYPE: | |
4182 | sys.stdout.write('PA %#x %s\n' % (addr, iwStr)) | |
4183 | elif type == AddrType.RA_TYPE: | |
4184 | sys.stdout.write('RA %#x %s\n' % (addr, iwStr)) | |
4185 | else: | |
4186 | sys.stdout.write('VA %#x %s\n' % (addr, iwStr)) | |
4187 | addr += 4 | |
4188 | i += 1 | |
4189 | ||
4190 | return None | |
4191 | ||
4192 | ||
4193 | def str2long (self, str): | |
4194 | """ | |
4195 | """ | |
4196 | if str.startswith('0x') or str.startswith('0X'): | |
4197 | return long(str, 16) | |
4198 | elif str.startswith('0'): | |
4199 | return long(str, 8) | |
4200 | else: | |
4201 | return long(str, 10) | |
4202 | ||
4203 | ||
4204 | def handleTodo (self, cmd): | |
4205 | """ | |
4206 | """ | |
4207 | self.todo(cmd) | |
4208 | raise RuntimeError | |
4209 | ||
4210 | ||
4211 | def wrongSyntax (self, cmd): | |
4212 | """ | |
4213 | """ | |
4214 | sys.stderr.write('Wrong command syntax: <%s>\n' % (cmd)) | |
4215 | raise RuntimeError | |
4216 | ||
4217 | ||
4218 | def showtraceback(self): | |
4219 | """Display the exception that just occurred. | |
4220 | #We remove the first stack item because it is our own code. | |
4221 | The output is written by self.write(), below. | |
4222 | """ | |
4223 | import traceback | |
4224 | ||
4225 | try: | |
4226 | type, value, tb = sys.exc_info() | |
4227 | sys.last_type = type | |
4228 | sys.last_value = value | |
4229 | sys.last_traceback = tb | |
4230 | tblist = traceback.extract_tb(tb) | |
4231 | #del tblist[:1] | |
4232 | list = traceback.format_list(tblist) | |
4233 | if list: | |
4234 | list.insert(0, "Traceback (most recent call last):\n") | |
4235 | list[len(list):] = traceback.format_exception_only(type, value) | |
4236 | finally: | |
4237 | tblist = tb = None | |
4238 | ||
4239 | map(self.write, list) | |
4240 | #sys.stderr.write('%s' % (list)) | |
4241 | ||
4242 | ||
4243 | def write (self, data): | |
4244 | """ | |
4245 | """ | |
4246 | sys.stderr.write(data) | |
4247 | ||
4248 | ||
4249 | def replaceToken (self, cmd): | |
4250 | """replace %reg with RS_read_register_name() so that the %reg can be | |
4251 | treated as a variable and used in any valid python expression. | |
4252 | """ | |
4253 | tokens = splitRE.split(cmd) | |
4254 | for token in tokens: | |
4255 | #print token | |
4256 | if token.startswith('%'): | |
4257 | name = self.regmap.feName2beName(token[1:]) | |
4258 | if name != '': | |
4259 | newToken = "%s.s%d.%s" % (self.topName,self.lastTid,name) | |
4260 | #sys.stderr.write('DBX: newToken=%s\n' % (newToken)) #DBX | |
4261 | cmd = cmd.replace(token, newToken) | |
4262 | return cmd | |
4263 | else: | |
4264 | #sys.stderr.write('unimplemented register %s\n' % (token[1:],)) | |
4265 | pass | |
4266 | return cmd | |
4267 | ||
4268 | ||
4269 | ||
4270 | """self-testing | |
4271 | """ | |
4272 | if __name__ == "__main__": | |
4273 | """ | |
4274 | """ | |
4275 | import Repository | |
4276 | niParser = CmdParserNi(Repository.Repository()) | |
4277 | ||
4278 | ||
4279 | ||
4280 |