GNU/Linux Application Programming (Programming Series)

2017-07-07 02:10:07

Now let s look at some of the other utilities that are useful when creating static, shared, or dynamic libraries.

file

The file utility tests the file argument for the purposes of identifying what it is. This utility is very useful in a number of different scenarios, but in this case it will provide us with a small amount of information about the shared object. Let s look at an interactive example:

$ file /usr/local/lib/libmyrand.so /usr/local/lib/libmyrand.so: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), not stripped $

So, using file , we see that our shared library is a 32-bit ELF object for the Intel 80386 processor family. It has been defined as not stripped, which simply means that debugging information is present.

size

The size command provides us with a very simple way to understand the text , data , and bss section sizes for an object. An example of the size command on our shared library is shown here:

$ size /usr/local/lib/libmyrand.so text data bss dec hex filename 2013 264 4 2281 8e9 /usr/local/lib/libmyrand.so $

nm

To dig into the object, we use the nm command. This commands permits us to look at the symbols that are available within a given object file. Let s look at a simple example using grep to filter our results:

$ nm -n /usr/local/lib/libmyrand.so grep " T " 00000608 T _init 0000074c T initRand 00000784 T getSRand 000007be T getRand 00000844 T _fini $

In this example, we use nm to print the symbols within the shared library, but then only emit those with the tag " T " to stdout (those symbols that are part of the .text section, or code segments). We also use the -n option to sort the output numerically by address, rather than the default, which is alphabetically by symbol name . This gives us relative address information within the library; if we wanted to know the specific sizes of these .text sections, we could use the -S option, as:

$ nm -n -S /usr/local/lib/libmyrand.so grep " T " 00000608 T _init 0000074c 00000036 T initRand 00000784 0000003a T getSRand 000007be 00000050 T getRand 00000844 T _fini $

From this example, we can see that the initRand is located at relative offset 0 74c in the library and its size is 0 36 (decimal 54) bytes. Many other options are available; the nm mainpage provides more detail on this.

objdump

The objdump utility is similar to nm in that it provides the ability to dig in and inspect the contents of an object. Let s now look at some of the specialized functions of objdump .

One of the most interesting features of objdump is its ability to disassemble the object into the native instruction set. Here s an excerpt of objdump performing this capability:

$ objdump -disassemble -S /usr/local/lib/libmyrand.so ... 0000074c <initRand>: 74c: 55 push %ebp 74d: 89 e5 mov %esp,%ebp 74f: 53 push %ebx 750: 83 ec 04 sub

$ objdump -disassemble -S /usr/local/lib/libmyrand.so ... 0000074c <initRand>: 74c: 55 push %ebp 74d: 89 e5 mov %esp,%ebp 74f: 53 push %ebx 750: 83 ec 04 sub $0x4,%esp 753: e8 00 00 00 00 call 758 <initRand+0xc> 758: 5b pop %ebx 759: 81 c3 f8 11 00 00 add $0x11f8,%ebx 75f: 83 ec 0c sub $0xc,%esp 762: 6a 00 push $0x0 764: e8 c7 fe ff ff call 630 <_init+0x28> 769: 83 c4 10 add $0x10,%esp 76c: 89 45 f8 mov %eax,0xfffffff8(%ebp) 76f: 83 ec 0c sub $0xc,%esp 772: ff 75 f8 pushl 0xfffffff8(%ebp) 775: e8 d6 fe ff ff call 650 <_init+0x48> 77a: 83 c4 10 add $0x10,%esp 77d: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 780: c9 leave 781: c3 ret 782: 90 nop 783: 90 nop ... $ x4,%esp 753: e8 00 00 00 00 call 758 <initRand+0xc> 758: 5b pop %ebx 759: 81 c3 f8 11 00 00 add

$ objdump -disassemble -S /usr/local/lib/libmyrand.so ... 0000074c <initRand>: 74c: 55 push %ebp 74d: 89 e5 mov %esp,%ebp 74f: 53 push %ebx 750: 83 ec 04 sub $0x4,%esp 753: e8 00 00 00 00 call 758 <initRand+0xc> 758: 5b pop %ebx 759: 81 c3 f8 11 00 00 add $0x11f8,%ebx 75f: 83 ec 0c sub $0xc,%esp 762: 6a 00 push $0x0 764: e8 c7 fe ff ff call 630 <_init+0x28> 769: 83 c4 10 add $0x10,%esp 76c: 89 45 f8 mov %eax,0xfffffff8(%ebp) 76f: 83 ec 0c sub $0xc,%esp 772: ff 75 f8 pushl 0xfffffff8(%ebp) 775: e8 d6 fe ff ff call 650 <_init+0x48> 77a: 83 c4 10 add $0x10,%esp 77d: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 780: c9 leave 781: c3 ret 782: 90 nop 783: 90 nop ... $ x0 764: e8 c7 fe ff ff call 630 <_init+0x28> 769: 83 c4 10 add

