APPENDIX B
`
`BugLite User's Guide
`
`Tools of the Trade
`
`The tool palette, on the left side of the task window, is used to switch modes of operation
`within BugLite. The current active tool is highlighted (inverted). Clicking on a tool will
`make it the current tool. The seven tools (from top to bottom) are shown in this section.
`
`ARROW tool; used to select objects to position them on the screen and
`
`connect objects.
`
`TASK tool; used to create a task.
`
`The task tool creates one task. Clicking anywhere in a task window will
`prompt you for the task name and add the new task to the window. The task
`can be moved around and connected to modules with the arrow tool.
`
`BugLite supports multiple tasks within the task Window.
`
`MODULE tool; used to open a module resource file. The standard file
`selection box will ask for the file to be opened.
`
`The module tool creates one module. Clicking anywhere in a task window
`will prompt you for the module resource file to open, as shown in Figure B-2.
`
`Figure B-2
`
`Open File dialog box
`
`51 EIIJMII Modules V
`
`PlagMunuPl2M.s
`PlagStereuPI2M.s
`PlaI_.|StereuSidSuund.s
`HeI:nrdStereuPI2M.s
`HeI:IJrdStereuSidSuund.s
`sr-3248.5
`srr:B24.s
`
`D TnggleFIelag.s
`
`Normally a module resource file is created using the following steps:
`
`1. Use the MPW editor to create the DSP3210 source code (example: Reve rb . s)
`
`2. Use the d32asm script to build the resource and put it into the source file:
`
`d32 asm Reve rb . s Reve rb . s
`
`Builds resource and puts it back into the source file
`
`INPUT tool; creates an object that provides access to the stereo sound input
`stream. This icon must then be connected to the appropriate input AIAO
`section. The data stream is 3210 floating-point numbers.
`
`Tools of the Trade
`
`Page 451 of 500
`
`429
`
`PUMA EXHIBIT 2005
`
`PART 10 OF 10
`
`Page 451 of 500
`
`

`
`APPENDIX B
`
`BugLite User's Guide
`
`OUTPUT tool; creates an object that provides the ability to sum a signal
`into the stereo output stream. This icon must then be connected to the
`appropriate output AIAO section. The data stream is 3210 floating-
`point numbers.
`
`DISK RECORD tool; used to create a new AIFF disk file that can be
`connected to a FIFO section to store data.
`
`DISK PLAY tool; used to open an existing AIFF file that can be connected to
`a FIFO section for data input.
`
`All objects in the task window have one or more triangular nibs (II-) associated with
`them. Nibs on the right side of an object are considered output and nibs on the left side
`are considered input. Two objects are connected by connecting their nibs with the arrow
`tool. These are the current valid connections:
`
`I Task to module: installs module into task.
`
`I Module to module: installs second module into task.
`
`I Section to section (both sections have same data type and size): allows section data to
`be shared between two modules.
`
`Sound input to AIAO: provides real-time data acquisition from the built-in
`microphone.
`
`AIAO to speaker output: provides real-time data playback to the built-in speaker.
`
`AIAO section to disk object: provides access to data on disk or saving data to disk.
`
`Using BugLite
`
`Before attempting to install a task onto the DSP subsystem each module's specification
`must be reviewed so that correct connections of module sections can be done. BugLite
`does only minimal checking for incompatible buffers.
`
`To make a task, follow these steps:
`
`1. Click anywhere in the task window with the TASK tool.
`The TASK tool will ask for a name for the new task. The name ”test” is used in the
`
`example, as shown in Figure B-3.
`
`Figure B-3
`
`Graphical representation of a task
`
`Using BugLite
`
`Page 452 of 500
`
`Page 452 of 500
`
`

`
`APPENDIX B
`
`BugLite User's Guide
`
`. Select the first module to be loaded.
`
`Figure B-4 shows a file input module ”File In” used for getting data into the DSP data
`stream. The MODULE tool uses the standard file selection dialog box to make the
`selection.
`
`Figure B-4
`
`Graphical representation of a module
`
`Fileln
`
`Pregrannfl
`
`LAIAIII
`
`R.-ill.-5.IZI
`
`Vafiame
`
`Cache
`
`Datafluff
`
`3. Connect the TASK to the MODULE using the ARROW tool.
`Figure B-5 shows a task connected to a module.
`
`Figure B-5
`
`Task connected to a module
`
`Fileln
`
`Pregrmnfl
`
`L.-5.|.-5.III
`
`RAIAIII
`
`Variable
`
`Cache
`
`Datafluff
`
`In this example there is a task called ”test” that was created with the TASK tool. The
`task has one module, ”File In,” connected to it.
`
`Using BugLite
`
`Page 453 of 500
`
`Page 453 of 500
`
`

`
`APPENDIX B
`
`BugLite User's Guide
`
`4. Select the DISK PLAY tool.
`
`The DISK PLAY tool uses the standard file selection dialog box to make the selection.
`
`Figure B-6
`
`Disk play of “funky” file
`
`funkg
`
`In this example there is a data file called ”funky” that is stored on disk. This data is in
`the AIFF data format.
`
`5. Connect the DISK PLAY icon (”funky” file) to the "DataBuff” section using the
`ARROW tool.
`
`Figure B-7
`
`Disk player connected to input buffer
`
`Fileln
`
`F'r'-:-gran':III
`
`LAIAD
`
`RAIAU
`
`'-i-'ar'iai:-ie
`
`Cache
`
`DataEiuff
`
`funku
`
`6. Select the OUTPUT tool and place the icon to the right of the module.
`
`Figure B-8
`
`Speaker connection icon
`
`iii
`
`Using BugLite
`
`Page 454 of 500
`
`Page 454 of 500
`
`

`
`APPENDIX B
`
`BugLite User's Guide
`
`7. Connect the L and R inputs of the OUTPUT icon to the ”LAIAO” and
`”RAIAO”sections respectively using the ARROW tool.
`
`Figure B-9
`
`Data output buffers connected to speakers
`
`Datafluff
`
`funkg
`
`8. Click once on the diamond shaped start button in the ”test” task icon.
`The diamond will change into a blinking square.
`
`Figure B-10
`
`Task with task active indicator
`
`The task has now been loaded into the DSP subsystem and the sounds recorded in the
`”funky” data file will play out of the DSP subsystem audio output.
`
`To disconnect two objects, click in one of the nibs and drag away from it. If the discon-
`nected object is part of a task that is executing, the task is stopped and removed from
`the DSP.
`
`To delete an object from the task window first select it by clicking on it with the arrow
`tool, then press the delete key. If the deleted object is part of a task that is executing, the
`task is stopped and removed from the DSP.
`
`Using BugLite
`
`Page 455 of 500
`
`Page 455 of 500
`
`

