C 編譯鏈接

int printf(const char* format, ...);
int global_init_var = 84;
int global_uninit_var;
void func1(int i)
{
printf("%d\n", i);
}
int main(void)
{
static int static_var = 85;
static int static_var2;
<span class="kt">int</span> <span class="n">a</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">b</span><span class="p">;</span>

<span class="n">func1</span><span class="p">(</span><span class="n">static_var</span> <span class="o">+</span> <span class="n">static_var2</span> <span class="o">+</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">);</span>

<span class="k">return</span> <span class="n">a</span><span class="p">;</span>

}

$ objcopy -I binary -O elf32-i386 -B i386 example.png image.o
$ objdump -ht image.o
image.o:     file format elf32-i386
Sections:
Idx Name          Size      VMA       LMA       File off  Algn
0 .data         000293d6  00000000  00000000  00000034  2**0
CONTENTS, ALLOC, LOAD, DATA
SYMBOL TABLE:
00000000 l    d  .data	00000000 .data
00000000 g       .data	00000000 _binary_example_png_start
000293d6 g       .data	00000000 _binary_example_png_end
000293d6 g       ABS	00000000 _binary_example_png_size

__attribute__((section("FOO"))) int global = 42;
__attribute__((section("BAR"))) void foo() { }

$ gcc -E main.c -o main.i          # C
$ cpp main.c > main.i              # CPP

$ gcc -S hello.i -o hello.s
$ gcc -S main.c -o main.s

$ gcc -c hello.s -o hello.o
$ as main.s -o main.o
$ gcc -c main.s -o main.o
$ gcc -c main.c -o main.o

$ gcc hello.o -o hello.exe

# ln -s libhello.so.1.0 libhello.so.1
# ln -s libhello.so.1 libhello.so

$ readelf -l a.out | grep interpreter

$ gcc -o test test.o -L. -lhello -Wl,-rpath,/home/lib:.
$ readelf -d test | grep RPATH
$ objdump -s -j .dynstr test                     // 查看.dynstr段的內容

$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/test/lib

/* filename: foobar.c */
#include "hello.h"
#include <stdio.h>
void foobar()
{
   printf("FooBar!\n");
}

/* filename: hello.c */
#include "hello.h"
#include <stdio.h>
void hello()
{
   printf("Hello world!\n");
}

/* filename: hello.h */
#ifndef _HELLO_H__
#define _HELLO_H__
void hello();
void foobar();
#endif

/* filename: main.c */
#include "hello.h"
int main(int argc, char **argv)
{
   foobar();
   hello();
   return 0;
}

$ gcc -c hello.c -o hello.o
$ gcc -c foobar.c -o foobar.o
$ ar crv libhello.a hello.o foobar.o
$ ar -t libhello.a                              // 查看打包的文件

$ echo "hello" > a.txt && echo "world" > b.txt
$ ar crv text.a a.txt b.txt
$ cat text.a

$ gcc main.c -o test -lhello                    // 庫在默認路徑下，如/usr/lib
$ gcc main.c -lhello -L. -static -o main        // 通過-L指定庫的路徑
$ gcc main.o -o main -WI,-Bstatic -lhello       // 報錯，顯示找不到-lgcc_s

$ gcc testlib.o -o test -WI,-Bstatic -lhello -WI,-Bdynamic -lbye

$ gcc -c main.c
$ ld main.o -L. -lhello

$ gcc -c -fPIC hello.c -o hello.o
$ 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
$ gcc -fPIC -shared -o libhello.so hello.c                         // 當然對於上述的步驟可以通過一步完成
$ readelf -d libhello.so.1.0 | grep SONAME                         // 查看對應的soname
$ nm -D libhello.so                                                // 查看符號

$ nm libhello.so

$ ldd -v hello
$ readelf -d hello     直接使用readelf

libc.so.x        基本C庫
ld-linux.so.2    動態裝入庫(用於動態鏈接庫的裝入及運行)

$ readelf -l EXECUTABLE

void *dlopen( const char *file, int mode );
  用來打開一個文件，使對象文件可被程序訪問，同時還會自動解析共享庫中的依賴項，這樣，如果打開了一個
    依賴於其他共享庫的對象，它就會自動加載它們，該函數返回一個句柄，該句柄用於後續的 API 調用。
  mode 參數通知動態鏈接器何時執行再定位，有兩個可能的值：
    A) RTLD_NOW，表明動態鏈接器將會在調用 dlopen 時完成所有必要的再定位；
    B) RTLD_LAZY，只在需要時執行再定位。
