2.3 Directives

!$PRAGMA WEAK (name1 [=name2])

WEAK (name1) defines name1 to be a weak symbol. The linker does not produce an error message if it does not find a definition for name1.

WEAK (name1=name2) defines name1 to be a weak symbol and an alias for name2.

If your program calls but does not define name1, the linker uses the definition from the library. However, if your program defines its own version of name1, then the program’s definition is used and the weak global definition of name1 in the library is not used. If the program directly calls name2, the definition from library is used; a duplicate definition of name2 causes an error. See the Oracle Solaris 11.3 Linkers and Libraries Guide for more information.

2.3.1.5The OPT Directive

The OPT directive requires that you specify SUN after !$PRAGMA.

The OPT directive sets the optimization level for a subprogram, overriding the level specified on the compilation command line. The directive must appear immediately before the target subprogram, and only applies to that subprogram. For example:

!$PRAGMA SUN OPT=2

SUBROUTINE smart(a,b,c,d,e)

...etc

When the above is compiled with an f95 command that specifies -O4, the directive will override this level and compile the subroutine at -O2. Unless there is another directive following this routine, the next subprogram will be compiled at -O4.

The routine must also be compiled with the -xmaxopt[=n] option for the directive to be recognized. This compiler option specifies a maximum optimization value for PRAGMA OPT directives: if a PRAGMA OPT specifies an optimization level greater than the -xmaxopt level, the - xmaxopt level is used.

2.3.1.6The PIPELOOP[=n] Directive

The PIPELOOP=n directive requires that you specify SUN after !$PRAGMA.

This directive must appear immediately before a DO loop. n is a positive integer constant, or zero, and asserts to the optimizer a dependence between loop iterations. A value of zero

2.3 Directives

indicates that the loop has no inter-iteration (loop-carried) dependencies and can be freely pipelined by the optimizer. A positive n value implies that the I-th iteration of the loop has a dependency on the (I-n)-th iteration, and can be pipelined at best for only n iterations at a time. (Default if n is not specified is 0)

C We know that the value of K is such that there can be no C cross-iteration dependencies (E.g. K>N)

!$PRAGMA SUN PIPELOOP=0 DO I=1,N

A(I)=A(I+K) + D(I) B(I)=B(I) + A(I)

END DO

2.3.1.7The PREFETCH Directives

The -xprefetch option flag, “3.4.168 –xprefetch[=a[,a]]” on page 148, enables a set of PREFETCH directives that advise the compiler to generate prefetch instructions for the specified data element on processors that support prefetch.

!$PRAGMA SUN_PREFETCH_READ_ONCE(name)

!$PRAGMA SUN_PREFETCH_READ_MANY(name)

!$PRAGMA SUN_PREFETCH_WRITE_ONCE(name)

!$PRAGMA SUN_PREFETCH_WRITE_MANY(name)

See also the Oracle Developer Studio 12.6: C User’s Guide or the SPARC Architecture Manual, Version 9 for further information about prefetch instructions.

2.3.1.8The ASSUME Directives

The ASSUME directive gives the compiler hints about conditions at certain points in the program. These assertions can help the compiler to guide its optimization strategies. The programmer can also use these directives to check the validity of the program during execution. There are two formats for ASSUME.

The syntax of the “point assertion” ASSUME is

!$PRAGMA ASSUME (expression [,probability])

Alternatively, the “range assertion” ASSUME is:

!$PRAGMA BEGIN ASSUME [expression [, probability)

34 Oracle Developer Studio 12.6: Fortran User's Guide • July 2017

2.3 Directives

block of statements

!$PRAGMA END ASSUME

Use the point assertion form to state a condition that the compiler can assume at that point in the program. Use the range assertion form to state a condition that holds over the enclosed range of statements. The BEGIN and END pairs in a range assertion must be properly nested.

The required expression is a boolean expression that can be evaluated at that point in the program that does not involve user-defined operators or function calls except for those listed below.

The optional probability value is a real number from 0.0 to 1.0, or an integer 0 or 1, giving the probability of the expression being true. A probability of 0.0 (or 0) means never true, and 1.0 (or 1) means always true. If not specified, the expression is considered to be true with a high probability, but not a certainty. An assertion with a probability other than exactly 0 or 1 is a non-certain assertion. Similarly, an assertion with a probability expressed exactly as 0 or 1 is a certain assertion.

For example, if the programmer knows that the length of a DO loop is always greater than 10,000, giving this hint to the compiler can enable it to produce better code. The following loop will generally run faster with the ASSUME pragma than without it.

!$PRAGMA BEGIN ASSUME(__tripcount().GE.10000,1) !! a big loop do i = j, n

a(i) = a(j) + 1 end do

!$PRAGMA END ASSUME

Two intrinsic functions are available for use specifically in the expression clause of the ASSUME directive. (Note that their names are prefixed by two underscores.)

This list of special intrinsics might expand in future releases.

Use with the -xassume_control compiler option. (See “3.4.114 – xassume_control[=keywords]” on page 110) For example, when compiled with - xassume_control=check, the example above would produce a warning if the trip count ever became less than 10,000.