xds.err

VRTX 商用嵌入式实时操作系统

 exceptions must be enabled in order for exception break-
 points to work.  Enabling EHS debugging sets a target 
 breakpoint, which allows XRAY to regain control when the
 target program throws an exception.  Disabling EHS debugging
 frees the target breakpoint.  When disabled, if a program 
 throws an exception while XRAY is executing a STEP or 
 STEPOVER command, XRAY will lose control of the target CPU.
 [Press RETURN to continue]
#h
 C++ Exception Handling Commands: (continued)

 BREAKTHROW  - set a break on exception throws
 BREAKCATCH  - set a break on exception catches

 Execution will be halted if the target program throws or
 catches an exception of the appropriate type.  The Code
 Viewport will show the throw or catch site.  Use the
 STEPOVER command to go directly from the throw site to the
 catch site, or use the STEP command to step from the throw
 site into and thru the sequence of destructor calls that 
 result from the unwinding of the runtime stack.

 [Press RETURN to continue]
#h
 C++ Exception Handling Commands: (continued)

 STATUS EHS  - report C++ Exception Handling System status

 This command will list all available information about the
 EHS system, including the enabled/disabled state, lists of 
 active throw and catch breakpoints, and what (if any) 
 exception has been thrown or caught.
#h
 Miscellaneous Commands:

 ALIAS       - define a command alias.
 HISTORY     - show/repeat previous command.
 DEFINE      - define a macro (C routine).
 SHOW        - show contents of macro.
 OPTION      - set/display debugger options.
 QUIT        - exit debugger.
#h
 Line Editing On Command Line:

   Right/Left  - move cursor one column right/left.
   Control-E   - move cursor to end of line.
   Control-B   - move cursor to start of line.
   Insert      - enable/disable insert mode.
   Delete_Under- remove one character at cursor.
   Delete_Left - remove one character left of cursor.
   Prev_Command- roll through history buffer.
 Additionally, by moving the cursor up in the command 
 viewport, any line can be re-executed. This includes
 macro definitions.
#h
 Control Keys:

  These are in addition to the line editing keys:

  Control-C    - stop the current command output or
                 execution (STOP/BREAK on some systems).
  ESC          - clear current command line, reject input.
  Control-F    - move active viewport contents left.
  Control-U    - move active viewport contents right.
  Control-S/Q  - stop/start output to command viewport. 
                 This may be used instead of more paging.
#h
 Forming Expressions:

 - address: to get the address of a scalar symbol, precede 
   the name with an '&'. Example: "BREAKREAD &global_int"
 - value: to get the value of an array or pointer, precede
   the name with a '*'. Example: "PRINT *pointer"
 - structure: to get the value of a member of a structure
   or union, use '.' or '->' (pointer). Example:
     "CE struct_var.member" and "MON ptr_struct->member"
 - code address: in high level: a line number as #number
   or procedure name. In low level, any expression will be
   treated as an address. Example: "GO #20" and "BI label"
 - assignment: use CEXPRESSION and '='. Example: "C var=exp"
#h
 Referencing Symbols:

 Symbols need to be qualified if not available in the 
 current context. Qualification means preceding the module
 and/or procedure name before the symbol:
 \global            -- global symbol in current root
 MODULE\function    -- static function
 MODULE\static      -- static variable
 MODULE\#20         -- line number
 procedure\local    -- local or argument
 #10\line_local     -- local to unnnamed block

 Combinations of the above are allowed.         
#h
 Reserved Symbols:

 All registers are preceded by an '@' and may be in upper
 or lower case. Example: "SETREG @pc=label"
 Some additional simulator registers exist:
 @cycles -- number of cycles simulated since last cleared
 @exc    -- controls exception processing. 0=Error, 1=Trap
            with message, 2=Trap. See manual for more.
 @exc    -- controls exception processing. 0=Error, 1=Trap
            with message, 2=Trap. See manual for more.
 @pisize -- returns size of instruction at PC. If set to an
            address, reads back as size of that instruction
 @fpu    -- controls floating point simulation.
#h
 Event Definition:

 An event consists of four parts: an address range, a data
 range, a set of bus status and a count. The default values
 are any address, any data value, any status and a count of 1.
 An event definition consists of comma separated event terms
 setting the parts to specified values or value ranges.
 The terms are defined as:
   Addr:  ADDR {== | !=} {value [&= value_mask] | value_range}
   Data:  DATA {== | !=} {value [&= value_mask] | value_range}
   Stat:  STAT {== | !=} {status_flag [ | status_flag] ...}
   Count: COUNT == value

 [press RETURN to continue]
