Index

Numbers and Symbols

!DIR$ in directivesFixed-Form Source

-xcode-xcode[=v]

-xdebuginfo-xdebuginfo=a[,a...]

-xglobalize-xglobalize[={yes|no}]

-xinline_paramxinline_param=a[,a[,a]...]

-xinline_reportxinline_report[=n]

-xtemp-xtemp=path

-xvector-xvector[=a]

.mod file, module fileModule Files

A

abrupt_underflow–fnonstd

address space–xaddr32[={yes|no}]

aliasing–xalias[=keywords]

-xalias–xalias[=keywords]

align  See Alsodata

-dalign–dalign

data in COMMON with -aligncommon–aligncommon[={1|2|4|8|16}]

alignment of data typesSize and Alignment of Data Types

ALLOCATABLE

extensionsExtended ALLOCATABLE Attribute

analyzer compile option, xF–xF

arguments, agreement, Xlist–Xlist[x]

arithmetic  Seefloating-point

array bounds checking–C

assembly code–S

ASSUME directiveThe ASSUME Directives

B

backward compatibility, command-line optionsBackward Compatibility and Legacy Options

binary I/OAdditional I/O Extensions

binding, dynamic/shared libraries–d{y|n}

Boolean

constant, alternate formsAlternate Forms of Boolean Constants

type, constantsBoolean Type

C

C(..) directiveThe C Directive

cache

padding for–pad[=p]

specify hardware cache–xcache=c

CALL

inlining subprogram calls with -inline–inline=[%auto][[,][no%]f1,…[no%]fn]

cc command-line options

-xdebuginfo-xdebuginfo=a[,a...]

-xinline_paramxinline_param=a[,a[,a]...]

-xinline_reportxinline_report[=n]

CDIR$ in directivesFixed-Form Source

code size–xspace

command-line

helpCommand-Line Help

command-line options

-a (obsolete)Obsolete f95 Options

-aligncommon–aligncommon[={1|2|4|8|16}]

-ansi–ansi

-arg=local–arg=local

-autopar, parallelize automatically–autopar

-Bdynamic–B{static|dynamic}

-Bstatic–B{static|dynamic}

-C, check subscripts–C

-c, compile only–c

-copyargs, allow stores to literal arguments–copyargs

-Dname, define symbol–Dname[=def]

-dalign

–fast

–dalign

-dbl_align_all, force data alignment–dbl_align_all[={yes|no}]

-depend–fast

data dependency analysis–depend[={yes|no}]

-dn–d{y|n}

-dryrun–dryrun

-dy–d{y|n}

-e, extended source lines–e

-erroff, suppress warnings–erroff[={%all|%none|taglist}]

-errtags, display message tag with warnings–errtags[={yes|no}]

-errwarn, error warnings–errwarn[={%all|%none|taglist}]

-ext_names, externals without underscore–ext_names=e

-f77–f77[=list]

-F–F

-f, align on 8-byte boundaries–f

-fast–fast

-fixed–fixed

-flags–flags

-fma

–fma[={none|fused}]

–fast

-fnonstd–fnonstd

-fns

–fns[={yes|no}]

–fast

-fopenmp-fopenmp

-fpp, Fortran preprocessor–fpp

-fprecision, x86 precision mode–fprecision={single|double|extended}

-free–free

-fround=r–fround={nearest|tozero|negative|positive}

-fserialior–fserialio

-fsimple–fast

simple floating-point model–fsimple[={1|2|0}]

-fstore–fstore

-ftrap–ftrap=t

-G–G

-g

–g[n]

-g

-hname–hname

-help–help

-i8 — use —xtypemap=integer:64 instead-i8

-Idir–Ipath

-inline–inline=[%auto][[,][no%]f1,…[no%]fn]

-iorounding–iorounding[={compatible|processor-defined}]

-keepmod–keepmod[={yes|no}]

-keeptmp–keeptmp

-Kpic–Kpic

-KPIC–KPIC

-Ldir–Lpath

-llibrary–lx

-libmil

–libmil

–fast

-library=sunperf-library=sunperf

-loopinfo, show parallelization–loopinfo

-m32 | —m64–m32 | –m64

-Mdir, f95 modulesModule Files

-moddir–moddir=path

-mt, multithread safe libraries-mt[={yes|no}]

-native–native

-native (obsolete)Obsolete f95 Options

-noautopar–noautopar

-nodepend–nodepend

-nofstore-nofstore

-nolib–nolib

-nolibmil–nolibmil

