In Linux, how can I use GCC to compile programs and generate static and dynamic libraries.

How to Use GCC to compile programs and generate simple programs in Linux
Static library and dynamic library.

This article applies to Linux developers. This article explains how to use GCC to compile programs, generate static libraries and dynamic libraries in Linux.

1. About installation. Generally, the compiler is installed by default, and there is a lot of information on the network to introduce the installation problems in different release versions. This article will not describe it.

II. Introduction to file extensions in C Programming
. A static library (package files)
. C source code without preprocessing
. H c header file


. I pre-processed C source code
Target file generated after. O Compilation
Assembly language code generated by. s
. So
Dynamic library (Dynamic Link Library)
Explanation: *. A is the static library that we use AR to package and generate after compilation. *. c generally makes the code we edit, and the result of our work. *. H is generally
The manually generated interface file can also be found in *. after C is complete, use the GCC option-aux-info to help us generate it ;*. I is the source code after preprocessing, which is automatically generated by GCC under option-e compilation.
*. O is a compilation.
The target file generated after translation ;*. S is the assembly language code generated by GCC under option-s compilation. For programs with high performance requirements, you can compile the assembly language file and optimize the assembly.
After compilation, the target file is generated and linked; *. So is a dynamic library, which is generated using the-FPIC-shared option of GCC.

Iii. compilation process of Hello. c

The demos in this section are for the file hello. C.

1. /*
2. * Hello. c
3. */
5. # Include <stdio. h>
6. Int main ()
7. {
8. Printf ("Hello, world! /N ");
9. Return 0;
10. }

1.
Generate executable programs directly

1. $ Gcc-O hello. c
2. $./Hello
3. Hello, world!
5. For example
   Compilation Method
   The results are the same:
6. $ GCC hello. C-O hello
7. $./Hello
8. Hello, world!
10. For example
    Compilation Method
    Different from the above Compilers
    Case (for details about the network data with different elf and A. out file formats, there is no difference in the results here ):
11. $ GCC hello. c
12. $./A. Out
13. Hello, world!

2.
Generate the pre-processed file hello. I

1. $ Gcc-e hello. C-O hello. I
2. $ Ls
3. A. Out hello. c hello. I
4. Hello. I.
   Is a new file
6. The result of the following statement is the same:
7. $ Gcc-e-o hello. I hello. c
9. For example
   If no output file is set, it is printed to the standard terminal. You can view the output file in less mode:
10. $ Gcc-e hello. c | less
11. #1 "Hello. c"
12. #1 "<built-in>"
13. #1 "<command line>"
14. #1 "Hello. c"
15. #1 "/usr/include/stdio. H" 1 3 4
16. #28 "/usr/include/stdio. H" 3 4
17. #1 "/usr/include/features. H" 1 3 4
18. #329 "/usr/include/features. H" 3 4
19. ..............................
21. Or
    Executed:
22. $ Gcc-e hello. C-O hello. I
23. $ VI hello. I
24. 1 #1 "Hello. c"
25. 2 #1 "<built-in>"
26. 3 #1 "<command line>"
27. 4 #1 "Hello. c"
28. 5 #1 "/usr/include/stdio. H" 1 3 4
29. 6 #28 "/usr/include/stdio. H" 3 4
30. 7 #1 "/usr/include/features. H" 1 3 4
31. 8 #329 "/usr/include/features. H" 3 4
33. ...... <
    The middle part is omitted> ..................
35. 929 #844 "/usr/include/stdio. H" 3 4
36. 930
37. 931 #2 "Hello. c" 2
38. 932
39. 933 int main ()
40. 934 {
41. 935 printf ("Hello, world! /N ");
42. 936
43. 937 return 0;
44. 938}
46. Yes
    As you can see, there are nearly 1000 lines of code, and we only account for the last 8 lines.

3. Generate assembly language files
Hello. s

1. $ Gcc-s hello. C-O hello. s
2. $ Ls
3. A. Out hello. c hello. I hello. s
4. Hello. s
   Is the newly generated file.
6. The result of the following statement is the same:
7. $ Gcc-S-O hello. s hello. c
9. For example
   The following statement results are the same:
10. $ Gcc-s hello. c
12. Also
    You can generate an assembly file using an intermediate file generated in the previous step:
13. $ Gcc-s hello. I-O hello. s
14. $ Gcc-S-O hello. s hello. I
15. $ Gcc-s hello. I
18. Raw
    The Assembly Code is as follows:
19. $ VI hello. s
20. 1. File "Hello. c"
21. 2. Section. rodata
22. 3. lc0:
23. 4. String "Hello, world! "
24. 5. Text
25. 6. globl main
26. 7. type main, @ Function
27. 8 main:
28. 9 Leal 4 (% ESP), % ECx
29. 10 andl $-16, % ESP
30. 11 pushl-4 (% ECx)
31. 12 pushl % EBP
32. //
    Note: If you are familiar with it, you can optimize part of the assembly to achieve better results.

4. Generate the target file
Hello. o

1. $ Gcc-C hello. C-O hello. o
2. $ Ls
3. A. Out hello. c hello. I hello. O hello. s
4. Hello. o
   Is the newly generated target file:
6. The result of the following statement is the same:
7. $ Gcc-c-o hello. O hello. c
9. For example
   The following statement results are the same:
10. $ Gcc-C hello. c
12. Also
    You can use the intermediate file hello. I or hello. s generated in the previous step to generate the target file:
13. $ Gcc-C hello. I
14. $ Gcc-C hello. s
16. Me
    You can use objdump to view the binary code of Hello. O:
17. $ Objdump-s hello. o
19. Hello. O: File Format elf32-i386
21. Contents of section. Text:
22. 0000 8d4c2404 83e4f0ff 71fc5589 e55183ec. L $ ...... Q. U ..
23. 0010 04c70424 00000000 e8fcffff ffb80000 ...... $ ............
24. 0020 listen 83c4 04595d8d 61fcc3 ...... y]. ..
25. Contents of section. rodata:
26. 0000 68656c6c 6f2c2077 6f450c64 2100 Hello, world !.
27. Contents of section. Comment:
28. 0000 00474343 3a202847 4e552920 342e312e. GCC: (GNU) 4.1.
29. 0010 31203230 30373031 30352028 52656420 1 20070105 (red
30. 0020 48617420 342e312e 312d3532 2900 hat 4.1.1-52 ).

5.
Generate executable programs using intermediate files

1. $ Gcc-O hello. I
2. $./Hello
3. Hello, world!
5. $ Gcc-O hello. s
6. $./Hello
7. Hello, world!
9. $ Gcc-O hello. o
10. $./Hello
11. Hello, world!

IV,
Static library generation
It is easier to generate static libraries in Linux. Use ar after generating the target file
Package. In medium and large projects, a module is generally made into a static library to facilitate management, improve compilation, and link efficiency.
This section is intended
Main. C, func1.c, and func2.c files

1. /*
2. * Main. c
3. */
4. # Include <stdio. h>
6. Extern int func1 ();
7. Extern int func2 ();
9. Int main ()
10. {
11. Int I;
13. I = func1 ();
14. Printf ("func1 return = % d/N", I );
16. I = func2 ();
17. Printf ("func2 return = % d/N", I );
19. Return 0;
20. }

-----------------------------------------------------

1. /*
2. * Func1.c
3. */
4. Int func1 ()
5. {
6. Return 100;
7. }

-----------------------------------------------------

1. /*
2. * Func2.c
3. */
4. Int func2 ()
5. {
6. Return 200;
7. }

I
Compilation refers
Order:

1. $ Gcc-C func1.c
2. $ Gcc-C func2.c
3. $ Ls
4. Func1.c func1.o func2.c func2.o main. c
6. Func1.o and func2.o are
   The target file we generated. The packaging command is as follows:
7. $ Ar-r libfunc. A func1.o func2.o
9. Me
   View the files in libfunc.:
10. $ Ar-T libfunc.
11. Func1.o
12. Func2.o
14. Now
    Use the static library and Main. C to generate the target program:
15. $ Gcc-O main. c libfunc.
16. $./Main
17. Func1 return = 100
18. Func2 returned = 200
20. And
    Our expectations are consistent. Next we will go to the dynamic library.

5. Dynamic library generation

The dynamic library generation in Linux is implemented using the GCC option. The case programs are the same as those in the static library. Here is the operation command:

1. First
   First, we generate the target file, but we need to add the compiler option-FPIC and linker option-shared
2. $ Gcc-FPIC-C func1.c
3. $ Gcc-FPIC-C func2.c
4. $ Gcc-shared-O libfunc. So func1.o func2.o
5. $ Ls
6. Func1.c func1.o func2.c func2.o libfunc. So main. c
8. Libfunc. So
   Is the target dynamic library we generated. We use the dynamic library and Main. C to generate the target program:
9. $ Gcc-O main. C-L.-lfunc
11. Note
    -L.-lfunc is used as the compilation option. -L. The table searches for the required dynamic library from the current directory.-lfunc is the call rule for the dynamic library. Name of the dynamic library in Linux
    The format is lib *. So, And the link represents the bit-L *, * is the name of your own database. Run the following command:
13. $./Main
14. ./Main: Error while loading shared libraries: libfunc. So: cannot open shared object file: no such file or directory
16. Submit
    Indicates an error,
    Indicates that the dynamic library cannot be found. In Linux, the most convenient solution is to copy libfunc. So to the absolute directory/lib. However, only Super Users have this permission. Another solution
    Is to change the environment variable LD_LIBRARY_PATH. As follows:
17. $ Export LD_LIBRARY_PATH = 'pwd'
18. $./Main
19. Func1 return = 100
20. Func2 returned = 200
22. Operation
    The row is successful. Now we can change the function of the dynamic library without re-linking. As follows:
23. Change func1.c:
24. Int func1 ()
25. {
26. Return 101;
27. }
28. More
    Change func2.c:
29. Int func2 ()
30. {
31. Return 202;
32. }
33. Heavy
    New Database generation:
34. $ Gcc-FPIC-shared func1.c func2.c-O libfunc. So
35. $./Main
36. Func1 return = 101
37. Func2 returned = 202
39. Yes
    We can see that the dynamic library has been updated.

Vi. Conclusion
This article briefly introduces how to use GCC to compile programs in Linux and how to simplify
Single Static and Dynamic library generation. The static library provides a packaging management solution, while the dynamic library updates the program to a certain extent. More importantly, when multiple instances exist, dynamic library can reduce memory consumption
(Only one part of code space is occupied ).
Those interested in this series of knowledge can continue to follow up and read subsequent articles: Library version management, GCC compilation options, makefile and automated compilation.