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 12.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 12.1 brings the following changes:

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

Red Hat Developer Toolset 12.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-12

# yum install package_name

# yum install devtoolset-12-toolchain

$ yum list available devtoolset-12-\*

# yum install package_name

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

# debuginfo-install package_name

# debuginfo-install devtoolset-12-dwz

To uninstall Red Hat Developer Toolset packages from your system:

# yum remove devtoolset-12\* 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-12 '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-12 '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-12-make package and is automatically installed with devtoolset-12-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-12 '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-12 'bash'

$ which make

$ make -v

#include <stdio.h>

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

$ scl enable devtoolset-12 '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

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-12 '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)

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

$ scl enable devtoolset-12 '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-12-binutils package and are automatically installed with devtoolset-12-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-12 '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-12 'bash'

$ which as

$ as -v

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

$ scl enable devtoolset-12 '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-12 'bash'

$ which ld

$ 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-12 '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-12 '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-12 'bash'

$ which objdump

$ objdump -v

$ scl enable devtoolset-12 '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-12 '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-12-elfutils package and is automatically installed with devtoolset-12-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-12 '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-12 '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-12 'bash'

$ which eu-objdump

$ 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-12-dwz package and is automatically installed with devtoolset-12-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-12 '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-12 'bash'

$ which dwz

$ 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 annockeck program are provided by the devtoolset-12-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-12 '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-12 'bash'

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

$ scl enable devtoolset-12 '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-12 'bash'

$ which annocheck

$ 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-12-gdb package and is automatically installed with devtoolset-12-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-12 'gcc -g -o output_file input_file...'

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

$ scl enable devtoolset-12 '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;
}

$ scl enable devtoolset-12 '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

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

# 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-12 '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

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-12 'bash'

$ which gdb

$ gdb -v

$ scl enable devtoolset-12 '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

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

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

(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 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      }

Setting a New Breakpoint

To set a new breakpoint at a certain line:

(gdb) break file_name:line_number

You can also set a breakpoint on a certain function:

(gdb) break file_name:function_name

