* gcc.dg/simulate-thread/simulate-thread.gdb: Use return value from
	simulate_thread_wrapper_other_threads
	* gcc.dg/simulate-thread/atomic-load-int128.c (simulate_thread_main):
	Move initialization of 'value' to main().
	(main): Initialize 'value';
	* gcc.dg/simulate-thread/speculative-store.c
	(simulate_thread_step_verify): Return 0 when successful.
	* gcc.dg/simulate-thread/simulate-thread.h (HOSTILE_THREAD_THRESHOLD):
	Reduce threshold.
	(INSN_COUNT_THRESHOLD): New.  Instruction limit to terminate test.
	(simulate_thread_wrapper_other_threads): Return a success/fail value
	and issue an error if the instruction count threshold is exceeded.

Index: testsuite/gcc.dg/simulate-thread/simulate-thread.gdb
===================================================================
*** testsuite/gcc.dg/simulate-thread/simulate-thread.gdb	(revision 184447)
--- testsuite/gcc.dg/simulate-thread/simulate-thread.gdb	(working copy)
*************** run
*** 5,11 ****
  
  set $ret = 0
  while (simulate_thread_fini != 1) && (! $ret)
!   call simulate_thread_wrapper_other_threads()
    stepi
    set $ret |= simulate_thread_step_verify()
  end
--- 5,11 ----
  
  set $ret = 0
  while (simulate_thread_fini != 1) && (! $ret)
!   set $ret |= simulate_thread_wrapper_other_threads()
    stepi
    set $ret |= simulate_thread_step_verify()
  end