-noqueue (obsolete)Obsolete f95 Options

-noreduction–noreduction

-norunpath–norunpath

-o, output file–o filename

-On

–O[n]

–O[n]

–fast

-onetrip–onetrip

-openmp–openmp

-p, profile (obsolete)–p

-pad=p

–pad[=p]

–fast

-pg, profile by procedure–pg

-pic–pic

-PIC–PIC

-pic (obsolete)Obsolete f95 Options

-PIC (obsolete)Obsolete f95 Options

-preserve_argvalues–preserve_argvalues[=simple|none|complete]

-Qoption–Qoption pr ls

-R list–R ls

-r8const–r8const

-recl=a[,b]–recl=a[,b]

-S–S

-s–s

-silent–silent

-stackvar

–xrecursive

–stackvar

-stop_status–stop_status[={yes|no}]

-temp–temp=dir

-time–time

-traceback–traceback[={%none|common|signals_list}]

-u–u

-U, do not convert to lowercase–U

-Uname, undefine preprocessor macro–Uname

-unroll, unroll loops–unroll=n

-useThe -use=list Option Flag

-V–V

-v–v

-vax–vax=keywords

-vpara–vpara

-W-Wc,arg

-w–w[n]

-xaddr32–xaddr32[={yes|no}]

-xalias=list–xalias[=keywords]

-xannotate[={yes|no}]–xannotate[={yes|no}]

-xarch=isa–xarch=isa

-xassume_control

–xassume_control[=keywords]

The ASSUME Directives

-xautopar–xautopar

-xbinopt–xbinopt={prepare | off}

-xcache=c–xcache=c

-xchip=c–xchip=c

-xcode=c-xcode[=v]

-xcommoncheck–xcommonchk[={yes|no}]

-xdebugformat–xdebugformat={dwarf|stabs}

-xdepend–xdepend

-xF–xF

-xglobalize-xglobalize[={yes|no}]

-xhasc, Hollerith as character–xhasc[={yes|no}]

-xhelp=h–xhelp=flags

-xhwcprof–xhwcprof[={enable | disable}]

-xia, interval arithmetic–xia[={widestneed|strict}]

-xinline–xinline=list

-xinstrument–xinstrument=[%no]datarace

-xinterval=v for interval arithmetic–xinterval[={widestneed|strict|no}]

-xipo, interprocedural optimizations–xipo[={0|1|2}]

-xipo_archive–xipo_archive[={none|readonly|writeback}]

-xipo_build-xipo_build=[yes|no]

-xivdep–xivdep[=p]

-xjobs, multiprocessor compilation-xjobs{=n|auto}

-xkeepframe, prohibit stack-related optimizations–xkeepframe[=[%all,%none,name,no%name]]

-xknown_lib, optimize library calls–xknown_lib=library_list

-xl, (obsolete)–xl

-xlang=f77, link with Fortran 77 libraries–xlang=f77

-xld, (obsolete)–xld

-xlibmil–xlibmil

-xlibmopt

–xlibmopt

–fast

-xlic_lib=sunperf obsolete–xlic_lib=sunperf

-Xlinker-Xlinker arg

-xlinkopt–xlinkopt[={1|2|0}]

-xlinkopt, link-time optimizations–xlinkopt[={1|2|0}]

-Xlist, global program checking–Xlist[x]

-xloopinfo–xloopinfo

-xM–xM

-xmaxopt–xmaxopt[=n]

-xmemalign–xmemalign[=<a><b>]

-xnolib

–xnolibmil

–xnolib

-xnolibmopt–xnolibmopt

-xOn–xOn

-xopenmp–xopenmp[={parallel|noopt|none}]

-xpagesize–xpagesize=size

-xpagesize_heap–xpagesize_heap=size

-xpagesize_stack–xpagesize_stack=size

-xpatchpadding-xpatchpadding[={fix|patch|size}]

-xpec–xpec[={yes|no}]

-xpg–xpg

-xpp=p–xpp={fpp|cpp}

-xprefetch

The PREFETCH Directives

The PREFETCH Directives

-xprefetch_auto_type–xprefetch_auto_type=indirect_array_access

-xprofile=p–xprofile=p

-xprofile_ircache–xprofile_ircache[=path]

-xprofile_pathmap=param–xprofile_pathmap=collect_prefix:use_prefix

-xrecursive–xrecursive

-xreduction–xreduction

-xregs=r–xregs=r

-xs-xs[={yes|no}]

-xsafe=mem–xsafe=mem

