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