Open System Services Porting Guide (G06.24+, H06.03+)
Table Of Contents
- What’s New in This Manual
- About This Manual
- 1 Introduction to Porting
- 2 The Development Environment
- 3 Useful Porting Tools
- 4 Interoperating Between User Environments
- Purpose of Interoperability
- The OSS User Environment
- OSS Commands for the Guardian User
- Guardian Commands for the UNIX User
- OSS Pathname and Guardian Filename Conversions
- Running the OSS Shell and Commands From TACL
- Running Guardian Commands From the OSS Shell
- Running OSS Processes With Guardian Attributes
- Using OSS Commands to Manage Guardian Objects
- 5 Interoperating Between Programming Environments
- 6 OSS Porting Considerations
- 7 Porting UNIX Applications to the OSS Environment
- 8 Migrating Guardian Applications to the OSS Environment
- General Migration Guidelines
- C Compiler Issues for Guardian Programs
- Using New and Extended Guardian Procedures
- Using OSS Functions in a Guardian Program
- Interoperating With OSS Programs
- Starting an OSS Program From the Guardian Environment
- C Compiler Considerations for OSS Programs
- Porting a Guardian Program to the OSS Environment
- How Arguments Are Passed to the C or C++ Program
- Differences in the Two Run-Time Environments
- Which Run-Time Routines Are Available
- Use of Common Run-Time Environment (CRE) Functions
- Replacing Guardian Procedure Calls With Equivalent OSS Functions
- Which IPC Mechanisms Can Be Used
- Interactions Between Guardian and OSS Functions
- 9 Porting From Specific UNIX Systems
- 10 Native Migration Overview
- 11 Porting or Migrating Sockets Applications
- 12 Porting Threaded Applications
- A Equivalent OSS and UNIX Commands for Guardian Users
- B Equivalent Guardian Commands for OSS and UNIX Users
- C Equivalent Inspect Debugging Commands for dbx Commands
- D Equivalent Native Inspect Debugging Commands for dbx Commands
- E Standard POSIX Threads Functions: Differences Between the Previous and Current Standards
- Glossary
- Index
The Development Environment
Open System Services Porting Guide—520573-006
2-19
Using the Debuggers With OSS Files
Refer to the Inspect Manual, Native Inspect Manual, or the Visual Inspect online help
for command details.
When an Inspect session begins, Inspect looks for an EDIT file named INSPLOCL in
the Guardian volume and subvolume containing the Inspect program file. The Inspect
program reads and executes Inspect commands contained in the INSPLOCL file. You
can also place Inspect commands in the Inspect custom file INSPCSTM in your default
logon directory. Commands in INSPCSTM are also executed when an Inspect session
begins. Commands in INSPCSTM override those in INSPLOCL because Inspect reads
INSPCSTM after reading INSPLOCL.
Native Inspect also provides a custom file in the default logon directory, named
EINSCSTM. This file can contain any Native Inspect commands you want to be
executed when the Native Inspect session begins.
All three debuggers let you set breakpoints at both code and data locations within your
program. You also can limit a breakpoint so that it suspends program execution only if
certain conditions exists.
Debugging Native Program Files
This subsection briefly introduces what is different about debugging native program
files. Refer to the Inspect Manual, the Native Inspect Manual, or the Visual Inspect
online help for the complete syntax of the debugger commands and detailed
explanations of the debugging features for native program files.
The Inspect, Native Inspect, and Visual Inspect debuggers create and read save files,
or snapshot files, from native processes. These files contain saved stack frames,
global data and heap areas, and the main stack. Inspect supports TNS/R native SRLs,
Native Inspect supports DLLs, and Visual Inspect supports both TNS/R native SRLs
and DLLs. This includes setting code and data breakpoints in SRLs or DLLs per
process, creating save files for applications that use SRLs or DLLs, and displaying and
modifying identifiers from SRLs or DLLs.
Debugging native processes differs from debugging TNS or accelerated processes.
Unlike TNS and accelerated processes, native processes do not maintain the TNS
process environment: for example, the TNS environment registers.
The optimization level option used with the native programs directly affects source-
level debugging. Source-level debugging could result in statements being merged and
a delay in updating memory from registers.
You can also use the noft or enoft utility to examine native program files. The noft
and enoft utilities can set and reset the Inspect flag in a native object file. See Using
the noft and enoft Utilities on Native Program Files on page 2-21 for more information
on debugging native program files.