-xsecure_code_analysis–xsecure_code_analysis{=[yes|no]}

-xsegment_align-xsegment_align=n

-xspace–xspace

-xtarget=t–xtarget=t

-xtarget=native–fast

-xtemp-xtemp=path

-xthroughput-xthroughput[={yes|no}]

-xtime–xtime

-xtypemap–xtypemap=spec

-xunboundsym-xunboundsym={yes|no}

-xunroll–xunroll=n

-xvector

-xvector[=a]

–fast

-ztext–ztext

commonly usedCommonly Used Options

default options fileUser-Supplied Default Options File

grouped by functionOptions Summary

legacyBackward Compatibility and Legacy Options

macrosMacro Flags

obsoleteObsolete Option Flags

obsolete f77 flags not supportedIncompatibility Issues

order of processingTypographic Notations for Options

pass option to compilation phase–Qoption pr ls

Reference to all option flagsOptions Reference

summaryOptions Summary

syntaxOptions Syntax

unrecognized optionsUnrecognized Command-Line Arguments

comments

as directivesDirectives

COMMON

alignment–aligncommon[={1|2|4|8|16}]

global consistency, -Xlist–Xlist[x]

padding–pad[=p]

TASKCOMMON consistency checking–xcommonchk[={yes|no}]

compatibility

Fortran 77

FORTRAN 77 Compatibility: Migrating to Oracle Developer Studio Fortran

–f77[=list]

forwardForward Compatibility

with CMixing Languages

compile and link

Separate Compiling and Linking

Compile-Link Sequence

and -B–B{static|dynamic}

build a dynamic shared library–G

compile only–c

dynamic (shared) libraries–d{y|n}

compiler

command lineInvoking the Compiler

driver, show commands with -dryrun

–dryrun

–dryrun

show version–V

timing–time

verbose messages–v

constant arguments, -copyargs–copyargs

continuation lines

Continuation Line Limits

–e

conventions

file name suffixesCommand-Line File Name Conventions

coverage analysis (tcov)–xprofile=p

cpp, C preprocessor

–F

–Dname[=def]

Source File Preprocessors

Cray

pointerCray Pointers

pointer and Fortran pointerDeclaring Cray Pointers and Fortran 95 Pointers

cross reference table, Xlist–Xlist[x]

D

data

alignment with -dbl_align_all–dbl_align_all[={yes|no}]

alignment with -f–f

alignment with -xmemalign–xmemalign[=<a><b>]

COMMON, alignment with aligncommon–aligncommon[={1|2|4|8|16}]

mappings with -xtypemap–xtypemap=spec

promote constants to REAL*8–r8const

size and alignmentSize and Alignment of Data Types

data dependence

-depend–depend[={yes|no}]

dbx

compile with -g option

–g[n]

-g

debugging

-g option

–g[n]

-g

-XlistDebugging Utilities

check array subscripts with -C–C

cross-reference table–Xlist[x]

global program checking with -Xlist–Xlist[x]

link debug information from object files into executable-xs[={yes|no}]

show compiler commands with -dryrun

–dryrun

–dryrun

utilitiesDebugging Utilities

with optimization–g[n]

default

data sizes and alignmentSize and Alignment of Data Types

include file paths–Ipath

define symbol for cpp, Dname–Dname[=def]

directives

ASSUMEThe ASSUME Directives

FIXEDFIXED and FREE Directives

Fortran 77Directives

FREEFIXED and FREE Directives

IGNORE_TKRThe IGNORE_TKR Directive

loop unrollingThe UNROLL Directive

OpenMP (Fortran)

Fortran OpenMP Directives

OpenMP Parallelization Directives

optimization levelThe OPT Directive

parallelization

Parallelization Directives

Parallelization Directives

special FortranForm of Special f95 Directive Lines

summary of all directivesFortran Directives Summary

weak linkingThe WEAK Directive

directory

temporary files–temp=dir

dynamic library

build, -G–G

name a dynamic library–hname

E

elfdumpThe -xcode Flags

environment

program terminations by STOP–stop_status[={yes|no}]

environment variablesUsing Environment Variables

error messages

f95f95 Runtime I/O Error Messages

message tags–errtags[={yes|no}]

suppress with -erroff–erroff[={%all|%none|taglist}]

exceptions, floating-point–fsimple[={1|2|0}]

trapping–ftrap=t

executable file

built-in path to dynamic libraries–R ls

name–o filename

strip symbol table from–s

explicit

typing–u

