User Guide

Red Hat Developer Toolset is a Red Hat offering for developers on the Red Hat Enterprise Linux platform. It provides a complete set of development and performance analysis tools that can be installed and used on multiple versions of Red Hat Enterprise Linux. Executables built with the Red Hat Developer Toolset toolchain can then also be deployed and run on multiple versions of Red Hat Enterprise Linux. For detailed compatibility information, see Section 1.3, “Compatibility”.

Red Hat Developer Toolset does not replace the default system tools provided with Red Hat Enterprise Linux 7 when installed on those platforms. Instead, a parallel set of developer tools provides an alternative, newer version of those tools for optional use by developers. The default compiler and debugger, for example, remain those provided by the base Red Hat Enterprise Linux system.

What Is New in Red Hat Developer Toolset 10.1

Since Red Hat Developer Toolset 4.1, the Red Hat Developer Toolset content is also available in the ISO format together with the rest of Red Hat Software Collections content at https://access.redhat.com/downloads, specifically for Server and Workstation. Note that packages that require the Optional channel, which are discussed in Section 1.5.3, “Installing Optional Packages”, cannot be installed from the ISO image.

Red Hat Developer Toolset differs from "Technology Preview" compiler releases previously supplied in Red Hat Enterprise Linux in two important respects:

Important bug fixes and security errata are issued to Red Hat Developer Toolset subscribers in a similar manner to Red Hat Enterprise Linux for two years from the release of each major version release. A new major version of Red Hat Developer Toolset is released annually, providing significant updates for existing components and adding major new components. A single minor release, issued six months after each new major version release, provides a smaller update of bug fixes, security errata, and new minor components.

Additionally, the Red Hat Enterprise Linux Application Compatibility Specification also applies to Red Hat Developer Toolset (subject to some constraints on the use of newer C++11 language features, detailed in Section 2.2.4, “C++ Compatibility”).

Red Hat Developer Toolset 10.1 brings the following changes:

For a full list of changes and features introduced in this release, see Appendix B, Changes in Version 10.1.

Red Hat Developer Toolset 10.1 is available for Red Hat Enterprise Linux 7 for a number of architectures.

For ABI compatibility information, see Section 2.2.4, “C++ Compatibility”.

Architecture support

Red Hat Developer Toolset is available on the following architectures:

Red Hat Developer Toolset is an offering distributed as a part of Red Hat Software Collections.

This content set is available to customers with Red Hat Enterprise Linux 7 subscriptions listed at https://access.redhat.com/solutions/472793.

Enable Red Hat Developer Toolset by using Red Hat Subscription Management. For information on how to register your system with this subscription management service, see the Red Hat Subscription Management collection of guides.

Red Hat Developer Toolset is distributed as a collection of RPM packages that can be installed, updated, uninstalled, and inspected by using the standard package management tools that are included in Red Hat Enterprise Linux. Note that a valid subscription that provides access to the Red Hat Software Collections content set is required in order to install Red Hat Developer Toolset on your system. For detailed instructions on how to associate your system with an appropriate subscription and get access to Red Hat Developer Toolset, see Section 1.4, “Getting Access to Red Hat Developer Toolset”.

yum install devtoolset-10

# yum install devtoolset-10

yum install package_name

# yum install package_name

yum install devtoolset-10-toolchain

# yum install devtoolset-10-toolchain

yum list available devtoolset-10-\*

$ yum list available devtoolset-10-\*

yum install package_name

# yum install package_name

yum install devtoolset-10-gdb-gdbserver devtoolset-10-gdb-doc

# yum install devtoolset-10-gdb-gdbserver devtoolset-10-gdb-doc

debuginfo-install package_name

# debuginfo-install package_name

debuginfo-install devtoolset-10-dwz

# debuginfo-install devtoolset-10-dwz

To uninstall Red Hat Developer Toolset packages from your system:

yum remove devtoolset-10\* libasan libatomic libcilkrts libitm liblsan libtsan libubsan

# yum remove devtoolset-10\* libasan libatomic libcilkrts libitm liblsan libtsan libubsan

This removes the GNU Compiler Collection, GNU Debugger, binutils, and other packages that are a part of Red Hat Developer Toolset from the system.

