projects / OpenSPARC-T2-SAM / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / api / samfe / src / CmdParserNi.py
CommitLineData
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
24import 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
34import RegisterMap
35from CmdParserNiCmd import *
36
37# the following breakpoint constants (BP_*) must be consistent with
38# include/system/BreakpointEntry.h
39BP_PC = 1
40BP_VA = 2
41BP_PA = 3
42
43hexRE = re.compile('^0[xX][0-9A-Fa-f]+$')
44octRE = re.compile('^0[0-7]+$')
45# split command line to locate any % variable, e.g., %pc
46splitRE = re.compile('[^%_\w]')
47
48### need to support the following commands:
49
50SYM_PA = 'p:'
51SYM_RA = 'r:'
52SYM_VA = 'v:'
53
54NAME_CPU = 'cpu'
55NAME_CORE = 'core'
56NAME_UCORE = 'ucore'
57NAME_STRAND = 'strand'
58
59NAME_breakpoint = 'phys_mem'
60NAME_context = 'TODO'
61NAME_image = 'TODO'
62NAME_memory_space = 'phys_mem'
63NAME_port_space = 'TODO'
64NAME_processor = 'th'
65NAME_rtl_intf = 'TODO'
66NAME_swerver_memory = 'swvmem'
67NAME_swerver_proc_mmu = 'swmmu'
68NAME_swerver_thread_mmu = 'stmmu'
69
70CMD_action = 'action'
71CMD_add_directory = 'add-directory'
72CMD_api_apropos = 'api-apropos'
73CMD_api_help = 'api-help'
74CMD_apropos = 'apropos'
75CMD_break_cr = 'break-cr'
76CMD_break_exception = 'break-exception'
77CMD_break_hap = 'break-hap'
78CMD_break_io = 'break-io'
79CMD_breakpoint_break = 'break'
80CMD_catch_exception = 'catch-exception'
81CMD_clear_directories = 'clear-directories'
82CMD_cmpregs = 'cmpregs'
83CMD_command_list = 'command-list'
84CMD_context_off = 'off'
85CMD_context_on = 'on'
86CMD_cycle_break = 'cycle-break'
87CMD_cycle_break_absolute = 'cycle-break-absolute'
88CMD_debug_level = 'debug-level'
89CMD_delete = 'delete'
90CMD_device_interrupt = 'device-interrupt'
91CMD_devs = 'devs'
92CMD_disable = 'disable'
93CMD_disable_real_time_mode = 'disable-real-time-mode'
94CMD_disassemble = 'disassemble'
95CMD_display = 'display'
96CMD_dstc_disable = 'dstc-disable'
97CMD_dstc_enable = 'dstc-enable'
98CMD_echo = 'echo'
99CMD_enable = 'enable'
100CMD_enable_external_commands = 'enable-external-commands'
101CMD_enable_real_time_mode = 'enable-real-time-mode'
102CMD_eosl = 'eosl'
103CMD_expect = 'expect'
104CMD_gdb_remote = 'gdb-remote'
105CMD_get = 'get'
106CMD_help = 'help'
107CMD_hex = 'hex'
108CMD_ignore = 'ignore'
109CMD_image_add_diff_file = 'add-diff-file'
110CMD_image_add_partial_diff_file = 'add-partial-diff-file'
111CMD_image_commit = 'commit'
112CMD_image_limit_memory = 'limit-memory'
113CMD_image_save = 'save'
114CMD_image_x = 'x'
115CMD_instruction_profile_mode = 'instruction-profile-mode'
116CMD_io = 'io'
117CMD_io_buffer = 'io-buffer'
118CMD_istc_disable = 'istc-disable'
119CMD_istc_enable = 'istc-enable'
120CMD_le_checksum = 'le-checksum'
121CMD_le_permissions = 'le-permissions'
122CMD_list_attributes = 'list-attributes'
123CMD_list_breakpoints = 'list-breakpoints'
124CMD_list_classes = 'list-classes'
125CMD_list_failed_modules = 'list-failed-modules'
126CMD_list_haps = 'list-haps'
127CMD_list_modules = 'list-modules'
128CMD_list_namespaces = 'list-namespaces'
129CMD_list_profilers = 'list-profilers'
130CMD_list_vars = 'list-vars'
131CMD_load_binary = 'load-binary'
132CMD_load_file = 'load-file'
133CMD_load_module = 'load-module'
134CMD_load_veri_file = 'load-veri-file'
135CMD_logical_to_physical = 'logical-to-physical'
136CMD_magic_break_disable = 'magic-break-disable'
137CMD_magic_break_enable = 'magic-break-enable'
138CMD_memory_profile = 'memory-profile'
139CMD_memory_space_map = 'map'
140CMD_module_list_refresh = 'module-list-refresh'
141CMD_mmuregs = 'mmuregs'
142CMD_native_path = 'native-path'
143CMD_new_command = 'new_command'
144CMD_new_context = 'new-context'
145CMD_output_radix = 'output-radix'
146CMD_pdisable = 'pdisable'
147CMD_pdisassemble = 'pdisassemble'
148CMD_penable = 'penable'
149CMD_pio = 'pio'
150CMD_pipe = 'pipe'
151CMD_pli_run = 'pli-run'
152CMD_port_space_map = 'map'
153CMD_pregs = 'pregs'
154CMD_fpregs = 'fpregs'
155CMD_pregs_all = 'pregs-all'
156CMD_pregs_hyper = 'pregs-hyper'
157#CMD_print = 'print'
158CMD_print_directories = 'print-directories'
159CMD_print_double_regs = 'print-double-regs'
160CMD_print_event_queue = 'print-event-queue'
161CMD_print_float_regs = 'print-float-regs'
162CMD_print_float_regs_raw = 'print-float-regs-raw'
163CMD_print_instruction_queue = 'print-instruction-queue'
164CMD_print_profile = 'print-profile'
165CMD_print_statistics = 'print-statistics'
166CMD_print_time = 'print-time'
167CMD_prof_page_details = 'prof-page-details'
168CMD_prof_page_map = 'prof-page-map'
169CMD_prof_weight = 'prof-weight'
170CMD_pselect = 'pselect'
171CMD_quit = 'quit'
172CMD_read_configuration = 'read-configuration'
173CMD_read_fp_reg_i = 'read-fp-reg-i'
174CMD_read_fp_reg_x = 'read-fp-reg-x'
175CMD_read_reg = 'read-reg'
176CMD_read_sw_pcs = 'read-sw-pcs'
177CMD_read_th_ctl_reg = 'read-th-ctl-reg'
178CMD_read_th_fp_reg_i = 'read-th-fp-reg-i'
179CMD_read_th_fp_reg_x = 'read-th-fp-reg-x'
180CMD_read_thread_status = 'read-thread-status'
181CMD_read_th_reg = 'read-th-reg'
182CMD_resolve_file = 'resolve-file'
183CMD_rtl_cycle = 'rtl_cycle'
184CMD_rtl_intf_info = 'info'
185CMD_run = 'run'
186CMD_runfast = 'runfast'
187CMD_whatis = 'whatis'
188CMD_run_command_file = 'run-command-file'
189CMD_run_python_file = 'run-python-file'
190CMD_set = 'set'
191CMD_set_context = 'set-context'
192CMD_set_pattern = 'set-pattern'
193CMD_set_pc = 'set-pc'
194CMD_set_prefix = 'set-prefix'
195CMD_set_prof_weight = 'set-prof-weight'
196CMD_set_substr = 'set-substr'
197CMD_special_interrupt = 'special-interrupt'
198CMD_sstepi = 'sstepi'
199CMD_stc_status = 'stc-status'
200CMD_step_break = 'step-break'
201CMD_step_break_absolute = 'step-break-absolute'
202CMD_step_cycle = 'step-cycle'
203CMD_step_instruction = 'step-instruction'
204CMD_stop = 'stop'
205CMD_swerver_memory_debug = 'debug'
206CMD_swerver_memory_info = 'info'
207CMD_swerver_proc_mmu_i_tlb_entry = 'i-tlb-entry'
208CMD_swerver_proc_mmu_probe = 'probe'
209CMD_swerver_proc_mmu_regs = 'regs'
210CMD_swerver_proc_mmu_tlb = 'tlb'
211CMD_swerver_proc_mmu_trace = 'trace'
212CMD_swerver_thread_mmu_probe = 'probe'
213CMD_swerver_thread_mmu_regs = 'regs'
214CMD_swerver_thread_mmu_trace = 'trace'
215CMD_swrun = 'swrun'
216CMD_trace_cr = 'trace-cr'
217CMD_trace_exception = 'trace-exception'
218CMD_trace_hap = 'trace-hap'
219CMD_trace_io = 'trace-io'
220CMD_trap_info = 'trap-info'
221CMD_unbreak = 'unbreak'
222CMD_undisplay = 'undisplay'
223CMD_unload_module = 'unload-module'
224CMD_write_configuration = 'write-configuration'
225CMD_write_fp_reg_i = 'write-fp-reg-i'
226CMD_write_fp_reg_x = 'write-fp-reg-x'
227CMD_write_reg = 'write-reg'
228CMD_write_th_ctl_reg = 'write-th-ctl-reg'
229CMD_write_th_fp_reg_i = 'write-th-fp-reg-i'
230CMD_write_th_fp_reg_x = 'write-th-fp-reg-x'
231CMD_write_thread_status = 'write-thread-status'
232CMD_x = 'x'
233CMD_xp = 'xp'
234
235# extra commands
236CMD_ssi = 'ssi'
237CMD_ALIAS = 'alias'
238CMD_UNALIAS = 'unalias'
239#CMD_RESET = 'reset'
240
241
242class 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
309class 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"""
4272if __name__ == "__main__":
4273 """
4274 """
4275 import Repository
4276 niParser = CmdParserNi(Repository.Repository())
4277
4278
4279
4280
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.