$ objdump -disassemble -S /usr/local/lib/libmyrand.so ... 0000074c <initRand>: 74c: 55 push %ebp 74d: 89 e5 mov %esp,%ebp 74f: 53 push %ebx 750: 83 ec 04 sub $0x4,%esp 753: e8 00 00 00 00 call 758 <initRand+0xc> 758: 5b pop %ebx 759: 81 c3 f8 11 00 00 add $0x11f8,%ebx 75f: 83 ec 0c sub $0xc,%esp 762: 6a 00 push $0x0 764: e8 c7 fe ff ff call 630 <_init+0x28> 769: 83 c4 10 add $0x10,%esp 76c: 89 45 f8 mov %eax,0xfffffff8(%ebp) 76f: 83 ec 0c sub $0xc,%esp 772: ff 75 f8 pushl 0xfffffff8(%ebp) 775: e8 d6 fe ff ff call 650 <_init+0x48> 77a: 83 c4 10 add $0x10,%esp 77d: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 780: c9 leave 781: c3 ret 782: 90 nop 783: 90 nop ... $ x10,%esp 76c: 89 45 f8 mov %eax,0xfffffff8(%ebp) 76f: 83 ec 0c sub

$ objdump -disassemble -S /usr/local/lib/libmyrand.so ... 0000074c <initRand>: 74c: 55 push %ebp 74d: 89 e5 mov %esp,%ebp 74f: 53 push %ebx 750: 83 ec 04 sub $0x4,%esp 753: e8 00 00 00 00 call 758 <initRand+0xc> 758: 5b pop %ebx 759: 81 c3 f8 11 00 00 add $0x11f8,%ebx 75f: 83 ec 0c sub $0xc,%esp 762: 6a 00 push $0x0 764: e8 c7 fe ff ff call 630 <_init+0x28> 769: 83 c4 10 add $0x10,%esp 76c: 89 45 f8 mov %eax,0xfffffff8(%ebp) 76f: 83 ec 0c sub $0xc,%esp 772: ff 75 f8 pushl 0xfffffff8(%ebp) 775: e8 d6 fe ff ff call 650 <_init+0x48> 77a: 83 c4 10 add $0x10,%esp 77d: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 780: c9 leave 781: c3 ret 782: 90 nop 783: 90 nop ... $ xc,%esp 772: ff 75 f8 pushl 0xfffffff8(%ebp) 775: e8 d6 fe ff ff call 650 <_init+0x48> 77a: 83 c4 10 add

$ objdump -disassemble -S /usr/local/lib/libmyrand.so ... 0000074c <initRand>: 74c: 55 push %ebp 74d: 89 e5 mov %esp,%ebp 74f: 53 push %ebx 750: 83 ec 04 sub $0x4,%esp 753: e8 00 00 00 00 call 758 <initRand+0xc> 758: 5b pop %ebx 759: 81 c3 f8 11 00 00 add $0x11f8,%ebx 75f: 83 ec 0c sub $0xc,%esp 762: 6a 00 push $0x0 764: e8 c7 fe ff ff call 630 <_init+0x28> 769: 83 c4 10 add $0x10,%esp 76c: 89 45 f8 mov %eax,0xfffffff8(%ebp) 76f: 83 ec 0c sub $0xc,%esp 772: ff 75 f8 pushl 0xfffffff8(%ebp) 775: e8 d6 fe ff ff call 650 <_init+0x48> 77a: 83 c4 10 add $0x10,%esp 77d: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 780: c9 leave 781: c3 ret 782: 90 nop 783: 90 nop ... $ x10,%esp 77d: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 780: c9 leave 781: c3 ret 782: 90 nop 783: 90 nop ... $

In addition to -disassemble (to disassemble to the native instruction set), we also specified -S to output interspersed source code. The problem is that we compiled our object to exclude this information. We can easily fix this as follows , by adding -g to the compilation process.