`
`APPENDIX B
`
`BugLite User's Guide
`
`Getting Information
`
`In the menu bar under Object is the Get Info selection. This selection provides informa-
`tion about the selected item. Each task, module, and section has specific kinds of data.
`Double-clicking an object will also bring up the object's information window.
`
`Task Info Window
`
`The task info window provides information on
`
`I real-time DSP cycles used in processor clock cycles
`
`I real-time or timeshare mode selection
`
`In Figure B-11 the task ”test” shows zero real-time cycles used, indicating that the task
`has not been run. The task has been set up to be inserted into the real-time task list. This
`will result in it being allocated a guaranteed bandwidth on the DSP.
`
`Figure B-11
`
`Task Get Info window
`
`Info for task: test
`
`Heal-time cycles used:
`
`I]
`
`E Heal—Time
`
`Module Info Window
`
`The module information window provides information on
`
`I Real—time DSP cycles used in processor clock cycles
`
`I Number of DSP frames that have been executed since the module was installed
`
`I Skip count setting for this module
`
`Getting Information
`
`Page 456 of 500
`
`Page 456 of 500
`
`

`
`APPENDIX B
`
`BugLite User's Guide
`
`I Flags for the module: a capital letter means flag is set, a lowercase letter means the
`flag is Clear:
`
`Flag
`d
`
`Meaning
`Demand cache
`
`0
`a
`
`c
`
`On-chip section table
`Use actual GPB
`
`Count this module in GPB calculation
`
`I Buffer scaling for this module, user changeable for configuration testing
`
`In the Get Info window shown in Figure B-12, the real-time cycles used are in DSP clock
`cycles. For this test, the DSP3210 had a frame time of 10 ms and a clock rate of 50 MHz.
`This results in a total of 500,000 DSP cycles per frame. This module used .0127 percent of
`the available DSP bandwidth. The value for real-time cycles used is the maximum cycles
`used in a single frame during a run of 59297 frames.
`
`Figure B-12
`
`Module Get Info window
`
`Info for module:
`
`Fileln
`
`Heal—time cycles used: 6353
`Frames euecuted: 5929?
`
`Skip count:
`
`I]
`
`Flags: dual:
`
`Buffers-::a|ing:
`
`Getting Information
`
`Page 457 of 500
`
`Page 457 of 500
`
`

