--- a/dom/base/AbstractRange.h
+++ b/dom/base/AbstractRange.h
@@ -72,16 +72,18 @@ class AbstractRange : public nsISupports
             typename RangeType>
   static nsresult SetStartAndEndInternal(
       const RangeBoundaryBase<SPT, SRT>& aStartBoundary,
       const RangeBoundaryBase<EPT, ERT>& aEndBoundary, RangeType* aRange);
 
   RefPtr<Document> mOwner;
   RangeBoundary mStart;
   RangeBoundary mEnd;
+  // `true` if `mStart` has a container and potentially other conditions are
+  // fulfilled.
   bool mIsPositioned;
 
   // Used by nsRange, but this should have this for minimizing the size.
   bool mIsGenerated;
   // Used by nsRange, but this should have this for minimizing the size.
   bool mCalledByJS;
 };
 

--- a/dom/base/Selection.cpp
+++ b/dom/base/Selection.cpp
@@ -764,36 +764,37 @@ void Selection::SetAnchorFocusRange(int3
   if (indx < 0)  // release all
   {
     mAnchorFocusRange = nullptr;
   } else {
     mAnchorFocusRange = mRanges[indx].mRange;
   }
 }
 
-static nsresult CompareToRangeStart(nsINode* aCompareNode,
-                                    int32_t aCompareOffset, nsRange* aRange,
-                                    int32_t* aCmp) {
+static nsresult CompareToRangeStart(const nsINode* aCompareNode,
+                                    int32_t aCompareOffset,
+                                    const nsRange* aRange, int32_t* aCmp) {
   nsINode* start = aRange->GetStartContainer();
   NS_ENSURE_STATE(aCompareNode && start);
   // If the nodes that we're comparing are not in the same document or in the
   // same subtree, assume that aCompareNode will fall at the end of the ranges.
   if (aCompareNode->GetComposedDoc() != start->GetComposedDoc() ||
       !start->GetComposedDoc() ||
       aCompareNode->SubtreeRoot() != start->SubtreeRoot()) {
     *aCmp = 1;
   } else {
     *aCmp = nsContentUtils::ComparePoints(aCompareNode, aCompareOffset, start,
                                           aRange->StartOffset());
   }
   return NS_OK;
 }
 
-static nsresult CompareToRangeEnd(nsINode* aCompareNode, int32_t aCompareOffset,
-                                  nsRange* aRange, int32_t* aCmp) {
+static nsresult CompareToRangeEnd(const nsINode* aCompareNode,
+                                  int32_t aCompareOffset, const nsRange* aRange,
+                                  int32_t* aCmp) {
   nsINode* end = aRange->GetEndContainer();
   NS_ENSURE_STATE(aCompareNode && end);
   // If the nodes that we're comparing are not in the same document or in the
   // same subtree, assume that aCompareNode will fall at the end of the ranges.
   if (aCompareNode->GetComposedDoc() != end->GetComposedDoc() ||
       !end->GetComposedDoc() ||
       aCompareNode->SubtreeRoot() != end->SubtreeRoot()) {
     *aCmp = 1;
@@ -809,28 +810,28 @@ static nsresult CompareToRangeEnd(nsINod
 //    Binary searches the given sorted array of ranges for the insertion point
 //    for the given node/offset. The given comparator is used, and the index
 //    where the point should appear in the array is placed in *aInsertionPoint.
 //
 //    If there is an item in the array equal to the input point, we will return
 //    the index of this item.
 
 nsresult Selection::FindInsertionPoint(
-    nsTArray<RangeData>* aElementArray, nsINode* aPointNode,
+    const nsTArray<RangeData>* aElementArray, const nsINode* aPointNode,
     int32_t aPointOffset,
-    nsresult (*aComparator)(nsINode*, int32_t, nsRange*, int32_t*),
+    nsresult (*aComparator)(const nsINode*, int32_t, const nsRange*, int32_t*),
     int32_t* aPoint) {
   *aPoint = 0;
   int32_t beginSearch = 0;
   int32_t endSearch = aElementArray->Length();  // one beyond what to check
 
   if (endSearch) {
     int32_t center = endSearch - 1;  // Check last index, then binary search
     do {
-      nsRange* range = (*aElementArray)[center].mRange;
+      const nsRange* range = (*aElementArray)[center].mRange;
 
       int32_t cmp;
       nsresult rv = aComparator(aPointNode, aPointOffset, range, &cmp);
       NS_ENSURE_SUCCESS(rv, rv);
 
       if (cmp < 0) {  // point < cur
         endSearch = center;
       } else if (cmp > 0) {  // point > cur
@@ -1186,37 +1187,39 @@ nsresult Selection::Clear(nsPresContext*
   return NS_OK;
 }
 
 // RangeMatches*Point
 //
 //    Compares the range beginning or ending point, and returns true if it
 //    exactly matches the given DOM point.
 
-static inline bool RangeMatchesBeginPoint(nsRange* aRange, nsINode* aNode,
+static inline bool RangeMatchesBeginPoint(const nsRange* aRange,
+                                          const nsINode* aNode,
                                           int32_t aOffset) {
   return aRange->GetStartContainer() == aNode &&
          static_cast<int32_t>(aRange->StartOffset()) == aOffset;
 }
 
-static inline bool RangeMatchesEndPoint(nsRange* aRange, nsINode* aNode,
-                                        int32_t aOffset) {
+static inline bool RangeMatchesEndPoint(const nsRange* aRange,
+                                        const nsINode* aNode, int32_t aOffset) {
   return aRange->GetEndContainer() == aNode &&
          static_cast<int32_t>(aRange->EndOffset()) == aOffset;
 }
 
 // Selection::EqualsRangeAtPoint
 //
 //    Utility method for checking equivalence of two ranges.
 
-bool Selection::EqualsRangeAtPoint(nsINode* aBeginNode, int32_t aBeginOffset,
-                                   nsINode* aEndNode, int32_t aEndOffset,
-                                   int32_t aRangeIndex) {
+bool Selection::EqualsRangeAtPoint(const nsINode* aBeginNode,
+                                   int32_t aBeginOffset,
+                                   const nsINode* aEndNode, int32_t aEndOffset,
+                                   int32_t aRangeIndex) const {
   if (aRangeIndex >= 0 && aRangeIndex < (int32_t)mRanges.Length()) {
-    nsRange* range = mRanges[aRangeIndex].mRange;
+    const nsRange* range = mRanges[aRangeIndex].mRange;
     if (RangeMatchesBeginPoint(range, aBeginNode, aBeginOffset) &&
         RangeMatchesEndPoint(range, aEndNode, aEndOffset))
       return true;
   }
   return false;
 }
 
 void Selection::GetRangesForInterval(nsINode& aBeginNode, int32_t aBeginOffset,
@@ -1253,28 +1256,20 @@ nsresult Selection::GetRangesForInterval
   for (int32_t i = startIndex; i < endIndex; i++) {
     if (!aRanges->AppendElement(mRanges[i].mRange))
       return NS_ERROR_OUT_OF_MEMORY;
   }
 
   return NS_OK;
 }
 
-// Selection::GetIndicesForInterval
-//
-//    Works on the same principle as GetRangesForIntervalArray above, however
-//    instead this returns the indices into mRanges between which the
-//    overlapping ranges lie.
-
-nsresult Selection::GetIndicesForInterval(nsINode* aBeginNode,
-                                          int32_t aBeginOffset,
-                                          nsINode* aEndNode, int32_t aEndOffset,
-                                          bool aAllowAdjacent,
-                                          int32_t* aStartIndex,
-                                          int32_t* aEndIndex) {
+nsresult Selection::GetIndicesForInterval(
+    const nsINode* aBeginNode, int32_t aBeginOffset, const nsINode* aEndNode,
+    int32_t aEndOffset, bool aAllowAdjacent, int32_t* aStartIndex,
+    int32_t* aEndIndex) const {
   int32_t startIndex;
   int32_t endIndex;
 
   if (!aStartIndex) aStartIndex = &startIndex;
   if (!aEndIndex) aEndIndex = &endIndex;
 
   *aStartIndex = -1;
   *aEndIndex = -1;
@@ -1288,17 +1283,17 @@ nsresult Selection::GetIndicesForInterva
   // interval can be discarded
   int32_t endsBeforeIndex;
   if (NS_FAILED(FindInsertionPoint(&mRanges, aEndNode, aEndOffset,
                                    &CompareToRangeStart, &endsBeforeIndex))) {
     return NS_OK;
   }
 
   if (endsBeforeIndex == 0) {
-    nsRange* endRange = mRanges[endsBeforeIndex].mRange;
+    const nsRange* endRange = mRanges[endsBeforeIndex].mRange;
 
     // If the interval is strictly before the range at index 0, we can optimize
     // by returning now - all ranges start after the given interval
     if (!RangeMatchesBeginPoint(endRange, aEndNode, aEndOffset)) return NS_OK;
 
     // We now know that the start point of mRanges[0].mRange equals the end of
     // the interval. Thus, when aAllowadjacent is true, the caller is always
     // interested in this range. However, when excluding adjacencies, we must
@@ -1324,55 +1319,55 @@ nsresult Selection::GetIndicesForInterva
     //     given interval's start point
     //   endsBeforeIndex points to a range whose start point equals the given
     //     interval's start point
     // In the final case, there can be two such ranges, a collapsed range, and
     // an adjacent range (they will appear in mRanges in that order). For this
     // final case, we need to increment endsBeforeIndex, until one of the
     // first two possibilites hold
     while (endsBeforeIndex < (int32_t)mRanges.Length()) {
-      nsRange* endRange = mRanges[endsBeforeIndex].mRange;
+      const nsRange* endRange = mRanges[endsBeforeIndex].mRange;
       if (!RangeMatchesBeginPoint(endRange, aEndNode, aEndOffset)) break;
       endsBeforeIndex++;
     }
 
     // Likewise, one of the following holds:
     //   beginsAfterIndex == 0,
     //   beginsAfterIndex points to a range whose end point does not equal
     //     the given interval's end point
     //   beginsOnOrAfter points to a range whose end point equals the given
     //     interval's end point
     // In the final case, there can be two such ranges, an adjacent range, and
     // a collapsed range (they will appear in mRanges in that order). For this
     // final case, we only need to take action if both those ranges exist, and
     // we are pointing to the collapsed range - we need to point to the
     // adjacent range
-    nsRange* beginRange = mRanges[beginsAfterIndex].mRange;
+    const nsRange* beginRange = mRanges[beginsAfterIndex].mRange;
     if (beginsAfterIndex > 0 && beginRange->Collapsed() &&
         RangeMatchesEndPoint(beginRange, aBeginNode, aBeginOffset)) {
       beginRange = mRanges[beginsAfterIndex - 1].mRange;
       if (RangeMatchesEndPoint(beginRange, aBeginNode, aBeginOffset))
         beginsAfterIndex--;
     }
   } else {
     // See above for the possibilities at this point. The only case where we
     // need to take action is when the range at beginsAfterIndex ends on
     // the given interval's start point, but that range isn't collapsed (a
     // collapsed range should be included in the returned results).
-    nsRange* beginRange = mRanges[beginsAfterIndex].mRange;
+    const nsRange* beginRange = mRanges[beginsAfterIndex].mRange;
     if (RangeMatchesEndPoint(beginRange, aBeginNode, aBeginOffset) &&
         !beginRange->Collapsed())
       beginsAfterIndex++;
 
     // Again, see above for the meaning of endsBeforeIndex at this point.
     // In particular, endsBeforeIndex may point to a collaped range which
     // represents the point at the end of the interval - this range should be
     // included
     if (endsBeforeIndex < (int32_t)mRanges.Length()) {
-      nsRange* endRange = mRanges[endsBeforeIndex].mRange;
+      const nsRange* endRange = mRanges[endsBeforeIndex].mRange;
       if (RangeMatchesBeginPoint(endRange, aEndNode, aEndOffset) &&
           endRange->Collapsed())
         endsBeforeIndex++;
     }
   }
 
   NS_ASSERTION(beginsAfterIndex <= endsBeforeIndex, "Is mRanges not ordered?");
   NS_ENSURE_STATE(beginsAfterIndex <= endsBeforeIndex);

--- a/dom/base/Selection.h
+++ b/dom/base/Selection.h
@@ -722,28 +722,35 @@ class Selection final : public nsSupport
                                  TableSelection* aTableSelectionType);
   MOZ_CAN_RUN_SCRIPT_BOUNDARY
   nsresult GetTableCellLocationFromRange(nsRange* aRange,
                                          TableSelection* aSelectionType,
                                          int32_t* aRow, int32_t* aCol);
   nsresult AddTableCellRange(nsRange* aRange, bool* aDidAddRange,
                              int32_t* aOutIndex);
 
-  nsresult FindInsertionPoint(nsTArray<RangeData>* aElementArray,
-                              nsINode* aPointNode, int32_t aPointOffset,
-                              nsresult (*aComparator)(nsINode*, int32_t,
-                                                      nsRange*, int32_t*),
-                              int32_t* aPoint);
-  bool EqualsRangeAtPoint(nsINode* aBeginNode, int32_t aBeginOffset,
-                          nsINode* aEndNode, int32_t aEndOffset,
-                          int32_t aRangeIndex);
-  nsresult GetIndicesForInterval(nsINode* aBeginNode, int32_t aBeginOffset,
-                                 nsINode* aEndNode, int32_t aEndOffset,
-                                 bool aAllowAdjacent, int32_t* aStartIndex,
-                                 int32_t* aEndIndex);
+  static nsresult FindInsertionPoint(
+      const nsTArray<RangeData>* aElementArray, const nsINode* aPointNode,
+      int32_t aPointOffset,
+      nsresult (*aComparator)(const nsINode*, int32_t, const nsRange*,
+                              int32_t*),
+      int32_t* aPoint);
+  bool EqualsRangeAtPoint(const nsINode* aBeginNode, int32_t aBeginOffset,
+                          const nsINode* aEndNode, int32_t aEndOffset,
+                          int32_t aRangeIndex) const;
+  /**
+   * Works on the same principle as GetRangesForIntervalArray, however
+   * instead this returns the indices into mRanges between which the
+   * overlapping ranges lie.
+   */
+  nsresult GetIndicesForInterval(const nsINode* aBeginNode,
+                                 int32_t aBeginOffset, const nsINode* aEndNode,
+                                 int32_t aEndOffset, bool aAllowAdjacent,
+                                 int32_t* aStartIndex,
+                                 int32_t* aEndIndex) const;
   RangeData* FindRangeData(nsRange* aRange);
 
   static void UserSelectRangesToAdd(nsRange* aItem,
                                     nsTArray<RefPtr<nsRange>>& rangesToAdd);
 
   /**
    * Preserves the sorting of mRanges.
    */

--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -2421,30 +2421,30 @@ bool nsContentUtils::PositionIsBefore(ns
   // Note, CompareDocumentPosition takes the latter params in different order.
   return (aNode2->CompareDocumentPosition(*aNode1, aNode2Index, aNode1Index) &
           (Node_Binding::DOCUMENT_POSITION_PRECEDING |
            Node_Binding::DOCUMENT_POSITION_DISCONNECTED)) ==
          Node_Binding::DOCUMENT_POSITION_PRECEDING;
 }
 
 /* static */
-int32_t nsContentUtils::ComparePoints(nsINode* aParent1, int32_t aOffset1,
-                                      nsINode* aParent2, int32_t aOffset2,
+int32_t nsContentUtils::ComparePoints(const nsINode* aParent1, int32_t aOffset1,
+                                      const nsINode* aParent2, int32_t aOffset2,
                                       bool* aDisconnected,
                                       ComparePointsCache* aParent1Cache) {
   if (aParent1 == aParent2) {
     // XXX This is odd.  aOffset1 and/or aOffset2 may be -1, e.g., it's result
     //     of nsINode::ComputeIndexOf(), but this compares such invalid
     //     offset with valid offset.
     return aOffset1 < aOffset2 ? -1 : aOffset1 > aOffset2 ? 1 : 0;
   }
 
-  AutoTArray<nsINode*, 32> parents1, parents2;
-  nsINode* node1 = aParent1;
-  nsINode* node2 = aParent2;
+  AutoTArray<const nsINode*, 32> parents1, parents2;
+  const nsINode* node1 = aParent1;
+  const nsINode* node2 = aParent2;
   do {
     parents1.AppendElement(node1);
     node1 = node1->GetParentNode();
   } while (node1);
   do {
     parents2.AppendElement(node2);
     node2 = node2->GetParentNode();
   } while (node2);
@@ -2457,44 +2457,44 @@ int32_t nsContentUtils::ComparePoints(ns
     *aDisconnected = disconnected;
   }
   if (disconnected) {
     NS_ASSERTION(aDisconnected, "unexpected disconnected nodes");
     return 1;
   }
 
   // Find where the parent chains differ
-  nsINode* parent = parents1.ElementAt(pos1);
+  const nsINode* parent = parents1.ElementAt(pos1);
   uint32_t len;
   for (len = std::min(pos1, pos2); len > 0; --len) {
-    nsINode* child1 = parents1.ElementAt(--pos1);
-    nsINode* child2 = parents2.ElementAt(--pos2);
+    const nsINode* child1 = parents1.ElementAt(--pos1);
+    const nsINode* child2 = parents2.ElementAt(--pos2);
     if (child1 != child2) {
       int32_t child1index = aParent1Cache
                                 ? aParent1Cache->ComputeIndexOf(parent, child1)
                                 : parent->ComputeIndexOf(child1);
       return child1index < parent->ComputeIndexOf(child2) ? -1 : 1;
     }
     parent = child1;
   }
 
   // The parent chains never differed, so one of the nodes is an ancestor of
   // the other
 
   NS_ASSERTION(!pos1 || !pos2,
                "should have run out of parent chain for one of the nodes");
 
   if (!pos1) {
-    nsINode* child2 = parents2.ElementAt(--pos2);
+    const nsINode* child2 = parents2.ElementAt(--pos2);
     // XXX aOffset1 may be -1 as mentioned above.  So, why does this return
     //     it's *before* of the valid DOM point?
     return aOffset1 <= parent->ComputeIndexOf(child2) ? -1 : 1;
   }
 
-  nsINode* child1 = parents1.ElementAt(--pos1);
+  const nsINode* child1 = parents1.ElementAt(--pos1);
   // XXX aOffset2 may be -1 as mentioned above.  So, why does this return it's
   //     *after* of the valid DOM point?
   int32_t child1index = aParent1Cache
                             ? aParent1Cache->ComputeIndexOf(parent, child1)
                             : parent->ComputeIndexOf(child1);
   return child1index < aOffset2 ? -1 : 1;
 }
 

--- a/dom/base/nsContentUtils.h
+++ b/dom/base/nsContentUtils.h
@@ -467,30 +467,30 @@ class nsContentUtils {
    * parent node. If value is -1, the value will be set to the return value of
    * ComputeIndexOf.
    */
   static bool PositionIsBefore(nsINode* aNode1, nsINode* aNode2,
                                int32_t* aNode1Index = nullptr,
                                int32_t* aNode2Index = nullptr);
 
   struct ComparePointsCache {
-    int32_t ComputeIndexOf(nsINode* aParent, nsINode* aChild) {
+    int32_t ComputeIndexOf(const nsINode* aParent, const nsINode* aChild) {
       if (aParent == mParent && aChild == mChild) {
         return mIndex;
       }
 
       mIndex = aParent->ComputeIndexOf(aChild);
       mParent = aParent;
       mChild = aChild;
       return mIndex;
     }
 
    private:
-    nsINode* mParent = nullptr;
-    nsINode* mChild = nullptr;
+    const nsINode* mParent = nullptr;
+    const nsINode* mChild = nullptr;
     int32_t mIndex = 0;
   };
 
   /**
    *  Utility routine to compare two "points", where a point is a
    *  node/offset pair
    *  Returns -1 if point1 < point2, 1, if point1 > point2,
    *  0 if error or if point1 == point2.
@@ -503,18 +503,18 @@ class nsContentUtils {
    *
    *  XXX aOffset1 and aOffset2 should be uint32_t since valid offset value is
    *      between 0 - UINT32_MAX.  However, these methods work even with
    *      negative offset values!  E.g., when aOffset1 is -1 and aOffset is 0,
    *      these methods return -1.  Some root callers depend on this behavior.
    *      On the other hand, nsINode can have ATTRCHILD_ARRAY_MAX_CHILD_COUN
    *      (0x3FFFFF) at most.  Therefore, they can be int32_t for now.
    */
-  static int32_t ComparePoints(nsINode* aParent1, int32_t aOffset1,
-                               nsINode* aParent2, int32_t aOffset2,
+  static int32_t ComparePoints(const nsINode* aParent1, int32_t aOffset1,
+                               const nsINode* aParent2, int32_t aOffset2,
                                bool* aDisconnected = nullptr,
                                ComparePointsCache* aParent1Cache = nullptr);
   template <typename FPT, typename FRT, typename SPT, typename SRT>
   static int32_t ComparePoints(
       const mozilla::RangeBoundaryBase<FPT, FRT>& aFirstBoundary,
       const mozilla::RangeBoundaryBase<SPT, SRT>& aSecondBoundary,
       bool* aDisconnected = nullptr);
 

--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -6124,46 +6124,45 @@ static bool SweepArenaList(Arena** arena
       return false;
     }
   }
 
   return true;
 }
 
 IncrementalProgress GCRuntime::sweepTypeInformation(FreeOp* fop,
-                                                    SliceBudget& budget,
-                                                    Zone* zone) {
+                                                    SliceBudget& budget) {
   // Sweep dead type information stored in scripts and object groups, but
   // don't finalize them yet. We have to sweep dead information from both live
   // and dead scripts and object groups, so that no dead references remain in
   // them. Type inference can end up crawling these zones again, such as for
   // TypeCompartment::markSetsUnknown, and if this happens after sweeping for
   // the sweep group finishes we won't be able to determine which things in
   // the zone are live.
 
   gcstats::AutoPhase ap1(stats(), gcstats::PhaseKind::SWEEP_COMPARTMENTS);
   gcstats::AutoPhase ap2(stats(), gcstats::PhaseKind::SWEEP_TYPES);
 
-  ArenaLists& al = zone->arenas;
-
-  AutoClearTypeInferenceStateOnOOM oom(zone);
+  ArenaLists& al = sweepZone->arenas;
+
+  AutoClearTypeInferenceStateOnOOM oom(sweepZone);
 
   if (!SweepArenaList<JSScript>(&al.gcScriptArenasToUpdate.ref(), budget)) {
     return NotFinished;
   }
 
   if (!SweepArenaList<ObjectGroup>(&al.gcObjectGroupArenasToUpdate.ref(),
                                    budget)) {
     return NotFinished;
   }
 
   // Finish sweeping type information in the zone.
   {
     gcstats::AutoPhase ap(stats(), gcstats::PhaseKind::SWEEP_TYPES_END);
-    zone->types.endSweep(rt);
+    sweepZone->types.endSweep(rt);
   }
 
   return Finished;
 }
 
 IncrementalProgress GCRuntime::releaseSweptEmptyArenas(FreeOp* fop,
                                                        SliceBudget& budget) {
   // Foreground finalized GC things have already been finalized, and now their
@@ -6340,40 +6339,40 @@ IncrementalProgress GCRuntime::sweepWeak
     // Tasks run until budget or work is exhausted.
   }
 
   AutoLockHelperThreadState lock;
   return work.empty(lock) ? Finished : NotFinished;
 }
 
 IncrementalProgress GCRuntime::finalizeAllocKind(FreeOp* fop,
-                                                 SliceBudget& budget,
-                                                 Zone* zone, AllocKind kind) {
+                                                 SliceBudget& budget) {
   // Set the number of things per arena for this AllocKind.
-  size_t thingsPerArena = Arena::thingsPerArena(kind);
+  size_t thingsPerArena = Arena::thingsPerArena(sweepAllocKind);
   auto& sweepList = incrementalSweepList.ref();
   sweepList.setThingsPerArena(thingsPerArena);
 
-  if (!zone->arenas.foregroundFinalize(fop, kind, budget, sweepList)) {
+  if (!sweepZone->arenas.foregroundFinalize(fop, sweepAllocKind, budget,
+                                            sweepList)) {
     return NotFinished;
   }
 
   // Reset the slots of the sweep list that we used.
   sweepList.reset(thingsPerArena);
 
   return Finished;
 }
 
-IncrementalProgress GCRuntime::sweepShapeTree(FreeOp* fop, SliceBudget& budget,
-                                              Zone* zone) {
+IncrementalProgress GCRuntime::sweepShapeTree(FreeOp* fop,
+                                              SliceBudget& budget) {
   // Remove dead shapes from the shape tree, but don't finalize them yet.
 
   gcstats::AutoPhase ap(stats(), gcstats::PhaseKind::SWEEP_SHAPE);
 
-  ArenaLists& al = zone->arenas;
+  ArenaLists& al = sweepZone->arenas;
 
   if (!SweepArenaList<Shape>(&al.gcShapeArenasToUpdate.ref(), budget)) {
     return NotFinished;
   }
 
   if (!SweepArenaList<AccessorShape>(&al.gcAccessorShapeArenasToUpdate.ref(),
                                      budget)) {
     return NotFinished;
@@ -6458,44 +6457,50 @@ class js::gc::SweepGroupsIter {
     MOZ_ASSERT(!done());
     gc->getNextSweepGroup();
   }
 };
 
 namespace sweepaction {
 
 // Implementation of the SweepAction interface that calls a method on GCRuntime.
-template <typename... Args>
-class SweepActionCall final : public SweepAction<GCRuntime*, Args...> {
-  using Method = IncrementalProgress (GCRuntime::*)(Args...);
+class SweepActionCall final : public SweepAction {
+  using Method = IncrementalProgress (GCRuntime::*)(FreeOp* fop,
+                                                    SliceBudget& budget);
 
   Method method;
 
  public:
   explicit SweepActionCall(Method m) : method(m) {}
-  IncrementalProgress run(GCRuntime* gc, Args... args) override {
-    return (gc->*method)(args...);
+  IncrementalProgress run(Args& args) override {
+    return (args.gc->*method)(args.fop, args.budget);
   }
   void assertFinished() const override {}
 };
 
 // Implementation of the SweepAction interface that yields in a specified zeal
 // mode.
-template <typename... Args>
-class SweepActionMaybeYield final : public SweepAction<GCRuntime*, Args...> {
+class SweepActionMaybeYield final : public SweepAction {
+#ifdef JS_GC_ZEAL
   ZealMode mode;
   bool isYielding;
+#endif
 
  public:
   explicit SweepActionMaybeYield(ZealMode mode)
-      : mode(mode), isYielding(false) {}
-
-  IncrementalProgress run(GCRuntime* gc, Args... args) override {
 #ifdef JS_GC_ZEAL
-    if (!isYielding && gc->shouldYieldForZeal(mode)) {
+      : mode(mode),
+        isYielding(false)
+#endif
+  {
+  }
+
+  IncrementalProgress run(Args& args) override {
+#ifdef JS_GC_ZEAL
+    if (!isYielding && args.gc->shouldYieldForZeal(mode)) {
       isYielding = true;
       return NotFinished;
     }
 
     isYielding = false;
 #endif
     return Finished;
   }
@@ -6505,216 +6510,149 @@ class SweepActionMaybeYield final : publ
   // These actions should be skipped if GC zeal is not configured.
 #ifndef JS_GC_ZEAL
   bool shouldSkip() override { return true; }
 #endif
 };
 
 // Implementation of the SweepAction interface that calls a list of actions in
 // sequence.
-template <typename... Args>
-class SweepActionSequence final : public SweepAction<Args...> {
-  using Action = SweepAction<Args...>;
-  using ActionVector = Vector<UniquePtr<Action>, 0, SystemAllocPolicy>;
+class SweepActionSequence final : public SweepAction {
+  using ActionVector = Vector<UniquePtr<SweepAction>, 0, SystemAllocPolicy>;
   using Iter = IncrementalIter<ContainerIter<ActionVector>>;
 
   ActionVector actions;
   typename Iter::State iterState;
 
  public:
-  bool init(UniquePtr<Action>* acts, size_t count) {
+  bool init(UniquePtr<SweepAction>* acts, size_t count) {
     for (size_t i = 0; i < count; i++) {
       auto& action = acts[i];
       if (!action) {
         return false;
       }
       if (action->shouldSkip()) {
         continue;
       }
       if (!actions.emplaceBack(std::move(action))) {
         return false;
       }
     }
     return true;
   }
 
-  IncrementalProgress run(Args... args) override {
+  IncrementalProgress run(Args& args) override {
     for (Iter iter(iterState, actions); !iter.done(); iter.next()) {
-      if (iter.get()->run(args...) == NotFinished) {
+      if (iter.get()->run(args) == NotFinished) {
         return NotFinished;
       }
     }
     return Finished;
   }
 
   void assertFinished() const override {
     MOZ_ASSERT(iterState.isNothing());
     for (const auto& action : actions) {
       action->assertFinished();
     }
   }
 };
 
-template <typename Iter, typename Init, typename... Args>
-class SweepActionForEach final : public SweepAction<Args...> {
+template <typename Iter, typename Init>
+class SweepActionForEach final : public SweepAction {
   using Elem = decltype(mozilla::DeclVal<Iter>().get());
-  using Action = SweepAction<Args..., Elem>;
   using IncrIter = IncrementalIter<Iter>;
 
   Init iterInit;
-  UniquePtr<Action> action;
+  Elem* elemOut;
+  UniquePtr<SweepAction> action;
   typename IncrIter::State iterState;
 
  public:
-  SweepActionForEach(const Init& init, UniquePtr<Action> action)
-      : iterInit(init), action(std::move(action)) {}
-
-  IncrementalProgress run(Args... args) override {
+  SweepActionForEach(const Init& init, Elem* maybeElemOut,
+                     UniquePtr<SweepAction> action)
+      : iterInit(init), elemOut(maybeElemOut), action(std::move(action)) {}
+
+  IncrementalProgress run(Args& args) override {
+    MOZ_ASSERT_IF(elemOut, *elemOut == Elem());
+    auto clearElem = mozilla::MakeScopeExit([&] { setElem(Elem()); });
     for (IncrIter iter(iterState, iterInit); !iter.done(); iter.next()) {
-      if (action->run(args..., iter.get()) == NotFinished) {
-        return NotFinished;
-      }
-    }
-    return Finished;
-  }
-
-  void assertFinished() const override {
-    MOZ_ASSERT(iterState.isNothing());
-    action->assertFinished();
-  }
-};
-
-template <typename Iter, typename Init, typename... Args>
-class SweepActionRepeatFor final : public SweepAction<Args...> {
- protected:
-  using Action = SweepAction<Args...>;
-  using IncrIter = IncrementalIter<Iter>;
-
-  Init iterInit;
-  UniquePtr<Action> action;
-  typename IncrIter::State iterState;
-
- public:
-  SweepActionRepeatFor(const Init& init, UniquePtr<Action> action)
-      : iterInit(init), action(std::move(action)) {}
-
-  IncrementalProgress run(Args... args) override {
-    for (IncrIter iter(iterState, iterInit); !iter.done(); iter.next()) {
-      if (action->run(args...) == NotFinished) {
+      setElem(iter.get());
+      if (action->run(args) == NotFinished) {
         return NotFinished;
       }
     }
     return Finished;
   }
 
   void assertFinished() const override {
     MOZ_ASSERT(iterState.isNothing());
+    MOZ_ASSERT_IF(elemOut, *elemOut == Elem());
     action->assertFinished();
   }
+
+ private:
+  void setElem(const Elem& value) {
+    if (elemOut) {
+      *elemOut = value;
+    }
+  }
 };
 
-// Helper class to remove the last template parameter from the instantiation of
-// a variadic template. For example:
-//
-//   RemoveLastTemplateParameter<Foo<X, Y, Z>>::Type ==> Foo<X, Y>
-//
-// This works by recursively instantiating the Impl template with the contents
-// of the parameter pack so long as there are at least two parameters. The
-// specialization that matches when only one parameter remains discards it and
-// instantiates the target template with parameters previously processed.
-template <typename T>
-class RemoveLastTemplateParameter {};
-
-template <template <typename...> class Target, typename... Args>
-class RemoveLastTemplateParameter<Target<Args...>> {
-  template <typename... Ts>
-  struct List {};
-
-  template <typename R, typename... Ts>
-  struct Impl {};
-
-  template <typename... Rs, typename T>
-  struct Impl<List<Rs...>, T> {
-    using Type = Target<Rs...>;
-  };
-
-  template <typename... Rs, typename H, typename T, typename... Ts>
-  struct Impl<List<Rs...>, H, T, Ts...> {
-    using Type = typename Impl<List<Rs..., H>, T, Ts...>::Type;
-  };
-
- public:
-  using Type = typename Impl<List<>, Args...>::Type;
-};
-
-template <typename... Args>
-static UniquePtr<SweepAction<GCRuntime*, Args...>> Call(
-    IncrementalProgress (GCRuntime::*method)(Args...)) {
-  return MakeUnique<SweepActionCall<Args...>>(method);
-}
-
-static UniquePtr<SweepAction<GCRuntime*, FreeOp*, SliceBudget&>> MaybeYield(
-    ZealMode zealMode) {
-  return js::MakeUnique<SweepActionMaybeYield<FreeOp*, SliceBudget&>>(zealMode);
-}
-
-static UniquePtr<SweepAction<GCRuntime*, FreeOp*, SliceBudget&, Zone*>>
-MaybeYieldInZoneLoop(ZealMode zealMode) {
-  return js::MakeUnique<SweepActionMaybeYield<FreeOp*, SliceBudget&, Zone*>>(
-      zealMode);
-}
-
-template <typename... Args, typename... Rest>
-static UniquePtr<SweepAction<Args...>> Sequence(
-    UniquePtr<SweepAction<Args...>> first, Rest... rest) {
-  UniquePtr<SweepAction<Args...>> actions[] = {std::move(first),
-                                               std::move(rest)...};
-  auto seq = MakeUnique<SweepActionSequence<Args...>>();
+static UniquePtr<SweepAction> Call(IncrementalProgress (GCRuntime::*method)(
+    FreeOp* fop, SliceBudget& budget)) {
+  return MakeUnique<SweepActionCall>(method);
+}
+
+static UniquePtr<SweepAction> MaybeYield(ZealMode zealMode) {
+  return MakeUnique<SweepActionMaybeYield>(zealMode);
+}
+
+template <typename... Rest>
+static UniquePtr<SweepAction> Sequence(UniquePtr<SweepAction> first,
+                                       Rest... rest) {
+  UniquePtr<SweepAction> actions[] = {std::move(first), std::move(rest)...};
+  auto seq = MakeUnique<SweepActionSequence>();
   if (!seq || !seq->init(actions, ArrayLength(actions))) {
     return nullptr;
   }
 
-  return UniquePtr<SweepAction<Args...>>(std::move(seq));
-}
-
-template <typename... Args>
-static UniquePtr<SweepAction<Args...>> RepeatForSweepGroup(
-    JSRuntime* rt, UniquePtr<SweepAction<Args...>> action) {
+  return UniquePtr<SweepAction>(std::move(seq));
+}
+
+static UniquePtr<SweepAction> RepeatForSweepGroup(
+    JSRuntime* rt, UniquePtr<SweepAction> action) {
+  if (!action) {
+    return nullptr;
+  }
+
+  using Action = SweepActionForEach<SweepGroupsIter, JSRuntime*>;
+  return js::MakeUnique<Action>(rt, nullptr, std::move(action));
+}
+
+static UniquePtr<SweepAction> ForEachZoneInSweepGroup(
+    JSRuntime* rt, Zone** zoneOut, UniquePtr<SweepAction> action) {
   if (!action) {
     return nullptr;
   }
 
-  using Action = SweepActionRepeatFor<SweepGroupsIter, JSRuntime*, Args...>;
-  return js::MakeUnique<Action>(rt, std::move(action));
-}
-
-template <typename... Args>
-static UniquePtr<
-    typename RemoveLastTemplateParameter<SweepAction<Args...>>::Type>
-ForEachZoneInSweepGroup(JSRuntime* rt, UniquePtr<SweepAction<Args...>> action) {
+  using Action = SweepActionForEach<SweepGroupZonesIter, JSRuntime*>;
+  return js::MakeUnique<Action>(rt, zoneOut, std::move(action));
+}
+
+static UniquePtr<SweepAction> ForEachAllocKind(AllocKinds kinds,
+                                               AllocKind* kindOut,
+                                               UniquePtr<SweepAction> action) {
   if (!action) {
     return nullptr;
   }
 
-  using Action = typename RemoveLastTemplateParameter<
-      SweepActionForEach<SweepGroupZonesIter, JSRuntime*, Args...>>::Type;
-  return js::MakeUnique<Action>(rt, std::move(action));
-}
-
-template <typename... Args>
-static UniquePtr<
-    typename RemoveLastTemplateParameter<SweepAction<Args...>>::Type>
-ForEachAllocKind(AllocKinds kinds, UniquePtr<SweepAction<Args...>> action) {
-  if (!action) {
-    return nullptr;
-  }
-
-  using Action = typename RemoveLastTemplateParameter<
-      SweepActionForEach<ContainerIter<AllocKinds>, AllocKinds, Args...>>::Type;
-  return js::MakeUnique<Action>(kinds, std::move(action));
+  using Action =
+      SweepActionForEach<ContainerIter<AllocKinds>, AllocKinds>;
+  return js::MakeUnique<Action>(kinds, kindOut, std::move(action));
 }
 
 }  // namespace sweepaction
 
 bool GCRuntime::initSweepActions() {
   using namespace sweepaction;
   using sweepaction::Call;
 
@@ -6725,28 +6663,29 @@ bool GCRuntime::initSweepActions() {
           Call(&GCRuntime::endMarkingSweepGroup),
           Call(&GCRuntime::beginSweepingSweepGroup),
           MaybeYield(ZealMode::IncrementalMultipleSlices),
           MaybeYield(ZealMode::YieldBeforeSweepingAtoms),
           Call(&GCRuntime::sweepAtomsTable),
           MaybeYield(ZealMode::YieldBeforeSweepingCaches),
           Call(&GCRuntime::sweepWeakCaches),
           ForEachZoneInSweepGroup(
-              rt,
-              Sequence(
-                  MaybeYieldInZoneLoop(ZealMode::YieldBeforeSweepingTypes),
-                  Call(&GCRuntime::sweepTypeInformation),
-                  MaybeYieldInZoneLoop(ZealMode::YieldBeforeSweepingObjects),
-                  ForEachAllocKind(ForegroundObjectFinalizePhase.kinds,
-                                   Call(&GCRuntime::finalizeAllocKind)),
-                  MaybeYieldInZoneLoop(ZealMode::YieldBeforeSweepingNonObjects),
-                  ForEachAllocKind(ForegroundNonObjectFinalizePhase.kinds,
-                                   Call(&GCRuntime::finalizeAllocKind)),
-                  MaybeYieldInZoneLoop(ZealMode::YieldBeforeSweepingShapeTrees),
-                  Call(&GCRuntime::sweepShapeTree))),
+              rt, &sweepZone.ref(),
+              Sequence(MaybeYield(ZealMode::YieldBeforeSweepingTypes),
+                       Call(&GCRuntime::sweepTypeInformation),
+                       MaybeYield(ZealMode::YieldBeforeSweepingObjects),
+                       ForEachAllocKind(ForegroundObjectFinalizePhase.kinds,
+                                        &sweepAllocKind.ref(),
+                                        Call(&GCRuntime::finalizeAllocKind)),
+                       MaybeYield(ZealMode::YieldBeforeSweepingNonObjects),
+                       ForEachAllocKind(ForegroundNonObjectFinalizePhase.kinds,
+                                        &sweepAllocKind.ref(),
+                                        Call(&GCRuntime::finalizeAllocKind)),
+                       MaybeYield(ZealMode::YieldBeforeSweepingShapeTrees),
+                       Call(&GCRuntime::sweepShapeTree))),
           Call(&GCRuntime::releaseSweptEmptyArenas),
           Call(&GCRuntime::endSweepingSweepGroup)));
 
   return sweepActions != nullptr;
 }
 
 IncrementalProgress GCRuntime::performSweepActions(SliceBudget& budget) {
   // Marked GC things may vary between recording and replaying, so sweep
@@ -6765,17 +6704,18 @@ IncrementalProgress GCRuntime::performSw
     MOZ_ASSERT(marker.isDrained());
   } else {
     if (markUntilBudgetExhausted(budget, gcstats::PhaseKind::SWEEP_MARK) ==
         NotFinished) {
       return NotFinished;
     }
   }
 
-  return sweepActions->run(this, &fop, budget);
+  SweepAction::Args args{this, &fop, budget};
+  return sweepActions->run(args);
 }
 
 bool GCRuntime::allCCVisibleZonesWereCollected() const {
   // Calculate whether the gray marking state is now valid.
   //
   // The gray bits change from invalid to valid if we finished a full GC from
   // the point of view of the cycle collector. We ignore the following:
   //

--- a/js/src/gc/GCRuntime.h
+++ b/js/src/gc/GCRuntime.h
@@ -46,24 +46,26 @@ class MarkingValidator;
 struct MovingTracer;
 enum class ShouldCheckThresholds;
 class SweepGroupsIter;
 class WeakCacheSweepIterator;
 
 enum IncrementalProgress { NotFinished = 0, Finished };
 
 // Interface to a sweep action.
-//
-// Note that we don't need perfect forwarding for args here because the
-// types are not deduced but come ultimately from the type of a function pointer
-// passed to SweepFunc.
-template <typename... Args>
 struct SweepAction {
+  // The arguments passed to each action.
+  struct Args {
+    GCRuntime* gc;
+    FreeOp* fop;
+    SliceBudget& budget;
+  };
+
   virtual ~SweepAction() {}
-  virtual IncrementalProgress run(Args... args) = 0;
+  virtual IncrementalProgress run(Args& state) = 0;
   virtual void assertFinished() const = 0;
   virtual bool shouldSkip() { return false; }
 };
 
 class ChunkPool {
   Chunk* head_;
   size_t count_;
 
@@ -647,26 +649,23 @@ class GCRuntime {
                                                        SliceBudget& budget);
   IncrementalProgress endMarkingSweepGroup(FreeOp* fop, SliceBudget& budget);
   void markIncomingCrossCompartmentPointers(MarkColor color);
   IncrementalProgress beginSweepingSweepGroup(FreeOp* fop, SliceBudget& budget);
   void sweepDebuggerOnMainThread(FreeOp* fop);
   void sweepJitDataOnMainThread(FreeOp* fop);
   IncrementalProgress endSweepingSweepGroup(FreeOp* fop, SliceBudget& budget);
   IncrementalProgress performSweepActions(SliceBudget& sliceBudget);
-  IncrementalProgress sweepTypeInformation(FreeOp* fop, SliceBudget& budget,
-                                           Zone* zone);
+  IncrementalProgress sweepTypeInformation(FreeOp* fop, SliceBudget& budget);
   IncrementalProgress releaseSweptEmptyArenas(FreeOp* fop, SliceBudget& budget);
   void startSweepingAtomsTable();
   IncrementalProgress sweepAtomsTable(FreeOp* fop, SliceBudget& budget);
   IncrementalProgress sweepWeakCaches(FreeOp* fop, SliceBudget& budget);
-  IncrementalProgress finalizeAllocKind(FreeOp* fop, SliceBudget& budget,
-                                        Zone* zone, AllocKind kind);
-  IncrementalProgress sweepShapeTree(FreeOp* fop, SliceBudget& budget,
-                                     Zone* zone);
+  IncrementalProgress finalizeAllocKind(FreeOp* fop, SliceBudget& budget);
+  IncrementalProgress sweepShapeTree(FreeOp* fop, SliceBudget& budget);
   void endSweepPhase(bool lastGC);
   bool allCCVisibleZonesWereCollected() const;
   void sweepZones(FreeOp* fop, bool destroyingRuntime);
   void decommitFreeArenasWithoutUnlocking(const AutoLockGC& lock);
   void startDecommit();
   void queueZonesAndStartBackgroundSweep(ZoneList& zones);
   void sweepFromBackgroundThread(AutoLockHelperThreadState& lock);
   void startBackgroundFree();
@@ -895,19 +894,19 @@ class GCRuntime {
   MainThreadData<unsigned> sweepGroupIndex;
 
   /*
    * Incremental sweep state.
    */
 
   MainThreadData<JS::Zone*> sweepGroups;
   MainThreadOrGCTaskData<JS::Zone*> currentSweepGroup;
-  MainThreadData<UniquePtr<SweepAction<GCRuntime*, FreeOp*, SliceBudget&>>>
-      sweepActions;
+  MainThreadData<UniquePtr<SweepAction>> sweepActions;
   MainThreadOrGCTaskData<JS::Zone*> sweepZone;
+  MainThreadOrGCTaskData<AllocKind> sweepAllocKind;
   MainThreadData<mozilla::Maybe<AtomsTable::SweepIterator>> maybeAtomsToSweep;
   MainThreadOrGCTaskData<JS::detail::WeakCacheBase*> sweepCache;
   MainThreadData<bool> hasMarkedGrayRoots;
   MainThreadData<bool> abortSweepAfterCurrentGroup;
 
 #ifdef DEBUG
   // During gray marking, delay AssertCellIsNotGray checks by
   // recording the cell pointers here and checking after marking has

--- a/js/src/gc/NurseryAwareHashMap.h
+++ b/js/src/gc/NurseryAwareHashMap.h
@@ -82,20 +82,20 @@ class NurseryAwareHashMap {
 
  public:
   using Lookup = typename MapType::Lookup;
   using Ptr = typename MapType::Ptr;
   using Range = typename MapType::Range;
   using Entry = typename MapType::Entry;
 
   explicit NurseryAwareHashMap(AllocPolicy a = AllocPolicy())
-      : map(std::move(a)) {}
+      : map(a), nurseryEntries(std::move(a)) {}
   explicit NurseryAwareHashMap(size_t length) : map(length) {}
   NurseryAwareHashMap(AllocPolicy a, size_t length)
-      : map(std::move(a), length) {}
+      : map(a, length), nurseryEntries(std::move(a)) {}
 
   bool empty() const { return map.empty(); }
   Ptr lookup(const Lookup& l) const { return map.lookup(l); }
   void remove(Ptr p) { map.remove(p); }
   Range all() const { return map.all(); }
   struct Enum : public MapType::Enum {
     explicit Enum(NurseryAwareHashMap& namap) : MapType::Enum(namap.map) {}
   };

--- a/js/src/vm/ArrayBufferObject.cpp
+++ b/js/src/vm/ArrayBufferObject.cpp
@@ -1568,17 +1568,17 @@ bool InnerViewTable::addView(JSContext* 
       }
     }
 
     if (!views.append(view)) {
       ReportOutOfMemory(cx);
       return false;
     }
   } else {
-    if (!map.add(p, buffer, ViewVector())) {
+    if (!map.add(p, buffer, ViewVector(cx->zone()))) {
       ReportOutOfMemory(cx);
       return false;
     }
     // ViewVector has one inline element, so the first insertion is
     // guaranteed to succeed.
     MOZ_ALWAYS_TRUE(p->value().append(view));
   }
 

--- a/js/src/vm/ArrayBufferObject.h
+++ b/js/src/vm/ArrayBufferObject.h
@@ -5,16 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef vm_ArrayBufferObject_h
 #define vm_ArrayBufferObject_h
 
 #include "mozilla/Maybe.h"
 
 #include "builtin/TypedObjectConstants.h"
+#include "gc/ZoneAllocator.h"
 #include "js/ArrayBuffer.h"
 #include "js/GCHashTable.h"
 #include "vm/JSObject.h"
 #include "vm/Runtime.h"
 #include "vm/SharedMem.h"
 #include "wasm/WasmTypes.h"
 
 namespace js {
@@ -601,17 +602,17 @@ template <>
 inline constexpr bool TypeIsUnsigned<uint32_t>() {
   return true;
 }
 
 // Per-compartment table that manages the relationship between array buffers
 // and the views that use their storage.
 class InnerViewTable {
  public:
-  typedef Vector<JSObject*, 1, SystemAllocPolicy> ViewVector;
+  typedef Vector<JSObject*, 1, ZoneAllocPolicy> ViewVector;
 
   friend class ArrayBufferObject;
 
  private:
   struct MapGCPolicy {
     static bool needsSweep(JSObject** key, ViewVector* value) {
       return InnerViewTable::sweepEntry(key, *value);
     }
@@ -620,19 +621,18 @@ class InnerViewTable {
   // This key is a raw pointer and not a WeakHeapPtr because the post-barrier
   // would hold nursery-allocated entries live unconditionally. It is a very
   // common pattern in low-level and performance-oriented JavaScript to create
   // hundreds or thousands of very short lived temporary views on a larger
   // buffer; having to tenured all of these would be a catastrophic performance
   // regression. Thus, it is vital that nursery pointers in this map not be held
   // live. Special support is required in the minor GC, implemented in
   // sweepAfterMinorGC.
-  typedef GCHashMap<JSObject*, ViewVector, MovableCellHasher<JSObject*>,
-                    SystemAllocPolicy, MapGCPolicy>
-      Map;
+  using Map = GCHashMap<JSObject*, ViewVector, MovableCellHasher<JSObject*>,
+                        ZoneAllocPolicy, MapGCPolicy>;
 
   // For all objects sharing their storage with some other view, this maps
   // the object to the list of such views. All entries in this map are weak.
   Map map;
 
   // List of keys from innerViews where either the source or at least one
   // target is in the nursery. The raw pointer to a JSObject is allowed here
   // because this vector is cleared after every minor collection. Users in
@@ -646,17 +646,17 @@ class InnerViewTable {
   // Sweep an entry during GC, returning whether the entry should be removed.
   static bool sweepEntry(JSObject** pkey, ViewVector& views);
 
   bool addView(JSContext* cx, ArrayBufferObject* buffer, JSObject* view);
   ViewVector* maybeViewsUnbarriered(ArrayBufferObject* obj);
   void removeViews(ArrayBufferObject* obj);
 
  public:
-  InnerViewTable() : nurseryKeysValid(true) {}
+  explicit InnerViewTable(Zone* zone) : map(zone), nurseryKeysValid(true) {}
 
   // Remove references to dead objects in the table and update table entries
   // to reflect moved objects.
   void sweep();
   void sweepAfterMinorGC();
 
   bool needsSweep() const { return map.needsSweep(); }
 

--- a/js/src/vm/Compartment.cpp
+++ b/js/src/vm/Compartment.cpp
@@ -36,17 +36,18 @@
 using namespace js;
 
 using JS::AutoStableStringChars;
 
 Compartment::Compartment(Zone* zone, bool invisibleToDebugger)
     : zone_(zone),
       runtime_(zone->runtimeFromAnyThread()),
       invisibleToDebugger_(invisibleToDebugger),
-      crossCompartmentWrappers(0) {}
+      crossCompartmentWrappers(zone, 0),
+      realms_(zone) {}
 
 #ifdef JSGC_HASH_TABLE_CHECKS
 
 void Compartment::checkWrapperMapAfterMovingGC() {
   /*
    * Assert that the postbarriers have worked and that nothing is left in
    * wrapperMap that points into the nursery, and that the hash table entries
    * are discoverable.

--- a/js/src/vm/Compartment.h
+++ b/js/src/vm/Compartment.h
@@ -13,16 +13,17 @@
 #include "mozilla/Tuple.h"
 #include "mozilla/Variant.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "gc/Barrier.h"
 #include "gc/NurseryAwareHashMap.h"
+#include "gc/ZoneAllocator.h"
 #include "js/UniquePtr.h"
 #include "vm/JSObject.h"
 #include "vm/JSScript.h"
 
 namespace js {
 
 // A key in a WrapperMap, a compartment's map from entities in other
 // compartments to the local values the compartment's own code must use to refer
@@ -271,22 +272,22 @@ class CrossCompartmentKey {
 // The data structure for storing CCWs, which has a map per target compartment
 // so we can access them easily. Note string CCWs are stored separately from the
 // others because they have target compartment nullptr.
 class WrapperMap {
   static const size_t InitialInnerMapSize = 4;
 
   using InnerMap =
       NurseryAwareHashMap<CrossCompartmentKey, JS::Value,
-                          CrossCompartmentKey::Hasher, SystemAllocPolicy>;
-  using OuterMap =
-      GCHashMap<JS::Compartment*, InnerMap, DefaultHasher<JS::Compartment*>,
-                SystemAllocPolicy>;
+                          CrossCompartmentKey::Hasher, ZoneAllocPolicy>;
+  using OuterMap = GCHashMap<JS::Compartment*, InnerMap,
+                             DefaultHasher<JS::Compartment*>, ZoneAllocPolicy>;
 
   OuterMap map;
+  Zone* zone;
 
  public:
   class Enum {
    public:
     enum SkipStrings : bool { WithStrings = false, WithoutStrings = true };
 
    private:
     Enum(const Enum&) = delete;
@@ -376,18 +377,18 @@ class WrapperMap {
     friend class WrapperMap;
 
     InnerMap* map;
 
     Ptr() : InnerMap::Ptr(), map(nullptr) {}
     Ptr(const InnerMap::Ptr& p, InnerMap& m) : InnerMap::Ptr(p), map(&m) {}
   };
 
-  WrapperMap() {}
-  explicit WrapperMap(size_t aLen) : map(aLen) {}
+  explicit WrapperMap(Zone* zone) : map(zone), zone(zone) {}
+  WrapperMap(Zone* zone, size_t aLen) : map(zone, aLen), zone(zone) {}
 
   bool empty() {
     if (map.empty()) {
       return true;
     }
     for (OuterMap::Enum e(map); !e.empty(); e.popFront()) {
       if (!e.front().value().empty()) {
         return false;
@@ -413,17 +414,17 @@ class WrapperMap {
     }
   }
 
   MOZ_MUST_USE bool put(const CrossCompartmentKey& k, const JS::Value& v) {
     JS::Compartment* c = const_cast<CrossCompartmentKey&>(k).compartment();
     MOZ_ASSERT(k.is<JSString*>() == !c);
     auto p = map.lookupForAdd(c);
     if (!p) {
-      InnerMap m(InitialInnerMapSize);
+      InnerMap m(zone, InitialInnerMapSize);
       if (!map.add(p, c, std::move(m))) {
         return false;
       }
     }
     return p->value().put(k, v);
   }
 
   size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) {
@@ -480,17 +481,17 @@ class WrapperMap {
 
 class JS::Compartment {
   JS::Zone* zone_;
   JSRuntime* runtime_;
   bool invisibleToDebugger_;
 
   js::WrapperMap crossCompartmentWrappers;
 
-  using RealmVector = js::Vector<JS::Realm*, 1, js::SystemAllocPolicy>;
+  using RealmVector = js::Vector<JS::Realm*, 1, js::ZoneAllocPolicy>;
   RealmVector realms_;
 
  public:
   /*
    * During GC, stores the head of a list of incoming pointers from gray cells.
    *
    * The objects in the list are either cross-compartment wrappers, or
    * debugger wrapper objects.  The list link is either in the second extra

--- a/js/src/vm/Realm.cpp
+++ b/js/src/vm/Realm.cpp
@@ -32,29 +32,31 @@
 #include "vm/JSAtom-inl.h"
 #include "vm/JSFunction-inl.h"
 #include "vm/JSObject-inl.h"
 #include "vm/JSScript-inl.h"
 #include "vm/NativeObject-inl.h"
 
 using namespace js;
 
-ObjectRealm::ObjectRealm(JS::Zone* zone) : innerViews(zone) {}
+ObjectRealm::ObjectRealm(JS::Zone* zone)
+    : innerViews(zone, zone), iteratorCache(zone) {}
 
 ObjectRealm::~ObjectRealm() {
   MOZ_ASSERT(enumerators == iteratorSentinel_.get());
 }
 
 Realm::Realm(Compartment* comp, const JS::RealmOptions& options)
     : JS::shadow::Realm(comp),
       zone_(comp->zone()),
       runtime_(comp->runtimeFromMainThread()),
       creationOptions_(options.creationOptions()),
       behaviors_(options.behaviors()),
       objects_(zone_),
+      varNames_(zone_),
       randomKeyGenerator_(runtime_->forkRandomKeyGenerator()),
       wasm(runtime_) {
   MOZ_ASSERT_IF(creationOptions_.mergeable(),
                 creationOptions_.invisibleToDebugger());
 
   runtime_->numRealms++;
 }
 

--- a/js/src/vm/Realm.h
+++ b/js/src/vm/Realm.h
@@ -250,17 +250,17 @@ class ObjectRealm {
   js::UniquePtr<js::ObjectWeakMap> lazyArrayBuffers;
 
   // Keep track of the metadata objects which can be associated with each JS
   // object. Both keys and values are in this realm.
   js::UniquePtr<js::ObjectWeakMap> objectMetadataTable;
 
   using IteratorCache =
       js::HashSet<js::PropertyIteratorObject*, js::IteratorHashPolicy,
-                  js::SystemAllocPolicy>;
+                  js::ZoneAllocPolicy>;
   IteratorCache iteratorCache;
 
   static inline ObjectRealm& get(const JSObject* obj);
 
   explicit ObjectRealm(JS::Zone* zone);
   ~ObjectRealm();
 
   MOZ_MUST_USE bool init(JSContext* cx);
@@ -325,17 +325,17 @@ class JS::Realm : public JS::shadow::Rea
       JSContext* cx);
 
   // The global environment record's [[VarNames]] list that contains all
   // names declared using FunctionDeclaration, GeneratorDeclaration, and
   // VariableDeclaration declarations in global code in this realm.
   // Names are only removed from this list by a |delete IdentifierReference|
   // that successfully removes that global property.
   using VarNamesSet =
-      JS::GCHashSet<JSAtom*, js::DefaultHasher<JSAtom*>, js::SystemAllocPolicy>;
+      JS::GCHashSet<JSAtom*, js::DefaultHasher<JSAtom*>, js::ZoneAllocPolicy>;
   VarNamesSet varNames_;
 
   friend class js::AutoSetNewObjectMetadata;
   js::NewObjectMetadataState objectMetadataState_{js::ImmediateMetadata()};
 
   // Random number generator for Math.random().
   mozilla::Maybe<mozilla::non_crypto::XorShift128PlusRNG>
       randomNumberGenerator_;

--- a/mobile/android/app/mobile.js
+++ b/mobile/android/app/mobile.js
@@ -776,23 +776,16 @@ pref("layout.accessiblecaret.script_chan
 
 // Optionally provide haptic feedback on longPress selection events.
 pref("layout.accessiblecaret.hapticfeedback", true);
 
 // Initial text selection on long-press is enhanced to provide
 // a smarter phone-number selection for direct-dial ActionBar action.
 pref("layout.accessiblecaret.extend_selection_for_phone_number", true);
 
-// Disable sending console to logcat on release builds.
-#ifdef RELEASE_OR_BETA
-pref("consoleservice.logcat", false);
-#else
-pref("consoleservice.logcat", true);
-#endif
-
 pref("browser.tabs.showAudioPlayingIcon", true);
 
 pref("dom.serviceWorkers.enabled", true);
 
 // Allow service workers to open windows for a longer period after a notification
 // click on mobile.  This is to account for some devices being quite slow.
 pref("dom.serviceWorkers.disable_open_click_delay", 5000);
 

--- a/modules/libpref/init/StaticPrefList.h
+++ b/modules/libpref/init/StaticPrefList.h
@@ -1050,16 +1050,30 @@ VARCACHE_PREF(
   Live,
   "clipboard.autocopy",
   clipboard_autocopy,
   bool, PREF_VALUE
 )
 #undef PREF_VALUE
 
 //---------------------------------------------------------------------------
+// Prefs starting with "consoleservice."
+//---------------------------------------------------------------------------
+
+#if defined(ANDROID)
+// Disable sending console to logcat on release builds.
+VARCACHE_PREF(
+  Live,
+  "consoleservice.logcat",
+   consoleservice_logcat,
+  RelaxedAtomicBool, NOT_IN_RELEASE_OR_BETA_VALUE
+)
+#endif
+
+//---------------------------------------------------------------------------
 // Prefs starting with "device."
 //---------------------------------------------------------------------------
 
 // Is support for the device sensors API enabled?
 VARCACHE_PREF(
   Live,
   "device.sensors.enabled",
   device_sensors_enabled,

--- a/nsprpub/TAG-INFO
+++ b/nsprpub/TAG-INFO
@@ -1,1 +1,1 @@
-NSPR_4_21_RTM
+NSPR_4_22_BETA1

--- a/nsprpub/admin/makeTargetDirs.sh
+++ b/nsprpub/admin/makeTargetDirs.sh
@@ -21,24 +21,20 @@
 mkdir  AIX4.3_64_DBG.OBJ
 mkdir  AIX4.3_64_OPT.OBJ
 mkdir  AIX4.3_DBG.OBJ
 mkdir  AIX4.3_OPT.OBJ
 mkdir  HP-UXB.11.00_64_DBG.OBJ
 mkdir  HP-UXB.11.00_64_OPT.OBJ
 mkdir  HP-UXB.11.00_DBG.OBJ
 mkdir  HP-UXB.11.00_OPT.OBJ
-mkdir  IRIX6.5_n32_PTH_DBG.OBJ
-mkdir  IRIX6.5_n32_PTH_OPT.OBJ
 mkdir  Linux2.2_x86_glibc_PTH_DBG.OBJ
 mkdir  Linux2.2_x86_glibc_PTH_OPT.OBJ
 mkdir  Linux2.4_x86_glibc_PTH_DBG.OBJ
 mkdir  Linux2.4_x86_glibc_PTH_OPT.OBJ
-mkdir  OSF1V4.0D_DBG.OBJ
-mkdir  OSF1V4.0D_OPT.OBJ
 mkdir  SunOS5.6_DBG.OBJ
 mkdir  SunOS5.6_OPT.OBJ
 mkdir  SunOS5.7_64_DBG.OBJ
 mkdir  SunOS5.7_64_OPT.OBJ
 mkdir  WIN954.0_DBG.OBJ
 mkdir  WIN954.0_DBG.OBJD
 mkdir  WIN954.0_OPT.OBJ
 mkdir  WINNT4.0_DBG.OBJ

--- a/nsprpub/admin/symlinks.sh
+++ b/nsprpub/admin/symlinks.sh
@@ -28,16 +28,13 @@ ln -s SunOS5.6_DBG.OBJ SunOS5.7_DBG.OBJ
 ln -s SunOS5.6_OPT.OBJ SunOS5.7_OPT.OBJ
 
 ln -s SunOS5.6_DBG.OBJ SunOS5.8_DBG.OBJ
 ln -s SunOS5.6_OPT.OBJ SunOS5.8_OPT.OBJ
 
 ln -s SunOS5.7_64_DBG.OBJ SunOS5.8_64_DBG.OBJ
 ln -s SunOS5.7_64_OPT.OBJ SunOS5.8_64_OPT.OBJ
 
-ln -s OSF1V4.0D_DBG.OBJ OSF1V5.0_DBG.OBJ
-ln -s OSF1V4.0D_OPT.OBJ OSF1V5.0_OPT.OBJ
-
 ln -s WINNT4.0_DBG.OBJ WINNT5.0_DBG.OBJ
 ln -s WINNT4.0_DBG.OBJD WINNT5.0_DBG.OBJD
 ln -s WINNT4.0_OPT.OBJ WINNT5.0_OPT.OBJ
 # --- end symlinks.sh ---------------------------------------------
 

--- a/nsprpub/config/Makefile.in
+++ b/nsprpub/config/Makefile.in
@@ -43,32 +43,16 @@ endif
 
 # Temporary workaround to disable the generation of
 # library build time because now.c uses the 'long long'
 # data type that's not available on some platforms.
 ifeq (,$(filter-out QNX SCOOS UNIXWARE,$(OS_ARCH)))
 DEFINES += -DOMIT_LIB_BUILD_TIME
 endif
 
-ifeq ($(OS_ARCH), IRIX)
-    ifeq ($(basename $(OS_RELEASE)),6)
-        ifndef NS_USE_GCC
-            ifeq ($(USE_N32),1)
-                XLDOPTS += -n32 -Wl,-woff,85
-            else
-                ifeq ($(USE_64),1)
-                    XLDOPTS += -64
-                else
-                    XLDOPTS += -32
-                endif
-            endif
-        endif
-    endif
-endif
-
 ifeq ($(OS_ARCH), HP-UX)
     ifeq ($(USE_64),1)
         XLDOPTS += +DD64
     endif
 endif
 
 ifeq ($(OS_ARCH), OS2)
 XCFLAGS = $(OS_CFLAGS)
@@ -76,17 +60,17 @@ endif
 
 include $(topsrcdir)/config/rules.mk
 
 PROGS	= $(OBJDIR)/now$(PROG_SUFFIX)
 
 ifeq (,$(CROSS_COMPILE)$(filter-out OS2 WINNT,$(OS_ARCH)))
 TARGETS = $(PROGS)
 else
-ifeq (,$(filter-out SYMBIAN WINCE,$(OS_ARCH)))
+ifeq (,$(filter-out WINCE,$(OS_ARCH)))
 TARGETS = $(PROGS)
 else
 PROGS	+= $(OBJDIR)/nsinstall$(PROG_SUFFIX)
 TARGETS = $(PROGS) $(PLSRCS:.pl=)
 endif
 endif
 
 OUTOPTION = -o # end of the line

--- a/nsprpub/config/autoconf.mk.in
+++ b/nsprpub/config/autoconf.mk.in
@@ -135,14 +135,13 @@ WRAP_SYSTEM_INCLUDES = @WRAP_SYSTEM_INCL
 
 MACOSX_DEPLOYMENT_TARGET = @MACOSX_DEPLOYMENT_TARGET@
 ifdef MACOSX_DEPLOYMENT_TARGET
 export MACOSX_DEPLOYMENT_TARGET
 endif
 
 MACOS_SDK_DIR	= @MACOS_SDK_DIR@
 
-SYMBIAN_SDK_DIR = @SYMBIAN_SDK_DIR@
 
 NEXT_ROOT	= @NEXT_ROOT@
 ifdef NEXT_ROOT
 export NEXT_ROOT
 endif

--- a/nsprpub/config/nsinstall.c
+++ b/nsprpub/config/nsinstall.c
@@ -25,19 +25,16 @@
 #ifdef USE_REENTRANT_LIBC
 #include "libc_r.h"
 #endif /* USE_REENTRANT_LIBC */
 
 #include "pathsub.h"
 
 #define HAVE_FCHMOD
 
-#if defined(BEOS)
-#undef HAVE_FCHMOD
-#endif
 
 /*
  * Does getcwd() take NULL as the first argument and malloc
  * the result buffer?
  */
 #if !defined(DARWIN)
 #define GETCWD_CAN_MALLOC
 #endif
@@ -512,14 +509,14 @@ reversepath(char *inpath, char *name, in
 	    len = strlen(name);
 	    cp -= len + 1;
 	    strcpy(cp, name);
 	    cp[len] = '/';
 	    free(name);
 	    xchdir("..");
 	} else {
 	    cp -= 3;
-	    strncpy(cp, "../", 3);
+	    memcpy(cp, "../", 3);
 	    xchdir(buf);
 	}
     }
     strcpy(outpath, cp);
 }

--- a/nsprpub/config/prdepend.h
+++ b/nsprpub/config/prdepend.h
@@ -5,9 +5,8 @@
 
 /*
  * A dummy header file that is a dependency for all the object files.
  * Used to force a full recompilation of NSPR in Mozilla's Tinderbox
  * depend builds.  See comments in rules.mk.
  */
 
 #error "Do not include this header file."
-

--- a/nsprpub/configure
+++ b/nsprpub/configure
@@ -618,17 +618,16 @@ ac_includes_default="\
 #ifdef HAVE_UNISTD_H
 # include <unistd.h>
 #endif"
 
 ac_subst_vars='LTLIBOBJS
 LIBOBJS
 MT
 NEXT_ROOT
-SYMBIAN_SDK_DIR
 MACOS_SDK_DIR
 WRAP_SYSTEM_INCLUDES
 VISIBILITY_FLAGS
 CYGWIN_WRAPPER
 OS_DLLFLAGS
 EXEFLAGS
 DLLFLAGS
 RCFLAGS
@@ -752,16 +751,17 @@ libdir
 psdir
 pdfdir
 dvidir
 htmldir
 infodir
 docdir
 oldincludedir
 includedir
+runstatedir
 localstatedir
 sharedstatedir
 sysconfdir
 datadir
 datarootdir
 libexecdir
 sbindir
 bindir
@@ -787,42 +787,38 @@ with_dist_prefix
 with_dist_bindir
 with_dist_includedir
 with_dist_libdir
 with_mozilla
 enable_optimize
 enable_debug
 enable_debug_symbols
 enable_win32_target
-enable_symbian_target
 enable_debug_rtl
 enable_static_rtl
-enable_n32
 enable_x32
 enable_64bit
 enable_mdupdate
 enable_cplus
 with_arm_kuser
 with_macos_sdk
 enable_macos_target
 enable_os2_high_mem
 enable_thumb2
 with_thumb
 with_thumb_interwork
 with_arch
 with_fpu
 with_float_abi
 with_soft_float
-with_symbian_sdk
 with_ccache
 enable_strip
 with_pthreads
 enable_user_pthreads
 enable_nspr_threads
-with_bthreads
 enable_ipv6
 enable_wrap_malloc
 with_wrap_malloc
 '
       ac_precious_vars='build_alias
 host_alias
 target_alias
 CC
@@ -867,17 +863,17 @@ x_libraries=NONE
 bindir='${exec_prefix}/bin'
 sbindir='${exec_prefix}/sbin'
 libexecdir='${exec_prefix}/libexec'
 datarootdir='${prefix}/share'
 datadir='${datarootdir}'
 sysconfdir='${prefix}/etc'
 sharedstatedir='${prefix}/com'
 localstatedir='${prefix}/var'
-
+runstatedir='${localstatedir}/run'
 includedir='${prefix}/include'
 oldincludedir='/usr/include'
 docdir='${datarootdir}/doc/${PACKAGE}'
 infodir='${datarootdir}/info'
 htmldir='${docdir}'
 dvidir='${docdir}'
 pdfdir='${docdir}'
 psdir='${docdir}'
@@ -1120,16 +1116,25 @@ do
     ac_prev=psdir ;;
   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
     psdir=$ac_optarg ;;
 
   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
   | -silent | --silent | --silen | --sile | --sil)
     silent=yes ;;
 
+  -runstatedir | --runstatedir | --runstatedi | --runstated \
+  | --runstate | --runstat | --runsta | --runst | --runs \
+  | --run | --ru | --r)
+    ac_prev=runstatedir ;;
+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+  | --run=* | --ru=* | --r=*)
+    runstatedir=$ac_optarg ;;
+
   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
     ac_prev=sbindir ;;
   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
   | --sbi=* | --sb=*)
     sbindir=$ac_optarg ;;
 
   -sharedstatedir | --sharedstatedir | --sharedstatedi \
   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
@@ -1257,17 +1262,17 @@ if test -n "$ac_unrecognized_opts"; then
     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
   esac
 fi
 
 # Check all directory arguments for consistency.
 for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
 		datadir sysconfdir sharedstatedir localstatedir includedir \
 		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
-		libdir localedir mandir
+		libdir localedir mandir runstatedir
 do
   eval ac_val=\$$ac_var
   # Remove trailing slashes.
   case $ac_val in
     */ )
       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
       eval $ac_var=\$ac_val;;
   esac
@@ -1410,16 +1415,17 @@ For better control, use the options belo
 
 Fine tuning of the installation directories:
   --bindir=DIR            user executables [EPREFIX/bin]
   --sbindir=DIR           system admin executables [EPREFIX/sbin]
   --libexecdir=DIR        program executables [EPREFIX/libexec]
   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
   --libdir=DIR            object code libraries [EPREFIX/lib]
   --includedir=DIR        C header files [PREFIX/include]
   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
   --infodir=DIR           info documentation [DATAROOTDIR/info]
   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
   --mandir=DIR            man documentation [DATAROOTDIR/man]
@@ -1448,21 +1454,18 @@ Optional Features:
   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
   --enable-optimize=OPT Enable code optimizations (ie. -O2)
   --enable-debug=DBG    Enable debugging (using compiler flags DBG)
   --enable-debug-symbols=DBG    Enable debugging symbols
                                        (using compiler flags DBG)
   --enable-win32-target=\$t
                           Specify win32 flavor. (WIN95 or WINNT)
-  --enable-symbian-target=\$t
-                          Specify symbian flavor. (WINSCW or GCCE)
   --enable-debug-rtl      Use the MSVC debug runtime library
   --enable-static-rtl     Use the MSVC static runtime library
-  --enable-n32            Enable n32 ABI support (IRIX only)
   --enable-x32            Enable x32 ABI support (x86_64 only)
   --enable-64bit          Enable 64-bit support (on certain platforms)
   --enable-mdupdate       Enable use of certain compilers' mdupdate feature
   --enable-cplus          Enable some c++ api routines
   --enable-macos-target=VER
                           Set the minimum MacOS version needed at runtime
                           10.2 for ppc, 10.4 for x86
   --disable-os2-high-mem  Disable high-memory support on OS/2
@@ -1501,23 +1504,19 @@ Optional Packages:
   --with-arch=[type|toolchain-default]
                            Use specific CPU features (-march=type)
   --with-fpu=[type|toolchain-default]
                            Use specific FPU type (-mfpu=type)
   --with-float-abi=[type|toolchain-default]
                            Use specific arm float ABI (-mfloat-abi=type)
   --with-soft-float[=yes|no|toolchain-default]
                            Use soft float library (-msoft-float)
-  --with-symbian-sdk=SYMBIAN_SDK_DIR
-                          The path to the Symbian SDK
   --with-ccache=path/to/ccache
                           Enable compiling with ccache
   --with-pthreads         Use system pthreads library as thread subsystem
-  --with-bthreads         Use system bthreads library as thread subsystem
-                          (BeOS only)
   --with-wrap-malloc=SHAREDLIB  Location of malloc wrapper library
 
 Some influential environment variables:
   CC          C compiler command
   CFLAGS      C compiler flags
   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
               nonstandard directory <lib dir>
   LIBS        libraries to pass to the linker, e.g. -l<library>
@@ -2482,17 +2481,17 @@ case $target_os in *\ *) target_os=`echo
 # The aliases save the names the user supplied, while $host etc.
 # will get canonicalized.
 test -n "$target_alias" &&
   test "$program_prefix$program_suffix$program_transform_name" = \
     NONENONEs,x,x, &&
   program_prefix=${target_alias}-
 
 MOD_MAJOR_VERSION=4
-MOD_MINOR_VERSION=21
+MOD_MINOR_VERSION=22
 MOD_PATCH_VERSION=0
 NSPR_MODNAME=nspr20
 _HAVE_PTHREADS=
 USE_PTHREADS=
 USE_USER_PTHREADS=
 USE_NSPR_THREADS=
 USE_N32=
 USE_X32=
@@ -2636,16 +2635,22 @@ fi
 
 # Check whether --with-android-platform was given.
 if test "${with_android_platform+set}" = set; then :
   withval=$with_android_platform; android_platform=$withval
 fi
 
 
 case "$target" in
+x86_64-linux*-android*)
+    android_tool_prefix="x86_64-linux-android"
+    ;;
+aarch64-linux*-android*)
+    android_tool_prefix="aarch64-linux-android"
+    ;;
 arm-linux*-android*|*-linuxandroid*)
     android_tool_prefix="arm-linux-androideabi"
     ;;
 i?86-*android*)
     android_tool_prefix="i686-linux-android"
     ;;
 mipsel-*android*)
     android_tool_prefix="mipsel-linux-android"
@@ -2850,21 +2855,16 @@ fi
 
 
 # Check whether --enable-win32-target was given.
 if test "${enable_win32_target+set}" = set; then :
   enableval=$enable_win32_target; OS_TARGET=`echo $enableval | tr a-z A-Z`
 fi
 
 
-# Check whether --enable-symbian-target was given.
-if test "${enable_symbian_target+set}" = set; then :
-  enableval=$enable_symbian_target; OS_TARGET=`echo $enableval | tr a-z A-Z`
-fi
-
 
 # Check whether --enable-debug-rtl was given.
 if test "${enable_debug_rtl+set}" = set; then :
   enableval=$enable_debug_rtl;  if test "$enableval" = "yes"; then
 	    USE_DEBUG_RTL=1
       else
 	    USE_DEBUG_RTL=0
       fi
@@ -2874,27 +2874,16 @@ fi
 # Check whether --enable-static-rtl was given.
 if test "${enable_static_rtl+set}" = set; then :
   enableval=$enable_static_rtl;  if test "$enableval" = "yes"; then
 	    USE_STATIC_RTL=1
       fi
 fi
 
 
-# Check whether --enable-n32 was given.
-if test "${enable_n32+set}" = set; then :
-  enableval=$enable_n32;  if test "$enableval" = "yes"; then
-	USE_N32=1
-      else if test "$enableval" = "no"; then
-	USE_N32=
-      fi
-    fi
-fi
-
-
 # Check whether --enable-x32 was given.
 if test "${enable_x32+set}" = set; then :
   enableval=$enable_x32;  if test "$enableval" = "yes"; then
         USE_X32=1
       else if test "$enableval" = "no"; then
         USE_X32=
       fi
     fi
@@ -2973,24 +2962,16 @@ if test -z "$CC"; then
             CC=xlc
         fi
     ;;
 
     *-hpux*)
         CC=cc
     ;;
 
-    *-irix*)
-        CC=cc
-    ;;
-
-    *-osf*)
-        CC=cc
-    ;;
-
     *-solaris*)
         CC=cc
     ;;
 
     esac
 fi
 
 if test -z "$CXX"; then
@@ -3013,24 +2994,16 @@ if test -z "$CXX"; then
             CXX=aCC
             ;;
         *)
             CXX=CC
             ;;
         esac
     ;;
 
-    *-irix*)
-        CXX=CC
-    ;;
-
-    *-osf*)
-        CXX=cxx
-    ;;
-
     *-solaris*)
         CXX=CC
     ;;
 
     esac
 fi
 
 if test -z "$SKIP_PATH_CHECKS"; then
@@ -3078,19 +3051,16 @@ fi
 fi
 
 if test -n "$MOZ_DEBUG"; then
     $as_echo "#define DEBUG 1" >>confdefs.h
 
     DEFINES="$DEFINES -UNDEBUG"
 
     case "${target_os}" in
-    beos*)
-        DEFINES="$DEFINES -DDEBUG_${USER}"
-        ;;
     mks*|cygwin*|mingw*|msys*|os2*)
         DEFINES="$DEFINES -DDEBUG_`echo ${USERNAME} | sed -e 's| |_|g'`"
         ;;
     *)
         DEFINES="$DEFINES -DDEBUG_`$WHOAMI`"
         ;;
     esac
 else
@@ -5621,20 +5591,16 @@ if test -n "$CROSS_COMPILE"; then
         riscos*)      OS_ARCH=RISCOS ;;
     esac
 else
     OS_ARCH=`uname -s | sed -e 's|/|_|g'`
     OS_RELEASE=`uname -r`
     OS_TEST=`uname -m`
 fi
 
-if test "$OS_ARCH" = "IRIX64"; then
-    OS_ARCH=IRIX
-fi
-
 if test "$OS_ARCH" = "AIX"; then
     OS_RELEASE=`uname -v`.`uname -r`
 fi
 
 if test "$OS_ARCH" = "FreeBSD"; then
     OS_RELEASE=`echo $OS_RELEASE | sed 's/-.*//'`
 fi
 
@@ -6011,19 +5977,16 @@ case "$host" in
     NSINSTALL=nsinstall
     ;;
 *-cygwin*|*-mks*)
     NSINSTALL='$(CYGWIN_WRAPPER) nsinstall'
     if test `echo "${PATH}" | grep -c \;` = 0; then
         CYGWIN_WRAPPER='sh $(topsrcdir)/build/cygwin-wrapper'
     fi
     ;;
-*-beos*)
-    HOST_CFLAGS="$HOST_CFLAGS -DXP_BEOS -DBeOS -DBEOS -D_POSIX_SOURCE"
-    ;;
 *os2*)
     ;;
 *)
     HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX"
     ;;
 esac
 
 case "$target" in
@@ -6369,87 +6332,16 @@ fi
         OBJECT_MODE=64
     else
         MDCPUCFG_H=_aix32.cfg
     fi
     PR_MD_CSRCS=aix.c
     RESOLVE_LINK_SYMBOLS=1
     ;;
 
-*-beos*)
-    $as_echo "#define XP_BEOS 1" >>confdefs.h
-
-    $as_echo "#define BeOS 1" >>confdefs.h
-
-    $as_echo "#define BEOS 1" >>confdefs.h
-
-    $as_echo "#define _POSIX_SOURCE 1" >>confdefs.h
-
-    DSO_LDOPTS=-nostart
-    MDCPUCFG_H=_beos.cfg
-    USE_BTHREADS=1
-    PR_MD_ARCH_DIR=beos
-    RESOLVE_LINK_SYMBOLS=1
-    case "${target_cpu}" in
-    i*86)
-        _OPTIMIZE_FLAGS=-O2
-        _DEBUG_FLAGS='-gdwarf-2 -O0'
-        MKSHLIB='$(CCC) $(DSO_LDOPTS) -o $@'
-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyaddr in -lbind" >&5
-$as_echo_n "checking for gethostbyaddr in -lbind... " >&6; }
-if ${ac_cv_lib_bind_gethostbyaddr+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lbind  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char gethostbyaddr ();
-int
-main ()
-{
-return gethostbyaddr ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  ac_cv_lib_bind_gethostbyaddr=yes
-else
-  ac_cv_lib_bind_gethostbyaddr=no
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bind_gethostbyaddr" >&5
-$as_echo "$ac_cv_lib_bind_gethostbyaddr" >&6; }
-if test "x$ac_cv_lib_bind_gethostbyaddr" = xyes; then :
-  OS_LIBS="$OS_LIBS -lbind -lsocket"
-fi
-
-        ;;
-    powerpc)
-        CC=mwcc
-        CCC=mwcc
-        LD=mwld
-        DSO_LDOPTS='-xms -export pragma -init _init_routine_ -term _term_routine_ -lroot -lnet /boot/develop/lib/ppc/glue-noinit.a /boot/develop/lib/ppc/init_term_dyn.o /boot/develop/lib/ppc/start_dyn.o'
-        _OPTIMIZE_FLAGS=-O2
-        _DEBUG_FLAGS='-g -O0'
-        ;;
-    esac
-    ;;
-
 *-bsdi*)
     $as_echo "#define XP_UNIX 1" >>confdefs.h
 
     $as_echo "#define BSDI 1" >>confdefs.h
 
     $as_echo "#define NEED_BSDREGEX 1" >>confdefs.h
 
 
@@ -6662,38 +6554,16 @@ tools are selected during the Xcode/Deve
                 else
                                                             LDFLAGS="$LDFLAGS -Wl,-syslibroot,${MACOS_SDK_DIR}"
                 fi
             fi
         fi
     fi
     ;;
 
-*-dgux*)
-    $as_echo "#define XP_UNIX 1" >>confdefs.h
-
-    $as_echo "#define _PR_LOCAL_THREADS_ONLY 1" >>confdefs.h
-
-    $as_echo "#define SVR4 1" >>confdefs.h
-
-    $as_echo "#define SYSV 1" >>confdefs.h
-
-    $as_echo "#define DGUX 1" >>confdefs.h
-
-    $as_echo "#define _DGUX_SOURCE 1" >>confdefs.h
-
-    $as_echo "#define _POSIX4A_DRAFT6_SOURCE 1" >>confdefs.h
-
-    DSO_LDOPTS=-G
-    _OPTIMIZE_FLAGS=-O2
-    _DEBUG_FLAGS=
-    MDCPUCFG_H=_dgux.cfg
-    PR_MD_CSRCS=dgux.c
-    ;;
-
 *-freebsd*)
     if test -z "$USE_NSPR_THREADS"; then
         USE_PTHREADS=1
     fi
     $as_echo "#define XP_UNIX 1" >>confdefs.h
 
     $as_echo "#define FREEBSD 1" >>confdefs.h
 
@@ -6719,17 +6589,17 @@ tools are selected during the Xcode/Deve
 
 *-hpux*)
     $as_echo "#define XP_UNIX 1" >>confdefs.h
 
     $as_echo "#define HPUX 1" >>confdefs.h
 
     $as_echo "#define _HPUX_SOURCE 1" >>confdefs.h
 
-    # OSF1 and HPUX report the POLLHUP event for a socket when the
+    # HPUX report the POLLHUP event for a socket when the
     # shutdown(SHUT_WR) operation is called for the remote end, even though
     # the socket is still writeable. Use select(), instead of poll(), to
     # workaround this problem.
     $as_echo "#define _PR_POLL_WITH_SELECT 1" >>confdefs.h
 
     $as_echo "#define _USE_BIG_FDS 1" >>confdefs.h
 
     DSO_LDOPTS='-b +h $(notdir $@)'
@@ -6885,120 +6755,16 @@ tools are selected during the Xcode/Deve
             USE_PTHREADS=
         fi
         if test "$USE_USER_PTHREADS"; then
             USE_PTHREADS=
         fi
     fi
     ;;
 
-*-irix*)
-    $as_echo "#define XP_UNIX 1" >>confdefs.h
-
-    $as_echo "#define IRIX 1" >>confdefs.h
-
-    $as_echo "#define SVR4 1" >>confdefs.h
-
-    $as_echo "#define _SGI_MP_SOURCE 1" >>confdefs.h
-
-    $as_echo "#define HAVE_FCNTL_FILE_LOCKING 1" >>confdefs.h
-
-    PR_MD_CSRCS=irix.c
-    PR_MD_ASFILES=os_Irix.s
-    MKSHLIB='$(LD) $(DSO_LDOPTS) -rdata_shared -shared -soname $(notdir $@) -o $@'
-    STRIP="$STRIP -f"
-    RESOLVE_LINK_SYMBOLS=1
-    if test -n "$USE_64"; then
-        MDCPUCFG_H=_irix64.cfg
-    else
-        MDCPUCFG_H=_irix32.cfg
-    fi
-    case "${target_os}" in
-    irix6*)
-        $as_echo "#define IRIX6 1" >>confdefs.h
-
-        USE_PTHREADS=1
-        USE_N32=1
-        COMPILER_TAG=_n32
-        IMPL_STRATEGY=_PTH
-        ;;
-    irix5*)
-        $as_echo "#define IRIX5 1" >>confdefs.h
-
-        USE_NSPR_THREADS=1
-        ;;
-    *)
-        USE_PTHREADS=1
-        USE_N32=1
-        ;;
-    esac
-    if test "$GNU_CC"; then
-                                                        	    AS='$(CC) -Wp,-P -x assembler-with-cpp -D_ASM -mips2 $(INCLUDES)'
-	    CFLAGS="$CFLAGS -Wall -Wno-format"
-	    _OPTIMIZE_FLAGS="-O6"
-    else
-	    if test -n "$USE_N32"; then
-		AS='as -D_ASM $(INCLUDES) -n32'
-	    else
-		AS='as -D_ASM $(INCLUDES)'
-	    fi
-	    CFLAGS="$CFLAGS -fullwarn -xansi"
-	    if test "$USE_N32"; then
-	        _OPTIMIZE_FLAGS="-O -OPT:Olimit=4000"
-	    else
-	        _OPTIMIZE_FLAGS="-O -Olimit 4000"
-	    fi
-	    if test "$USE_MDUPDATE"; then
-                CFLAGS="$CFLAGS -MDupdate \$(DEPENDENCIES)"
-	    fi
-	    case "${target}" in
-	    *-irix6.*)
-	        CFLAGS="$CFLAGS -multigot"
-	        DSO_LDOPTS="-no_unresolved"
-	        if test "$USE_N32"; then
-		        CFLAGS="$CFLAGS -n32 -woff 1209"
-		        DSO_LDOPTS="$DSO_LDOPTS -n32"
-	        else
-		        if test "$USE_64"; then
-		            CFLAGS="$CFLAGS -64"
-		        else
-		            CFLAGS="$CFLAGS -32"
-		        fi
-	        fi
-	        ;;
-	    *)
-	        CFLAGS="$CFLAGS -xgot"
-	        ;;
-	    esac
-    fi
-    if test "${target_os}" = "irix5.3"; then
-	    $as_echo "#define IRIX5_3 1" >>confdefs.h
-
-    fi
-    case "${target_os}" in
-	irix6.5)
-	    if test -z "$GNU_CC"; then
-		    CFLAGS="$CFLAGS -mips3"
-	    fi
-	    $as_echo "#define _PR_HAVE_GETPROTO_R 1" >>confdefs.h
-
-	    $as_echo "#define _PR_HAVE_GETPROTO_R_POINTER 1" >>confdefs.h
-
-	    $as_echo "#define _PR_HAVE_SGI_PRDA_PROCMASK 1" >>confdefs.h
-
-	    ;;
-	irix5*)
-	    ;;
-	*)
-	    $as_echo "#define _PR_HAVE_SGI_PRDA_PROCMASK 1" >>confdefs.h
-
-	    ;;
-	esac
-    ;;
-
 *-linux*|*-gnu*|*-k*bsd*-gnu|*-android*|*-linuxandroid*)
     if test -z "$USE_NSPR_THREADS"; then
         USE_PTHREADS=1
         IMPL_STRATEGY=_PTH
     fi
     $as_echo "#define XP_UNIX 1" >>confdefs.h
 
     $as_echo "#define _GNU_SOURCE 1" >>confdefs.h
@@ -7287,16 +7053,21 @@ tools are selected during the Xcode/Deve
             fi
 	fi
         ;;
     x86_64)
 	    $as_echo "#define _AMD64_ 1" >>confdefs.h
 
 	    USE_64=1
 	    ;;
+    aarch64)
+	    $as_echo "#define _ARM64_ 1" >>confdefs.h
+
+	    USE_64=1
+	    ;;
     ia64)
 	    $as_echo "#define _IA64_ 1" >>confdefs.h
 
 	    USE_64=1
 	    ;;
     *)
 	    $as_echo "#define _CPU_ARCH_NOT_DEFINED 1" >>confdefs.h
 
@@ -7382,71 +7153,16 @@ tools are selected during the Xcode/Deve
     OS_LIBS="-lc"
     if test -z "$USE_NSPR_THREADS"; then
         USE_PTHREADS=1
     fi
     DSO_LDOPTS='-shared -fPIC -Wl,-soname,$(notdir $@)'
     MKSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
     ;;
 
-*-osf*)
-    SHELL_OVERRIDE="SHELL		= /usr/bin/ksh"
-    $as_echo "#define XP_UNIX 1" >>confdefs.h
-
-    $as_echo "#define OSF1 1" >>confdefs.h
-
-    $as_echo "#define _REENTRANT 1" >>confdefs.h
-
-    # OSF1 and HPUX report the POLLHUP event for a socket when the
-    # shutdown(SHUT_WR) operation is called for the remote end, even though
-    # the socket is still writeable. Use select(), instead of poll(), to
-    # workaround this problem.
-    $as_echo "#define _PR_POLL_WITH_SELECT 1" >>confdefs.h
-
-
-    if echo "$OS_RELEASE" | egrep -c '(V2.0|V3.2)' 2>/dev/null ; then
-        USE_NSPR_THREADS=1
-    fi
-
-    if test -z "$GNU_CC"; then
-        CC="$CC -std1 -ieee_with_inexact"
-        if test "$OS_RELEASE" != "V2.0"; then
-            CC="$CC -readonly_strings"
-        fi
-        _OPTIMIZE_FLAGS="$_OPTIMIZE_FLAGS -Olimit 4000"
-        ac_fn_c_check_header_mongrel "$LINENO" "machine/builtins.h" "ac_cv_header_machine_builtins_h" "$ac_includes_default"
-if test "x$ac_cv_header_machine_builtins_h" = xyes; then :
-  $as_echo "#define OSF1_HAVE_MACHINE_BUILTINS_H 1" >>confdefs.h
-
-fi
-
-
-    else
-        CFLAGS="$CFLAGS -mieee"
-        CXXFLAGS="$CXXFLAGS -mieee"
-    fi
-
-    if echo $OS_RELEASE | egrep -c '(V2.0|V3.2)' 2>/dev/null; then
-        $as_echo "#define HAVE_INT_LOCALTIME_R 1" >>confdefs.h
-
-    else
-        $as_echo "#define HAVE_FCNTL_FILE_LOCKING 1" >>confdefs.h
-
-        $as_echo "#define HAVE_POINTER_LOCALTIME_R 1" >>confdefs.h
-
-    fi
-    if echo $OS_RELEASE | grep -c V4.0 >/dev/null; then
-        $as_echo "#define OSF1V4_MAP_PRIVATE_BUG 1" >>confdefs.h
-
-    fi
-    DSO_LDOPTS='-shared -all -expect_unresolved "*" -soname $(notdir $@)'
-    MDCPUCFG_H=_osf1.cfg
-    PR_MD_CSRCS=osf1.c
-    ;;
-
 *-qnx*)
     $as_echo "#define XP_UNIX 1" >>confdefs.h
 
     $as_echo "#define QNX 1" >>confdefs.h
 
     $as_echo "#define _PR_NEED_H_ERRNO 1" >>confdefs.h
 
     USE_NSPR_THREADS=1
@@ -7678,104 +7394,16 @@ fi
 
         MDCPUCFG_H=_unixware7.cfg
     fi
     PR_MD_CSRCS=unixware.c
     DSO_LDOPTS=-G
     CPU_ARCH=x86
     ;;
 
-*-symbian*)
-
-# Check whether --with-symbian-sdk was given.
-if test "${with_symbian_sdk+set}" = set; then :
-  withval=$with_symbian_sdk; SYMBIAN_SDK_DIR=$withval
-fi
-
-
-    echo -----------------------------------------------------------------------------
-    echo Building with Symbian SDK in: $SYMBIAN_SDK_DIR
-    echo -----------------------------------------------------------------------------
-
-    $as_echo "#define XP_UNIX 1" >>confdefs.h
-
-    $as_echo "#define SYMBIAN 1" >>confdefs.h
-
-    $as_echo "#define __arm__ 1" >>confdefs.h
-
-    $as_echo "#define __SYMBIAN32__ 1" >>confdefs.h
-
-    $as_echo "#define _UNICODE 1" >>confdefs.h
-
-    $as_echo "#define NDEBUG 1" >>confdefs.h
-
-    $as_echo "#define __SUPPORT_CPP_EXCEPTIONS__ 1" >>confdefs.h
-
-    $as_echo "#define MOZ_STDERR_TO_STDOUT 1" >>confdefs.h
-
-    $as_echo "#define HAVE_FCNTL_FILE_LOCKING 1" >>confdefs.h
-
-    $as_echo "#define HAVE_SOCKLEN_T 1" >>confdefs.h
-
-    USE_PTHREADS=1
-    LIB_SUFFIX=lib
-    DLL_SUFFIX=dll
-    MKSHLIB=
-    DSO_LDOPTS=
-    DSO_CFLAGS=
-    VISIBILITY_FLAGS=
-    MDCPUCFG_H=_symbian.cfg
-    PR_MD_CSRCS=symbian.c
-    NSINSTALL=nsinstall
-    RANLIB='echo no ranlib '
-    CPU_ARCH=ARM
-    OS_ARCH=SYMBIAN
-    OS_EXE_CFLAGS="$OS_EXE_CFLAGS -D__EXE__"
-    CFLAGS="$CFLAGS -MD -nostdinc"
-    SYMBIAN_SYS_INCLUDE="-I$SYMBIAN_SDK_DIR/Epoc32/include/variant -I$SYMBIAN_SDK_DIR/Epoc32/include -I$SYMBIAN_SDK_DIR/Epoc32/include/stdapis"
-    echo -------------------------------------------------------
-    echo SYMBIAN_SYS_INCLUDE is: $SYMBIAN_SYS_INCLUDE
-    echo -------------------------------------------------------
-    case "$OS_TARGET" in
-    WINSCW)
-        CC=mwccsym2.exe
-        CXX=mwccsym2.exe
-        LD=mwldsym2.exe
-        AR=mwldsym2.exe
-        WINSCW_LD_DIR="\$(SYMBIAN_SDK_DIR)/EPOC32/RELEASE/WINSCW/UDEB"
-        CFLAGS="$CFLAGS -O0 -inline off -wchar_t off -align 4 -warnings on -w nohidevirtual,nounusedexpr -msgstyle gcc -enum int -str pool -exc ms -trigraphs on -nostderr -gccdep -cwd source -i- -I\$(VPATH)"
-        SYMBIAN_SYS_INCLUDE="$SYMBIAN_SYS_INCLUDE -include Symbian_OS_v9.2.hrh"
-        AR_FLAGS="-library -msgstyle gcc -stdlib -subsystem windows -noimplib -o \$@"
-        $as_echo "#define _DEBUG 1" >>confdefs.h
-
-        $as_echo "#define __CW32__ 1" >>confdefs.h
-
-        $as_echo "#define __WINS__ 1" >>confdefs.h
-
-        $as_echo "#define __WINSCW__ 1" >>confdefs.h
-
-        DEFINES="$DEFINES -U_WIN32"
-	    ;;
-    GCCE)
-        CFLAGS="$CFLAGS -Wall -Wno-unknown-pragmas -fexceptions -march=armv5t -mapcs -pipe -x c -msoft-float"
-        CXXFLAGS="$CXXFLAGS $CFLAGS -Wno-ctor-dtor-privacy"
-        SYMBIAN_SYS_INCLUDE="$SYMBIAN_SYS_INCLUDE -include $SYMBIAN_SDK_DIR/EPOC32/INCLUDE/GCCE/GCCE.h"
-        $as_echo "#define __GCCE__ 1" >>confdefs.h
-
-        $as_echo "#define __EABI__ 1" >>confdefs.h
-
-        DEFINES="$DEFINES -D__PRODUCT_INCLUDE__=$SYMBIAN_SDK_DIR/Epoc32/include/variant/Symbian_OS_v9.2.hrh"
-	    ;;
-    *)
-	    as_fn_error $? "Missing OS_TARGET for ${target}. Set --enable-symbian-target to with 'WINSCW' or 'GCCE'." "$LINENO" 5
-   	;;
-    esac
-    CFLAGS="$CFLAGS ${SYMBIAN_SYS_INCLUDE}"
-    ;;
-
 *-os2*)
     $as_echo "#define XP_OS2 1" >>confdefs.h
 
     $as_echo "#define XP_PC 1" >>confdefs.h
 
     $as_echo "#define BSD_SELECT 1" >>confdefs.h
 
     $as_echo "#define TCPV40HDRS 1" >>confdefs.h
@@ -7823,17 +7451,17 @@ fi
 
 esac
 
 if test -z "$SKIP_LIBRARY_CHECKS"; then
 
 
 
 case $target in
-*-darwin*|*-beos*|*-os2*)
+*-darwin*|*-os2*)
     ;;
 *)
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
 $as_echo_n "checking for dlopen in -ldl... " >&6; }
 if ${ac_cv_lib_dl_dlopen+:} false; then :
   $as_echo_n "(cached) " >&6
 else
   ac_check_lib_save_LIBS=$LIBS
@@ -8276,31 +7904,16 @@ if test "${enable_nspr_threads+set}" = s
   enableval=$enable_nspr_threads;  if test "$enableval" = "yes"; then
 	    USE_PTHREADS=
 	    USE_USER_PTHREADS=
 	    USE_NSPR_THREADS=1
 	  fi
 fi
 
 
-case "$target" in
-*-beos*)
-
-# Check whether --with-bthreads was given.
-if test "${with_bthreads+set}" = set; then :
-  withval=$with_bthreads; 	if test "$withval" = "yes"; then
-    	    USE_BTHREADS=1
-	        USE_USER_PTHREADS=
-	        USE_PTHREADS=
-	    fi
-fi
-
-    ;;
-esac
-
 fi # SKIP_LIBRARY_CHECKS
 
 # Check whether --enable-ipv6 was given.
 if test "${enable_ipv6+set}" = set; then :
   enableval=$enable_ipv6;  if test "$enableval" = "yes"; then
 	    USE_IPV6=1
       else
 	    USE_IPV6=
@@ -8468,57 +8081,33 @@ case "$target" in
     fi
     if test "$USE_USER_PTHREADS"; then
         cat >>confdefs.h <<_ACEOF
 #define _POSIX_C_SOURCE 199506L
 _ACEOF
 
     fi
     ;;
-*-irix*)
-    if test "${target_os}" = "irix6.5"; then
-        if test -n "$USE_PTHREADS"; then
-            $as_echo "#define _PR_HAVE_GETHOST_R 1" >>confdefs.h
-
-            $as_echo "#define _PR_HAVE_GETHOST_R_POINTER 1" >>confdefs.h
-
-        fi
-    fi
-    ;;
 *-linux*|*-gnu*|*-k*bsd*-gnu)
     if test -n "$USE_NSPR_THREADS"; then
         $as_echo "#define _PR_LOCAL_THREADS_ONLY 1" >>confdefs.h
 
     fi
     ;;
-*-mingw*|*-msys*|*-cygwin*|*-mks*|*-os2*|*-beos*)
+*-mingw*|*-msys*|*-cygwin*|*-mks*|*-os2*)
         USE_PTHREADS=
     _PTHREAD_LDFLAGS=
     USE_USER_PTHREADS=
     ;;
 *-netbsd*|*-openbsd*)
     if test -n "$USE_NSPR_THREADS"; then
         $as_echo "#define _PR_LOCAL_THREADS_ONLY 1" >>confdefs.h
 
     fi
     ;;
-*-osf*)
-    if test -n "$USE_NSPR_THREADS"; then
-        $as_echo "#define _PR_LOCAL_THREADS_ONLY 1" >>confdefs.h
-
-    fi
-    if test -n "$USE_PTHREADS"; then
-        if echo $OS_RELEASE | egrep -c '(V2.0|V3.2)' 2>/dev/null; then
-            :
-        else
-            $as_echo "#define _PR_HAVE_THREADSAFE_GETHOST 1" >>confdefs.h
-
-        fi
-    fi
-    ;;
 *-solaris*)
     if test -n "$USE_NSPR_THREADS"; then
         $as_echo "#define _PR_LOCAL_THREADS_ONLY 1" >>confdefs.h
 
     fi
     if test -n "$USE_PTHREADS"; then
         $as_echo "#define _REENTRANT 1" >>confdefs.h
 
@@ -8712,17 +8301,16 @@ fi
 
 
 
 
 
 
 
 
-
 MAKEFILES="
     Makefile
     config/Makefile
     config/autoconf.mk
     config/nsprincl.mk
     config/nsprincl.sh
     config/nspr-config
     config/nspr.pc

--- a/nsprpub/configure.in
+++ b/nsprpub/configure.in
@@ -10,17 +10,17 @@ AC_CONFIG_SRCDIR([pr/include/nspr.h])
 
 AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
 AC_CANONICAL_TARGET
 
 dnl ========================================================
 dnl = Defaults
 dnl ========================================================
 MOD_MAJOR_VERSION=4
-MOD_MINOR_VERSION=21
+MOD_MINOR_VERSION=22
 MOD_PATCH_VERSION=0
 NSPR_MODNAME=nspr20
 _HAVE_PTHREADS=
 USE_PTHREADS=
 USE_USER_PTHREADS=
 USE_NSPR_THREADS=
 USE_N32=
 USE_X32=
@@ -128,16 +128,22 @@ AC_ARG_WITH(android-version,
     android_version=$withval)
 
 AC_ARG_WITH(android-platform,
 [  --with-android-platform=DIR
                           location of platform dir],
     android_platform=$withval)
 
 case "$target" in
+x86_64-linux*-android*)
+    android_tool_prefix="x86_64-linux-android"
+    ;;
+aarch64-linux*-android*)
+    android_tool_prefix="aarch64-linux-android"
+    ;;
 arm-linux*-android*|*-linuxandroid*)
     android_tool_prefix="arm-linux-androideabi"
     ;;
 i?86-*android*)
     android_tool_prefix="i686-linux-android"
     ;;
 mipsel-*android*)
     android_tool_prefix="mipsel-linux-android"
@@ -328,44 +334,31 @@ AC_ARG_ENABLE(debug-symbols,
           MOZ_DEBUG_SYMBOLS=
       fi ])
 
 AC_ARG_ENABLE(win32-target,
     [  --enable-win32-target=\$t
                           Specify win32 flavor. (WIN95 or WINNT)],
     OS_TARGET=`echo $enableval | tr a-z A-Z`)
 
-AC_ARG_ENABLE(symbian-target,
-    [  --enable-symbian-target=\$t
-                          Specify symbian flavor. (WINSCW or GCCE)],
-    OS_TARGET=`echo $enableval | tr a-z A-Z`)
 
 AC_ARG_ENABLE(debug-rtl,
     [  --enable-debug-rtl      Use the MSVC debug runtime library],
     [ if test "$enableval" = "yes"; then
 	    USE_DEBUG_RTL=1
       else
 	    USE_DEBUG_RTL=0
       fi ])
 
 AC_ARG_ENABLE(static-rtl,
     [  --enable-static-rtl     Use the MSVC static runtime library],
     [ if test "$enableval" = "yes"; then
 	    USE_STATIC_RTL=1
       fi ])
 
-AC_ARG_ENABLE(n32,
-    [  --enable-n32            Enable n32 ABI support (IRIX only)],
-    [ if test "$enableval" = "yes"; then
-	USE_N32=1
-      else if test "$enableval" = "no"; then
-	USE_N32=
-      fi
-    fi ])
-
 AC_ARG_ENABLE(x32,
     [  --enable-x32            Enable x32 ABI support (x86_64 only)],
     [ if test "$enableval" = "yes"; then
         USE_X32=1
       else if test "$enableval" = "no"; then
         USE_X32=
       fi
     fi ])
@@ -443,24 +436,16 @@ if test -z "$CC"; then
             CC=xlc
         fi
     ;;
 
     *-hpux*)
         CC=cc
     ;;
 
-    *-irix*)
-        CC=cc
-    ;;
-
-    *-osf*)
-        CC=cc
-    ;;
-
     *-solaris*)
         CC=cc
     ;;
 
     esac
 fi
 
 dnl ========================================================
@@ -488,43 +473,32 @@ if test -z "$CXX"; then
             CXX=aCC
             ;;
         *)
             CXX=CC
             ;;
         esac
     ;;
 
-    *-irix*)
-        CXX=CC
-    ;;
-
-    *-osf*)
-        CXX=cxx
-    ;;
-
     *-solaris*)
         CXX=CC
     ;;
 
     esac
 fi
 
 if test -z "$SKIP_PATH_CHECKS"; then
     AC_PATH_PROG(WHOAMI, $WHOAMI whoami, echo not_whoami)
 fi
 
 if test -n "$MOZ_DEBUG"; then
     AC_DEFINE(DEBUG)
     DEFINES="$DEFINES -UNDEBUG"
 
     case "${target_os}" in
-    beos*)
-        DEFINES="$DEFINES -DDEBUG_${USER}"
-        ;;
     mks*|cygwin*|mingw*|msys*|os2*)
         DEFINES="$DEFINES -DDEBUG_`echo ${USERNAME} | sed -e 's| |_|g'`"
         ;;
     *)
         DEFINES="$DEFINES -DDEBUG_`$WHOAMI`"
         ;;
     esac
 else
@@ -851,20 +825,16 @@ if test -n "$CROSS_COMPILE"; then
         riscos*)      OS_ARCH=RISCOS ;;
     esac
 else
     OS_ARCH=`uname -s | sed -e 's|/|_|g'`
     OS_RELEASE=`uname -r`
     OS_TEST=`uname -m`
 fi
 
-if test "$OS_ARCH" = "IRIX64"; then
-    OS_ARCH=IRIX
-fi
-
 if test "$OS_ARCH" = "AIX"; then
     OS_RELEASE=`uname -v`.`uname -r`
 fi
 
 if test "$OS_ARCH" = "FreeBSD"; then
     OS_RELEASE=`echo $OS_RELEASE | sed 's/-.*//'`
 fi
 
@@ -1188,19 +1158,16 @@ case "$host" in
     NSINSTALL=nsinstall
     ;;
 *-cygwin*|*-mks*)
     NSINSTALL='$(CYGWIN_WRAPPER) nsinstall'
     if test `echo "${PATH}" | grep -c \;` = 0; then
         CYGWIN_WRAPPER='sh $(topsrcdir)/build/cygwin-wrapper'
     fi
     ;;
-*-beos*)
-    HOST_CFLAGS="$HOST_CFLAGS -DXP_BEOS -DBeOS -DBEOS -D_POSIX_SOURCE"
-    ;;
 *os2*)
     ;;
 *)
     HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX"
     ;;
 esac
 
 dnl ========================================================
@@ -1263,44 +1230,16 @@ case "$target" in
         OBJECT_MODE=64
     else
         MDCPUCFG_H=_aix32.cfg
     fi
     PR_MD_CSRCS=aix.c
     RESOLVE_LINK_SYMBOLS=1
     ;;
         
-*-beos*)
-    AC_DEFINE(XP_BEOS)
-    AC_DEFINE(BeOS)
-    AC_DEFINE(BEOS)
-    AC_DEFINE(_POSIX_SOURCE)
-    DSO_LDOPTS=-nostart
-    MDCPUCFG_H=_beos.cfg
-    USE_BTHREADS=1
-    PR_MD_ARCH_DIR=beos
-    RESOLVE_LINK_SYMBOLS=1
-    case "${target_cpu}" in
-    i*86)
-        _OPTIMIZE_FLAGS=-O2
-        _DEBUG_FLAGS='-gdwarf-2 -O0'
-        MKSHLIB='$(CCC) $(DSO_LDOPTS) -o $@'
-        AC_CHECK_LIB(bind, gethostbyaddr, [OS_LIBS="$OS_LIBS -lbind -lsocket"])
-        ;;
-    powerpc)
-        CC=mwcc
-        CCC=mwcc
-        LD=mwld
-        DSO_LDOPTS='-xms -export pragma -init _init_routine_ -term _term_routine_ -lroot -lnet /boot/develop/lib/ppc/glue-noinit.a /boot/develop/lib/ppc/init_term_dyn.o /boot/develop/lib/ppc/start_dyn.o'
-        _OPTIMIZE_FLAGS=-O2    
-        _DEBUG_FLAGS='-g -O0'
-        ;;
-    esac
-    ;;
-
 *-bsdi*)
     AC_DEFINE(XP_UNIX)
     AC_DEFINE(BSDI)
     AC_DEFINE(NEED_BSDREGEX)
 
     CFLAGS="$CFLAGS -Wall -Wno-format"
     CXXFLAGS="$CXXFLAGS -Wall -Wno-format"
 
@@ -1516,31 +1455,16 @@ tools are selected during the Xcode/Deve
                     dnl to be explicit.
                     LDFLAGS="$LDFLAGS -Wl,-syslibroot,${MACOS_SDK_DIR}"
                 fi
             fi
         fi
     fi
     ;;
 
-*-dgux*)
-    AC_DEFINE(XP_UNIX)
-    AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
-    AC_DEFINE(SVR4)
-    AC_DEFINE(SYSV)
-    AC_DEFINE(DGUX)
-    AC_DEFINE(_DGUX_SOURCE)
-    AC_DEFINE(_POSIX4A_DRAFT6_SOURCE)
-    DSO_LDOPTS=-G
-    _OPTIMIZE_FLAGS=-O2
-    _DEBUG_FLAGS=
-    MDCPUCFG_H=_dgux.cfg
-    PR_MD_CSRCS=dgux.c
-    ;;
-
 *-freebsd*)
     if test -z "$USE_NSPR_THREADS"; then
         USE_PTHREADS=1
     fi
     AC_DEFINE(XP_UNIX)
     AC_DEFINE(FREEBSD)
     AC_DEFINE(HAVE_BSD_FLOCK)
     AC_DEFINE(HAVE_SOCKLEN_T)
@@ -1558,17 +1482,17 @@ tools are selected during the Xcode/Deve
     MDCPUCFG_H=_freebsd.cfg
     PR_MD_CSRCS=freebsd.c
     ;;
 
 *-hpux*)
     AC_DEFINE(XP_UNIX)
     AC_DEFINE(HPUX)
     AC_DEFINE(_HPUX_SOURCE)
-    # OSF1 and HPUX report the POLLHUP event for a socket when the
+    # HPUX report the POLLHUP event for a socket when the
     # shutdown(SHUT_WR) operation is called for the remote end, even though
     # the socket is still writeable. Use select(), instead of poll(), to
     # workaround this problem.
     AC_DEFINE(_PR_POLL_WITH_SELECT)
     AC_DEFINE(_USE_BIG_FDS)
     DSO_LDOPTS='-b +h $(notdir $@)'
     PR_MD_CSRCS=hpux.c
     if test "$OS_TEST" = "ia64"; then
@@ -1703,115 +1627,16 @@ tools are selected during the Xcode/Deve
             USE_PTHREADS=
         fi
         if test "$USE_USER_PTHREADS"; then
             USE_PTHREADS=
         fi
     fi
     ;;
 
-*-irix*)
-    AC_DEFINE(XP_UNIX)
-    AC_DEFINE(IRIX)
-    AC_DEFINE(SVR4)
-    AC_DEFINE(_SGI_MP_SOURCE)
-    AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
-    PR_MD_CSRCS=irix.c
-    PR_MD_ASFILES=os_Irix.s
-    MKSHLIB='$(LD) $(DSO_LDOPTS) -rdata_shared -shared -soname $(notdir $@) -o $@'
-    STRIP="$STRIP -f"
-    RESOLVE_LINK_SYMBOLS=1
-    if test -n "$USE_64"; then
-        MDCPUCFG_H=_irix64.cfg
-    else
-        MDCPUCFG_H=_irix32.cfg
-    fi
-    case "${target_os}" in
-    irix6*)
-        AC_DEFINE(IRIX6)
-        USE_PTHREADS=1
-        USE_N32=1
-        COMPILER_TAG=_n32
-        IMPL_STRATEGY=_PTH
-        ;;
-    irix5*)
-        AC_DEFINE(IRIX5)
-        USE_NSPR_THREADS=1
-        ;;
-    *)
-        USE_PTHREADS=1
-        USE_N32=1
-        ;;
-    esac
-    if test "$GNU_CC"; then
-        dnl
-        dnl If we are using gcc with native binutils, we need to
-        dnl suppress the
-        dnl #lineno "filename" num num
-        dnl lines, which confuse IRIX native as.  Add -Wp,-P to the
-        dnl gcc command line, which passes -P to the preprocessor.
-        dnl
-	    AS='$(CC) -Wp,-P -x assembler-with-cpp -D_ASM -mips2 $(INCLUDES)'
-	    CFLAGS="$CFLAGS -Wall -Wno-format"
-	    _OPTIMIZE_FLAGS="-O6"
-    else
-	    if test -n "$USE_N32"; then
-		AS='as -D_ASM $(INCLUDES) -n32'
-	    else
-		AS='as -D_ASM $(INCLUDES)'
-	    fi
-	    CFLAGS="$CFLAGS -fullwarn -xansi"
-	    if test "$USE_N32"; then
-	        _OPTIMIZE_FLAGS="-O -OPT:Olimit=4000"
-	    else
-	        _OPTIMIZE_FLAGS="-O -Olimit 4000"
-	    fi
-	    if test "$USE_MDUPDATE"; then
-                CFLAGS="$CFLAGS -MDupdate \$(DEPENDENCIES)"
-	    fi
-	    case "${target}" in
-	    *-irix6.*)
-	        CFLAGS="$CFLAGS -multigot"
-	        DSO_LDOPTS="-no_unresolved"
-	        if test "$USE_N32"; then
-		        CFLAGS="$CFLAGS -n32 -woff 1209"
-		        DSO_LDOPTS="$DSO_LDOPTS -n32"
-	        else
-		        if test "$USE_64"; then
-		            CFLAGS="$CFLAGS -64"
-		        else
-		            CFLAGS="$CFLAGS -32"
-		        fi
-	        fi
-	        ;;
-	    *)
-	        CFLAGS="$CFLAGS -xgot"
-	        ;;
-	    esac
-    fi
-    if test "${target_os}" = "irix5.3"; then
-	    AC_DEFINE(IRIX5_3)
-    fi
-    case "${target_os}" in
-	irix6.5)
-	    if test -z "$GNU_CC"; then
-		    CFLAGS="$CFLAGS -mips3"
-	    fi
-	    AC_DEFINE(_PR_HAVE_GETPROTO_R)
-	    AC_DEFINE(_PR_HAVE_GETPROTO_R_POINTER)
-	    AC_DEFINE(_PR_HAVE_SGI_PRDA_PROCMASK)
-	    ;;
-	irix5*)
-	    ;;
-	*)
-	    AC_DEFINE(_PR_HAVE_SGI_PRDA_PROCMASK)
-	    ;;
-	esac
-    ;;
-
 *-linux*|*-gnu*|*-k*bsd*-gnu|*-android*|*-linuxandroid*)
     if test -z "$USE_NSPR_THREADS"; then
         USE_PTHREADS=1
         IMPL_STRATEGY=_PTH
     fi
     AC_DEFINE(XP_UNIX)
     AC_DEFINE(_GNU_SOURCE)
     AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
@@ -2168,57 +1993,16 @@ tools are selected during the Xcode/Deve
     OS_LIBS="-lc"
     if test -z "$USE_NSPR_THREADS"; then
         USE_PTHREADS=1
     fi
     DSO_LDOPTS='-shared -fPIC -Wl,-soname,$(notdir $@)'
     MKSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
     ;;
 
-*-osf*)
-    SHELL_OVERRIDE="SHELL		= /usr/bin/ksh"
-    AC_DEFINE(XP_UNIX)
-    AC_DEFINE(OSF1)
-    AC_DEFINE(_REENTRANT)
-    # OSF1 and HPUX report the POLLHUP event for a socket when the
-    # shutdown(SHUT_WR) operation is called for the remote end, even though
-    # the socket is still writeable. Use select(), instead of poll(), to
-    # workaround this problem.
-    AC_DEFINE(_PR_POLL_WITH_SELECT)
-
-    if echo "$OS_RELEASE" | egrep -c '(V2.0|V3.2)' 2>/dev/null ; then
-        USE_NSPR_THREADS=1
-    fi
-
-    if test -z "$GNU_CC"; then
-        CC="$CC -std1 -ieee_with_inexact"
-        if test "$OS_RELEASE" != "V2.0"; then
-            CC="$CC -readonly_strings"
-        fi
-        _OPTIMIZE_FLAGS="$_OPTIMIZE_FLAGS -Olimit 4000"
-        AC_CHECK_HEADER(machine/builtins.h, AC_DEFINE(OSF1_HAVE_MACHINE_BUILTINS_H))
-    else
-        CFLAGS="$CFLAGS -mieee"
-        CXXFLAGS="$CXXFLAGS -mieee"
-    fi
-
-    if echo $OS_RELEASE | egrep -c '(V2.0|V3.2)' 2>/dev/null; then
-        AC_DEFINE(HAVE_INT_LOCALTIME_R)
-    else
-        AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
-        AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
-    fi
-    if echo $OS_RELEASE | grep -c V4.0 >/dev/null; then
-        AC_DEFINE(OSF1V4_MAP_PRIVATE_BUG)
-    fi
-    DSO_LDOPTS='-shared -all -expect_unresolved "*" -soname $(notdir $@)'
-    MDCPUCFG_H=_osf1.cfg
-    PR_MD_CSRCS=osf1.c
-    ;;
-
 *-qnx*)
     AC_DEFINE(XP_UNIX)
     AC_DEFINE(QNX)
     AC_DEFINE(_PR_NEED_H_ERRNO)
     USE_NSPR_THREADS=1
     MDCPUCFG_H=_qnx.cfg
     PR_MD_CSRCS=qnx.c
     ;;
@@ -2416,86 +2200,16 @@ tools are selected during the Xcode/Deve
         AC_DEFINE(_PR_HAVE_SOCKADDR_LEN)
         MDCPUCFG_H=_unixware7.cfg
     fi
     PR_MD_CSRCS=unixware.c
     DSO_LDOPTS=-G
     CPU_ARCH=x86
     ;;
 
-*-symbian*)
-    AC_ARG_WITH(symbian-sdk,
-    [  --with-symbian-sdk=SYMBIAN_SDK_DIR
-                          The path to the Symbian SDK],
-    SYMBIAN_SDK_DIR=$withval)
-
-    echo -----------------------------------------------------------------------------
-    echo Building with Symbian SDK in: $SYMBIAN_SDK_DIR
-    echo -----------------------------------------------------------------------------
-
-    AC_DEFINE(XP_UNIX)
-    AC_DEFINE(SYMBIAN)
-    AC_DEFINE(__arm__)
-    AC_DEFINE(__SYMBIAN32__)
-    AC_DEFINE(_UNICODE)
-    AC_DEFINE(NDEBUG)
-    AC_DEFINE(__SUPPORT_CPP_EXCEPTIONS__)
-    AC_DEFINE(MOZ_STDERR_TO_STDOUT)
-    AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
-    AC_DEFINE(HAVE_SOCKLEN_T)
-    USE_PTHREADS=1
-    LIB_SUFFIX=lib
-    DLL_SUFFIX=dll
-    MKSHLIB=
-    DSO_LDOPTS=
-    DSO_CFLAGS=
-    VISIBILITY_FLAGS=
-    MDCPUCFG_H=_symbian.cfg
-    PR_MD_CSRCS=symbian.c
-    NSINSTALL=nsinstall
-    RANLIB='echo no ranlib '
-    CPU_ARCH=ARM
-    OS_ARCH=SYMBIAN
-    OS_EXE_CFLAGS="$OS_EXE_CFLAGS -D__EXE__"
-    CFLAGS="$CFLAGS -MD -nostdinc"
-    SYMBIAN_SYS_INCLUDE="-I$SYMBIAN_SDK_DIR/Epoc32/include/variant -I$SYMBIAN_SDK_DIR/Epoc32/include -I$SYMBIAN_SDK_DIR/Epoc32/include/stdapis"
-    echo -------------------------------------------------------
-    echo SYMBIAN_SYS_INCLUDE is: $SYMBIAN_SYS_INCLUDE
-    echo -------------------------------------------------------
-    case "$OS_TARGET" in
-    WINSCW)
-        CC=mwccsym2.exe
-        CXX=mwccsym2.exe
-        LD=mwldsym2.exe
-        AR=mwldsym2.exe
-        WINSCW_LD_DIR="\$(SYMBIAN_SDK_DIR)/EPOC32/RELEASE/WINSCW/UDEB"
-        CFLAGS="$CFLAGS -O0 -inline off -wchar_t off -align 4 -warnings on -w nohidevirtual,nounusedexpr -msgstyle gcc -enum int -str pool -exc ms -trigraphs on -nostderr -gccdep -cwd source -i- -I\$(VPATH)"
-        SYMBIAN_SYS_INCLUDE="$SYMBIAN_SYS_INCLUDE -include Symbian_OS_v9.2.hrh"
-        AR_FLAGS="-library -msgstyle gcc -stdlib -subsystem windows -noimplib -o \$@"
-        AC_DEFINE(_DEBUG)
-        AC_DEFINE(__CW32__)
-        AC_DEFINE(__WINS__)
-        AC_DEFINE(__WINSCW__)
-        DEFINES="$DEFINES -U_WIN32"
-	    ;;
-    GCCE)
-        CFLAGS="$CFLAGS -Wall -Wno-unknown-pragmas -fexceptions -march=armv5t -mapcs -pipe -x c -msoft-float"
-        CXXFLAGS="$CXXFLAGS $CFLAGS -Wno-ctor-dtor-privacy"
-        SYMBIAN_SYS_INCLUDE="$SYMBIAN_SYS_INCLUDE -include $SYMBIAN_SDK_DIR/EPOC32/INCLUDE/GCCE/GCCE.h"
-        AC_DEFINE(__GCCE__)
-        AC_DEFINE(__EABI__)
-        DEFINES="$DEFINES -D__PRODUCT_INCLUDE__=$SYMBIAN_SDK_DIR/Epoc32/include/variant/Symbian_OS_v9.2.hrh"
-	    ;;
-    *)
-	    AC_MSG_ERROR([Missing OS_TARGET for ${target}. Set --enable-symbian-target to with 'WINSCW' or 'GCCE'.])
-   	;;
-    esac
-    CFLAGS="$CFLAGS ${SYMBIAN_SYS_INCLUDE}"
-    ;;
-
 *-os2*)
     AC_DEFINE(XP_OS2)
     AC_DEFINE(XP_PC)
     AC_DEFINE(BSD_SELECT)
     AC_DEFINE(TCPV40HDRS)
     LIB_SUFFIX=lib
     DLL_SUFFIX=dll
     RC=rc.exe
@@ -2543,17 +2257,17 @@ dnl ====================================
 
 
 dnl We don't want anything to link with libdl even if it's present on OS X, 
 dnl since it's not used and not part of the default installation.
 dnl The same goes for BeOS.
 dnl OS/2 has dlfcn in libc.
 
 case $target in
-*-darwin*|*-beos*|*-os2*)
+*-darwin*|*-os2*)
     ;;
 *)
     AC_CHECK_LIB(dl, dlopen,
         [AC_CHECK_HEADER(dlfcn.h,
             OS_LIBS="-ldl $OS_LIBS")])
     ;;
 esac
 
@@ -2709,29 +2423,16 @@ AC_ARG_ENABLE(user-pthreads,
 AC_ARG_ENABLE(nspr-threads,
     [  --enable-nspr-threads   Build using classic nspr threads],
     [ if test "$enableval" = "yes"; then
 	    USE_PTHREADS=
 	    USE_USER_PTHREADS=
 	    USE_NSPR_THREADS=1
 	  fi])
 
-case "$target" in
-*-beos*)
-    AC_ARG_WITH(bthreads,
-    [  --with-bthreads         Use system bthreads library as thread subsystem
-                          (BeOS only)],
-    [	if test "$withval" = "yes"; then
-    	    USE_BTHREADS=1
-	        USE_USER_PTHREADS=
-	        USE_PTHREADS=
-	    fi])
-    ;;
-esac
-
 fi # SKIP_LIBRARY_CHECKS
 
 AC_ARG_ENABLE(ipv6,
     [  --enable-ipv6           Compile ipv6 support],
     [ if test "$enableval" = "yes"; then
 	    USE_IPV6=1
       else
 	    USE_IPV6=
@@ -2879,52 +2580,32 @@ case "$target" in
     if test "$USE_PTHREADS"; then
         AC_DEFINE_UNQUOTED(_POSIX_C_SOURCE,199506L)
         AC_DEFINE(_PR_HAVE_THREADSAFE_GETHOST)
     fi
     if test "$USE_USER_PTHREADS"; then
         AC_DEFINE_UNQUOTED(_POSIX_C_SOURCE,199506L)
     fi
     ;;
-*-irix*)
-    if test "${target_os}" = "irix6.5"; then
-        if test -n "$USE_PTHREADS"; then
-            AC_DEFINE(_PR_HAVE_GETHOST_R)
-            AC_DEFINE(_PR_HAVE_GETHOST_R_POINTER)
-        fi
-    fi
-    ;;
 *-linux*|*-gnu*|*-k*bsd*-gnu)
     if test -n "$USE_NSPR_THREADS"; then
         AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
     fi
     ;;
-*-mingw*|*-msys*|*-cygwin*|*-mks*|*-os2*|*-beos*)
-    dnl win32, os2 & beos cannot use pthreads
+*-mingw*|*-msys*|*-cygwin*|*-mks*|*-os2*)
+    dnl win32, os2 cannot use pthreads
     USE_PTHREADS=
     _PTHREAD_LDFLAGS=
     USE_USER_PTHREADS=
     ;;
 *-netbsd*|*-openbsd*)
     if test -n "$USE_NSPR_THREADS"; then
         AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
     fi
     ;;
-*-osf*)
-    if test -n "$USE_NSPR_THREADS"; then
-        AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
-    fi
-    if test -n "$USE_PTHREADS"; then
-        if echo $OS_RELEASE | egrep -c '(V2.0|V3.2)' 2>/dev/null; then
-            :
-        else
-            AC_DEFINE(_PR_HAVE_THREADSAFE_GETHOST)
-        fi
-    fi
-    ;;
 *-solaris*)
     if test -n "$USE_NSPR_THREADS"; then
         AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
     fi
     if test -n "$USE_PTHREADS"; then
         AC_DEFINE(_REENTRANT)
         AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
         if test "$OS_TEST" = "i86pc"; then
@@ -3119,17 +2800,16 @@ AC_SUBST(RC)
 AC_SUBST(RCFLAGS)
 AC_SUBST(DLLFLAGS)
 AC_SUBST(EXEFLAGS)
 AC_SUBST(OS_DLLFLAGS)
 AC_SUBST(CYGWIN_WRAPPER)
 AC_SUBST(VISIBILITY_FLAGS)
 AC_SUBST(WRAP_SYSTEM_INCLUDES)
 AC_SUBST(MACOS_SDK_DIR)
-AC_SUBST(SYMBIAN_SDK_DIR)
 AC_SUBST(NEXT_ROOT)
 AC_SUBST(MT)
 
 dnl ========================================================
 dnl Generate output files.
 dnl ========================================================
 MAKEFILES="
     Makefile

--- a/nsprpub/lib/ds/Makefile.in
+++ b/nsprpub/lib/ds/Makefile.in
@@ -38,20 +38,16 @@ endif # WINNT
 ifeq ($(OS_ARCH), AIX)
 ifeq ($(CLASSIC_NSPR),1)
 OS_LIBS = -lc
 else
 OS_LIBS = -lc_r
 endif
 endif
 
-ifeq ($(OS_ARCH),IRIX)
-OS_LIBS = -lc
-endif
-
 ifeq ($(OS_ARCH),SunOS)
 OS_LIBS = -lc
 MAPFILE = $(OBJDIR)/pldsmap.sun
 GARBAGE += $(MAPFILE)
 ifdef NS_USE_GCC
 ifdef GCC_USE_GNU_LD
 MKSHLIB += -Wl,--version-script,$(MAPFILE)
 else

--- a/nsprpub/lib/libc/src/Makefile.in
+++ b/nsprpub/lib/libc/src/Makefile.in
@@ -47,20 +47,16 @@ endif # WINNT
 ifeq ($(OS_ARCH), AIX)
 ifeq ($(CLASSIC_NSPR),1)
 OS_LIBS = -lc
 else
 OS_LIBS = -lc_r
 endif
 endif
 
-ifeq ($(OS_ARCH),IRIX)
-OS_LIBS = -lc
-endif
-
 ifeq ($(OS_ARCH),SunOS)
 OS_LIBS = -lc
 MAPFILE = $(OBJDIR)/plcmap.sun
 GARBAGE += $(MAPFILE)
 ifdef NS_USE_GCC
 ifdef GCC_USE_GNU_LD
 MKSHLIB += -Wl,--version-script,$(MAPFILE)
 else

--- a/nsprpub/lib/prstreams/Makefile.in
+++ b/nsprpub/lib/prstreams/Makefile.in
@@ -9,22 +9,16 @@ MOD_DEPTH	= ../..
 topsrcdir	= @top_srcdir@
 srcdir		= @srcdir@
 VPATH		= @srcdir@
 
 include $(MOD_DEPTH)/config/autoconf.mk
 
 include $(topsrcdir)/config/config.mk
 
-ifeq ($(OS_ARCH), IRIX)
-    ifneq ($(OS_RELEASE),5.3)
-        CCC_ONLY_FLAGS += -exceptions
-    endif
-endif
-
 ifeq ($(OS_ARCH), BeOS)
     CFLAGS += -frtti -fexceptions
 endif
 
 INCLUDES = -I$(dist_includedir)
 
 HEADERS = $(wildcard $(srcdir)/*.h)
 

--- a/nsprpub/lib/prstreams/tests/testprstrm/Makefile.in
+++ b/nsprpub/lib/prstreams/tests/testprstrm/Makefile.in
@@ -52,24 +52,16 @@ endif
 ifeq ($(OS_ARCH),OS2)
 LDOPTS += -Zomf -Zlinker /PM:VIO -lstdcpp
 endif
 
 ifneq ($(OS_ARCH), WINNT)
 PWD = $(shell pwd)
 endif
 
-ifeq ($(OS_ARCH), IRIX)
-LDOPTS += -rpath $(PWD)/$(dist_libdir)
-endif
-
-ifeq ($(OS_ARCH), OSF1)
-LDOPTS += -rpath $(PWD)/$(dist_libdir)
-endif
-
 ifeq ($(OS_ARCH), HP-UX)
 LDOPTS += -Wl,+s,+b,$(PWD)/$(dist_libdir)
 endif
 
 # AIX
 ifeq ($(OS_ARCH),AIX)
 LDOPTS += -blibpath:$(PWD)/$(dist_libdir):/usr/lib:/lib
 ifeq ($(OS_ARCH)$(OS_RELEASE),AIX4.1)

--- a/nsprpub/lib/tests/Makefile.in
+++ b/nsprpub/lib/tests/Makefile.in
@@ -59,20 +59,16 @@ endif
 ifeq ($(OS_ARCH),OS2)
 LDOPTS += -Zomf -Zlinker /PM:VIO
 endif
 
 ifneq ($(OS_ARCH), WINNT)
 PWD = $(shell pwd)
 endif
 
-ifeq ($(OS_ARCH), IRIX)
-LDOPTS += -rpath $(PWD)/$(dist_libdir)
-endif
-
 ifeq ($(OS_ARCH), Linux)
     ifeq ($(OS_RELEASE), 1.2)
         EXTRA_LIBS = -ldl
     else
         LDOPTS += -Xlinker -rpath $(PWD)/$(dist_libdir)
         ifeq ($(USE_PTHREADS),1)
             EXTRA_LIBS = -lpthread
         endif
@@ -80,20 +76,16 @@ ifeq ($(OS_ARCH), Linux)
 endif
 
 ifeq (,$(filter-out OpenBSD,$(OS_ARCH)))
     ifeq ($(USE_PTHREADS),1)
         EXTRA_LIBS = -lpthread
     endif
 endif
 
-ifeq ($(OS_ARCH), OSF1)
-LDOPTS += -rpath $(PWD)/$(dist_libdir) -lpthread
-endif
-
 ifeq ($(OS_ARCH), HP-UX)
 LDOPTS += -Wl,+s,+b,$(PWD)/$(dist_libdir)
 endif
 
 # AIX
 ifeq ($(OS_ARCH),AIX)
 LDOPTS += -blibpath:$(PWD)/$(dist_libdir):/usr/lib:/lib
 LIBPR = -lnspr$(MOD_MAJOR_VERSION)_shr

--- a/nsprpub/pr/include/gencfg.c
+++ b/nsprpub/pr/include/gencfg.c
@@ -1,36 +1,30 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <stdio.h>
 
-#if defined(sgi)
-#ifndef IRIX
-	error - IRIX is not defined
-#endif
-#endif
-
 #if defined(__sun)
 #ifndef SOLARIS
 	error - SOLARIS is not defined
 #endif
 #endif
 
 #if defined(__hpux)
 #ifndef HPUX
 	error - HPUX is not defined
 #endif
 #endif
 
 #if defined(__alpha) 
-#if !(defined(_WIN32)) && !(defined(OSF1)) && !(defined(__linux)) && !(defined(__FreeBSD__))
-	error - None of OSF1, _WIN32, __linux, or __FreeBSD__ is defined
+#if !(defined(_WIN32)) && !(defined(__linux)) && !(defined(__FreeBSD__))
+	error - None of _WIN32, __linux, or __FreeBSD__ is defined
 #endif
 #endif
 
 #if defined(_IBMR2)
 #ifndef AIX
 	error - AIX is not defined
 #endif
 #endif

deleted file mode 100644
--- a/nsprpub/pr/include/md/_beos.cfg
+++ /dev/null
@@ -1,120 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef nspr_cpucfg___
-#define nspr_cpucfg___
-
-#ifndef XP_BEOS
-#define XP_BEOS
-#undef XP_UNIX
-#endif
-
-#ifndef BEOS
-#define BEOS
-#endif
-
-#define PR_AF_INET6 5  /* same as AF_INET6 */
-
-#ifdef __powerpc__
-#undef  IS_LITTLE_ENDIAN
-#define IS_BIG_ENDIAN 1
-#else
-#define IS_LITTLE_ENDIAN 1
-#undef  IS_BIG_ENDIAN
-#endif
-
-#define PR_BYTES_PER_BYTE   1
-#define PR_BYTES_PER_SHORT  2
-#define PR_BYTES_PER_INT    4
-#define PR_BYTES_PER_INT64  8
-#define PR_BYTES_PER_LONG   4
-#define PR_BYTES_PER_FLOAT  4
-#define PR_BYTES_PER_DOUBLE 8
-#define PR_BYTES_PER_WORD   4
-#define PR_BYTES_PER_DWORD  8
-#define PR_BYTES_PER_WORD_LOG2   2
-#define PR_BYTES_PER_DWORD_LOG2  3
-
-#define PR_BITS_PER_BYTE    8
-#define PR_BITS_PER_SHORT   16
-#define PR_BITS_PER_INT     32
-#define PR_BITS_PER_INT64   64
-#define PR_BITS_PER_LONG    32
-#define PR_BITS_PER_FLOAT   32
-#define PR_BITS_PER_DOUBLE  64
-#define PR_BITS_PER_WORD    32
-
-#define PR_BITS_PER_BYTE_LOG2   3
-#define PR_BITS_PER_SHORT_LOG2  4
-#define PR_BITS_PER_INT_LOG2    5
-#define PR_BITS_PER_INT64_LOG2  6
-#define PR_BITS_PER_LONG_LOG2   5
-#define PR_BITS_PER_FLOAT_LOG2  5
-#define PR_BITS_PER_DOUBLE_LOG2 6
-#define PR_BITS_PER_WORD_LOG2   5
-
-#define PR_ALIGN_OF_SHORT   2
-#define PR_ALIGN_OF_INT     4
-#define PR_ALIGN_OF_LONG    4
-#define PR_ALIGN_OF_INT64   4
-#define PR_ALIGN_OF_FLOAT   4
-#define PR_ALIGN_OF_DOUBLE  4
-#define PR_ALIGN_OF_POINTER 4
-
-#ifndef HAVE_LONG_LONG
-#define	HAVE_LONG_LONG
-#endif
-/*
- * XXX These two macros need to be investigated for different architectures.
- */
-#define	HAVE_ALIGNED_DOUBLES
-#define	HAVE_ALIGNED_LONGLONGS
-
-#ifndef NO_NSPR_10_SUPPORT
-
-#define BYTES_PER_BYTE		PR_BYTES_PER_BYTE
-#define BYTES_PER_SHORT 	PR_BYTES_PER_SHORT
-#define BYTES_PER_INT 		PR_BYTES_PER_INT
-#define BYTES_PER_INT64		PR_BYTES_PER_INT64
-#define BYTES_PER_LONG		PR_BYTES_PER_LONG
-#define BYTES_PER_FLOAT		PR_BYTES_PER_FLOAT
-#define BYTES_PER_DOUBLE	PR_BYTES_PER_DOUBLE
-#define BYTES_PER_WORD		PR_BYTES_PER_WORD
-#define BYTES_PER_DWORD		PR_BYTES_PER_DWORD
-
-#define BITS_PER_BYTE		PR_BITS_PER_BYTE
-#define BITS_PER_SHORT		PR_BITS_PER_SHORT
-#define BITS_PER_INT		PR_BITS_PER_INT
-#define BITS_PER_INT64		PR_BITS_PER_INT64
-#define BITS_PER_LONG		PR_BITS_PER_LONG
-#define BITS_PER_FLOAT		PR_BITS_PER_FLOAT
-#define BITS_PER_DOUBLE		PR_BITS_PER_DOUBLE
-#define BITS_PER_WORD		PR_BITS_PER_WORD
-
-#define BITS_PER_BYTE_LOG2	PR_BITS_PER_BYTE_LOG2
-#define BITS_PER_SHORT_LOG2	PR_BITS_PER_SHORT_LOG2
-#define BITS_PER_INT_LOG2	PR_BITS_PER_INT_LOG2
-#define BITS_PER_INT64_LOG2	PR_BITS_PER_INT64_LOG2
-#define BITS_PER_LONG_LOG2	PR_BITS_PER_LONG_LOG2
-#define BITS_PER_FLOAT_LOG2	PR_BITS_PER_FLOAT_LOG2
-#define BITS_PER_DOUBLE_LOG2 	PR_BITS_PER_DOUBLE_LOG2
-#define BITS_PER_WORD_LOG2	PR_BITS_PER_WORD_LOG2
-
-#define ALIGN_OF_SHORT		PR_ALIGN_OF_SHORT
-#define ALIGN_OF_INT		PR_ALIGN_OF_INT
-#define ALIGN_OF_LONG		PR_ALIGN_OF_LONG
-#define ALIGN_OF_INT64		PR_ALIGN_OF_INT64
-#define ALIGN_OF_FLOAT		PR_ALIGN_OF_FLOAT
-#define ALIGN_OF_DOUBLE		PR_ALIGN_OF_DOUBLE
-#define ALIGN_OF_POINTER	PR_ALIGN_OF_POINTER
-#define ALIGN_OF_WORD		PR_ALIGN_OF_WORD
-
-#define BYTES_PER_WORD_LOG2	PR_BYTES_PER_WORD_LOG2
-#define BYTES_PER_DWORD_LOG2	PR_BYTES_PER_DWORD_LOG2
-#define WORDS_PER_DWORD_LOG2	PR_WORDS_PER_DWORD_LOG2
-
-#endif /* NO_NSPR_10_SUPPORT */
-
-#endif /* nspr_cpucfg___ */

deleted file mode 100644
--- a/nsprpub/pr/include/md/_beos.h
+++ /dev/null
@@ -1,583 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef nspr_beos_defs_h___
-#define nspr_beos_defs_h___
-
-#include "prtypes.h"
-#include "prio.h"
-#include "prthread.h"
-#include "prproces.h"
-#include "prmem.h"
-#include "obsolete/prsem.h"
-#include <errno.h>
-
-#include <support/SupportDefs.h>
-#include <kernel/OS.h>
-#include <dirent.h>
-
-/*
- * Internal configuration macros
- */
-
-#ifdef BONE_VERSION
-#define _PR_HAVE_SOCKADDR_LEN
-#define HAVE_NETINET_TCP_H
-#endif
-
-#define PR_LINKER_ARCH	"beos"
-#define _PR_SI_SYSNAME  "BEOS"
-#ifdef __powerpc__
-#define _PR_SI_ARCHITECTURE "ppc"
-#else
-#define _PR_SI_ARCHITECTURE "x86"
-#endif
-#define PR_DLL_SUFFIX		".so"
-
-#define _PR_VMBASE              0x30000000
-#define _PR_STACK_VMBASE	0x50000000
-#define _MD_DEFAULT_STACK_SIZE	65536L
-#define _MD_MMAP_FLAGS          MAP_PRIVATE
-
-#undef	HAVE_STACK_GROWING_UP
-#define HAVE_DLL
-#define _PR_NO_CLOCK_TIMER
-
-/*
- * The Atomic operations
- */
-
-#define _PR_HAVE_ATOMIC_OPS
-#define _MD_INIT_ATOMIC _MD_AtomicInit
-#define _MD_ATOMIC_INCREMENT _MD_AtomicIncrement
-#define _MD_ATOMIC_ADD _MD_AtomicAdd
-#define _MD_ATOMIC_DECREMENT _MD_AtomicDecrement
-#define _MD_ATOMIC_SET _MD_AtomicSet
-
-#define HAVE_CVAR_BUILT_ON_SEM
-#define _PR_GLOBAL_THREADS_ONLY
-#define _PR_BTHREADS
-#define _PR_NEED_FAKE_POLL
-#define _PR_HAVE_PEEK_BUFFER
-#define _PR_PEEK_BUFFER_MAX (16 * 1024)
-#define _PR_FD_NEED_EMULATE_MSG_PEEK(fd) 1
-#define _PR_CONNECT_DOES_NOT_BIND
-#define _PR_HAVE_O_APPEND
-
-/* Define threading functions and objects as native BeOS */
-struct _MDThread {
-    thread_id	tid;	/* BeOS thread handle */
-	sem_id		joinSem;	/* sems used to synchronzie joining */
-	PRBool	is_joining;	/* TRUE if someone is currently waiting to
-						   join this thread */
-};
-
-struct _MDThreadStack {
-    PRInt8	notused;
-};
-
-/*
- * Lock and Semaphore related definitions
- */
-
-struct _MDLock {
-    sem_id semaphoreID;
-    int32  benaphoreCount;
-};
-
-struct _MDCVar {
-    sem_id sem1;
-    sem_id sem2;
-    int16  count;
-};
-
-struct _MDSemaphore {
-    sem_id sid;
-};
-
-/*
-** CPU-related definitions
-*/
-struct _MDCPU {
-    int8		unused;
-};
-
-/*
-** Process-related definitions
-*/
-struct _MDProcess {
-    pid_t pid;
-};
-
-struct _MDSegment {
-    PRInt8 notused;
-};
-
-/*
-** File- and directory-related definitions
-*/
-
-#ifndef BONE_VERSION
-#define BE_SOCK_SHUTDOWN_READ	0x01
-#define BE_SOCK_SHUTDOWN_WRITE	0x02
-#endif
-
-struct _MDFileDesc {
-    PRInt32	osfd;
-    PRInt32	sock_state;
-    PRBool	accepted_socket;
-    PRNetAddr	peer_addr;
-#ifndef BONE_VERSION
-    PRBool	connectValueValid;
-    int		connectReturnValue;
-    int		connectReturnError;
-#endif
-};
-
-struct _MDDir {
-    DIR		*d;
-};
-
-#define PR_DIRECTORY_SEPARATOR		'/'
-#define PR_DIRECTORY_SEPARATOR_STR	"/"
-#define PR_PATH_SEPARATOR		':'
-#define PR_PATH_SEPARATOR_STR		":"
-
-#define GETTIMEOFDAY(tp)	gettimeofday((tp), NULL)
-
-/* --- Memory-mapped files stuff --- not implemented on BeOS */
-
-struct _MDFileMap {
-    PRInt8 unused;
-};
-
-/*
- * Network related definitions.
- */
-
-#ifndef BONE_VERSION
-#define IPPROTO_IP 0
-#define AF_UNIX 2
-#define TCP_NODELAY SO_NONBLOCK
-#define SO_LINGER -1
-#define SO_ERROR 4
-#endif
-
-#define _PR_INTERRUPT_CHECK_INTERVAL_SECS 5
-
-#ifndef BONE_VERSION
-/* these aren't actually used. if they are, we're screwed */
-struct  protoent {
-    char    *p_name;        /* official protocol name */
-    char    **p_aliases;    /* alias list */
-    int     p_proto;        /* protocol # */
-};
-
-struct protoent* getprotobyname(const char* name);
-struct protoent* getprotobynumber(int number);
-#endif
-
-/*
- * malloc() related definitions.
- */
-
-#undef _PR_OVERRIDE_MALLOC
-
-/* Miscellaneous */
-
-#define _MD_ERRNO()             (errno)
-
-#define _MD_CLEANUP_BEFORE_EXIT _MD_cleanup_before_exit
-#define _MD_EXIT _MD_exit
-
-#define _MD_GET_ENV getenv
-#define _MD_PUT_ENV putenv
-
-#define _MD_EARLY_INIT _MD_early_init
-#define _MD_FINAL_INIT _MD_final_init
-#define _MD_EARLY_CLEANUP()
-
-/* CPU Stuff */
-
-#define _MD_INIT_CPUS _MD_init_cpus
-#define _MD_WAKEUP_CPUS _MD_wakeup_cpus
-#define _MD_START_INTERRUPTS _MD_start_interrupts
-#define _MD_STOP_INTERRUPTS _MD_stop_interrupts
-#define _MD_DISABLE_CLOCK_INTERRUPTS _MD_disable_clock_interrupts
-#define _MD_BLOCK_CLOCK_INTERRUPTS _MD_block_clock_interrupts
-#define _MD_UNBLOCK_CLOCK_INTERRUPTS _MD_unblock_clock_interrupts
-#define _MD_CLOCK_INTERRUPT _MD_clock_interrupt
-#define _MD_INIT_STACK _MD_init_stack
-#define _MD_CLEAR_STACK _MD_clear_stack
-// #define _MD_GET_INTSOFF _MD_get_intsoff
-// #define _MD_SET_INTSOFF _MD_set_intsoff
-#define _MD_CURRENT_CPU _MD_current_cpu
-#define _MD_SET_CURRENT_CPU _MD_set_current_cpu
-#define _MD_INIT_RUNNING_CPU _MD_init_running_cpu
-#define _MD_PAUSE_CPU _MD_pause_cpu
-
-/* Thread stuff */
-
-#define _MD_CURRENT_THREAD() PR_GetCurrentThread()
-// #define _MD_GET_ATTACHED_THREAD _MD_get_attached_thread
-#define _MD_LAST_THREAD _MD_last_thread
-#define _MD_SET_CURRENT_THREAD _MD_set_current_THREAD
-#define _MD_SET_LAST_THREAD _MD_set_last_thread
-#define _MD_INIT_THREAD _MD_init_thread
-#define _MD_EXIT_THREAD _MD_exit_thread
-#define _MD_INIT_ATTACHED_THREAD _MD_init_attached_thread
-
-#define _MD_SUSPEND_THREAD _MD_suspend_thread
-#define _MD_RESUME_THREAD _MD_resume_thread
-#define _MD_SUSPEND_CPU _MD_suspend_cpu
-#define _MD_RESUME_CPU _MD_resume_cpu
-#define _MD_BEGIN_SUSPEND_ALL _MD_begin_suspend_all
-#define _MD_END_SUSPEND_ALL _MD_end_suspend_all
-#define _MD_BEGIN_RESUME_ALL _MD_begin_resume_all
-#define _MD_END_RESUME_ALL _MD_end_resume_all
-
-#define _MD_GET_SP _MD_get_sp
-
-#define _MD_CLEAN_THREAD _MD_clean_thread
-#define _MD_CREATE_PRIMORDIAL_USER_THREAD _MD_create_primordial_user_thread
-#define _MD_CREATE_USER_THREAD _MD_create_user_thread
-#define _MD_INIT_PRIMORDIAL_THREAD _MD_init_primordial_thread
-#define _MD_CREATE_THREAD _MD_create_thread
-#define _MD_YIELD _MD_yield
-#define _MD_SET_PRIORITY _MD_set_priority
-
-#define _MD_SUSPENDALL _MD_suspendall
-#define _MD_RESUMEALL _MD_resumeall
-
-#define _MD_SWITCH_CONTEXT _MD_switch_context
-#define _MD_RESTORE_CONTEXT _MD_restore_context
-
-#define _MD_WAIT _MD_wait
-#define _MD_WAKEUP_WAITER _MD_wakeup_waiter
-
-#define _MD_SETTHREADAFFINITYMASK _MD_setthreadaffinitymask
-#define _MD_GETTHREADAFFINITYMASK _MD_getthreadaffinitymask
-
-/* Thread Synchronization */
-
-#define _MD_INIT_LOCKS _MD_init_locks
-#define _MD_NEW_LOCK _MD_new_lock
-#define _MD_FREE_LOCK _MD_free_lock
-#define _MD_LOCK _MD_lock
-#define _MD_TEST_AND_LOCK _MD_test_and_lock
-#define _MD_UNLOCK _MD_unlock
-#define _MD_IOQ_LOCK _MD_ioq_lock
-#define _MD_IOQ_UNLOCK _MD_ioq_unlock
-#define _MD_NEW_SEM _MD_new_sem
-#define _MD_DESTROY_SEM _MD_destroy_sem
-#define _MD_TIMED_WAIT_SEM _MD_timed_wait_sem
-#define _MD_WAIT_SEM _MD_wait_sem
-#define _MD_POST_SEM _MD_post_sem
-// #define _MD_NEW_CV _MD_new_cv
-// #define _MD_FREE_CV _MD_free_cv
-// #define _MD_WAIT_CV _MD_wait_cv
-// #define _MD_NOTIFY_CV _MD_notify_cv
-// #define _MD_NOTIFYALL_CV _MD_notifyall_cv
-
-/* File I/O */
-
-/* don't need any I/O initializations */
-#define _MD_INIT_IO()
-#define _MD_INIT_FILEDESC(fd)
-
-#define _MD_OPEN_DIR _MD_open_dir
-#define _MD_READ_DIR _MD_read_dir
-#define _MD_CLOSE_DIR _MD_close_dir
-#define _MD_MAKE_NONBLOCK _MD_make_nonblock
-#define _MD_SET_FD_INHERITABLE _MD_set_fd_inheritable
-#define _MD_INIT_FD_INHERITABLE _MD_init_fd_inheritable
-#define _MD_QUERY_FD_INHERITABLE _MD_query_fd_inheritable
-#define _MD_OPEN _MD_open
-#define _MD_OPEN_FILE _MD_open
-#define _MD_CLOSE_FILE _MD_close_file
-#define _MD_READ _MD_read
-#define _MD_WRITE _MD_write
-#define _MD_WRITEV _MD_writev
-#define _MD_LSEEK _MD_lseek
-#define _MD_LSEEK64 _MD_lseek64
-#define _MD_FSYNC _MD_fsync
-#define _MD_DELETE _MD_delete
-#define _MD_GETFILEINFO _MD_getfileinfo
-#define _MD_GETFILEINFO64 _MD_getfileinfo64
-#define _MD_GETOPENFILEINFO _MD_getopenfileinfo
-#define _MD_GETOPENFILEINFO64 _MD_getopenfileinfo64
-#define _MD_RENAME _MD_rename
-#define _MD_ACCESS _MD_access
-#define _MD_STAT stat
-#define _MD_MKDIR _MD_mkdir
-#define _MD_MAKE_DIR _MD_mkdir
-#define _MD_RMDIR _MD_rmdir
-#define _MD_PR_POLL _MD_pr_poll
-
-/* Network I/O */
-
-#define _MD_CLOSE_SOCKET _MD_close_socket
-#define _MD_CONNECT _MD_connect
-#define _MD_ACCEPT _MD_accept
-#define _MD_BIND _MD_bind
-#define _MD_LISTEN _MD_listen
-#define _MD_SHUTDOWN _MD_shutdown
-#define _MD_RECV _MD_recv
-#define _MD_SEND _MD_send
-#define _MD_ACCEPT_READ _MD_accept_read
-#define _MD_GETSOCKNAME _MD_getsockname
-#define _MD_GETPEERNAME _MD_getpeername
-#define _MD_GETSOCKOPT _MD_getsockopt
-#define _MD_SETSOCKOPT _MD_setsockopt
-#define _MD_RECVFROM _MD_recvfrom
-#define _MD_SENDTO _MD_sendto
-#define _MD_SOCKETPAIR _MD_socketpair
-#define _MD_SOCKET _MD_socket
-#define _MD_SOCKETAVAILABLE _MD_socketavailable
-#define _MD_PIPEAVAILABLE _MD_socketavailable
-
-#define _MD_GET_SOCKET_ERROR()	(errno)
-#define _MD_GETHOSTNAME _MD_gethostname
-
-#define _MD_SELECT select
-
-/* Process management */
-
-#define _MD_CREATE_PROCESS _MD_create_process
-#define _MD_DETACH_PROCESS _MD_detach_process
-#define _MD_WAIT_PROCESS _MD_wait_process
-#define _MD_KILL_PROCESS _MD_kill_process
-
-/* Atomic data operations */
-
-// #define _MD_INIT_ATOMIC _MD_init_atomic
-// #define _MD_ATOMIC_INCREMENT _MD_atomic_increment
-// #define _MD_ATOMIC_DECREMENT _MD_atomic_decrement
-// #define _MD_ATOMIC_SET _MD_atomic_set
-
-/* memory management */
-
-#define _MD_INIT_SEGS _MD_init_segs
-#define _MD_ALLOC_SEGMENT _MD_alloc_segment
-#define _MD_FREE_SEGMENT _MD_free_segment
-
-/* Memory mapped file I/O */
-
-#define _MD_CREATE_FILE_MAP _MD_create_file_map
-#define _MD_GET_MEM_MAP_ALIGNMENT _MD_get_mem_map_alignment
-#define _MD_MEM_MAP _MD_mem_map
-#define _MD_MEM_UNMAP _MD_mem_unmap
-#define _MD_CLOSE_FILE_MAP _MD_close_file_map
-
-/* Time related */
-
-#define _MD_NOW _MD_now
-#define _MD_INTERVAL_INIT _MD_interval_init
-#define _MD_GET_INTERVAL _MD_get_interval
-#define _MD_INTERVAL_PER_SEC _MD_interval_per_sec
-
-/* File locking */
-
-#define _MD_LOCKFILE _MD_lockfile
-#define _MD_TLOCKFILE _MD_tlockfile
-#define _MD_UNLOCKFILE _MD_unlockfile
-
-/**
- * Prototypes for machine dependent function implementations. (Too bad
- * NSPR's MD system blows so much that we have to reiterate every stinking
- * thing we implement here in our MD header file.)
- */
-
-/* Miscellaneous */
-
-NSPR_API(void) _MD_cleanup_before_exit(void);
-NSPR_API(void) _MD_exit(PRIntn status);
-
-NSPR_API(char*) _MD_get_env(const char *name);
-NSPR_API(PRIntn) _MD_put_env(const char *name);
-
-NSPR_API(void) _MD_early_init(void);
-NSPR_API(void) _MD_final_init(void);
-
-/* CPU Stuff */
-
-NSPR_API(void) _MD_init_cpus();
-NSPR_API(void) _MD_wakeup_cpus();
-NSPR_API(void) _MD_start_interrupts(void);
-NSPR_API(void) _MD_stop_interrupts(void);
-NSPR_API(void) _MD_disable_clock_interrupts(void);
-NSPR_API(void) _MD_block_clock_interrupts(void);
-NSPR_API(void) _MD_unblock_clock_interrupts(void);
-NSPR_API(void) _MD_clock_interrupt(void);
-// NSPR_API(void) _MD_init_stack(PRThreadStack *ts, PRIntn redzone);
-// NSPR_API(void) _MD_clear_stack(PRThreadStack* ts);
-// NSPR_API(PRInt32) _MD_get_intsoff(void);
-// NSPR_API(void) _MD_set_intsoff(PRInt32 _val);
-// NSPR_API(_PRCPU*) _MD_current_cpu(void);
-// NSPR_API(void) _MD_set_current_cpu(_PRCPU *cpu);
-// NSPR_API(void) _MD_init_running_cpu(_PRCPU *cpu);
-NSPR_API(PRInt32) _MD_pause_cpu(PRIntervalTime timeout);
-
-/* Thread stuff */
-
-// NSPR_API(PRThread*) _MD_current_thread(void);
-NSPR_API(PRThread*) _MD_get_attached_thread(void);
-NSPR_API(PRThread*) _MD_last_thread(void);
-NSPR_API(void) _MD_set_current_thread(PRThread *thread);
-NSPR_API(void) _MD_set_last_thread(PRThread *thread);
-NSPR_API(PRStatus) _MD_init_thread(PRThread *thread);
-NSPR_API(void) _MD_exit_thread(PRThread *thread);
-NSPR_API(PRStatus) _MD_init_attached_thread(PRThread *thread);
-
-NSPR_API(void) _MD_suspend_thread(PRThread *thread);
-NSPR_API(void) _MD_resume_thread(PRThread *thread);
-// NSPR_API(void) _MD_suspend_cpu(_PRCPU  *cpu);
-// NSPR_API(void) _MD_resume_cpu(_PRCPU  *cpu);
-NSPR_API(void) _MD_begin_suspend_all(void);
-NSPR_API(void) _MD_end_suspend_all(void);
-NSPR_API(void) _MD_begin_resume_all(void);
-NSPR_API(void) _MD_end_resume_all(void);
-
-NSPR_API(void *) _MD_get_sp(PRThread *thread);
-
-NSPR_API(void) _MD_clean_thread(PRThread *thread);
-NSPR_API(void) _MD_create_primordial_user_thread(PRThread *);
-NSPR_API(PRThread*) _MD_create_user_thread(PRUint32 stacksize, void (*start)(void *), void *arg);
-NSPR_API(void) _MD_init_primordial_thread(PRThread *thread);
-NSPR_API(PRStatus) _MD_create_thread(PRThread *thread, void (*start)(void *), PRThreadPriority priority, PRThreadScope scope, PRThreadState state, PRUint32 stackSize);
-NSPR_API(void) _MD_yield(void);
-NSPR_API(void) _MD_set_priority(struct _MDThread *md, PRThreadPriority newPri);
-
-NSPR_API(void) _MD_suspendall(void);
-NSPR_API(void) _MD_resumeall(void);
-
-NSPR_API(void) _MD_init_context(PRThread *thread, char *top, void (*start) (void), PRBool *status);
-NSPR_API(void) _MD_switch_context(PRThread *thread);
-NSPR_API(void) _MD_restore_context(PRThread *thread);
-
-NSPR_API(PRStatus) _MD_wait(PRThread *, PRIntervalTime timeout);
-NSPR_API(PRStatus) _MD_wakeup_waiter(PRThread *);
-
-NSPR_API(PRInt32) _MD_setthreadaffinitymask(PRThread *thread, PRUint32 mask );
-NSPR_API(PRInt32) _MD_getthreadaffinitymask(PRThread *thread, PRUint32 *mask);
-
-/* Thread Synchronization */
-
-NSPR_API(void) _MD_init_locks(void);
-NSPR_API(PRStatus) _MD_new_lock(struct _MDLock *md);
-NSPR_API(void) _MD_free_lock(struct _MDLock *md);
-NSPR_API(void) _MD_lock(struct _MDLock *md);
-NSPR_API(PRIntn) _MD_test_and_lock(struct _MDLock *md);
-NSPR_API(void) _MD_unlock(struct _MDLock *md);
-NSPR_API(void) _MD_ioq_lock(void);
-NSPR_API(void) _MD_ioq_unlock(void);
-NSPR_API(void) _MD_new_sem(struct _MDSemaphore *md, PRUintn value);
-NSPR_API(void) _MD_destroy_sem(struct _MDSemaphore *md);
-NSPR_API(PRStatus) _MD_timed_wait_sem(struct _MDSemaphore *md, PRIntervalTime timeout);
-NSPR_API(PRStatus) _MD_wait_sem(struct _MDSemaphore *md);
-NSPR_API(void) _MD_post_sem(struct _MDSemaphore *md);
-// NSPR_API(PRInt32) _MD_new_cv(struct _MDCVar *md);
-// NSPR_API(void) _MD_free_cv(struct _MDCVar *md);
-// NSPR_API(void) _MD_wait_cv(struct _MDCVar *mdCVar, struct _MDLock *mdLock, PRIntervalTime timeout);
-// NSPR_API(void) _MD_notify_cv(struct _MDCVar *md, struct _MDLock *lock);
-// NSPR_API(void) _MD_notifyall_cv(struct _MDCVar *md, struct _MDLock *lock);
-
-/* File I/O */
-
-// NSPR_API(void) _MD_init_io(void);
-NSPR_API(PRStatus) _MD_open_dir(struct _MDDir *md,const char *name);
-NSPR_API(char *) _MD_read_dir(struct _MDDir *md, PRIntn flags);
-NSPR_API(PRInt32) _MD_close_dir(struct _MDDir *md);
-NSPR_API(void) _MD_make_nonblock(PRFileDesc *fd);
-NSPR_API(void) _MD_init_fd_inheritable(PRFileDesc *fd, PRBool imported);
-NSPR_API(void) _MD_query_fd_inheritable(PRFileDesc *fd);
-NSPR_API(PRInt32) _MD_open(const char *name, PRIntn osflags, PRIntn mode);
-NSPR_API(PRInt32) _MD_close_file(PRInt32 osfd);
-NSPR_API(PRInt32) _MD_read(PRFileDesc *fd, void *buf, PRInt32 amount);
-NSPR_API(PRInt32) _MD_write(PRFileDesc *fd, const void *buf, PRInt32 amount);
-NSPR_API(PRInt32) _MD_writev(PRFileDesc *fd, const PRIOVec *iov, PRInt32 iov_size, PRIntervalTime timeout);
-NSPR_API(PRInt32) _MD_lseek(PRFileDesc *fd, PRInt32 offset, int whence);
-NSPR_API(PRInt64) _MD_lseek64(PRFileDesc *fd, PRInt64 offset, int whence);
-NSPR_API(PRInt32) _MD_fsync(PRFileDesc *fd);
-NSPR_API(PRInt32) _MD_delete(const char *name);
-NSPR_API(PRInt32) _MD_getfileinfo(const char *fn, PRFileInfo *info);
-NSPR_API(PRInt32) _MD_getfileinfo64(const char *fn, PRFileInfo64 *info);
-NSPR_API(PRInt32) _MD_getopenfileinfo(const PRFileDesc *fd, PRFileInfo *info);
-NSPR_API(PRInt32) _MD_getopenfileinfo64(const PRFileDesc *fd, PRFileInfo64 *info);
-NSPR_API(PRInt32) _MD_rename(const char *from, const char *to);
-NSPR_API(PRInt32) _MD_access(const char *name, PRIntn how);
-NSPR_API(PRInt32) _MD_stat(const char *name, struct stat *buf);
-NSPR_API(PRInt32) _MD_mkdir(const char *name, PRIntn mode);
-NSPR_API(PRInt32) _MD_rmdir(const char *name);
-NSPR_API(PRInt32) _MD_pr_poll(PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout);
-
-/* Network I/O */
-NSPR_API(PRInt32) _MD_close_socket(PRInt32 osfd);
-NSPR_API(PRInt32) _MD_connect(PRFileDesc *fd, const PRNetAddr *addr, PRUint32 addrlen, PRIntervalTime timeout);
-NSPR_API(PRInt32) _MD_accept(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen, PRIntervalTime timeout);
-NSPR_API(PRInt32) _MD_bind(PRFileDesc *fd, const PRNetAddr *addr, PRUint32 addrlen);
-NSPR_API(PRInt32) _MD_listen(PRFileDesc *fd, PRIntn backlog);
-NSPR_API(PRInt32) _MD_shutdown(PRFileDesc *fd, PRIntn how);
-NSPR_API(PRInt32) _MD_recv(PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout);
-NSPR_API(PRInt32) _MD_send(PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout);
-NSPR_API(PRInt32) _MD_accept_read(PRFileDesc *sd, PRInt32 *newSock, PRNetAddr **raddr, void *buf, PRInt32 amount, PRIntervalTime timeout);
-// NSPR_API(PRInt32) _MD_fast_accept(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen, PRIntervalTime timeout, PRBool fast, _PR_AcceptTimeoutCallback callback, void *callbackArg);
-// NSPR_API(PRInt32) _MD_fast_accept_read(PRFileDesc *sd, PRInt32 *newSock, PRNetAddr **raddr, void *buf, PRInt32 amount, PRIntervalTime timeout, PRBool fast, _PR_AcceptTimeoutCallback callback, void *callbackArg);
-// NSPR_API(void) _MD_update_accept_context(PRInt32 s, PRInt32 ls);
-NSPR_API(PRStatus) _MD_getsockname(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen);
-NSPR_API(PRStatus) _MD_getpeername(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen);
-NSPR_API(PRStatus) _MD_getsockopt(PRFileDesc *fd, PRInt32 level, PRInt32 optname, char* optval, PRInt32* optlen);
-NSPR_API(PRStatus) _MD_setsockopt(PRFileDesc *fd, PRInt32 level, PRInt32 optname, const char* optval, PRInt32 optlen);
-NSPR_API(PRInt32) _MD_recvfrom(PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, PRNetAddr *addr, PRUint32 *addrlen, PRIntervalTime timeout);
-NSPR_API(PRInt32) _MD_sendto(PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags, const PRNetAddr *addr, PRUint32 addrlen, PRIntervalTime timeout);
-NSPR_API(PRInt32) _MD_socketpair(int af, int type, int flags, PRInt32 *osfd);
-NSPR_API(PRInt32) _MD_socket(int af, int type, int flags);
-NSPR_API(PRInt32) _MD_socketavailable(PRFileDesc *fd);
-
-// NSPR_API(PRInt32) _MD_get_socket_error(void);
-NSPR_API(PRStatus) _MD_gethostname(char *name, PRUint32 namelen);
-
-/* Process management */
-
-NSPR_API(PRProcess *) _MD_create_process(const char *path, char *const *argv, char *const *envp, const PRProcessAttr *attr);
-NSPR_API(PRStatus) _MD_detach_process(PRProcess *process);
-NSPR_API(PRStatus) _MD_wait_process(PRProcess *process, PRInt32 *exitCode);
-NSPR_API(PRStatus) _MD_kill_process(PRProcess *process);
-
-/* Atomic data operations */
-
-// NSPR_API(void) _MD_init_atomic(void);
-// NSPR_API(PRInt32) _MD_atomic_increment(PRInt32 *);
-// NSPR_API(PRInt32) _MD_atomic_decrement(PRInt32 *);
-// NSPR_API(PRInt32) _MD_atomic_set(PRInt32 *, PRInt32);
-
-/* Memory management */
-
-NSPR_API(void) _MD_init_segs(void);
-NSPR_API(PRStatus) _MD_alloc_segment(PRSegment *seg, PRUint32 size, void *vaddr);
-NSPR_API(void) _MD_free_segment(PRSegment *seg);
-
-/* Memory mapped file I/O */
-
-NSPR_API(PRStatus) _MD_create_file_map(PRFileMap *fmap, PRInt64 size);
-NSPR_API(PRInt32) _MD_get_mem_map_alignment(void);
-NSPR_API(void *) _MD_mem_map(PRFileMap *fmap, PRInt64 offset, PRUint32 len);
-NSPR_API(PRStatus) _MD_mem_unmap(void *addr, PRUint32 size);
-NSPR_API(PRStatus) _MD_close_file_map(PRFileMap *fmap);
-
-/* Time related */
-
-NSPR_API(PRTime) _MD_now(void);
-NSPR_API(void) _MD_interval_init(void);
-NSPR_API(PRIntervalTime) _MD_get_interval(void);
-NSPR_API(PRIntervalTime) _MD_interval_per_sec(void);
-
-/* File locking */
-
-NSPR_API(PRStatus) _MD_lockfile(PRInt32 osfd);
-NSPR_API(PRStatus) _MD_tlockfile(PRInt32 osfd);
-NSPR_API(PRStatus) _MD_unlockfile(PRInt32 osfd);
-
-#endif /* _nspr_beos_defs_h___*/