$ gcc -c -g -fPIC initapi.c $ gcc -c -g -fPIC randapi.c $ gcc -shared initapi.o randapi.o -o libmyrand.so $ objdump -disassemble -S libmyrand.so ... 00000790 <initRand>: * */ void initRand() { 790: 55 push %ebp 791: 89 e5 mov %esp,%ebp 793: 53 push %ebx 794: 83 ec 04 sub $0x4,%esp 797: e8 00 00 00 00 call 79c <initRand+0xc> 79c: 5b pop %ebx 79d: 81 c3 fc 11 00 00 add $0x11fc,%ebx time_t seed; seed = time(NULL); 7a3: 83 ec 0c sub $0xc,%esp 7a6: 6a 00 push $0x0 7a8: e8 c7 fe ff ff call 674 <_init+0x28> 7ad: 83 c4 10 add $0x10,%esp 7b0: 89 45 f8 mov %eax,0xfffffff8(%ebp) srand ( seed ); 7b3: 83 ec 0c sub $0xc,%esp 7b6: ff 75 f8 pushl 0xfffffff8(%ebp) 7b9: e8 d6 fe ff ff call 694 <_init+0x48> 7be: 83 c4 10 add $0x10,%esp return; } 7c1: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 7c4: c9 leave 7c5: c3 ret 7c6: 90 nop 7c7: 90 nop ... $ x4,%esp 797: e8 00 00 00 00 call 79c <initRand+0xc> 79c: 5b pop %ebx 79d: 81 c3 fc 11 00 00 add

$ gcc -c -g -fPIC initapi.c $ gcc -c -g -fPIC randapi.c $ gcc -shared initapi.o randapi.o -o libmyrand.so $ objdump -disassemble -S libmyrand.so ... 00000790 <initRand>: * */ void initRand() { 790: 55 push %ebp 791: 89 e5 mov %esp,%ebp 793: 53 push %ebx 794: 83 ec 04 sub $0x4,%esp 797: e8 00 00 00 00 call 79c <initRand+0xc> 79c: 5b pop %ebx 79d: 81 c3 fc 11 00 00 add $0x11fc,%ebx time_t seed; seed = time(NULL); 7a3: 83 ec 0c sub $0xc,%esp 7a6: 6a 00 push $0x0 7a8: e8 c7 fe ff ff call 674 <_init+0x28> 7ad: 83 c4 10 add $0x10,%esp 7b0: 89 45 f8 mov %eax,0xfffffff8(%ebp) srand ( seed ); 7b3: 83 ec 0c sub $0xc,%esp 7b6: ff 75 f8 pushl 0xfffffff8(%ebp) 7b9: e8 d6 fe ff ff call 694 <_init+0x48> 7be: 83 c4 10 add $0x10,%esp return; } 7c1: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 7c4: c9 leave 7c5: c3 ret 7c6: 90 nop 7c7: 90 nop ... $ x11fc,%ebx time_t seed; seed = time(NULL); 7a3: 83 ec 0c sub

$ gcc -c -g -fPIC initapi.c $ gcc -c -g -fPIC randapi.c $ gcc -shared initapi.o randapi.o -o libmyrand.so $ objdump -disassemble -S libmyrand.so ... 00000790 <initRand>: * */ void initRand() { 790: 55 push %ebp 791: 89 e5 mov %esp,%ebp 793: 53 push %ebx 794: 83 ec 04 sub $0x4,%esp 797: e8 00 00 00 00 call 79c <initRand+0xc> 79c: 5b pop %ebx 79d: 81 c3 fc 11 00 00 add $0x11fc,%ebx time_t seed; seed = time(NULL); 7a3: 83 ec 0c sub $0xc,%esp 7a6: 6a 00 push $0x0 7a8: e8 c7 fe ff ff call 674 <_init+0x28> 7ad: 83 c4 10 add $0x10,%esp 7b0: 89 45 f8 mov %eax,0xfffffff8(%ebp) srand ( seed ); 7b3: 83 ec 0c sub $0xc,%esp 7b6: ff 75 f8 pushl 0xfffffff8(%ebp) 7b9: e8 d6 fe ff ff call 694 <_init+0x48> 7be: 83 c4 10 add $0x10,%esp return; } 7c1: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 7c4: c9 leave 7c5: c3 ret 7c6: 90 nop 7c7: 90 nop ... $ x0 7a8: e8 c7 fe ff ff call 674 <_init+0x28> 7ad: 83 c4 10 add

