From: Mathieu Desnoyers Date: Sun, 22 May 2016 15:26:00 +0000 (-0400) Subject: Fix: test weak-hidden symbols X-Git-Tag: v2.9.0-rc1~92 X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=3227b2b93e5eafe5e9ab5fcbad718eb36cd4a383;p=lttng-ust.git Fix: test weak-hidden symbols On many architectures (arm32, arm64, powerpc64) gcc chooses to assign different addresses to weak-hidden symbols from different compile units within the same module. This is unfortunate, but still OK with respect to tracepoints. The real issue is on 32-bit powerpc, where gcc (in O1 or more) assigns different addresses only for objects larger than 8 bytes, but same addresses for objects of 8 bytes or less (int and pointers). Signed-off-by: Mathieu Desnoyers --- diff --git a/tests/gcc-weak-hidden/b.c b/tests/gcc-weak-hidden/b.c index 2419ed9f..218a1545 100644 --- a/tests/gcc-weak-hidden/b.c +++ b/tests/gcc-weak-hidden/b.c @@ -1,6 +1,20 @@ -char testsym[9] __attribute__((weak, visibility("hidden"))); +int testint __attribute__((weak, visibility("hidden"))); +void *testptr __attribute__((weak, visibility("hidden"))); +struct { + char a[24]; +} testsym_24_bytes __attribute__((weak, visibility("hidden"))); -void *fct1(void) +void *testfct_int(void) { - return testsym; + return &testint; +} + +void *testfct_ptr(void) +{ + return &testptr; +} + +void *testfct_24_bytes(void) +{ + return &testsym_24_bytes; } diff --git a/tests/gcc-weak-hidden/c.c b/tests/gcc-weak-hidden/c.c index 59f9046d..1a744e29 100644 --- a/tests/gcc-weak-hidden/c.c +++ b/tests/gcc-weak-hidden/c.c @@ -1,6 +1,20 @@ -char testsym[9] __attribute__((weak, visibility("hidden"))); +int testint __attribute__((weak, visibility("hidden"))); +void *testptr __attribute__((weak, visibility("hidden"))); +struct { + char a[24]; +} testsym_24_bytes __attribute__((weak, visibility("hidden"))); -void *fctlib1(void) +void *testlibfct1_int(void) { - return testsym; + return &testint; +} + +void *testlibfct1_ptr(void) +{ + return &testptr; +} + +void *testlibfct1_24_bytes(void) +{ + return &testsym_24_bytes; } diff --git a/tests/gcc-weak-hidden/d.c b/tests/gcc-weak-hidden/d.c index bb16bdb3..05e10b4e 100644 --- a/tests/gcc-weak-hidden/d.c +++ b/tests/gcc-weak-hidden/d.c @@ -1,6 +1,20 @@ -char testsym[9] __attribute__((weak, visibility("hidden"))); +int testint __attribute__((weak, visibility("hidden"))); +void *testptr __attribute__((weak, visibility("hidden"))); +struct { + char a[24]; +} testsym_24_bytes __attribute__((weak, visibility("hidden"))); -void *fctlib2(void) +void *testlibfct2_int(void) { - return testsym; + return &testint; +} + +void *testlibfct2_ptr(void) +{ + return &testptr; +} + +void *testlibfct2_24_bytes(void) +{ + return &testsym_24_bytes; } diff --git a/tests/gcc-weak-hidden/main.c b/tests/gcc-weak-hidden/main.c index a2f31756..b4542f79 100644 --- a/tests/gcc-weak-hidden/main.c +++ b/tests/gcc-weak-hidden/main.c @@ -10,22 +10,79 @@ * granted, provided the above notices are retained, and a notice that * the code was modified is included with the above copyright notice. */ + +#include #include "tap.h" #define NUM_TESTS 2 -char testsym[9] __attribute__((weak, visibility("hidden"))); +int testint __attribute__((weak, visibility("hidden"))); +void *testptr __attribute__((weak, visibility("hidden"))); +struct { + char a[24]; +} testsym_24_bytes __attribute__((weak, visibility("hidden"))); + +void *testfct_int(void); +void *testfct_ptr(void); +void *testfct_24_bytes(void); + +void *testlibfct1_int(void); +void *testlibfct1_ptr(void); +void *testlibfct1_24_bytes(void); + +void *testlibfct2_int(void); +void *testlibfct2_ptr(void); +void *testlibfct2_24_bytes(void); + +enum { + MATCH_PROGRAM_INT, + MATCH_PROGRAM_PTR, + MATCH_PROGRAM_24_BYTES, + MATCH_LIB_INT, + MATCH_LIB_PTR, + MATCH_LIB_24_BYTES, + NR_MATCH, +}; -void *fct1(void); -void *fctlib1(void); -void *fctlib2(void); +static bool match_matrix[NR_MATCH]; int main() { plan_tests(NUM_TESTS); - ok(fct1() == testsym, - "Address of weak symbol with hidden visibility match between compile units within same module for main program"); - ok(fctlib1() == fctlib2(), - "Address of weak symbol with hidden visibility match between compile units within same module for shared library"); + + if (testfct_int() == &testint) + match_matrix[MATCH_PROGRAM_INT] = true; + if (testfct_ptr() == &testptr) + match_matrix[MATCH_PROGRAM_PTR] = true; + if (testfct_24_bytes() == &testsym_24_bytes) + match_matrix[MATCH_PROGRAM_24_BYTES] = true; + + if (testlibfct1_int() == testlibfct2_int()) + match_matrix[MATCH_LIB_INT] = true; + if (testlibfct1_ptr() == testlibfct2_ptr()) + match_matrix[MATCH_LIB_PTR] = true; + if (testlibfct1_24_bytes() == testlibfct2_24_bytes()) + match_matrix[MATCH_LIB_24_BYTES] = true; + + diag("Address of weak symbol with hidden visibility %s between compile units within same module for main program (4 bytes integer object)", + match_matrix[MATCH_PROGRAM_INT] ? "match" : "MISMATCH"); + diag("Address of weak symbol with hidden visibility %s between compile units within same module for main program (pointer object)", + match_matrix[MATCH_PROGRAM_PTR] ? "match" : "MISMATCH"); + diag("Address of weak symbol with hidden visibility %s between compile units within same module for main program (24 bytes structure object)", + match_matrix[MATCH_PROGRAM_24_BYTES] ? "match" : "MISMATCH"); + + diag("Address of weak symbol with hidden visibility %s between compile units within same module for shared library (4 bytes integer object)", + match_matrix[MATCH_LIB_INT] ? "match" : "MISMATCH"); + diag("Address of weak symbol with hidden visibility %s between compile units within same module for shared library (pointer object)", + match_matrix[MATCH_LIB_PTR] ? "match" : "MISMATCH"); + diag("Address of weak symbol with hidden visibility %s between compile units within same module for shared library (24 bytes structure object)", + match_matrix[MATCH_LIB_24_BYTES] ? "match" : "MISMATCH"); + + ok(match_matrix[MATCH_PROGRAM_INT] == match_matrix[MATCH_PROGRAM_PTR] + && match_matrix[MATCH_PROGRAM_INT] == match_matrix[MATCH_PROGRAM_24_BYTES], + "Weak-hidden behavior is the same for 4 bytes integer, pointer, and 24 bytes structure objects for within main program"); + ok(match_matrix[MATCH_LIB_INT] == match_matrix[MATCH_LIB_PTR] + && match_matrix[MATCH_LIB_INT] == match_matrix[MATCH_LIB_24_BYTES], + "Weak-hidden behavior is the same for 4 bytes integer, pointer, and 24 bytes structure objects for within shared library"); return 0; }