docs: private void loadGeneratedImplementationClasses(BeanMetaData bmd,
                                                      Method[] localMethods,
                                                      Method[] remoteMethods,
                                                      Method[] localHomeMethods,
                                                      Method[] remoteHomeMethods) throws ContainerException, EJBConfigurationException {
  
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.entry(tc, "loadGeneratedImplementationClasses");
          }
  
          // Use indirect local proxies if configured and supported.          F58064
          EJBModuleMetaDataImpl mmd = bmd._moduleMetaData;
          bmd.ivIndirectLocalProxies = (ContainerProperties.IndirectLocalProxies ||
                                        mmd.getEJBApplicationMetaData().isIndirectLocalProxies() ||
                                        bmd.ivUnversionedJ2eeName != null)
                                       &&
                                       (bmd.isEntityBean() ||
                                        bmd.isStatelessSessionBean() ||
                                        bmd.isSingletonSessionBean());
  
          String classNameToLoad = null;
          EJBRuntime runtime = bmd.container.getEJBRuntime();
  
          try {
              String componentRemoteWrapperImplName = null;
              String componentLocalWrapperImplName = null;
              String businessRemoteWrapperImplName[] = null;
              String businessLocalWrapperImplName[] = null;
              String homeRemoteWrapperImplName = null;
              String homeLocalWrapperImplName = null;
              String homeImplName = null;
              ClassLoader classLoader = bmd.classLoader;
  
              // --------------------------------------------------------------------
              // For ManagedBeans, usually the only 'generated' class would be the
              // home, which is really just a special subclass of EJSHome that is
              // not generated at all, and can just be set directly. There is no
              // need for a NameUtil for this, so skip all of the processing below
              // and just set the home class and return.
              //
              // However, if the ManagedBean has either PreDestroy or AroundInvoke
              // interceptors, then a special version of a No-Interface wrapper
              // is needed (which skips pre/post inovke).. so fall through to
              // the code below and generate one.                        F743-34301.1
              // --------------------------------------------------------------------
              if (bmd.type == InternalConstants.TYPE_MANAGED_BEAN) {
                  // ManagedBeans have special home for bean creation
                  bmd.homeBeanClass = ManagedBeanHome.class;
  
                  if (bmd.ivInterceptorMetaData == null) {
                      return; // no interceptors = no wrapper
                  }
  
                  if (bmd.ivInterceptorMetaData.ivPreDestroyInterceptors == null) {
                      boolean hasAroundInvoke = false;
                      for (EJBMethodInfoImpl methodInfo : bmd.localMethodInfos) {
                          if (methodInfo.getAroundInterceptorProxies() != null) {
                              hasAroundInvoke = true;
                              break;
                          }
                      }
  
                      // No PreDestory && no AroundInvoke = no wrapper
                      if (!hasAroundInvoke) {
                          return;
                      }
                  }
              }
  
              // -----------------------------------------------------------------------
              //
              // Create an instance of NameUtil, passing it all of the data that it
              // would have previously extracted from WCCM.  This allows NameUtil
              // to generate deployed class names independent of the source (i.e.
              // WCCM or annotations)... and by using an instance, instead of static
              // methods, provides improved performance, as the common parts of
              // the deployed class names can be calculated once.
              //
              // Note that the meta data constants used elsewhere in EJB Container
              // must be converted to the NameUtil constants to avoid circular build
              // dependencies, and to allow NameUtil to continue to be shared
              // with EJBDeploy.                                               d366807.3
              //
              // -----------------------------------------------------------------------
  
              // retrieve customer provided class names
              String remoteHomeInterface = bmd.ivInitData.ivRemoteHomeInterfaceName;
              String remoteInterface = bmd.ivInitData.ivRemoteInterfaceName;
              String localHomeInterface = bmd.ivInitData.ivLocalHomeInterfaceName;
              String localInterface = bmd.ivInitData.ivLocalInterfaceName;
              String[] remoteBusinessInterfaces = bmd.ivInitData.ivRemoteBusinessInterfaceNames;
              String[] localBusinessInterfaces = bmd.ivInitData.ivLocalBusinessInterfaceNames;
              String beanClass = bmd.ivInitData.ivClassName;
              String primaryKey = bmd.pKeyClass == null ? null : bmd.pKeyClass.getName();
  
              // No-Interface view counts as a local interface, and since it requires
              // the same processing below, will be added to the list of local business
              // interfaces (and may be the only local interface).          F743-1756
              if (bmd.ivLocalBean) {
                  if (localBusinessInterfaces == null) {
                      localBusinessInterfaces = new String[1];
                  } else {
                      String[] newNames = new String[localBusinessInterfaces.length + 1];
                      System.arraycopy(localBusinessInterfaces, 0, newNames, 1,
                                       localBusinessInterfaces.length);
                      localBusinessInterfaces = newNames;
                  }
  
                  localBusinessInterfaces[0] = beanClass;
              }
  
              // Convert bean type into NameUtil type string
              String nameUtilBeanType = EJBMDOrchestrator.nameTypeFromBeanTypeMap[bmd.type];
  
              // RELEASE: This switch statement must be updated with every new release level
              // Calculate NameUtil version from bean version
              int nameUtilBeanVersion = -1;
              switch (bmd.ivModuleVersion) {
                  case BeanMetaData.J2EE_EJB_VERSION_1_1:
                  case BeanMetaData.J2EE_EJB_VERSION_1_0:
                      nameUtilBeanVersion = NameUtil.EJB_1X;
                      break;
  
                  case BeanMetaData.J2EE_EJB_VERSION_2_0:
                  case BeanMetaData.J2EE_EJB_VERSION_2_1:
                      nameUtilBeanVersion = NameUtil.EJB_2X;
                      break;
  
                  default:
                      nameUtilBeanVersion = NameUtil.EJB_3X;
                      break;
              }
  
              NameUtil nameUtil = new NameUtil(bmd.enterpriseBeanName, remoteHomeInterface, remoteInterface, localHomeInterface, localInterface, remoteBusinessInterfaces, localBusinessInterfaces, beanClass, primaryKey, nameUtilBeanType, nameUtilBeanVersion);
  
              // --------------------------------------------------------------------
              //JITDeploy handling for all MDB's.
              // --------------------------------------------------------------------
              if (bmd.type == InternalConstants.TYPE_MESSAGE_DRIVEN) {
                  // Set localImplClassName based on whether the old or new MDB implementation
                  // is being used. A null value indicates the new MDB implementation and will
                  // always be returned on Liberty. The new MDB implementation runs through JITDeploy.
                  // For traditional WAS, the old MDB message listener style could be returned (MessageListener.class),
                  // and we need to preserve this behavior.
                  bmd.localImplClass = runtime.getMessageEndpointImplClass(bmd);
                  if (bmd.localImplClass != null) {
                      componentLocalWrapperImplName = bmd.localImplClass.getName();
                  } else {
                      componentLocalWrapperImplName = nameUtil.getMDBProxyClassName();
                      classNameToLoad = componentLocalWrapperImplName;
                      EJBWrapperType wrapperType;
                      if (bmd.ivIsNoMethodInterfaceMDB) {
                          wrapperType = EJBWrapperType.MDB_NO_METHOD_INTERFACE_PROXY;
                      } else {
                          wrapperType = EJBWrapperType.MDB_PROXY;
                      }
                      bmd.localImplClass = JITDeploy.generateMDBProxy(classLoader,
                                                                      classNameToLoad,
                                                                      new Class<?>[] { bmd.localInterfaceClass, bmd.enterpriseBeanClass },
                                                                      wrapperType,
                                                                      bmd.enterpriseBeanClass.getName(),
                                                                      localMethods,
                                                                      bmd.localMethodInfos,
                                                                      bmd.j2eeName.toString(),
                                                                      runtime.getClassDefiner());
                  }
                  // Clear classNameToLoad so any exceptions here won't get
                  // reported in the catch block below as a ClassNotFound,
                  // but instead as a general container error.
                  classNameToLoad = null;
  
                  // For no-method interface MDB, obtain the ivMessageEndpointBase field
                  // on the generated proxy class that holds a reference to the
                  // MessageEndpointBase object and make it accessible so it may be set
                  // when an instance is created.
                  if (bmd.ivIsNoMethodInterfaceMDB) {
                      bmd.ivMessageEndpointBaseField = bmd.localImplClass.getDeclaredField(MESSAGE_ENDPOINT_BASE_FIELD);
                      bmd.ivMessageEndpointBaseField.setAccessible(true);
                  }
  
                  // L001126: If we have an activation spec then the home bean
                  // class is a MessageEndpointFactory.  If not, then we must be
                  // using listener ports, so set the home bean class to an MDBPool.
                  bmd.homeBeanClass = runtime.getMessageEndpointFactoryImplClass(bmd);
                  homeImplName = bmd.homeBeanClass.getName();
  
                  // Finally, set the activation config properties in the bmd and
                  // resolve the message destination JNDI name for the MDB
                  bmd.ivActivationConfig = bmd.ivInitData.ivActivationConfigProperties;
                  runtime.resolveMessageDestinationJndiName(bmd);
              }
  
              // --------------------------------------------------------------------
              // If this is a ManagedBean that requires a wrapper, then generate a
              // special version of a no-interface wrapper that doesn't call pre
              // or post invoke.                                         F743-34301.1
              // --------------------------------------------------------------------
              else if (bmd.type == InternalConstants.TYPE_MANAGED_BEAN) {
                  bmd.ivBusinessLocalImplClasses = new Class[1];
                  classNameToLoad = nameUtil.getBusinessLocalImplClassName(0);
                  bmd.ivBusinessLocalImplClasses[0] = JITDeploy.generateEJBWrapper(classLoader,
                                                                                   classNameToLoad,
                                                                                   new Class<?>[] { bmd.ivBusinessLocalInterfaceClasses[0] },
                                                                                   EJBWrapperType.MANAGED_BEAN,
                                                                                   localMethods,
                                                                                   bmd.localMethodInfos,
                                                                                   bmd.enterpriseBeanClassName,
                                                                                   bmd.j2eeName.toString(),
                                                                                   runtime.getClassDefiner()); // F70650
  
                  // For No-Interface view (LocalBean), obtain the Fields on
                  // the generated wrapper class that holds a reference to the
                  // container and wrapper metadata (an EJSWrapperBase subclass)
                  // and make them accessible so they may be set when an
                  // instance is created.
  
                  // Clear classNameToLoad so any exceptions here won't get
                  // reported in the catch block below as a ClassNotFound,
                  // but instead as a general container error.
                  classNameToLoad = null;
                  bmd.ivLocalBeanWrapperField = bmd.ivBusinessLocalImplClasses[0].getDeclaredField(LOCAL_BEAN_WRAPPER_FIELD);
                  bmd.ivLocalBeanWrapperField.setAccessible(true);
                  bmd.ivManagedBeanBeanOField = bmd.ivBusinessLocalImplClasses[0].getDeclaredField(MANAGED_BEAN_BEANO_FIELD);
                  bmd.ivManagedBeanBeanOField.setAccessible(true);
              }
  
              // --------------------------------------------------------------------
              // Beginning with EJB 3.0 module level, all 'generated' classes
              // (except CMP) are generated and loaded dynamically via ASM
              // (i.e. 'just-in-time' deploy).
              // --------------------------------------------------------------------
              else if (!mmd.isEJBDeployed()) {
                  // Generate/Load the Component Remote Implementation ('Wrapper')
                  if (remoteInterface != null) {
                      componentRemoteWrapperImplName = nameUtil.getRemoteImplClassName();
                      classNameToLoad = componentRemoteWrapperImplName;
                      bmd.remoteImplClass = JITDeploy.generateEJBWrapper(classLoader,
                                                                         classNameToLoad,
                                                                         new Class<?>[] { bmd.remoteInterfaceClass },
                                                                         EJBWrapperType.REMOTE, // d413752
                                                                         remoteMethods,
                                                                         bmd.methodInfos, // d367572.4
                                                                         bmd.enterpriseBeanClassName,
                                                                         bmd.j2eeName.toString(), // d443878
                                                                         runtime.getClassDefiner()); // F70650
  
                      // Only generate the Tie if remote is supported (CORBA classes are available)
                      if (runtime.isRemoteSupported()) {
                          bmd.remoteTieClass = JITDeploy.generate_Tie(classLoader,
                                                                      classNameToLoad,
                                                                      bmd.remoteInterfaceClass,
                                                                      bmd.j2eeName.toString(),
                                                                      runtime.getClassDefiner(),
                                                                      mmd.getRMICCompatible(),
                                                                      runtime.isRemoteUsingPortableServer());
                      }
                  }
  
                  // Generate/Load the Component Local Implementation ('Wrapper')
                  if (localInterface != null) {
                      componentLocalWrapperImplName = nameUtil.getLocalImplClassName(); // d114199 d147734
  
                      // L001126: Moved this section into the else block, this used to sit outside the if/else block
                      // but is no longer valid if the bmd.type is MESSAGE_DRIVEN as we will set localImplClass
                      // directly at that point.
                      classNameToLoad = componentLocalWrapperImplName;
                      bmd.localImplClass = JITDeploy.generateEJBWrapper(classLoader,
                                                                        classNameToLoad,
                                                                        new Class<?>[] { bmd.localInterfaceClass },
                                                                        EJBWrapperType.LOCAL, // d413752
                                                                        localMethods,
                                                                        bmd.localMethodInfos, // d367572.4
                                                                        bmd.enterpriseBeanClassName,
                                                                        bmd.j2eeName.toString(), // d443878
                                                                        runtime.getClassDefiner()); // F70650
  
                      // L001126 - end change
                  }
  
                  // Generate/Load the implementation classes (wrappers) for the
                  // Business Local interfaces (except for MDB).              d369262
                  if (bmd.ivBusinessLocalInterfaceClasses != null) {
                      int numInterfaces = bmd.ivBusinessLocalInterfaceClasses.length;
                      bmd.ivBusinessLocalImplClasses = new Class[numInterfaces];
                      businessLocalWrapperImplName = new String[numInterfaces];
                      // If No-Interface view present (LocalBean), then the first
                      // local wrapper is of type LOCAL_BEAN                  F743-1756
                      EJBWrapperType wrapperType = (bmd.ivLocalBean) ? EJBWrapperType.LOCAL_BEAN : EJBWrapperType.BUSINESS_LOCAL;
                      for (int i = 0; i < numInterfaces; ++i) {
                          businessLocalWrapperImplName[i] = nameUtil.getBusinessLocalImplClassName(i);
                          classNameToLoad = businessLocalWrapperImplName[i];
                          bmd.ivBusinessLocalImplClasses[i] = JITDeploy.generateEJBWrapper(classLoader,
                                                                                           classNameToLoad,
                                                                                           new Class<?>[] { bmd.ivBusinessLocalInterfaceClasses[i] },
                                                                                           wrapperType, // d413752 F743-1756
                                                                                           localMethods,
                                                                                           bmd.localMethodInfos, // d367572.4
                                                                                           bmd.enterpriseBeanClassName,
                                                                                           bmd.j2eeName.toString(), // d443878
                                                                                           runtime.getClassDefiner()); // F70650
                          wrapperType = EJBWrapperType.BUSINESS_LOCAL; // F743-1756
                      }
  
                      // For No-Interface view (LocalBean), obtain the Fields on
                      // the generated wrapper class that holds a reference to the
                      // container and wrapper metadata (an EJSWrapperBase subclass)
                      // and make them accessible so they may be set when an
                      // instance is created.                                 F743-1756
                      if (bmd.ivLocalBean) {
                          // Clear classNameToLoad so any exceptions here won't get
                          // reported in the catch block below as a ClassNotFound,
                          // but instead as a general container error.
                          classNameToLoad = null;
                          bmd.ivLocalBeanWrapperField = bmd.ivBusinessLocalImplClasses[0].getDeclaredField(LOCAL_BEAN_WRAPPER_FIELD);
                          bmd.ivLocalBeanWrapperField.setAccessible(true);
                      }
  
                      if (bmd.ivIndirectLocalProxies) {
                          bmd.ivBusinessLocalImplProxyConstructors = new Constructor<?>[numInterfaces];
                          for (int i = 0; i < numInterfaces; i++) {
                              Class<?> interfaceClass = bmd.ivBusinessLocalInterfaceClasses[i];
                              Method[] methods = DeploymentUtil.getMethods(null, new Class<?>[] { interfaceClass });
                              classNameToLoad = EJBWrapperProxy.getProxyClassName(interfaceClass);
                              bmd.ivBusinessLocalImplProxyConstructors[i] = getWrapperProxyConstructor(bmd, classNameToLoad, interfaceClass, methods);
                          }
                      }
                  }
  
                  // Generate/Load the implementation classes (wrappers) for the
                  // Business Remote interfaces.                               d369262
                  if (bmd.ivBusinessRemoteInterfaceClasses != null) {
                      int numInterfaces = bmd.ivBusinessRemoteInterfaceClasses.length;
                      bmd.ivBusinessRemoteImplClasses = new Class[numInterfaces];
                      bmd.ivBusinessRemoteTieClasses = new Class[numInterfaces]; // d416391
                      businessRemoteWrapperImplName = new String[numInterfaces];
                      for (int i = 0; i < numInterfaces; ++i) {
                          businessRemoteWrapperImplName[i] = nameUtil.getBusinessRemoteImplClassName(i);
                          classNameToLoad = businessRemoteWrapperImplName[i];
                          bmd.ivBusinessRemoteImplClasses[i] = JITDeploy.generateEJBWrapper(classLoader,
                                                                                            classNameToLoad,
                                                                                            new Class<?>[] { bmd.ivBusinessRemoteInterfaceClasses[i] },
                                                                                            EJBWrapperType.BUSINESS_REMOTE, // d413752
                                                                                            remoteMethods,
                                                                                            bmd.methodInfos, // d367572.4
                                                                                            bmd.enterpriseBeanClassName,
                                                                                            bmd.j2eeName.toString(), // d443878
                                                                                            runtime.getClassDefiner()); // F70650
  
                          // Only generate the Tie if remote is supported (CORBA classes are available)
                          if (runtime.isRemoteSupported()) {
                              bmd.ivBusinessRemoteTieClasses[i] = JITDeploy.generate_Tie(classLoader,
                                                                                         classNameToLoad,
                                                                                         bmd.ivBusinessRemoteInterfaceClasses[i],
                                                                                         bmd.j2eeName.toString(),
                                                                                         runtime.getClassDefiner(),
                                                                                         mmd.getRMICCompatible(),
                                                                                         runtime.isRemoteUsingPortableServer());
                          }
                      }
                  }
  
                  // Not an MDB, so generate home bean class name and home wrapper
                  // class if necessary via JITDeploy.
                  homeImplName = nameUtil.getHomeBeanClassName(); // d114199 d147734
  
                  if (homeImplName != null) {
                      classNameToLoad = homeImplName;
                      bmd.homeBeanClass = JITDeploy.generateEJBHomeImplClass(bmd.classLoader,
                                                                             classNameToLoad,
                                                                             bmd.homeInterfaceClass,
                                                                             bmd.localHomeInterfaceClass,
                                                                             bmd.enterpriseBeanClass, // d369262.5
                                                                             bmd.pKeyClass, // d369262.8
                                                                             bmd.ivInitMethodMap, // d369262.5
                                                                             bmd.j2eeName.toString(), // d443878
                                                                             bmd.type,
                                                                             runtime.getClassDefiner()); // F70650
                  } else if (bmd.type == InternalConstants.TYPE_SINGLETON_SESSION || // F743-508
                             bmd.type == InternalConstants.TYPE_STATELESS_SESSION ||
                             bmd.type == InternalConstants.TYPE_STATEFUL_SESSION) {
                      // Use generic SessionHome when no home is defined.
                      bmd.homeBeanClass = SessionHome.class; // F743-34301.1
                  }
  
                  // load generated remote Home ('Wrapper') Impl class - EJSRemote[Type]HomeItf
                  //    e.g. EJSRemoteCMPTest1Home
                  homeRemoteWrapperImplName = nameUtil.getHomeRemoteImplClassName(); // d114199 d147734
                  if (homeRemoteWrapperImplName != null) {
                      classNameToLoad = homeRemoteWrapperImplName;
                      bmd.homeRemoteImplClass = JITDeploy.generateEJBWrapper(bmd.classLoader,
                                                                             classNameToLoad,
                                                                             new Class<?>[] { bmd.homeInterfaceClass },
                                                                             EJBWrapperType.REMOTE_HOME, // d413752
                                                                             remoteHomeMethods, // d413752
                                                                             bmd.homeMethodInfos, // d367572.4
                                                                             bmd.homeBeanClass.getName(),
                                                                             bmd.j2eeName.toString(), // d443878
                                                                             runtime.getClassDefiner()); // F70650
  
                      // Only generate the Tie if remote is supported (CORBA classes are available)
                      if (runtime.isRemoteSupported()) {
                          bmd.homeRemoteTieClass = JITDeploy.generate_Tie(classLoader,
                                                                          classNameToLoad,
                                                                          bmd.homeInterfaceClass,
                                                                          bmd.j2eeName.toString(), // d443878
                                                                          runtime.getClassDefiner(), // F70650
                                                                          mmd.getRMICCompatible(),
                                                                          runtime.isRemoteUsingPortableServer());
                      }
                  }
  
                  // load generated local Home ('Wrapper') Impl class - EJSLocal[Type]HomeItf
                  //    e.g. EJSLocalCMPTest1Home
                  homeLocalWrapperImplName = nameUtil.getHomeLocalImplClassName(); // f111627 d114199 d147734
                  if (homeLocalWrapperImplName != null) {
                      classNameToLoad = homeLocalWrapperImplName;
                      bmd.homeLocalImplClass = JITDeploy.generateEJBWrapper(bmd.classLoader,
                                                                            classNameToLoad,
                                                                            new Class<?>[] { bmd.localHomeInterfaceClass },
                                                                            EJBWrapperType.LOCAL_HOME, // d413752
                                                                            localHomeMethods, // d413752
                                                                            bmd.localHomeMethodInfos, // d367572.4
                                                                            bmd.homeBeanClass.getName(),
                                                                            bmd.j2eeName.toString(), // d443878
                                                                            runtime.getClassDefiner()); // F70650
                  }
              }
  
              // ----------------------------------------------------------
              // For module versions <= EJB 2.1, the classes generated by
              // EJBDeploy are still loaded, just as in previous releases.
              // ----------------------------------------------------------
              else {
                  // Load the Component Remote Implementation ('Wrapper')
                  componentRemoteWrapperImplName = nameUtil.getRemoteImplClassName();
                  classNameToLoad = componentRemoteWrapperImplName;
                  bmd.remoteImplClass = loadGeneratedClass(classLoader,
                                                           classNameToLoad,
                                                           nameUtil);
  
                  // Load the Component Local Implementation ('Wrapper')
                  componentLocalWrapperImplName = nameUtil.getLocalImplClassName(); // d114199 d147734
  
                  classNameToLoad = componentLocalWrapperImplName;
                  bmd.localImplClass = loadGeneratedClass(classLoader,
                                                          classNameToLoad,
                                                          nameUtil);
  
                  // For EJB 2.X Entity Beans with Container Managed Persistance
                  // (CMP), the Enterprise Bean provided by the customer in the
                  // deployment descriptor will be an abstract class. The Concrete
                  // beam implementation name must be determined and that class
                  // loaded, replacing the customer provided abstract bean
                  // implementation class loaded earlier in this method.    f110762.2
  
                  // Calculate module version flag
                  // WCCM agrees to contract that version IDs are sequentially assigned.
                  boolean isPost11DD = (bmd.ivModuleVersion >= BeanMetaData.J2EE_EJB_VERSION_2_0);
  
                  if (isPost11DD && // 114138.3 d147734
                      bmd.type == InternalConstants.TYPE_CONTAINER_MANAGED_ENTITY &&
                      bmd.cmpVersion == InternalConstants.CMP_VERSION_2_X) {
                      // This is an EJB 2.x CMP Entity Bean.  The bean class loaded
                      // above is abstract. Determine the concrete implementation
                      // name and load it, replacing the abstract one from above.
                      if (isTraceOn && tc.isDebugEnabled())
                          Tr.debug(tc, bmd.enterpriseBeanClassName + " is an EJB 2.x CMP Bean");
  
                      bmd.enterpriseBeanClassName = nameUtil.getConcreteBeanClassName();
                      classNameToLoad = bmd.enterpriseBeanClassName;
                      bmd.enterpriseBeanClass = loadGeneratedClass(classLoader, classNameToLoad, nameUtil); // d183360
  
                  } else if (bmd.type == InternalConstants.TYPE_CONTAINER_MANAGED_ENTITY) {
                      // This is an EJB 1.x CMP Entity Bean. Persistence will be
                      // handled through a generated persister class which was loaded
                      // elsewhere.                                                  f110762.2
                      if (isTraceOn && tc.isDebugEnabled())
                          Tr.debug(tc, bmd.enterpriseBeanClassName + " is an EJB 1.x CMP Bean");
                  }
  
                  // Load Home implementation bean if necessary.
                  // d147734
  
                  // Not an MDB, so generated name for home bean class and load the
                  // generated home class if one was generated by ejbdeploy.
                  homeImplName = nameUtil.getHomeBeanClassName(); // d114199 d147734
  
                  if (homeImplName != null) {
                      classNameToLoad = homeImplName;
                      bmd.homeBeanClass = loadGeneratedClass(classLoader, classNameToLoad, nameUtil); // f111627 d147734
  
                  } else if (bmd.type == InternalConstants.TYPE_SINGLETON_SESSION || // F743-508
                             bmd.type == InternalConstants.TYPE_STATELESS_SESSION ||
                             bmd.type == InternalConstants.TYPE_STATEFUL_SESSION) {
                      // Use generic SessionHome when no home is defined.
                      bmd.homeBeanClass = SessionHome.class; // F743-34301.1
                  }
  
                  // load generated remote Home ('Wrapper') Impl class - EJSRemote[Type]HomeItf
                  //    e.g. EJSRemoteCMPTest1Home
                  homeRemoteWrapperImplName = nameUtil.getHomeRemoteImplClassName(); // d114199 d147734
                  classNameToLoad = homeRemoteWrapperImplName;
                  bmd.homeRemoteImplClass = loadGeneratedClass(classLoader, homeRemoteWrapperImplName, nameUtil); // f111627 d147734
  
                  // load generated local Home ('Wrapper') Impl class - EJSLocal[Type]HomeItf
                  //    e.g. EJSLocalCMPTest1Home
                  homeLocalWrapperImplName = nameUtil.getHomeLocalImplClassName(); // f111627 d114199 d147734
                  classNameToLoad = homeLocalWrapperImplName;
                  bmd.homeLocalImplClass = loadGeneratedClass(classLoader, classNameToLoad, nameUtil); // f111627 d147734
  
              } // End else version <= 2.1 load EJBDeploy generated classes
  
              if (bmd.ivIndirectLocalProxies && bmd.localHomeInterfaceClass != null) {
                  classNameToLoad = EJBWrapperProxy.getProxyClassName(bmd.localHomeInterfaceClass);
                  bmd.homeLocalImplProxyConstructor = getWrapperProxyConstructor(bmd, classNameToLoad, bmd.localHomeInterfaceClass, localHomeMethods);
  
                  classNameToLoad = EJBWrapperProxy.getProxyClassName(bmd.localInterfaceClass);
                  bmd.localImplProxyConstructor = getWrapperProxyConstructor(bmd, classNameToLoad, bmd.localInterfaceClass, localMethods);
              }
  
              // If there is a WebService Endpoint, save the name to be used when
              // generating the WebService Endpoint wrapper class.     F743-1756CodRv
              if (bmd.ivHasWebServiceEndpoint) {
                  bmd.ivWebServiceEndpointProxyName = nameUtil.getWebServiceEndpointProxyClassName();
              }
  
              // Trace gnerated implementation classes that we have loaded
              if (isTraceOn && tc.isDebugEnabled()) {
                  Tr.debug(tc, " **** component remote wrapper impl class = " +
                               componentRemoteWrapperImplName);
                  Tr.debug(tc, " **** component local wrapper impl class = " +
                               componentLocalWrapperImplName);
                  if (businessRemoteWrapperImplName != null) {
                      Tr.debug(tc, " **** business remote wrapper impl class(es) = " +
                                   Arrays.toString(businessRemoteWrapperImplName));
                  } else {
                      Tr.debug(tc, " **** business remote wrapper impl class(es) = null");
                  }
                  if (businessLocalWrapperImplName != null) {
                      Tr.debug(tc, " **** business local wrapper impl class(es) = " +
                                   Arrays.toString(businessLocalWrapperImplName));
                  } else {
                      Tr.debug(tc, " **** business local wrapper impl class(es) = null");
                  }
                  Tr.debug(tc, " **** home remote wrapper impl class = " +
                               homeRemoteWrapperImplName);
                  Tr.debug(tc, " **** home local wrapper impl class = " +
                               homeLocalWrapperImplName);
                  Tr.debug(tc, " **** home impl class = " +
                               homeImplName);
              }
  
          } catch (ClassNotFoundException ex) {
              FFDCFilter.processException(ex, CLASS_NAME + ".loadGeneratedImplementationClasses", "4353");
              if (isTraceOn && tc.isEventEnabled())
                  Tr.event(tc, "Failed to initialize BeanMetaData instance", ex);
              EJBConfigurationException ecex;
              ecex = new EJBConfigurationException("Bean class " + classNameToLoad + " could not be found or loaded", ex);
              Tr.error(tc, "BEANCLASS_NOT_FOUND_CNTR0075E", classNameToLoad);
              throw ecex;
          } catch (LinkageError ex) {
              FFDCFilter.processException(ex, CLASS_NAME + ".loadGeneratedImplementationClasses", "4363");
              if (isTraceOn && tc.isEventEnabled())
                  Tr.event(tc, "Failed to initialize BeanMetaData instance", ex);
              EJBConfigurationException ecex;
              ecex = new EJBConfigurationException("Bean class " + classNameToLoad + " could not be loaded", ex);
              Tr.error(tc, "BEANCLASS_NOT_FOUND_CNTR0075E", classNameToLoad);
              throw ecex;
          } catch (Throwable ex) {
              FFDCFilter.processException(ex, CLASS_NAME + ".loadGeneratedImplementationClasses", "4373");
              ContainerException cex;
              if (classNameToLoad != null) {
                  cex = new ContainerException("Bean class " + classNameToLoad + " could not be found or loaded", ex);
                  Tr.error(tc, "BEANCLASS_NOT_FOUND_CNTR0075E", classNameToLoad);
              } else {
                  cex = new ContainerException("Failed to initialize BeanMetaData instance - " +
                                               "caught Throwable", ex);
                  Tr.error(tc, "CAUGHT_EXCEPTION_THROWING_NEW_EXCEPTION_CNTR0035E",
                           new Object[] { ex, cex.toString() });
              }
              throw cex;
          }
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.exit(tc, "loadGeneratedImplementationClasses");
          }
  
      }