關於Linux靜態庫和動態庫的分析

1.什麼是庫
    在windows平臺和linux平臺下都大量存在着庫。
    本質上來說庫是一種可執行代碼的二進制形式，可以被操作系統載入內存執行。
    由於windows和linux的本質不同，因此二者庫的二進制是不兼容的。
    本文僅限於介紹linux下的庫。
    
2.庫的種類
    linux下的庫有兩種：靜態庫和共享庫（動態庫）。
    二者的不同點在於代碼被載入的時刻不同。
    靜態庫的代碼在編譯過程中已經被載入可執行程序，因此體積較大。
    共享庫的代碼是在可執行程序運行時才載入內存的，在編譯過程中僅簡單的引用，因此代碼體積較小。
    
3.庫存在的意義
    庫是別人寫好的現有的，成熟的，可以複用的代碼，你可以使用但要記得遵守許可協議。
    現實中每個程序都要依賴很多基礎的底層庫，不可能每個人的代碼都從零開始，因此庫的存在意義非同尋常。
    共享庫的好處是，不同的應用程序如果調用相同的庫，那麼在內存裏只需要有一份該共享庫的實例。
    
4.庫文件是如何產生的在linux下
    靜態庫的後綴是.a，它的產生分兩步
    Step 1.由源文件編譯生成一堆.o，每個.o裏都包含這個編譯單元的符號表
    Step 2.ar命令將很多.o轉換成.a，成文靜態庫
    動態庫的後綴是.so，它由gcc加特定參數編譯產生。
    例如:
    $ gcc -fPIC -c *.c $ gcc -shared -Wl,-soname, libfoo.so.1 -o libfoo.so.1.0 *.
    
5.庫文件是如何命名的，有沒有什麼規範
    在linux下，庫文件一般放在/usr/lib /lib下，
    靜態庫的名字一般爲libxxxx.a，其中xxxx是該lib的名稱
    動態庫的名字一般爲libxxxx.so.major.minor，xxxx是該lib的名稱，major是主版本號， minor是副版本號。
    
6.如何知道一個可執行程序依賴哪些庫
    ldd命令可以查看一個可執行程序依賴的共享庫，
    例如# ldd /bin/lnlibc.so.6
    => /lib/libc.so.6 (0×40021000)/lib/ld-linux.so.2
    => /lib/ld-linux.so.2 (0×40000000)
    可以看到ln命令依賴於libc庫和ld-linux庫。
    
7.可執行程序在執行的時候如何定位共享庫文件
    當系統加載可執行代碼時候，能夠知道其所依賴的庫的名字，但是還需要知道絕對路徑
    此時就需要系統動態載入器(dynamic linker/loader)
    對於elf格式的可執行程序，是由ld-linux.so*來完成的，
    它先後搜索elf文件的 DT_RPATH段—環境變量LD_LIBRARY_PATH—/etc/ld.so.cache文件列表—/lib/,
    /usr/lib目錄找到庫文件後將其載入內存。
    
8.在新安裝一個庫之後如何讓系統能夠找到他
    如果安裝在/lib或者/usr/lib下，那麼ld默認能夠找到，無需其他操作。
    如果安裝在其他目錄，需要將其添加到/etc/ld.so.cache文件中，步驟如下
    1.編輯/etc/ld.so.conf文件，加入庫文件所在目錄的路徑
    2.運行ldconfig，該命令會重建/etc/ld.so.cache文件


    我們通常把一些公用函數製作成函數庫，供其它程序使用。函數庫分爲靜態庫和動態庫兩種。
    靜態庫在程序編譯時會被連接到目標代碼中，程序運行時將不再需要該靜態庫。
    動態庫在程序編譯時並不會被連接到目標代碼中，而是在程序運行是才被載入，
    因此在程序運行時還需要動態庫存在。
    本文主要通過舉例來說明在Linux中如何創建靜態庫和動態庫，以及使用它們。
    在創建函數庫前，我們先來準備舉例用的源程序，並將函數庫的源程序編譯成.o文件。 
    第1步：編輯得到舉例的程序--hello.h、hello.c和main.c； 
    hello.h(見程序1)爲該函數庫的頭文件。
    hello.c(見程序2)是函數庫的源程序，其中包含公用函數hello，該函數將在屏幕上輸出"Hello XXX!"。
    main.c(見程序3)爲測試庫文件的主程序，在主程序中調用了公用函數hello。 
    程序1: hello.h
    #ifndef HELLO_H
    #define HELLO_H
    
    void hello(const char *name);
    
    #endif //HELLO_H
    
    程序2: hello.c
    #include 
    
    void hello(const char *name)
    {
      printf("Hello %s!\n", name);
    }
    
    程序3: main.c
    #include "hello.h"
    
    int main()
    {
      hello("everyone");
      return 0;
    }
    
    第2步：將hello.c編譯成.o文件； 
    無論靜態庫，還是動態庫，都是由.o文件創建的。因此，我們必須將源程序hello.c通過gcc先編譯成.o文件。 
    在系統提示符下鍵入以下命令得到hello.o文件。 
    # gcc -c hello.c 
    # 
    (注1：本文不介紹各命令使用和其參數功能，若希望詳細瞭解它們，請參考其他文檔。) 
    (注2：首字符"#"是系統提示符，不需要鍵入，下文相同。) 
    我們運行ls命令看看是否生存了hello.o文件。 
    # ls 
    hello.c hello.h hello.o main.c 
    # 
    (注3：首字符不是"#"爲系統運行結果，下文相同。) 
    在ls命令結果中，我們看到了hello.o文件，本步操作完成。 
    下面我們先來看看如何創建靜態庫，以及使用它。 
    