Note that the uninstallation of the tools provided by Red Hat Developer Toolset does not affect the Red Hat Enterprise Linux system versions of these tools.

Docker-formatted container images can be used to run Red Hat Developer Toolset components inside virtual software containers, thus isolating them from the host system and allowing for their rapid deployment. For detailed description of the Red Hat Developer Toolset docker-formatted container images and Red Hat Developer Toolset Dockerfiles, see Using Red Hat Software Collections Container Images.

For more information about Red Hat Developer Toolset and Red Hat Enterprise Linux, see the resources listed below.

Online Documentation

See Also

scl enable devtoolset-10 'gcc -lsomelib objfile.o'

$ scl enable devtoolset-10 'gcc -lsomelib objfile.o'

Using a library from the Red Hat Developer Toolset in this manner results in the linker error message undefined reference to symbol. To prevent this problem, follow the standard linking practice, and specify the option adding the library after the options specifying the object files:

scl enable devtoolset-10 'gcc objfile.o -lsomelib'

$ scl enable devtoolset-10 'gcc objfile.o -lsomelib'

Note that this recommendation also applies when using the base Red Hat Enterprise Linux version of GCC.

For more information about the GNU Compiler Collections and its features, see the resources listed below.

Installed Documentation

Online Documentation

See Also

In Red Hat Developer Toolset, GNU make is provided by the devtoolset-10-make package and is automatically installed with devtoolset-10-toolchain as described in Section 1.5, “Installing Red Hat Developer Toolset”.

To build a program without using a Makefile, run the make tool as follows:

scl enable devtoolset-10 'make source_file_without_extension'

$ scl enable devtoolset-10 'make source_file_without_extension'

This command makes use of implicit rules that are defined for a number of programming languages, including C, C++, and Fortran. The result is a binary file named source_file_without_extension in the current working directory.

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset make as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which make

$ which make

make -v

$ make -v

#include <stdio.h>

int main(int argc, char *argv[]) {
  printf("Hello, World!\n");
  return 0;
}

#include <stdio.h>

int main(int argc, char *argv[]) {
  printf("Hello, World!\n");
  return 0;
}

scl enable devtoolset-10 'make hello'

$ scl enable devtoolset-10 'make hello'
cc     hello.c   -o hello

To build complex programs that consist of a number of source files, make uses configuration files called Makefiles that control how to compile the components of a program and build the final executable. Makefiles can also contain instructions for cleaning the working directory, installing and uninstalling program files, and other operations.

make automatically uses files named GNUmakefile, makefile, or Makefile in the current directory. To specify another file name, use the -f option:

make -f make_file

$ make -f make_file

Describing the details of Makefile syntax is beyond the scope of this guide. See GNU make, the upstream GNU make manual, which provides an in-depth description of the GNU make utility, Makefile syntax, and their usage.

The full make manual is also available in the Texinfo format as a part of your installation. To view this manual:

scl enable devtoolset-10 'info make'

$ scl enable devtoolset-10 'info make'

CC=gcc
CFLAGS=-c -Wall
SOURCE=hello.c
OBJ=$(SOURCE:.c=.o)
EXE=hello

all: $(SOURCE) $(EXE)

$(EXE): $(OBJ)
        $(CC) $(OBJ) -o $@

.o: .c
        $(CC) $(CFLAGS) $< -o $@

clean:
        rm -rf $(OBJ) $(EXE)

CC=gcc
CFLAGS=-c -Wall
SOURCE=hello.c
OBJ=$(SOURCE:.c=.o)
EXE=hello

all: $(SOURCE) $(EXE)

$(EXE): $(OBJ)
        $(CC) $(OBJ) -o $@

.o: .c
        $(CC) $(CFLAGS) $< -o $@

clean:
        rm -rf $(OBJ) $(EXE)

scl enable devtoolset-10 'make'

$ scl enable devtoolset-10 'make'
gcc -c -Wall hello.c -o hello.o
gcc hello.o -o hello

scl enable devtoolset-10 'make clean'

$ scl enable devtoolset-10 'make clean'
rm -rf hello.o hello

