Pgf90 Man Page

| Comments

本文用于收集PGI Fortran90 V10.3编译器帮助文档。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
pgf90(1)							      pgf90(1)



NAME
       pgf90 - The Portland Group Inc. Fortran 90/95 compiler

SYNOPSIS
       pgf90 [ -flag ]...  sourcefile...

DESCRIPTION
       pgf90  is  the interface to The Portland Group Inc. (PGI) Fortran 90/95
       compiler for AMD64 and IA32/EM64T processors.  pgf90 invokes  the  For-
       tran compiler, assembler, and linker with options derived from its com-
       mand line arguments.  pgf90 is an alias for pgfortran.

       Suffixes of source file names indicate the type	of  processing	to  be
       done:

       .f     fixed-format Fortran source; compile
       .F     fixed-format Fortran source; preprocess, compile
       .f90   free-format Fortran source; compile
       .F90   free-format Fortran source; preprocess, compile
       .f95   free-format Fortran source; compile
       .F95   free-format Fortran source; preprocess, compile
       .for   fixed-format Fortran source; compile
       .FOR   fixed-format Fortran source; preprocess, compile
       .fpp   fixed-format Fortran source; preprocess, compile
       .s     assembler source; assemble
       .S     assembler source; preprocess, assemble
       .o     object file; passed to linker
       .a     library archive file; passed to linker

       If  coinstalled with pgcc, C file suffixes are also recognized and com-
       piled with the pgcc compiler; see pgcc and  PGI	User’s	Guide.	 Other
       files are passed to the linker (if linking is requested) with a warning
       message.

       Unless one overrides the default action using  a	 command-line  option,
       pgf90  deletes  the  intermediate preprocessor and assembler files (see
       the options -c, -E, -F, and -Mkeepasm); if a single Fortran program  is
       compiled	 and  linked  with  one pgf90 command, the intermediate object
       file is also deleted.  Linking is the last stage of  the	 compile  pro-
       cess,  unless  you  use one of the -c, -E, -F, or -S options, or unless
       compilation errors stop the whole process.

OPTIONS
       Options must be separate; -cs is different from -c -s.  Here is a  list
       of  all	options,  grouped  by type.  More detailed explanations are in
       following sections.

       Overall Options
	      -- -# -### -c -[no]defaultoptions -dryrun -drystdinc --flagcheck
	      -flags -help[=option] -Manno -Minform=level -Mkeepasm -M[no]list
	      -noswitcherror -o file -rc rcfile -S -show -silent -time -v -V
	      -V<ver> -w -Wpass,option -Ypass,directory

       Optimization Options
	      -fast -fastsse -fpic -fPIC -Kpic -KPIC -Mcache_align
	      -Mconcur=option -M[no]depchk -M[no]dse -Mextract=option
	      -M[no]frame -Minfo=option -Minline=option -Minstrument=option
	      -M[no]ipa=option -M[no]lre[=assoc|noassoc] -M[no]movnt
	      -Mneginfo=option -Mnoopenmp -Mnosgimp -Mnovintr -Mpfi[=option]
	      -Mpfo[=option] -M[no]pre[=all] -M[no]prefetch=option
	      -Mprof=option -M[no]propcond -Mquad -Msafe_lastval
	      -M[no]scalarsse -M[no]smart -M[no]smartalloc[=option]
	      -M[no]stride0 -M[no]unroll=option -M[no]unsafe_par_align
	      -M[no]vect=option -M[no]zerotrip -mp[=option] -Olevel -pg

       Debugging Options
	      -C -g -gopt -M[no]bounds -Mchkfpstk -Mchkptr -Mchkstk -Mcoff
	      -Mdwarf1 -Mdwarf2 -Mdwarf3 -Melf -Mnodwarf -M[no]pgicoff
	      -[no]traceback

       Preprocessor Options
	      -Dmacro -E -F -Idirectory
	      -Mcpp=[[no]comment|m|md|mm|mmd|suffix:suff] -Mnostddef
	      -Mnostdinc -Mpreprocess -Uname -YI,directory -Yp,directory

       Assembler Options
	      -Wa,argument[,argument]...  -Ya,directory

       Linker Options
	      --[no-]as-needed -Bdynamic -Bstatic -Bstatic_pgi -g77libs
	      -llibrary -Ldirectory -m -Mlfs -Mmpi=option -Mnostartup
	      -Mnostdlib -M[no]rpath -Mscalapack -pgcpplibs -pgf77libs
	      -pgf90libs -r -Rdirectory -rpathdirectory -s -shared -sonamename
	      -uname --[no-]whole-archive -Wl,argument[,argument]...
	      -YC,directory -Yl,directory -YL,directory -YS,directory
	      -YU,directory

       Language Options
	      -byteswapio -i2 -i4 -i8 -i8storage -Mallocatable[=95|03]
	      -M[no]backslash -Mbyteswapio -Mcray=pointer -Mcuda=option
	      -M[no]dalign -M[no]dclchk -M[no]defaultunit -M[no]dlines
	      -Mdollar=char -Mextend -Mfixed -M[no]free[form] -M[no]i4
	      -M[no]iomutex -M[no]llalign -Mnomain -M[no]onetrip -M[no]r8
	      -M[no]r8intrinsics=float -M[no]recursive -M[no]ref_externals
	      -M[no]save -M[no]signextend -Mstandard -M[no]unixlogical
	      -M[no]upcase -module directory -r4 -r8

       Target-specific Options
	      -K[no]ieee -Ktrap=option -M[no]daz -M[no]flushz
	      -M[no]fpapprox=option -M[no]fpmisalign -M[no]fprelaxed=option
	      -M[no]func32 -M[no]large_arrays -M[no]longbranch -M[no]loop32
	      -M[no]second_underscore -M[no]varargs -Mwritable-strings -m32
	      -m64 -mcmodel=small|medium -pc val -ta=target -tp target

       When source files are compiled using any of the -g, -mp, -Mconcur,
       -Mipa, or -Mprof options, the same option(s) should be passed when
       using pgf90 to link the objects.


