* hinfo.cc (hinfo::find_unused_handle): Just check for table entry == NULL

since we are already bounds checked by default.
* thread.cc (ResourceLocks::Lock): Streamline this function since it is called
a lot.
(ReleaseResourceLock): Ditto.

winsup/cygwin/ChangeLog

@@ -1,3 +1,11 @@
+Fri Aug  4 00:00:46 2000  Christopher Faylor <cgf@cygnus.com>
+
+	* hinfo.cc (hinfo::find_unused_handle): Just check for table entry ==
+	NULL since we are already bounds checked by default.
+	* thread.cc (ResourceLocks::Lock): Streamline this function since it is
+	called a lot.
+	(ReleaseResourceLock): Ditto.
+
 Thu Aug  3 20:44:39 2000  Christopher Faylor <cgf@cygnus.com>
 
 	* select.cc (fhandler_console::select_read): Call set_cursor_maybe

winsup/cygwin/dtable.cc

@@ -130,7 +130,8 @@ hinfo::find_unused_handle (int start)
   do
     {
       for (int i = start; i < (int) size; i++)
-	if (not_open (i))
+	/* See if open -- no need for overhead of not_open */
+	if (fds[i] == NULL)
 	  return i;
     }
   while (extend (NOFILE_INCR));

winsup/cygwin/thread.cc

@@ -29,9 +29,12 @@ extern int threadsafe;
 #define NOT_IMP(n)  system_printf ("not implemented %s\n", n); return 0;
 
 #define CHECKHANDLE(rval, release) \
-  if ( ! item->HandleOke() ) { \
+  if (!item->HandleOke ()) \
-    if ( release ) item->used=false; \
+    { \
-    return rval; };
+      if (release) \
+	item->used=false; \
+      return rval; \
+    }
 
 #define GETTHREAD(n) \
   if (!thread) system_printf ("thread is NULL");\
@@ -68,9 +71,7 @@ _reent_clib ()
 
 #ifdef _CYG_THREAD_FAILSAFE
   if (_r == 0)
-    {
     system_printf ("local thread storage not inited");
-    }
 #endif
 
   SetLastError (tmp);
@@ -85,22 +86,32 @@ _reent_winsup ()
   _r = (struct __reent_t *) TlsGetValue (MT_INTERFACE->reent_index);
 #ifdef _CYG_THREAD_FAILSAFE
   if (_r == 0)
-    {
     system_printf ("local thread storage not inited");
-    }
 #endif
   SetLastError (tmp);
   return _r->_winsup;
 };
 
+inline LPCRITICAL_SECTION
+ResourceLocks::Lock (int _resid)
+{
+#ifdef _CYG_THREAD_FAILSAFE
+  if (!inited)
+    system_printf ("lock called before initialization");
+
+  thread_printf ("Get Resource lock %d ==> %p for %p , real : %d , threadid %d ",
+		 _resid, &lock, user_data, myself->pid, GetCurrentThreadId ());
+#endif
+  return &lock;
+};
+
 void
 SetResourceLock (int _res_id, int _mode, const char *_function)
 {
-#if 0
+#ifdef _CYG_THREAD_FAILSAFE
-  if (!threadsafe)
+  thread_printf ("Set resource lock %d mode %d for %s start",
-    return;
+		 _res_id, _mode, _function);
 #endif
-  thread_printf ("Set resource lock %d mode %d for %s start", _res_id, _mode, _function);
   EnterCriticalSection (user_data->resourcelocks->Lock (_res_id));
 
 #ifdef _CYG_THREAD_FAILSAFE
@@ -112,13 +123,9 @@ SetResourceLock (int _res_id, int _mode, const char *_function)
 void
 ReleaseResourceLock (int _res_id, int _mode, const char *_function)
 {
-#if 0
+#ifdef _CYG_THREAD_FAILSAFE
-  if (!threadsafe)
-    return;
-#endif
   thread_printf ("Release resource lock %d mode %d for %s done", _res_id, _mode, _function);
 
-#ifdef _CYG_THREAD_FAILSAFE
   AssertResourceOwner (_res_id, _mode);
   user_data->resourcelocks->count--;
   if (user_data->resourcelocks->count == 0)
@@ -133,27 +140,15 @@ void
 AssertResourceOwner (int _res_id, int _mode)
 {
 
-  thread_printf ("Assert Resource lock %d ==> for %p , real : %d , threadid %d count %d owner %d", _res_id, user_data, (myself ? myself->pid : -1), GetCurrentThreadId (), user_data->resourcelocks->count, user_data->resourcelocks->owner);
+  thread_printf ("Assert Resource lock %d ==> for %p , real : %d , threadid %d count %d owner %d",
+		 _res_id, user_data, myself->pid, GetCurrentThreadId (),
+		 user_data->resourcelocks->count, user_data->resourcelocks->owner);
   if (user_data && (user_data->resourcelocks->owner != GetCurrentThreadId ()))
-    {
     system_printf ("assertion failed, not the resource owner");
-    };
 }
 
 #endif
 
-LPCRITICAL_SECTION
-ResourceLocks::Lock (int _resid)
-{
-  if (!inited)
-    {
-      system_printf ("lock called before initialization");
-    };
-
-  thread_printf ("Get Resource lock %d ==> %p for %p , real : %d , threadid %d ", _resid, &lock, user_data, (myself ? myself->pid : -1), GetCurrentThreadId ());
-  return &lock;
-};
-
 void
 ResourceLocks::Init ()
 {
@@ -167,7 +162,7 @@ ResourceLocks::Init ()
   count = 0;
 #endif
 
-  thread_printf ("Resource lock %p inited by %p , %d", &lock, user_data, (myself ? myself->pid : -1));
+  thread_printf ("Resource lock %p inited by %p , %d", &lock, user_data, myself->pid);
 };
 
 void
@@ -178,7 +173,7 @@ ResourceLocks::Delete ()
       thread_printf ("Close Resource Locks %p ", &lock);
       DeleteCriticalSection (&lock);
       inited = false;
-    };
+    }
 };
 
 