void *dlsym( void *restrict handle, const char *restrict name );
通過句柄和連接符名稱獲取函數名或者變量名。
char *dlerror();
返回一個可讀的錯誤字符串，該函數沒有參數，它會在發生前面的錯誤時返回一個字符串，在沒有錯誤發生時返回NULL。
char *dlclose( void *handle );
通知操作系統不再需要句柄和對象引用了。它完全是按引用來計數的，所以同一個共享對象的多個用戶相互間
不會發生衝突（只要還有一個用戶在使用它，它就會待在內存中）。
任何通過已關閉的對象的 dlsym 解析的符號都將不再可用。

$ gcc -rdynamic -o dl library_libdl.c -ldl        # 編譯
$ ./dl                                            # 測試
> libm.so cosf 0.0
   1.000000
> libm.so sinf 0.0
   0.000000
> libm.so tanf 1.0
   1.557408
> bye

$ cat caculate.c                                     # 查看動態庫源碼
int add(int a, int b) {
    return (a + b);
}
int sub(int a, int b) {
    return (a - b);
}
$ gcc -fPIC -shared caculate.c -o libcaculate.so     # 生成動態庫
$ cat foobar.c                                       # 測試源碼
#include <stdio.h>
#include <dlfcn.h>
#include <stdlib.h>
typedef int (CAC_FUNC)(int, int);                           // 定義函數指針類型
int main(int argc, char* argv) {
void *handle;
char *error;
CAC_FUNC cac_func = NULL;
if ( !(handle=dlopen("./libcaculate.so", RTLD_LAZY)) ) { // 打開動態鏈接庫
    fprintf(stderr, "!!! %s\n", dlerror());
    exit(EXIT_FAILURE);
}

cac_func = dlsym(handle, "add");                         // 獲取一個函數
if ((error = dlerror()) != NULL)  {
    fprintf(stderr, "!!! %s\n", error);
    exit(EXIT_FAILURE);
}
printf("add: %d\n", (cac_func)(2,7));

dlclose(handle);                                         // 關閉動態鏈接庫
exit(EXIT_SUCCESS);

}
$ gcc -rdynamic -o foobar foobar.c -ldl              # 編譯測試

-h, --section-headers, --headers
  查看目標文件的頭部信息。
-x, --all-headers
  顯示所有的頭部信息，包括了符號表和重定位表，等價於 -a -f -h -p -r -t 。
-s, --full-contents
  顯示所請求段的全部信息，通常用十六進製表示，默認只會顯示非空段。
-d, --disassemble
  反彙編，一般只反彙編含有指令的段。
-t, --syms
  顯示符號表，與nm類似，只是顯示的格式不同，當然顯示與文件的格式相關，對於ELF如下所示。
  00000000 l    d  .bss   00000000 .bss
  00000000 g       .text  00000000 fred

$ readelf -S hello

$ strip hello

常用參數：
  -S / --strip-all
    不從源文件中拷貝重定位信息和符號信息到輸出文件(目的文件)中去。
  -I bfdname/--input-target=bfdname
    明確告訴程序源文件的格式是什麼，bfdname是BFD庫中描述的標準格式名。
  -O bfdname/--output-target=bfdname
    使用指定的格式來寫輸出文件(即目標文件)，bfdname是BFD庫中描述的標準格式名，
    如binary(raw binary 格式)、srec(s-record 文件)。
  -R sectionname/--remove-section=sectionname
    從輸出文件中刪掉所有名為section-name的段。

$ objcopy -R .comment -R .note.ABI-tag -R .gnu.version hello hello1

常用參數：
  -a --all
    等價於-h -l -S -s -r -d -V -A -I
  -h --file-header
    文件頭信息；
  -l --program-headers
    程序的頭部信息；
  -S --section-headers
    各個段的頭部信息；
  -e --headers
    全部頭信息，等價於-h -l -S；
示例用法：
----- 讀取dynstr段，包含了很多需要加載的符號，每個動態庫後跟著需要加載函數
$ readelf -p .dynstr hello
----- 查看是否含有調試信息
$ readelf -S hello | grep debug