Overall Options
       --	 Anything after this switch is treated as a filename.  Note
		 that most tools will not allow a filename starting with a
		 dash, so these should be avoided.

       -#	 Display the invocations of the compiler, assembler, and
		 linker.  These invocations are the command lines created by
		 pgf90.

       -###	 Display invocations of the compiler, assembler and linker,
		 but do not execute them.

       -c	 Skip the link step; compile and assemble only.

       -defaultoptions (default) -nodefaultoptions
		 Use (don’t use) the default options set in site-specific or
		 user-specific PREOPTIONS or POSTOPTIONS driver variables.

       -dryrun	 Use this option to display the invocations of the compiler,
		 assembler, and linker but do not execute them.

       -drystdinc
		 Display the standard include directories without invoking the
		 compiler.

       --flagcheck
		 Don’t compile anything; just emit any messages for command-
		 line switch errors.  Return a success error code if there are
		 no command-line switch errors.

       -flags	 Display all valid pgf90 command-line options in alphabetical
		 order.

       -help[=option]
		 Displays command-line options recognized by pgf90 on the
		 standard output.  pgf90 -help -otherswitch will give help
		 about -otherswitch.  The default is to list pgf90 command
		 line options by group; options are:

		 groups	  Print out the groups into which the switches are
			  organized.

		 asm	  Print help for assembler command-line options.

		 debug	  Print help for debugging command-line options.

		 language Print help for language-specific command-line
			  options.

		 linker	  Print help for linker options.

		 opt	  Print help for optimization command-line options.

		 other	  Print help for any other command-line options.

		 overall  Print help for overall command-line options.

		 phase	  Print help for the known compiler phases.

		 prepro	  Print help for preprocessor command-line options.

		 suffix	  Describe the known file suffixes.

		 switch	  Print all switches in alphabetical order.

		 target	  Print help for target-specific command-line options.

		 variable Show the pgf90 configuration; this is the same as
			  -show.

       -Manno	 Produce annotated assembly files, where source code is
		 intermixed with assembly language; implies -Mkeepasm.

       -Minform=level
		 Specify the minimum level of error severity that the compiler
		 displays during compilation.

		 fatal	   Instructs the compiler to display fatal error
			   messages.

		 file (default) nofile
			   Print out (don’t print out) the names of files as
			   they are compiled; this is only active when there
			   is more than one file on the command line.

		 severe	   Instructs the compiler to display severe and fatal
			   error messages.

		 warn	   Instructs the compiler to display warning, severe
			   and fatal error messages.

		 inform	   Instructs the compiler to display all error
			   messages (inform, warn, severe and fatal).

		 The default is -Minform=warn.

       -Mkeepasm Keep the assembly file for each source file, but continue to
		 assemble and link the program. This is mainly for use in
		 compiler performance analysis and debugging.

       -Mlist -Mnolist (default)
		 Create (don’t create) a listing file.

       -noswitcherror
		 Ignore unknown command line switches after printing an
		 warning message; the default behavior is to print an error
		 message and halt.

       -o file	 Use file as the name of the executable program, rather than
		 the default a.out.  If used with -c or -S and a single input
		 file, file is used as the name of the object or assembler
		 output file.

       -rc rcfile
		 Specifies the name of a pgf90 startup configuration file.  If
		 rcfile is a full pathname, then use the specified file.  If
		 rcfile is a relative pathname, use the file name as found in
		 the $DRIVER directory.

       -S	 Skip the assembly and link steps. Leave the output from the
		 compile step in a file named file.s for each file named, for
		 instance, file.f.  See also -o.

       -show	 Produce help information describing the current pgf90
		 configuration.

       -silent	 Do not print warning messages. Same as -Minform=severe.

       -time	 Print execution times for the various steps in the compiler
		 itself.

       -v	 Verbose mode; print out the command line for each tool before
		 it is executed.

       -V	 Display version messages and other information.

       -V<ver>	 If the specified version of the compiler is installed, that
		 version of the compiler is invoked.

       -w	 Do not print warning messages.

       -Wpass,option[,option...]
		 Pass option to the specified pass.  Each comma-delimited
		 option is passed as a separate argument.  The passes are:

		 h	   for the Fortran 90/95 front end,

		 0	   for the compiler back end,

		 a	   for the assembler,

		 i	   for the interprocedural analyzer, and

		 l	   for the linker.

       -Ypass,directory
		 Look in directory for pass pass, rather than in the standard
		 area. The passes are:

		 h	   Search for the Fortran 90/95 front end executable
			   in directory.

		 0	   Search for the compiler back end executable in
			   directory.

		 a	   Search for the assembler executable in directory.

		 C	   Search for the compiler library in directory.

		 i	   Search for the InterProcedural Analyzer (IPA) in
			   directory.

		 l	   Search for the linker in directory.

		 I	   Set the compiler’s standard include directory to
			   directory.  The standard include directory is set
			   to a default value by the driver and can be
			   overridden by this option.

		 L	   If the linker supports the -YL option, then pass
			   the option -YL,directory to the linker. Otherwise,
			   use directory as the standard library location.

		 S	   Search for the startup object files in directory.

		 U	   If the linker supports the -YU option, then pass
			   the option -YU,directory to the linker. Otherwise
			   this option is ignored.