`
`APPENDIX B
`
`BugLite User's Guide
`
`Section Information
`
`The section information window, shown in Figure B-13, provides information on
`
`I Size of the section in bytes
`
`I Type of section: capital letter means flag is set; lower-case means flag is clear:
`
`Flag
`
`Meaning
`
`1
`
`o
`s
`
`t
`
`Input buffer
`
`Output buffer
`Scalable section
`
`Static section
`
`I Flag settings: capital letter means flag is set; lower-case means flag is clear:
`
`Flag
`1
`
`s
`
`Meaning
`Load section
`
`Save section
`
`Clear section
`
`Save on context switch
`
`Bank A
`
`Bank B
`
`DSP use only (only DSP should modify this memory)
`
`The Get Info window in Figure B-13 can be decoded as
`
`I section size: 960 Bytes
`
`I section type: Not a defined section type
`
`I caching flags: Save section, Clear section, Save on context switch, Load section into
`Bank B, DSP use only
`
`Figure B-13
`
`Section Get Info window
`
`Info for section: LHIHIJ
`
`Size:
`
`960
`
`Bytes
`
`Type:
`
`inst
`
`Flags:
`
`I§C|.I.|flBI]
`
`Getting Information
`
`Page 458 of 500
`
`Page 458 of 500
`
`

`
`APPENDIX C
`
`Snoopy User's Guide
`
`Snoopy is a powerful, browser/ debugger, in the tradition of SourceBug, for the DSP
`programming environment. Like SourceBug, it provides breakpoint, single stepping, and
`code disassembly capabilities. Unlike SourceBug, it also provides editing capabilities and
`operates on code already installed in the system. Snoopy does not support source-level
`debugging at this time.
`
`This appendix describes how to use the Snoopy debugger.
`
`The section ”Getting Started” tells how to install the Snoopy application and provides
`detailed information about how it works.
`
`”Using Snoopy” provides valuable information about the menu commands and how to
`access additional controls and selections when available. The menu commands are listed
`
`in the order they would most likely be used. When a command invokes a dialog box, the
`selections available in the box are discussed immediately following the command. The
`windows available for displaying more information are detailed in ”Additional
`Information Windows.”
`
`To run Snoopy, you need system software 7.1 or later and at least 128 KB of available
`RAM; preferred size is 768 KB.
`
`Getting Started
`
`This section tells you how to install and launch the Snoopy debugger.
`
`Installation
`
`Snoopy operates as an application running on the Macintosh Quadra 840AV or
`Macintosh Centris 660AV main processor. To use it:
`
`1. Copy the application to your hard drive.
`
`2. Launch Snoopy.
`
`Snoopy can reside anywhere on your hard drive. However, you may find it useful to
`have Snoopy in the same directory as your DSP object code so you don't have to search
`through multiple directories to locate your source or symbol files. See ”Module Menu,”
`later in this appendix, for instructions on loading and removing symbols.
`
`Getting Started
`
`Page 459 of 500
`
`Page 459 of 500
`
`

`
`APPENDIX C
`
`Snoopy User’s Guide
`
`What You See When You Launch Snoopy
`
`When Snoopy is launched the DSP Control window will show information about the
`built-in DSP. In multiple DSP systems there would be an icon for each processor. To
`select the processor to debug, click on the ICON for the desired processor. Figure C-1
`shows the ICON for the built-in DSP. To show and hide the DSP Control window see
`
`”Windows Menu,” later in this appendix.
`
`Figure C-1
`
`DSP Control window
`
`The Real Time Tasks window, shown in Figure C-2, is the primary display window for
`both code and data display. If there are tasks currently installed on the DSP, they are
`shown in the scrollable lists at the top of the window.
`
`Note
`
`Standard sound automatically installs itself onto the DSP
`to enable the sound functions. 0
`
`Task/Module/Section Lists
`
`At the top of the Real-Time Tasks window are three scrollable lists that contain (from left
`to right) the currently installed tasks, the modules belonging to the currently highlighted
`task, and the sections belonging to the currently highlighted module. This hierarchical
`representation makes navigation through the potentially large number of tasks, modules,
`and sections straightforward and intuitive.
`
`For example, in Figure C-2 there is one task installed in the system named Input. Task
`Input has one module, Input, that has four sections. The section currently being
`displayed in the Data Display window is Program. If you wanted to view the Temp
`section, you would simply click on Temp in the list, and it would appear in the Data
`Display window.
`
`The Data Display Window
`
`The lower half of the Real-Time Tasks window contains the Data Display window. The
`data belonging to the currently selected section is displayed here in the current format.
`See ”Formatting,” later in this appendix, for details.
`
`Getting Started
`
`Page 460 of 500
`
`Page 460 of 500
`
`

`
`A P P E N [)1 X C
`
`Snoopy User's Guide
`
`Figure C-2
`
`Real Time Tasks window
`
`Heal Time Tasks
`
`%|
`
`E
`
`E F'ru:u;|r'.arn
`
`n|:nut
`Preput
`
`Pl
`call
`
`P22 + 0><02FIC
`*P13
`(short) 0><0004
`r~13 (P13)
`0 + P2
`P22 + 0><0310
`*r*4
`P22 + 0><03I34
`*r3
`r4 + 0x0004
`*r'-1
`0x0001
`if'-’.ne) Pl = P1 + F5
`FE! — r*19 + 0><0000
`PEI
`*r'-I5
`nap
`Pl
`
`
`
`
`
`991111|II|IIIIII
`
`2‘";?fers_
`
`Breakpoint
`
`PC indicator
`
`Bl-eakpoint
`column
`
`PC column
`
`I
`I
`Postput
`E
`Dutput
`Dffset Flddress
`I:II:II:II:II:I FF|F|I:I'.-";lI:II:I
`+00004 FF|FIO?904
`+00003 FFIFIO'r‘903
`+00000 FFIFIO'r‘900
`+00010 FFIFIO'r‘910
`+00014 FFIFIO'r‘914
`;*+00013 FFIFIO'r‘913
`+0001|3 FFIFIO'r‘91|3
`5
`+00020 FFIFIO'r‘920
`+00024 FFIFIO'r‘924
`+00023 FF|FIO?923
`+0002|3 FFIFIO'r‘92|3
`+00030 FFIFIO'r‘930
`+00033 FFIFIO'r‘933
`+00034 FFIFIO'r‘934
`+00030 FFIFIO'r‘930
`+00040 FFIFIO'r‘940
`+00044 FFIFIO'r‘944
`+00043 FFIFIO'r‘943
`+00040 FFIFIO?940
`+00050 FFIFIO'r‘950
`Store Address
`
`5
`
`=
`
`-
`
`Duta
`'3EIEEIIZE: 1'.-‘
`90E5031?
`90F4|331'.’
`9Ei9F|02FIC
`90F4FI000
`14200004
`12940000
`30000000
`93050022
`94930310
`90E42000
`94730304
`90E31300
`90E10300
`94240004
`93E30001
`93010335
`94050000
`9CE53000
`30000000
`93010021
`
`0 + F1
`
`Data display window
`
`Run/Store Address Pop-up Menu
`
`The DSP sections have (potentially) two containers; one at the ”storage” address, and the
`other at the ”run” address. The storage address, if there is one, is usually off-chip (in host
`DRAM or local SRAM), while the run address can either be off-chip or on-chip. The Run/
`Store Address pop-up menu, shown in Figure C-3, allows you to select which location
`you wish to view.
`
`Note
`
`Because the DSP operating system is a caching operating system, it is
`difficult, if not impossible, to present cached data in a meaningful way
`while the DSP is running. Consequently, when you switch to a cached
`”Run Address” and the machine is running, a message will appear
`in the Data Display window indicating that the data is unavailable.
`Similarly, if you stop the DSP and attempt to display a cached run
`address that has yet to be cached, a message will appear indicating that
`the section is out of scope. 0
`
`Figure C-3
`
`Run/Store Address pop-up menu
`
`Hun Hddress
`
`v-‘Stare Hddress
`
`Getting Started
`
`Page 461 of 500
`
`Page 461 of 500
`
`

`
`APPENDIX C
`
`Snoopy User’s Guide
`
`PC Column
`
`The PC (program counter) indicator (an arrow) appears in the PC column, at the
`appropriate offset, indicating where the DSP is stopped in the specified section. Any
`window showing the data where the program counter has stopped will also show the PC
`indicator arrow.
`
`The Breakpoint Column
`
`The breakpoint column, located at the left of the PC column, shows both the current
`breakpoints and the possible breakpoint/ single step locations (called breakpoint
`candidates). Current breakpoints are indicated by a diamond, and breakpoint candidates
`are indicated by gray brackets. Breakpoint restrictions are discussed in detail in ”Setting
`and Clearing Breakpoints,” later in this appendix.
`
`Pane Resizers
`
`As you can see, the Real-Time Tasks window and the other data display windows are
`divided by double lines into panes, each of which is resizable. To resize a pane, simply
`place the cursor on the Pane Resizers, click, drag, and release at the desired point. The
`cursor becomes a pair of opposing arrows as shown in Figure C-4. Resizing allows you
`to optimize your screen's real estate.
`
`Figure C-4
`
`Vertical and horizontal pane resizers
`
`i:Resizer cursor
`
`Using Snoopy
`
`This section explains the use of all Snoopy’s menu items. There are additional controls
`that are accessed using either a double click of the mouse or the Option key and a mouse
`click. These additional controls are explained where appropriate.
`
`Using Snoopy
`
`Page 462 of 500
`
`Page 462 of 500
`
`

