Bug 1438688, part 4 - Hoist arrays to XPTHeader. r=njn

To allow XPT information to be shared between processes, it needs to
not contain any pointers, because they cause relocations. I've
eliminated pointers by hoisting all of the variable length data
structures to XPTHeader, into a single array for each type of
data. These data structures now use an index into these arrays to find
their first element. Strings are similar, but they are mashed into a
single giant string, including embedded null terminators. Modifying
the accessor methods to support this is easy, because there is only a
single global instance of each of these arrays in XPTHeader.

MozReview-Commit-ID: 5rgwaEBvDYl

--HG--
extra : rebase_source : 2e423f088d662920a89f3b66c70d26fe340b5fce

xpcom/reflect/xptinfo/xptiInterfaceInfo.cpp

@@ -301,7 +301,7 @@ xptiInterfaceEntry::GetInterfaceIndexForParam(uint16_t methodIndex,
     const XPTTypeDescriptor *td = &param->mType;
 
     while (td->Tag() == TD_ARRAY) {
-        td = td->ArrayElementType(mDescriptor);
+        td = td->ArrayElementType();
     }
 
     if (td->Tag() != TD_INTERFACE_TYPE) {
@@ -441,7 +441,7 @@ xptiInterfaceEntry::GetTypeInArray(const nsXPTParamInfo* param,
             NS_ERROR("bad dimension");
             return NS_ERROR_INVALID_ARG;
         }
-        td = td->ArrayElementType(mDescriptor);
+        td = td->ArrayElementType();
     }
 
     *type = td;
@@ -549,7 +549,7 @@ xptiInterfaceEntry::GetInterfaceIsArgNumberForParam(uint16_t methodIndex,
     const XPTTypeDescriptor *td = &param->mType;
 
     while (td->Tag() == TD_ARRAY) {
-        td = td->ArrayElementType(mDescriptor);
+        td = td->ArrayElementType();
     }
 
     if (td->Tag() != TD_INTERFACE_IS_TYPE) {

xpcom/typelib/xpt/xpt_struct.h

@@ -27,6 +27,15 @@ struct XPTTypeDescriptorPrefix;
 struct XPTHeader {
   static const uint16_t kNumInterfaces;
   static const XPTInterfaceDirectoryEntry kInterfaceDirectory[];
+  static const XPTInterfaceDescriptor kInterfaces[];
+  static const XPTTypeDescriptor kTypes[];
+  static const XPTParamDescriptor kParams[];
+  static const XPTMethodDescriptor kMethods[];
+  static const XPTConstDescriptor kConsts[];
+
+  // All of the strings for this header, including their null
+  // terminators, concatenated into a single string.
+  static const char kStrings[];
 };
 
 /*
@@ -39,8 +48,10 @@ struct XPTInterfaceDirectoryEntry {
   inline const char* Name() const;
 
   nsID mIID;
-  const char* mName;
-  const XPTInterfaceDescriptor* mInterfaceDescriptor;
+  uint32_t mName; // Index into XPTHeader::mStrings.
+  // mInterfaceDescriptor is a 1-based index into XPTHeader::mInterfaces. The
+  // value 0 is used to indicate unresolved interfaces.
+  uint32_t mInterfaceDescriptor;
 };
 
 /*
@@ -64,14 +75,12 @@ struct XPTInterfaceDescriptor {
   /*
    * This field ordering minimizes the size of this struct.
    */
-  const XPTMethodDescriptor* mMethodDescriptors;
-  const XPTConstDescriptor* mConstDescriptors;
-  const XPTTypeDescriptor* mAdditionalTypes;
+  uint16_t mMethodDescriptors; // Index into XPTHeader::mMethods.
+  uint16_t mConstDescriptors; // Index into XPTHeader::mConsts.
   uint16_t mParentInterface;
   uint16_t mNumMethods;
   uint16_t mNumConstants;
   uint8_t mFlags;
-  uint8_t mNumAdditionalTypes;
 };
 
 /*
@@ -147,9 +156,9 @@ struct XPTTypeDescriptor {
     return mData1;
   }
 
-  const XPTTypeDescriptor* ArrayElementType(const XPTInterfaceDescriptor* aDescriptor) const {
+  const XPTTypeDescriptor* ArrayElementType() const {
     MOZ_ASSERT(Tag() == TD_ARRAY);
-    return &aDescriptor->mAdditionalTypes[mData2];
+    return &XPTHeader::kTypes[mData2];
   }
 
   // We store the 16-bit iface value as two 8-bit values in order to
@@ -188,10 +197,10 @@ union XPTConstValue {
 
 struct XPTConstDescriptor {
   const char* Name() const {
-    return mName;
+    return &XPTHeader::kStrings[mName];
   }
 
-  const char* mName;
+  uint32_t mName; // Index into XPTHeader::mStrings.
   XPTTypeDescriptor mType;
   union XPTConstValue mValue;
 };
@@ -210,36 +219,39 @@ struct XPTParamDescriptor {
  */
 struct XPTMethodDescriptor {
   const char* Name() const {
-    return mName;
+    return &XPTHeader::kStrings[mName];
   }
   const XPTParamDescriptor& Param(uint8_t aIndex) const {
-    return mParams[aIndex];
+    return XPTHeader::kParams[mParams + aIndex];
   }
 
-  const char* mName;
-  const XPTParamDescriptor* mParams;
+  uint32_t mName; // Index into XPTHeader::mStrings.
+  uint32_t mParams; // Index into XPTHeader::mParams.
   uint8_t mFlags;
   uint8_t mNumArgs;
 };
 
 const char*
 XPTInterfaceDirectoryEntry::Name() const {
-  return mName;
+  return &XPTHeader::kStrings[mName];
 }
 
 const XPTInterfaceDescriptor*
 XPTInterfaceDirectoryEntry::InterfaceDescriptor() const {
-  return mInterfaceDescriptor;
+  if (mInterfaceDescriptor == 0) {
+    return nullptr;
+  }
+  return &XPTHeader::kInterfaces[mInterfaceDescriptor - 1];
 }
 
 const XPTMethodDescriptor&
 XPTInterfaceDescriptor::Method(size_t aIndex) const {
-  return mMethodDescriptors[aIndex];
+  return XPTHeader::kMethods[mMethodDescriptors + aIndex];
 }
 
 const XPTConstDescriptor&
 XPTInterfaceDescriptor::Const(size_t aIndex) const {
-  return mConstDescriptors[aIndex];
+  return XPTHeader::kConsts[mConstDescriptors + aIndex];
 }
 
 #endif /* xpt_struct_h */