explicit parallelization directivesParallelization Directives

extensions

ALLOCATABLEExtended ALLOCATABLE Attribute

non-ANSI, -ansi flag–ansi

other I/OAdditional I/O Extensions

stream I/OFortran 2003 Stream I/O

VALUEVALUE Attribute

VAX structures and unionsSTRUCTURE and UNION (VAX Fortran)

extensions and featuresFeatures of the Fortran Compiler

external C functionsThe C Directive

external names–ext_names=e

F

f95 command line

Command Syntax

Invoking the Compiler

fdumpmod for viewing module contents

The fdumpmod Command

Modules

features

Fortran 95Oracle Developer Studio Fortran Features and Extensions

release historyFeatures Release History

features and extensionsFeatures of the Fortran Compiler

FFLAGS environment variableUsing Environment Variables

file

executableCompile-Link Sequence

objectCompile-Link Sequence

size too bigMemory Size

file names

recognized by the compiler

Source Form Assumed

Command-Line File Name Conventions

fixed-format source–fixed

FIXED directive

Restrictions

FIXED and FREE Directives

flags  Seecommand-line options

floating-point

interval arithmetic–xinterval[={widestneed|strict|no}]

non-standard–fns[={yes|no}]

preferences, -fsimple–fsimple[={1|2|0}]

rounding–fround={nearest|tozero|negative|positive}

trapping mode–ftrap=t

FLUSH statementFortran 2003 FLUSH I/O Statement

form

tabTab Form

Fortran

compatibility with legacy

FORTRAN 77 Compatibility: Migrating to Oracle Developer Studio Fortran

–f77[=list]

–arg=local

directives

Form of Special f95 Directive Lines

Directives

features and extensionsFeatures of the Fortran Compiler

handling nonstandard Fortran 77 aliasingAdditional Notes About Migrating to the f95 Compiler

incompatibilities with legacyIncompatibility Issues

modulesModule Files

preprocessor–Dname[=def]

invoking with -F–F

utilitiesOther Fortran Utilities

Fortran 200xFortran 200x Features

Fortran 95

caseCase

featuresSource Language Features

I/O extensionsAdditional I/O Extensions

linking with Fortran 77Linking With Legacy FORTRAN 77-Compiled Routines

fpp, Fortran preprocessor

–fpp

–F

–Dname[=def]

Source File Preprocessors

free-format source–free

FREE directive

Restrictions

FIXED and FREE Directives

fsecond-underscore–ext_names=e

fsplit, Fortran utilityOther Fortran Utilities

function

external CThe C Directive

function-level reordering–xF

G

global program checking, -Xlist–Xlist[x]

global symbols

weakThe WEAK Directive

gprof

-pg, profile by procedure–pg

H

hardware architecture

–xchip=c

–xarch=isa

heap page size

–xpagesize_stack=size

–xpagesize_heap=size

–xpagesize=size

help

command-lineCommand-Line Help

hexadecimalHexadecimal

HollerithHollerith

I

#ifdefSource File Preprocessors

#includeSource File Preprocessors

#include path–Ipath

I/O extensionsAdditional I/O Extensions

IGNORE_TKR directiveThe IGNORE_TKR Directive

IMPORT statementFortran 2003 IMPORT Statement

INCLUDE files–Ipath

floatingpoint.hAdditional Notes About Migrating to the f95 Compiler

system.incLibrary Interfaces and system.inc

incompatibilities, FORTRAN 77Incompatibility Issues

initialization of local variables–xcheck[=keyword[,keyword]]

inline

templates, -libmil–libmil

with -fast–fast

inlining

automatic with -O4–O[n]

with -inline–inline=[%auto][[,][no%]f1,…[no%]fn]

installation

path–Ipath

interfaces

libraryLibrary Interfaces and system.inc

interval arithmetic

-xia option–xia[={widestneed|strict}]

-xinterval option–xinterval[={widestneed|strict|no}]

intrinsics

extensionsIntrinsics

interfacesLibrary Interfaces and system.inc

legacy FortranFortran Intrinsics

invalid, floating-point–ftrap=t

ISA, instruction set architecture–xarch=isa

IVDEP directive

–xivdep[=p]

IVDEP Directive

L

large filesMemory Size

legacy compiler optionsBackward Compatibility and Legacy Options

libm

searched by default–Lpath

libraries

building shared librariesThe -xcode Flags

Oracle Developer Studio Performance LibraryOracle Developer Studio Performance Library

library

build, -G–G