Optimization Options
       -fast  Chooses generally optimal flags for the target platform.	Use
	      pgf90 -fast -help to see the equivalent switches.	 Note this
	      sets the optimization level to a minimum of 2; see -O.

       -fastsse
	      Chooses generally optimal flags for a processor that supports
	      SSE instructions (Pentium 3/4, AthlonXP/MP, Opteron) and SSE2
	      (Pentium 4, Opteron).  Use pgf90 -fastsse -help to see the
	      equivalent switches.

       -fpic  (Linux only) Instructs the compiler to generate position-
	      independent code which can be used to create shared object files
	      (dynamically linked libraries).

       -fPIC  Equivalent to -fpic; provided for compatibility with other
	      compilers.

       -Kpic  Equivalent to -fpic; provided for compatibility with other
	      compilers.

       -KPIC  Equivalent to -fpic; provided for compatibility with other
	      compilers.

       -Mcache_align
	      Align unconstrained data objects of size greater than or equal
	      to 16 bytes on cache-line boundaries.  An unconstrained object
	      is a variable or array that is not a member of an aggregate
	      structure or common block, is not allocatable, and is not an
	      automatic array.

       -Mconcur[=option[,option,...]]
	      Instructs the compiler to enable auto-concurrentization of
	      loops.  This also sets the optimization level to a minimum of 2;
	      see -O.  If -Mconcur is specified, multiple processors will be
	      used to execute loops which the compiler determines to be
	      parallelizable.  When linking, the -Mconcur switch must be
	      specified or unresolved references will occur. The
	      OMP_NUM_THREADS or NCPUS environment variables control how many
	      processors will be used to execute parallelized loops.  The
	      options can be one or more of the following:

	      allcores	Use all available cores when the environment variables
			OMP_NUM_THREADS and NCPUS are not set.	This must be
			specified at link time.

	      bind	Bind threads to cores or processors.  This must be
			specified at link time.

	      altcode:n noaltcode
			Generate (don’t generate) alternate scalar code for
			parallelized loops.  The parallelizer generates scalar
			code to be executed whenever the loop count is less
			than or equal to n.  If noaltcode is specified, the
			parallelized version of the loop is always executed
			regardless of the loop count.

	      altreduction[:n]
			Generate alternate scalar code for parallelized loops
			containing a reduction.	 If a parallelized loop
			contains a reduction, the parallelizer generates
			scalar code to be executed whenever the loop count is
			less than or equal to n.

	      assoc (default) noassoc
			Enable (disable) parallelization of loops with
			reductions.

	      cncall nocncall (default)
			Assume (don’t assume) that loops containing calls are
			safe to parallelize. Also, no minimum loop count
			threshold must be satisfied before parallelization
			will occur, and last values of scalars are assumed to
			be safe.

	      dist:block
			Parallelize with block distribution. Contiguous blocks
			of iterations of a parallelizable loop are assigned to
			the available processors.

	      dist:cyclic
			Parallelize with cyclic distribution. The outermost
			parallelizable loop in any loop nest is parallelized.
			If a parallelized loop is innermost, its iterations
			are allocated to processors cyclically. For example,
			if there are 3 processors executing a loop, processor
			0 performs iterations 0, 3, 6, etc; processor 1
			performs iterations 1, 4, 7, etc; and processor 2
			performs iterations 2, 5, 8, etc.

	      innermost noinnermost (default)
			Enable (disable) parallelization of innermost loops.

	      levels:n	Parallelize loops nested at most n levels deep; the
			default is 3.

	      numa nonuma
			(Linux only) Use (don’t use) thread/processor affinity
			for NUMA architectures; use this option when linking
			the program.  -Mconcur=numa will link in a numa
			library and objects to prevent the operating system
			from migrating threads from one processor to another.

       -Mdepchk (default) -Mnodepchk
	      Assume (don’t assume) that potential data dependencies exist.
	      -Mnodepchk may result in incorrect code.

       -Mdse -Mnodse (default)
	      Enable (disable) the dead store elimination optimization.

       -Mextract=[option[,option,...]]
	      Run the subprogram extraction phase to prepare for inlining.
	      The =lib:filename option must be used with this switch to name
	      an extract library.  See -Minline for more details on inlining.

	      subprogram[,subprogram]
		     A non-numeric option not containing a period is assumed
		     to be the name of a subprogram to be extracted.

	      name:subprogram[,subprogram]
		     Specifies the name of a subprogram or subprograms to be
		     extracted.

	      lib:directory
		     Specifies the name of a directory to contain the
		     extracted subprograms; this directory will be created if
		     it does not exist.

	      [size:]number
		     A numeric option is assumed to be a size.	Functions
		     containing number or less statements are extracted.  If
		     both number and function are specified, then functions
		     matching the given name(s) or meeting the size
		     requirements, are extracted.

       -Mframe -Mnoframe (default)
	      Set up (don’t set up) a true stack frame pointer for functions;
	      -Mnoframe allows slightly more efficient operation when a stack
	      frame is not needed, but some options override -Mnoframe.

       -Minfo[=option[,option,...]]
	      Emit useful information to stderr. The options are:

	      all	The same as
			-Minfo=accel,inline,ipa,loop,lre,mp,opt,par,unified,vect.

	      accel	Emit information about accelerator region targeting.

	      autoinline
			Emit information about functions inlined due to the
			inline attribute.

	      ccff	Append complete CCFF information to the object files.

	      ftn	Emit Fortran-specific information.

	      hpf	Emit HPF-specific information.

	      inline	Emit information about functions extracted and
			inlined.

	      intensity Emit compute intensity information about loops.

	      ipa	Emit information about the optimizations enabled by
			interprocedural analysis (IPA).

	      loop | opt
			Emit information about loop optimizations.  This
			includes information about vectorization and loop
			unrolling.

	      mp	Emit information about OpenMP parallel regions.

	      par	Emit information about loop parallelization.

	      pfo	Emit profile feedback information

	      time | stat
			Emit compilation statistics.

	      unified	Emit information about which routines are selected for
			target-specific optimizations using the PGI Unified
			Binary.

	      vect	Emit information about automatic loop vectorization.
       With no options, -Minfo is the same as
       -Minfo=accel,inline,ipa,loop,lre,mp,opt,par,unified,vect.

       -Minline[=option[,option,...]]
	      Pass options to the function inliner. The options are:

	      lib:filename.ext
			Specify an inline library created by a previous
			-Mextract option.  Functions from the specified
			library are inlined.  If no library is specified,
			functions are extracted from a temporary library
			created during an extract prepass.

	      except:func
			Specifies which functions should not be inlined.

	      [name:]function
			A non-numeric option is assumed to be a function name.
			If name: is specified, what follows is always the name
			of a function.

	      [size:]number
			A numeric option is assumed to be a size.  Functions
			containing number or less statements are inlined.  If
			both number and function are specified, then functions
			matching the given name(s) or meeting the size
			requirements, are inlined.

	      levels:number
			number of levels of inlining are performed.  The
			default is 1.

	      reshape	For Fortran, the default is to not inline subprograms
			with array arguments if the array shape does not match
			the shape in the caller. This overrides the default.

       -Minstrument [=option]
	      (linux86-64 only) Generate additional code to enable function-
	      level instrumentation.  This option implies -Minfo=ccff and
	      -Mframe.	The option is

	      functions (default)

       -Mipa [=option[,option,...]] -Mnoipa (default)
	      Enable and specify options for InterProcedural Analysis (IPA).
	      This also sets the optimization level to a minimum of 2; see -O.
	      If no option list is specified, then it is equivalent to
	      -Mipa=const.  The options are:

	      align noalign (default)
			Enable (disable) recognition when pointer targets are
			all cache-line aligned, allowing better SSE code
			generation.

	      arg noarg (default)
			Remove (don’t remove) arguments replaced by
			-Mipa=ptr,const.  -Mipa=noarg implies
			-Mipa=nolocalarg.

	      cg nocg (default)
			Generate information for the pgicg call graph display
			tool.  Run pgicgexecutable to see the call graph
			information.

	      const (default) noconst
			Enable (disable) propagation of constants across
			procedure calls.

	      except:proc
			Used with -Mipa=inline, disables inlining of procedure
			proc.

	      f90ptr nof90ptr (default)
			Enable (disable) Fortran 90 pointer disambiguation
			across procedure calls.

	      fast	Chooses generally optimal -Mipa flags for the target
			platform; use pgf90 -Mipa -help to see the equivalent
			options.

	      force	Force all objects to recompile regardless of whether
			IPA information has changed.

	      globals noglobals (default)
			Analyze (don’t analyze) which globals are modified by
			procedure calls.

	      inline:n	Determine additional functions to inline, allowing up
			to n levels of inlining.

	      inlinenopfo:n
			This is the same as -Mipa=inline, except it ignores
			any profile frequency information from -Mpfo when
			choosing which functions to inline.

	      ipofile	Save IPA information in a .ipo file instead of the
			default of appending the information to the object
			file.

	      jobs:n	Use up to n jobs in parallel to reoptimize object
			files.

	      keepobj (default) nokeepobj
			Keep (don’t keep) the optimized object files, using
			file name mangling, to reduce recompile time in
			subsequent application builds.

	      libc nolibc (default)
			Optimize calls to certain standard C library routines.

	      libinline nolibinline (default)
			Allow (don’t allow) inlining from routines in
			libraries; -Mipa=libinline implies -Mipa=inline.

	      libopt nolibopt (default)
			Allow (don’t allow) recompiling and reoptimizing
			routines from libraries with IPA information.

	      localarg nolocalarg (default)
			Enable (disable) feature to externalize local
			variables to allow arguments to be replaced by
			-Mipa=ptr.  -Mipa=localarg implies -Mipa=arg.

	      main:func Specify a function to serve as a global entry point;
			may appear multiple times; disables linking.

	      ptr noptr (default)
			Enable (disable) pointer disambiguation across
			procedure calls.

	      pure nopure (default)
			Detect (don’t detect) pure functions.

	      quiet	Don’t print out messages about which files are
			recompiled at link time.

	      required	Return an error condition if IPA is inhibited for any
			reason, rather than the default behavior of linking
			without IPA optimization.

	      reshape noreshape (default)
			Enable (disable) Fortran inlining with mismatched
			array shapes.

	      safe:[function|library]
			Declares that the named function, or all functions in
			the named library are safe; a safe procedure does not
			call back into the known procedures and does not
			change any known global variables.  Without
			-Mipa=safe, any unknown procedures will cause IPA to
			fail.

	      safeall nosafeall (default)
			Declares that all unknown functions are safe (not
			safe); see -Mipa=safe.

	      shape noshape (default)
			Perform (don’t perform) Fortran 90 shape propagation.

	      summary	Only collect IPA summary information when compiling;
			this prevents IPA optimization of this file, but
			allows optimization for other files linked with this
			file.

	      vestigial novestigial (default)
			Remove (don’t remove) functions that are not called.

       -Mlre[=assoc|noassoc] -Mnolre
	      Enable (disable) loop-carried redundancy elimination.  The assoc
	      option allows expression reassociation, and the noassoc option
	      disallows expression reassociation.

       -Mmovnt -Mnomovnt
	      Force (disable) generation of nontemporal moves.	-Mmovnt used
	      with -fastsse can sometimes be faster than -fastsse alone.
	      -Mnomovnt also disables -Mvect=movntaltcode.  By default
	      nontemporal moves are generated for loops with large loop
	      counts.

       -Mneginfo=option[,option...]
	      Instructs the compiler to produce information on why certain
	      optimizations are not performed.	Use the -Minfo flag instead.

       -Mnoopenmp
	      When -mp is present, ignore the OpenMP pragmas.

       -Mnosgimp
	      When -mp is present, ignore the SGI parallelization pragmas.

       -Mnovintr
	      Do not generate vector intrinsic calls.

       -Mpfi[=option]
	      Generate profile feedback instrumentation; this includes extra
	      code to collect run-time statistics to be used in a subsequent
	      compile; -Mpfi must also appear when the program is linked.
	      When the program is run, a profile feedback file pgfi.out will
	      be generated; see -Mpfo.	The allowed options are:

	      indirect noindirect (default)
			Enable (disable) collection of indirect function call
			targets, which can be used for indirect function call
			inlining.

       -Mpfo[=option[,option,...]]
	      Enable profile feedback optimizations; there must be a profile
	      feedback file pgfi.out in the current directory, which contains
	      the result of an execution of the program compiled with -Mpfi.
	      The options are:

	      indirect noindirect (default)
			Enable (disable) indirect function call inlining; this
			requires a pgfi.out file generated from a binary built
			with -Mpfi=indirect.

	      layout (default) nolayout
			Enable (disable) basic block layout to take advantage
			of instruction cache locality by keeping hot paths
			close together.

	      dir=directory
			Specify the directory containing the pgfi.out profile
			feedback information file; the default is the current
			directory.

       -Mpre[=all] -Mnopre (default)
	      Enable (disable) the partial redundancy elimination
	      optimization.

	      all	Enable aggressive PRE.

       -Mprefetch[=option:n] -Mnoprefetch
	      Add (don’t add) prefetch instructions for those processors that
	      support them (Pentium 4, Opteron); -Mprefetch is default on
	      Opteron; -Mnoprefetch is default on other processors.  The
	      options are:

	      distance:d
			Set the fetch-ahead distance for prefetch instructions
			to d cache lines.

	      n:n	Set the maximum number of prefetch instructions to
			generate in a loop to n.

	      nta	Use the prefetchnta instruction.

	      plain	Use the prefetch instruction.

	      t0	Use the prefetcht0 instruction.

	      w		Allow the AMD-specific prefetchw instruction.

       -Mprof[=option[,option,...]]
	      Set performance profiling options.  Use of these options will
	      cause the resulting executable to create a performance profile
	      that can be viewed and analyzed with the PGPROF performance
	      profiler.	 In the descriptions below, PGI-style profiling
	      implies compiler-generated source instrumentation.  MPICH-style
	      profiling implies the use of instrumented wrappers for MPI
	      library routines.	 The -Mprof options are:

	      ccff

	      dwarf	Generate limited DWARF symbol information sufficient
			for most performance profilers.

	      func	Perform PGI-style function level profiling.

	      hwcts	Generate a profile using event-based sampling of
			hardware counters via the PAPI interface (linux86-64
			only, PAPI must be installed).

	      lines	Perform PGI-style line level profiling.

	      hpmpi	(PGI CDK only) Perform MPICH-style profiling for the
			HP Implies -Mmpi=hpmpi.

	      mpich1	(PGI CDK only) Perform MPICH-style profiling for
			MPICH-1.  Implies -Mmpi=mpich1.

	      mpich2	(PGI CDK only) Perform MPICH-style profiling for
			MPICH-2.  Implies -Mmpi=mpich2.

	      mvapich1	(PGI CDK only) Perform MPICH-style profiling for
			MVAPICH.  Implies -Mmpi=mvapich1.

	      time	Generate a profile using time-based instruction-level
			statistical sampling. This is equivalent to -pg,
			except that the profile is saved in a file named
			pgprof.out instead of gmon.out.

	      On Linux systems that have OProfile installed, PGPROF supports
	      collection of performance data without recompilation. Use of
	      -Mprof=dwarf is useful for this mode of profiling.

       -Mpropcond (default) -Mnopropcond
	      Enable (disable) propagation of constant values derived from
	      conditional branches with equality tests.

       -Mquad Align large objects on quad-word boundaries.

       -Msafe_lastval
	      In the case where a scalar is used after a loop, but is not
	      defined on every iteration of the loop, the compiler does not by
	      default parallelize the loop. However, this option tells the
	      compiler it is safe to parallelize the loop.

       -Mscalarsse -Mnoscalarsse
	      Utilize (don’t use) SSE (Pentium 3, 4, AthlonXP/MP, Opteron) and
	      SSE2 (Pentium 4, Opteron) instructions to perform the operations
	      coded. This requires the assembler to be capable of interpreting
	      SSE/SSE2 instructions.  The default is -Mscalarsse for Opteron
	      in 64-bit mode, and -Mnoscalarsse otherwise.

       -Msmart -Mnosmart (default)
	      Enable (disable) optional AMD64-specific post-pass instruction
	      scheduling.

       -Msmartalloc=option[,...] -Mnosmartalloc (default)
	      Add (don’t add) a call to the routine mallopt in the main
	      routine; this can have a dramatic impact on the performance of
	      programs that dynamically allocate memory.  To be effective,
	      this switch must be specified when compiling the file containing
	      the Fortran, C, or C++ main routine.  This is currently only
	      available on 64-bit Linux systems.  The behavior of -Msmartalloc
	      can be modified with the following options:

	      huge	Link in the huge page runtime library, so dynamic
			memory will be allocated in huge pages.

	      huge:n	Link in the huge page runtime library and allocate n
			huge pages.

	      hugebss	(x86-64 only) Link in the huge page runtime library
			and allocate the BSS section (containing uninitialized
			static symbols) in huge pages.	This requires that the
			huge page runtime library be linked dynamically, so
			the -rpath option for that directory will be added
			regardless of the setting of -Mnorpath.

	      nohuge	Override any previous -Msmartalloc=huge or
			-Msmartalloc=hugebss switches; do not link in the huge
			page runtime library.

       -Mstride0 -Mnostride0 (default)
	      Generate (don’t generate) alternate code for a loop that
	      contains an induction variable whose increment may be zero.

       -Munroll[=option[,option...]] -Mnounroll (default)
	      Invoke (don’t invoke) the loop unroller.	This also sets the
	      optimization level to a minimum of 2; see -O.  The option is one
	      of the following:

	      c:m	Instructs the compiler to completely unroll loops with
			a constant loop count less than or equal to m, a
			supplied constant.  If this value is not supplied, the
			m count is set to 4.

	      n:u	Instructs the compiler to unroll u times, a single-
			block loop which is not completely unrolled, or has a
			non-constant loop count.  If u is not supplied, the
			unroller computes the number of times a candidate loop
			is unrolled.

	      m:u	Instructs the compiler to unroll u times, a multi-
			block loop which is not completely unrolled, or has a
			non-constant loop count.  If u is not supplied, the
			unroller computes the number of times a candidate loop
			is unrolled.

	      -Mnounroll instructs the compiler not to unroll loops.

       -Munsafe_par_align -Mnounsafe_par_align
	      Use (don’t use) aligned moves for array loads in parallelized
	      loops as long as the first element of the array is aligned; this
	      is only effective with -Mscalarsse or -Mvect=sse.	 It is unsafe
	      because there are situations where the array elements allocated
	      to some processors are not aligned.

       -Mvect [=option[,option,...]] -Mnovect (default)
	      Pass options to the internal vectorizer.	This also sets the
	      optimization level to a minimum of 2; see -O.  If no option list
	      is specified, then the following vector optimizations are used:
	      assoc,cachesize:c,nosse, where c is the actual cache size of the
	      machine.	The -Mvect options are:

	      altcode (default) noaltcode
			Enable (disable) alternate code generation for vector
			loops, depending on such characteristics as array
			alignments and loop counts.

	      assoc (default) noassoc
			Enable (disable) certain associativity conversions
			that can change the results of a computation due to
			floating point roundoff error differences.  A typical
			optimization is to change the order of additions,
			which is mathematically correct, but can be
			computationally different, due to roundoff error.

	      cachesize:number (default=automatic)
			Instructs the vectorizer, when performing cache tiling
			optimizations, to assume a cache size of number.

	      fuse nofuse (default)
			Enable (disable) loop fusion to combine adjacent loops
			into a single loop.

	      gather (default) nogather
			Enable (disable) vectorization of loops with indirect
			array references.

	      idiom noidiom (default)
			Enable idiom recognition; this currently has no
			effect.

	      levels:n	Set maximum nest level of loops to optimize.

	      partial	Enable partial loop vectorization via innermost loop
			distribution.

	      prefetch	Use prefetch instructions in loops where profitable.

	      short noshort (default)
			Enable (disable) recognition of short vector
			operations that arise from scalar code outside of
			loops or within the body of loops.

	      sizelimit[:number] nosizelimit (default)
			Limit the size of loops that are vectorized; the
			default is to attempt to vectorize all loops.

	      sse nosse (default)
			Use (don’t use) SSE, SSE2, 3Dnow, and prefetch
			instructions in loops where possible.

	      uniform nouniform (default)
			Perform the same optimizations in the vectorized and
			residual loops.	 This may affect the performance of
			the residual loop.

       -Mnovect disables the vectorizer, and is the default.

       -Mzerotrip (default) -Mnozerotrip
	      Include (don’t include) a zero-trip test for loops.  Use
	      -Mnozerotrip only when all loops are known to execute at least
	      once.

       -mp[=option]
	      Interpret OpenMP pragmas to explicitly parallelize regions of
	      code for execution by multiple threads on a multi-processor
	      system. Most OpenMP pragmas as well as the SGI parallelization
	      pragmas are supported. See Chapters 5 and 6 of the PGI User’s
	      Guide for more information on these pragmas.  The options
	      allowed are:

	      align noalign (default)
			Modify (don’t modify) default loop iteration
			scheduling to align iterations with array references.
			The default is to use simple static scheduling.

	      allcores	Use all available cores when the environment variables
			OMP_NUM_THREADS and NCPUS are not set.	This must be
			specified at link time.

	      bind	Bind threads to cores or processors.  This must be
			specified at link time.

	      numa nonuma
			Use (don’t use) libraries to give affinity between
			threads and processors; this is useful with NUMA (non-
			uniform memory access) parallel architectures, so
			memory allocated by a particular thread will be
			allocated close to that processor, and will remain
			close to that thread.  The default depends on the host
			machine.

       -O[level]
	      Set the optimization level.  If -O is not specified, then the
	      default level is 1 if -g is not specified, and 0 if -g is
	      specified.  If a number is not supplied with -O then the
	      optimization level is set to 2.  The optimization levels and
	      their meanings are as follows:

	      0		A basic block is generated for each C statement. No
			scheduling is done between statements. No global
			optimizations are performed.

	      1		Scheduling within extended basic blocks is performed.
			Some register allocation is performed. No global
			optimizations are performed.

	      2		All level 1 optimizations are performed. In addition,
			traditional scalar optimizations such as induction
			recognition and loop invariant motion are performed by
			the global optimizer.

	      3		All level 1 and 2 optimizations are performed.	In
			addition, this level enables more aggressive code
			hoisting and scalar replacement optimizations that may
			or may not be profitable.

	      4		All level 1, 2 and 3 optimizations are performed.  In
			addition, hoisting of guarded invariant floating point
			expressions is enabled.

       -pg    (Linux only) Enable gprof-style sample-based profiling; implies
	      -Mframe.


