home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / a_utils / debugger / amiga / powervsr.rdm < prev   
Encoding:
Text File  |  1992-02-18  |  11.3 KB  |  151 lines
  1. This is PowerVisor, a powerful machinelanguage level debugger                   
  2. for the serious Amiga programmer.                                               
  3.  
  4. This is an update to PV V1.10 beta. Many bugs have been fixed and
  5. some new features are added.
  6. This is version V1.13 beta. (notice ! still beta)
  7.  
  8. Below follows a list of features.                                               
  9. PowerVisor is shareware. Read the 'ReadThisFile' file in the                    
  10. root of the zoo file for more info.                                             
  11.                                                                                 
  12. Warning ! This is still a beta version. Although a very                         
  13. stable one I think.                                                             
  14.                                                                                 
  15.                                                                                 
  16. Some PowerVisor features :                                                      
  17.                                                                                 
  18. - Compatible with all Amiga models and all Motorola processors that             
  19.   you can put in your Amiga (68000,68010,68020,68030,68881,68882,               
  20.   68851). (The disassembler also supports the 68040).                           
  21. - Full screen debugger or commandline type debugger all in one.                 
  22.   This new version even has a primitive source level debugger
  23.   (for C and assembler).
  24. - Very configurable, you can redefine the keys (for example to                  
  25.   emulate the monam2 keys).                                                     
  26.   You can attach almost any command to almost any key.                          
  27. - Two versions : one for AmigaDOS 1.2-1.3 and one for AmigaDOS 2.0.             
  28. - The following singlestep commands are supported :                             
  29.     - simple trace                                                              
  30.     - trace over BSR/JSR (works even in ROM)                                    
  31.     - trace until register changes (done in singlestepmode)                     
  32.     - trace until branch (stops tracing before branch really                    
  33.       executes) (done in singlestepmode).                                       
  34.     - trace until operating system call used (JSR (a6) or JMP (a6))             
  35.       (done in singlestepmode).                                                 
  36.     - trace until address (with automatic breakpoint).                          
  37.     - trace until condition becomes true (with a powerful expression            
  38.       evaluator, you could for example trace until register d0 is               
  39.       equal to d1 and d2 is equal to d3) (done in singlestep mode).             
  40. - The following breakpoints are supported :                                     
  41.     - break                                                                     
  42.     - break and remove breakpoint                                               
  43.     - break after <n> times                                                     
  44.     - break if condition is true                                                
  45.     - profile breakpoint (counter)                                              
  46. - The number of breakpoints is unlimited (only limited by memory).              
  47. - When you are tracing a program you can continue typing commands.              
  48.   You can even singlestep more commands at the same time (multitasking          
  49.   debugging).                                                                   
  50. - SYMBOL hunks are supported.                                                   
  51. - You can interactivelly add or remove symbols so you can more easily           
  52.   remember routines to jump to.                                                 
  53. - You can debug crashed tasks, you can load a task, you can simply              
  54.   take a task from the task list to debug it or you can wait until              
  55.   the next task is started.                                                     
  56. - ARexx port. You can write your scripts in ARexx.                              
  57.   This ARexx scripts are asynchronious (multitasking) so you                    
  58.   can run an ARexx script in one logical window and type commands               
  59.   in the other one.                                                             
  60. - Simple scripts can also be written in the internal script                     
  61.   language.                                                                     
  62. - You can list several system lists : tasks, locks, files, libraries,           
  63.   devices, resources, interrupts, resident modules, dos devices,                
  64.   fonts, message ports, semaphores, execbase, graphicsbase,                     
  65.   intuitionbase, windows, screens, input handlers, memory lists,                
  66.   autoconfig devices, ...                                                       
  67. - You can ask more information about each element of a list. For                
  68.   example you can dump the task structure of an element in the                  
  69.   task list.                                                                    
  70. - You can of course view memory and disassemble instructions.                   
  71. - There is a very powerful 'view' command. You can define                       
  72.   regions of memory to be of a certain type. The 'view' command                 
  73.   will then automatically adapts its output to the type of the                  
  74.   memory. The following types are supported : ascii, byte,                      
  75.   word, long, code (disassembly) and structures. With the last                  
  76.   type you can define a region of memory to be a structure. For                 
  77.   example: with one command you can define all tasks in the system              
  78.   as 'STRUCTURE Task'. When the 'view' command accidently hits                  
  79.   the memory of one task, the output will automatically reflect                 
  80.   this.                                                                         
  81.   You can define your own structures to use in PowerVisor.                      
  82. - You can interactivelly test and use libraries and devices.                    
  83.   PowerVisor understands fd-files so that you can use the library               
  84.   functions in this library as if you type them from C (more                    
  85.   or less). This is very useful when you want to see how a certain              
  86.   library function works.                                                       
  87. - PowerVisor traps crashes and gurus (most of them anyway).                     
  88. - PowerVisor traps stack overflows.                                             
  89. - PowerVisor has 7 different logical windows (these are not                     
  90.   Intuition windows) for output. One is for the fullscreen debugger,            
  91.   one is for the automatic refresh and two are for normal output.               
  92.   The other two are for PortPrint output (see later) and for ARexx              
  93.   output. The last one is for the source level debugger.
  94.   You can use a different font for any of the logical windows.                  
  95. - Powerful windowsystem. You can stack Intuitionwindows and                     
  96.   PowerVisor windows in any way you want.                                       
  97. - Integrated portprint facility (with library), all messages printed            
  98.   appear on the PowerVisor window.                                              
  99. - Support for interlace/non interlace.                                          
  100. - PowerVisor uses a 3D screen when started in AmigaDOS 2.0.                     
  101.   PowerVisor also uses overscan in AmigaDOS 2.0.                                
  102. - In AmigaDOS 2.0 the PowerVisor screen is a public screen.                     
  103.   You can make the screen of PowerVisor an autoscrolling                        
  104.   screen (like the 2.0 WorkBench).                                              
  105. - You can put the PowerVisor window on each screen available in                 
  106.   the system. This is of course dangerous but it can be useful                  
  107.   to debug some programs.                                                       
  108. - A logical window can be bigger than the visible size. This enables            
  109.   you to scroll this window to view the previous output.                        
  110. - A built-in snap facility.                                                     
  111. - A very powerful command parser and expression evaulator.                      
  112.   Some examples :                                                               
  113.     (5*4)<<2                 => 80                                              
  114.     *4                       => pointer to execbase                             
  115.     *4.b                     => byte at location 4                              
  116.     {a=5;v a*a}+1            => 26                                              
  117.     *(task:input.device+4)   => contents of task structure                      
  118.     if(a>=0,a,-a)            => abs(a)                                          
  119. - Online help.                                                                  
  120. - You can patch each library function in the system to see how                  
  121.   many times a function is used, by whom it is used, or what                    
  122.   parameters where given.                                                       
  123. - Scratch register kill is also supported starting with PV 1.13.
  124. - Commandline history.                                                          
  125. - 'Alias' command.                                                              
  126. - MMU commands, you can disassemble the mmu tree, you can reset                 
  127.   all U and M (used and modify) bits, you can display all 68020                 
  128.   68030 and the mmu registers. (several bugs have been solved here)
  129. - 'kill' and 'freeze' commands to kill and freeze tasks.                        
  130. - You can remove a lot of things : tasks, input handlers, windows,              
  131.   screens, resident modules, ...                                                
  132. - You can read or write blocks using the trackdisk.device.                      
  133. - Variables allow you to remember values for later. Very useful                 
  134.   when debugging.                                                               
  135. - Except for the lists and the extra information for each element               
  136.   in the list, you can ask other information as well :                          
  137.     - all gadgets in a window (gadget structure is dumped)                      
  138.     - hunks for a process                                                       
  139. - Redirection of output to a file (log file).                                   
  140. - There are also commands to search, fill and copy memory.                      
  141. - You can also install a usage counter for each tasks, so that                  
  142.   you can determine how active a certain task is.                               
  143. - You can determine maximum stack checking for a task or process
  144. - Uses menus in AmigaDOS 2.0
  145. - Uses reqtools.library for requesters if available (reqtools is
  146.   made by Nico Francois)
  147. - New feature for PV 1.13: primitive resource tracking for AllocMem,
  148.   AllocVec and OpenLibrary
  149.                                                                                 
  150.           Jorrit Tyberghein                                                     
  151.