`
`APPENDIX C
`
`Snoopy User's Guide
`
`Menu Bar
`
`There are two standard menus: File and Edit. The other five menus are specific to
`Snoopy, as shown in Figure C-5.
`
`Figure C-5
`
`Menu bar
`
`E File Edit
`
`Find Module Control
`
`Inspect windows
`
`Control Menu
`
`The Control menu has commands for running (Run), stopping (Break), and single
`stepping (Single Step) the DSP. If the DSP is running only the Break command will be
`available, as shown in Figure C-6. In order to View a cached program or data from a
`module, the DSP must be stopped while executing in the module's program section. This
`is done by first using the Break command to halt the DSP, then setting a breakpoint in
`the desired module. Breakpoints are explained in ”Setting and Clearing Breakpoints,”
`later in this appendix.
`
`Figure C-6
`
`Control menu
`
`i File Edit
`
`Find Module Control
`fies;
`Break
`
`Inspect windows
`
`$s's:s_§§§> fiiegz
`
`{Z§<=:<';;' §§§§ §§;'<=:<'§§<;;<;'§:;E~§
`
`After the DSP has been stopped using the Break command, the Run and Single Step
`commands become available, as shown in Figure C-7.
`
`Figure C-7
`
`Control commands after break
`
`i File Edit
`
`Find Module Control
`Hun
`§§;'e<';§<
`
`Inspect windows
`
`Single Step
`
`{I§<a<'ss' §§§§ §§s'<a<'sk;;<s'sr;‘§<>
`
`The Clear All Breakpoints command is available only if the DSP is stopped and there are
`one or more breakpoints set.
`
`Using Snoopy
`
`Page 463 of 500
`
`Page 463 of 500
`
`

`
`APPENDIX C
`
`Snoopy User’s Guide
`
`Setting and Clearing Breakpoints
`
`To set a breakpoint in a section, move the mouse to the breakpoint column and click in
`any row that has a breakpoint candidate marker. See Figure C-8. (Notice that the cursor
`has changed to the breakpoint cursor.) To remove a breakpoint, simply click the
`breakpoint indicator. To remove all breakpoints use the Control menu's Clear All
`Breakpoints command.
`
`Figure C-8
`
`Setting breakpoints
`
`Breakpoint candidate
`Breakpoint indicator
`
`Note
`
`You cannot set or clear a breakpoint while the DSP is running. 6
`
`Snoopy can also set a breakpoint to the nth occurrence of the instruction. To set a
`multiple breakpoint the breakpoint must already have been set. Use the Option key and
`click the breakpoint indicator to set the number of times the breakpoint instruction is to
`be executed before stopping the DSP. A dialog box will appear allowing you to change
`the pass counter on the specified breakpoint. See Figure C-9. The initial number is
`always one. If the breakpoint counter is set to four then the breakpoint instruction will
`execute three times and stop the DSP on the fourth occurrence of the instruction.
`
`Figure C-9
`
`Setting the breakpoint counter
`
`Break point count:
`
`ml
`
`ll
`
`Breakpoint Restrictions
`
`Because the AT&T DSP3210 is a pipelined device, and because it has minimal provisions
`for debugging, there are restrictions as to Where you can set breakpoints. You can only
`set a breakpoint at a location that has a breakpoint candidate marker.
`
`Using Snoopy
`
`Page 464 of 500
`
`Page 464 of 500
`
`

`
`APPENDIX C
`
`Snoopy User's Guide
`
`Single Stepping
`
`To step to the next available instruction (not necessarily the next instruction), select
`Single Step from the Control menu.
`
`Note
`
`Single Stepping is implemented using breakpoints (remember, no trace).
`Because of this, Snoopy can only step within a section or DSP operating
`system routine. 9
`
`Inspect Menu
`
`The Inspect menu provides access to additional display windows. These windows are
`available to View real-time tasks, timeshare tasks, DSP operating system routines, the
`EVT, the on—chip SRAM, and the registers. See Figure C-10.
`
`Figure C-10
`
`Inspect menu
`
`i File Edit Find Module Edntrdl
`
`Inspect
`Uiew Real Time Tasks
`éfiéem '§§'§::§? §?s<';;'e E'<';s§<s
`UieLI.I Kernel Hdutines
`UieLI.I ElIT
`UieLI.I l]n Chip SHHM
`Uiew Registers
`
`éfiéssss §€'E§{é€
`
`tins: :25;
`
`Additionally, the Inspect menu has the View Selection As submenu. This menu is used to
`select the different data formats for viewing purposes only. See Figure C-11. Changes
`made in the View Selection As menu do not effect the actual data type. To coerce data
`into another data type see the ”Editing Data” section.
`
`Figure C-11
`
`Data display format menu
`
`SZIIJ EIJIZIE
`
`3210 Fleet [8 per line]
`3210 Heat [1 per line]
`IEEE Float [3 per line]
`IEEE Fldat [I per line]
`J1 Law [3 per line]
`1.1 Law [1 per line]
`H Law [8 per line]
`H Law [I per line]
`Long [8 per line]
`Long [1 per line]
`Short [8 per line]
`Short [1 per line]
`
`Using Snoopy
`
`Page 465 of 500
`
`Page 465 of 500
`
`

`
`APPENDIX C
`
`Snoopy User’s Guide
`
`Formatting
`
`Data can be displayed in several formats. To change the data format, highlight the
`display lines you wish to change and select a format from the View Selection As menu
`accessed through the Inspect menu. To highlight multiple lines hold down the shift key
`while dragging the mouse.
`
`Editing Data
`
`Editing data is a point-and-click operation. Simply point to the data element you wish
`to edit in the data display window and double-click. The dialog box shown in
`Figure C-12 will appear, allowing you to View and edit the data and the data type.
`
`Figure C-12
`
`Data editing window
`
`Data @FEE1F3?l]
`
`f-2-21-2|:-1'-'1
`
`Note
`
`Data Viewed as type DSP Code cannot be edited. 0
`
`WARNING
`
`DSP Code can be viewed as some other data type and the editor will
`allow it to be changed. Extreme caution should be used when changing
`DSP Code. There are no safeguards to prevent illegal opcodes from
`being entered. This could result in loss of data or code. A
`
`The defined data types that can be selected are shown in Figure C-13. Changes in the
`data type will coerce the data into the new data type. Use the View Selection As menu
`if you only want to View the data in a different format.
`
`Figure C-13
`
`Defined data types
`
`IEEE Float
`1.1 Law
`H Lam
`
`Using Snoopy
`
`Page 466 of 500
`
`Page 466 of 500
`
`

`
`APPENDIX C
`
`Snoopy User's Guide
`
`Windows Menu
`
`When you launch the Snoopy application, you are presented with the Real-Time Tasks
`window and the Current PC window. As shown in Figure C-14, the Windows menu lists
`all open windows at the bottom of the menu and provides a quick way to bring any
`window to the front. Auto Hide Windows (not implemented) removes the current
`window when a new window is selected. The Windows menu also provides limited
`control over open windows.
`
`Figure C-14 Windows menu
`
`Module Eontrol
`
`Inspect
`
`Update Front window BEU
`Full Titles
`Hide DSP Control
`§§zs§<s §§'s<§<5 i§§'sr;<§<s;;s<>
`
`./Current PE
`Real Time Tasks
`
`When the DSP is running the frontmost window is not automatically updated. The
`Window must be told to update or the data display will show only old data. This can be
`done using the Update Front Window command in the Windows menu. Windows such
`as Registers, Real-Time Tasks, and Timeshare Tasks will not have their data display
`window updated if the DSP is running.
`
`Windows can also be set to show the full title using the Full Titles command. This
`includes information describing the specific DSP chip that the module is running on.
`Also, the DSP Control window can be hidden or displayed from the Windows menu.
`
`Additional Information Windows
`
`This section describes the additional display windows used to provide information
`about other parts of the DSP. The additional windows provide information about the
`inside operation of the DSP. There are five additional windows:
`
`I Current PC
`
`I Kernel Routines
`
`I EVT (Exception Vector Table)
`
`I On-Chip SRAM
`
`I Registers (in the DSP)
`
`Using Snoopy
`
`Page 467 of 500
`
`Page 467 of 500
`
`

