KAP C for OpenVMS Alpha
Quick Reference

April 1997

This document lists KAP C for OpenVMS Alpha command-line qualifiers.

For more information about these qualifiers, see the KAP C OpenVMS Alpha User Guide.

Revision /Update Information This is a revised document.

Operating System and Version: OpenVMS Alpha, Versions 7.1

Software Version: KAP C, Version 3.1

Digital Equipment Corporation
Maynard, Massachusetts
_____________________________________________________________________

First Printing, March 1993

Revised, April 1997

Possession, use, or copying of the software described in this publication is authorized only pursuant to a valid written license from Digital or an authorized sublicensor.

Digital Equipment Corporation makes no representations that the use of its products in the manner described in this publication will not infringe on existing or future patent rights, nor do the descriptions contained in this publication imply the granting of licenses to make, use, or sell equipment or software in accordance with the description. Digital Equipment Corporation 1993, 1996, 1997. All rights reserved. Kuck & Associates, Inc. 1993, 1996, 1997. All rights reserved.

The following are trademarks of Digital Equipment Corporation: AlphaGeneration, Digital, VAX DOCUMENT, and the DIGITAL logo.

KAP is a trademark of Kuck & Associates, Inc.

All other trademarks and registered trademarks are the property of their respective holders.

This document is available on CD-ROM.

This document was produced using SDMLWEB. 1

Table 1 KAP Command-Line Qualifiers

Long Name  Short Name  Default Value 
General Optimization     
[no]interchange  interchange  interchange 
[no]namepartitioning= <integer>,<integer>  [n]namepart= <integer>, <integer>  off 
optimize  o=5 
[no]recursion  [n]rc  off 
roundoff  roundoff=3 
scalaropt=<integer>  so=<integer>  so=3 
[no]skip  [n]sk  off 
tune=<architecture>  tune= <architecture>  tune= <architecture> 
Parallel Processing     
[no]concurrentize  [n]conc  noconc 
minconcurrent=<integer>  mc  mc=1000 
Inlining and IPA     
inline[=<names>]  inl[=<names>]  off 
noinline[=<names>]  ninl[=<names>]   
ipa[=<names>]  ipa[=<names>]  off 
noipa[=<names>]  nipa[=<names>]   
inline_and_copy=<names>  inlc=<names>  off 
inline_create=<file>  incr=<file>  off 
ipa_create=<file>  ipacr=<file>  off 
inline_depth=<integer>  ind=<integer>  ind=2 
ipa_depth=<integer>  ipad=<integer>  ind=2 
inline_from_ files=<file>,<file>  inff=<file>,<file>  current source file 
ipa_from_ files=<file>,<file>  ipaff=<file>,<file>  current source file 
inline_from_ libraries= <library>,<library>  infl=<library>, <library>  off 
ipa_from_ libraries= <library>,<library>  ipafl=<library>, <library>  off 
inline_ looplevel=<integer>  inll=<integer>  inll=2 
ipa_ looplevel=<integer>  ipall=<integer>  ipall=2 
inline_manual  inm  off 
ipa_ manual  ipam  off 
inline_optimize=<integer>    inline_optimize=0 
ipa_optimize=<integer>    ipa_optimize=0 
Input- Output     
cmp[=<file>]  cmp[=<file>]  see User Guide 
nocmp  ncmp   
list[=<file>]  l[=<file>]  nl 
nolist  nl   
Listing     
cmpoptions[=<list>]  cp[=<list>]  ncp 
nocmpoptions  ncp   
lines=<integer>  ln=<integer>  ln=55 
listingwidth=<integer>  lw=<integer>  lw=132 
listoptions=<list>  lo=<list>  see User Guide 
Language Qualifiers     
[no]natural  [n]nat  nat 
signed  signed  signed 
Advanced Optimization     
addressresolution=<integer>  arl=<integer>  arl=2 
[no]arclimit=<integer>  [n]arclm=<integer>  arclm=5000 
cacheline=<integer>  chl=<integer>  chl=32,32 
cache_prefetch_line_count= <integer>[,<integer>]  cplc=<integer>  cplc=0 
cachesize=<integer>  chs=<integer>  chs=8,0 
dpregisters=<integer>  dpr=<integer>  dpr=32 
each_invariant_if_growth= <integer>  eiifg=<integer>  eiifg=20 
fpregisters=<integer>  fpr=<integer>  fpr=32 
[no]fuse=<integer>  [n]fuse  nofuse 
fuselevel=<integer>  fuselevel=<integer>  fuselevel=0 
heaplimit=<integer>  heap=<integer>  heaplimit=100 
limit=<integer>  lm=<integer>  lm=50 
[no]machine=<list>  [n]ma  noma 
max_ invariant_if_growth= <integer>  miifg=<integer>  miifg=500 
routine=<routine_name> /<limited qualifiers>  rt=<routine_name> /<limited qualifiers>  off 
setassociativity=<integer>  sasc=<integer>  sasc=1 
stdio  stdio  off 
syntax=<list>  sy=<list>  sy=d 
unroll=<integer>  ur=<integer>  ur=4 
unroll2=<integer>  ur2=<integer>  ur2=200 
unroll3=<integer>  ur3=<integer>  ur3=1 