(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
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

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

(gdb) clear function_name

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

(gdb) clear 7
Deleted breakpoint 2

To start an execution of the program you are debugging:

(gdb) run

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

(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);

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 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

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

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

(gdb) step

Finally, you can execute a certain number of lines:

(gdb) step number

(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) 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-12-gdb-doc package provides the following documentation in HTML and PDF formats in the /opt/rh/devtoolset-12/root/usr/share/doc/devtoolset-12-gdb-doc-11.2 directory:

Online Documentation

See Also

In Red Hat Enterprise Linux, the strace utility is provided by the devtoolset-12-strace package and is automatically installed with devtoolset-12-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-12 '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-12 '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-12 'bash'

$ which strace

$ strace -V

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

$ scl enable devtoolset-12 '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-12 'strace -e expression program argument...'

$ scl enable devtoolset-12 '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-12 'strace -t program argument...'

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

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

$ scl enable devtoolset-12 '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-12 'strace -c program argument...'

$ scl enable devtoolset-12 '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-12 'strace -e fault=syscall program argument...'

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

$ scl enable devtoolset-12 '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-12-ltrace package and is automatically installed with devtoolset-12-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-12 '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-12 '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-12 'bash'

$ which ltrace

$ ltrace -V

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

$ scl enable devtoolset-12 '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-12 'ltrace -e expression program argument...'

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

$ scl enable devtoolset-12 '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) +++

$ scl enable devtoolset-12 'ltrace -t program argument...'

$ scl enable devtoolset-12 'ltrace -tt program argument...'

$ scl enable devtoolset-12 'ltrace -r program argument...'

$ scl enable devtoolset-12 'ltrace -tt pwd'
13:27:19.631371 __libc_start_main([ "pwd" ] <unfinished ...>
13:27:19.632240 getenv("POSIXLY_CORRECT")                        = nil
13:27:19.632520 strrchr("pwd", '/')                              = nil
13:27:19.632786 setlocale(LC_ALL, "")                            = "en_US.UTF-8"
13:27:19.633220 bindtextdomain("coreutils", "/usr/share/locale") = "/usr/share/locale"
13:27:19.633471 textdomain("coreutils")                          = "coreutils"
(...)
13:27:19.637110  exited (status 0)

$ scl enable devtoolset-12 'ltrace -c program argument...'

$ scl enable devtoolset-12 'ltrace -c lsblk > /dev/null'
% time     seconds  usecs/call     calls      function
------ ----------- ----------- --------- --------------------
 53.60    0.261644      261644         1 __libc_start_main
  4.48    0.021848          58       374 mbrtowc
  4.41    0.021524          57       374 wcwidth
  4.39    0.021409          57       374 __ctype_get_mb_cur_max
  4.38    0.021359          57       374 iswprint
  4.06    0.019838          74       266 readdir64
  3.21    0.015652          69       224 strlen
...
------ ----------- ----------- --------- --------------------
100.00    0.488135                  3482 total

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

Installed Documentation

Online Documentation

See Also

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

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

$ scl enable devtoolset-12 'memstomp program argument...'

To immediately terminate the analyzed program when a problem is detected, run the utility with the --kill (or -k for short) command line option:

$ scl enable devtoolset-12 'memstomp --kill program argument...'

The use of the --kill option is especially recommended if you are analyzing a multi-threaded program; the internal implementation of backtraces is not thread-safe and running the memstomp utility on a multi-threaded program without this command line option can therefore produce unreliable results.

Additionally, if you have compiled the analyzed program with the debugging information or this debugging information is available to you, you can use the --debug-info (or -d) command line option to produce a more detailed backtrace:

$ scl enable devtoolset-12 'memstomp --debug-info program argument...'

For detailed instructions on how to compile your program with the debugging information built in the binary file, see Section 8.2, “Preparing a Program for Debugging”. For information on how to install debugging information for any of the Red Hat Developer Toolset packages, see Section 1.5.4, “Installing Debugging Information”.

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 memstomp as default:

$ scl enable devtoolset-12 'bash'

#include <stdio.h>
#include <string.h>

#define BUFSIZE 80

int main(int argc, char *argv[]) {
  char employee[BUFSIZE] = "John,Doe,john@example.com";
  char name[BUFSIZE] = {0};
  char surname[BUFSIZE] = {0};
  char *email;
  size_t length;

  /* Extract the information: */
  memccpy(name, employee, ',', BUFSIZE);
  length = strlen(name);
  memccpy(surname, employee + length, ',', BUFSIZE);
  length += strlen(surname);
  email = employee + length;

  /* Compose the new entry: */
  strcat(employee, surname);
  strcpy(employee, name);
  strcat(employee, email);

  /* Print the result: */
  puts(employee);

  return 0;
}

$ scl enable devtoolset-12 'gcc -rdynamic -g -o employee employee.c'

$ scl enable devtoolset-12 'memstomp --debug-info ./employee'
memstomp: 0.1.4 successfully initialized for process employee (pid 14887).

strcat(dest=0x7fff13afc265, src=0x7fff13afc269, bytes=21) overlap for employee(14887)
        ??:0    strcpy()
        ??:0    strcpy()
        ??:0    _Exit()
        ??:0    strcat()
        employee.c:26   main()
        ??:0    __libc_start_main()
        ??:0    _start()
John,john@example.comDoe,

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

Installed Documentation

See Also

In Red Hat Developer Toolset, SystemTap is provided by the devtoolset-12-systemtap package and is automatically installed with devtoolset-12-perftools as described in Section 1.5, “Installing Red Hat Developer Toolset”.

In order to place instrumentation into the Linux kernel, SystemTap may also require installation of additional packages with debugging information. To determine which packages to install, run the stap-prep utility as follows:

$ scl enable devtoolset-12 'stap-prep'

Note that if you execute this command as the root user, the utility automatically offers the packages for installation. For more information on how to install these packages on your system, see the Red Hat Enterprise Linux 7 SystemTap Beginners Guide.

To execute any of the tools that are part of SystemTap:

$ scl enable devtoolset-12 'tool option...'

See Table 12.1, “Tools Distributed with SystemTap for Red Hat Developer Toolset” for a list of tools that are distributed with SystemTap. For example, to run the stap tool to build an instrumentation module:

$ scl enable devtoolset-12 'stap option... argument...'

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 SystemTap as default:

$ scl enable devtoolset-12 'bash'

$ which stap

$ stap -V

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

Installed Documentation

Online Documentation

See Also

In Red Hat Developer Toolset, Valgrind is provided by the devtoolset-12-valgrind package and is automatically installed with devtoolset-12-perftools.

For detailed instructions on how to install Red Hat Developer Toolset and related packages to your system, see Section 1.5, “Installing Red Hat Developer Toolset”.

To run any of the Valgrind tools on a program you want to profile:

$ scl enable devtoolset-12 'valgrind --tool=tool program argument...'

See Table 13.1, “Tools Distributed with Valgrind for Red Hat Developer Toolset” for a list of tools that are distributed with Valgrind. The argument of the --tool command line option must be specified in lower case, and if this option is omitted, Valgrind uses Memcheck by default. For example, to run Cachegrind on a program to identify the sources of cache misses:

$ scl enable devtoolset-12 'valgrind --tool=cachegrind program argument...'

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 Valgrind as default:

$ scl enable devtoolset-12 'bash'

$ which valgrind

$ valgrind --version

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

Installed Documentation

Online Documentation

See Also

In Red Hat Developer Toolset, OProfile is provided by the devtoolset-12-oprofile package and is automatically installed with devtoolset-12-perftools as described in Section 1.5, “Installing Red Hat Developer Toolset”.

To run any of the tools that are distributed with OProfile:

# scl enable devtoolset-12 'tool option...'

See Table 14.1, “Tools Distributed with OProfile for Red Hat Developer Toolset” for a list of tools that are distributed with OProfile. For example, to use the ophelp command to list available events in the XML format:

$ scl enable devtoolset-12 'ophelp -X'

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 OProfile as default:

$ scl enable devtoolset-12 'bash'

$ which operf

# operf --version

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

Installed Documentation

Online Documentation

See Also

In Red Hat Developer Toolset, the Dyninst library is provided by the devtoolset-12-dyninst package and is automatically installed with devtoolset-12-perftools as described in Section 1.5, “Installing Red Hat Developer Toolset”. In addition, it is recommended that you also install the GNU Compiler Collection provided by the devtoolset-12-toolchain package.

If you intend to write a custom instrumentation for binaries, install the relevant header files:

# yum install devtoolset-12-dyninst-devel

You can also install API documentation for this library:

# yum install devtoolset-12-dyninst-doc

For a complete list of documents that are included in the devtoolset-12-dyninst-doc package, see Section 15.3, “Additional Resources”. For detailed instructions on how to install optional packages to your system, see Section 1.5, “Installing Red Hat Developer Toolset”.

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

Installed Documentation

The devtoolset-12-dyninst-doc package installs the following documents in the /opt/rh/devtoolset-12/root/usr/share/doc/devtoolset-12-dyninst-doc-12.1.0/ directory:

For information on how to install this package on your system, see Section 15.1, “Installing Dyninst”.

Online Documentation

See Also

Several items of information should be gathered before contacting GSS.

Background Information

Ensure you have the following background information at hand before calling GSS:

Diagnostics

The diagnostics report for Red Hat Enterprise Linux is required as well. This report is also known as a sosreport and the program to create the report is provided by the sos package. To install the sos package and all its dependencies on your system:

# yum install sos

To generate the report:

# sosreport

For more information, access the Knowledgebase article at https://access.redhat.com/kb/docs/DOC-3593.

Account and Contact Information

In order to help you, GSS requires your account information to customize their support, as well contact information to get back to you. When you contact GSS ensure you have your:

Issue Severity

Determining an issue’s severity is important to allow the GSS team to prioritize their work. There are four levels of severity.

For more information on determining the severity level of an issue, see https://access.redhat.com/support/policy/severity.

Once the issue severity has been determined, submit a service request through the Customer Portal under the Connect option, or at https://access.redhat.com/support/contact/technicalSupport.html. Note that you need your Red Hat login details in order to submit service requests.

If the severity is level 1 or 2, then follow up your service request with a phone call. Contact information and business hours are found at https://access.redhat.com/support/contact/technicalSupport.html.

If you have a premium subscription, then after hours support is available for Severity 1 and 2 cases.

Turn-around rates for both premium subscriptions and standard subscription can be found at https://access.redhat.com/support/offerings/production/sla.

If you feel an issue is not being handled correctly or adequately, you can escalate it. There are two types of escalations:

More information on escalation, including contacts, is available at https://access.redhat.com/support/escalation.

If there is more relevant information regarding a closed service request (such as the problem reoccurring), you can re-open the request via the Red Hat Customer Portal at https://access.redhat.com/support/policy/mgt_escalation.html or by calling your local support center, the details of which can be found at https://access.redhat.com/support/contact/technicalSupport.html.

For more information, see the resources listed below.

Online Documentation