`
`It P P E PG I) I X C
`
`Snoopy User’s Guide
`
`Current PC
`
`The Current PC window shows the section or DSP operating system routine that was
`running on the DSP when a break was initiated. This window can only show data when
`the DSP has been stopped. If the DSP has been stopped with no breakpoint set it will
`always stop at External Intone of the DSP operating system routines. Figure C-15
`shows the current program counter when a breakpoint is set in the Standard Sound
`Input Taskzlnput Modu1e:Program Section at address 5 O 0 3E O 2 O. The current PC
`location has been single stepped two times. Notice that the address 5 0 0 3E O 1 4 has no
`breakpoint allowed. It will also be stepped over by the single—step procedure.
`
`Figure C-15
`
`Current PC window
`
`Current PE
`
`Input->|npul->PriJ I ram
`HddFess
`Data
`+00000 5003E000 QDESCB1?
`+00004 5003E004
`90EfiC81?
`+00008 5003E008
`90F4C81?
`+0000C 5003EO0C 95980280
`+00010 5003E010
`9CF4H000
`+00014 5003E014
`14200004
`;
`§j»+00018 5003E018
`12940000
`‘
`+00010 5003E0
`8000000
`flflflzfl
`.
`:
`u
`5:
`iv
`+00024 5003E02
`9 H0310
`+00028 5003E028
`9CE42000
`+0002C 5003E02C 94?H03C4
`+00030 5003E030
`9CE31800
`+00034 5003E034
`94240004
`+00038 5003E038
`9CE10800
`+0003C 5003E03C 9BE30001
`+00040 5003E040
`98010885
`+00044 5003E044
`94050000
`+00048 5003E048
`9CEE3000
`+00040 5003E04C 80000000
`+00050 5003E050
`98010021
`5003E054
`98020025
`I
`-
`..
`
`Run
`
`*sp++
`*sp++
`*sp++
`F18
`F18
`F1 = (shoFt) 0x0004
`call F18 (F18)
`
`9911IIIIIIIIIIII
`
`F22 + 0x0310
`*F4
`F22 + 0x03C4
`*F3
`F4 + 0x0004
`*F1
`0x0001
`iffine) F1 = F1 + F5
`F19 + 0x000C
`
`The DSP Operating System Routines
`
`DSP operating system routines are shown in the Kernel Routines window; simply select
`View Kernel Routines from the Inspect menu. The DSP operating system routines will be
`presented in a browser window similar to the Real-Time Tasks window with the
`exception of the list at the top. This window is shown in Figure C-16. You can mani-
`pulate DSP operating system routines (set breakpoints, single—step, and reformat) the
`same way you manipulate sections.
`
`Using Snoopy
`
`Page 468 of 500
`
`Page 468 of 500
`
`