Table 2 Ranges

Value  Meaning 
addressresolution 
KAP C makes no assumptions about data aliasing 
A pointer will not contain its own address 
No objects represented by function parameters overlap in memory KAP C assumes parameter aliasing Equivalent to #pragma_KAP distinct for all parameters 
Globals, function parameters, and locals form distinct groups 
No aliases for objects 
listoptions   
Calling tree at end of program listing 
KAP C qualifiers used, printed at end of each program unit 
Loop-by-loop optimization table 
Names of program unit 
Performance statistics compilation 
Summary of loop optimizations performed 
machine   
Prefer nonstride-1 array access 
Directs KAP to parallelize only outer loops 
Prefer optimization of for loop stride-1 references 
other   
Limit  >0 
Arclimit  >0 
optimize   
No optimization performed Simple program analysis performed 
Simple loop optimization performed Loops distributed to optimize only part of loop 
Loops in a loop nest optimized Lifetime analysis performed More powerful data dependence tests performed 
Special techniques used to break data dependence cycles Triangular loops recognized Loop interchanging performed to improve memory referencing Special case data dependence tests used 
Two versions of a loop generated to break data dependence arc when necessary Exact data dependence tests performed Wraparound variables recognized 
Array expansion and loop fusion enabled 
roundoff   
No roundoff-changing transformations 
Loop interchanging around serial reductions allowed if -optimize is equal to or greater than 4 Simplification of expressions from forward substitution or inside trigonometric intrinsic functions returning integer values is performed Code floating enabled if -scalaropt is equal to or greater than 2 Loop rerolling enabled if -scalaropt is equal to or greater than 2 
Reciprocal substitution performed to move an expensive division outside of loop 
Floating point induction variables recognized Memory management enabled if -scalaropt=3 Expressions such as A/ B /C can be rotated to A / (B * C) 
scalaropt   
No scalar optimizations performed 
Only simple scalar optimizations performed Dead-code elimination Global forward substitution Dusty deck IF transformations enabled 
Full range of scalar optimizations performed Floating invariant IFs out of loops Induction variable recognition Loop rerolling if -roundoff is equal to or greater than 1 Loop peeling, loop fusion, loop unrolling 
Memory management enabled if - roundoff=3 
syntax   
Strict compliance with ANSI C 
Accepts common C 
unroll - enabled only with -scalaropt=2 
-unroll=<#it> and - unroll2=<weight> 
  where:

<#it> is the maximum number of iterations to unroll.


=0 use default values to unroll
=1 no unrolling

<weight> is the maximum weight, estimate of work, in an unrolled loop. Work is estimated by counting operands and operators in a loop. The default is at most 4 iterations and maximum work of 100 per unrolled iteration. 

Table 3 KAP Assertions and Directives

KAP Assertion  Duration 
#pragma _KAP arl=<integer>  Selectable 
#pragma _KAP distinct (name, name)  Selectable 
#pragma _KAP no side effects (name)  Program unit 
Parallel Processing:   
#pragma _KAP concurrent  Selectable 
#pragma _KAP concurrent call  Selectable 
#pragma _KAP concurrent ignore call  Selectable 
#pragma _KAP serial  Selectable 
KAP Directive  Range of Values 
Inlining and Interprocedural Analysis:   
#pragma _KAP inline [here] [routine] [global] [(name[,name..])]   Selectable 
#pragma _KAP ipa [here] [routine] [global] [(name[,name..])]   Selectable 
Memory Management:   
#pragma_ KAP padding (var_list)  Program unit 
#pragma_KAP storage order (var_list)  Program unit 
Parallel Processing:   
#pragma _ KAP minconcurrent (<integer>)  Program unit