Debugging Options
       -C     Add array bounds checking; the same as -Mbounds.

       -g     Generate symbolic debug information. This also sets the
	      optimization level to zero, unless a -O switch is present on the
	      command line. Symbolic debugging may give confusing results if
	      an optimization level other than zero is selected.  Using -O0
	      the generated code will be slower than code generated at other
	      optimization levels.

       -gopt  Generate symbolic debug information, without affecting
	      optimizations.  This may give confusing results when debugging
	      with optimizations; it is intended for use with other tools that
	      use the debug information.

       -Mbounds -Mnobounds (default)
	      Add (don’t add) array bound checking.

       -Mchkfpstk
	      Check for internal consistency of the IA-32 floating point stack
	      in the prologue of a function and after returning from a
	      function or subroutine call. If the PGI_CONTINUE environment
	      variable is set, the stack will be automatically cleaned up and
	      execution will continue. There is a performance penalty
	      associated with the stack cleanup. If PGI_CONTINUE is set to
	      verbose, the stack will be automatically cleaned up and
	      execution will continue after a warning message is printed.

       -Mchkptr
	      Check for unintended de-referencing of NULL pointers.

       -Mchkstk
	      Check the stack for available space upon entry to and before the
	      start of a parallel region. Useful when many private variables
	      are declared.

       -Mcoff Generate a COFF formatted object.

       -Mdwarf1
	      (IA-32 only) Generate DWARF1 debug information with -g.

       -Mdwarf2
	      Generate DWARF2 debug information with -g.

       -Mdwarf3
	      Generate DWARF3 debug information with -g.

       -Melf  Generate an ELF formatted object.

       -Mnodwarf
	      Don’t add the default dwarf information.

       -Mpgicoff -Mnopgicoff
	      Generate additional symbolic debug information.

       -traceback (default) -notraceback
	      Add debug information for runtime traceback