`
`APPENDIX C
`
`Snoopy User's Guide
`
`Figure C-16
`
`DSP Operating System Routines window
`
`Kernel Routines
`
`ParseSegrnent
`Pushflegisters
`PopRegisters
`
`Anoni Mouse
`Anoni Mouse
`Anoni Mouse
`
`+00004 5003F87
`+00008 5003F880
`+00000 5003F884
`+00010 5003F888
`+00014 5003F880
`+00018 5003F890
`+00010 5003F894
`+00020 5003F898
`+00024 5003F890
`+00028 5003F880
`+00020 5003F884
`+00080 5003F888
`+00034 5003F880
`+00088 5003F880
`+00030 5003F884
`+00040 5003F888
`+00044 5003F880
`+00048 5003F800
`+00040 5003F804
`+00050 5003F808
`Run Address
`
`48000
`95?80240
`1420FFF8
`12940000
`90E19800
`95980278
`90F48000
`80000000
`12940000
`80000000
`943803F0
`128F0050
`945803E0
`95980254
`90F48000
`98958835
`12940000
`94380300
`98958835
`943803E0
`
`P1? = P22 + 0x0240
`P1 = (short) 0xFFF8
`call P18 (P18)
`*P1? = P1
`P13
`P22 + 0x0278
`P13
`*P13
`hop
`call F13 (F18)
`nap
`P1 = P22 + 0x03F0
`cull pc+0X0050 (P183
`P2 = P22 + 0x03E0
`P18
`P22 + 0X0254
`P13
`*P13
`P19
`P19 - P19
`cull P18 (P18)
`= P22 + 0x0300
`P19 - P19
`P22 + 0x03E0
`
`The EVT
`
`The DSP operating system places system information, such as run—time variables and
`routine addresses in the exception vector table (EVT). To View the EVT window, select
`View EVT from the Inspect menu. The resulting window is shown in Figure C-17.
`
`Figure C-17
`
`EVT window
`
`+00000 00015280
`+00004 00015284
`+00008 00015288
`+00000 00015280
`+00010 00015290
`+00014 00015294
`+00018 00015298
`+00010 00015290
`+00020 00015280
`+00024 00015284
`+00028 00015288
`+00020 00015280
`+00030 00015280
`+00034 00015284
`+00088 00015288
`+00030 00015280
`+00040 00015200
`+00044 00015204
`+00048 00015208
`+00040 00015200
`+00050
`
`00015880
`00000000
`802FO0F0
`90F90000
`802F0108
`90F90000
`00000000
`00000000
`00000000
`00000000
`00000000
`00000000
`00000000
`00000000
`00000000
`00000000
`802FO0F8
`90F90000
`802FO0F0
`90F90000
`00000000
`
`Run
`
`Using Snoopy
`
`Page 469 of 500
`
`Page 469 of 500
`
`