$ gcc -c -g -fPIC initapi.c $ gcc -c -g -fPIC randapi.c $ gcc -shared initapi.o randapi.o -o libmyrand.so $ objdump -disassemble -S libmyrand.so ... 00000790 <initRand>: * */ void initRand() { 790: 55 push %ebp 791: 89 e5 mov %esp,%ebp 793: 53 push %ebx 794: 83 ec 04 sub $0x4,%esp 797: e8 00 00 00 00 call 79c <initRand+0xc> 79c: 5b pop %ebx 79d: 81 c3 fc 11 00 00 add $0x11fc,%ebx time_t seed; seed = time(NULL); 7a3: 83 ec 0c sub $0xc,%esp 7a6: 6a 00 push $0x0 7a8: e8 c7 fe ff ff call 674 <_init+0x28> 7ad: 83 c4 10 add $0x10,%esp 7b0: 89 45 f8 mov %eax,0xfffffff8(%ebp) srand ( seed ); 7b3: 83 ec 0c sub $0xc,%esp 7b6: ff 75 f8 pushl 0xfffffff8(%ebp) 7b9: e8 d6 fe ff ff call 694 <_init+0x48> 7be: 83 c4 10 add $0x10,%esp return; } 7c1: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 7c4: c9 leave 7c5: c3 ret 7c6: 90 nop 7c7: 90 nop ... $ x10,%esp 7b0: 89 45 f8 mov %eax,0xfffffff8(%ebp) srand( seed ); 7b3: 83 ec 0c sub

$ gcc -c -g -fPIC initapi.c $ gcc -c -g -fPIC randapi.c $ gcc -shared initapi.o randapi.o -o libmyrand.so $ objdump -disassemble -S libmyrand.so ... 00000790 <initRand>: * */ void initRand() { 790: 55 push %ebp 791: 89 e5 mov %esp,%ebp 793: 53 push %ebx 794: 83 ec 04 sub $0x4,%esp 797: e8 00 00 00 00 call 79c <initRand+0xc> 79c: 5b pop %ebx 79d: 81 c3 fc 11 00 00 add $0x11fc,%ebx time_t seed; seed = time(NULL); 7a3: 83 ec 0c sub $0xc,%esp 7a6: 6a 00 push $0x0 7a8: e8 c7 fe ff ff call 674 <_init+0x28> 7ad: 83 c4 10 add $0x10,%esp 7b0: 89 45 f8 mov %eax,0xfffffff8(%ebp) srand ( seed ); 7b3: 83 ec 0c sub $0xc,%esp 7b6: ff 75 f8 pushl 0xfffffff8(%ebp) 7b9: e8 d6 fe ff ff call 694 <_init+0x48> 7be: 83 c4 10 add $0x10,%esp return; } 7c1: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 7c4: c9 leave 7c5: c3 ret 7c6: 90 nop 7c7: 90 nop ... $ xc,%esp 7b6: ff 75 f8 pushl 0xfffffff8(%ebp) 7b9: e8 d6 fe ff ff call 694 <_init+0x48> 7be: 83 c4 10 add

$ gcc -c -g -fPIC initapi.c $ gcc -c -g -fPIC randapi.c $ gcc -shared initapi.o randapi.o -o libmyrand.so $ objdump -disassemble -S libmyrand.so ... 00000790 <initRand>: * */ void initRand() { 790: 55 push %ebp 791: 89 e5 mov %esp,%ebp 793: 53 push %ebx 794: 83 ec 04 sub $0x4,%esp 797: e8 00 00 00 00 call 79c <initRand+0xc> 79c: 5b pop %ebx 79d: 81 c3 fc 11 00 00 add $0x11fc,%ebx time_t seed; seed = time(NULL); 7a3: 83 ec 0c sub $0xc,%esp 7a6: 6a 00 push $0x0 7a8: e8 c7 fe ff ff call 674 <_init+0x28> 7ad: 83 c4 10 add $0x10,%esp 7b0: 89 45 f8 mov %eax,0xfffffff8(%ebp) srand ( seed ); 7b3: 83 ec 0c sub $0xc,%esp 7b6: ff 75 f8 pushl 0xfffffff8(%ebp) 7b9: e8 d6 fe ff ff call 694 <_init+0x48> 7be: 83 c4 10 add $0x10,%esp return; } 7c1: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 7c4: c9 leave 7c5: c3 ret 7c6: 90 nop 7c7: 90 nop ... $ x10,%esp return; } 7c1: 8b 5d fc mov 0xfffffffc(%ebp),%ebx 7c4: c9 leave 7c5: c3 ret 7c6: 90 nop 7c7: 90 nop ... $

Having compiled our source code with -g , we now have the ability to understand the C source to machine code mapping.

Numerous other capabilities are provided with objdump . The GNU/Linux mainpage lists the plethora of other options.

ranlib

The ranlib utility is one of the most important utilities when creating static libraries. This utility creates an index of the contents of the library and stores it in the library file itself. When this index is present in the library, the linking stage of building an image can be sped up considerably. Therefore, the ranlib utility should be performed whenever a new static library is created. An example of using ranlib is shown here:

$ ranlib libmyrand.a $

Note that the same thing can be performed using the ar command with the -s option, as:

$ ar -s libmyrand.a $

file

size

nm

objdump

ranlib

Категории