Preprocessor Options
       -Dname[=def]
	      Define name to be def in the preprocessor. If def is missing, it
	      is assumed to be empty. If the = sign is missing, then name is
	      defined to be the string 1.

       -E     Preprocess each .c file and send the result to standard output.
	      No compilation, assembly, or linking is performed.

       -F     Preprocess each file and leave the output in a file named file.f
	      for each file named file.F.  No compilation, assembly, or
	      linking is performed.

       -Idirectory
	      Add directory to the compiler’s search path for include files.
	      For include files surrounded by < >, each -I directory is
	      searched followed by the standard area. For include files
	      surrounded by " ", the directory containing the file containing
	      the #include directive is searched, followed by the -I
	      directories, followed by the standard area.

       -Mcpp=[[no]comment|m|md|mm|mmd|suffix:suff]
	      Only runs the preprocessor on the input file(s); by default, the
	      output is written to file.i, unless renamed with the -o switch.
	      The options are:

	      comment nocomment
		   Keep (don’t keep) C-style comments in the preprocessed
		   output.

	      m	   Print makefile dependencies to stdout, a la -M.

	      md   Print makefile dependencies to file.d, a la -MD.

	      mm   Print makefile dependencies to stdout, ignoring system
		   includes (includes with angle braces), a la -MM.

	      mmd  Print makefile dependencies to file.d, ignoring system
		   includes (includes with angle braces), a la -MMD.

	      suffix:suff
		   When generating makefile dependencies, name the dependent
		   file file.suff; the default is to name the dependent file
		   file.o.

       -Mnostddef
	      Do not predefine any macros to the preprocessor.

       -Mnostdinc
	      Do not search in the standard location for include files when
	      those files are not found elsewhere.

       -Mpreprocess
	      Run the preprocessor on Fortran or assembler source files.  By
	      default, the preprocessor is run when the source’s suffix is
	      .fpp, .F, .F90, .F95, or .HPF.

       -Uname Remove any initial definition of name in the preprocessor. The
	      only names predefined by the preprocessor itself are the
	      standard ANSI C predefined macros. The driver may predefine
	      other names (see the following description for the -Mnostddef
	      option).	NOTE: ANSI C predefined macros can be defined and
	      undefined on the command line, but not with #define and
	      #undefine directives in the source.

       -YI,directory
	      Look in directory for the standard compiler include files.

       -Yp,directory
	      Look in directory for the preprocessor executable.


Assembler Options
       -Wa,option[,option...]
	      Pass each comma-delimited option to the assembler.

       -Ya,directory
	      Look in directory for the assembler executable.