`
`APPENDIX C
`
`Snoopy User’s Guide
`
`On-Chip SRAM
`
`To View the On-Chip SRAM window, select View On Chip SRAM from the Inspect
`menu. The resulting window is shown in Figure C-18.
`
`E
`
`Figure C-18
`
`On-Chip SRAM window
`
`l]n E|'Ii|J SFIHM
`
`90E5031?
`+00000 5003E000
`90E5C31?
`+00004 5003E004
`90E?C31?
`+00003 5003E003
`+0000C 5003EO0C 90E3C31?
`+00010 5003E010
`90E9C31?
`+00014 5003E014
`90F4C31?
`+00013 5003E013
`94350003
`+00010 5003E010
`90E52300
`+00020 5003E020
`30000000
`+00024 5003E024
`95150004
`+00023 5003E023
`9CE34000
`+0002C 5003E02C 30000000
`+00030 5003E030
`94050003
`+00034 5003E034
`9CE53000
`+00033 5003E033
`30000000
`+0003C 5003E03C 95350010
`+00040 5003E040
`90E94300
`+00044 5003E044
`30000000
`+00043 5003E043
`95930230
`+0004C 5003E04C 9CF4H000
`+00050 5003E050
`14200004
`._.:u:n:u-d
`Run Address
`
`*sp++
`*sp++
`*sp++
`*sp++
`*sp++
`*sp++
`P5 ‘ P19 + 0x000C
`*P5
`
`P19 + 0x0004
`*P3
`
`P19 + 0x0003
`*Pfi
`
`P19 + 0x0010
`*P9
`
`P22 + 0x02HC
`*P13
`P13
`P1 = (Short) 0x0004
`
`When the DSP has been stopped, all sections that are currently in it's cache can be
`viewed in the On-Chip SRAM window. The data displayed is an image of the
`cached code, buffers, tables, and other types of sections. Figure C-19 shows a possible
`SRAM layout.
`
`Figure C-19
`
`Example of SRAM layout
`
`— Unused memory
`
`Code Section
`
`Pexerneier Section
`
`Data Section
`
`Registers
`
`To display the DSP registers, select Show Registers from the Edit menu. The resulting
`window is shown in Figure C-20. Notice that the processor status word is displayed as a
`group of check boxes in the upper right corner.
`
`Using Snoopy
`
`Page 470 of 500
`
`Page 470 of 500
`
`