#h
 Event Definition (continued):
 
 A value is a 32-bit number and a value_range is two values 
 separated by '..'.  Another way to specify a range is to use
 a value_mask. The 0 bits in the value_mask indicate the don't
 care bits in the value. e.g. addr==0x2345&=0xFFFFFFC0 defines
 an address range between 0x2340 and 0x237F.
 Each term cannot appear more than once in a definition.
 An event is true if and only if all specified terms are true.
 The count specifies how many times an event must occur before
 it is recognized.  

 [press RETURN to continue]
#h
 Event Definition (continued):

 Possible status flags are: 
   rup	- read from user program space
   wup  - write to user program space
   rud  - read from user data space
   wud  - write to user data space
   rsp  - read from supervisor program space
   wsp  - write to supervisor program space
   rsd  - read from supervisor data space
   wsd  - write to supervisor data space
   rcp  - read from cpu space
   wcp  - write to cpu space
   ack  - interrupt acknowledge (same as rcp)
#h
 Event Expression:

 An event expression is a list of events separated by the
 logical OR operator (|). 
 For example, the event expression
     ev{2} | ev{3} | ev{4}
 is true if any one or more of the three events occur. 

 Event expressions are used in the SETSTATUS QUALIFY and
 STATUS BUFFER (or TRACE) commands. 
#h
 Event Sequence:

 An event sequence is a state equation defining the desired
 sequence of event occurrences. Events are separated by the
 following operators:
     |	  - logical OR  
     =>   - then
 For example, the event sequence
     ev{2} | ev{3} => ev{4} | ev{5} | ev{6}
 is true if ev{4}, ev{5} or ev{6} occurs after ev{2} or 
 ev{3}. 

 Event sequences are used in the SETSTATUS TRIGGER command.
#h
 ADD (ADD):
 ADD [type] symbol_name [&address] [=value[,value...]]

 The ADD command creates a symbol and adds it to the debugger
 symbol table. The symbol's name must be declared, but any
 valid C data type is optional. The default type is int.  The
 value may be any set of integers, characters or strings. A
 zero must be added to strings.

 > add char str[4] &0x4000 = "abc",0
#h
 ALIAS (AL):
 ALIAS [name [= [replacement]]]

 The ALIAS command is used to create command aliases. The
 following formats are allowed:
   ALIAS                  /* show all aliases */
   ALIAS name             /* show replacement for name */
   ALIAS name=            /* delete alias */
   ALIAS name=replacement /* define alias */
   ALIAS name=replace($*) /* define alias - arg control */
 An asterisk may be used in the name as: REQUIRED*OPTIONAL.
 The '$*' allows specifying where the command arguments
 should go in the replacement string (default: after). 
#h
 ANALYZE (AN):
 ANALYZE [ON | OFF | CLEAR | SAVE=filename |
          LOAD=filename |
          INCLUDE=program-unit[,program-unit ...] | 
          EXCLUDE=program-unit[,program-unit ...] ]

 The ANALYZE command defines and controls the test coverage
 mechanism in the debugger.  The ON qualifier turns the
 analyzer on for data collection; the OFF qualifier turns
 test coverage off; the CLEAR qualifier clears all
 accumulated test coverage data.

 [Press RETURN to continue]
#h
 ANALYZE (continued):
 
 The SAVE/LOAD qualifiers are used to save/reload the
 execution test data to/from file (time stamp and root name
 is added to saved file); the INCLUDE/EXCLUDE qualifiers
 allow the user to include/exclude program units for test
 coverage analysis (default is to include the entire
 program).  A program unit can be root (program), module
 (file), function (procedure), line number range, or address
 range.  The default value if no parameter is given is to
 display whether analyzer is on or off.

 > an ex=FOPEN,read,#20..#25,0x4000..0x4100
#h
 BREAKACCESS (BA):
 BREAKACCESS [address | address_range] [;macro_name]

 The BREAKACCESS command sets an access breakpoint, which
 halts program execution each time the target program
 attempts to read from or write to the specified memory
 location(s). A macro may also be named, in which case it is
 executed each time a break is encountered. Execution 
 continues if the macro returns a non-zero.

 > ba flags..flags+10; showit()
