Studies have shown that a full 50% of software development time is devoted to debugging, an inevitability no matter how well the software is designed. MULTI—with its range of sophisticated tools and utilities—offers the most powerful capabilities available for flushing out even the nastiest bugs. With the MULTI IDE’s unparalleled debugging features, you can get a higher quality, more reliable product to market in much less time.
Run-Time Error Checking: pinpoint bug locations
With MULTI’s Run-Time Error Checking utility, you can accurately and easily pinpoint the location in your source code of a variety of run-time errors, including:
- accessing an element beyond an array’s declared bounds
- assigning an out-of-range value to a variable or field of small integral type
- unhandled case in a switch statement
- dividing by zero
- accessing invalid memory through a pointer
- memory leak detection
Error Checking can also uncover the true source of bugs usually manifested in secondary effects, such as a variable corrupted by use of an invalid address. In normal circumstances a bug like this can be extremely difficult to track down because it acts differently with each occurrence. Run-Time Error Checking stops the program right where the invalid address is used and reports that it has detected an invalid memory access.
| Minimal effect on code execution & speed |
|
MULTI Run-Time Error Checking onlyminimally effects code size and execution speed, so it is practical for debugging any program. You can also enable or disable Error Checking on a module-by-module basis to restrict it to specific sections of a program.
The Error Checking capability is a benefit of the tight integration between the MULTI IDE and Green Hills Compilers, which can also perform a number of compile-time checks such as MISRA C compliance.
With Run-Time Error Checking, problems that might otherwise take a week to resolve now take only minutes. Lineby-line code searches are eliminated and the reliability of your program is significantly improved.
|
|
| Cross-Reference Browser: track the lifespan of variables & procedures |
The Cross-Reference Browser enables you to track the role played by any specific variable or procedure throughout your program and quickly discover how it is being used (or misused). For any symbol, the Browser window can display a complete list of references that clearly differentiates definitions, declarations, assignments, and value references. References in the Debugger source pane are also highlighted to make their locations apparent. |
|
| Effortless code navigation |
At the heart of the MULTI IDE’s debugging capabilities, the Debugger window includes a number of intuitive features that help you effortlessly browse, examine, and search your source code. These include:
- clicking on selections in the Navigation Bar for quick access to files and procedures
- choosing a name from File or Procedure Locator menu to display the appropriate code in the Source Pane
- viewing the definition of a particular procedure or class by clicking on the symbol name anywhere it appears
Other time-saving features include forward and back buttons that navigate through files and procedures recently visited, similar to the way the back and forward buttons work in a Web browser.
The Debugger’s advanced search capabilities let you issue navigation commands with wildcard characters so that you can easily find procedures even when you cannot remember their exact names. You may also search your entire source base using regular expressions.
|
| Class Browser: understand class hierarchy |
|
The powerful Class Browser provides high-level visibility of program organization by displaying all class hierarchies. Using the Class Browser, you can readily understand the relationships between parent and child classes. Like other MULTI tools, the Class Browser is tightly linked to the source code. To view the details of any class’ declaration, you simply click on it in the Browser.
|
| The Class Browser displays information in two modes: tree view mode—ideal for showing simple hierarchies—and graph mode—better for representing hierarchies that include multiple inheritance. Both modes offer expandable and collapsible nodes so you can drill down into details as necessary. In tree view, classes, structures, and unions are color-coded to distinguish among types. |
|
| Green Hills Software processor probes |
|
|
|
Calls Browser: view program control flow
The Calls Browser gathers all of a program’s function calls in a hierarchical table that provides a graphical view of
program control flow to help you better understand your program.
 |
The Browser provides visual representations of both static and dynamic call hierarchies. Static graphs show all potential calls, while dynamic graphs use profiling information or trace data to display how a program actually ran. The Browser also displays static calls by file, so you can readily see interactions between code in different source files and better understand the relationships between functions.
In addition to call hierarchies, the Calls Browser can display a single function and show the functions it calls or the functions that call it. The Browser’s view can be expanded to include neighboring functions, the functions they call, etc.
For fast debugging, you can jump directly from the Calls Browser to a function in the Debugger or the Editor to easily modify it. The intuitive Browser window color-codes nodes by type so at-a-glance you can readily differentiate:
- recursive functions
- functions called via function pointers
- functions with debugging information
- functions without debugging information
Seamless debugging of multitasking and multiple processor systems
For projects with multiple threads of execution, multiple processors, multiple boards, or any combination of these, MULTI offers a coherent debugging environment for visualizing and debugging the system. For each process or processor, MULTI opens a separate debug window. In each window, you can single step, set breakpoints, and examine data the same way you would with any other application.
With multiple processor systems, the Debugger shows all programs running on your target, so you do not have to debug complex interactions one small piece at a time. Through separate windows on your desktop, you can watch the interaction as the application executes on different processors. The Debugger works seamlessly no matter if the processors are homogenous or heterogeneous.
In addition to seamless debugging, multiple processor support enables significant cost benefits. You can place multiple processors on the same board and use a single, low-pincount JTAG connection to view and control all of them simultaneously. By consolidating the overhead of multiple connectors into a single interface, you can significantly reduce costs on today’s crowded boards.
|
)
)
)
)
)
