Хочу разобраться с таблицами экспорта в C/C++ библиотеках/исп. файлах.

Для них есть какие-то правила формирования имён символов или каждый компилятор заворачивает двойные двоеточия ("::") как-то по-своему?

ЕМНИП, да.

Правильно я понимаю, что static глобальные переменные не попадут в таблицу экспорта, обеспечивая локальность символа для данной единицы трансляции?

Да.

А если надо заюзать глобальную переменную из другой единицы трансляции, то нужно объявить эту переменную со словом extern?

Нет, если переменная статическая, то она доступна только из этого файла. Никак ты её из другого не заюзаешь.

Что такое hidden visibility в gcc?

http://gcc.gnu.org/wiki/Visibility

А вообще, подписался на тред, ждём местных гуру.

PS На тему visibility ещё вот

Нет, если переменная статическая, то она доступна только из этого файла. Никак ты её из другого не заюзаешь.

Я имел ввиду не статическую, а обычную глобальную. Щас проверил - я прав.

t1.cpp

#include <iostream>
//int variable = 1;
extern int variable;

int f_t2(int);

int main(void)
{
	std::cout << "variable " << variable << "\n";
	std::cout << f_t2( 2 ) << "\n";	
	return 0;
}

t2.cpp:

#include <iostream>

int variable = 2;

int f_t2(int _x)
{

	std::cout << "\nf_t2()\n";
	return _x*2;
	
}

xx@(none) ~ $ g++ t1.cpp t2.cpp -o t
xx@(none) ~ $ ./t 
variable 2

f_t2()
4

Если какой-то символ где-то дублируется, линкер матерится (как оно под разными платформами)?

А при чём тут платформа? Один и тот же ld может работать и под виндами, и под макосью, и даже под линухом.

Есть ли в таблице экспорта какая-то «разная степень видимости»?

Насколько я помню, нет.

Для них есть какие-то правила формирования имён символов или каждый компилятор заворачивает двойные двоеточия ("::") как-то по-своему?

Каждый по-своему. Поэтому, в частности, если нужно совместно использовать код, сделанный разными компиляторами, то приходится делать C-обёртки (extern «C»).

Что сделать в C/C++ - программе, чтобы обеспечить символу присутствие в таблице экспорта?

Да, в общем, ничего. Пляски нужны, чтобы символ в таблицу экспорта не попал.

Я, правда, не знаю — локальный класс, объявленный внутри функции, в таблицу экспорта попадёт? В принципе, он там ни для чего не нужен.

Чето я не понял:

struct A {
   void f() {} 
};

namespace {
    struct NA {
        void f() {}
    };
}

void f() {
    struct FA {
        void f() {}
    };
    FA fa;
    fa.f();
    A a;
    a.f();
    NA na;
    na.f();
}

$ g++ -c test.cpp
$ nm -gC test.o 
0000000000000014 T f()
0000000000000000 W A::f()

То есть попадает только функция f() и метод A::f(). Почему не попадает NA, понятно. Классы не экспортируются чтоли? Или я как-то не так смотрю?

Если какой-то символ где-то дублируется, линкер матерится

Если символ дублируется в библиотеках - ругаться не будет. К тому же, бывают слабые и общие символы - они могут дублироваться (man nm).

Так ты его запихал в анонимный неймспейс. Оно и не должно попадать.

Про анонимный неймспейс понятное дело. Я имею в виду, экспортируются только имена функций? Почему не экспортируются классы полностью: конструкторы, деструкторы?

Может быть компилятор решил не генерировать какой-либо код конструктора и деструктора вообще, ибо ваши структуры представляют собой сущности размером в ноль байт, где нечего конструировать и деконструировать? Это в стандарте написано, что у каждого класса/структуры обязательно будет конструктор, на крайняк умолчательный. Но компиляторы помимо стандарта взаимодействуют с реальным миром, где часто есть возможность оптимизации. Компилятор посмотрел на вашу структуру и подумал: пускай чувак считает, что у него есть умолчательный конструктор, который ничего не делает. Но его реализация ничем не будет отличаться от полного его отсутствия: я конечно могу ему родить функцию с 10 инструкциями «nop» внутри, но нахрена козе боян?

А, понял. Так оно просто не нужно. Ни конструктор, ни деструктор ни фига не делают, и компилятор это прекрасно знает.

Другой вопрос, если ты напишешь конструктор лично, пусть даже пустой. Или, дабы повыпендриваться, добавишь, скажем, инициализируемое поле:

struct B {
   B() {}
};

struct A {
   void f() {}
   B b;
};

namespace U {
    struct NA {
        void f() {}
    };
}

void f() {
    struct FA {
        void f() {}
    };
    FA fa;
    fa.f();
    A a;
    a.f();
    U::NA na;
    na.f();
}

00000005 T f()
00000000 T A::f()
00000000 T A::A()
00000000 T B::B()
00000000 T U::NA::f()

Штука в том, что по одному лишь описанию структур (обычно - в заголовочном файле) компилятор может понять, нужно ли экспортировать конструктор; а это нужно, как раз, в том случае, когда конструктор специфицирован явно у самой структуры, у одного из её членов или у одного из её предков. Соответственно, компилируя тот же заголовочный файл ещё раз (в составе другого c-файла), компилятор сделает тот же вывод, и отсутствующий конструктор вызвать не попытается.