disable system libraries–nolib

dynamic search path in executable–R ls

interfacesLibrary Interfaces and system.inc

linking with -l–lx

name a shared library–hname

Oracle Developer Studio Performance Library

–xlic_lib=sunperf

-library=sunperf

path to shared library in executable–norunpath

position-independent and pure–ztext

limit

commandControl of Virtual Memory

stack size–stackvar

limits

Fortran compilerLimits and Defaults

linear algebra routines

–xlic_lib=sunperf

-library=sunperf

link-time optimizations–xlinkopt[={1|2|0}]

linking

consistent compile and linkConsistent Compiling and Linking

consistent with compilationConsistent Compiling and Linking

disable system libraries–nolib

enable dynamic linking, shared libraries–d{y|n}

linker -Mmapfile option–xF

separate from compilationSeparate Compiling and Linking

specifying libraries with -l–lx

weak namesThe WEAK Directive

with automatic parallelization, -autopar–autopar

with compilationCompile-Link Sequence

list of command-line options–help

list of directivesFortran Directives Summary

loop

automatic parallelization–autopar

dependence analysis, -depend–depend[={yes|no}]

executed once, -onetrip–onetrip

parallelization messages–loopinfo

unrolling with -unroll–unroll=n

unrolling with directiveThe UNROLL Directive

M

macro command-line optionsMacro Flags

man pagesMan Pages

math library

and -L dir option–Lpath

optimized version–xlibmopt

memory

actual real memory, displaySwap Space Limits

limit virtual memoryControl of Virtual Memory

optimizer out of memoryMemory Size

messages

parallelization

–vpara

–loopinfo

runtimeOperating System Error Messages

suppress with -silent–silent

verbose–v

misaligned data, specifying behavior–xmemalign[=<a><b>]

MODDIR environment variable–moddir=path

modulesModule Files

-useThe -use=list Option Flag

.mod fileModule Files

creating and usingModules

default path–moddir=path

fdumpmod for displaying module filesThe fdumpmod Command

fdumpmod for viewing module contentsModules

multithreading

-mt[={yes|no}]

  Seeparallelization

N

name

object, executable file–o filename

nonstandard_arithmetic()–fnonstd

numeric sequence type–aligncommon[={1|2|4|8|16}]

O

object files

compile only–c

name–o filename

object library search directories–Lpath

object-oriented FortranObject-Oriented Fortran Support

obsolete command-line optionsObsolete Option Flags

octalOctal

OMP_NUM_THREADS, number of threads–autopar

one-trip DO loops–onetrip

OpenMPOpenMP Parallelization Directives

directives summaryFortran OpenMP Directives

OPT directiveThe OPT Directive

-xmaxopt option–xmaxopt[=n]

optimization

across source files–xipo[={0|1|2}]

aliasing–xalias[=keywords]

floating-point–fsimple[={1|2|0}]

inline user-written routines–inline=[%auto][[,][no%]f1,…[no%]fn]

interprocedural–xipo[={0|1|2}]

levels–O[n]

link-time–xlinkopt[={1|2|0}]

loop unrolling–unroll=n

loop unrolling by directiveThe UNROLL Directive

math library–xlibmopt

OPT directive

–xmaxopt[=n]

The OPT Directive

PIPELOOP directiveThe PIPELOOP[=n] Directive

PREFETCH directiveThe PREFETCH Directives

specify cache–xcache=c

specify instruction set architecture–xarch=isa

specify processor–xchip=c

target hardware–native

with -fast–fast

with debugging–g[n]

options  Seecommand-line options

order of

functions–xF

order of processing, optionsTypographic Notations for Options

overflow

stack–stackvar

trap on floating-point–ftrap=t

overindexing

aliasing–xalias[=keywords]

P

padding–pad[=p]

page size, setting stack or heap

–xpagesize_stack=size

–xpagesize_heap=size

–xpagesize=size

parallelization

automatic–autopar

directivesParallelization Directives

loop information–loopinfo

messages–vpara

OpenMP

–xopenmp[={parallel|noopt|none}]

OpenMP Parallelization Directives

OpenMP directives summarizedFortran OpenMP Directives

reduction operations–reduction

parameters, global consistency, Xlist–Xlist[x]

passes of the compiler–v

path

dynamic libraries in executable–R ls

library search–Lpath

to standard include files–Ipath

Pentium-xtarget Values on x86 Platforms

performance

optimization–fast

Oracle Developer Studio Performance LibraryOracle Developer Studio Performance Library

