Accelerator Manual Abstract This manual describes how to use the Accelerator to optimize TNS object code for Hewlett-Packard TNS/R systems. The Accelerator processes files for the HP NonStop™ Open System Services (OSS) and Guardian environments. Product Version N/A Supported Releases This publication supports D30.00 and all subsequent D-series RVUs, G01.00 and all subsequent G-series RVUs, and H06.03and all subsequent H-series RVUs until otherwise indicated by its replacement publication.
Document History Part Number Product Version Published 108428 N/A December 1994 527303-001 N/A May 2005 527303-002 N/A July 2005
Accelerator Manual Glossary Index What’s New in This Manual v Manual Information v New and Changed Information Figures Tables vi About This Manual vii Preface vii Audience vii How to Use This Manual vii Organization viii Additional Information ix System Dependencies xi Notation Conventions xi Abbreviations xvi 1. Introduction How the Accelerator Works 1-1 When to Use the Accelerator 1-3 Accelerator Resource Requirements Cross-Platform Acceleration 1-5 1-4 2.
3. Preparing Your Program for the Accelerator Contents Odd-Byte References 2-10 Shift Instructions With Dynamic Shift Counts 2-12 Data Alignment in TNS and Accelerated Code 2-13 Misalignment Tracing Facility 2-14 Misalignment Handling 2-15 3.
6. Accelerator Performance Issues Contents Inheritance of Condition Codes 5-3 Safe Aliasing Rules 5-6 Truncation in Address Calculations 5-6 6.
A. Data Type Correspondence and Return Value Sizes Contents Options 10-2 A. Data Type Correspondence and Return Value Sizes Glossary Index Figures Figure 1-1. Figure 1-2. Figure 1-3. Figure 1-4. Figure 3-1. Figure 4-1.
What’s New in This Manual Manual Information Accelerator Manual Abstract This manual describes how to use the Accelerator to optimize TNS object code for Hewlett-Packard TNS/R systems. The Accelerator processes files for the HP NonStop™ Open System Services (OSS) and Guardian environments. Product Version N/A Supported Releases This publication supports D30.00 and all subsequent D-series RVUs, G01.00 and all subsequent G-series RVUs, and H06.
New and Changed Information What’s New in This Manual New and Changed Information This edition of the Accelerator Manual includes these changes and additions: • • Cross-Platform Acceleration on page 1-5 introduces the concept of cross-platform acceleration using the Accelerator for TNS/R platforms and the Object Code Accelerator (OCA) for TNS/E platforms. The Accelerator Data Alignment Addendum is incorporated into Section 2, Preparing Your Program for TNS/R Systems.
About This Manual Preface The Accelerator enables you to increase the performance of programs that run on TNS/R systems. The Accelerator optimizes TNS programs to take advantage of the TNS/R architecture. The Accelerator processes a TNS object file to produce an accelerated object file. Most TNS object code that has been accelerated runs faster on TNS/R systems than TNS object code that has not been accelerated.
Organization About This Manual If you want to: Read the following sections: Run a TNS program on a TNS/R system Section 2, Preparing Your Program for TNS/R Systems Determine whether or not to accelerate a TNS program Section 1, Introduction Accelerate a TNS program Section 1, Introduction Section 2, Preparing Your Program for TNS/R Systems Section 3, Preparing Your Program for the Accelerator Section 4, Using the Accelerator Section 5, Setting Accelerator Options Increase the performance of an acc
Additional Information About This Manual Section 9, Error, Warning, and Note Messages, lists each of the error, warning, and note messages emitted by the Accelerator, with accompanying cause, effect, and recovery text. Section 10, Accelerator Command Summary, summarizes the Accelerator product syntax and options. Appendix A, Data Type Correspondence and Return Value Sizes, contains tables with the return value size generated by HP language compilers for each data type.
Additional Information About This Manual The manuals in Table ii, System Programming Manuals explain how to write programs for HP NonStop systems and how to convert programs from C-series systems to Dseries systems and D-series to G-series. Table ii.
System Dependencies About This Manual For a description of the hardware aspects of the TNS/R systems and the process oriented organization of the operating system, refer to the appropriate system description manual. For a detailed description of the RISC instruction set implemented on TNS/R systems, refer to MIPS RISC Architecture, by Gerry Kane and Joe Heinrich, Prentice Hall, New Jersey, 1992.
General Syntax Notation About This Manual This requirement is described under Backup DAM Volumes and Physical Disk Drives on page 3-2. General Syntax Notation This list summarizes the notation conventions for syntax presentation in this manual. UPPERCASE LETTERS. Uppercase letters indicate keywords and reserved words. Type these items exactly as shown. Items not enclosed in brackets are required. For example: MAXATTACH lowercase italic letters.
General Syntax Notation About This Manual ALLOWSU { ON | OFF } | Vertical Line. A vertical line separates alternatives in a horizontal list that is enclosed in brackets or braces. For example: INSPECT { OFF | ON | SAVEABEND } … Ellipsis. An ellipsis immediately following a pair of brackets or braces indicates that you can repeat the enclosed sequence of syntax items any number of times.
Notation for Messages About This Manual !i and !o. In procedure calls, the !i notation follows an input parameter (one that passes data to the called procedure); the !o notation follows an output parameter (one that returns data to the calling program). For example: CALL CHECKRESIZESEGMENT ( segment-id !i , error ) ; !o !i,o. In procedure calls, the !i,o notation follows an input/output parameter (one that both passes data to the called procedure and returns data to the calling program).
Notation for Management Programming Interfaces About This Manual [ ] Brackets. Brackets enclose items that are sometimes, but not always, displayed. For example: Event number = number [ Subject = first-subject-value ] A group of items enclosed in brackets is a list of all possible items that can be displayed, of which one or none might actually be displayed.
Change Bar Notation About This Manual lowercase letters. Words in lowercase letters are words that are part of the notation, including Data Definition Language (DDL) keywords. For example: token-type !r. The !r notation following a token or field name indicates that the token or field is required. For example: ZCOM-TKN-OBJNAME !o. token-type ZSPI-TYP-STRING. !r The !o notation following a token or field name indicates that the token or field is optional.
1 Introduction The Accelerator processes TNS object code to produce accelerated object code. On TNS/R systems, accelerated object code runs significantly faster than TNS object code. This section describes how the Accelerator works, how to determine which programs to accelerate, and the cost in time and space to accelerate your programs. How the Accelerator Works The Accelerator takes as input an executable TNS object file and produces as output an accelerated object file.
How the Accelerator Works Introduction Accelerator option settings, but these actions are worthwhile only in the case of performance-critical programs. Figure 1-2, User Program Execution Modes on TNS/R Systems, on page 1-2 shows two of the execution modes available to user programs on TNS/R systems: TNS mode and accelerated mode. • • TNS mode is the operational environment in which TNS instructions execute. On TNS/R systems, TNS instructions are implemented by millicode routines.
When to Use the Accelerator Introduction The Accelerator can process bound, executable object programs generated by B40 and later releases of the C, COBOL85, FORTRAN, Pascal, and TAL compilers. The Accelerator can process executable object programs that run in either the Guardian or Open System Services (OSS) environment. (You cannot accelerate object programs generated by the COBOL 74 compiler.
Accelerator Resource Requirements Introduction Accelerator Resource Requirements The Accelerator, like an optimizing compiler, is both CPU-intensive and memoryintensive. Try to run the Accelerator on a lightly loaded processor with more than 16MB of physical memory. The Accelerator uses large amounts of the extended segment heap area (about 135 KB per 1000 TNS instructions). Much of this virtual memory must remain in physical memory to avoid page faults that slow the Accelerator.
Cross-Platform Acceleration Introduction Figure 1-4. Comparing TNS and Accelerated Object Files Sizes With a Symbols Region TNS Object Code Binder Region Symbols Region Accelerated Object Code VST0103.vdd The inline code expansion factor measures the worst-case increase in main memory required for accelerated code; the typical increase is less. It is the number of bytes of RISC code divided by the number of bytes of TNS code.
Cross-Platform Acceleration Introduction accelerator Object Code Accelerator (OCA) is supported on G06.24 and later G-series RVUs, enabling you to accelerate TNS object files on the TNS/R platform for execution only on the TNS/E platform. (A file with an IPF region only runs in interpreted mode on the TNS/R platform).
2 Preparing Your Program for TNS/R Systems Most TNS programs written for the HP NonStop operating system run on TNS/R systems without modification. Variances between TNS and TNS/R systems, however, might require modification in some programs, particularly low-level TAL programs. In this section: • • • General Considerations on page 2-1, discusses hardware and software release issues that affect moving programs between any two different models of HP NonStop systems.
Preparing Your Program for TNS/R Systems Checking Segment Limits Detection Guideline • Examine source code that explicitly disables overflow traps to make sure it tests for arithmetic overflow with the $OVERFLOW function. Also look for user-written trap handlers that return after an overflow. It is good coding practice always to test for overflow, not just after multiplication and division operations.
Extended Segment Size Preparing Your Program for TNS/R Systems Page Addresses (%H) 1 00080000 - 00080FFF 2 00081000 - 00081FFF 3 00082000 - 00082FFF 00083000 - 000837FF 4 x 00083800 - 00083FFF VST0201.vdd Required Change • If your programs reference data beyond a segment’s logical limit, eliminate these references. Extended Segment Size The operating system defines the maximum size of an extended segment to be 127.5 MB (%0776000000D) on both TNS and TNS/R systems.
Preparing Your Program for TNS/R Systems Supported Operating System Release Supported Operating System Release TNS/R systems support C30.06 and later releases of the operating system. If a program that ran correctly on a TNS system prior to the C30 release runs incorrectly on a TNS/R system, verify that changes made in the C30 operating system release do not produce the incorrect behavior before checking TNS/R system-specific variances.
Preparing Your Program for TNS/R Systems • • • • • Trap Handlers That Use the Program Counter Clear overflow and resume Resume after a loop timer Put values into global variables Jump to a restart point by changing the trap variables P, L, ENV, space ID, and S Save the register stack with the usual code statement of: CODE (PUSH %777); ! Save register stack contents However, the contents of the register stack are imprecise at the moment of a trap for programs executing on TNS/R systems.
Preparing Your Program for TNS/R Systems Reserved Instructions specifies an entry point into the application program where execution is to begin if a trap occurs. You do not need to change ARMTRAP procedures with parameters of (-1,-1). These parameters cause programs to abend on traps. Trap handlers are usually small enough in both size and number to check visually. Required Change • Change your programs to comply with the preceding restrictions.
Preparing Your Program for TNS/R Systems Nonprivileged References to System Global Data Detection Guidelines • • Look for statements that pass a 32-bit extended address of a P-relative object to other routines. Run your program on a TNS system. If the program runs correctly, your code is correct. Required Change • Recode statements that pass a 32-bit extended address of a P-relative object to other routines.
Segment Wrapping Preparing Your Program for TNS/R Systems Example The following TAL procedure tries to use the system value at address SG[0], but on a TNS system, the procedure uses whatever is at address G[0] in the user data segment. For more information on how to access the system data segment, refer to the section on “Privileged Procedures” in the TAL Reference Manual. INT cpuno = 'SG' + 0; INT .
Segment Wrapping Preparing Your Program for TNS/R Systems Examples The following examples show addressing operations that might not wrap back on the segment on TNS/R systems as they do on TNS systems. STRUCT s(*); BEGIN INT i; INT(32) d; INT j; END; PROC exam; BEGIN INT .p (s); STRUCT s2(s); @p := -1; ! -1 = 65535 (unsigned), structure starts at ! the last word of the user data segment and ! goes past the end s2 ':=' p FOR $LEN(s2) BYTES; p.d := %h12345678%d; p.
Preparing Your Program for TNS/R Systems Odd-Byte References Odd-Byte References When a language compiler applies a TNS word instruction to an operand with an oddbyte address, run-time results are unpredictable.
Odd-Byte References Preparing Your Program for TNS/R Systems their least significant bit set. If your program was written following good TAL programming practices, odd-byte references are not a concern. In TAL, data types stored as doublewords or quadruplewords include INT(32), FIXED(n), REAL, REAL(64), and INT(64). In C, data types stored as doublewords or quadruplewords include long, unsigned long, long long, float, and double.
Preparing Your Program for TNS/R Systems Shift Instructions With Dynamic Shift Counts pointer P contains a byte address. When P is set to -1, the structure starts on an odd-byte boundary; therefore, the program might trap or it might continue executing. STRUCT s(*); BEGIN INT i; INT(32) d; INT j; END; PROC test; BEGIN INT .EXT p(s); @p:= -1d; p.
Data Alignment in TNS and Accelerated Code Preparing Your Program for TNS/R Systems Detection Guidelines • • Use a text editor to search for ALS 0, LLS 0, ARS 0, and LRS 0 in TAL CODE statements. Make sure that the operands for these instructions do not use shift counts greater than 31. Use a text editor to search for the TAL bit-shift operators: unsigned left and right shift ('<<' and '>>') and signed left and right shift (<< and >>).
Misalignment Tracing Facility Preparing Your Program for TNS/R Systems The behavior of TNS programs with misaligned addresses on TNS/R processors is almost impossible to predict. If you are not sure that your program has only aligned addresses, you can use the tracing facility to detect whether programs are using misaligned pointers, and if so, where. You should then change the programs to avoid misalignment.
Preparing Your Program for TNS/R Systems Misalignment Handling Because a process can run for a long time, the tracing facility samples the process (that is, checks its exception data) periodically (approximately once an hour). If the process recorded an exception since the previous sample, the tracing facility records an entry in the EMS log. If the process ends, and any exception has occurred since the last sample, the operating system produces a final Event Management Service (EMS) event.
Preparing Your Program for TNS/R Systems Misalignment Handling Table 2-1. TNS Misalignment Handling Methods Method Description ROUND (default)* After rounding down a misaligned address, the system proceeds to access the address, as in G06.16 and earlier RVUs. FAIL Instead of rounding down a misaligned address and proceeding to access the target, the operating system considers the instruction to have failed. For a Guardian process, this failure generates an Instruction Failure trap (trap #1).
3 Preparing Your Program for the Accelerator Most TNS programs written since the C30 versions of the operating system can be accelerated without modification. Variances between TNS and TNS/R systems that affect accelerated code only might require modification in some programs, particularly low-level TAL programs. In this section: • • General Considerations on page 3-1, discusses software development issues that significantly affect the performance of accelerated code.
Preparing Your Program for the Accelerator Binder and Inspect Symbols Regions that assumes that the function returns an INT value. In most cases, the Accelerator can process object files compiled without C/C++ function prototypes, but the resulting accelerated object code is often inefficient and makes numerous transitions into executing TNS code. Use C/C++ function prototypes for all of your C/C++ routines, if possible.
Preparing Your Program for the Accelerator Passing Parameters in Registers The condition codes N, Z, and K are undefined for traps that occur when executing accelerated object code. Do not write trap handlers that: • • Base their decisions on these register values Resume to points that expect these register values to be valid Refer to the Trap Handlers That Use the Register Stack on page 2-4 for guidelines on writing trap handlers.
Preparing Your Program for the Accelerator • • • Passing Parameters in Registers The calling procedure employs a use register and does not drop it before the call. TAL USE and DROP statements are often used to optimize repetitive references to localized expressions or iteration variables The procedure is not written in TAL (see Note below for C programs) The procedure calls the Debug process Note. The library function CLIB^EXTFNAME^TO^INTFNAME contains an uninitialized register variable in C30.
Passing Parameters in Registers Preparing Your Program for the Accelerator fragment ending a procedure leaves a value on the register stack, although RP implies that no value is returned. PROC Q; ! Lots of code CODE (LOAD L+3); CODE (STRP 7); CODE (EXIT); ! Loads value on stack from data segment ! Set RP=7, imply no value returned When the PCAL instruction in the following fragment calls procedure Q, it uses the value left on the register stack.
Arithmetic Left-Shift Sign Bit Preparing Your Program for the Accelerator Figure 3-1. Passing Parameters in Registers Inherits Registers Procedure Alpha passes a value in register 7 to procedure Beta. Procedure Beta assumes that it inherits one register. The Accelerator emits Warning 34 for procedure Beta. Specify "InheritsR7 Beta" to get a correctly accelerated program.
Preparing Your Program for the Accelerator Non-Standard Procedure Call or Return RP Values those of TNS object code, but only if an overflow occurs. It is unlikely that programs knowingly use left-shift operations that overflow. Detection Guideline • Look for arithmetic left-shift operations that overflow. Required Change • Remove arithmetic left-shift operations that overflow from your programs. Example In TNS object code, the value of I is 0, while in accelerated object code, I= %100000.
Preparing Your Program for the Accelerator • Non-Standard Procedure Call or Return RP Values The Accelerator issues Error 70: Error 70: The following procedure has two exit points that leave different size values on the register stack: Procedure '' returns words at offset and returns words at offset . The Accelerator cannot optimize this code because it cannot determine what size value to expect at each call site.
Non-Standard Procedure Call or Return RP Values Preparing Your Program for the Accelerator option for functions where the number of words returned is dependent upon run-time logic. Examples • The declared size of a function (procedure or subprocedure) return result value in the Binder region must match the actual return size or the Accelerator generates incorrect code. The following TAL procedure returns three words implicitly and two words explicitly.
Preparing Your Program for the Accelerator Non-Standard Procedure Call or Return RP Values The Accelerator option ReturnValSize must be used for this procedure to return the three values correctly: ReturnValSize FOO 3 The Accelerator also issues Warning 32 for the following program fragment: FOR i := 0 TO 4 DO STACK( i ); ?RP = 4 PROC Start; BEGIN INT i; FOR i:=0 TO 4 DO BEGIN STACK i; ?RP 7 END; ! other code ?RP = 4 END; • This example loads five values on the stack, and sets the correct current RP set
Preparing Your Program for the Accelerator Non-Standard Procedure Call or Return RP Values The Accelerator issues the following warning when you accelerate the preceding procedure: Warning 32: The return value sizes derived for the following procedures conflict with those given in the Binder region: 'main'; 7 derived by the Accelerator; 1 given in the Binder region 'f'; 2 derived by the Accelerator; 0 given in the Binder region Acceleration is based on the Binder region; you can override that value with a
Preparing Your Program for the Accelerator Relationship Between Global and Local Data Blocks The Accelerator issues the following warning when you accelerate the preceding example: Warning 32: The return value sizes derived for the following procedures conflict with those given in the Binder region: 'Foo'; 2 derived by the Accelerator; 3 given in the Binder region Acceleration is based on the Binder region; you can override that value with a ReturnValSize option.
Preparing Your Program for the Accelerator Procedure Name Conflicts Procedure Name Conflicts A program can call several procedures of the same name, as long as each of the procedures resides in a different code space. For example, a program can call a system library procedure named File_Close_ and a user library procedure named File_Close_. Each of these procedures can have a different return value size. The Accelerator must determine the return value size for all procedures called by a program.
Preparing Your Program for the Accelerator Procedure Name Conflicts Example • In this example, the procedure File_Close_ in the user library returns four words and the procedure File_Close_ in the system library returns two words.
4 Using the Accelerator The Accelerator program processes TNS object code programs and produces accelerated object code programs. You can run the Accelerator from either the Guardian or Open System Services (OSS) environment. This section describes: • • • • • • • • • • Running the Accelerator on page 4-1 describes how to run the Accelerator from the Guardian and OSS environments. Accelerator Listings on page 4-4 describes Accelerator listings.
AXCEL Command Usage Examples Using the Accelerator run-options is one or more standard run-time options, as described in the TACL Reference Manual.
OSS Environment Using the Accelerator • The Accelerator accelerates the object file test1, generates an accelerated object file named test2, and writes its listing to the file mylist: AXCEL /OUT mylist/ test1, test2 • The Accelerator performs the steps in the previous example, and the Accelerator UserLib option is specified: AXCEL /OUT mylist/ test1, test2; UserLib $VOL.SUBVOL.
Accelerator Listings Using the Accelerator The following examples show how these c89 flags are used: • c89 compiles the source file test1.c, generates symbolic information (the Symbols region), and binds it into a program file named a.out: c89 -g test1.c • c89 binds the object file test1.o into a program file named a.out and then accelerates it into an accelerated file named a.out: c89 -O test1.o • c89 compiles, binds, and accelerates the source test2.
Online Help Using the Accelerator 0 Errors were detected 0 Warnings were issued Accelerated File Name: $GOLD.MYFILES.AOBJ CPU Time 0:00:03.331 Elapsed Time 0:00:13 Extended segment size = 779634 bytes. Online Help The Accelerator online help facility displays information about Accelerator options, messages, features, and concepts. Help text is organized in a hierarchical fashion; general topics at the top level, with more specific subtopics at each lower level.
Online Help Using the Accelerator Figure 4-1. Accelerator Online Help Example >AXCEL ACCELERATOR - T9276D30 - 31OCT94 - (Jul 16 1994 14:11:29) Copyright HP Computers, Incorporated, 1988 - 2004 AXCEL The Accelerator processes TNS object files to produce accelerated object files for TNS/R systems. Help is available on all Accelerator options and messages and various topics related to the Accelerator. Enter the name of one of the topics listed below at a help prompt to display help on that topic.
A Strategy for Using the Accelerator Using the Accelerator Figure 4-1. Accelerator Online Help Example Additional help is available on these topics: Accelerator Linkable Obey SC Super-Options Userlib Elementary-Options Note Procdebug Scoping-Directives Suppressmsg Warning Error Notes Returnsr SL UC Inheritsr Notlinkable Returnvalsize Stmtdebug UL Topic? Super-Options For ease of use, the Accelerator elementary option settings have been packaged into three sets called the Accelerator super options.
Specifying the Code Space Using the Accelerator 3. Debug the TNS version of your complete program. 4. Run the Accelerator. If the Accelerator issues an error message, it will not produce an output file. Correct the error and run the Accelerator again. 5. Examine the Accelerator listing. If there are any warning messages, investigate each warning, and fix if necessary. The Accelerator issues warning messages to call your attention to possible problems.
Specifying the Debugging Mode Using the Accelerator user code. Note that user library code not identified as such to the Accelerator cannot be used as a user library or a shared run-time library at execution time. Accelerating User Libraries and Shared Run-Time Libraries To accelerate a user library or a shared run-time library, accelerate the TNS object file as user library code by specifying the UL option.
Specifying Accelerated Libraries Using the Accelerator You can direct the Accelerator to optimize only within each code sequence resulting from a source language statement; it does not optimize across two or more source statements within a procedure. Although this code is not as highly optimized, you can trace the RISC code to the corresponding TNS code more easily because statement boundaries are preserved.
Accelerating Programs With Embedded SQL Using the Accelerator If you change the interface to any non-extensible routines in a library, both the library and the user code programs that call it must reaccelerate. If you only change the routine internals, only the library must reaccelerate. This is analogous to the recompilation that you must perform when the interface between your source program and its library changes.
Comments Using the Accelerator In the Guardian environment, you specify an obey file as a run-option within the slashes that optionally follow the keyword AXCEL, as in this example: AXCEL /in fred/ input-file, output-file or in the AXCEL-options part of the command, following the semicolon: AXCEL input-file, output-file; obey fred In the OSS environment, you specify an obey file in the -WAXCEL flag to the c89 utility.
Scoping Directives Using the Accelerator The three scoping directives and the code space to which they apply are: ?UC_Scope ?UL_Scope ?SC_Scope Applies to user code Applies to user library Applies to system code and system library Scoping directives do not affect all options. Table 4-1 lists whether or not a scope can be defined for a particular option: Table 4-1.
Controlling Accelerator Messages Using the Accelerator One use of scoping directives is to distinguish between procedures in different code spaces that have the same name.
Turning Notes On Using the Accelerator code constructs that might cause the program to make a transition into TNS code and thus impact the performance of the program. The Accelerator issues error messages and warning messages by default; you must direct it to issue note messages. You can also direct the Accelerator to suppress issuing specific warning and note messages. Turning Notes On The Accelerator issues note messages only if you explicitly request them by using the Notes option.
5 Setting Accelerator Options This section describes the Accelerator elementary and super options. Accelerator elementary options determine whether or not the Accelerator generates code to account for specific program variances or constructs. For programs or procedures that contain one of these variances or constructs, you must set to “on” the appropriate elementary option to produce an accelerated program that runs correctly.
Atomicity of Instructions Setting Accelerator Options The Table 5-1, Accelerator Super Options, on page 5-2 shows the settings of the elementary options for each super option. Table 5-1. Accelerator Super Options Atomic InheritsCC OvTrap SafeAliasingRules TruncateIndexing Common OFF OFF ON ON ON Fast OFF OFF OFF OFF OFF Safe ON ON ON ON ON You can set super options for an entire program only. You can set elementary options for an entire program or for individual procedures.
Inheritance of Condition Codes Setting Accelerator Options You only need to be concerned about setting the Atomic_On option if your program contains TAL procedures.
Inheritance of Condition Codes Setting Accelerator Options The Accelerator issues Warning 33 when it detects a procedure that it suspects of inheriting condition codes. The Accelerator can detect most, but not all procedures that inherit condition codes.
Inheritance of Condition Codes Setting Accelerator Options Overflow Checking Arithmetic overflows are different between TNS and TNS/R systems. Many 16-bit arithmetic operations that overflow on the 16-bit TNS systems do not overflow on the 32-bit TNS/R systems. The Accelerator option default setting, OvTrap_On, generates additional code that checks 16-bit arithmetic for overflows that are not automatically detected by TNS/R systems.
Safe Aliasing Rules Setting Accelerator Options Super Option Settings The Common and Safe options set OvTrap_On, and the Fast option sets OvTrap_Off. Safe Aliasing Rules On TNS systems, C and TAL programs can make piecemeal modifications to pointers and array indexes by means of indirect addressing. For example, an indirect reference to an extended pointer can modify as little as one byte of that pointer.
Truncation in Address Calculations Setting Accelerator Options You cannot set TruncateIndexing_Off for: • • Pascal programs without an Inspect symbols region FORTRAN programs The Accelerator automatically sets TruncateIndexing_On when you accelerate a FORTRAN program. For all other programs, only set TruncateIndexing_Off if you are willing to test them exhaustively to make sure that they do not depend on 16-bit address truncation.
6 Accelerator Performance Issues Performance in Perspective The Accelerator can greatly increase the performance of your programs. For most programs, simply accelerating them with the Accelerator default options produces highperformance code. You only need to read this section if you have a performancecritical program that spends a significant percentage of processing time in user code. Most application programs spend a substantial percentage of their execution time in system code.
Minimizing Code Generation Accelerator Performance Issues • • Accelerate programs with the ProcDebug debugging option (the default) instead of the StmtDebug option. Accelerate a program’s user library. After you accelerate the user library, accelerate the program again, specifying the accelerated user library with the UserLib option. Refer to Accelerating User Libraries and Shared Run-Time Libraries on page 4-9 for details.
Minimizing Transitions Into TNS Code Accelerator Performance Issues “to make a transition into TNS code” when this occurs. To generate an accelerated program, the Accelerator statically predicts the flow of a program and the value of the register pointer (RP). Certain dynamic constructs in a program can interfere with the Accelerator’s predictions and cause transitions into TNS object code. Transitions do not affect the correctness of programs.
Minimizing Transitions Into TNS Code Accelerator Performance Issues Note. When a labeled statement immediately follows a procedure call, the labeled statement is not a registerexact point. Most transitions to TNS code do not noticeably affect program performance because the program usually does not stay in TNS code for a long time. Remove transitions from performance-critical programs only. Use the Measure system performance-analysis tool to determine how much time your program spends executing TNS code.
Accelerator Performance Issues Using ReturnValSize to Eliminate Transitions Using ReturnValSize to Eliminate Transitions The Accelerator must know the size of the return values from every procedure called by the program it is to accelerate, including internal and external procedure calls. The Accelerator attempts to find the return value size for procedure calls from: • • • The Binder region of the object file, for internal procedure calls.
External Procedure Calls Accelerator Performance Issues Procedure '' contains: subproc beginning at offset returns words at offset and words at offset Note 15: The Accelerator could not determine the return value size of the following subprocedures: Subprocs embedded in procedure '': Entry at offset ; Guessed return size , times When you specify the ReturnValSize option for a particular procedure, the Accelerator mig
Internal Procedure Calls Accelerator Performance Issues Detection Guideline • The Accelerator emits Note 1 for external procedures that might cause transitions into TNS code. Note 1: The Accelerator was not able to determine return value size of the following external procedures: ; Guessed return size , times; Suggested Changes • • If the program has an accelerated user library, specify it with the UserLib option.
Recoding to Eliminate Transitions Accelerator Performance Issues Recoding to Eliminate Transitions To eliminate these transitions into TNS code, you must recode your programs. These transitions occur because of program constructs for which the Accelerator cannot determine the value of the register pointer, RP, or the destination of a jump. Far Jumps Far jumps are jumps that modify the subroutine stack marker to return to a location other than the call.
Dynamic Procedure Calls Accelerator Performance Issues ! of the address reference @ErrorL above WHILE work DO ... • Programs dynamically computing the address of the targeted TNS instruction make a transition into TNS object code if the return point is not a register-exact point: my^marker := my^marker + magic; • The Accelerator finds a register-exact point following the call to the C library routine setjmp, so the longjmp routine jumps to that point.
Dynamic Procedure Calls Accelerator Performance Issues Detection Guidelines • The Accelerator issues the following note: Note 3: The Accelerator was not able to determine return value size of the following dynamic procedure calls in your program: Call at offset
in proc ; guessed return size Suggested Changes • For DPCLs in TAL programs, you have three options: • • • • If the TAL compiler processed a call to formal procedure parameters with a DPCL instruction, recompile withDynamic Procedure Calls Accelerator Performance Issues Examples • The dynamic procedure calls in C: void callbell (void (*bell) (void)) { (*bell) (); } void callfun (int (*fun) (int val)) { int result; result = (*fun) (4); ... } • The dynamic procedure calls in TAL: PROC callbell (bell); PROC bell; BEGIN CALL bell; END; PROC callfun (fun); INT PROC fun; BEGIN INT result; result := fun (4); ...
SETP State Machines Accelerator Performance Issues The following procedure causes a transition into TNS code because it delays storing the function’s return result value: INT PROC driver; BEGIN STACK Table_drive; CODE (DPCL); ?RP = 0 ... RETURN; END; ! Table_drive returns an INT value ! Transition into TNS object code ! Do some work ! The result from DPCL Table_Drive The procedure Driver returns a value left untouched in the register stack from the dynamically called procedure.
SETP State Machines Accelerator Performance Issues While SETP instructions do not necessarily force a transition into TNS code, the table lookup makes SETP slower than other types of branching. Do not use a SETP instruction as a performance substitute for a CASE statement. Detection Guidelines • The Accelerator issues Note 6 for each SETP instruction. Unless your program is written in TAL, you probably will not gain much performance if you recode to eliminate these SETP instructions.
SETE Instructions Accelerator Performance Issues table and the next state. The SETP instruction transfers control to the dynamically fetched location. ?SYMBOLS CODE ( SETP ); RETURN; ! No static flow control is visible below ! this point without the symbols region ! The "action" routines action 1: ...; action 2: ...; action 3: ...
Minimizing Compatibility Traps Accelerator Performance Issues Detection Guideline • The Accelerator issues Note 7 for each SETE instruction it detects. Note 7: SETE instructions appear in the following procedure(s): '' at offset(s): Examine each SETE instruction to see if it changes the RP field of the ENV register. Suggested Changes • • Compiler-generated SETE instructions rarely cause transitions into TNS code.
Odd-Byte References Traps Accelerator Performance Issues The results of odd-byte references to doublewords and quadruplewords are unpredictable on TNS/R systems. Refer to Odd-Byte References on page 2-10 for details. Detection Guidelines • • Use the PROCESS/PROCESSH report produced by the Measure performance analysis tool to find the number of compatibility traps. Look for uninitialized pointers.
Relative Segments 2 and 3 Traps Accelerator Performance Issues The following variation works without generating a compatibility trap: DEFINE SETBITG(VECTOR,BIT) = BEGIN ! BIT = 0..N STACK %100000 '>>' BIT.<12:15>; STACK @VECTOR[ BIT '>>' 4 ]; ! OK CODE( ORX ); END#; Relative Segments 2 and 3 Traps Attempts to form a pointer to process-relative (P-relative) data in relative segments 2 or 3 causes a compatibility trap unless the reference is made using the TAL $XADR function.
Relative Segments 2 and 3 Traps Accelerator Performance Issues The $DBLL function is incorrect for TNS and TNS/R systems. On TNS systems, this statement works correctly for a P-relative array in user code, but cannot be used by a library procedure.
7 Debugging Accelerated Programs You can use either Debug, the machine-level debugger, or Inspect, the symbolic debugger, to debug accelerated programs. Source-level (symbolic) debugging of accelerated programs is very similar to TNS programs. However, machine-level debugging of accelerated programs is limited, and rarely necessary.
Register-Exact Points Debugging Accelerated Programs When executing TNS instructions on a TNS/R system, the TNS/R system maintains the TNS machine state (the register stack, S, P, E, and L registers) as if you were running your program on a TNS system. Because the TNS machine state is maintained, no change is required to run existing TNS programs on TNS/R systems and, with very few exceptions, debugging is the same.
ProcDebug Debugging Accelerated Programs statement boundaries and the ability to modify memory safely. TNS machine-level restrictions include the fact that breakpoints are restricted to memoryexact points and register modification is restricted to register-exact points. ProcDebug ProcDebug, the default optimization level, results in optimizations that might blur statement boundaries. Blurred statement boundaries result in some statements becoming inaccessible for debugging purposes.
A Strategy for Debugging Debugging Accelerated Programs • • • If the program runs incorrectly on a TNS system, the problem is in your program logic. If the program runs correctly on TNS systems and incorrectly on TNS/R systems, the problem is almost certainly a TNS/R variance in your program. In this case, examine your program for variances described in Section 2, Preparing Your Program for TNS/R Systems.
8 Future Guidelines The following list provides guidelines for writing programs for future software platforms. • • • • Do not use the contents, location, or size of the stack frame marker. The stack frame marker is machine-dependent. Do not use the contents of TNS machine-specific registers such as ENV, P, RP, L, and S. Do not depend upon results after an overflow being the same on all HP NonStop systems. Centralize TAL DEFINE macros that control overflow.
9 Error, Warning, and Note Messages The Accelerator issues an error message when it finds a code construct that it cannot accelerate, or when it cannot understand input options or input file format. The Accelerator does not produce an executable object file if it finds error conditions. You must resolve all error conditions to accelerate your program successfully. This section defines Accelerator errors, warnings, notes.
Note Messages Error, Warning, and Note Messages Effect. The accelerated program executes correctly. The Accelerator emitted a runtime check to assure that its guess was correct. If the Accelerator guessed the correct return value size for the external procedure call, then the program continues to execute the accelerated code after calls to the procedure. If the Accelerator guessed incorrectly, then the program makes a transition into executing TNS code after calls to the procedure.
Note Messages Error, Warning, and Note Messages 3 Note 3: The Accelerator was not able to determine return value size of the following dynamic procedure calls in your program: Call at offset
in proc ; guessed return size Cause. The Accelerator was not able to determine the size of the value returned by the given dynamic procedure calls. It guessed a return value size based on the context of the call, and emitted a run-time check to verify its guess. Effect.Note Messages Error, Warning, and Note Messages 3. The Accelerator interprets a data region to be a code path. Effect. The accelerated program executes correctly. The program makes a transition into TNS code for the portion of code in which the Accelerator is uncertain about the value of RP. Recovery. Check other notes about return value sizes, and any warnings that the value of the register pointer (RP) might have been misunderstood.
Note Messages Error, Warning, and Note Messages 8 Note 8: IDXP instructions appear in the following procedure(s): '' at offset(s): Cause. FORTRAN program uses the IDXP instruction in array references. The Accelerator cannot statically predict the number of dimensions in a dynamically allocated FORTRAN array. Effect. References to single dimensional arrays execute in accelerated code. References to multidimensional arrays make a transition into TNS code. They both execute correctly.
Note Messages Error, Warning, and Note Messages Effect. The program executes correctly. The program makes a transition into executing TNS code at the DLEN instruction. Recovery. None needed. 12 Note 12: Unknown instructions appear in the following procedure(s): '' () at offset(s): Cause. The Accelerator processed a TAL program containing unknown opcodes.
Note Messages Error, Warning, and Note Messages Effect. The Accelerator probably had to guess the return value sizes based on the context at the subprocedure call sites. Note 15 shows the sizes that the Accelerator guessed. The accelerated program executes correctly since a run-time check verifies the guess. If the guess is correct, then the program continues to execute accelerated code upon return from the subprocedure call.
Note Messages Error, Warning, and Note Messages Cause. The Accelerator cannot statically determine the return address because of address map conflicts. The following code constructs can generate register-exact point conflicts: 1. A procedure call immediately followed by a user-defined label or dynamic control transfer (a SETP instruction) 2. A procedure call immediately followed by a secondary entry point to the current procedure or subprocedure 3.
Warning Messages Error, Warning, and Note Messages Warning Messages The Accelerator issues a warning when it finds a code construct for which it might have produced incorrect code. The Accelerator cannot automatically distinguish between a benign situation and a dangerous situation, so you must check the code manually as recommended by the specific messages. An Accelerator session that produces warnings also produces an executable file.
Warning Messages Error, Warning, and Note Messages Recovery. Check the size given in the ReturnValSize option against the source code. If the option is incorrect, then correct it and accelerate the program again. 31 Warning 31: The ReturnValSize options given for the following procedures conflict with the derived estimates: ; given as an option; derived by the Accelerator The Accelerator's translation is based on the option. Cause.
Warning Messages Error, Warning, and Note Messages 4. A C program uses the ldiv C run-time library function and was compiled with a version of the HP C compiler released before 15JUN91. These compiler versions incorrectly marked the ldiv function as having a return value size of four words. 5. A C function was compiled without the appropriate C function prototypes for the routines it calls. Effect. Values from the Binder region override the values derived by the Accelerator.
Warning Messages Error, Warning, and Note Messages Effect. If the named procedure references the condition codes before performing some work that would reset them, then the accelerated code is incorrect. The Accelerator did not propagate the value stored in the condition codes from the calling procedure to the named procedure. Recovery. Ignore this warning for non-TAL procedures.
Warning Messages Error, Warning, and Note Messages In the case of the C library problem described previously, the accelerated code might cause a run-time trap or invalidate user variables. Recovery. For TAL programs with procedures that in fact inherit registers, you have two options: 1. Modify the source code to eliminate the implicit parameter passing through the register. 2. Accelerate the program again, supplying a InheritsRn or ReturnsRn option.
Warning Messages Error, Warning, and Note Messages 38 Warning 38: The following SETE instructions set the T bit while OvTrap_Off was selected: '' at offset(s): Cause. The named procedure contains a SETE instruction that sets the T-bit in a procedure for which the OvTrap_Off option was specified. Effect. You probably do not want to use the OvTrap_Off option for this procedure since the code explicitly turns overflow trapping on.
Error Messages Error, Warning, and Note Messages Error Messages The Accelerator issues an error when it finds a code construct that it cannot accelerate, or when it cannot understand input options or input file format. The original TNS object file remains unchanged. Error messages are numbered 50 through 86. 50 Error 50: Return value size for procedure in the input file was given as and in ReturnValSize options.
Error Messages Error, Warning, and Note Messages 2. The input, user library, or obey file exists. 3. The input, user library, or obey file security is set correctly. 53 Error 53: and were set -- you may only select one. Cause. More than one code space option (UC, UL, SC, SL) was specified for the object file to be accelerated. Effect. The Accelerator cannot determine in which space the program resides. Recovery.
Error Messages Error, Warning, and Note Messages 56 Error 56: Command line options must be separated by a comma. Error 56: Obey file options occupying the same line must be separated by a comma: see obey file . Cause. The Accelerator did not find a comma following an option. Effect. The Accelerator cannot interpret the options correctly. Recovery. Check your command line or the named obey file. Add a comma after each option on the command line.
Error Messages Error, Warning, and Note Messages 59 Error 59: Option
Error Messages Error, Warning, and Note Messages Recovery. Check your command line or the named obey file. Make sure you did not separate arguments to an option with commas. You can supply more than one procedure name argument to an option by separating the names with a space: InheritsCC_On TERMCTL LISTVAL, OvTrap_Off ORDER 63 Error 63: No Input file name was provided. Cause. No input file name was provided. Effect. The Accelerator cannot determine which object file to accelerate. Recovery.
Error Messages Error, Warning, and Note Messages 67 Error 67: Input file contains no procedures. Cause. The input file contains no procedures. Effect. There is no code in the specified object file for the Accelerator to accelerate. Recovery. Provide a file that contains procedures. 68 Error 68: User library file has not been accelerated. Cause. The Accelerator was given a user library named in the UserLib option that has not been accelerated. Effect.
Error Messages Error, Warning, and Note Messages • Were compiled without a C function prototype for the routine the function calls Effect. The Accelerator assumes that each procedure returns only one size value. The Accelerator cannot determine the correct return value size at each call site. Recovery. If the named procedure returns only one size value, specify that value with a ReturnValSize option. If the named procedure returns more than one size value, specify a ReturnValSize UNKNOWN option.
Error Messages Error, Warning, and Note Messages 75 Error 75: You cannot mix options and directives on the same obey file line. See obey file . Cause. Scoping directives share a line with options in the obey file. The scoping directives are ?UC_Scope, ?UL_Scope, ?SC_Scope. Effect. The Accelerator cannot understand the options and directives listed on the same line in the obey file. Recovery. Move the scoping directives to occupy lines without options.
Error Messages Error, Warning, and Note Messages Effect. The Accelerator does not generate an accelerated object file. Recovery. Compile the source file for the input object file with a supported compiler. 82 Error 82: file is neither type-101 nor type-180. Cause. The obey filename provided to the IN parameter must be type 101 or 180 text files. Effect. The Accelerator cannot accept a file that is not type 101 or 180 as an input obey file. Recovery.
Error Messages Error, Warning, and Note Messages 86 Error 86: Out of swap space, acceleration cannot proceed. Cause. The Accelerator cannot accelerate the file because there is not enough room on the disk for the swap file. Effect. The Accelerator does not produce an accelerated object file. Recovery. You have three options to resolve this error: 1. Clear space on the volume that contains the Accelerator. INSTALL places the Accelerator (AXCEL) program on $SYSTEM by default. 2.
Error Messages Error, Warning, and Note Messages 1. The file name is spelled correctly. 2. The input, user library, or obey file exits. 3. The input, user library, or object file is properly secured.
10 Accelerator Command Summary Syntax AXCEL [/ run-options/] input-file, output-file [; AXCEL-options] run-options is one or more standard run-time options, as described in the TACL Reference Manual.
Options Accelerator Command Summary Refer to the c89(1) reference page or the Open System Services Shell and Utilities Reference Manual for details on running the Accelerator from the OSS environment. Options Table 10-1 lists all Accelerator options.
Options Accelerator Command Summary Table 10-1. Accelerator Options (page 2 of 2) Scope can be defined Options (bold=default) Purpose SafeAliasingRules_On [proc] SafeAliasingRules_Off [proc] Specifies whether or not the program or named procedure requires the Accelerator to generate code to account for piecemeal modifications to pointers by means of indirect addressing.
A Data Type Correspondence and Return Value Sizes The following tables contain the return value size generated by HP language compilers for each data type. Use this information when you need to specify values with the Accelerator ReturnValSize option. These tables are also useful if your programs use data from files created by programs in another language, or your programs pass parameters to programs written in callable languages.
Data Type Correspondence and Return Value Sizes Table A-1.
Data Type Correspondence and Return Value Sizes Table A-2. Integer Types, Part 2 64-Bit Integer Bit Integer of 1 to 31 Bits Decimal Integer BASIC INT(64) FIXED(0) -- -- C long long -- -- COBOL PICS9(n) COMP or PIC 9(n) COMP without P or V, 10≤n≤18 -- Numeric DISPLAY FORTRAN INTEGER*8 -- -- Pascal INT64 UNSIGNED(n), 1≤n≤16 INT(n) 1≤n≤16 DECIMAL SQL NUMERIC(10)...NUMERIC(18) PIC9(10)COMP...
Data Type Correspondence and Return Value Sizes Table A-4. Character Types Character Character String Varying Length Character String BASIC STRING STRING -- C signed char unsigned char pointer to char struct { int len; char val [n] }; COBOL Alphabetic Numeric DISPLAY Alphanumeric-Edited Alphanumeric Numeric-Edited Alphabetic Numeric DISPLAY Alphanumeric-Edited Alphanumeric Numeric-Edited 01 name. 03 len USAGE IS NATIVE-2 1 03 val PIC X(n).
Data Type Correspondence and Return Value Sizes Table A-6.
Glossary absolute pathname. A pathname that begins with a slash (/) character and is resolved beginning with the root directory. Contrast with “relative pathname.” accelerate. To use the Accelerator program to generate an accelerated object file. accelerated mode. The operational environment in which Accelerator-generated RISC instructions execute. accelerated object code. The RISC instructions that result from processing a TNS object file with the Accelerator. accelerated object file.
current working directory. Glossary instructions, and many special-purpose instructions. Contrast with “reduced instructionset computing (RISC).” current working directory. The directory from which relative pathnames are resolved. A process always has a current working directory. See “working directory.” D-series system. A system that is running a D-series version of the operating system. directory. A file that contains directory entries. No two directory entries in the same directory have the same name.
nonexact point. Glossary nonexact point. A location in an accelerated program that is not a memory-exact point. At nonexact points, the TNS program state cannot be mapped directly from TNS/R to TNS machine locations. NonStop Open System Services (OSS). An application program interface (API) to the HP NonStop operating system and associated tools and utilities. See “Open System Services” for a more complete definition. object file.
program file. Glossary program file. An executable object file. See “object file.” reduced instruction-set computing (RISC). A processor architecture based on a relatively small and simple instruction set, a large number of general-purpose registers, and an optimized instruction pipeline that supports high-performance instruction execution. Contrast with “complex instruction-set computing (CISC).” register-exact point.
TNS instructions. Glossary NonStop EXT, NonStop VLX, NonStop Cyclone, NonStop CLX 600, CLX 700, and CLX 800, and NonStop CLX/R 1100 systems. Contrast with “HP NonStop Series/RISC (TNS/R).” TNS instructions. Stack-oriented, 16-bit machine instructions defined as part of the TNS environment. On TNS systems, TNS instructions are implemented by microcode; on TNS/R systems, TNS instructions are implemented by millicode routines or by translation to an equivalent sequence of RISC instructions.
working directory. Glossary working directory. A directory, associated with a process, that is used in pathname resolution for pathnames that do not begin with a slash (/) character.
Index A Absolute addressing 8-1 Accelerated mode executing in 1-2 Accelerated object file size 1-4 Accelerating privileged code -xi progams with embedded SQL 4-11 strategy 4-7 system procedures 4-9 system processes 4-9 user libraries 6-2 Acceleration cross platform 1-5 Accelerator controlling messages 4-14 displaying of notes 6-3 function of 1-1, 6-2 introduction 1-1 invoking through c89 4-3 listings 4-4 messages 4-15 minimizing code generation 6-2 OCTDECS files 6-6 prediction logic 6-3, 6-7 procedures defi
B Index Accelerator options UserLib 4-10, 6-2, 6-5 Addition operations 2-1 Address calculations 5-6 Address misalignment causes of 2-13 handling 2-15/2-16 symptoms of 2-10 tracing facility for 2-14 Addresses of P-relative objects, passing 2-6 Addressing operations 2-8 Aliasing rules 5-6 ALLOCATESEGMENT system procedure 2-3 ALTER statements 6-13 Arithmetic operations 2-2 ARMTRAP 3-3 ARMTRAP system procedure 2-5, 3-3 Array indexes 5-6 Atomicity 5-2 Atomic_Off option 5-2, 6-2 Atomic_On option 5-3, 6-2 B Bin
E Index Data segment system global 2-7 user global 2-7 Debug 3-4, 7-1 Debugger 2-10 Debugging Accelerator options 7-2 differences between TNS and accelerated programs 7-1 memory-exact points 7-2 nonexact points 7-2 register-exact points 7-2 specifying the mode 4-9 strategy 7-3 synchronization points 7-1 TNS/R systems 7-1 Default misalignment handling method 2-16 Disk space 1-4 Division operations 2-1 Doublewords 2-10 Double-word shift instructions 2-12 DPCLs 6-9 DROP 3-3 DROP statements 3-3 Dynamic proced
L Index N Instruction set SETE 5-5, 6-14 SETP 6-12 STRP 6-10 Internal procedure calls 6-7 IOPs 5-5 I/O processes 5-5 L Linkable option 4-9 Listings, Accelerator 4-4 Local data block 3-12 Locating trap handlers 2-5 M Machine-level debugging 7-1 Measure 1-3, 6-1, 6-4, 6-16, 6-17 Memory requirements 1-4 Memory-exact points 7-2 Messages controlling 4-14 error 9-1, 9-15 note 9-1 suppression of 4-15 warning 9-1, 9-9 Microcode 6-2 Millicode 1-1, 6-2 Minimizing code generation 6-2 compatibility traps 6-15 tran
P Index OSS environment system dependencies -xi using obey files 4-11 using the Accelerator 4-3 Overflow checking 5-5, 6-2 recommended defines 8-1 results 2-1, 8-1 OvTrap_Off option 5-6, 6-2 OvTrap_On option 5-6, 6-2 P P register 2-5, 6-12, 8-1 Page size 2-2 Pascal dynamic procedure calls 6-9 Passing parameters in registers 3-3 Pathnames 4-3 Performance 6-1 aliasing rules 6-2 atomicity 6-2 coding far jumps 6-8 dynamic procedure calls 6-9 effect of ProcDebug option 7-3 inheritance of condition codes 6-2 m
S Index Register-exact points 6-3, 7-2 ProcDebug 7-3 StmtDebug 7-3 Relationship between global and local data blocks 3-12 Relative segments 2 and 3 6-17 Reserved instructions 2-6 RESIZESEGMENT system procedure 2-3 Results after an overflow 2-1 Return RP values 3-7 Return value sizes 3-7 conflicts with Binder region 6-6 external procedure calls 6-5, 6-6 internal procedure calls 6-5, 6-7 prediction logic 6-6 subprocedures 6-5 Returning parameters in registers 3-4 ReturnsR options 3-4 ReturnValSize option 3-
T Index Swap volume, specifying 4-2, 10-1 Symbols region 6-3 determining presence of 4-10 SETP instructions 6-12 Synchronization points 7-1 memory-exact 7-2 nonexact 7-2 register-exact 7-2 SYSGEN process 4-9 System data segment 2-7 data structures 8-1 dependencies -xi variables 8-1 System code 4-9, 5-5 System library 4-9, 5-5 System procedures accelerating 4-9 ALLOCATESEGMENT 2-3 ARMTRAP 2-5, 3-3 RESIZESEGMENT 2-3 SEG MENT_ALLOCATE_ 2-3 System processes, accelerating 4-9 T TAL bit operations 5-3 bit-shif
U Index address calculations 5-6 addresses of P-relative objects 2-6 arithmetic overflows 5-6 atomicity 5-2 code generation 5-1 ENV register 3-2 future 8-1 global and local data blocks 3-12 inheritance of condition codes 5-3 modifying array indexes 5-6 modifying pointers 5-6 odd-byte references 2-10 passing parameters in registers 3-3 privileged code 8-1 privileged instructions 2-6 procedure calls 3-7 procedure name conflicts 3-13 register stack 2-4 registers 3-4 SG pointers 2-7 shift instructions 2-12 st
Special Characters Index Special Characters $XADR function 6-17 -Waxcel flag 4-3, 4-11 -Wverbose flag 4-4 ?RP directive 3-9 Accelerator Manual—527303-002 Index -9