@@ -200,7 +195,7 @@ MTinterface::Find (void *_value, int (*comp) (void *, void *), register int &_in
       if (current->used && comp (current, _value))
         break;
       current = NULL;
-    };
+    }
   return current;
 };
 
@@ -214,7 +209,7 @@ MTinterface::Find (MTitem & _item, MTList * _list)
       current = _list->items[_index];
       if (current->used && current == &_item)
         break;
-    };
+    }
   return (_index == _list->index ? -1 : _index);
 };
 
@@ -260,7 +255,7 @@ MTinterface::Init0 ()
       threadlist.items[i] = NULL;
       mutexlist.items[i] = NULL;
       semalist.items[i] = NULL;
-    };
+    }
 
   threadlist.index = 0;
   mutexlist.index = 0;
@@ -541,9 +536,7 @@ __pthread_create (pthread_t * thread, const pthread_attr_t * attr, TFD (start_ro
     {
       __pthread_attr_init (&a);
       item = MT_INTERFACE->CreateThread (thread, start_routine, arg, a);
-    };
+    }
-
-
 
   CHECKITEM (LOCK_THREAD_LIST, WRITE_LOCK | READ_LOCK, "__pthread_create")
 
@@ -885,23 +878,23 @@ extern "C"
   int __pthread_create (pthread_t *, const pthread_attr_t *, TFD (start_routine), void *arg)
   {
     return -1;
-  };
+  }
   int __pthread_attr_init (pthread_attr_t * attr)
   {
     return -1;
-  };
+  }
   int __pthread_attr_destroy (pthread_attr_t * attr)
   {
     return -1;
-  };
+  }
   int __pthread_attr_setstacksize (pthread_attr_t * attr, size_t size)
   {
     return -1;
-  };
+  }
   int __pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size)
   {
     return -1;
-  };
+  }
 /*
    __pthread_attr_setstackaddr (...){ return -1; };
    __pthread_attr_getstackaddr (...){ return -1; };
@@ -909,7 +902,7 @@ extern "C"
   int __pthread_exit (void *value_ptr)
   {
     return -1;
-  };
+  }
 
   int __pthread_join (pthread_t thread_id, void **return_val)
   {
@@ -919,83 +912,83 @@ extern "C"
   unsigned long __pthread_getsequence_np (pthread_t * thread)
   {
     return 0;
-  };
+  }
   int __pthread_key_create (pthread_key_t * key)
   {
     return -1;
-  };
+  }
   int __pthread_key_delete (pthread_key_t * key)
   {
     return -1;
-  };
+  }
   int __pthread_setspecific (pthread_key_t * key, const void *value)
   {
     return -1;
-  };
+  }
   void *__pthread_getspecific (pthread_key_t * key)
   {
     return NULL;
-  };
+  }
   int __pthread_kill (pthread_t * thread, int sig)
   {
     return -1;
-  };
+  }
   int __pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set)
   {
     return -1;
-  };
+  }
   pthread_t __pthread_self ()
   {
     return -1;
-  };
+  }
   int __pthread_equal (pthread_t * t1, pthread_t * t2)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_lock (pthread_mutex_t *)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_trylock (pthread_mutex_t *)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_unlock (pthread_mutex_t *)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_destroy (pthread_mutex_t *)
   {
     return -1;
-  };
+  }
   int __sem_init (sem_t * sem, int pshared, unsigned int value)
   {
     return -1;
-  };
+  }
   int __sem_destroy (sem_t * sem)
   {
     return -1;
-  };
+  }
   int __sem_wait (sem_t * sem)
   {
     return -1;
-  };
+  }
   int __sem_trywait (sem_t * sem)
   {
     return -1;
-  };
+  }
   int __sem_post (sem_t * sem)
   {
     return -1;
-  };
+  }
   struct _reent *_reent_clib ()
   {
     return NULL;
-  };
+  }
 }
 
 #endif                          // MT_SAFE