我正在从没有源代码的静态库中创建共享库。
许多堆栈溢出问题提供了关于answers的解决方法：
gcc -shared -o libxxx.so -Wl,--whole-archive libxxx.a -Wl,--no-whole-archive
但是，静态库的某些公共函数作为共享库中的隐藏函数包括在内：
$ nm --defined-only libxxx.a | grep __intel_cpu_indicator_init
0000000000000000 T __intel_cpu_indicator_init
$ nm libxxx.so | grep __intel_cpu_indicator_init
00000000030bb160 t __intel_cpu_indicator_init
__ intel_cpu_indicator_init符号从导出变为隐藏。
它不是该过程中唯一隐藏的符号：
$ nm libxxx.a | grep ' T ' | wc -l
37969
$ nm libxxx.so | grep ' T ' | wc -l
37548
$ nm libxxx.a | grep ' t ' | wc -l
62298
$ nm libxxx.so | grep ' t ' | wc -l
62727
请注意，37969 + 62298 = 100267和37548 + 62727 = 100275。
我可以做些什么使链接程序生成一个共享库，其中包含静态库中的所有公共符号，也可以在共享库中公开吗？
答案 0 :(得分：1)
当某些全局符号定义在某些
libxxx.a中归档的目标文件是用function attribute编译的
或variable attribute visibility("hidden")
此属性的作用是，当目标文件包含 全局符号定义链接到共享库中：
.symtab）中，符号的链接从全局更改为局部，
因此，当该共享库与其他任何库链接时，链接器将看不到符号的定义。.dynsym）中（默认情况下为）
因此，当将共享库加载到进程中时，加载器同样无法找到该符号的定义。简而言之，出于动态链接的目的，隐藏了目标文件中的全局符号定义。
使用以下方法进行检查：
$ readelf -s libxxx.a | grep HIDDEN
，我希望您能获得未导出的全局符号的点击量。如果没有 您无需再阅读，因为我对您看到的内容没有其他解释 而且不会指望我建议不要用脚开枪射击。
这是一个例子：
交流
#include <stdio.h>
void aa(void)
{
puts(__func__);
}
b.c
#include <stdio.h>
void __attribute__((visibility("hidden"))) bb(void)
{
puts(__func__);
}
de.c
#include <stdio.h>
void __attribute__((visibility("default"))) dd(void)
{
puts(__func__);
}
void ee(void)
{
puts(__func__);
}
我们将像这样编译a.c和b.c：
$ gcc -Wall -c a.c b.c
我们可以看到符号aa和ab在它们各自的对象文件中已定义并且是全局的：
$ nm --defined-only a.o b.o
a.o:
0000000000000000 T aa
0000000000000000 r __func__.2361
b.o:
0000000000000000 T bb
0000000000000000 r __func__.2361
但是我们也可以观察到这种差异：
$ readelf -s a.o
Symbol table '.symtab' contains 13 entries:
Num: Value Size Type Bind Vis Ndx Name
...
10: 0000000000000000 19 FUNC GLOBAL DEFAULT 1 aa
...
相比：
$ readelf -s b.o
Symbol table '.symtab' contains 13 entries:
Num: Value Size Type Bind Vis Ndx Name
...
10: 0000000000000000 19 FUNC GLOBAL HIDDEN 1 bb
...
aa是具有GLOBAL可见度的DEFAULT符号，而bb是GLOBAL
具有HIDDEN可见性的符号。
我们将以不同的方式编译de.c：
$ gcc -Wall -fvisibility=hidden -c de.c
在这里，我们指示编译器任何符号都应隐藏
可见性，除非为以下对象指定了反补贴的visibility属性
它在源代码中。因此，我们看到：
$ readelf -s de.o
Symbol table '.symtab' contains 15 entries:
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
...
11: 0000000000000000 19 FUNC GLOBAL DEFAULT 1 dd
...
14: 0000000000000013 19 FUNC GLOBAL HIDDEN 1 ee
在静态库中归档这些目标文件不会改变它们：
$ ar rcs libabde.a a.o b.o de.o
然后将它们都链接到共享库中
$ gcc -o libabde.so -shared -Wl,--whole-archive libabde.a -Wl,--no-whole-archive
我们发现：
$ readelf -s libabde.so | egrep '(aa|bb|dd|ee|Symbol table)'
Symbol table '.dynsym' contains 8 entries:
6: 0000000000001105 19 FUNC GLOBAL DEFAULT 12 aa
7: 000000000000112b 19 FUNC GLOBAL DEFAULT 12 dd
Symbol table '.symtab' contains 59 entries:
45: 0000000000001118 19 FUNC LOCAL DEFAULT 12 bb
51: 000000000000113e 19 FUNC LOCAL DEFAULT 12 ee
54: 0000000000001105 19 FUNC GLOBAL DEFAULT 12 aa
56: 000000000000112b 19 FUNC GLOBAL DEFAULT 12 dd
bb和ee（在目标文件中具有GLOBAL可见性的HIDDEN），
LOCAL在libabde.so的静态符号中，并且完全不存在
从其动态符号表中获取。
鉴于此，您可能希望重新评估您的任务：
在libxxx.a的目标文件中被赋予隐藏可见性的符号具有
被隐藏，因为编辑它们的人有理由
希望将他们隐藏在动态联系之外。您是否有需要的反补贴
导出它们以进行动态链接？还是您只想导出它们，因为
您已经注意到它们没有导出，也不知道为什么不这样做？
但是，如果您想取消隐藏隐藏的符号，并且无法更改源代码
在libxxx.a中归档的目标文件中，最不麻烦的方法是：
libxxx.a提取每个目标文件HIDDEN可视性替换DEFAULT libyyy.a libyyy.a代替libxxx.a。用于篡改目标文件的binutils工具是objcopy。
但是objcopy无法直接操作
一个符号，您就必须为“达到效果
“”隐藏隐藏的符号：
objcopy --redefine-sym，将每个隐藏的全局符号S重命名为__hidden__S。objcopy --add-symbol，添加一个新的全局符号S，其值与__hidden_S相同
但默认情况下获得DEFAULT可见性。最后出现两个具有相同定义的符号：原始隐藏的一个 以及新的未隐藏别名。
更可取的是，可以简单而又更改符号在 一个ELF目标文件，一种方法是提交LIEF library (Library to Instrument Executable Formats)- 瑞士军队电锯用于对象和可执行文件的更改 1 。
这是一个Python脚本，它调用pylief（LIEF Python模块）取消隐藏
ELF对象文件中隐藏的全局变量：
unhide.py
#!/usr/bin/python
# unhide.py - Replace hidden with default visibility on global symbols defined
# in an ELF object file
import argparse, sys, lief
from lief.ELF import SYMBOL_BINDINGS, SYMBOL_VISIBILITY, SYMBOL_TYPES
def warn(msg):
sys.stderr.write("WARNING: " + msg + "\n")
def unhide(objfile_in, objfile_out = None, namedsyms=None):
if not objfile_out:
objfile_out = objfile_in
binary = lief.parse(objfile_in)
allsyms = { sym.name for sym in binary.symbols }
selectedsyms = set([])
nasyms = { sym.name for sym in binary.symbols if \
sym.type == SYMBOL_TYPES.NOTYPE or \
sym.binding != SYMBOL_BINDINGS.GLOBAL or \
sym.visibility != SYMBOL_VISIBILITY.HIDDEN }
if namedsyms:
namedsyms = set(namedsyms)
nosyms = namedsyms - allsyms
for nosym in nosyms:
warn("No symbol " + nosym + " in " + objfile_in + ": ignored")
for sym in namedsyms & nasyms:
warn("Input symbol " + sym + \
" is not a hidden global symbol defined in " + objfile_in + \
": ignored")
selectedsyms = namedsyms - nosyms
else:
selectedsyms = allsyms
selectedsyms -= nasyms
unhidden = 0;
for sym in binary.symbols:
if sym.name in selectedsyms:
sym.visibility = SYMBOL_VISIBILITY.DEFAULT
unhidden += 1
print("Unhidden: " + sym.name)
print("{} symbols were unhidden".format(unhidden))
binary.write(objfile_out)
def get_args():
parser = argparse.ArgumentParser(
description="Replace hidden with default visibility on " + \
"global symbols defined in an ELF object file.")
parser.add_argument("ELFIN",help="ELF object file to read")
parser.add_argument("-s","--symbol",metavar="SYMBOL",action="append",
help="Unhide SYMBOL. " + \
"If unspecified, unhide all hidden global symbols defined in ELFIN")
parser.add_argument("--symfile",
help="File of whitespace-delimited symbols to unhide")
parser.add_argument("-o","--out",metavar="ELFOUT",
help="ELF object file to write. If unspecified, rewrite ELFIN")
return parser.parse_args()
def main():
args = get_args()
objfile_in = args.ELFIN
objfile_out = args.out
symlist = args.symbol
if not symlist:
symlist = []
symfile = args.symfile
if symfile:
with open(symfile,"r") as fh:
symlist += [word for line in fh for word in line.split()]
unhide(objfile_in,objfile_out,symlist)
main()
用法：
$ ./unhide.py -h
usage: unhide.py [-h] [-s SYMBOL] [--symfile SYMFILE] [-o ELFOUT] ELFIN
Replace hidden with default visibility on global symbols defined in an ELF
object file.
positional arguments:
ELFIN ELF object file to read
optional arguments:
-h, --help show this help message and exit
-s SYMBOL, --symbol SYMBOL
Unhide SYMBOL. If unspecified, unhide all hidden
global symbols defined in ELFIN
--symfile SYMFILE File of whitespace-delimited symbols to unhide
-o ELFOUT, --out ELFOUT
ELF object file to write. If unspecified, rewrite
ELFIN
这是一个shell脚本：
unhide.sh
#!/bin/bash
OLD_ARCHIVE=$1
NEW_ARCHIVE=$2
OBJS=$(ar t $OLD_ARCHIVE)
for obj in $OBJS; do
rm -f $obj
ar xv $OLD_ARCHIVE $obj
./unhide.py $obj
done
rm -f $NEW_ARCHIVE
ar rcs $NEW_ARCHIVE $OBJS
echo "$NEW_ARCHIVE made"
需要：
$1 =现有静态库的名称$2 =新静态库的名称并创建包含$2中目标文件的$1，每次修改
unhide.py取消隐藏其所有隐藏的全局定义。
返回我们的插图，我们可以运行：
$ ./unhide.sh libabde.a libnew.a
x - a.o
0 symbols were unhidden
x - b.o
Unhidden: bb
1 symbols were unhidden
x - de.o
Unhidden: ee
1 symbols were unhidden
libnew.a made
并确认可以使用：
$ readelf -s libnew.a | grep HIDDEN; echo Done
Done
$ readelf -s libnew.a | egrep '(aa|bb|dd|ee)'
10: 0000000000000000 19 FUNC GLOBAL DEFAULT 1 aa
10: 0000000000000000 19 FUNC GLOBAL DEFAULT 1 bb
11: 0000000000000000 19 FUNC GLOBAL DEFAULT 1 dd
14: 0000000000000013 19 FUNC GLOBAL DEFAULT 1 ee
最后，如果我们将共享库与新档案重新链接
$ gcc -o libabde.so -shared -Wl,--whole-archive libnew.a -Wl,--no-whole-archive
存档中的所有全局符号都已导出：
$ readelf --dyn-syms libabde.so | egrep '(aa|bb|dd|ee)'
6: 0000000000001105 19 FUNC GLOBAL DEFAULT 12 aa
7: 000000000000112b 19 FUNC GLOBAL DEFAULT 12 dd
8: 0000000000001118 19 FUNC GLOBAL DEFAULT 12 bb
9: 000000000000113e 19 FUNC GLOBAL DEFAULT 12 ee
[1] Download C/C++/Python libraries
Debian / Ubuntu提供了C / C ++开发人员软件包lief-dev。