#h
 BREAKCATCH (BCA):
 BREAKCATCH [/a | expression] [;macro_name]

 The BREAKCATCH command sets a catch breakpoint, which halts
 program execution each time the target program catches a 
 C++ Exception of the type specified.  If a macro is given,
 it will be executed each time the break occurs.  Execution
 continues if the macro returns a non-zero value.  The /a
 flag specifies break on any and all exceptions.  

[press RETURN to continue]
#h
 BREAKCATCH (continued):
 BREAKCATCH [/a | expression] [;macro_name]

 In the absense of /a, the exception breakpoint will match
 catches of the same data type as the expression given.
 Typically this expression may be a cast expression, eg. 
 (double *) 0.  If the expression is an actual data object, 
 the exception breakpoint will match any exception of 
 the same data type, since only types (and not objects) 
 can be caught.

 > breakcatch (MyClass *) 0  // match catch of MyClass ptr
 > breakcatch  MyObject      // match catch typeof(MyObject)
 > breakcatch /a             // match catch of any exception
#h
 BREAKCOMPLEX (BC):
 BREAKCOMPLEX [type [{, | =} addr...]] [;macro_name]

 The BREAKCOMPLEX command sets a specialized complex 
 breakpoint. The type name argument defines what kind
 of complex breakpoint is being set. The list of types
 is available in the user manual. The complex breakpoints
 may be used to halt program execution or to trigger
 logic analysis. A macro may also be named, in which case 
 it is executed each time a break is encountered. Execution 
 continues if the macro returns a non-zero.

 > bc trigger, pin7=high
#h
 BREAKINSTRUCTION (B):
 BREAKINSTRUCTION [address | address_range] [;macro_name]

 The BREAKINSTRUCTION command sets an instruction break-
 point, which halts program execution each time the target
 program attempts to execute an instruction at the speci-
 fied memory location(s). If you specify a range, break-
 points are set on the first byte of each instruction. A
 macro associated with a breakpoint is executed each time
 the break occurs. Execution continues if the macro returns
 a non-zero. 'B' displays all breakpoints.

 > b #26..#38; trace()
#h
 BREAKREAD (BR):
 BREAKREAD [address | address_range] [;macro_name]

 The BREAKREAD command sets a read breakpoint, which halts
 program execution each time the target program attempts to
 read data from the specified memory location(s). If a macro
 is named, it will be executed each time the break occurs.
 Execution continues if the macro returns a non-zero.

 > br 0x201b..2100h; checkval()
#h
 BREAKTHROW (BT):
 BREAKTHROW [/a | /r | expression] [;macro_name]

 The BREAKTHROW command sets a throw breakpoint, which halts
 program execution each time the target program throws a 
 C++ Exception of the type specified.  If a macro is given,
 it will be executed each time the break occurs.  Execution
 continues if the macro returns a non-zero value.  The /a
 flag specifies any and all exceptions.  The /r flag 
 specifies only fatal (terminate) exceptions.

[press RETURN to continue]
#h
 BREAKTHROW (continued):
 BREAKTHROW [/a | /r | expression] [;macro_name]

 In the absense of /a or /r, the excepion breakpoint will
 match throws of the same data type as the expression given.
 Typically this expression may be a cast expression, eg. 
 (double *) 0.  If the expression is an actual data object, 
 the exception breakpoint will match only throws of that 
 specific object (and not other objects of the same type).

 > breakthrow (MyClass *) 0  // match throw of MyClass ptr
 > breakthrow  MyObject      // match ONLY throw of MyObject
 > breakthrow  /r            // match throws that terminate
#h
 BREAKWRITE (BW):
 BREAKWRITE [address | address_range] [;macro_name]

 The BREAKWRITE command sets a write breakpoint, which halts
 program execution each time the target memory attempts to
 write data to the specified memory location(s). If a macro
 is specified, it will be executed each time the break
 occurs. Execution continues if the macro returns a non-zero.

 > bw flags[2]; showval(flags[2])
#h
 BROWSE (BRO):
 BROWSE symbol_name

 The BROWSE command displays the inheritance relationships
 of a C++ class; it will show the base classes (parents)
 and derived classes (children) of the given class.  The
 symbol_name given may be the name of a class, object, or