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