第3步：由.o文件創建靜態庫； 
    靜態庫文件名的命名規範是以lib爲前綴，緊接着跟靜態庫名，擴展名爲.a。
    例如：我們將創建的靜態庫名爲myhello，則靜態庫文件名就是libmyhello.a。
    在創建和使用靜態庫時，需要注意這點。創建靜態庫用ar命令。 
    在系統提示符下鍵入以下命令將創建靜態庫文件libmyhello.a。 
    # ar cr libmyhello.a hello.o 
    # 
    我們同樣運行ls命令查看結果： 
    # ls 
    hello.c hello.h hello.o libmyhello.a main.c 
    # 
    ls命令結果中有libmyhello.a。 


第4步：在程序中使用靜態庫； 
    靜態庫製作完了，如何使用它內部的函數呢？只需要在使用到這些公用函數的源程序中包含這些公用函數的原型聲明，
    然後在用gcc命令生成目標文件時指明靜態庫名，gcc將會從靜態庫中將公用函數連接到目標文件中。
    注意，gcc會在靜態庫名前加上前綴lib，然後追加擴展名.a得到的靜態庫文件名來查找靜態庫文件。 
    在程序3:main.c中，我們包含了靜態庫的頭文件hello.h，然後在主程序main中直接調用公用函數hello。
    下面先生成目標程序hello，然後運行hello程序看看結果如何。 
    # gcc -o hello main.c -L. -lmyhello 
    # ./hello 
    Hello everyone! 
    # 
    我們刪除靜態庫文件試試公用函數hello是否真的連接到目標文件 hello中了。 
    # rm libmyhello.a 
    rm: remove regular file `libmyhello.a'? y 
    # ./hello 
    Hello everyone! 
    # 
    程序照常運行，靜態庫中的公用函數已經連接到目標文件中了。 
    我們繼續看看如何在Linux中創建動態庫。我們還是從.o文件開始。 
    
第5步：由.o文件創建動態庫文件； 
    動態庫文件名命名規範和靜態庫文件名命名規範類似，也是在動態庫名增加前綴lib，但其文件擴展名爲.so。
    例如：我們將創建的動態庫名爲myhello，則動態庫文件名就是libmyhello.so。用gcc來創建動態庫。 
    在系統提示符下鍵入以下命令得到動態庫文件libmyhello.so。 
    # gcc -shared -fPCI -o libmyhello.so hello.o 
    # 
    我們照樣使用ls命令看看動態庫文件是否生成。 
    # ls 
    hello.c hello.h hello.o libmyhello.so main.c 
    # 
    
第6步：在程序中使用動態庫； 
    在程序中使用動態庫和使用靜態庫完全一樣，也是在使用到這些公用函數的源程序中包含這些公用函數的原型聲明，
    然後在用gcc命令生成目標文件時指明動態庫名進行編譯。我們先運行gcc命令生成目標文件，再運行它看看結果。 
    # gcc -o hello main.c -L. -lmyhello 
    # ./hello 
    ./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory 
    # 
    哦！出錯了。快看看錯誤提示，原來是找不到動態庫文件libmyhello.so。程序在運行時，會在/usr/lib和/lib等目錄中查找需要的動態庫文件。
    若找到，則載入動態庫，否則將提示類似上述錯誤而終止程序運行。我們將文件libmyhello.so複製到目錄/usr/lib中，再試試。 
    # mv libmyhello.so /usr/lib 
    # ./hello 
    ./hello: error while loading shared libraries: /usr/lib/libhello.so: cannot restore segment prot after reloc: Permission denied
    由於SELinux引起，
    # chcon -t texrel_shlib_t /usr/lib/libhello.so
    # ./hello
    Hello everyone! 
    # 
    成功了。這也進一步說明了動態庫在程序運行時是需要的。 
    我們回過頭看看，發現使用靜態庫和使用動態庫編譯成目標程序使用的gcc命令完全一樣，那當靜態庫和動態庫同名時，
    gcc命令會使用哪個庫文件呢？抱着對問題必究到底的心情，來試試看。 
    先刪除 除.c和.h外的 所有文件，恢復成我們剛剛編輯完舉例程序狀態。 
    # rm -f hello hello.o /usr/lib/libmyhello.so 
    # ls 
    hello.c hello.h main.c 
    # 
    在來創建靜態庫文件libmyhello.a和動態庫文件libmyhello.so。 
    # gcc -c hello.c 
    # ar cr libmyhello.a hello.o 
    # gcc -shared -fPCI -o libmyhello.so hello.o 
    # ls 
    hello.c hello.h hello.o libmyhello.a libmyhello.so main.c 
    # 
    通過上述最後一條ls命令，可以發現靜態庫文件libmyhello.a和動態庫文件libmyhello.so都已經生成，並都在當前目錄中。然後，
    我們運行gcc命令來使用函數庫myhello生成目標文件hello，並運行程序 hello。 
    # gcc -o hello main.c -L. -lmyhello 
    # ./hello 
    ./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory 
    # 
    從程序hello運行的結果中很容易知道，當靜態庫和動態庫同名時， gcc命令將優先使用動態庫。 
    基本概念 
    庫有動態與靜態兩種，動態通常用.so爲後綴，靜態用.a爲後綴。 
    例如：libhello.so libhello.a 爲了在同一系統中使用不同版本的庫，可以在庫文件名後加上版本號爲後綴,
    例如：libhello.so.1.0,由於程序連接默認以.so爲文件後綴名。所以爲了使用這些庫，通常使用建立符號連接的方式。 
    ln -s libhello.so.1.0 libhello.so.1 
    ln -s libhello.so.1 libhello.so 
    
6.1、使用庫 
    當要使用靜態的程序庫時，連接器會找出程序所需的函數，然後將它們拷貝到執行文件，由於這種拷貝是完整的，所以一旦連接成功，
    靜態程序庫也就不再需要了。 然而，對動態庫而言，就不是這樣。動態庫會在執行程序內留下一個標記指明當程序執行時，
    首先必須載入這個庫。由於動態庫節省空間，
    linux下進行連接的缺省操作是首先連接動態庫，也就是說，如果同時存在靜態和動態庫，不特別指定的話，將與動態庫相連接。 
    現在假設有一個叫hello的程序開發包，它提供一個靜態庫libhello.a 一個動態庫libhello.so,一個頭文件hello.h,
    頭文件中提供sayhello()這個函數 /* hello.h */ void sayhello(); 另外還有一些說明文檔。 
    這一個典型的程序開發包結構 與動態庫連接 linux默認的就是與動態庫連接，下面這段程序testlib.c使用hello庫中的sayhello()函數 
    /*testlib.c*/ 
    #include  
    #include  
    int main() 
    { 
       sayhello(); 
       return 0; 
    } 
    使用如下命令進行編譯 $gcc -c testlib.c -o testlib.o 
    用如下命令連接： $gcc testlib.o -lhello -o testlib 
    連接時要注意，假設libhello.o 和libhello.a都在缺省的庫搜索路徑下/usr/lib下，如果在其它位置要加上-L參數 與與靜態庫連接麻煩一些，
    主要是參數問題。還是上面的例子： 
    $gcc testlib.o -o testlib -WI,-Bstatic -lhello 
    注：這個特別的"-WI，-Bstatic"參數，實際上是傳給了連接器ld。指示它與靜態庫連接，如果系統中只有靜態庫當然就不需要這個參數了。
    如果要和多個庫相連接，而每個庫的連接方式不一樣，比如上面的程序既要和libhello進行靜態連接，又要和libbye進行動態連接，其命令應爲： 
    $gcc testlib.o -o testlib -WI,-Bstatic -lhello -WI,-Bdynamic -lbye 
  
6.2、動態庫的路徑問題 爲了讓執行程序順利找到動態庫，有三種方法： 
    (1)把庫拷貝到/usr/lib和/lib目錄下。 
    (2)在LD_LIBRARY_PATH環境變量中加上庫所在路徑。 
    例如動態庫libhello.so在/home/ting/lib目錄下，以bash爲例，使用命令： 
    $export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/ting/lib 


(3) 修改/etc/ld.so.conf文件，把庫所在的路徑加到文件末尾，並執行ldconfig刷新。這樣，加入的目錄下的所有庫文件都可見。 


6.3、查看庫中的符號 
    有時候可能需要查看一個庫中到底有哪些函數，nm命令可以打印出庫中的涉及到的所有符號。庫既可以是靜態的也可以是動態的。
    nm列出的符號有很多，常見的有三種： 
    一種是在庫中被調用，但並沒有在庫中定義(表明需要其他庫支持)，用U表示； 
    一種是庫中定義的函數，用T表示，這是最常見的； 
    另外一種是所謂的“弱 態”符號，它們雖然在庫中被定義，但是可能被其他庫中的同名符號覆蓋，用W表示。 
    例如，假設開發者希望知道上文提到的hello庫中是否定義了 printf(): 
    $nm libhello.so | grep printf U 
    其中printf U表示符號printf被引用，但是並沒有在函數內定義，由此可以推斷，要正常使用hello庫，必須有其它庫支持，
    再使用ldd命令查看hello依賴於哪些庫： 
    $ldd hello libc.so.6=>/lib/libc.so.6(0x400la000) /lib/ld-linux.so.2=>/lib/ld-linux.so.2 (0x40000000) 
    從上面的結果可以繼續查看printf最終在哪裏被定義，有興趣可以go on 


6.4、生成庫 
    第一步要把源代碼編繹成目標代碼。 
    以下面的代碼爲例，生成上面用到的hello庫： 
    /* hello.c */ 
    #include   
    void sayhello() 
    { 
      printf("hello,world "); 
    } 
    用gcc編繹該文件，在編繹時可以使用任何全法的編繹參數，例如-g加入調試代碼等： gcc -c hello.c -o hello.o 
    (1)連接成靜態庫 連接成靜態庫使用ar命令，其實ar是archive的意思 
    $ar cqs libhello.a hello.o 
    (2)連接成動態庫 生成動態庫用gcc來完成，由於可能存在多個版本，因此通常指定版本號： 
    $gcc -shared -Wl,-soname,libhello.so.1 -o libhello.so.1.0 hello.o 
    另外再建立兩個符號連接： 
    $ln -s libhello.so.1.0 libhello.so.1 
    $ln -s libhello.so.1 libhello.so 
       這樣一個libhello的動態連接庫就生成了。最重要的是傳gcc -shared 參數使其生成是動態庫而不是普通執行程序。選項 
    -Wl 表示後面的參數也就是-soname,libhello.so.1是準備留給連接器ld(link drive)進行處理。實際上，
    每一個庫都有一個soname(如果沒有用-Wl,-soname,xxxxx.so.x指定的話,就是生成庫的文件名,soname<=libname)，
    當連接器發現它正在查找的程序庫中有這樣一個soname(不管是手動還是缺省的)，連接器便會將其提取出來嵌入連結中的二進制文件內，
    而不是它正在運行的實際文件名，在程序執行期間，程序就會以soname名字去查找庫文件，而不是庫的文件名，
    爲了保證通過soname能定位到庫文件,我們還要建立soname和庫文件的鏈接關係。同樣的,爲了保證編譯的時候可以通過-l選項定位動態庫, 
    那麼我們還要創建一個 這樣形式的鏈接 libxxxxx.so 去關聯庫文件．所以纔有上面兩個ln命令的使用.
       爲了保證運行時,不會出現庫導入錯誤,可以運行 ldd 命令 來測試 鏈接進目標文件的 soname 是否可以導入相關的庫文件.
    如果出現了none的地方,就要看看庫所在目錄是否添加到可以搜索到的地方了呢.
    把soname作爲庫的區分標誌, 這樣做的目的主要是允許系統中多個版本的庫文件共存，
    也就是說,soname是庫的區分標誌,習慣上在命名庫文件的時候通常與soname相同 libxxxx.so.major.minor 其中，
    xxxx是庫的名字，major是主版本號，minor 是次版本號.