For more information about the GNU make tool and its features, see the resources listed below.

Installed Documentation

Online Documentation

See Also

In Red Hat Developer Toolset, binutils are provided by the devtoolset-10-binutils package and are automatically installed with devtoolset-10-toolchain as described in Section 1.5, “Installing Red Hat Developer Toolset”.

To produce an object file from an assembly language program, run the as tool as follows:

scl enable devtoolset-10 'as option ... -o object_file source_file'

$ scl enable devtoolset-10 'as option ... -o object_file source_file'

This creates an object file named object_file in the current working directory.

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset as as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which as

$ which as

as -v

$ as -v

To create an executable binary file or a library from object files, run the ld tool as follows:

scl enable devtoolset-10 'ld option ... -o output_file object_file ...'

$ scl enable devtoolset-10 'ld option ... -o output_file object_file ...'

This creates a binary file named output_file in the current working directory. If the -o option is omitted, the compiler creates a file named a.out by default.

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset ld as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which ld

$ which ld

ld -v

$ ld -v

The binutils provide many binary tools other than a linker and an assembler. For a complete list of these tools, see Table 4.1, “Tools Included in binutils for Red Hat Developer Toolset”.

To execute any of the tools that are a part of binutils:

scl enable devtoolset-10 'tool option ... file_name'

$ scl enable devtoolset-10 'tool option ... file_name'

See Table 4.1, “Tools Included in binutils for Red Hat Developer Toolset” for a list of tools that are distributed with binutils. For example, to use the objdump tool to inspect an object file:

scl enable devtoolset-10 'objdump option ... object_file'

$ scl enable devtoolset-10 'objdump option ... object_file'

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset binary tools as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which objdump

$ which objdump

objdump -v

$ objdump -v

scl enable devtoolset-10 'ld -lsomelib objfile.o'

$ scl enable devtoolset-10 'ld -lsomelib objfile.o'

Using a library from the Red Hat Developer Toolset in this manner results in the linker error message undefined reference to symbol. To prevent this problem, follow the standard linking practice, and specify the option adding the library after the options specifying the object files:

scl enable devtoolset-10 'ld objfile.o -lsomelib'

$ scl enable devtoolset-10 'ld objfile.o -lsomelib'

Note that this recommendation also applies when using the base Red Hat Enterprise Linux version of binutils.

For more information about binutils, see the resources listed below.

Installed Documentation

Online Documentation

See Also

In Red Hat Developer Toolset, elfutils is provided by the devtoolset-10-elfutils package and is automatically installed with devtoolset-10-toolchain as described in Section 1.5, “Installing Red Hat Developer Toolset”.

To execute any of the tools that are part of elfutils, run the tool as follows:

scl enable devtoolset-10 'tool option ... file_name'

$ scl enable devtoolset-10 'tool option ... file_name'

See Table 5.1, “Tools Included in elfutils for Red Hat Developer Toolset” for a list of tools that are distributed with elfutils. For example, to use the eu-objdump tool to inspect an object file:

scl enable devtoolset-10 'eu-objdump option ... object_file'

$ scl enable devtoolset-10 'eu-objdump option ... object_file'

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset binary tools as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which eu-objdump

$ which eu-objdump

eu-objdump -V

$ eu-objdump -V

For more information about elfutils, see the resources listed below.

See Also

In Red Hat Developer Toolset, the dwz utility is provided by the devtoolset-10-dwz package and is automatically installed with devtoolset-10-toolchain as described in Section 1.5, “Installing Red Hat Developer Toolset”.

To optimize DWARF debugging information in a binary file, run the dwz tool as follows:

scl enable devtoolset-10 'dwz option... file_name'

$ scl enable devtoolset-10 'dwz option... file_name'

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset dwz as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which dwz

$ which dwz

dwz -v

$ dwz -v

For more information about dwz and its features, see the resources listed below.

Installed Documentation

See Also

In Red Hat Developer Toolset, the annobin plugin and the annocheck program are provided by the devtoolset-10-gcc package and are installed as described in Section 1.5.3, “Installing Optional Packages”.

To pass options to the annobin plugin with gcc, use:

scl enable devtoolset-10 'gcc -fplugin=annobin -fplugin-arg-annobin-option file-name'

$ scl enable devtoolset-10 'gcc -fplugin=annobin -fplugin-arg-annobin-option file-name'

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset as as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which annobin

$ which annobin

To scan files, directories or RPM packages with the annocheck program:

scl enable devtoolset-10 'annocheck file-name'

$ scl enable devtoolset-10 'annocheck file-name'

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset as as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which annocheck

$ which annocheck

annocheck --version

$ annocheck --version

For more information about annocheck, annobin and its features, see the resources listed below.

Installed Documentation

In Red Hat Developer Toolset, the GNU Debugger is provided by the devtoolset-10-gdb package and is automatically installed with devtoolset-10-toolchain as described in Section 1.5, “Installing Red Hat Developer Toolset”.

Compiling Programs with Debugging Information

To compile a C program with debugging information that can be read by the GNU Debugger, make sure the gcc compiler is run with the -g option:

scl enable devtoolset-10 'gcc -g -o output_file input_file...'

$ scl enable devtoolset-10 'gcc -g -o output_file input_file...'

Similarly, to compile a C++ program with debugging information:

scl enable devtoolset-10 'g++ -g -o output_file input_file...'

$ scl enable devtoolset-10 'g++ -g -o output_file input_file...'

#include <stdio.h>
#include <limits.h>

int main (int argc, char *argv[]) {
  unsigned long int a = 0;
  unsigned long int b = 1;
  unsigned long int sum;

  while (b < LONG_MAX) {
    printf("%ld ", b);
    sum = a + b;
    a = b;
    b = sum;
  }

  return 0;
}

#include <stdio.h>
#include <limits.h>

int main (int argc, char *argv[]) {
  unsigned long int a = 0;
  unsigned long int b = 1;
  unsigned long int sum;

  while (b < LONG_MAX) {
    printf("%ld ", b);
    sum = a + b;
    a = b;
    b = sum;
  }

  return 0;
}

scl enable devtoolset-10 'gcc -g -o fibonacci fibonacci.c'

$ scl enable devtoolset-10 'gcc -g -o fibonacci fibonacci.c'

Installing Debugging Information for Existing Packages

To install debugging information for a package that is already installed on the system:

debuginfo-install package_name

# debuginfo-install package_name

Note that the yum-utils package must be installed for the debuginfo-install utility to be available on your system.

debuginfo-install glibc

# debuginfo-install glibc
Loaded plugins: product-id, refresh-packagekit, subscription-manager
--> Running transaction check
---> Package glibc-debuginfo.x86_64 0:2.17-105.el7 will be installed
...

To run the GNU Debugger on a program you want to debug:

scl enable devtoolset-10 'gdb file_name'

$ scl enable devtoolset-10 'gdb file_name'

This starts the gdb debugger in interactive mode and displays the default prompt, (gdb). To quit the debugging session and return to the shell prompt, run the following command at any time:

(gdb) quit

(gdb) quit

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset gdb as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which gdb

$ which gdb

gdb -v

$ gdb -v

scl enable devtoolset-10 'gdb fibonacci'

$ scl enable devtoolset-10 'gdb fibonacci'
GNU gdb (GDB) Red Hat Enterprise Linux 8.2-2.el7
Copyright (C) 2017 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-redhat-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from fibonacci...done.
(gdb)

To view the source code of the program you are debugging:

(gdb) list

(gdb) list

Before you start the execution of the program you are debugging, gdb displays the first ten lines of the source code, and any subsequent use of this command lists another ten lines. Once you start the execution, gdb displays the lines that are surrounding the line on which the execution stops, typically when you set a breakpoint.

You can also display the code that is surrounding a particular line:

(gdb) list file_name:line_number

(gdb) list file_name:line_number

Similarly, to display the code that is surrounding the beginning of a particular function:

(gdb) list file_name:function_name

(gdb) list file_name:function_name

Note that you can change the number of lines the list command displays:

(gdb) set listsize number

(gdb) set listsize number

(gdb) set listsize 20

(gdb) set listsize 20

