Name
tau_compiler.sh — Instrumenting source files.
Synopsis
tau_compiler.sh  [
                  	-p
                  	profile
                        ] [-optVerbose
                          ] [-optMemDbg
                          ] [-optDetectMemoryLeaks
                          ] [-optPdtDir=dir
                          ] [-optPdtF95Opts=opts
                          ] [-optPdtF95Reset=opts
                          ] [-optPdtCOpts=opts
                          ] [-optPdtCReset=opts
                          ] [-optPdtCxxOpts=opts
                          ] [-optPdtCReset=opts
                          ] [-optPdtF90Parser=parser
                          ] [-optPdtCxxParser=parser
                          ] [-optGnuFortranParser
                          ] [-optGnuCleanscapeParser
                          ] [-optPdtUser=opts
                          ] [-optTauInstr=path
                          ] [-optContinueBeforeOMP
                          ] [-optIncludeMemory
                  ] [-optTrackUPCR
                  ] [-optTrackDMAPP
                  ] [-optTrackPthread
                  ] [-optNoTrackGOMP
                  ] [-optTrackMPCThread
                  ] [-optPreProcess
                  ] [-optCPP=path
                  ] [-optCPPOpts=options
                  ] [-optFPP=path
                  ] [-optFPPOpts=options
                  ] [-optCPPReset=options
                  ] [-optTauSelectFile=file
                          ] [
                                  -optPDBFile=file
                          ] [
                                  -optTau=opts
                          ] [
                                  -optCompile=opts
                          ] [
                                  -optTauDefs=opts
                          ] [
                                  -optTauIncludes=opts
                          ] [
                                  -optReset=opts
                          ] [
                                  -optLinking=opts
                                ] [
                     -optLinkReset=opts
                          ] [
                     -optLinkPreserveLib=opts
                          ] [
                                  -optTauCC=cc
                          ] [
                                  -optUseReturnFix
                          ] [
                                  -optLinkOnly
                          ] [
                                  -optOpariTool=path/opari
                          ] [
                                  -optOpariDir=path
                          ] [
                                  -optOpariOpts=opts
                          ] [
                                  -optOpariReset=opts
                          ] [
                                  -optOpariLibs=opts
                          ] [
                                  -optOpari2Tool=path/opari2
                          ] [
                                  -optOpari2ConfigTool=path/opari2_config
                          ] [
                                  -optOpari2Dir=path
                          ] [
                                  -optOpari2Opts=opts
                          ] [
                                  -optOpari2Reset=opts
                                ] [
                                  -optOpariNoInit
                          ] [
                                  -optNoMpi
                          ] [
                                  -optMpi
                          ] [
                                  -optNoRevert 
                          ] [
                                  -optRevert
                          ] [
                                  -optKeepFiles
                          ] [-optAppC
                          ] [-optAppCXX
                          ] [-optAppF90
                          ] [-optShared
                          ] [-optCompInst
                          ] [-optPDTInst
                          ] [-optDisableHeaderInst
                          ] {
                  	compiler
                        } [
                  	compiler_options
                        ] [
                                  -optTauWrapFile=filename
                          ]
               
Description
The TAU Compiler provides a simple way to automatically instrument an entire project. The TAU Compiler can be used on C, C++, fixed form Fortran, and free form Fortran.
Options
-optVerbose
                      Turn on verbose debugging messages.
                  
            
-optMemDbg
                      Enable TAU's runtime memory debugger.
                  
            
-optDetectMemoryLeaks
                Instructs TAU to detect any memory leaks in C/C++
               programs.TAU then tracks the source location of the memory leak as
               wellas the place in the callstack where the memory allocation
               wasmade.
               
            
-optPdtDir=<dir>
                      The PDT architecture directory. Typically
                          $(PDTDIR)/$(PDTARCHDIR).
                  
            
-optPdtF95Opts=<opts>
                      Options for Fortran parser in PDT (f95parse).
                  
            
