If the INCLUDE Fortran 90 statement is used within a program, the code that was included appears in the listing file with a plus sign (+) immediately after the line number on each line of the file. INCLUDEd lines are numbered separately from the lines of the main file. An example of this (from an -lo=o listing) follows:

2 subroutine fr (w) 3 real w 4 INCLUDE 'b.f' 1 + a = 1.0 2 + w = w - a 5 return 6 end

10.2.4 Footnotes

Important details about the actions taken by KAP are given in the Footnotes listing. The Footnotes are numbered and printed at the bottom of each program unit under the Footnote List heading. References to the footnotes are displayed in the listing under the column headed Footnotes. An example of a footnote follows.

In the listing the following appears:

13 DD 1790 if (b(i).le.6) ib(j*i) = i+j

At the end of the listing under the heading, Footnotes, is the following:

13: data dependence Data dependence involving this line due to variable IB

In this example, 13 is the footnote number, DD, meaning data dependence, is the class of message issued by KAP, and the if statement on line 1790 is the reference for this footnote.

10.2.5 Syntax Error/Warning Messages

When KAP detects syntax errors, it simply copies the input program unit to the transformed code file with no attempt to optimize the code.

When a program has syntax errors, messages are presented in the source (-listoptions=o) listing, interspersed with the user's code. Regardless of whether an original listing is requested, stderr: notes syntax errors and warnings. To locate the error messages in the source listing, look for lines beginning with the symbols ###, for example:

Footnotes Actions DO Loops Line 1 SUBROUTINE Z(A, B, N) 2 REAL A(N,N), B(N,N) +--------3 DO 20 I=1,N !+-------4 DO 20 J=1,N !! 5 X = A(I,J) !! 6 Y = B(I,J) !!_______7 20 C(I,J) = X + Y ### line(7) ### error %KAP-E-DO_NON_EXE, DO loop ends on a non-executable statement. ### error %KAP-E-STMT_FUNCTION_O, Array not declared or statement function declared after executable statements. 8 PRINT *, X 9 RETURN 10 END

KAP also may intersperse syntax warning messages with the user's code, but optimization proceeds. Syntax warnings are for constructs that are not legal, but whose intent is clear.

10.2.6 Questions Generated by KAP

At times KAP needs additional information on which to base optimization decisions. In these cases KAP may ask a question to indicate what additional information is needed.

The following loop comes from an example for -listoptions=o:

1 2 q so +--------- 24 DO 135 I = 1,N 3 DD SO !_________ 25 135 D(IP(I)) = C(I) + 3 3: question %KAP-I-PERMUTATION_VEC, Is "IP" a permutation vector?

If you know IP is a permutation vector (or, at least, contains no duplicate values), this information can be passed to KAP with the following assertion:

!*$* assert permutation (ip) DO 135 I = 1,N 135 D(IP(I)) = C(I) + 3

This information may enable KAP to optimize the loop or the surrounding code. See Chapter 7 for information about KAP assertions.

10.2.7 Action Summary

Statements that are translated or modified by KAP are identified by abbreviations in the Action Summary listing field. The notations tell which class(es) of messages were issued for each line or statement. The following list explains each of these classes. KAP lists the abbreviated explanation of its actions at the bottom of the listing. For the DIR class, the class itself usually serves as the message; no detailed message follows. All other class abbreviations indicate a message follows in this class.

The abbreviations and meanings of these classes are as follows:

• DD (Data Dependence) --- This message indicates that a data dependence involving this statement prevented optimization.
• DIR (Directive) --- This class is used in conjunction with the footnotes, and concerns compiler directives. If you coded a compiler directive and that line does not have the DIR abbreviation in the listing, KAP did not recognize the directive. Check the setting of the -directives switch and the syntax of the directive.
• E (Syntax Error) --- These messages indicate syntax errors. These may refer to missing or extra characters, illegal keywords, or text placed in the wrong column. Optimization of such program units is inhibited; the Fortran 90 output file contains a copy of this program unit unmodified by KAP.
• EX (Extension) --- These messages show where a construct in the original program is not allowed in the language dialect KAP produces. In some cases an operation or type is allowed in the input language, but not in the output language.
• I (Inserted) --- These messages indicate a statement was added by KAP. In several of the scalar transformations, and in output generation, statements must be inserted into the transformed code.
• INF (Informational) --- These messages provide noncritical information to the user.
• INL (Inlined Subprogram) --- These messages mark lines where a subroutine or function was inlined or interprocedural analyzed. The text of the inlined routine, with appropriate substitutions, appears in the transformed code.
• LR (Loop Reordering) --- These messages inform you that a Fortran 90 statement has been modified in the process of interchanging loops. If during optimization KAP ascertains that an outer loop would be more efficient if innermost, and if it is legal to reorder the loops, KAP places the outer loop inside. In the process of doing this, KAP may have to change loop bounds (for triangular loops) or distribute loops or float IF assignments. Only the statements modified to do the exchange are marked where they occurred. Not all statements in the exchanged loops are marked.
• MIS (Miscellaneous) --- These messages inform you that some KAP diagnostic information has been lost. This does not mean the program has been transformed improperly, but that some messages generated in the process have been lost.
• NO (Program Too Large) --- These messages tell you that the program unit being processed is too large for KAP to optimize due to KAP data structure size limitations. KAP stops optimization and passes the original program unit to the transformed code file unchanged. You must split the program into smaller sections for KAP to process. This class of message rarely appears.
• OT (Output Translation) --- These messages indicate KAP changed the name of a modification to avoid a conflict with an intrinsic function name.
• OTF (Output Translation Fails) --- These messages mark statements that have constructs that exist in the input language but are not representable in the output language.
• OW (Option Error) --- The marked line appears to have a directive or assertion, but either KAP does not recognize it, or it has a syntax error.
• Q (Question) --- These messages inform you that KAP attempted to optimize a loop nest, but discovered a data dependence that it could not break at compilation time without further information. The information may be available to you and you can answer the question with an appropriate assertion.
• STD (Standardized) --- These messages mark where a program has been changed to a more standard form to improve the chance of finding optimizable code. The dusty-deck transformations KAP performs (for example, converting an IF/GOTO into a block IF) use this notation.
• TE (Translator Error) --- These messages inform you of an internal KAP error. A traceback is written to the listing file. The traceback and the code that caused it should be sent to your software vendor so a correction can be made. If the error can be reproduced in a small program unit, that small program unit will be easier to work from and may speed isolating the problem.
• W (Warning) --- These messages contain syntax warnings.

The Loop Table listing (-listoptions=l) includes an entry for each loop indicating whether it was optimized, or why it was not. This section lists the possible messages and gives a brief explanation for each. The two most common reasons for a loop to be left serial are that the iterations were not independent (the listing should give a Data Dependence message) and that the loop contained I/O statements.

• Bad intrinsic call --- Code rearrangement by KAP may give unpredictable results.
• Bad operator --- Code rearrangement by KAP may give unpredictable results.
• Branches out of/into loop --- Code may be iteration-order dependent.
• CALL with alternate returns --- Program flow too uncertain.
• IO statements in loop --- Input/Output assumed order-dependent.
• Cannot allocate temporary array --- Usually, a Data Dependence could have been lifted by expanding a scalar into an array, but there was a name conflict.
• Distributed --- Loop divided into smaller loops, some of which may be otherwise optimized.
• DO statement not optimizable --- For example, iteration count of a DO WHILE loop is not known.
• Fused with other loops --- Adjacent loops joined into a larger loop to reduce overhead.
• GOTO in loop --- Possible flow patterns too complicated for KAP.
• Left as DO loop --- Usually, a Data Dependence prevented optimization.
• Left as a serial loop --- Usually, too much synchronization required.
• Nested IFs --- The branching pattern was too complicated.
• No optimizable statements --- For example, no arithmetic in loop.
• Not enough work --- Optimization overhead greater than expected gain.
• Optimization disabled --- By a directive or assertion.
• Scalar directive --- A directive or assertion turned off optimization.
• Scalar mode preferable --- Usually, too much synchronization needed.
• Too many inner loops: LIMIT > integer --- VERY complicated loop nest; KAP will try to optimize inner loops.
• Too many stmts/DD arcs --- VERY complicated loop nest; try increasing -arclimit.
• Unoptimizable call --- SUBROUTINE or FUNCTION with unknown side effects.
• Unoptimizable intrinsic call --- Unknown side effects.
• Unoptimizable operation --- For example, character string manipulation.
• Unoptimizable statements in loop --- Usually I/O.
• Unoptimizable symbol use --- Variable used in a complicated way, such as with COMMON or EQUIVALENCE.
• Unoptimizable variable or operation type --- Only numerical work is easily optimized by Compaq KAP Fortran/OpenMP for Tru64 UNIX.
• Unrolled --- Loop would run more efficiently than rolled up (see explanations in Chapter 5 and Chapter 9).

Appendix F provides a complete list of the diagnostic messages that can appear in the program listing (original or transformed).

In addition to the listing file, some messages (such as for command switch errors or missing files) are written to the error file. These are intended to be self-explanatory.

Table A-1 shows the Compaq extensions to Fortran.

Table A-1 Compaq Fortran Extensions Supported by KAP Fortran/OpenMP