(gdb) list
1       #include <stdio.h>
2       #include <limits.h>
3
4       int main (int argc, char *argv[]) {
5         unsigned long int a = 0;
6         unsigned long int b = 1;
7         unsigned long int sum;
8
9         while (b < LONG_MAX) {
10          printf("%ld ", b);
11          sum = a + b;
12          a = b;
13          b = sum;
14        }
15
16        return 0;
17      }

(gdb) list
1       #include <stdio.h>
2       #include <limits.h>
3
4       int main (int argc, char *argv[]) {
5         unsigned long int a = 0;
6         unsigned long int b = 1;
7         unsigned long int sum;
8
9         while (b < LONG_MAX) {
10          printf("%ld ", b);
11          sum = a + b;
12          a = b;
13          b = sum;
14        }
15
16        return 0;
17      }

Setting a New Breakpoint

To set a new breakpoint at a certain line:

(gdb) break file_name:line_number

(gdb) break file_name:line_number

You can also set a breakpoint on a certain function:

(gdb) break file_name:function_name

(gdb) break file_name:function_name

(gdb) break 10
Breakpoint 1 at 0x4004e5: file fibonacci.c, line 10.

(gdb) break 10
Breakpoint 1 at 0x4004e5: file fibonacci.c, line 10.

Listing Breakpoints

To display a list of currently set breakpoints:

(gdb) info breakpoints

(gdb) info breakpoints

(gdb) info breakpoints
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x00000000004004e5 in main at fibonacci.c:10

(gdb) info breakpoints
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x00000000004004e5 in main at fibonacci.c:10

Deleting Existing Breakpoints

To delete a breakpoint that is set at a certain line:

(gdb) clear line_number

(gdb) clear line_number

Similarly, to delete a breakpoint that is set on a certain function:

(gdb) clear function_name

(gdb) clear function_name

(gdb) break 7
Breakpoint 2 at 0x4004e3: file fibonacci.c, line 7.

(gdb) break 7
Breakpoint 2 at 0x4004e3: file fibonacci.c, line 7.

(gdb) clear 7
Deleted breakpoint 2

(gdb) clear 7
Deleted breakpoint 2

To start an execution of the program you are debugging:

(gdb) run

(gdb) run

If the program accepts any command line arguments, you can provide them as arguments to the run command:

(gdb) run argument…

(gdb) run argument…

The execution stops when the first breakpoint (if any) is reached, when an error occurs, or when the program terminates.

(gdb) run
Starting program: /home/john/fibonacci

Breakpoint 1, main (argc=1, argv=0x7fffffffe4d8) at fibonacci.c:10
10          printf("%ld ", b);

(gdb) run
Starting program: /home/john/fibonacci

Breakpoint 1, main (argc=1, argv=0x7fffffffe4d8) at fibonacci.c:10
10          printf("%ld ", b);

The gdb utility allows you to display the value of almost anything that is relevant to the program, from a variable of any complexity to a valid expression or even a library function. However, the most common task is to display the value of a variable.

To display the current value of a certain variable:

(gdb) print variable_name

(gdb) print variable_name

(gdb) print a
$1 = 0
(gdb) print b
$2 = 1

(gdb) print a
$1 = 0
(gdb) print b
$2 = 1

To resume the execution of the program you are debugging after it reached a breakpoint:

(gdb) continue

(gdb) continue

The execution stops again when another breakpoint is reached. To skip a certain number of breakpoints (typically when you are debugging a loop):

(gdb) continue number

(gdb) continue number

The gdb utility also allows you to stop the execution after executing a single line of code:

(gdb) step

(gdb) step

Finally, you can execute a certain number of lines:

(gdb) step number

(gdb) step number

(gdb) continue
Continuing.

Breakpoint 1, main (argc=1, argv=0x7fffffffe4d8) at fibonacci.c:10
10          printf("%ld ", b);

(gdb) continue
Continuing.

Breakpoint 1, main (argc=1, argv=0x7fffffffe4d8) at fibonacci.c:10
10          printf("%ld ", b);

(gdb) step 3
13          b = sum;

(gdb) step 3
13          b = sum;

(gdb) print sum
$3 = 2

(gdb) print sum
$3 = 2