Index: testsuite/gcc.dg/simulate-thread/atomic-load-int128.c
===================================================================
*** testsuite/gcc.dg/simulate-thread/atomic-load-int128.c	(revision 184447)
--- testsuite/gcc.dg/simulate-thread/atomic-load-int128.c	(working copy)
*************** void simulate_thread_main()
*** 105,113 ****
  {
    int x;
  
-   /* Make sure value starts with an atomic value now.  */
-   __atomic_store_n (&value, ret, __ATOMIC_SEQ_CST);
- 
    /* Execute loads with value changing at various cyclic values.  */
    for (table_cycle_size = 16; table_cycle_size > 4 ; table_cycle_size--)
      {
--- 105,110 ----
*************** void simulate_thread_main()
*** 126,131 ****
--- 123,132 ----
  main()
  {
    fill_table ();
+ 
+   /* Make sure value starts with an atomic value from the table.  */
+   __atomic_store_n (&value, table[0], __ATOMIC_SEQ_CST);
+ 
    simulate_thread_main ();
    simulate_thread_done ();
    return 0;
Index: testsuite/gcc.dg/simulate-thread/speculative-store.c
===================================================================
*** testsuite/gcc.dg/simulate-thread/speculative-store.c	(revision 184447)
--- testsuite/gcc.dg/simulate-thread/speculative-store.c	(working copy)
*************** int simulate_thread_step_verify()
*** 24,29 ****
--- 24,30 ----
        printf("FAIL: global variable was assigned to.  \n");
        return 1;
      }
+   return 0;
  }
  
  int simulate_thread_final_verify()
Index: testsuite/gcc.dg/simulate-thread/simulate-thread.h
===================================================================
*** testsuite/gcc.dg/simulate-thread/simulate-thread.h	(revision 184447)
--- testsuite/gcc.dg/simulate-thread/simulate-thread.h	(working copy)
*************** simulate_thread_done ()
*** 37,43 ****
     infinite loop to be avoided.
  
     If the testcase defines HOSTILE_PAUSE_ERROR, then it will be
!    considered an RUNTIME FAILURE if the hostile pause is triggered.
     This will allow to test for guaranteed forward progress routines.
  
     If the default values for HOSTILE_THREAD_THRESHOLD or
--- 37,43 ----
     infinite loop to be avoided.
  
     If the testcase defines HOSTILE_PAUSE_ERROR, then it will be
!    considered a RUNTIME FAILURE if the hostile pause is triggered.
     This will allow to test for guaranteed forward progress routines.
  
     If the default values for HOSTILE_THREAD_THRESHOLD or
*************** simulate_thread_done ()
*** 50,66 ****
     hostile condition is interferring.  */
  
    
! /* Define the threshold to start pausing the hostile thread.  */
  #if !defined (HOSTILE_THREAD_THRESHOLD)
! #define HOSTILE_THREAD_THRESHOLD 	500
  #endif
  
  /* Define the length of pause in cycles for the hostile thread to pause to
!    allow forward progress to be made.  */
  #if !defined (HOSTILE_THREAD_PAUSE)
  #define HOSTILE_THREAD_PAUSE	20
  #endif
  
  void simulate_thread_other_threads (void);
  int simulate_thread_final_verify (void);
  
--- 50,78 ----
     hostile condition is interferring.  */
  
    
! /* Define the threshold instruction count to start pausing the hostile 
!    thread.  To avoid huge potential log files when things are not going well,
!    set this number very low.  If a test specifically requires that the forward
!    progress guarantee is made, this number should be raised by the testcase. */
  #if !defined (HOSTILE_THREAD_THRESHOLD)
! #define HOSTILE_THREAD_THRESHOLD 	50
  #endif
  
  /* Define the length of pause in cycles for the hostile thread to pause to
!    allow forward progress to be made.  If this number is too low, a 
!    compare_and_swap loop may not have time to finish, especially on a
!    128 bit operation. */
  #if !defined (HOSTILE_THREAD_PAUSE)
  #define HOSTILE_THREAD_PAUSE	20
  #endif
  
+ /* Define the number of instructions which are allowed to be executed before
+    the testcase is deemed to fail.  This is primarily to avoid huge log files
+    when a testcase goes into an infinte loop.  */
+ #if !defined (INSN_COUNT_THRESHOLD)
+ #define INSN_COUNT_THRESHOLD	10000
+ #endif
+ 
  void simulate_thread_other_threads (void);
  int simulate_thread_final_verify (void);
  
*************** static int simulate_thread_hostile_pause
*** 71,96 ****
     is reached, the other_thread process is paused for
     HOSTILE_THREAD_PAUSE cycles before resuming, and the counters start
     again.  */
! void
  simulate_thread_wrapper_other_threads()
  {
!   static int count = 0;
!   static int pause = 0;
  
!   if (++count >= HOSTILE_THREAD_THRESHOLD)
      {
        if (!simulate_thread_hostile_pause)
          simulate_thread_hostile_pause = 1;
  
        /* Count cycles before calling the hostile thread again.  */
!       if (pause++ < HOSTILE_THREAD_PAUSE)
! 	return;
  
        /* Reset the pause counter, as well as the thread counter.  */
!       pause = 0;
!       count = 0;
      }
    simulate_thread_other_threads ();
  }
  
  
--- 83,116 ----
     is reached, the other_thread process is paused for
     HOSTILE_THREAD_PAUSE cycles before resuming, and the counters start
     again.  */
! int
  simulate_thread_wrapper_other_threads()
  {
!   static int insn_count = 0;
!   static int hostile_count = 0;
!   static int hostile_pause = 0;
! 
!   if (++insn_count >= INSN_COUNT_THRESHOLD)
!     {
!       printf ("FAIL: Testcase exceeded maximum instruction count threshold\n");
!       return 1;
!     }
  
!   if (++hostile_count >= HOSTILE_THREAD_THRESHOLD)
      {
        if (!simulate_thread_hostile_pause)
          simulate_thread_hostile_pause = 1;
  
        /* Count cycles before calling the hostile thread again.  */
!       if (hostile_pause++ < HOSTILE_THREAD_PAUSE)
! 	return 0;
  
        /* Reset the pause counter, as well as the thread counter.  */
!       hostile_pause = 0;
!       hostile_count = 0;
      }
    simulate_thread_other_threads ();
+   return 0;
  }