ltrace | This directory contains sources of ltrace | Code Inspection library

No. "22d72c" are the 6 characters that read read from your file... just check the beginning of file.

Indeed if you read from STDIN_FILENO using read (or for example use fgets; strace will output

*sz is the same as sz[0], i.e. the first character of the string. In your case the first character has the numeric value 33 (aka hex 0x21). In other words, your code prints 33.

If you want to convert the first sizeof(int) characters to an integer, you should use bit shifting instead.

If sizeof(int) is 4 and you want little endian conversion, it would be something like:

Check if this helps, comments in code:

The GCC bug in __tls_get_addr stack alignment you reference is specific to x86-64. It does not exist on i386. I'll assume you swapped i386 and x86-64 in your question.

In general, the distribution toolchains are consistent and well-tested. If you compile your programs with the system compiler and use the system glibc version, __tls_get_addr will work as expected, even if the GCC bug has not been fixed. The bug only materializes if buggy programs are run with a malloc that happens to use vector instructions. With glibc's malloc, this only happens with GCC 7 or later. Once Fedora started to use GCC 7 as the system compiler, the incomplete workaround for the GCC bug in glibc was discovered, and a more complete workaround was implemented upstream (and integrated into Fedora). Before the GCC 7 switch, the buggy applications were running just fine.

Some distributions have backported the fix because they support multiple compilers and malloc implementations. In the end, this is a distribution integration issue, so if you have doubts, you need to talk to your distribution support.

___tls_get_addr (three underscores) is merely an internal implementation detail. It was visible to some debugging tools in glibc 2.20 and earlier because it was not a hidden symbol. In glibc 2.21 and later, it was made hidden (on i386), and ltrace and similar tools will no longer report it. This is merely a minor performance optimization, it does not affect functionality.

I have had success with the perf tool, which lets me know which functions are taking the most time. On my Pynq board specifically, the executable is found in /usr/lib/linux-tools-4.15.0-20 which is not by default in PATH. I also used FlameGraph for excellent visualization of the call graph.

You can use uftrace utility written by Namhyung Kim. It's available as a package in Ubuntu although I built the code from master branch manually to make sure I use the newest vanilla version. Example main.c:

This may have to do with binaries being compiled with -z now. I created a quick test program (I'm using Ubuntu 16.04):

Even w/o optimization, g++ warns unused variable arr on the first one with option -Wunused-variable, and objdump shows nothing continues with the initialization after the stack space is allocated for the array.

However, the second one receives no warning even it has that line of logically dead code. Not only is the stack space allocated for the array, but also the implicit initialization on the items takes place, thus finally causes the segmentation fault at runtime.

The operation = on the third one tries to assign the array size to another storage place beyond the stack limit, thus certainly causes the segmentation fault as well.

According to the reference:

Implicit initialization

If an initializer is not provided:

objects with automatic storage duration are initialized to indeterminate values (which may be trap representations).

objects with static and thread-local storage duration are initialized as follows:

pointers are initialized to null pointer values of their types.

objects of integral types are initialized to unsigned zero.

objects of floating types are initialized to positive zero.

members of arrays, structs, and unions are initialized as described above, recursively, plus all padding bits are initialized to zero.

It seems that the first one belongs to objects with automatic storage duration and the second one to objects with thread-local storage duration in view of g++.

There is no default heap size. The heap is always dynamic and starts at zero. The system calls used are mmap, brk and sbrk.

Most dynamic linked programs use heap in the program loader. They also use it when setting up output buffers for std::cout, FILE *stdout, etc. This is what you see as the "initial heap."

If you built a program without using the C runtime support libraries you would not see any heap usage.