DIGITAL Fortran 77 Extension	Compaq KAP	Compaq Fortran Compiler
Language Elements and Source Form
END can be continued across lines	Yes	Yes
99 continuation lines (in free format)	Yes	Yes
99 continuation lines (in fixed format)	Yes	Yes
\ treated as escape
$ allowed in names	Yes	Yes
ASCII characters x'a1' to x'fe' valid	Yes	Yes
D debug lines (in fixed form only)	Yes	Yes
TAB character treated as whitespace	Yes	Yes
Leading _ allowed in names		Yes
Variable names larger than 31 characters
Data Types and Attributes
INTEGER*8, LOGICAL*8	Yes	Yes
REAL*16	Yes	Yes
Size of the largest character is 2**31	Yes	Yes
DOUBLE COMPLEX intrinsic type	Yes	Yes
*typelength specifier	Yes	Yes
AUTOMATIC attribute and statement	Yes	Yes
STATIC attribute and statement	Yes	Yes
BYTE intrinsic type	Yes	Yes
BYTE treated same as INTEGER	Yes	Yes
BYTE treated same as LOGICAL	Yes	Yes
COMPLEX*32
Cray POINTER	Yes	Yes
VIRTUAL attribute and statement	Yes	Yes
VOLATILE attribute and statement	Yes	Yes
BYTE treated same as CHARACTER
Cray style boolean constants
Cray Character POINTER
IMPLICIT STATIC and AUTOMATIC	Yes
IMPLICIT UNDEFINED
VAX STYLE parameter statement	Yes	Yes
VAX structure, UNION, MAP, RECORD declarations	Yes	Yes
Constants, Declarations, and Initialization
Statement function with structure constructor	Yes	Yes
Hollerith constants in initialization expressions	Yes	Yes
//Initializer	Yes	Yes
Equivalence Character and non-Character	Yes	Yes
Hollerith allowed to initialize COMPLEX	Yes	Yes
Linear subscript notation in Equivalence	Yes	Yes
Multiple SAVEs without arguments		Yes
Named constants allowed to initialize COMPLEX	Yes	Yes
Trailing octal and hexadecimal notation	Yes	Yes
Typeless character treated as Hollerith	Yes	Yes
Cray pointee as element in derived type	Yes	Yes
Cray POINTER as element in derived type
Cray POINTER with TARGET attribute	Yes	Yes
Equivalence using sequenced derived types		Yes
Scalar subobject allowed in DATA	Yes
T and F (for .true. and .false. in DATA and intialization expressions)		Yes
Typeless constants in initialization expressions	Yes	Yes
Array Concepts
Underindex of arrays		Yes
Overindexing of arrays
[] form for array constructors		Yes
Array with up to 20 dimension
Linearized array constructor		Yes
Expressions and Assignment
.XOR same as .NEQ	Yes	Yes
Binary constant allowed in arithmetic expression	Yes	Yes
Bit mask operations on Cray POINTER variables	Yes	Yes
Bit mask operations on integer constants and variables	Yes	Yes
Bit mask operations on typeless constants	Yes	Yes
Hollerith in arithmetic expressions	Yes	Yes
Hollerith allowed in relational expressions	Yes	Yes
.A. .O. .N. for .AND. .OR. .NOT.	Yes
Adjacent arithmetic operations	Yes	Yes
Bit mask operations on real constants and variables
INTEGER and LOGICAL intermixing	Yes	Yes
Controlling Execution
Extended range DO loops	Yes	Yes
Real can be used in integer contexts like RETURN, computed GOTO, array bounds	Yes	Yes
& in alternate return (in fixed form only)		Yes
Input and Output Processing
ENCODE and DECODE I/O statements	Yes	Yes
Record specifier	Yes	Yes
Namelist with internal files	Yes
VAX ACCEPT, REWRITE, and DELETE statements	Yes	Yes
VAX OPEN and CLOSE staement specifiers	Yes	Yes
VAX TYPE I/O statement	Yes	Yes
VAX UNLOCK, FIND, and DEFINEFILE statements	Yes	Yes
Input and Output Editing
$ edit descriptor	Yes	Yes
Q data edit_descriptor	Yes	Yes
S edit descriptor	Yes	Yes
h edit_descriptor	Yes	Yes
X without position as edit descriptor	Yes	Yes
Comma optional in format expression	Yes
Ew.dQe. Qw.d, Fw.dQe edit descriptor	Yes	Yes
Variable <> format expressions	Yes	Yes
Non-character format expression	Yes	Yes
Program Units
PROGRAM can have argument list	Yes
RETURN as end in main program
Using Procedures
%ref and %val	Yes	Yes
PURE functions		Yes
%loc	Yes	Yes
References to RECURSIVE FUNCTION name followed by 0 are treated as a function call even when the RESULT is not specified as long as the function is not array valued		Yes
Function result can have SAVE attribute
Intrinsic Procedures
MAXLOC and MINLOC accept DIM=argument		Yes
Scope, Association, and Definition
COMMON block can be initialized outside of BLOCK DATA	Yes	Yes
Named COMMON in multiple BLOCK DATA	Yes	Yes
Up to 26 unnamed block data	Yes
COMMON block can have same name as program		Yes