`
`APPENDIX C
`
`Snoopy User's Guide
`
`Figure C-20
`
`Registers window
`
`E Registers
`
`UUZHCVZH
`
`pc sddsreve
`
`fl|:|[E||:||:||:||:||:|
`
`|3|I||I|15EI5S
`r‘-1
`r2 DIZIIZIDIIIIZI44
`P3 ffffEi|I|E||3
`r‘-4 DIZIIZIDIZIIZIEII
`P5 IJEIEIDEIEIEID
`r‘-5 DIZIIZIDIZIIZIEII
`P? |J|ZI|ZI2fT'EI1
`
`r*El DDDDDD23
`r‘-Q ffffffff
`
`r11 5|II|II3fcb|3
`r12 DEIEIDEIEIEII3
`
`r‘-14 ffffe2cIf
`
`r‘-15 DIIIIIIDIIIEIEID
`P15 |J|ZI|ZI15EI?3
`r‘1'r‘ |3|I|14|:I5cEl
`r‘-18 |J|ZI|ZI153ec
`P19 IJEIEIDEIEIEID
`
`P20 5|ZI|ZI3fS?3
`
`sp U|I||I|15n:d4
`r22 DIZIIZIIEZSD
`
`El
`-81650.08
`
`The Registers window displays the contents of all of the DSP registers for the instruction
`at the current PC location. The Registers window is not updated while the DSP is
`running. Manual update of the frontmost window is explained in ”Windows Menu,”
`earlier in this appendix.
`
`Standard Menus
`
`Snoopy uses the two menus that resemble standard Finder menus: File and Edit. The File
`menu is used for opening, closing, and saving files. It uses the standard dialog box for all
`operations. The Edit menu operates like the standard Finder Edit menu.
`
`Find Menu
`
`There are two commands in the Find menu. The Find command is used to locate specific
`strings within the currently selected window. The Find Again command finds
`subsequent occurrences of the specified information. See Figure C-21.
`
`Figure C-21
`
`Find menu
`
`i File Edit
`
`Find Module Edntrdl
`Find
`38F
`
`Inspect windows
`
`iiérzsé §§§<'§%¥§
`
`223%‘;
`
`Using Snoopy
`
`Page 471 of 500
`
`Page 471 of 500
`
`

`
`APPENDIX C
`
`Snoopy User’s Guide
`
`When the Find command is selected the dialog box in Figure C-22 will appear. The Find
`command can locate specific data values that are of a specific data type. If the specified
`value is in the display range of any of the windows, the required window will be
`selected and the address will be shown. The required window does not need to be the
`frontmost Window or even open for the Find operation to select it.
`
`Figure C-22
`
`Find Command dialog box
`
`Find lllhat ?
`
`Lnnk For:
`
`"Eta Tune
`
`(E) Hddress with that Llalue
`D Dffset with that value
`C: Instance with that ualue
`
`Search In
`
`Hll Sections
`
`There are three ways to look for specific locations in the data display. They are:
`
`I look for an address with the specified Value
`
`I look for an offset with the specified value
`
`I look for an instance with the specified value
`
`When trying to locate a specific address location in the Data Display window use the
`Look For Address with that value. When looking for a relative address within the data
`display use the Look For Offset with that Value. To look for a specific data word within
`the data window use the Look For Instance with that Value.
`
`The default data type is a Long Word. This should be used Whenever specifying an offset
`value. When looking for an Instance the data type may also be specified, as shown in
`Figure C-23.
`
`Figure C-23
`
`Find Data Types menu
`
`Shnrt
`Ehar
`32]!) Float
`IEEE Flnat
`1.1 Law
`H Law
`
`Using Snoopy
`
`Page 472 of 500
`
`Page 472 of 500
`
`

`
`APPENDIX C
`
`Snoopy User's Guide
`
`You may also specify the section or sections to be searched, as shown in Figure C-24.
`
`Figure C-24
`
`Search In selection menu
`
`Current Section
`Search In \/H" Sections
`
`If the data with the specified data type