For more information about the GNU Debugger and all its features, see the resources listed below.

Installed Documentation

Installing the devtoolset-10-gdb-doc package provides the following documentation in HTML and PDF formats in the /opt/rh/devtoolset-10/root/usr/share/doc/devtoolset-10-gdb-doc-9.2 directory:

Online Documentation

See Also

In Red Hat Enterprise Linux, the strace utility is provided by the devtoolset-10-strace package and is automatically installed with devtoolset-10-toolchain as described in Section 1.5, “Installing Red Hat Developer Toolset”.

To run the strace utility on a program you want to analyze:

scl enable devtoolset-10 'strace program argument...'

$ scl enable devtoolset-10 'strace program argument...'

Replace program with the name of the program you want to analyze, and argument with any command line options and arguments you want to supply to this program. Alternatively, you can run the utility on an already running process by using the -p command line option followed by the process ID:

scl enable devtoolset-10 'strace -p process_id'

$ scl enable devtoolset-10 'strace -p process_id'

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset strace as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which strace

$ which strace

strace -V

$ strace -V

scl enable devtoolset-10 'strace -o file_name program argument...'

$ scl enable devtoolset-10 'strace -o file_name program argument...'

scl enable devtoolset-10 'strace -o fibonacci.log ./fibonacci 20'

$ scl enable devtoolset-10 'strace -o fibonacci.log ./fibonacci 20'
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

scl enable devtoolset-10 'strace -e expression program argument...'

$ scl enable devtoolset-10 'strace -e expression program argument...'

scl enable devtoolset-10 'strace -e mmap,munmap ./employee'

