docs: protected void registerServant()
      {
          if (ivRemoteObjectWrapper != null)
          {
              // synchronized on the remote Wrapper to set the isRemoteRegistered flag
              synchronized (ivRemoteObjectWrapper)
              {
                  if (!isRemoteRegistered)
                  {
  
                      try
                      {
                          if (!isZOS) // LIDB2775-23.9
                          {
  
                              // Servant registration must be performed with the application classloader
                              // in force.  This is especially needed for JITDeploy since
                              // the JIT pluggin will be on the application classloader.
                              // Without the JIT pluggin the classloader will not trigger
                              // JITDeploy to create the stub.  //d521388
                              Object originalLoader = ThreadContextAccessor.UNCHANGED;
                              try
                              {
                                  if (ivBMD != null) // EJBFactories have no BMD d529446
                                  {
                                      originalLoader = EJBThreadData.svThreadContextAccessor.pushContextClassLoaderForUnprivileged(ivBMD.classLoader); //PK83186
  
                                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                      {
                                          if (originalLoader != ThreadContextAccessor.UNCHANGED)
                                          {
                                              Tr.debug(tc, "registerServant : old ClassLoader = " + originalLoader);
                                              Tr.debug(tc, "registerServant : new ClassLoader = " + ivBMD.classLoader);
                                          }
                                          else
                                          {
                                              Tr.debug(tc, "registerServant : current ClassLoader = " + ivBMD.classLoader);
                                          }
                                      }
                                  }
                                  ivRemoteObjectWrapper.container.getEJBRuntime().registerServant(ivRemoteObjectWrapper.beanId.getByteArray(), ivRemoteObjectWrapper);
                              } finally
                              {
                                  EJBThreadData.svThreadContextAccessor.popContextClassLoaderForUnprivileged(originalLoader);
                              } // finally
  
                          } // if( !isZOS )
  
                          isRemoteRegistered = true;
                      } catch (Exception ex)
                      {
                          FFDCFilter.processException(ex, CLASS_NAME +
                                                          ".registerServant",
                                                      "184", this);
                          if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                          {
                              Tr.event(tc, "Failed to register wrapper instance",
                                       new Object[] { ivRemoteObjectWrapper, ex });
                          }
                      }
  
                  } // if ( !isRemoteRegistered )
  
              } // synchronized( ivRemoteObject )
  
          } // if ( ivRemoteObject != null )
  
      }