1 #ifndef NULL 2 #define NULL ((void *) 0) 3 #endif 4 5 /* This is part of the shared library ld test. This file becomes part 6 of a shared library. */ 7 8 /* This variable is supplied by the main program. */ 9 #ifndef XCOFF_TEST 10 extern int mainvar; 11 #endif 12 13 /* This variable is defined in the shared library, and overridden by 14 the main program. */ 15 #ifndef XCOFF_TEST 16 #ifdef SHARED 17 /* SHARED is defined if we are compiling with -fpic/-fPIC. */ 18 int overriddenvar = -1; 19 #else 20 /* Without -fpic, newer versions of gcc assume that we are not 21 compiling for a shared library, and thus that overriddenvar is 22 local. */ 23 extern int overriddenvar; 24 #endif 25 #endif 26 27 /* This variable is defined in the shared library. */ 28 int shlibvar1 = 3; 29 30 /* This variable is defined by another object in the shared library. */ 31 extern int shlibvar2; 32 33 /* These functions return the values of the above variables as seen in 34 the shared library. */ 35 36 #ifndef XCOFF_TEST 37 int 38 shlib_mainvar () 39 { 40 return mainvar; 41 } 42 #endif 43 44 #ifndef XCOFF_TEST 45 int 46 shlib_overriddenvar () 47 { 48 return overriddenvar; 49 } 50 #endif 51 52 int 53 shlib_shlibvar1 () 54 { 55 return shlibvar1; 56 } 57 58 int 59 shlib_shlibvar2 () 60 { 61 return shlibvar2; 62 } 63 64 /* This function calls a function defined by another object in the 65 shared library. */ 66 67 extern int shlib_shlibcalled (); 68 69 int 70 shlib_shlibcall () 71 { 72 return shlib_shlibcalled (); 73 } 74 75 #ifndef XCOFF_TEST 76 /* This function calls a function defined in this object in the shared 77 library. The main program will override the called function. */ 78 79 extern int shlib_overriddencall2 (); 80 81 int 82 shlib_shlibcall2 () 83 { 84 return shlib_overriddencall2 (); 85 } 86 87 #ifdef SHARED 88 int 89 shlib_overriddencall2 () 90 { 91 return 7; 92 } 93 #endif 94 #endif 95 96 /* This function calls a function defined by the main program. */ 97 98 #ifndef XCOFF_TEST 99 extern int main_called (); 100 101 int 102 shlib_maincall () 103 { 104 return main_called (); 105 } 106 #endif 107 108 /* This function is passed a function pointer to shlib_mainvar. It 109 confirms that the pointer compares equally. */ 110 111 int 112 shlib_checkfunptr1 (p) 113 int (*p) (); 114 { 115 return p == shlib_shlibvar1; 116 } 117 118 /* This function is passed a function pointer to main_called. It 119 confirms that the pointer compares equally. */ 120 121 #ifndef XCOFF_TEST 122 int 123 shlib_checkfunptr2 (p) 124 int (*p) (); 125 { 126 return p == main_called; 127 } 128 #endif 129 130 /* This function returns a pointer to shlib_mainvar. */ 131 132 int 133 (*shlib_getfunptr1 ()) () 134 { 135 return shlib_shlibvar1; 136 } 137 138 /* This function returns a pointer to main_called. */ 139 140 #ifndef XCOFF_TEST 141 int 142 (*shlib_getfunptr2 ()) () 143 { 144 return main_called; 145 } 146 #endif 147 148 /* This function makes sure that constant data and local functions 149 work. */ 150 151 #ifndef __STDC__ 152 #define const 153 #endif 154 155 static int i = 6; 156 static const char *str = "Hello, world\n"; 157 158 int 159 shlib_check () 160 { 161 const char *s1, *s2; 162 163 if (i != 6) 164 return 0; 165 166 /* To isolate the test, don't rely on any external functions, such 167 as strcmp. */ 168 s1 = "Hello, world\n"; 169 s2 = str; 170 while (*s1 != '\0') 171 if (*s1++ != *s2++) 172 return 0; 173 if (*s2 != '\0') 174 return 0; 175 176 if (shlib_shlibvar1 () != 3) 177 return 0; 178 179 return 1; 180 } 181 182 #ifdef HIDDEN_WEAK_TEST 183 #define HIDDEN_UNDEF_TEST 184 #define WEAK_TEST 185 #endif 186 187 #ifdef PROTECTED_WEAK_TEST 188 #define PROTECTED_UNDEF_TEST 189 #define WEAK_TEST 190 #endif 191 192 #if defined (HIDDEN_UNDEF_TEST) || defined (PROTECTED_UNDEF_TEST) 193 #ifdef WEAK_TEST 194 #pragma weak visibility 195 #endif 196 extern int visibility (); 197 #else 198 int 199 visibility () 200 { 201 return 2; 202 } 203 #endif 204 205 #ifdef HIDDEN_NORMAL_TEST 206 asm (".hidden visibility_normal"); 207 208 int 209 visibility_normal () 210 { 211 return 2; 212 } 213 #endif 214 215 int 216 visibility_checkfunptr () 217 { 218 #ifdef WEAK_TEST 219 return 1; 220 #else 221 #ifdef HIDDEN_NORMAL_TEST 222 int (*v) () = visibility_normal; 223 #else 224 int (*v) () = visibility; 225 #endif 226 return (*v) () == 2; 227 #endif 228 } 229 230 int 231 visibility_check () 232 { 233 #ifdef WEAK_TEST 234 if (&visibility) 235 return visibility () == 1; 236 else 237 return 1; 238 #else 239 #ifdef HIDDEN_NORMAL_TEST 240 return visibility_normal () == 2; 241 #else 242 return visibility () == 2; 243 #endif 244 #endif 245 } 246 247 void * 248 visibility_funptr () 249 { 250 #ifdef WEAK_TEST 251 if (&visibility == NULL) 252 return NULL; 253 else 254 #endif 255 return visibility; 256 } 257 258 #if defined (HIDDEN_UNDEF_TEST) || defined (PROTECTED_UNDEF_TEST) 259 #ifdef WEAK_TEST 260 #pragma weak visibility_var 261 #endif 262 extern int visibility_var; 263 #else 264 int visibility_var = 2; 265 #endif 266 267 #ifdef HIDDEN_NORMAL_TEST 268 asm (".hidden visibility_var_normal"); 269 270 int visibility_var_normal = 2; 271 #endif 272 273 int 274 visibility_checkvarptr () 275 { 276 #ifdef WEAK_TEST 277 if (&visibility_var) 278 return visibility_var == 1; 279 else 280 return 1; 281 #else 282 #ifdef HIDDEN_NORMAL_TEST 283 int *v = &visibility_var_normal; 284 #else 285 int *v = &visibility_var; 286 #endif 287 return *v == 2; 288 #endif 289 } 290 291 int 292 visibility_checkvar () 293 { 294 #ifdef WEAK_TEST 295 return 1; 296 #else 297 #ifdef HIDDEN_NORMAL_TEST 298 return visibility_var_normal == 2; 299 #else 300 return visibility_var == 2; 301 #endif 302 #endif 303 } 304 305 void * 306 visibility_varptr () 307 { 308 #ifdef WEAK_TEST 309 if (&visibility_var == NULL) 310 return NULL; 311 else 312 #endif 313 return &visibility_var; 314 } 315 316 int 317 visibility_varval () 318 { 319 #ifdef WEAK_TEST 320 if (&visibility_var == NULL) 321 return 0; 322 else 323 #endif 324 return visibility_var; 325 } 326 327 #if defined (HIDDEN_TEST) || defined (HIDDEN_UNDEF_TEST) 328 asm (".hidden visibility"); 329 asm (".hidden visibility_var"); 330 #else 331 #if defined (PROTECTED_TEST) || defined (PROTECTED_UNDEF_TEST) || defined (PROTECTED_WEAK_TEST) 332 asm (".protected visibility"); 333 asm (".protected visibility_var"); 334 #endif 335 #endif 336 337 #ifdef HIDDEN_NORMAL_TEST 338 int shlib_visibility_com; 339 asm (".hidden shlib_visibility_com"); 340 341 int 342 shlib_visibility_checkcom () 343 { 344 return shlib_visibility_com == 0; 345 } 346 347 int 348 shlib_visibility_checkweak () 349 { 350 return 1; 351 } 352 #elif defined (HIDDEN_WEAK_TEST) 353 #pragma weak shlib_visibility_undef_var_weak 354 extern int shlib_visibility_undef_var_weak; 355 asm (".hidden shlib_visibility_undef_var_weak"); 356 357 #pragma weak shlib_visibility_undef_func_weak 358 extern int shlib_visibility_undef_func_weak (); 359 asm (".hidden shlib_visibility_undef_func_weak"); 360 361 #pragma weak shlib_visibility_var_weak 362 extern int shlib_visibility_var_weak; 363 asm (".hidden shlib_visibility_var_weak"); 364 365 #pragma weak shlib_visibility_func_weak 366 extern int shlib_visibility_func_weak (); 367 asm (".hidden shlib_visibility_func_weak"); 368 369 int 370 shlib_visibility_checkcom () 371 { 372 return 1; 373 } 374 375 int 376 shlib_visibility_checkweak () 377 { 378 return &shlib_visibility_undef_var_weak == NULL 379 && &shlib_visibility_undef_func_weak == NULL 380 && &shlib_visibility_func_weak == NULL 381 && &shlib_visibility_var_weak == NULL; 382 } 383 #else 384 int 385 shlib_visibility_checkcom () 386 { 387 return 1; 388 } 389 390 int 391 shlib_visibility_checkweak () 392 { 393 return 1; 394 } 395 #endif 396 397 #ifdef PROTECTED_TEST 398 #ifdef SHARED 399 int shared_data = 100; 400 #else 401 extern int shared_data; 402 #endif 403 404 int * 405 shared_data_p () 406 { 407 return &shared_data; 408 } 409 410 int 411 shared_func () 412 { 413 return 100; 414 } 415 416 void * 417 shared_func_p () 418 { 419 return shared_func; 420 } 421 #endif 422
