This commit was manufactured by cvs2svn to create branch 'binutils-

[external/binutils.git] / ld / testsuite / ld-elfvsb / main.c

diff --git a/ld/testsuite/ld-elfvsb/main.c b/ld/testsuite/ld-elfvsb/main.c
index eef5c01..b498d43 100644 (file)
--- a/ld/testsuite/ld-elfvsb/main.c
+++ b/ld/testsuite/ld-elfvsb/main.c
@@ -1,3 +1,20 @@
+#ifdef PROTECTED_CHECK
+#include <features.h>
+#include <stdio.h>
+
+int
+main (void)
+{
+#if defined (__GLIBC__) && (__GLIBC__ > 2 \
+                           || (__GLIBC__ == 2 \
+                               &&  __GLIBC_MINOR__ >= 2))
+  puts ("yes");
+#else
+  puts ("no");
+#endif
+  return 0;
+}
+#else
 /* This is the main program for the shared library test.  */
 
 #include <stdio.h>
@@ -25,17 +42,31 @@ extern int visibility_checkvar ();
 extern int visibility_checkvarptr ();
 extern int visibility_varval ();
 extern void *visibility_varptr ();
+extern int shlib_visibility_checkcom ();
+extern int shlib_visibility_checkweak ();
+
+int shlib_visibility_com = 1;
+
+int shlib_visibility_var_weak = 1;
+
+int
+shlib_visibility_func_weak ()
+{
+  return 1;
+}
 
 #ifdef HIDDEN_WEAK_TEST
-#define HIDDEN_UNDEF_TEST
 #define WEAK_TEST
 #endif
 
 #ifdef PROTECTED_WEAK_TEST
-#define PROTECTED_UNDEF_TEST
 #define WEAK_TEST
 #endif
 
+#ifdef PROTECTED_UNDEF_TEST
+#define PROTECTED_TEST
+#endif
+
 #ifndef WEAK_TEST
 extern int visibility ();
 extern int visibility_var;
@@ -43,38 +74,55 @@ extern int visibility_var;
 
 #if !defined (HIDDEN_TEST) && defined (PROTECTED_TEST)
 int
-visibility ()
+visibility (void)
 {
   return 1;
 }
 
 static int
-main_visibility_check ()
+main_visibility_check (void)
 {
-  return visibility_funptr () != visibility;
+  return ((int (*) (void)) visibility_funptr ()) != visibility;
 }
 
 int visibility_var = 1;
 
 static int
-main_visibility_checkvar ()
+main_visibility_checkvar (void)
 {
   return visibility_varval () != visibility_var
         && visibility_varptr () != &visibility_var;
 }
+
+#ifndef PROTECTED_UNDEF_TEST
+int shared_data = 1;
+asm (".protected shared_data");
+
+int
+shared_func (void)
+{
+  return 1;
+}
+
+asm (".protected shared_func");
+
+extern int * shared_data_p ();
+typedef int (*func) ();
+extern func shared_func_p ();
+#endif
 #else
 static int
-main_visibility_check ()
+main_visibility_check (void)
 {
 #ifdef WEAK_TEST
   return visibility_funptr () == NULL;
 #else
-  return visibility_funptr () == visibility;
+  return ((int (*) (void)) visibility_funptr ()) == visibility;
 #endif
 }
 
 static int
-main_visibility_checkvar ()
+main_visibility_checkvar (void)
 {
 #ifdef WEAK_TEST
   return visibility_varval () == 0
@@ -89,7 +137,7 @@ main_visibility_checkvar ()
 /* This function is called by the shared library.  */
 
 int
-main_called ()
+main_called (void)
 {
   return 6;
 }
@@ -97,15 +145,93 @@ main_called ()
 /* This function overrides a function in the shared library.  */
 
 int
-shlib_overriddencall2 ()
+shlib_overriddencall2 (void)
 {
   return 8;
 }
 
+#ifdef HIDDEN_NORMAL_TEST
+int visibility_com;
+asm (".hidden visibility_com");
+
+int
+main_visibility_checkcom (void)
+{
+  return visibility_com == 0;
+}
+
 int
-main ()
+main_visibility_checkweak (void)
+{
+  return 1;
+}
+#elif defined (HIDDEN_WEAK_TEST)
+int
+main_visibility_checkcom (void)
+{
+  return 1;
+}
+
+#pragma weak visibility_undef_var_weak
+extern int visibility_undef_var_weak;
+asm (".hidden visibility_undef_var_weak");
+
+#pragma weak visibility_undef_func_weak
+extern int visibility_undef_func_weak ();
+asm (".hidden visibility_undef_func_weak");
+
+#pragma weak visibility_var_weak
+extern int visibility_var_weak;
+asm (".hidden visibility_var_weak");
+
+#pragma weak visibility_func_weak
+extern int visibility_func_weak ();
+asm (".hidden visibility_func_weak");
+
+int
+main_visibility_checkweak ()
+{
+  return &visibility_undef_var_weak == NULL
+        && &visibility_undef_func_weak == NULL
+        && &visibility_func_weak == NULL
+        && &visibility_var_weak == NULL;
+}
+#elif defined (HIDDEN_UNDEF_TEST)
+extern int visibility_def;
+asm (".hidden visibility_def");
+extern int visibility_func ();
+asm (".hidden visibility_func");
+
+int
+main_visibility_checkcom (void)
+{
+  return & visibility_def != NULL && visibility_def == 2;
+}
+
+int
+main_visibility_checkweak (void)
+{
+  return & visibility_func != NULL && visibility_func () == 2;
+}
+#else
+int
+main_visibility_checkcom (void)
+{
+  return 1;
+}
+
+int
+main_visibility_checkweak (void)
+{
+  return 1;
+}
+#endif
+
+int
+main (void)
 {
   int (*p) ();
+  int ret = 0;
 
   printf ("mainvar == %d\n", mainvar);
   printf ("overriddenvar == %d\n", overriddenvar);
@@ -154,5 +280,27 @@ main ()
          visibility_checkvarptr ());
   printf ("main_visibility_checkvar () == %d\n",
          main_visibility_checkvar ());
-  return 0;
+  printf ("main_visibility_checkcom () == %d\n",
+         main_visibility_checkcom ());
+  printf ("shlib_visibility_checkcom () == %d\n",
+         shlib_visibility_checkcom ());
+  printf ("main_visibility_checkweak () == %d\n",
+         main_visibility_checkweak ());
+  printf ("shlib_visibility_checkweak () == %d\n",
+         shlib_visibility_checkweak ());
+
+#if !defined (PROTECTED_UNDEF_TEST) && defined (PROTECTED_TEST)
+  if (&shared_data != shared_data_p ())
+    ret = 1;
+  p = shared_func_p ();
+  if (shared_func != p)
+    ret = 1;
+  if (shared_data != *shared_data_p ())
+    ret = 1;
+  if (shared_func () != (*p) () )
+    ret = 1;
+#endif
+
+  return ret;
 }
+#endif