-optPdtF95Reset=<opts>
                      Reset options to the Fortran parser to the given list.
                  
            
-optPdtCOpts=<opts>
                      Options for C parser in PDT (cparse). Typically
                          $(TAU_MPI_INCLUDE) $(TAU_INCLUDE) $(TAU_DEFS).
               
                  
            
-optPdtCReset=<opts>
                      Reset options to the C parser to the given list
                  
            
-optPdtCxxOpts=<opts>
               Options for C++ parser in PDT (cxxparse).  Typically
                          $(TAU_MPI_INCLUDE) $(TAU_INCLUDE) $(TAU_DEFS).
               
                  
            
-optPdtCxxReset=<opts>
                      Reset options to the C++ parser to the given list
                  
            
-optPdtF90Parser=<parser>
                      Specify a different Fortran parser. For e.g.,
                          f90parse instead of
                          f95parse.
                        
            
-optPdtCxxParser=<parser>
                      Specify a different C++ parser. For e.g.,
                          cxxparse401 instead of
                          cxxparse.
                  
            
-optGnuFortranParser=<parser>
                      Specify the GNU gfortran Fortran parser
               gfparseinstead of
               f95parse
               
                  
            
-optGnuCleanscapeParser
                      Uses the Cleanscape Fortran parser
               f95parseinstead of GNU's
               gfparse
               
                  
            
-optPdtUser=<opts>
                      Optional arguments for parsing source code.
                  
            
-optTauInstr=<path>
                      Specify location of tau_instrumentor. Typically
                          $(TAUROOT)/$(CONFIG_ARCH)/bin/tau_instrumentor.
                  
            
-optContinueBeforeOMP
               Insert a CONTINUE statement before !$OMP directives.
               
            
-optIncludeMemory
               Forinteral use only
               
            
-optTrackUPCR
               Adds tracking of the UPC runtime library.
               
            
-optTrackDMAPP
               Specify wrapping of Pthread library calls at link time.
               
            
-optTrackPthread
               Adds tracking of the UPC runtime library.
               
            
-optNoTrackGOMP
               Disable wrapping of GOMP library calls at link time
               
            
-optTrackMPCThread
               Specify wrapping of MPC Thread library calls at link time.
               
            
-optPreProcess
                      Preprocess the source code before parsing. Uses
               /usr/bin/cpp-P by default.
               
            
-optCPP=<path>
                      Specify an alternative preprocessor and pre-process the
               sources.
               
               
            
-optCPPOpts=<options>
               
                  		Specify additional options to the C pre-processor.
               
            
-optCPPReset=<options>
               
               ResetC preprocessor options to the specified list.
               
               
            
-optFPP=<path>
                      Specify an alternative preprocessor and pre-process for Fortran sources.
               
            
-optFPPOpts=<options>
               
                  		Specify additional options to the Fortran pre-processor.
                   
            
-optTauSelectFile=<file>
                      Specify selective instrumentation file for tau_instrumentor
                  
            
               
                          -optPDBFile=<file>
               
               
                          Specify PDB file for tau_instrumentor. Skips parsing stage.
               
                  
            
               
                          -optTau=<opts>
               
               
                          Specify options for tau_instrumentor.
               
                  
            
               
                          -optCompile=<opts>
               
               
                          Options passed to the compiler. Typically
                          
                                 $(TAU_MPI_INCLUDE) $(TAU_INCLUDE) $(TAU_DEFS)
                             .
               
                  
            
               
                          -optTauDefs=<opts>
               
               
                          Options passed to the compiler by TAU. Typically
               	
                             	$(TAU_DEFS)
                  	.
               
                  
            
               
                          -optTauIncludes=<opts>
               
               
                          Options passed to the compiler by TAU. Typically
               	
                  	$(TAU_MPI_INCLUDE) $(TAU_INCLUDE)
                  	.
               
                  
            
               
                          -optReset=<opts>
               
               
                          Reset options to the compiler to the given list
               
                  
            
               
                          -optLinking=<opts>
                          Options passed to the linker. Typically
                          $(TAU_MPI_FLIBS) $(TAU_LIBS) $(TAU_CXXLIBS)
                             .
                  
            
               
                          -optLinkReset=<opts>
                          Reset options to the linker to the given list.
                  
            
                          -optLinkPreserveLib=<opts>
                          Libraries which TAU should preserve the order of on the link line see "Moving these libraries to the end of the
               link line:". Default: none.
                  
            
                          -optTauCC=<cc>
                          Specifies the C compiler used by TAU.
                  
            