Linker Options
       --as-needed --no-as-needed
	      (Linux only; not supported by all linkers) Passed to the linker.
	      Instructs the linker to only set the DT_NEEDED flag for
	      subsequent shared libraries, requiring those libraries at run
	      time, if they are used to satisfy references.  --no-as-needed
	      restores the default behavior.

       -Bdynamic
	      (Linux only) Passed to the linker to specify dynamic binding.

       -Bstatic
	      (Linux only) Passed to the linker to specify static binding.

       -Bstatic_pgi
	      (Linux only) Statically link in the PGI libraries, while using
	      dynamic linking for the system libraries; implies -Mnorpath.

       -g77libs
	      (Linux only) Link-time option which allows object files
	      generated by GNU g77 (or gcc) to be linked in to pgf90 main
	      programs.

       -llibrary
	      Passed to the linker; load the library liblibrary.a from the
	      standard library directory.  See also the -L option.

       -Ldirectory
	      Add directory to the list of directories in which the linker
	      searches for libraries.

       -m     Cause the linker to display a link map.

       -Mlfs  (32-bit Linux only) Link in the Large File Support routines
	      available on Linux versions later than Red Hat 7.0 or SuSE 7.1.
	      This will support files from Fortran I/O that are larger than
	      2GB. Equivalent to -L$PGI/linux86/10.3-0/liblf.

       -Mmpi=option
	      (PGI CDK only) -Mmpi adds the include and library options to the
	      compile and link commands necessary to build an MPI application
	      using MPI libraries installed with the PGI Cluster Development
	      Kit (CDK). -Mmpi inserts -I$MPIDIR/include into the compile
	      line, and -L$MPIDIR/lib -lfmpich -lmpich into the link line.
	      The specified option is used to determine whether to select
	      MPICH-1 or MPICH-2 headers and libraries. The base directories
	      for MPICH-1 and MPICH-2 are set in localrc.  The -Mmpi options
	      are:

	      hpmpi	Select preconfigured HP-MPI libraries.	mpich1 Select
			preconfigured MPICH-1 libraries.

	      mpich2	Select preconfigured MPICH-2 libraries.

	      mvapich1	Select preconfigured MVAPICH libraries.

	      The user can set the environment variables MPIDIR and MPILIBNAME
	      to override the default values for the MPI directory and library
	      name.

       -Mnostartup
	      Do not link in the usual startup routine. This routine contains
	      the entry point for the program.

       -Mnostdlib
	      Do not link in the standard libraries when linking a program.

       -Mrpath (default) -Mnorpath
	      The default is to add -rpath to the link line giving the
	      directories containing the PGI shared objects.  Use -Mnorpath to
	      instruct the driver not to add any -rpath switches to the link
	      line.

       -Mscalapack
	      (PGI CDK only) Add the Scalapack libraries.

       -pgcpplibs
	      Link-time option to add the C++ runtime libraries, allowing
	      mixed-language programming.

       -pgf77libs
	      Link-time option to add the pgf77 runtime libraries, allowing
	      mixed-language programming.

       -pgf90libs
	      Link-time option to add the pgf90 runtime libraries, allowing
	      mixed-language programming.

       -r     Passed to the linker; generate a re-linkable object file.

       -Rdirectory
	      (Linux only) Passed to the linker; always search directory for
	      shared object files when running the generated executable.

       -rpathdirectory
	      Passed to the linker to add the directory to the runtime shared
	      library search path.

       -s     Passed to the linker; strip symbol table information.

       -shared
	      (Linux only) Passed to the linker. Instructs the linker to
	      generate a shared object file (dynamically linked library).
	      Implies -fpic.

       -sonamename
	      (Linux only) Passed to the linker. When creating a shared
	      object, instructs the linker to set the internal DT_SONAME field
	      to the specified name.

       -uname Passed to the linker; generate undefined reference.

       --whole-archive --no-whole-archive
	      (Linux only) Passed to the linker.  Instructs the linker to
	      include all objects in subsequent archive files.
	      --no-whole-archive restores the default behavior.

       -Wl,option[,option...]
	      Pass each comma-delimited option to the linker.

       -YC,directory
	      Look in directory for the standard compiler library files.

       -Yl,directory
	      Look in directory for the linker.

       -YL,directory
	      Look in directory for the standard system library files.

       -YS,directory
	      Look in directory for the standard system startup object files.

       -YU,directory
	      Passed to the linker; change library search path.


