docs: protected void processReferenceContext(BeanMetaData bmd) throws InjectionException, EJBConfigurationException {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled())
              Tr.entry(tc, "ensureReferenceDataIsProcessed");
  
          // At this point, regardless of whether we are in a pure or hybrid flow,
          // we should have a populated ReferenceContext.
          //
          // Now we attempt to process it.  If we are in a pure flow, processing
          // will actually occur.  If we are in a hybrid flow, processing will
          // occur if it has not been done yet (via the webcontainer, or via
          // some other bean component).  If it has already been done, this
          // call will no-op...but thats a black box to us here, and we don't
          // know are care if processing actually runs now, or if it already
          // ran earlier in time.
          ReferenceContext refContext = bmd.ivReferenceContext;
          refContext.process();
  
          // Persist output data structures into BMD
          bmd._javaNameSpaceContext = refContext.getJavaCompContext(); // F743-17630CodRv
          bmd.setJavaNameSpace(refContext.getComponentNameSpace());
          bmd._resourceRefList = refContext.getResolvedResourceRefs();
          bmd.ivJavaColonCompEnvMap = refContext.getJavaColonCompEnvMap();
          bmd.envProps = refContext.getEJBContext10Properties(); // F743-17630CodRv
  
          // F743-21481
          // Stick InjectionTargets that are visible to bean class into BMD
          bmd.ivBeanInjectionTargets = getInjectionTargets(bmd, bmd.enterpriseBeanClass);
  
          // F743-21481
          // Stick the InjectionTargets that are visible to each interceptor
          // class into the InterceptorMetaData
          InterceptorMetaData imd = bmd.ivInterceptorMetaData;
          if (imd != null) {
              Class<?>[] interceptorClasses = imd.ivInterceptorClasses;
              if (interceptorClasses != null && interceptorClasses.length > 0) {
                  InjectionTarget[][] interceptorInjectionTargets = new InjectionTarget[interceptorClasses.length][0];
  
                  for (int i = 0; i < interceptorClasses.length; i++) {
                      // The InjectionTarget[] associated with the interceptor class is
                      // empty (ie, 0 length array) if there are no visible
                      // InjectionTargets. Its added to the interceptorInjectionTargets
                      // array anyway because this array needs to have the same length
                      // as the IMD.ivInterceptorClasses array...ie, each 'row' in this
                      // array corresponds directly to a class in that array, and if the
                      // two arrays get out-of-sync, then we have a problem.
                      Class<?> oneInterceptorClass = interceptorClasses[i];
                      InjectionTarget[] targets = getInjectionTargets(bmd, oneInterceptorClass);
                      interceptorInjectionTargets[i] = targets;
                  }
  
                  imd.ivInterceptorInjectionTargets = interceptorInjectionTargets;
              }
  
              if (isTraceOn && tc.isDebugEnabled())
                  Tr.debug(tc, "Interceptor metadata after adding any InjectionTargets:\n" + imd);
          }
  
          if (!EJSPlatformHelper.isZOSCRA()) {
              // Verify that a MDB or stateless session bean instance or the
              // interceptor instances of MDB and SLSB are not the target of a
              // extended persistent context injection since extended persistent
              // unit is only allowed for the SFSB and it's interceptor instances.
              findAndProcessExtendedPC(bmd); //465813
          }
  
          if (isTraceOn && tc.isEntryEnabled())
              Tr.exit(tc, "ensureReferenceDataIsProcessed");
      }