Liren Large Software Subsidy 5

home *** CD-ROM | disk | FTP | other *** search

/ Liren Large Software Subsidy 5 / 05.iso / a / a523 / 14.ddi / HELP.PDU < prev next >

Wrap

Text File | 1988-06-08 | 26.7 KB | 831 lines

# PDU - The ORACLE source-level symbolic Protected-mode Debugging Utility Interactive Help for Version 2.4 To display more information on a topic, enter its name at the prompt. You can abbreviate the topic with one or more letters, as long as the abbreviation is not ambiguous with other topics on the same menu. You can also go directly to the help screen on that topic by using the topic in the HELP command, such as HELP EXPRESSIONS To leave help, press RETURN at the "Topic:" prompt. To back up to the help screen on the previous topic, press return at the "Subtopic:" prompt. @Commands @Expressions @Source_level_debugging @Symbols #COMMANDS =Commands Commands PDU commands are entered at the ':' prompt. Commands can be abbreviated to one or two letters. In the command descriptions, the uppercase part of the command is required to specify the command unambiguously but the remainder is optional. Optional arguments to the commands are shown with square brackets, and keywords are shown in uppercase. @Assign @BAse @BP @Byte @CLS @CLOse @DB @DD @DElete_symbols @Display_memory @DW @Evaluate @Go @Help @K_nesting @Load @Mode @Nesting @POinter @Proceed @PTr @Question_mark_? @Quit @Registers @screen_flip @shell_escape @Source_step @SYmbols @Trace @Unassemble @WIndow @Window_mode @Word @$ @\ #WINDOW_MODE =Window_Mode Window Mode In addition to the standard line mode of operation, PDU can be used in "window mode". This mode offers several features to make debugging easier: - Function keys for frequently-used commands - Screen flipping, which keeps the application screen and the debugger screen separate, making it easier to debug full-screen applications - A separate window on the debugger screen for registers To use screen mode, you must invoke PDU with the -w switch: pdu -w [other_options] [program_name] @Function_keys @Register_window @Screen_flipping #WINDOW_MODE REGISTER_WINDOW =Window_mode Window_mode Register_window When PDU is operating in window mode, it always displays the current register contents at the top of the screen. The rest of the screen is devoted to the command area, where you enter commands just as you would in line mode. Since the registers are always displayed at the top of the debugger screen, PDU does not redisplay the register contents at tracepoints and breakpoints. Instead, it simply displays the next instruction to be executed. #WINDOW_MODE FUNCTION_KEYS =Window_mode Window_mode Function_keys When PDU is in window mode, the following key mappings apply: F1 - same as DOS F1 (template editing key) F3 - same as DOS F3 (template editing key) F4 - show application screen F5 - Go F6 - same as DOS F6 (end-of-file) F8 - Trace F10 - Procede (skip trace) if in assembly mode - Source-step if in source mode #WINDOW_MODE SCREEN_FLIPPING =Window_mode Window_mode Screen_flipping When PDU is in window mode, the application screen is kept separate from the debugger screen. Whenever the application code is running, its screen is displayed; whenever the debugger is in control, the debugger screen is displayed. So, any Trace, Go, Proceed, or Single-Step command will show the application screen until the debugger is in control again. You can look at the current application screen while the debugger is active by using the \ command, or by pressing the F4 key. The application screen is displayed until you hit another key, which returns you to the debugger screen. #COMMANDS \ =Commands Commands \ The \ command returns to the application screen when screen flipping has been enabled. PDU will display the current application screen until you hit a key, which will return you to the PDU command line. To enable screen flipping, use the -f switch when PDU is started. When screen flipping is enabled, the application screen is saved whenever the PDU command line is active, and is restored any time the application is running. This allows you to debug full-screen applications more easily. #COMMANDS SCREEN_FLIP =Commands Commands screen_flip The \ command is used to flip between the debugger and the application screen. See the \ command for more information. #COMMANDS QUESTION_MARK_? =Commands Commands ? The ? command has two functions: it operates like the Help command if you don't give it an argument, and it operates like the Evaluate command if you do. #COMMANDS $ =Commands Commands $ The $ command allows you to issue a DOS command or temporarily suspend PDU to use the command processor. To execute a DOS command: $<command> When the command has completed, control returns to PDU. All DOS commands are available, although care should be taken when using commands which will run or affect a program in protected mode. Specifically, it is unwise to remove the PME, to prem PDU, or to start another copy of PDU. To start a DOS subshell: $ The same warnings apply to commands executed within a DOS subshell. When you wish to return to PDU, issue the EXIT command to the DOS shell. #COMMANDS WORD =Commands Commands Word The Word comand displays memory in 16-bit words. Format: Word [address [Length <length>]] #COMMANDS WINDOW =Commands Commands WIndow The WIndow command allows you to specify a list of commands that should be executed each time your program is interrupted by a breakpoint. Normally, a Register command is executed, showing you the contents of the CPU registers and the next instruction to be executed. However, it is occasionally useful to display something else. To create a window macro: WIndow After typing the WIndow command, PDU will prompt you for a list of commands. You should enter any number of commands, one per line (just as you would enter to PDU directly) which are to be executed at each breakpoint. Enter a blank line when done. To delete the window macro: WIndow Close #COMMANDS UNASSEMBLE =Commands Commands Unassemble The Unassemble command displays object code. Format: U [address [Length <length>]] Symbols and source lines, if available, are displayed along with the object code. Note that if you have issued a MODE SOURCE command, only the source lines will be displayed. #COMMANDS TRACE =Commands Commands Trace The Trace command executes one machine-language instruction from your program. This allows you to examine the flow of your program in fine detail. The instruction at CS:IP is executed, and control is returned to the PDU command line. Format: T #COMMANDS SYMBOLS =Commands Commands Symbols The SYmbols command lists the symbols from your source program along with their addresses. Format: SYmbols [symbol] If you don't specify a symbol to examine, all symbols are listed. The symbol you specify may contain the wildcards '*' and '?'. '*' matches zero or more characters of a symbol name, and '?' matches exactly one character (but will also match the null character, so ABC? matches ABC as well as ABCD). Any number of wildcards of either type may be used in the symbol specification. #COMMANDS SOURCE_STEP =Commands Commands Source_step The Source-step command executes your program one source line at a time. It is the source-level equivalent of the Trace command. Format: Source-step To use the Source-step command, the CS:IP value must be inside code for which your symbol file contains line numbers, and the module must be assigned. If the line contains calls to subroutines, the Source-step command traces over those calls. You must use the Trace or Go command if you want to trace into subroutine calls. Except for lines containing RET (return) instructions, CS:IP will normally point to another source line from the same module after a Source-step command. #COMMANDS SHELL_ESCAPE =Commands Commands shell_escape The $ command is used to invoke an operating system subshell. See the $ command for more information. #COMMANDS REGISTERS =Commands Commands Registers The Registers command allows you to display or change the contents of the CPU registers. To display all registers: Register To modify the contents of a register: Register <reg> [=<value>] The <reg> must be AX, BX, CX, DX, SI, DI, BP, SP, CS, DS, ES, SS, or FLAGS. If you do not provide a value, PDU will display the current value and prompt you for a new one; if you do not enter a value at the prompt, the register will be left unchanged. #COMMANDS QUIT =Commands Commands Quit The Quit command terminates the debugging session, optionally leaving PDU resident in memory. Format: Quit [Resident] If you do not specify Resident, PDU is removed from memory along with the program you are debugging (if any). If you are debugging resident software, it is sometimes advantageous to leave PDU resident, so that it can intercept access violations in the resident software you are testing. It is much easier to interpret the conditions of access violations when you can investigate register and memory contents at the time of the exception. #COMMANDS PTR =Commands Commands PTr The PTr command displays memory as 32-bit pointers. Format: PTr [address [Length <length>]] #COMMANDS POINTER =Commands Commands POinter The POinter command is the same as the PTr comand. #COMMANDS NESTING =Commands Commands Nesting The Nesting command is the same as the K command. #COMMANDS MODE =Commands Commands Mode The Mode command allows you to turn assembly language listing on and off when you are debugging a program at source level. To mix assembler and source listings: Mode Assembler To list only the source code: Mode Source Note that you can list only assember code simply by closing (or not assigning) a module to the code you are debugging. Note also that if you are in Source-only mode, and the code pointer moves to an unassigned module, there will be no display of code at all. You will have to reenable assembler display using the Mode Assembler command in such a case. Typing the Mode command without an argument shows you the current mode. #COMMANDS LOAD =Commands Load Commands Load The Load command is used to load a program or symbols for the current program. @Program_loading @Symbol_loading #COMMANDS LOAD SYMBOL_LOADING =Commands Load Commands Load Symbol_loading To load symbols: Load Symbols <mapfile> You normally only need to use this command if your mapfile has a different name than your program file or if its extension is not .MAP. If you do not specify an extension with the Load Symbols comand, .MAP is assumed. #COMMANDS LOAD PROGRAM_LOADING =Commands Load Commands Load Program_loading To load a program: Load <program> [commandline] The specified program is loaded. If you have specified a commandline, it is passed to your program as though it had been the rest of the DOS command which loaded your program. After your program is loaded, PDU will attempt to load symbols for the program using a file with the same name drive, path, and filename as your program, but with a .MAP extension. Once your program has been loaded, the first instruction will be displayed and the registers will have their normal entry-condition values. NOTE: Do not specify PLOAD in the Load command; it automatically loads your program into protected mode for you. Also note that you cannot run a real-mode (.EXE) file in this manner. PDU only allows you to debug protected-mode programs. #COMMANDS K_NESTING =Commands Commands K_nesting The K command provides a stack traceback showing you the history of CALLs within your program. It shows you the current CS:IP location at the top of the list, then the location which called the current subroutine, then the location which called that, back to the beginning of your program. Format: K Note that the stack traceback assumes that a C-style function prologue is used (that is, BP is pushed, then set to point to the pushed value of BP). If you are in a subroutine with a non-standard prologue, or if the first few instructions of the subroutine haven't been executed yet, the traceback may miss some levels of nesting. #COMMANDS HELP =Commands Commands Help Use the Help command to display information on using PDU. #COMMANDS GO =Commands Commands Go The Go command begins or continues execution of your program from the current value of CS:IP until a breakpoint is hit or your program terminates. You can optionally specify a list of temporary breakpoints using the Go command. Syntax: Go [address [, address [...]] If present, the list of addresses (separated by commas) specifies locations at which temporary breakpoints should be set. Temporary breakpoints differ from ordinary breakpoints set using the BP command in that all temporary breakpoints are only in effect during this Go command. They are removed when any breakpoint, temporary or ordinary, is hit. #COMMANDS EVALUATE =Commands Commands Evaluate The Evaluate command prints the result of evaluating an expression. Format: Evaluate <expression> For example: e _main+30t*8 #COMMANDS DW =Commands Commands DW The DW command displays memory as 16-bit words. Format: DW [address [Length <length>]] #COMMANDS DELETE_SYMBOLS =Commands Commands DElete_symbols The DElete command drops all symbol and line number information. Format: DElete #COMMANDS DD =Commands Commands DD The DD command displays memory as double-words (pointers). Format: DD [address [Length <length>]] #COMMANDS DB =Commands Commands DB The DB command displays memory as bytes. Format: DB [address [Length <address>]] #COMMANDS DISPLAY_MEMORY =Commands Commands Display_memory The D (display memory) command displays memory in the current format. The format of the most recent display command is used. If you haven't used a display command yet, the byte format is used. Syntax: D [address] [Length <length>] #COMMANDS CLOSE =Commands Commands CLOse Note: PDU will automatically close modules as needed. This command is provided so that you can explicitly disable the display of source lines for certain modules. The CLOse command reverses the effect of the Assign command, disabling source line display for a module. Syntax: CLOse <module> The CLOse command can be used if you do not want source lines for the current module. After a close, source will not be displayed until you use Assign to re-open the module. Note that the effect of the CLOse command is achieved by hitting the RETURN key when PDU asks you the name of a source file it is attempting to automatically open. If you respond to the question with just the RETURN key, PDU will not try to open that module again until you use an Assign command on the module. #COMMANDS BYTE =Commands Commands Byte The Byte command displays memory in bytes. The syntax is: Byte [address [Length <length>]] #COMMANDS CLS =Commands Commands CLS The CLS command clears the screen. #COMMANDS BP =Commands BP Commands BP The BP command sets, removes, and displays breakpoints in your program. @Listing_breakpoints @Removing_breakpoints @Setting_breakpoints #COMMANDS BP LISTING_BREAKPOINTS =Commands BP Commands BP Listing_breakpoints To list breakpoints, enter BP without arguments. The address of each breakpoint is displayed. #COMMANDS BP REMOVING_BREAKPOINTS =Commands BP Commands BP Removing_breakpoints To remove a breakpoint, use BP -bpnumber, where bpnumber is the number of the breakpoint you wish to remove. (Whenever you set a breakpoint, PDU will tell you the number it has assigned to the breakpoint. You must use this number when referring to the breakpoint thereafter. If you have forgotten a breakpoint number, just list the breakpoints, and PDU will show you each breakpoint's number and address.) To remove all breakpoints, use the BP * command. Examples: remove breakpoint 3: bp -3 remove all breakpoints: bp * #COMMANDS BP SETTING_BREAKPOINTS =Commands BP Commands BP Setting Breakpoints To set a breakpoint, use BP <address>, where <address> is the location at which you wish to set a breakpoint. You can specify more than one address by separating the addresses with commas. For example, to set breakpoints at _main and at _hello, you would type: bp _main, _hello PDU will display the number it assigns to each breakpoint. There is an upper limit on the number of breakpoints; if you exceed this limit, PDU will not allow you to set any more breakpoints until you remove some. Also, PDU will not allow you to set a breakpoint in an invalid segment. #COMMANDS BASE =Commands Commands Base The BAse command sets the default base for numeric entry. You may set the default base to binary, octal, decimal, or hexadecimal. Syntax: BAse [base] Where base is: 'b', 'y', or '2' for binary; 'o', 'q', or '8' for octal; 'd', 't', or '10' for decimal; 'h', 'x', or '16' for hexadecimal. If you don't provide a new base, PDU will display the current default base. The default when you start the debugger is hexadecimal. Note that the BAse command does not affect the radix of numbers displayed by PDU. #COMMANDS ASSIGN =Commands Commands Assign Note: the Assign command is needed only if you have CLOsed a module, or if you didn't supply a filename when PDU asked you the name of a source file it was looking for. The Assign comand associates a source program file with an object module, allowing you to view source code interspersed with the object code it produced. The syntax is: Assign [module sourcefile] For example: assign test c:\user\test.c The example assigns the C program source file "c:\user\test.c" to the object module named "test". Subsequently, whenever you unassemble code belonging to the module "test", PDU will display the source code which corresponds to the object code being displayed. If you type the Assign command without arguments, all the currently open modules are listed. PDU will automatically assign modules for you as needed. You may choose to disable source line display with a CLOse command, however, and you can also disable it by hitting the RETURN key if PDU asks you for the file name of a source file it is attempting to open automatically. The Assign command can be used to re-open a module in these cases. #EXPRESSIONS =Expressions Expressions PDU will accept an algebraic expression almost anywhere it requires a number. In an expression, you can mix numbers of various bases, registers, symbols and line numbers from your program using arithmetic operators. To use a symbol from your program, just enter its name in place of a number. The full SEGMENT:OFFSET value of the symbol is used. To use a line number, you must specify the module and the line number within the module; for example, to specify the 100th line of module TEST, you would enter test#100 @Examples @Operators #EXPRESSIONS OPERATORS =Expressions Expressions Operators PDU recognizes the following operators in an expression: + addition - subtraction/unary negation * multiplication / integer division > bit-shift right (x > y is x shifted right y times) < bit-shift left & bitwise AND operation | bitwise OR operation ^ bitwise XOR operation ~ bitwise NOT operation The normal precedence rules of C apply to these operations, but you can use parentheses to override. #EXPRESSIONS EXAMPLES =Expressions Expressions Examples To unassemble instructions starting at _main: u _main To unassemble instructions starting at line 20 in module test: u test#20 To look at bytes of memory starting 30 bytes into the area starting at _buffer: db _buffer+30t (Note that the 't' after the '30' makes it a decimal number, regardless of the default base for numeric entry.) To look at pointers starting 20 (hex) bytes after ES:SI: dd es:si+20h To look at bytes in the 15th (decimal) entry in an array of data structures, each of which being 22 (hex) bytes long, based at _struc1 in the data segment, you would type: db ds:_struc1+15t*22h Note that you can mix numeric bases freely in this manner regardless of the default base. Also note that the multiplication is carried out before the addition, so the expression is evaluated correctly. #SYMBOLS = Symbols PDU will attempt to read symbols from the .MAP file corresponding to your program when the .PXE file is loaded. To create a .MAP file which PDU can use to find your program symbols, you should use the MS-DOS linker and specify the /MAP option. The .MAP file should have the same name as the .PXE file. If it doesn't, you must explicitly load symbols after the program is loaded using the LOAD SYMBOLS command. Once symbols have been loaded, PDU will display symbolic labels during object code unassembly, and you can use symbol names in place of the addresses they represent. You use a symbol by simply using its name in an expression. #SOURCE_LEVEL_DEBUGGING = Source_level_debugging PDU will attempt to read line numbers from the .MAP file when it loads your program. You should create the .MAP file using the MS-DOS linker and specify the /LINE option. See the help screen for Symbols for more information on the .MAP file. Once lines are loaded, you can use line numbers anywhere a number or symbol could be used. To specify line 120 in module test, you would use: test#120 (Note that line numbers are always entered and displayed in decimal, regardless of the default numeric base.) When you are debugging in a module with line numbers, you can use the Source-step command in conjunction with the Mode Source command to debug your program at source level, without having to pay attention to the machine-language program running underneath. PDU might occasionally ask you for the name of a source file. It will do this only when it can't find the file in one of the directories that a previous source file was in, or when the file has an extension that no previous source file had. If you just press ENTER, without a filename, PDU will not try to open a source file for the module. You can later tell PDU the name of the source file for the module using the ASSIGN command. If you want to tell PDU not to show source lines for a module, use the CLOSE command. Use ASSIGN to reverse the effect of a CLOSE. #nichts