-optUseReturnFix
                 Specifies the use of a bug fix with ROSE parser using EDG v3.x
               
            
-optLinkOnly
                 Disable instrumentation during compilation, do link in the TAU libs
               
            
                          -optOpariTool=<path/opari>
                          Specifies the location of the Opari tool.
                  
            
                          -optOpariDir=<path>
                          Specifies the location of the Opari directory.
                  
            
                          -optOpariOpts=<opts>
                          Specifies optional arguments to the Opari tool.
                  
            
                          -optOpariNoInit
                         Do not initlize the POMP2 regions.
                  
            
                          -optOpariReset=<opts>
                          Resets options passed to the Opari tool.
                        
            
                          -optOpariLibs=<>
                         Specifies the libraries that have POMP2 regions. (Overrides optOpariNoInit).
                  
            
                          -optOpari2Tool=<path to opari2>
                         	Specifies the location of the Opari tool.
                         
            
                               -optOpari2ConfigTool=<path/opari2-config>
                               Specifies the location of the Opari tool configuration file
                   
            
                             -optOpari2Opts=<opts>
                             Specifies optional arguments to the Opari tool.
                   
            
                             -optOpari2Reset=<opts>
                             Resets options passed to the Opari tool.
                    
            
                             -optOpari2Dirs=<opts>
                             Specifies the location of the Opari directory
                   
            
                          -optNoMpi
                          Removes -l*mpi*
                          libraries during linking (default).
                  
            
                          -optMpi
                          Does not remove
                          -l*mpi*
                          libraries during linking.
                  
            
                          -optNoRevert
                          Exit on error. THIS IS CRAZY Does not revert to the original compilation
               	rule on error.
                  
            
                          -optRevert
                      Revert to the original compilation rule on error (default).
                  
            
                          -optKeepFiles
                          Does not remove intermediate
                          .pdb and
                          .inst.* files.
                        
            
                          -optReuseFiles
               		Reuses a pre-instrumented file and preserves them.
                  
            
-optAppCC
                      Sets the failsafe C compiler.
                    
            
-optAppCXX
                      Sets the failsafe C++ compiler.
                    
            
-optAppF90
                      Sets the failsafe F90 compiler
                  
            
-optShared
                      Use shared library version of TAU
                    
            
-optCompInst
               
                      Use compiler-based instrumentation
               
                  
            
-optNoCompInst
               
                       Do not revert to compiler instrumentation if source instrumentation fails.
                  
            
-optPDTInst
                      Use PDT-based instrumentation
                  
            
-optHeaderInst
                     Enable instrumentation of headers
                  
            
-optDisableHeaderInst
               
                      Disable instrumentation of headers
               
                  
            
-optTrackIO
                       Specify wrapping of POSIX I/O calls at link time.
               
                     
            
-optMICOffload
                     Links code for Intel MIC offloading, requires both host and MIC TAU libraries
                  
            
-optWrappersDir=""
               
                     Specify the location of the link wrappers directory.
                  
            
-optTauUseCXXForC
                      Specifies the use of a C++ compiler for compiling C code
                  
            
-optTauWrapFile=<filename>
               
                      Specify path to the link_options.tau file generated by tau_wrap
               
                  
            
-optFixHashIf