$ scl enable devtoolset-10 'strace -e mmap,munmap ./employee'
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f896c744000
mmap(NULL, 61239, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f896c735000
mmap(0x3146a00000, 3745960, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x3146a00000
mmap(0x3146d89000, 20480, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x189000) = 0x3146d89000
mmap(0x3146d8e000, 18600, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x3146d8e000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f896c734000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f896c733000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f896c732000
munmap(0x7f896c735000, 61239)           = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f896c743000
John,john@example.comDoe,
+++ exited with 0 +++

scl enable devtoolset-10 'strace -t program argument...'

$ scl enable devtoolset-10 'strace -t program argument...'

scl enable devtoolset-10 'strace -tt program argument...'

$ scl enable devtoolset-10 'strace -tt program argument...'

scl enable devtoolset-10 'strace -r program argument...'

$ scl enable devtoolset-10 'strace -r program argument...'

scl enable devtoolset-10 'strace -tt pwd'

$ scl enable devtoolset-10 'strace -tt pwd'
19:43:28.011815 execve("./pwd", ["./pwd"], [/* 36 vars */]) = 0
19:43:28.012128 brk(0)                  = 0xcd3000
19:43:28.012174 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fc869cb0000
19:43:28.012427 open("/etc/ld.so.cache", O_RDONLY) = 3
19:43:28.012446 fstat(3, {st_mode=S_IFREG|0644, st_size=61239, ...}) = 0
19:43:28.012464 mmap(NULL, 61239, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fc869ca1000
19:43:28.012483 close(3)                = 0
...
19:43:28.013410 +++ exited with 0 +++

scl enable devtoolset-10 'strace -c program argument...'

$ scl enable devtoolset-10 'strace -c program argument...'

scl enable devtoolset-10 'strace -c lsblk > /dev/null'

$ scl enable devtoolset-10 'strace -c lsblk > /dev/null'
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 80.88    0.000055           1       106        16 open
 19.12    0.000013           0       140           munmap
  0.00    0.000000           0       148           read
  0.00    0.000000           0         1           write
  0.00    0.000000           0       258           close
  0.00    0.000000           0        37         2 stat
...
------ ----------- ----------- --------- --------- ----------------
100.00    0.000068                  1790        35 total

scl enable devtoolset-10 'strace -e fault=syscall program argument...'

$ scl enable devtoolset-10 'strace -e fault=syscall program argument...'

scl enable devtoolset-10 'strace -e inject=syscall:error=error-type program argument'
scl enable devtoolset-10 'strace -e inject=syscall:retval=return-value program argument'

$ scl enable devtoolset-10 'strace -e inject=syscall:error=error-type program argument'
$ scl enable devtoolset-10 'strace -e inject=syscall:retval=return-value program argument'

scl enable devtoolset-10 'strace -e fault=mmap:error=EPERM lsblk > /dev/null'

$ scl enable devtoolset-10 'strace -e fault=mmap:error=EPERM lsblk > /dev/null'
execve("/usr/bin/lsblk", ["lsblk"], 0x7fff1c0e02a0 /* 54 vars */) = 0
brk(NULL)                               = 0x55d9e8b43000
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = -1 EPERM (Operation not permitted) (INJECTED)
writev(2, [{iov_base="lsblk", iov_len=5}, {iov_base=": ", iov_len=2}, {iov_base="error while loading shared libra"..., iov_len=36}, {iov_base=": ", iov_len=2}, {iov_base="", iov_len=0}, {iov_base="", iov_len=0}, {iov_base="cannot create cache for search p"..., iov_len=35}, {iov_base=": ", iov_len=2}, {iov_base="Cannot allocate memory", iov_len=22}, {iov_base="\n", iov_len=1}], 10lsblk: error while loading shared libraries: cannot create cache for search path: Cannot allocate memory
) = 105
exit_group(127)                         = ?
+++ exited with 127 +++

For more information about strace and its features, see the resources listed below.

Installed Documentation

See Also

In Red Hat Enterprise Linux, the ltrace utility is provided by the devtoolset-10-ltrace package and is automatically installed with devtoolset-10-toolchain as described in Section 1.5, “Installing Red Hat Developer Toolset”.

To run the ltrace utility on a program you want to analyze:

scl enable devtoolset-10 'ltrace program argument...'

$ scl enable devtoolset-10 'ltrace program argument...'

Replace program with the name of the program you want to analyze, and argument with any command line options and arguments you want to supply to this program. Alternatively, you can run the utility on an already running process by using the -p command line option followed by the process ID:

scl enable devtoolset-10 'ltrace -p process_id'

$ scl enable devtoolset-10 'ltrace -p process_id'

Note that you can execute any command using the scl utility, causing it to be run with the Red Hat Developer Toolset binaries used in preference to the Red Hat Enterprise Linux system equivalent. This allows you to run a shell session with Red Hat Developer Toolset ltrace as default:

scl enable devtoolset-10 'bash'

$ scl enable devtoolset-10 'bash'

which ltrace

$ which ltrace

ltrace -V

$ ltrace -V

scl enable devtoolset-10 'ltrace -o file_name program argument...'

$ scl enable devtoolset-10 'ltrace -o file_name program argument...'

scl enable devtoolset-10 'ltrace -o fibonacci.log ./fibonacci 20'

$ scl enable devtoolset-10 'ltrace -o fibonacci.log ./fibonacci 20'
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

scl enable devtoolset-10 'ltrace -e expression program argument...'

$ scl enable devtoolset-10 'ltrace -e expression program argument...'

scl enable devtoolset-10 'ltrace -e malloc+free-@libc.so* program'

$ scl enable devtoolset-10 'ltrace -e malloc+free-@libc.so* program'

scl enable devtoolset-10 'ltrace -e opendir+readdir+closedir ls'

$ scl enable devtoolset-10 'ltrace -e opendir+readdir+closedir ls'
ls->opendir(".")     = { 3 }
ls->readdir({ 3 })   = { 61533, "." }
ls->readdir({ 3 })   = { 131, ".." }
ls->readdir({ 3 })   = { 67185100, "BUILDROOT" }
ls->readdir({ 3 })   = { 202390772, "SOURCES" }
ls->readdir({ 3 })   = { 60249, "SPECS" }
ls->readdir({ 3 })   = { 67130110, "BUILD" }
ls->readdir({ 3 })   = { 136599168, "RPMS" }
ls->readdir({ 3 })   = { 202383274, "SRPMS" }
ls->readdir({ 3 })   = nil
ls->closedir({ 3 })  = 0
BUILD  BUILDROOT  RPMS  SOURCES  SPECS  SRPMS
+++ exited (status 0) +++