performance library

–xlic_lib=sunperf

-library=sunperf

PIPELOOP directiveThe PIPELOOP[=n] Directive

pointeeCray Pointers

pointerCray Pointers

aliasing–xalias[=keywords]

position-independent code

–PIC

–pic

POSIX library, not supportedIncompatibility Issues

POSIX threads-mt[={yes|no}]

pragma  Seedirectives

precision on x86

-fprecision–fprecision={single|double|extended}

-fstore–fstore

PREFETCH directive

The PREFETCH Directives

The PREFETCH Directives

The PREFETCH Directives

preprocessor, source file

define symbol–Dname[=def]

force -fpp–fpp

fpp, cppSource File Preprocessors

specify with -xpp=p–xpp={fpp|cpp}

undefine symbol–Uname

processor

specify target processor–xchip=c

profile data path map–xprofile_pathmap=collect_prefix:use_prefix

profiling

-pg, -gprof–pg

-xprofile–xprofile=p

R

range of subscripts–C

recursive subprograms–xrecursive

release historyFeatures Release History

reorder functions–xF

rounding

–fsimple[={1|2|0}]

–fround={nearest|tozero|negative|positive}

S

search

object library directories–Lpath

shared library

build, -G–G

disallow linking, -dn–d{y|n}

name a shared library–hname

pure, no relocations–ztext

shell

limitsControl of Virtual Memory

SIGFPE, floating-point exception–fnonstd

size of compiled code–xspace

Solaris threads-mt[={yes|no}]

source file

preprocessingSource File Preprocessors

source format

mixing format of source lines (f95)Mixing Forms

options (f95)Source Form Assumed

source lines

extended–e

fixed-format–fixed

free-format–free

line lengthFixed-Form Source Lines

preprocessor–xpp={fpp|cpp}

SPARC platform

cache–xcache=c

chip–xchip=c

code address space-xcode[=v]

instruction set architecture-xarch keywords common to both SPARC and x86 platforms

stack

increase stack size–stackvar

overflow–stackvar

setting page size

–xpagesize_stack=size

–xpagesize_heap=size

–xpagesize=size

standard

include files–Ipath

standard numeric sequence type–aligncommon[={1|2|4|8|16}]

standards

conformanceStandards Conformance

identify non-ANSI extensions, -ansi flag–ansi

static

binding–d{y|n}

STOP statement, return status–stop_status[={yes|no}]

stream I/OFortran 2003 Stream I/O

strict (interval arithmetic)–xinterval[={widestneed|strict|no}]

strip executable of symbol table, s–s

suffix

of file names recognized by compiler

Source Form Assumed

Command-Line File Name Conventions

suppress

implicit typing–u

linking–c

warnings–w[n]

warnings by tag name, -erroff–erroff[={%all|%none|taglist}]

swap space

display actual swap spaceSwap Space Limits

limit amount of disk swap spaceMemory Size

swap commandSwap Space Limits

symbol table

for dbx

–g[n]

-g

syntax

command line optionsOptions Syntax

compiler command lineCommand Syntax

f95 command

Command Syntax

Invoking the Compiler

system.incLibrary Interfaces and system.inc

T

tab

form source tabTab Form

tape I/O, not supportedIncompatibility Issues

tcov

-xprofile–xprofile=p

templates, inline–libmil

temporary files, directory for–temp=dir

traceback–traceback[={%none|common|signals_list}]

trapping

floating-point exceptions–ftrap=t

on memory–xsafe=mem

type declaration alternate formAbbreviated Size Notation for Numeric Data Types

U

ulimit commandControl of Virtual Memory

underflow

gradualSubnormal REAL and DOUBLE

trap on floating-point–ftrap=t

underscore–ext_names=e

do not append to external namesThe C Directive

UNROLL directiveThe UNROLL Directive

usage

compilerInvoking the Compiler

utilitiesOther Fortran Utilities

V

variables

alignmentSize and Alignment of Data Types

local–stackvar

undeclared–u

VAX VMS Fortran extensions

STRUCTURE and UNION (VAX Fortran)

–vax=keywords

version

id of each compiler pass–V

W

warnings

message tags–errtags[={yes|no}]

suppress messages–w[n]

suppress with -erroff–erroff[={%all|%none|taglist}]

undeclared variables–u

use of non-standard extensions–ansi

weak linker symbolsThe WEAK Directive

WEAK directiveThe WEAK Directive

widestneed (interval arithmetic)–xinterval[={widestneed|strict|no}]