Language Options
       -byteswapio
	      Swap bytes from big-endian to little-endian or vice versa on
	      input/output of unformatted Fortran data. Use of this option
	      enables reading/writing of Fortran unformatted data files
	      compatible with those produced on Sun or SGI systems.

       -i2    Treat INTEGER variables as two bytes.

       -i4    Treat INTEGER variables as four bytes.

       -i8    Treat default INTEGER and LOGICAL variables as eight bytes.  For
	      operations involving integers, use 64-bits for computations.

       -i8storage
	      Allocates 8 bytes for INTEGER and LOGICAL.

       -Mallocatable[=95|03]
	      Select whether to use Fortran 1995 or Fortran 2003 semantics for
	      assignments to allocatable objects and allocatable components of
	      derived types.  Fortran 1995 semantics require the user to
	      allocate the object or component and that an array object or
	      component be conformant before the assignment.  Fortran 2003
	      semantics require the compiler to add code to check whether the
	      object or component is allocated and whether an array object is
	      conformant before the assignment, and to allocate or reallocate
	      if not.

       -Mbackslash -Mnobackslash (default)
	      Treat (don’t treat) backslash as a normal (non-escape) character
	      in strings.  -Mnobackslash causes the standard C backslash
	      escape sequences to be recognized in quoted strings; -Mbackslash
	      causes the backslash to be treated like any other character.

       -Mbyteswapio
	      Swap bytes from big-endian to little-endian or vice versa on
	      input/output of unformatted Fortran data. Use of this option
	      enables reading/writing of Fortran unformatted data files
	      compatible with those produced on Sun or SGI systems.

       -Mcray=pointer
	      Force Cray Fortran (CF77) compatibility with respect to the
	      listed options.  Possible options include:

	      pointer	For purposes of optimization, assume that pointer-
			based variables do not overlap the storage of any
			other variable.

       -Mcuda[=option[,option...]
	      Enable CUDA Fortran extensions, and link with the CUDA Fortran
	      libraries.  -Mcuda is required on the link line if there are no
	      CUDA Fortran source files specified on the command line.	The
	      options are:

	      emu	Enable emulation mode; in emulation mode, all code is
			executed on the host processor, allowing host-level
			debugging.

	      cc10	Generate code for a device with compute capability
			1.0.

	      cc11	Generate code for a device with compute capability
			1.1.

	      cc13	Generate code for a device with compute capability
			1.3.

	      keepbin	Keep the generated CUDA binary files, with a .bin
			suffix.

	      keepptx	Keep the generated portable assembly files, with a
			.ptx suffix.

	      maxregcount:n
			Set the maximum number of registers to use in the
			generated GPU code.

       -Mdalign (default) -Mnodalign
	      Align (don’t align) doubles in structures on 8-byte boundaries.
	      -Mnodalign may lead to data alignment exceptions.

       -Mdclchk -Mnodclchk (default)
	      Require (don’t require) that all variables be declared.

       -Mdefaultunit -Mnodefaultunit (default)
	      Treat (don’t treat) ’*’ as stdout/stdin regardless of the status
	      of units 6/5.  -Mnodefaultunit causes * to be a synonym for 5 on
	      input and 6 on output; -Mdefaultunit causes * to be a synonym
	      for stdin on input and stdout on output.

       -Mdlines -Mnodlines (default)
	      Treat (don’t treat) lines beginning with D in column 1 as
	      executable statements, ignoring the D.

       -Mdollar=char
	      Set the character used to replace dollar signs in names to be
	      char.  Default is an underscore (_).

       -Mextend
	      Allow 132-column source lines.

       -Mfixed
	      Process Fortran source using fixed form specifications.  The
	      -Mfree options specify free form formatting.  By default files
	      with a .f or .F extension use fixed form formatting.

       -Mfree -Mfreeform -Mnofree -Mnofreeform
	      Process Fortran source using free form specifications.  The
	      -Mnofree and -Mfixed options specify fixed form formatting.  By
	      default files with a .f90, .F90, .f95 or .F95 extension use
	      freeform formatting.

       -Mi4 (default) -Mnoi4
	      Treat (don’t treat) INTEGER as INTEGER*4.	 -Mnoi4 treats INTEGER
	      as INTEGER*2.

       -Miomutex -Mnoiomutex (default)
	      Generate (don’t generate) critical section calls around Fortran
	      I/O statements.

       -Mllalign -Mnollalign (default)
	      Align (don’t align) long longs or INTEGER*8 in structures or
	      common blocks on 8-byte boundaries.  -Mnollalign is the default,
	      and this is a change beginning with release 4.0. Releases prior
	      to 4.0 aligned long longs on 8-byte boundaries.

       -Mnomain
	      When the link step is called, don’t include the object file
	      which calls the Fortran main program. Useful for using the pgf90
	      driver to link programs with the main program written in C or
	      C++ and one or more subroutines written in Fortran.

       -Monetrip -Mnoonetrip (default)
	      Force (don’t force) each DO loop to be iterated at least once.

       -Mr8 -Mnor8 (default)
	      Treat (don’t treat) REAL as DOUBLE PRECISION and real constants
	      as double precision constants.

       -Mr8intrinsics [=float]-Mnor8intrinsics (default)
	      Treat (don’t treat) the intrinsics CMPLX as DCMPLX and REAL as
	      DBLE.

	      float	Also treat the FLOAT intrinsic as DBLE.

       -Mrecursive -Mnorecursive (default)
	      Allocate (don’t allocate) local variables on the stack, thus
	      allowing recursion. SAVEd, data-initialized, or namelist members
	      are always allocated statically, regardless of the setting of
	      this switch.

       -Mref_externals -Mnoref_externals (default)
	      Force (don’t force) references to names appearing in EXTERNAL
	      statements.

       -Msave -Mnosave (default)
	      Assume (don’t assume) that all local variables are subject to
	      the SAVE statement.  -Msave may allow many older Fortran
	      programs to run but can greatly reduce performance.

       -Msignextend (default) -Mnosignextend
	      Sign extend (don’t sign extend) when a narrowing conversion
	      overflows.  For example, when -Msignextend is in effect and an
	      integer containing the value 65535 is converted to a short, the
	      value of the short will be -1.  ANSI C specifies that the result
	      of such conversions are undefined.

       -Mstandard
	      Flag non-ANSI-Fortran usage.

       -Munixlogical -Mnounixlogical (default)
	      When -Munixlogical is in effect, a logical is considered to be
	      .TRUE.  if its value is non-zero and .FALSE.  otherwise.	When
	      -Mnounixlogical is in effect (the default), a logical considered
	      to be .TRUE.  if its value is odd and .FALSE.  if its value is
	      even.

       -Mupcase -Mnoupcase (default)
	      Preserve (don’t preserve) case in names.	-Mnoupcase causes all
	      names to be converted to lower case. Note that, if -Mupcase is
	      used, then variable name ’X’ is different than variable name
	      ’x’, and keywords must be in lower case.

       -module directory
	      Save/search for module files in directory

       -r4    Interpret DOUBLE PRECISION variables as REAL.

       -r8    Interpret REAL variables as DOUBLE PRECISION.  Equivalent to
	      using the options -Mr8 and -Mr8intrinsics.


Target-specific Options
       -Kieee -Knoieee (default)
	      Perform floating-point operations in strict conformance with the
	      IEEE 754 standard.  Some optimizations are disabled with -Kieee,
	      and a more accurate math library is used.	 The default -Knoieee
	      uses faster but very slightly less accurate methods.

       -Ktrap=[option,[option]...]
	      Controls the behavior of the processor when exceptions occur.
	      Possible options include

	      align   Trap on memory alignment errors, currently ignored.

	      denorm  Trap on denormalized operands.

	      divz    Trap on divide by zero.

	      fp      Trap on floating point exceptions.

	      inexact Trap on inexact result.

	      inv     Trap on invalid operands.

	      none (default)
		      Disable all traps.

	      ovf     Trap on floating point overflow.

	      unf     Trap on floating point underflow.
       -Ktrap is only processed when compiling a main function/program.
       -Ktrap=fp is equivalent to -Ktrap=divz,inv,ovf.	These options
       correspond to the processor’s exception mask bits.  Normally, the
       processor’s exception mask bits are on, meaning floating-point
       exceptions are masked; the processor recovers from the exception and
       continues.  If a mask bit is off (unmasked) and the corresponding
       exception occurs, execution terminates with floating point exception
       (Linux FPE signal).

       -Mdaz -Mnodaz
	      Enable (disable) mode to treat denormalized floating point
	      numbers as zero.	-Mdaz is default for -tp p7-64 targets;
	      -Mnodaz is default otherwise.

       -Mflushz (default) -Mnoflushz
	      Set SSE to flush-to-zero mode.

       -Mfpapprox [=option[,option,...]] -Mnofpapprox (default)
	      Perform (don’t perform) certain single-precision floating point
	      operations using low-precision approximation.  This can be very
	      dangerous; the low-precision approximations are much faster than
	      the full precision computation, but the results will be
	      different.  This option should be used only with the utmost
	      care.  The options are

	      div	Approximate single precision floating point division.

	      rsqrt	Approximate single precision floating point reciprocal
			square root.

	      sqrt	Approximate single precision floating point square
			root.
       With no options, -Mfpapprox will approximate all three operations.

       -Mfpmisalign -Mnofpmisalign
	      Allow (don’t allow) vector arithmetic instructions with memory
	      operands that are not aligned on 16-byte boundaries.

       -Mfprelaxed [=option[,option,...]] -Mnofprelaxed (default)
	      Perform (don’t perform) certain floating point operations using
	      relaxed precision when it improves speed.	 The options are

	      div	Perform divide using relaxed precision.

	      order noorder
			Allow (don’t allow) expression reordering, including
			factoring such as computing a*b+a*c as a*(b+c).

	      recip	Perform reciprocal operations using relaxed precision.

	      rsqrt	Perform reciprocal square root (1/sqrt) using relaxed
			precision.

	      sqrt	Perform square root using relaxed precision.
       With no options, -Mfprelaxed will choose to generate relaxed precision
       code for those operations that generate a significant performance
       improvement, depending on the target processor.

       -Mfunc32 (default) -Mnofunc32
	      Align (don’t align) functions on 32 byte boundaries.

       -Mlarge_arrays -Mnolarge_arrays (default)
	      (linux86-64 only). Allow (don’t allow) arrays larger than 2GB;
	      -Mlarge_arrays is default with -mcmodel=medium.

       -Mlongbranch -Mnolongbranch (default)
	      Enable (disable) long branches.

       -Mloop32 -Mnoloop32 (default)
	      Align (don’t align) innermost loops on 32 byte boundaries for
	      -tp barcelona.

       -Msecond_underscore -Mnosecond_underscore (default)
	      Add (don’t add) a second underscore to the name of a Fortran
	      global if its name already contains an underscore. This option
	      is useful for maintaining compatibility with g77, which adds a
	      second underscore to such symbols by default.

       -Mvarargs -Mnovarargs (default)
	      (x86-64 only) Generate code for calls made from Fortran to C
	      routines to use varargs calling sequence.

       -Mwritable-strings
	      Store string constants in the writable data segment.

       -m32   Compile for 32-bit target.

       -m64   Compile for 64-bit target.

       -mcmodel=small|medium
	      (AMD64 and IA32/EM64T only) Use the memory model that limits
	      objects to less than 2GB (small) or allows data sections to be
	      larger than 2GB (medium); implies -Mlarge_arrays

       -pc val
	      The IA-32 architecture implements a floating-point stack using 8
	      80-bit registers. Each register uses bits 0-63 as the
	      significand, bits 64-78 for the exponent, and bit 79 is the sign
	      bit. This 80-bit real format is the default format (called the
	      extended format).	 When values are loaded into the floating
	      point stack they are automatically converted into extended real
	      format.  The precision of the floating point stack can be
	      controlled, however, by setting the precision control bits (bits
	      8 and 9) of the floating control word appropriately. In this
	      way, the programmer can explicitly set the precision to standard
	      IEEE double using 64 bits, or to single precision using 32 bits.
	      The default precision setting is system dependent.  If you use
	      -pc to alter the precision setting for a routine, the main
	      program must be compiled with the same value for -pc.  The
	      command line option -pc val lets the programmer set the
	      compiler’s precision preference. Valid values for val are:
		  32 single precision
		  64 double precision
		  80 extended precision
	      Operations performed exclusively on the floating point stack
	      using extended precision, without storing into or loading from
	      memory, can cause problems with accumulated values within the
	      extra 16 bits of extended precision values.  This can lead to
	      answers, when rounded, that do not match expected results.

       -ta=target
	      Specify the type of the accelerator to which to target
	      accelerator regions; accepted values are

	      -ta=nvidia
		      Compile the accelerator regions for a CUDA-enabled
		      NVIDIA GPU.  Additional suboptions valid after
		      -ta=nvidia are:

		      analysis
			  Perform the analysis, but do not generate GPU code.

		      nofma
			  Do not generate fused multiply-add operations.

		      cc10
			  Generate code for a device with compute capability
			  1.0.

		      cc11
			  Generate code for a device with compute capability
			  1.1.

		      cc13
			  Generate code for a device with compute capability
			  1.3.

		      fastmath
			  Enable the fast math library, which includes faster,
			  but lower precision, implementations of certain math
			  and intrinsic functions.

		      keepbin
			  Keep the generated CUDA binary, with a .bin suffix.

		      keepptx
			  Keep the generated portable assembly files, with a
			  .ptx suffix.

		      maxregcount:n
			  Set the maximum number of registers to use in the
			  generated GPU code.

		      mul24
			  Use 24-bit multiplication for array subscripting.

		      time
			  Link with a profile library to collect simple timing
			  information for accelerator regions.

	      -ta=host
		      Compile the accelerator regions to run on the host
		      processor.

	      The default in the absence of the -ta flag is to ignore the
	      accelerator directives and compile for the host.	Multiple
	      targets are allowed, such as -ta=nvidia,host, in which case two
	      versions of each routine with accelerator regions are generated,
	      one to run on the NVIDIA GPU and one on the host; the selection
	      of which version to execute is made at run time.

       -tp target
	      Specify the type of the target processor; possibilities are

	      -tp amd64
		      AMD Opteron or Athlon-64 in 64-bit mode

	      -tp amd64e
		      AMD Opteron revision E or later, in 64-bit mode;
		      includes SSE3 instructions

	      -tp athlon
		      AMD Athlon processor

	      -tp athlonxp
		      AMD AthlonXP and AthlonMP processor

	      -tp barcelona -tp barcelona-32
		      AMD Barcelona processor in 32-bit mode

	      -tp barcelona-64
		      AMD Barcelona processor in 64-bit mode

	      -tp core2 -tp core2-32
		      Intel core2 processor in 32-bit mode

	      -tp core2-64
		      Intel core2 processor in 64-bit mode

	      -tp istanbul -tp istanbul-32
		      AMD Istanbul architecture Opteron processor, 32-bit mode

	      -tp istanbul-64
		      AMD Istanbul architecture Opteron processor, 64-bit mode

	      -tp k7  AMD Athlon processor

	      -tp k8-32
		      AMD Opteron or Athlon-64 in 32-bit mode

	      -tp k8-64
		      AMD Opteron or Athlon-64 in 64-bit mode

	      -tp k8-64e
		      AMD Opteron revision E or later, in 64-bit mode;
		      includes SSE3 instructions

	      -tp nehalem -tp nehalem-32
		      Intel Nehalem architecture Core processor, 32-bit mode

	      -tp nehalem-64
		      Intel Nehalem architecture Core processor, 64-bit mode

	      -tp p5  Pentium processor

	      -tp p6  Pentium Pro / Pentium II

	      -tp p7 -tp p7-32
		      Pentium 4 processor

	      -tp p7-64
		      IA32/EM64T processor in 64-bit mode

	      -tp penryn -tp penryn-32
		      Intel Penryn architecture Pentium processor, 32-bit mode

	      -tp penryn-64
		      Intel Penryn architecture Pentium processor, 64-bit mode

	      -tp piii
		      Pentium III processor

	      -tp piv Pentium 4 processor

	      -tp px -tp px-32
		      Blended code generation that will work on any
		      x86-compatible processor

	      -tp px-64
		      Blended code generation that will work on any 64-bit x86
		      processor

	      -tp shanghai -tp shanghai-32
		      AMD Shanghai architecture Opteron processor, 32-bit mode

	      -tp shanghai-64
		      AMD Shanghai architecture Opteron processor, 64-bit mode

	      -tp x64 Single binary where each procedure is optimized for both
		      the AMD Opteron and the Intel IA32/EM64T in 64-bit mode;
		      the selection of which optimized copy to execute is made
		      at run time depending on the machine executing the code.

	      The default in the absence of the -tp flag is to compile for the
	      type of CPU on which the compiler is running.

FILES
       a.out	   executable output file
       pgpf.out	   Profile feedback data file; see -Mpfi
       pgprof.out  PGPROF output file; see -Mprof
       file.a	   library of object files
       file.f	   fixed-format Fortran source file
       file.F	   fixed-format Fortran source file that requires
		   preprocessing
       file.f90	   free-format Fortran source file
       file.F90	   free-format Fortran source file that requires preprocessing
       file.f95	   free-format Fortran source file
       file.F95	   free-format Fortran source file that requires preprocessing
       file.for	   fixed-format Fortran source file
       file.fpp	   fixed-format Fortran source file that requires
		   preprocessing
       file.ipa	   InterProcedural Analyzer (IPA) file
       file.ipo	   InterProcedural Analyzer (IPA) file
       file.o	   object file
       file.s	   assembler source file
       .mypgf90rc  You may add custom switches or make other additions to
		   pgf90 by creating a file named .mypgf90rc in your home
		   directory.

       The installation of this version of the compiler resides in
       $PGI/target/10.3-0/; other versions may coexist in
       $PGI/target/release/.  $PGI is an environment variable that points to
       the root of the compiler installation directory. If $PGI is not set,
       the default is /usr/pgi.	 The target is one of the following:
       linux86	   for 32-bit IA32 Linux targets
       linux86-64  for 64-bit AMD64 or IA32/EM64T Linux targets

       The compiler installation subdirectories are:
       bin/	   compiler and tool executables and configuration (rc) files
       include/	   compiler include files
       lib/	   libraries and object files
       liblf/	   libraries and object files

SEE ALSO
       pgcc (1), pgCC (1), pgf77 (1), pghpf (1), pgprof (1), pgdbg (1), and
       the PGI User’s Guide.

DIAGNOSTICS
       The compiler produces information and error messages as it translates
       the input program. The linker and assembler may issue their own error
       messages.



				 February 2010			      pgf90(1)

Comments