src/share/vm/runtime/objectMonitor.cpp

rev 4899 : 8019973: PPC64 (part 11): Fix IA64 preprocessor conditionals on AIX.
Summary: On AIX 7.1 systemcfg.h defines IA64 unconditionally, so test for !AIX where IA64 is used. Clean up old gcc bug workaround (ATTR) and includes in forte.cpp.

*** 52,69 ****
  #endif
  #ifdef TARGET_OS_FAMILY_bsd
  # include "os_bsd.inline.hpp"
  #endif
  
- #if defined(__GNUC__) && !defined(IA64)
-   // Need to inhibit inlining for older versions of GCC to avoid build-time failures
-   #define ATTR __attribute__((noinline))
- #else
-   #define ATTR
- #endif
- 
- 
  #ifdef DTRACE_ENABLED
  
  // Only bother with this argument setup if dtrace is available
  // TODO-FIXME: probes should not fire when caller is _blocked.  assert() accordingly.
  
--- 52,61 ----
*** 311,321 ****
      _recursions++;
      return true;
    }
  }
  
! void ATTR ObjectMonitor::enter(TRAPS) {
    // The following code is ordered to check the most common cases first
    // and to reduce RTS->RTO cache line upgrades on SPARC and IA32 processors.
    Thread * const Self = THREAD ;
    void * cur ;
  
--- 303,313 ----
      _recursions++;
      return true;
    }
  }
  
! void ObjectMonitor::enter(TRAPS) {
    // The following code is ordered to check the most common cases first
    // and to reduce RTS->RTO cache line upgrades on SPARC and IA32 processors.
    Thread * const Self = THREAD ;
    void * cur ;
  
*** 474,484 ****
        // Retry doesn't make as much sense because the lock was just acquired.
        if (true) return -1 ;
     }
  }
  
! void ATTR ObjectMonitor::EnterI (TRAPS) {
      Thread * Self = THREAD ;
      assert (Self->is_Java_thread(), "invariant") ;
      assert (((JavaThread *) Self)->thread_state() == _thread_blocked   , "invariant") ;
  
      // Try the lock - TATAS
--- 466,476 ----
        // Retry doesn't make as much sense because the lock was just acquired.
        if (true) return -1 ;
     }
  }
  
! void ObjectMonitor::EnterI (TRAPS) {
      Thread * Self = THREAD ;
      assert (Self->is_Java_thread(), "invariant") ;
      assert (((JavaThread *) Self)->thread_state() == _thread_blocked   , "invariant") ;
  
      // Try the lock - TATAS
*** 723,733 ****
  //
  // In the future we should reconcile EnterI() and ReenterI(), adding
  // Knob_Reset and Knob_SpinAfterFutile support and restructuring the
  // loop accordingly.
  
! void ATTR ObjectMonitor::ReenterI (Thread * Self, ObjectWaiter * SelfNode) {
      assert (Self != NULL                , "invariant") ;
      assert (SelfNode != NULL            , "invariant") ;
      assert (SelfNode->_thread == Self   , "invariant") ;
      assert (_waiters > 0                , "invariant") ;
      assert (((oop)(object()))->mark() == markOopDesc::encode(this) , "invariant") ;
--- 715,725 ----
  //
  // In the future we should reconcile EnterI() and ReenterI(), adding
  // Knob_Reset and Knob_SpinAfterFutile support and restructuring the
  // loop accordingly.
  
! void ObjectMonitor::ReenterI (Thread * Self, ObjectWaiter * SelfNode) {
      assert (Self != NULL                , "invariant") ;
      assert (SelfNode != NULL            , "invariant") ;
      assert (SelfNode->_thread == Self   , "invariant") ;
      assert (_waiters > 0                , "invariant") ;
      assert (((oop)(object()))->mark() == markOopDesc::encode(this) , "invariant") ;
*** 928,938 ****
  // any one time.  (more precisely, we want to minimize timer-seconds, which is
  // the integral of the # of active timers at any instant over time).
  // Both impinge on OS scalability.  Given that, at most one thread parked on
  // a monitor will use a timer.
  
! void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) {
     Thread * Self = THREAD ;
     if (THREAD != _owner) {
       if (THREAD->is_lock_owned((address) _owner)) {
         // Transmute _owner from a BasicLock pointer to a Thread address.
         // We don't need to hold _mutex for this transition.
--- 920,930 ----
  // any one time.  (more precisely, we want to minimize timer-seconds, which is
  // the integral of the # of active timers at any instant over time).
  // Both impinge on OS scalability.  Given that, at most one thread parked on
  // a monitor will use a timer.
  
! void ObjectMonitor::exit(bool not_suspended, TRAPS) {
     Thread * Self = THREAD ;
     if (THREAD != _owner) {
       if (THREAD->is_lock_owned((address) _owner)) {
         // Transmute _owner from a BasicLock pointer to a Thread address.
         // We don't need to hold _mutex for this transition.