Merge inbound to mozilla-central. a=merge
authorCiure Andrei <aciure@mozilla.com>
Wed, 10 Jul 2019 12:41:47 +0300
changeset 542552 6e5088fb8fd6ac3ad4956ec3f623b525f4cdd81a
parent 542537 823177295f4c17856f7dacad1e1f3d4204d377ba (current diff)
parent 542551 4483006a672e1b3018c6235d71a90183daa0ffc5 (diff)
child 542620 ed01b10e5a83a6003df915cb83226b43baa84598
child 542632 f3a387c13e2c4ca4783f90d00fb20564e3441933
push id11848
push userffxbld-merge
push dateMon, 26 Aug 2019 19:26:25 +0000
treeherdermozilla-beta@9b31bfdfac10 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone70.0a1
first release with
nightly linux32
6e5088fb8fd6 / 70.0a1 / 20190710094220 / files
nightly linux64
6e5088fb8fd6 / 70.0a1 / 20190710094220 / files
nightly mac
6e5088fb8fd6 / 70.0a1 / 20190710094220 / files
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
Merge inbound to mozilla-central. a=merge
dom/base/nsContentUtils.cpp
dom/base/nsContentUtils.h
js/src/gc/GC.cpp
js/src/vm/Compartment.cpp
js/src/vm/Realm.cpp
nsprpub/pr/include/md/_beos.cfg
nsprpub/pr/include/md/_beos.h
nsprpub/pr/include/md/_dgux.cfg
nsprpub/pr/include/md/_dgux.h
nsprpub/pr/include/md/_irix.h
nsprpub/pr/include/md/_irix32.cfg
nsprpub/pr/include/md/_irix64.cfg
nsprpub/pr/include/md/_osf1.cfg
nsprpub/pr/include/md/_osf1.h
nsprpub/pr/include/md/_symbian.cfg
nsprpub/pr/include/md/_symbian.h
nsprpub/pr/src/bthreads/.cvsignore
nsprpub/pr/src/bthreads/Makefile.in
nsprpub/pr/src/bthreads/bsrcs.mk
nsprpub/pr/src/bthreads/btcvar.c
nsprpub/pr/src/bthreads/btlocks.c
nsprpub/pr/src/bthreads/btmisc.c
nsprpub/pr/src/bthreads/btmon.c
nsprpub/pr/src/bthreads/btsem.c
nsprpub/pr/src/bthreads/btthread.c
nsprpub/pr/src/bthreads/objs.mk
nsprpub/pr/src/md/beos/.cvsignore
nsprpub/pr/src/md/beos/Makefile.in
nsprpub/pr/src/md/beos/bcpu.c
nsprpub/pr/src/md/beos/beos.c
nsprpub/pr/src/md/beos/beos_errors.c
nsprpub/pr/src/md/beos/bfile.c
nsprpub/pr/src/md/beos/bmemory.c
nsprpub/pr/src/md/beos/bmisc.c
nsprpub/pr/src/md/beos/bmmap.c
nsprpub/pr/src/md/beos/bnet.c
nsprpub/pr/src/md/beos/bproc.c
nsprpub/pr/src/md/beos/brng.c
nsprpub/pr/src/md/beos/bseg.c
nsprpub/pr/src/md/beos/bsrcs.mk
nsprpub/pr/src/md/beos/btime.c
nsprpub/pr/src/md/beos/objs.mk
nsprpub/pr/src/md/unix/irix.c
nsprpub/pr/src/md/unix/os_Irix.s
nsprpub/pr/src/md/unix/osf1.c
nsprpub/pr/src/md/unix/symbian.c
nsprpub/pr/tests/sproc_ch.c
nsprpub/pr/tests/sproc_p.c
--- 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___*/
deleted file mode 100644
--- a/nsprpub/pr/include/md/_dgux.cfg
+++ /dev/null
@@ -1,108 +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_UNIX
-#define XP_UNIX
-#endif
-
-#ifndef DGUX
-#define DGUX
-#endif
-
-#define IS_LITTLE_ENDIAN 1
-#undef  IS_BIG_ENDIAN
-#ifndef HAVE_LONG_LONG
-#define HAVE_LONG_LONG
-#endif
-#undef	HAVE_ALIGNED_DOUBLES
-#undef	HAVE_ALIGNED_LONGLONGS
-
-#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 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/_dgux.h
+++ /dev/null
@@ -1,188 +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_dgux_defs_h___
-#define nspr_dgux_defs_h___
-
-/*
- * Internal configuration macros
- */
-
-#define PR_LINKER_ARCH	"dgux"
-#define _PR_SI_SYSNAME		"DGUX"
-#define _PR_SI_ARCHITECTURE	"x86"
-#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
-
-#ifndef	HAVE_WEAK_IO_SYMBOLS
-#define	HAVE_WEAK_IO_SYMBOLS
-#endif
-
-#undef  HAVE_STACK_GROWING_UP
-#define HAVE_NETCONFIG
-#define	HAVE_DLL
-#define	USE_DLFCN
-#define NEED_STRFTIME_LOCK
-#define NEED_TIME_R
-#define _PR_NEED_STRCASECMP
-#define _PR_POLL_AVAILABLE
-#define _PR_USE_POLL
-#define _PR_NO_LARGE_FILES
-#define _PR_STAT_HAS_ONLY_ST_ATIME
-
-#define USE_SETJMP
-
-#include <setjmp.h>
-
-#define _SETJMP setjmp
-#define _LONGJMP longjmp
-#define _PR_CONTEXT_TYPE         jmp_buf
-#define _MD_GET_SP(_t)           (_t)->md.context[4]
-#define _PR_NUM_GCREGS	_JBLEN
-
-#define CONTEXT(_th) ((_th)->md.context)
-
-/*
-** Initialize the thread context preparing it to execute _main.
-*/
-#define _MD_INIT_CONTEXT(_thread, _sp, _main, status) \
-{								  \
-    *status = PR_TRUE; \
-    if(_SETJMP(CONTEXT(_thread))) (*_main)(); \
-    _MD_GET_SP(_thread) = (int) ((_sp) - 128); \
-}
-
-#define _MD_SWITCH_CONTEXT(_thread)  \
-    if (!_SETJMP(CONTEXT(_thread))) { \
-	(_thread)->md.errcode = errno;  \
-	_PR_Schedule();		     \
-    }
-
-/*
-** Restore a thread context, saved by _MD_SWITCH_CONTEXT
-*/
-#define _MD_RESTORE_CONTEXT(_thread) \
-{				     \
-    errno = (_thread)->md.errcode;	     \
-    _MD_SET_CURRENT_THREAD(_thread); \
-    _LONGJMP(CONTEXT(_thread), 1);    \
-}
-
-/* Machine-dependent (MD) data structures.
- * Don't use SVR4 native threads (yet). 
- */
-
-struct _MDThread {
-    _PR_CONTEXT_TYPE context;
-    int id;
-    int errcode;
-};
-
-struct _MDThreadStack {
-    PRInt8 notused;
-};
-
-struct _MDLock {
-    PRInt8 notused;
-};
-
-struct _MDSemaphore {
-    PRInt8 notused;
-};
-
-struct _MDCVar {
-    PRInt8 notused;
-};
-
-struct _MDSegment {
-    PRInt8 notused;
-};
-
-/*
- * md-specific cpu structure field
- */
-#define _PR_MD_MAX_OSFD FD_SETSIZE
-
-struct _MDCPU_Unix {
-    PRCList ioQ;
-    PRUint32 ioq_timeout;
-    PRInt32 ioq_max_osfd;
-    PRInt32 ioq_osfd_cnt;
-#ifndef _PR_USE_POLL
-    fd_set fd_read_set, fd_write_set, fd_exception_set;
-    PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD],
-                fd_exception_cnt[_PR_MD_MAX_OSFD];
-#else
-    struct pollfd *ioq_pollfds;
-    int ioq_pollfds_size;
-#endif  /* _PR_USE_POLL */
-};
-
-#define _PR_IOQ(_cpu)               ((_cpu)->md.md_unix.ioQ)
-#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu))
-#define _PR_FD_READ_SET(_cpu)       ((_cpu)->md.md_unix.fd_read_set)
-#define _PR_FD_READ_CNT(_cpu)       ((_cpu)->md.md_unix.fd_read_cnt)
-#define _PR_FD_WRITE_SET(_cpu)      ((_cpu)->md.md_unix.fd_write_set)
-#define _PR_FD_WRITE_CNT(_cpu)      ((_cpu)->md.md_unix.fd_write_cnt)
-#define _PR_FD_EXCEPTION_SET(_cpu)  ((_cpu)->md.md_unix.fd_exception_set)
-#define _PR_FD_EXCEPTION_CNT(_cpu)  ((_cpu)->md.md_unix.fd_exception_cnt)
-#define _PR_IOQ_TIMEOUT(_cpu)       ((_cpu)->md.md_unix.ioq_timeout)
-#define _PR_IOQ_MAX_OSFD(_cpu)      ((_cpu)->md.md_unix.ioq_max_osfd)
-#define _PR_IOQ_OSFD_CNT(_cpu)      ((_cpu)->md.md_unix.ioq_osfd_cnt)
-#define _PR_IOQ_POLLFDS(_cpu)       ((_cpu)->md.md_unix.ioq_pollfds)
-#define _PR_IOQ_POLLFDS_SIZE(_cpu)  ((_cpu)->md.md_unix.ioq_pollfds_size)
-
-#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu)  32
-
-struct _MDCPU {
-    struct _MDCPU_Unix md_unix;
-};
-
-#define _MD_INIT_LOCKS()
-#define _MD_NEW_LOCK(lock) PR_SUCCESS
-#define _MD_FREE_LOCK(lock)
-#define _MD_LOCK(lock)
-#define _MD_UNLOCK(lock)
-#define _MD_INIT_IO()
-#define _MD_IOQ_LOCK()
-#define _MD_IOQ_UNLOCK()
-
-/*
- * The following are copied from _sunos.h, _aix.h.  This means
- * some of them should probably be moved into _unixos.h.  But
- * _irix.h seems to be quite different in regard to these macros.
- */
-#define _MD_INTERVAL_USE_GTOD
-
-#define _MD_EARLY_INIT		_MD_EarlyInit
-#define _MD_FINAL_INIT		_PR_UnixInit
-#define _MD_INIT_RUNNING_CPU(cpu) _MD_unix_init_running_cpu(cpu)
-#define _MD_INIT_THREAD         _MD_InitializeThread
-#define _MD_EXIT_THREAD(thread)
-#define	_MD_SUSPEND_THREAD(thread)
-#define	_MD_RESUME_THREAD(thread)
-#define _MD_CLEAN_THREAD(_thread)
-
-/*
- * We wrapped the select() call.  _MD_SELECT refers to the built-in,
- * unwrapped version.
- */
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/time.h>
-extern int _select(int nfds, fd_set *readfds, fd_set *writefds,
-	fd_set *execptfds, struct timeval *timeout);
-#define _MD_SELECT _select
-
-#define _MD_POLL _poll
-#include <poll.h>
-#include <stropts.h>
-extern int _poll(struct pollfd *fds, unsigned long nfds, int timeout);
-
-#endif /* nspr_dgux_defs_h___ */
deleted file mode 100644
--- a/nsprpub/pr/include/md/_irix.h
+++ /dev/null
@@ -1,438 +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_irix_defs_h___
-#define nspr_irix_defs_h___
-
-#define _PR_HAVE_ATOMIC_CAS
-
-/*
- * MipsPro assembler defines _LANGUAGE_ASSEMBLY
- */
-#ifndef _LANGUAGE_ASSEMBLY
-
-#include "prclist.h"
-#include "prthread.h"
-#include <sys/ucontext.h>
-
-/*
- * Internal configuration macros
- */
-
-#define PR_LINKER_ARCH          "irix"
-#define _PR_SI_SYSNAME          "IRIX"
-#define _PR_SI_ARCHITECTURE     "mips"
-#define PR_DLL_SUFFIX		".so"
-
-#define _PR_VMBASE              0x30000000
-#define _PR_STACK_VMBASE        0x50000000
-#define _PR_NUM_GCREGS          9
-#define _MD_MMAP_FLAGS          MAP_PRIVATE
-
-#define _MD_DEFAULT_STACK_SIZE  65536L
-#define _MD_MIN_STACK_SIZE      16384L
-
-#undef  HAVE_STACK_GROWING_UP
-#define HAVE_WEAK_IO_SYMBOLS
-#define HAVE_WEAK_MALLOC_SYMBOLS
-#define HAVE_DLL
-#define USE_DLFCN
-#define _PR_HAVE_ATOMIC_OPS
-#define _PR_POLL_AVAILABLE
-#define _PR_USE_POLL
-#define _PR_STAT_HAS_ST_ATIM
-#define _PR_HAVE_OFF64_T
-#define HAVE_POINTER_LOCALTIME_R
-#define _PR_HAVE_POSIX_SEMAPHORES
-#define PR_HAVE_POSIX_NAMED_SHARED_MEMORY
-#define _PR_ACCEPT_INHERIT_NONBLOCK
-
-#ifdef _PR_INET6
-#define _PR_HAVE_INET_NTOP
-#define _PR_HAVE_GETIPNODEBYNAME
-#define _PR_HAVE_GETIPNODEBYADDR
-#define _PR_HAVE_GETADDRINFO
-#endif
-
-/* Initialization entry points */
-NSPR_API(void) _MD_EarlyInit(void);
-#define _MD_EARLY_INIT _MD_EarlyInit
-
-NSPR_API(void) _MD_IrixInit(void);
-#define _MD_FINAL_INIT _MD_IrixInit
-
-#define _MD_INIT_IO()
-
-/* Timer operations */
-NSPR_API(PRIntervalTime) _MD_IrixGetInterval(void);
-#define _MD_GET_INTERVAL _MD_IrixGetInterval
-
-NSPR_API(PRIntervalTime) _MD_IrixIntervalPerSec(void);
-#define _MD_INTERVAL_PER_SEC _MD_IrixIntervalPerSec
-
-/* GC operations */
-NSPR_API(void *) _MD_GetSP(PRThread *thread);
-#define    _MD_GET_SP _MD_GetSP
-
-/* The atomic operations */
-#include <mutex.h>
-#define _MD_INIT_ATOMIC()
-#define _MD_ATOMIC_INCREMENT(val) add_then_test((unsigned long*)val, 1)
-#define _MD_ATOMIC_ADD(ptr, val) add_then_test((unsigned long*)ptr, (unsigned long)val)
-#define _MD_ATOMIC_DECREMENT(val) add_then_test((unsigned long*)val, 0xffffffff)
-#define _MD_ATOMIC_SET(val, newval) test_and_set((unsigned long*)val, newval)
-
-#if defined(_PR_PTHREADS)
-#else /* defined(_PR_PTHREADS) */
-
-/************************************************************************/
-
-#include <setjmp.h>
-#include <errno.h>
-#include <unistd.h>
-#include <bstring.h>
-#include <sys/time.h>
-#include <ulocks.h>
-#include <sys/prctl.h>
-
-
-/*
- * Data region private to each sproc. This region is setup by calling
- * mmap(...,MAP_LOCAL,...). The private data is mapped at the same
- * address in every sproc, but every sproc gets a private mapping.
- *
- * Just make sure that this structure fits in a page, as only one page
- * is allocated for the private region.
- */
-struct sproc_private_data {
-    struct PRThread *me;
-    struct _PRCPU *cpu;
-    struct PRThread *last;
-    PRUintn intsOff;
-	int		sproc_pid;
-};
-
-extern char *_nspr_sproc_private;
-
-#define _PR_PRDA() ((struct sproc_private_data *) _nspr_sproc_private)
-#define _MD_SET_CURRENT_THREAD(_thread) _PR_PRDA()->me = (_thread)
-#define _MD_THIS_THREAD() (_PR_PRDA()->me)
-#define _MD_LAST_THREAD() (_PR_PRDA()->last)
-#define _MD_SET_LAST_THREAD(_thread) _PR_PRDA()->last = (_thread)
-#define _MD_CURRENT_CPU() (_PR_PRDA()->cpu)
-#define _MD_SET_CURRENT_CPU(_cpu) _PR_PRDA()->cpu = (_cpu)
-#define _MD_SET_INTSOFF(_val) (_PR_PRDA()->intsOff = _val)
-#define _MD_GET_INTSOFF() (_PR_PRDA()->intsOff)
-
-#define _MD_SET_SPROC_PID(_val) (_PR_PRDA()->sproc_pid = _val)
-#define _MD_GET_SPROC_PID() (_PR_PRDA()->sproc_pid)
-
-NSPR_API(struct PRThread*) _MD_get_attached_thread(void);
-NSPR_API(struct PRThread*) _MD_get_current_thread(void);
-#define _MD_GET_ATTACHED_THREAD()	_MD_get_attached_thread()
-#define _MD_CURRENT_THREAD()	_MD_get_current_thread()
-
-#define _MD_CHECK_FOR_EXIT() {					\
-		if (_pr_irix_exit_now) {				\
-			_PR_POST_SEM(_pr_irix_exit_sem);	\
-			_MD_Wakeup_CPUs();					\
-			_exit(0);							\
-		}										\
-	}
-		
-#define _MD_ATTACH_THREAD(threadp)
-
-#define _MD_SAVE_ERRNO(_thread)			(_thread)->md.errcode = errno;
-#define _MD_RESTORE_ERRNO(_thread)		errno = (_thread)->md.errcode;
-
-extern struct _PRCPU  *_pr_primordialCPU;
-extern usema_t *_pr_irix_exit_sem;
-extern PRInt32 _pr_irix_exit_now;
-extern int _pr_irix_primoridal_cpu_fd[];
-extern PRInt32 _pr_irix_process_exit;
-extern PRInt32 _pr_irix_process_exit_code;
-
-/* Thread operations */
-#define _PR_LOCK_HEAP()	{						\
-			PRIntn _is;					\
-				if (_pr_primordialCPU) {		\
-				if (_MD_GET_ATTACHED_THREAD() && 		\
-					!_PR_IS_NATIVE_THREAD( 		\
-					_MD_GET_ATTACHED_THREAD()))	\
-						_PR_INTSOFF(_is); 	\
-					_PR_LOCK(_pr_heapLock);		\
-				}
-
-#define _PR_UNLOCK_HEAP() 	if (_pr_primordialCPU)	{		\
-					_PR_UNLOCK(_pr_heapLock);	\
-				if (_MD_GET_ATTACHED_THREAD() && 		\
-					!_PR_IS_NATIVE_THREAD( 		\
-					_MD_GET_ATTACHED_THREAD()))	\
-						_PR_INTSON(_is);	\
-				}					\
-			  }
-
-#define _PR_OPEN_POLL_SEM(_sem)  usopenpollsema(_sem, 0666)
-#define _PR_WAIT_SEM(_sem) uspsema(_sem)
-#define _PR_POST_SEM(_sem) usvsema(_sem)
-
-#define _MD_CVAR_POST_SEM(threadp)	usvsema((threadp)->md.cvar_pollsem)
-
-#define _MD_IOQ_LOCK()
-#define _MD_IOQ_UNLOCK()
-
-struct _MDLock {
-    ulock_t lock;
-	usptr_t *arena;
-};
-
-/*
- * disable pre-emption for the LOCAL threads when calling the arena lock
- * routines
- */
-
-#define _PR_LOCK(lock) {						\
-		PRIntn _is;						\
-		PRThread *me = _MD_GET_ATTACHED_THREAD();			\
-		if (me && !_PR_IS_NATIVE_THREAD(me))			\
-			_PR_INTSOFF(_is); 				\
-		ussetlock(lock);					\
-		if (me && !_PR_IS_NATIVE_THREAD(me))			\
-			_PR_FAST_INTSON(_is); 				\
-	}
-
-#define _PR_UNLOCK(lock) {						\
-		PRIntn _is;						\
-		PRThread *me = _MD_GET_ATTACHED_THREAD();			\
-		if (me && !_PR_IS_NATIVE_THREAD(me))			\
-			_PR_INTSOFF(_is); 				\
-		usunsetlock(lock);					\
-		if (me && !_PR_IS_NATIVE_THREAD(me))			\
-			_PR_FAST_INTSON(_is); 				\
-	}
-
-NSPR_API(PRStatus) _MD_NEW_LOCK(struct _MDLock *md);
-NSPR_API(void) _MD_FREE_LOCK(struct _MDLock *lockp);
-
-#define _MD_LOCK(_lockp) _PR_LOCK((_lockp)->lock)
-#define _MD_UNLOCK(_lockp) _PR_UNLOCK((_lockp)->lock)
-#define _MD_TEST_AND_LOCK(_lockp) (uscsetlock((_lockp)->lock, 1) == 0)
-
-extern ulock_t _pr_heapLock;
-
-struct _MDThread {
-    jmp_buf jb;
-    usptr_t     *pollsem_arena;
-    usema_t     *cvar_pollsem;
-    PRInt32     cvar_pollsemfd;
-    PRInt32     cvar_pollsem_select;    /* acquire sem by calling select */
-    PRInt32     cvar_wait;              /* if 1, thread is waiting on cvar Q */
-    PRInt32	id;
-    PRInt32	suspending_id;
-    int errcode;
-};
-
-struct _MDThreadStack {
-    PRInt8 notused;
-};
-
-struct _MDSemaphore {
-    usema_t *sem;
-};
-
-struct _MDCVar {
-    ulock_t mdcvar_lock;
-};
-
-struct _MDSegment {
-    PRInt8 notused;
-};
-
-/*
- * md-specific cpu structure field
- */
-#define _PR_MD_MAX_OSFD FD_SETSIZE
-
-struct _MDCPU_Unix {
-    PRCList ioQ;
-    PRUint32 ioq_timeout;
-    PRInt32 ioq_max_osfd;
-    PRInt32 ioq_osfd_cnt;
-#ifndef _PR_USE_POLL
-    fd_set fd_read_set, fd_write_set, fd_exception_set;
-    PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD],
-				fd_exception_cnt[_PR_MD_MAX_OSFD];
-#else
-	struct pollfd *ioq_pollfds;
-	int ioq_pollfds_size;
-#endif	/* _PR_USE_POLL */
-};
-
-#define _PR_IOQ(_cpu)			((_cpu)->md.md_unix.ioQ)
-#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu))
-#define _PR_FD_READ_SET(_cpu)		((_cpu)->md.md_unix.fd_read_set)
-#define _PR_FD_READ_CNT(_cpu)		((_cpu)->md.md_unix.fd_read_cnt)
-#define _PR_FD_WRITE_SET(_cpu)		((_cpu)->md.md_unix.fd_write_set)
-#define _PR_FD_WRITE_CNT(_cpu)		((_cpu)->md.md_unix.fd_write_cnt)
-#define _PR_FD_EXCEPTION_SET(_cpu)	((_cpu)->md.md_unix.fd_exception_set)
-#define _PR_FD_EXCEPTION_CNT(_cpu)	((_cpu)->md.md_unix.fd_exception_cnt)
-#define _PR_IOQ_TIMEOUT(_cpu)		((_cpu)->md.md_unix.ioq_timeout)
-#define _PR_IOQ_MAX_OSFD(_cpu)		((_cpu)->md.md_unix.ioq_max_osfd)
-#define _PR_IOQ_OSFD_CNT(_cpu)		((_cpu)->md.md_unix.ioq_osfd_cnt)
-#define _PR_IOQ_POLLFDS(_cpu)		((_cpu)->md.md_unix.ioq_pollfds)
-#define _PR_IOQ_POLLFDS_SIZE(_cpu)	((_cpu)->md.md_unix.ioq_pollfds_size)
-
-#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu)	32
-
-
-struct _MDCPU {
-    PRInt32 id;
-    PRInt32 suspending_id;
-    struct _MDCPU_Unix md_unix;
-};
-
-/*
-** Initialize the thread context preparing it to execute _main.
-*/
-#define _MD_INIT_CONTEXT(_thread, _sp, _main, status)	      \
-    PR_BEGIN_MACRO				      \
-	int *jb = (_thread)->md.jb;		      \
-    *status = PR_TRUE;              \
-	(void) setjmp(jb);			      \
-	(_thread)->md.jb[JB_SP] = (int) ((_sp) - 64); \
-	(_thread)->md.jb[JB_PC] = (int) _main;	      \
-	_thread->no_sched = 0; \
-    PR_END_MACRO
-
-/*
-** Switch away from the current thread context by saving its state and
-** calling the thread scheduler. Reload cpu when we come back from the
-** context switch because it might have changed.
-*
-*  XXX RUNQ lock needed before clearing _PR_NO_SCHED flag, because the
-*      thread may be unr RUNQ?
-*/
-#define _MD_SWITCH_CONTEXT(_thread) \
-    PR_BEGIN_MACRO    \
-    PR_ASSERT(_thread->no_sched); \
-    if (!setjmp(_thread->md.jb)) { \
-        _MD_SAVE_ERRNO(_thread) \
-        _MD_SET_LAST_THREAD(_thread); \
-        _PR_Schedule(); \
-    } else {      \
-        PR_ASSERT(_MD_LAST_THREAD() !=_MD_CURRENT_THREAD()); \
-            _MD_LAST_THREAD()->no_sched = 0;			\
-    }             \
-    PR_END_MACRO
-
-/*
-** Restore a thread context that was saved by _MD_SWITCH_CONTEXT or
-** initialized by _MD_INIT_CONTEXT.
-*/
-#define _MD_RESTORE_CONTEXT(_newThread) \
-    PR_BEGIN_MACRO \
-    int *jb = (_newThread)->md.jb; \
-    _MD_RESTORE_ERRNO(_newThread) \
-    _MD_SET_CURRENT_THREAD(_newThread); \
-    _newThread->no_sched = 1;		\
-    longjmp(jb, 1); \
-    PR_END_MACRO
-
-NSPR_API(PRStatus) _MD_InitThread(struct PRThread *thread,
-								PRBool wakeup_parent);
-NSPR_API(PRStatus) _MD_InitAttachedThread(struct PRThread *thread,
-									PRBool wakeup_parent);
-#define _MD_INIT_THREAD(thread) 			_MD_InitThread(thread, PR_TRUE)
-#define _MD_INIT_ATTACHED_THREAD(thread)		\
-						_MD_InitAttachedThread(thread, PR_FALSE)
-
-NSPR_API(void) _MD_ExitThread(struct PRThread *thread);
-#define _MD_EXIT_THREAD _MD_ExitThread
-
-NSPR_API(void) _MD_SuspendThread(struct PRThread *thread);
-#define _MD_SUSPEND_THREAD _MD_SuspendThread
-
-NSPR_API(void) _MD_ResumeThread(struct PRThread *thread);
-#define _MD_RESUME_THREAD _MD_ResumeThread
-
-NSPR_API(void) _MD_SuspendCPU(struct _PRCPU *thread);
-#define _MD_SUSPEND_CPU _MD_SuspendCPU
-
-NSPR_API(void) _MD_ResumeCPU(struct _PRCPU *thread);
-#define _MD_RESUME_CPU _MD_ResumeCPU
-
-#define _MD_BEGIN_SUSPEND_ALL()
-#define _MD_END_SUSPEND_ALL()
-#define _MD_BEGIN_RESUME_ALL()
-#define _MD_END_RESUME_ALL()
-
-NSPR_API(void) _MD_InitLocks(void);
-#define _MD_INIT_LOCKS _MD_InitLocks
-
-NSPR_API(void) _MD_CleanThread(struct PRThread *thread);
-#define _MD_CLEAN_THREAD _MD_CleanThread
-
-#define _MD_YIELD()    sginap(0)
-
-/* The _PR_MD_WAIT_LOCK and _PR_MD_WAKEUP_WAITER functions put to sleep and
- * awaken a thread which is waiting on a lock or cvar.
- */
-NSPR_API(PRStatus) _MD_wait(struct PRThread *, PRIntervalTime timeout);
-#define _MD_WAIT _MD_wait
-
-NSPR_API(void) _PR_MD_primordial_cpu();
-NSPR_API(void) _PR_MD_WAKEUP_PRIMORDIAL_CPU();
-
-NSPR_API(PRStatus) _MD_WakeupWaiter(struct PRThread *);
-#define _MD_WAKEUP_WAITER _MD_WakeupWaiter
-
-NSPR_API(void ) _MD_exit(PRIntn status);
-#define _MD_EXIT	_MD_exit
-
-#include "prthread.h"
-
-NSPR_API(void) _MD_SetPriority(struct _MDThread *thread,
-	PRThreadPriority newPri);
-#define _MD_SET_PRIORITY _MD_SetPriority
-
-NSPR_API(PRStatus) _MD_CreateThread(
-                        struct PRThread *thread,
-                        void (*start) (void *),
-                        PRThreadPriority priority,
-                        PRThreadScope scope,
-                        PRThreadState state,
-                        PRUint32 stackSize);
-#define _MD_CREATE_THREAD _MD_CreateThread
-
-extern void _MD_CleanupBeforeExit(void);
-#define _MD_CLEANUP_BEFORE_EXIT _MD_CleanupBeforeExit
-
-NSPR_API(void) _PR_MD_PRE_CLEANUP(PRThread *me);
-
-
-/* The following defines the unwrapped versions of select() and poll(). */
-extern int _select(int nfds, fd_set *readfds, fd_set *writefds,
-	fd_set *exceptfds, struct timeval *timeout);
-#define _MD_SELECT	_select
-
-#include <stropts.h>
-#include <poll.h>
-#define _MD_POLL _poll
-extern int _poll(struct pollfd *fds, unsigned long nfds, int timeout);
-
-
-#define HAVE_THREAD_AFFINITY 1
-
-NSPR_API(PRInt32) _MD_GetThreadAffinityMask(PRThread *unused, PRUint32 *mask);
-#define _MD_GETTHREADAFFINITYMASK _MD_GetThreadAffinityMask
-
-NSPR_API(void) _MD_InitRunningCPU(struct _PRCPU *cpu);
-#define    _MD_INIT_RUNNING_CPU _MD_InitRunningCPU
-
-#endif  /* defined(_PR_PTHREADS) */
-
-#endif /* _LANGUAGE_ASSEMBLY */
-
-#endif /* nspr_irix_defs_h___ */
deleted file mode 100644
--- a/nsprpub/pr/include/md/_irix32.cfg
+++ /dev/null
@@ -1,119 +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 _SGI_MP_SOURCE
-#define _SGI_MP_SOURCE
-#endif
-
-#ifndef XP_UNIX
-#define XP_UNIX
-#endif
-
-#ifndef IRIX
-#define IRIX
-#endif
-
-#undef  IS_LITTLE_ENDIAN
-#define IS_BIG_ENDIAN 1
-
-#define PR_AF_INET6 24  /* same as AF_INET6 */
-
-#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_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_BYTES_PER_WORD_LOG2  2
-#define PR_BYTES_PER_DWORD_LOG2 3
-
-#define PR_ALIGN_OF_SHORT   2
-#define PR_ALIGN_OF_INT     4
-#define PR_ALIGN_OF_LONG    4
-#define PR_ALIGN_OF_INT64   8
-#define PR_ALIGN_OF_FLOAT   4
-#define PR_ALIGN_OF_DOUBLE  8
-#define PR_ALIGN_OF_POINTER 4
-#define PR_ALIGN_OF_WORD    4
-
-#ifndef HAVE_LONG_LONG
-#define HAVE_LONG_LONG
-#endif
-#define HAVE_ALIGNED_DOUBLES
-#define HAVE_ALIGNED_LONGLONGS
-
-#define _PR_POLL_BACKCOMPAT
-
-#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/_irix64.cfg
+++ /dev/null
@@ -1,118 +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 _SGI_MP_SOURCE
-#define _SGI_MP_SOURCE
-#endif
-
-#ifndef XP_UNIX
-#define XP_UNIX
-#endif
-
-#ifndef IRIX
-#define IRIX
-#endif
-
-#undef  IS_LITTLE_ENDIAN
-#define IS_BIG_ENDIAN 1
-#define IS_64
-
-#define PR_AF_INET6 24  /* same as AF_INET6 */
-
-#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   8
-#define PR_BYTES_PER_FLOAT  4
-#define PR_BYTES_PER_DOUBLE 8
-#define PR_BYTES_PER_WORD   8
-#define PR_BYTES_PER_DWORD  8
-
-#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    64
-#define PR_BITS_PER_FLOAT   32
-#define PR_BITS_PER_DOUBLE  64
-#define PR_BITS_PER_WORD    64
-
-#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   6
-#define PR_BITS_PER_FLOAT_LOG2  5
-#define PR_BITS_PER_DOUBLE_LOG2 6
-#define PR_BITS_PER_WORD_LOG2   6
-
-#define PR_BYTES_PER_WORD_LOG2  3
-#define PR_BYTES_PER_DWORD_LOG2 3
-
-#define PR_ALIGN_OF_SHORT   2
-#define PR_ALIGN_OF_INT     4
-#define PR_ALIGN_OF_LONG    4
-#define PR_ALIGN_OF_INT64   8
-#define PR_ALIGN_OF_FLOAT   4
-#define PR_ALIGN_OF_DOUBLE  8
-#define PR_ALIGN_OF_POINTER 4
-#define PR_ALIGN_OF_WORD    4
-
-#ifndef HAVE_LONG_LONG
-#define HAVE_LONG_LONG
-#endif
-#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___ */
--- a/nsprpub/pr/include/md/_linux.cfg
+++ b/nsprpub/pr/include/md/_linux.cfg
@@ -1107,16 +1107,61 @@
 #define PR_ALIGN_OF_FLOAT   4
 #define PR_ALIGN_OF_DOUBLE  8
 #define PR_ALIGN_OF_POINTER 8
 #define PR_ALIGN_OF_WORD    8
 
 #define PR_BYTES_PER_WORD_LOG2  3
 #define PR_BYTES_PER_DWORD_LOG2 3
 
+#elif defined(__arc__)
+
+#define IS_LITTLE_ENDIAN 1
+#undef  IS_BIG_ENDIAN
+
+#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_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
+#define PR_ALIGN_OF_WORD    4
+
+#define PR_BYTES_PER_WORD_LOG2   2
+#define PR_BYTES_PER_DWORD_LOG2  3
+
 #else
 
 #error "Unknown CPU architecture"
 
 #endif
 
 #ifndef HAVE_LONG_LONG
 #define	HAVE_LONG_LONG
--- a/nsprpub/pr/include/md/_linux.h
+++ b/nsprpub/pr/include/md/_linux.h
@@ -56,16 +56,18 @@
 #elif defined(__m32r__)
 #define _PR_SI_ARCHITECTURE "m32r"
 #elif defined(__or1k__)
 #define _PR_SI_ARCHITECTURE "or1k"
 #elif defined(__riscv) && (__riscv_xlen == 32)
 #define _PR_SI_ARCHITECTURE "riscv32"
 #elif defined(__riscv) && (__riscv_xlen == 64)
 #define _PR_SI_ARCHITECTURE "riscv64"
+#elif defined(__arc__)
+#define _PR_SI_ARCHITECTURE "arc"
 #else
 #error "Unknown CPU architecture"
 #endif
 #define PR_DLL_SUFFIX		".so"
 
 #define _PR_VMBASE              0x30000000
 #define _PR_STACK_VMBASE	0x50000000
 #define _MD_DEFAULT_STACK_SIZE	65536L
deleted file mode 100644
--- a/nsprpub/pr/include/md/_osf1.cfg
+++ /dev/null
@@ -1,116 +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_UNIX
-#define XP_UNIX
-#endif
-
-#ifndef OSF1
-#define OSF1
-#endif
-
-#define IS_LITTLE_ENDIAN 1
-#undef  IS_BIG_ENDIAN
-#ifndef HAVE_LONG_LONG
-#define	HAVE_LONG_LONG
-#endif
-#define HAVE_ALIGNED_DOUBLES
-#define HAVE_ALIGNED_LONGLONGS
-#ifndef IS_64
-#define IS_64
-#endif
-
-#define PR_AF_INET6 26  /* same as AF_INET6 */
-
-#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   8
-#define PR_BYTES_PER_FLOAT  4
-#define PR_BYTES_PER_DOUBLE 8
-#define PR_BYTES_PER_WORD   8
-#define PR_BYTES_PER_DWORD  8
-
-#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    64
-#define PR_BITS_PER_FLOAT   32
-#define PR_BITS_PER_DOUBLE  64
-#define PR_BITS_PER_WORD    64
-
-#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   6
-#define PR_BITS_PER_FLOAT_LOG2  5
-#define PR_BITS_PER_DOUBLE_LOG2 6
-#define PR_BITS_PER_WORD_LOG2   6
-
-#define PR_BYTES_PER_WORD_LOG2  3
-#define PR_BYTES_PER_DWORD_LOG2 3
-
-#define PR_ALIGN_OF_SHORT   2
-#define PR_ALIGN_OF_INT     4
-#define PR_ALIGN_OF_LONG    8
-#define PR_ALIGN_OF_INT64   8
-#define PR_ALIGN_OF_FLOAT   4
-#define PR_ALIGN_OF_DOUBLE  8
-#define PR_ALIGN_OF_POINTER 8
-
-#define _PR_POLL_BACKCOMPAT
-
-#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/_osf1.h
+++ /dev/null
@@ -1,222 +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_osf1_defs_h___
-#define nspr_osf1_defs_h___
-
-/*
- * Internal configuration macros
- */
-
-#define PR_LINKER_ARCH	"osf"
-#define _PR_SI_SYSNAME	"OSF"
-#define _PR_SI_ARCHITECTURE "alpha"
-#define PR_DLL_SUFFIX		".so"
-
-#define _PR_VMBASE              0x30000000
-#define _PR_STACK_VMBASE        0x50000000
-#define _MD_DEFAULT_STACK_SIZE  131072L
-#define _MD_MMAP_FLAGS          MAP_PRIVATE
-
-#undef  HAVE_STACK_GROWING_UP
-#undef 	HAVE_WEAK_IO_SYMBOLS
-#undef 	HAVE_WEAK_MALLOC_SYMBOLS
-#define HAVE_DLL
-#define HAVE_BSD_FLOCK
-
-#define NEED_TIME_R
-#define USE_DLFCN
-
-#define _PR_POLL_AVAILABLE
-#define _PR_USE_POLL
-#define _PR_STAT_HAS_ONLY_ST_ATIME
-#define _PR_HAVE_LARGE_OFF_T
-#define _PR_HAVE_GETIPNODEBYNAME
-#define _PR_HAVE_GETIPNODEBYADDR
-#define _PR_HAVE_GETADDRINFO
-#define _PR_INET6_PROBE
-#ifdef _PR_INET6
-#define _PR_HAVE_INET_NTOP
-#else
-#define AF_INET6 26
-#ifndef AI_CANONNAME
-#define AI_CANONNAME 0x00000002
-struct addrinfo {
-    int              ai_flags;
-    int              ai_family;
-    int              ai_socktype;
-    int              ai_protocol;
-    size_t           ai_addrlen;
-    char            *ai_canonname;
-    struct sockaddr *ai_addr;
-    struct addrinfo *ai_next;
-};
-#endif
-#define AI_V4MAPPED 0x00000010
-#define AI_ALL      0x00000008
-#define AI_ADDRCONFIG 0x00000020
-#endif
-#define _PR_HAVE_POSIX_SEMAPHORES
-#define PR_HAVE_POSIX_NAMED_SHARED_MEMORY
-
-#define USE_SETJMP
-
-#include <setjmp.h>
-
-/*
- * A jmp_buf is actually a struct sigcontext.  The sc_sp field of
- * struct sigcontext is the stack pointer.
- */
-#define _MD_GET_SP(_t) (((struct sigcontext *) (_t)->md.context)->sc_sp)
-#define PR_NUM_GCREGS _JBLEN
-#define CONTEXT(_th) ((_th)->md.context)
-
-/*
-** Initialize a thread context to run "_main()" when started
-*/
-#define _MD_INIT_CONTEXT(_thread, _sp, _main, status)	      \
-{									  \
-        *status = PR_TRUE;              \
-    if (setjmp(CONTEXT(_thread))) {				\
-	(*_main)();						\
-    }								\
-    _MD_GET_SP(_thread) = (long) ((_sp) - 64);			\
-    _MD_GET_SP(_thread) &= ~15;					\
-}
-
-#define _MD_SWITCH_CONTEXT(_thread)  \
-    if (!setjmp(CONTEXT(_thread))) { \
-	(_thread)->md.errcode = errno;  \
-	_PR_Schedule();		     \
-    }
-
-/*
-** Restore a thread context, saved by _MD_SWITCH_CONTEXT
-*/
-#define _MD_RESTORE_CONTEXT(_thread) \
-{				     \
-    errno = (_thread)->md.errcode;     \
-    _MD_SET_CURRENT_THREAD(_thread);	\
-    longjmp(CONTEXT(_thread), 1);    \
-}
-
-/* Machine-dependent (MD) data structures */
-
-struct _MDThread {
-    jmp_buf context;
-    int id;
-    int errcode;
-};
-
-struct _MDThreadStack {
-    PRInt8 notused;
-};
-
-struct _MDLock {
-    PRInt8 notused;
-};
-
-struct _MDSemaphore {
-    PRInt8 notused;
-};
-
-struct _MDCVar {
-    PRInt8 notused;
-};
-
-struct _MDSegment {
-    PRInt8 notused;
-};
-
-/*
- * md-specific cpu structure field
- */
-#define _PR_MD_MAX_OSFD FD_SETSIZE
-
-struct _MDCPU_Unix {
-    PRCList ioQ;
-    PRUint32 ioq_timeout;
-    PRInt32 ioq_max_osfd;
-    PRInt32 ioq_osfd_cnt;
-#ifndef _PR_USE_POLL
-    fd_set fd_read_set, fd_write_set, fd_exception_set;
-    PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD],
-				fd_exception_cnt[_PR_MD_MAX_OSFD];
-#else
-	struct pollfd *ioq_pollfds;
-	int ioq_pollfds_size;
-#endif	/* _PR_USE_POLL */
-};
-
-#define _PR_IOQ(_cpu)			((_cpu)->md.md_unix.ioQ)
-#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu))
-#define _PR_FD_READ_SET(_cpu)		((_cpu)->md.md_unix.fd_read_set)
-#define _PR_FD_READ_CNT(_cpu)		((_cpu)->md.md_unix.fd_read_cnt)
-#define _PR_FD_WRITE_SET(_cpu)		((_cpu)->md.md_unix.fd_write_set)
-#define _PR_FD_WRITE_CNT(_cpu)		((_cpu)->md.md_unix.fd_write_cnt)
-#define _PR_FD_EXCEPTION_SET(_cpu)	((_cpu)->md.md_unix.fd_exception_set)
-#define _PR_FD_EXCEPTION_CNT(_cpu)	((_cpu)->md.md_unix.fd_exception_cnt)
-#define _PR_IOQ_TIMEOUT(_cpu)		((_cpu)->md.md_unix.ioq_timeout)
-#define _PR_IOQ_MAX_OSFD(_cpu)		((_cpu)->md.md_unix.ioq_max_osfd)
-#define _PR_IOQ_OSFD_CNT(_cpu)		((_cpu)->md.md_unix.ioq_osfd_cnt)
-#define _PR_IOQ_POLLFDS(_cpu)		((_cpu)->md.md_unix.ioq_pollfds)
-#define _PR_IOQ_POLLFDS_SIZE(_cpu)	((_cpu)->md.md_unix.ioq_pollfds_size)
-
-#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu)	32
-
-struct _MDCPU {
-	struct _MDCPU_Unix md_unix;
-};
-
-#ifndef _PR_PTHREADS
-#define _MD_INIT_LOCKS()
-#endif
-#define _MD_NEW_LOCK(lock) PR_SUCCESS
-#define _MD_FREE_LOCK(lock)
-#define _MD_LOCK(lock)
-#define _MD_UNLOCK(lock)
-#define _MD_INIT_IO()
-#define _MD_IOQ_LOCK()
-#define _MD_IOQ_UNLOCK()
-
-/*
- * The following are copied from _sunos.h, _aix.h.  This means
- * some of them should probably be moved into _unixos.h.  But
- * _irix.h seems to be quite different in regard to these macros.
- */
-#define _MD_INTERVAL_USE_GTOD
-
-#define _MD_EARLY_INIT		_MD_EarlyInit
-#define _MD_FINAL_INIT		_PR_UnixInit
-#define _MD_INIT_RUNNING_CPU(cpu) _MD_unix_init_running_cpu(cpu)
-#define _MD_INIT_THREAD         _MD_InitializeThread
-#define _MD_EXIT_THREAD(thread)
-#define	_MD_SUSPEND_THREAD(thread)
-#define	_MD_RESUME_THREAD(thread)
-#define _MD_CLEAN_THREAD(_thread)
-
-/* The following defines unwrapped versions of select() and poll(). */
-#include <sys/time.h>
-extern int __select (int, fd_set *, fd_set *, fd_set *, struct timeval *);
-#define _MD_SELECT              __select
-
-#include <sys/poll.h>
-#define _MD_POLL __poll
-extern int __poll(struct pollfd filedes[], unsigned int nfds, int timeout);
-
-/*
- * Atomic operations
- */
-#ifdef OSF1_HAVE_MACHINE_BUILTINS_H
-#include <machine/builtins.h>
-#define _PR_HAVE_ATOMIC_OPS
-#define _MD_INIT_ATOMIC()
-#define _MD_ATOMIC_INCREMENT(val) (__ATOMIC_INCREMENT_LONG(val) + 1)
-#define _MD_ATOMIC_ADD(ptr, val)  (__ATOMIC_ADD_LONG(ptr, val) + val)
-#define _MD_ATOMIC_DECREMENT(val) (__ATOMIC_DECREMENT_LONG(val) - 1)
-#define _MD_ATOMIC_SET(val, newval) __ATOMIC_EXCH_LONG(val, newval)
-#endif /* OSF1_HAVE_MACHINE_BUILTINS_H */
-
-#endif /* nspr_osf1_defs_h___ */
--- a/nsprpub/pr/include/md/_pth.h
+++ b/nsprpub/pr/include/md/_pth.h
@@ -79,22 +79,22 @@
  *   (one should be able to read a pointer with a single machine
  *   instruction).  However, PR_GetCurrentThread calls calloc if
  *   it is called by a thread that was not created by NSPR.  The
  *   malloc tracing tools in the Mozilla client use PRMonitor for
  *   locking in their malloc, calloc, and free functions.  If
  *   PR_EnterMonitor calls any of these functions, infinite
  *   recursion ensues.
  */
-#if defined(IRIX) || defined(OSF1) || defined(AIX) || defined(SOLARIS) \
+#if defined(AIX) || defined(SOLARIS) \
 	|| defined(LINUX) || defined(__GNU__) || defined(__GLIBC__) \
 	|| defined(HPUX) || defined(FREEBSD) \
 	|| defined(NETBSD) || defined(OPENBSD) || defined(BSDI) \
 	|| defined(NTO) || defined(DARWIN) \
-	|| defined(UNIXWARE) || defined(RISCOS)	|| defined(SYMBIAN)
+	|| defined(UNIXWARE) || defined(RISCOS)
 #define _PT_PTHREAD_INVALIDATE_THR_HANDLE(t)  (t) = 0
 #define _PT_PTHREAD_THR_HANDLE_IS_INVALID(t)  (t) == 0
 #define _PT_PTHREAD_COPY_THR_HANDLE(st, dt)   (dt) = (st)
 #else 
 #error "pthreads is not supported for this architecture"
 #endif
 
 #if defined(_PR_PTHREADS)
@@ -111,41 +111,34 @@
 
 /*
  * These platforms don't have sigtimedwait()
  */
 #if (defined(AIX) && !defined(AIX4_3_PLUS)) \
 	|| defined(LINUX) || defined(__GNU__)|| defined(__GLIBC__) \
 	|| defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) \
 	|| defined(BSDI) || defined(UNIXWARE) \
-	|| defined(DARWIN) || defined(SYMBIAN)
+	|| defined(DARWIN)
 #define PT_NO_SIGTIMEDWAIT
 #endif
 
-#if defined(OSF1)
-#define PT_PRIO_MIN            PRI_OTHER_MIN
-#define PT_PRIO_MAX            PRI_OTHER_MAX
-#elif defined(IRIX)
-#include <sys/sched.h>
-#define PT_PRIO_MIN            PX_PRIO_MIN
-#define PT_PRIO_MAX            PX_PRIO_MAX
-#elif defined(AIX)
+#if defined(AIX)
 #include <sys/priv.h>
 #include <sys/sched.h>
 #ifndef PTHREAD_CREATE_JOINABLE
 #define PTHREAD_CREATE_JOINABLE     PTHREAD_CREATE_UNDETACHED
 #endif
 #define PT_PRIO_MIN            DEFAULT_PRIO
 #define PT_PRIO_MAX            DEFAULT_PRIO
 #elif defined(HPUX)
 #include <sys/sched.h>
 #define PT_PRIO_MIN            sched_get_priority_min(SCHED_OTHER)
 #define PT_PRIO_MAX            sched_get_priority_max(SCHED_OTHER)
 #elif defined(LINUX) || defined(__GNU__) || defined(__GLIBC__) \
-	|| defined(FREEBSD) || defined(SYMBIAN)
+	|| defined(FREEBSD)
 #define PT_PRIO_MIN            sched_get_priority_min(SCHED_OTHER)
 #define PT_PRIO_MAX            sched_get_priority_max(SCHED_OTHER)
 #elif defined(NTO)
 /*
  * Neutrino has functions that return the priority range but
  * they return invalid numbers, so I just hard coded these here
  * for now.  Jerry.Kirk@Nexarecorp.com
  */
@@ -172,36 +165,22 @@
 #error "pthreads is not supported for this architecture"
 #endif
 
 /*
  * The _PT_PTHREAD_YIELD function is called from a signal handler.
  * Needed for garbage collection -- Look at PR_Suspend/PR_Resume
  * implementation.
  */
-#if defined(OSF1)
-/*
- * sched_yield can't be called from a signal handler.  Must use
- * the _np version.
- */
-#define _PT_PTHREAD_YIELD()            	pthread_yield_np()
-#elif defined(AIX)
+#if defined(AIX)
 extern int (*_PT_aix_yield_fcn)();
 #define _PT_PTHREAD_YIELD()			(*_PT_aix_yield_fcn)()
-#elif defined(IRIX)
-#include <time.h>
-#define _PT_PTHREAD_YIELD() \
-    PR_BEGIN_MACRO               				\
-		struct timespec onemillisec = {0};		\
-		onemillisec.tv_nsec = 1000000L;			\
-        nanosleep(&onemillisec,NULL);			\
-    PR_END_MACRO
 #elif defined(HPUX) || defined(SOLARIS) \
 	|| defined(LINUX) || defined(__GNU__) || defined(__GLIBC__) \
 	|| defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) \
 	|| defined(BSDI) || defined(NTO) || defined(DARWIN) \
-	|| defined(UNIXWARE) || defined(RISCOS) || defined(SYMBIAN)
+	|| defined(UNIXWARE) || defined(RISCOS)
 #define _PT_PTHREAD_YIELD()            	sched_yield()
 #else
 #error "Need to define _PT_PTHREAD_YIELD for this platform"
 #endif
 
 #endif /* nspr_pth_defs_h_ */
deleted file mode 100644
--- a/nsprpub/pr/include/md/_symbian.cfg
+++ /dev/null
@@ -1,170 +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_cpucfg___
-#define nspr_cpucfg___
-
-#ifndef XP_UNIX
-#define XP_UNIX
-#endif
-
-#ifndef SYMBIAN
-#define SYMBIAN
-#endif
-
-#define PR_AF_INET6 0x0806  /* same as AF_INET6 */
-
-#ifdef __arm__
-
-#define IS_LITTLE_ENDIAN 1
-#undef  IS_BIG_ENDIAN
-
-#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_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_FLOAT   4
-#define PR_ALIGN_OF_POINTER 4
-#define PR_ALIGN_OF_WORD    4
-#define PR_ALIGN_OF_INT64   8
-#define PR_ALIGN_OF_DOUBLE  8
-
-#define PR_BYTES_PER_WORD_LOG2   2
-#define PR_BYTES_PER_DWORD_LOG2  3
-
-#elif defined(__WINS__)
-
-#define IS_LITTLE_ENDIAN 1
-#undef  IS_BIG_ENDIAN
-
-#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_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_FLOAT   4
-#define PR_ALIGN_OF_POINTER 4
-#define PR_ALIGN_OF_WORD    4
-#define PR_ALIGN_OF_INT64   4
-#define PR_ALIGN_OF_DOUBLE  4
-
-#define PR_BYTES_PER_WORD_LOG2   2
-#define PR_BYTES_PER_DWORD_LOG2  3
-
-#else
-
-#error "Unknown CPU architecture"
-
-#endif
-
-#ifndef HAVE_LONG_LONG
-#define	HAVE_LONG_LONG
-#endif
-#if PR_ALIGN_OF_DOUBLE == 8
-#define HAVE_ALIGNED_DOUBLES
-#endif
-#if PR_ALIGN_OF_INT64 == 8
-#define HAVE_ALIGNED_LONGLONGS
-#endif
-
-#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/_symbian.h
+++ /dev/null
@@ -1,50 +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_symbian_defs_h___
-#define nspr_symbian_defs_h___
-
-#include "prthread.h"
-
-/*
- * Internal configuration macros
- */
-
-#define _PR_SI_SYSNAME  "SYMBIAN"
-#if defined(__WINS__)
-#define _PR_SI_ARCHITECTURE "i386"
-#elif defined(__arm__)
-#define _PR_SI_ARCHITECTURE "arm"
-#else
-#error "Unknown CPU architecture"
-#endif
-#define PR_DLL_SUFFIX		".dll"
-
-#undef	HAVE_STACK_GROWING_UP
-
-#ifdef DYNAMIC_LIBRARY
-#define HAVE_DLL
-#define USE_DLFCN
-#endif
-
-#define _PR_STAT_HAS_ONLY_ST_ATIME
-#define _PR_NO_LARGE_FILES
-#define _PR_HAVE_SYSV_SEMAPHORES
-#define PR_HAVE_SYSV_NAMED_SHARED_MEMORY
-
-#ifndef _PR_PTHREADS
-#error "Classic NSPR is not implemented"
-#endif
-
-extern void _MD_EarlyInit(void);
-
-#define _MD_EARLY_INIT                  _MD_EarlyInit
-#define _MD_FINAL_INIT                  _PR_UnixInit
-#define _MD_INTERVAL_USE_GTOD
-
-/* For writev() */
-#include <sys/uio.h>
-
-#endif /* nspr_symbian_defs_h___ */
--- a/nsprpub/pr/include/md/_unixos.h
+++ b/nsprpub/pr/include/md/_unixos.h
@@ -41,23 +41,21 @@
  *
  * fd_set is defined in <sys/types.h>.  Usually
  * <sys/time.h> includes <sys/types.h>, but on some
  * older systems <sys/time.h> does not include
  * <sys/types.h>, so we include it explicitly.
  */
 #include <sys/time.h>
 #include <sys/types.h>
-#if defined(AIX) || defined(SYMBIAN)
+#if defined(AIX)
 #include <sys/select.h>
 #endif
 
-#ifndef SYMBIAN
 #define HAVE_NETINET_TCP_H
-#endif
 
 #define _PR_HAVE_O_APPEND
 
 #define PR_DIRECTORY_SEPARATOR		'/'
 #define PR_DIRECTORY_SEPARATOR_STR	"/"
 #define PR_PATH_SEPARATOR		':'
 #define PR_PATH_SEPARATOR_STR		":"
 typedef int (*FARPROC)();
@@ -256,19 +254,17 @@ extern void		_MD_Wakeup_CPUs(void);
 #define _MD_WAKEUP_CPUS _MD_Wakeup_CPUs
 
 #define _MD_PAUSE_CPU			_MD_PauseCPU
 
 #if defined(_PR_LOCAL_THREADS_ONLY) || defined(_PR_GLOBAL_THREADS_ONLY)
 #define _MD_CLEANUP_BEFORE_EXIT()
 #endif
 
-#ifndef IRIX
 #define _MD_EXIT(status)		_exit(status)
-#endif
 
 /************************************************************************/
 
 #define _MD_GET_ENV				getenv
 #define _MD_PUT_ENV				putenv
 
 /************************************************************************/
 
--- a/nsprpub/pr/include/md/prosdep.h
+++ b/nsprpub/pr/include/md/prosdep.h
@@ -44,68 +44,51 @@ PR_BEGIN_EXTERN_C
 #include "md/_openbsd.h"
 
 #elif defined(BSDI)
 #include "md/_bsdi.h"
 
 #elif defined(HPUX)
 #include "md/_hpux.h"
 
-#elif defined(IRIX)
-#include "md/_irix.h"
-
 #elif defined(LINUX) || defined(__GNU__) || defined(__GLIBC__)
 #include "md/_linux.h"
 
-#elif defined(OSF1)
-#include "md/_osf1.h"
-
 #elif defined(DARWIN)
 #include "md/_darwin.h"
 
 #elif defined(SOLARIS)
 #include "md/_solaris.h"
 
 #elif defined(SCO)
 #include "md/_scoos.h"
 
 #elif defined(UNIXWARE)
 #include "md/_unixware.h"
 
-#elif defined(DGUX)
-#include "md/_dgux.h"
-
 #elif defined(QNX)
 #include "md/_qnx.h"
 
 #elif defined(NTO)
 #include "md/_nto.h"
 
 #elif defined(RISCOS)
 #include "md/_riscos.h"
 
-#elif defined(SYMBIAN)
-#include "md/_symbian.h"
-
 #else
 #error unknown Unix flavor
 
 #endif
 
 #include "md/_unixos.h"
 #include "md/_unix_errors.h"
 
-#elif defined(XP_BEOS)
-
-#include "md/_beos.h"
-#include "md/_unix_errors.h"
-
 #else
 
-#error "The platform is not BeOS, Unix, Windows, or Mac"
+#error "The platform is not Unix, Windows, or Mac"
 
 #endif
 
 #ifdef _PR_PTHREADS
 #include "md/_pth.h"
 #endif
 
 PR_END_EXTERN_C
--- a/nsprpub/pr/include/obsolete/protypes.h
+++ b/nsprpub/pr/include/obsolete/protypes.h
@@ -23,24 +23,16 @@ typedef PRIntn intn;
  * int32, uint32, int64, and uint64 because some of these int
  * types are defined by standard header files on some platforms.
  * Our strategy here is to include all such standard headers
  * first, and then define these int types only if they are not
  * defined by those standard headers.
  */
 
 /*
- * BeOS defines all the int types below in its standard header
- * file SupportDefs.h.
- */
-#ifdef XP_BEOS
-#include <support/SupportDefs.h>
-#endif
-
-/*
  * SVR4 typedef of uint is commonly found on UNIX machines.
  *
  * On AIX 4.3, sys/inttypes.h (which is included by sys/types.h)
  * defines the types int8, int16, int32, and int64.
  *
  * On OS/2, sys/types.h defines uint.
  */
 #if defined(XP_UNIX) || defined(XP_OS2)
@@ -51,91 +43,83 @@ typedef PRIntn intn;
 #ifdef HPUX
 #include <model.h>
 #endif
 
 /*
  * uint
  */
 
-#if !defined(XP_BEOS) && !defined(XP_OS2) && !defined(XP_UNIX) || defined(NTO)
+#if !defined(XP_OS2) && !defined(XP_UNIX) || defined(NTO)
 typedef PRUintn uint;
 #endif
 
 /*
  * uint64
  */
 
-#if !defined(XP_BEOS)
 typedef PRUint64 uint64;
-#endif
 
 /*
  * uint32
  */
 
-#if !defined(XP_BEOS)
 #if !defined(_WIN32) && !defined(XP_OS2) && !defined(NTO)
 typedef PRUint32 uint32;
 #else
 typedef unsigned long uint32;
 #endif
-#endif
 
 /*
  * uint16
  */
 
-#if !defined(XP_BEOS)
 typedef PRUint16 uint16;
-#endif
 
 /*
  * uint8
  */
 
-#if !defined(XP_BEOS)
 typedef PRUint8 uint8;
-#endif
 
 /*
  * int64
  */
 
-#if !defined(XP_BEOS) && !defined(_PR_AIX_HAVE_BSD_INT_TYPES)
+#if !defined(_PR_AIX_HAVE_BSD_INT_TYPES)
 typedef PRInt64 int64;
 #endif
 
 /*
  * int32
  */
 
-#if !defined(XP_BEOS) && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \
+#if !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \
     && !defined(HPUX)
 #if !defined(_WIN32) && !defined(XP_OS2) && !defined(NTO)
 typedef PRInt32 int32;
 #else
 typedef long int32;
 #endif
 #endif
 
 /*
  * int16
  */
 
-#if !defined(XP_BEOS) && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \
+#if !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \
     && !defined(HPUX)
 typedef PRInt16 int16;
 #endif
 
 /*
  * int8
  */
 
-#if !defined(XP_BEOS) && !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \
+#if !defined(_PR_AIX_HAVE_BSD_INT_TYPES) \
     && !defined(HPUX)
 typedef PRInt8 int8;
 #endif
 
 typedef PRFloat64 float64;
 typedef PRUptrdiff uptrdiff_t;
 typedef PRUword uprword_t;
 typedef PRWord prword_t;
--- a/nsprpub/pr/include/prinet.h
+++ b/nsprpub/pr/include/prinet.h
@@ -27,17 +27,17 @@
  *        depend on it to pull in the system header files you need.
  *     2. WARNING: This file is no longer cross-platform as it is a no-op
  *        for WIN32!  See the comment in the WIN32 section for details.
  */
 
 #ifndef prinet_h__
 #define prinet_h__
 
-#if defined(XP_UNIX) || defined(XP_OS2) || defined(XP_BEOS)
+#if defined(XP_UNIX) || defined(XP_OS2)
 #include <sys/types.h>
 #include <sys/socket.h>		/* AF_INET */
 #include <netinet/in.h>         /* INADDR_ANY, ..., ntohl(), ... */
 #ifdef XP_OS2
 #include <sys/ioctl.h>
 #endif
 #ifdef XP_UNIX
 #ifdef AIX
@@ -65,17 +65,17 @@ struct sockaddr_dl;
 #if defined(OS2) && !defined(INADDR_LOOPBACK)
 #define INADDR_LOOPBACK 0x7f000001
 #endif
 
 /*
  * Prototypes of ntohl() etc. are declared in <machine/endian.h>
  * on these platforms.
  */
-#if defined(BSDI) || defined(OSF1)
+#if defined(BSDI)
 #include <machine/endian.h>
 #endif
 
 /* On Android, ntohl() etc. are declared in <sys/endian.h>. */
 #ifdef __ANDROID__
 #include <sys/endian.h>
 #endif
 
--- a/nsprpub/pr/include/prinit.h
+++ b/nsprpub/pr/include/prinit.h
@@ -26,21 +26,21 @@ PR_BEGIN_EXTERN_C
 /*
 ** NSPR's version is used to determine the likelihood that the version you
 ** used to build your component is anywhere close to being compatible with
 ** what is in the underlying library.
 **
 ** The format of the version string is
 **     "<major version>.<minor version>[.<patch level>] [<Beta>]"
 */
-#define PR_VERSION  "4.21"
+#define PR_VERSION  "4.22 Beta"
 #define PR_VMAJOR   4
-#define PR_VMINOR   21
+#define PR_VMINOR   22
 #define PR_VPATCH   0
-#define PR_BETA     PR_FALSE
+#define PR_BETA     PR_TRUE
 
 /*
 ** PRVersionCheck
 **
 ** The basic signature of the function that is called to provide version
 ** checking. The result will be a boolean that indicates the likelihood
 ** that the underling library will perform as the caller expects.
 **
--- a/nsprpub/pr/include/prio.h
+++ b/nsprpub/pr/include/prio.h
@@ -140,31 +140,23 @@ struct PRIPv6Addr {
 #define pr_s6_addr32	_S6_un._S6_u32
 #define pr_s6_addr64 	_S6_un._S6_u64
 
 typedef struct PRIPv6Addr PRIPv6Addr;
 
 union PRNetAddr {
     struct {
         PRUint16 family;                /* address family (0x00ff maskable) */
-#ifdef XP_BEOS
-        char data[10];                  /* Be has a smaller structure */
-#else
         char data[14];                  /* raw address data */
-#endif
     } raw;
     struct {
         PRUint16 family;                /* address family (AF_INET) */
         PRUint16 port;                  /* port number */
         PRUint32 ip;                    /* The actual 32 bits of address */
-#ifdef XP_BEOS
-        char pad[4];                    /* Be has a smaller structure */
-#else
         char pad[8];
-#endif
     } inet;
     struct {
         PRUint16 family;                /* address family (AF_INET6) */
         PRUint16 port;                  /* port number */
         PRUint32 flowinfo;              /* routing information */
         PRIPv6Addr ip;                  /* the actual 128 bits of address */
         PRUint32 scope_id;              /* set of interfaces for a scope */
     } ipv6;
--- a/nsprpub/pr/include/private/pprthred.h
+++ b/nsprpub/pr/include/private/pprthred.h
@@ -278,36 +278,16 @@ NSPR_API(PRIntn) PR_GetMonitorEntryCount
 ** Just like PR_CEnterMonitor except that if the monitor is owned by
 ** another thread NULL is returned.
 */
 NSPR_API(PRMonitor*) PR_CTestAndEnterMonitor(void *address);
 
 /*---------------------------------------------------------------------------
 ** PLATFORM-SPECIFIC INITIALIZATION FUNCTIONS
 ---------------------------------------------------------------------------*/
-#if defined(IRIX)
-/*
-** Irix specific initialization funtion to be called before PR_Init
-** is called by the application. Sets the CONF_INITUSERS and CONF_INITSIZE
-** attributes of the shared arena set up by nspr.
-**
-** The environment variables _NSPR_IRIX_INITUSERS and _NSPR_IRIX_INITSIZE
-** can also be used to set these arena attributes. If _NSPR_IRIX_INITUSERS
-** is set, but not _NSPR_IRIX_INITSIZE, the value of the CONF_INITSIZE
-** attribute of the nspr arena is scaled as a function of the
-** _NSPR_IRIX_INITUSERS value.
-** 
-** If the _PR_Irix_Set_Arena_Params() is called in addition to setting the
-** environment variables, the values of the environment variables are used.
-** 
-*/
-NSPR_API(void) _PR_Irix_Set_Arena_Params(PRInt32 initusers, PRInt32 initsize);
-
-#endif /* IRIX */
-
 #if defined(XP_OS2)
 /*
 ** These functions need to be called at the start and end of a thread.
 ** An EXCEPTIONREGISTRATIONRECORD must be declared on the stack and its
 ** address passed to the two functions.
 */
 NSPR_API(void) PR_OS2_SetFloatExcpHandler(EXCEPTIONREGISTRATIONRECORD* e);
 NSPR_API(void) PR_OS2_UnsetFloatExcpHandler(EXCEPTIONREGISTRATIONRECORD* e);
--- a/nsprpub/pr/include/private/primpl.h
+++ b/nsprpub/pr/include/private/primpl.h
@@ -5,20 +5,16 @@
 
 #ifndef primpl_h___
 #define primpl_h___
 
 #if defined(_PR_PTHREADS)
 #include <pthread.h>
 #endif
 
-#if defined(_PR_BTHREADS)
-#include <kernel/OS.h>
-#endif
-
 #ifdef WIN32
 /*
  * Allow use of functions and symbols first defined in Win2k.
  */
 #if !defined(WINVER) || (WINVER < 0x0500)
 #undef WINVER
 #define WINVER 0x0500
 #endif
@@ -269,17 +265,17 @@ typedef struct _PRInterruptTable {
     const char *name;
     PRUintn missed_bit;
     void (*handler)(void);
 } _PRInterruptTable;
 
 #define _PR_CPU_PTR(_qp) \
     ((_PRCPU*) ((char*) (_qp) - offsetof(_PRCPU,links)))
 
-#if !defined(IRIX) && !defined(WIN32) && !defined(XP_OS2) \
+#if !defined(WIN32) && !defined(XP_OS2) \
         && !(defined(SOLARIS) && defined(_PR_GLOBAL_THREADS_ONLY))
 #define _MD_GET_ATTACHED_THREAD()        (_PR_MD_CURRENT_THREAD())
 #endif
 
 #ifdef _PR_LOCAL_THREADS_ONLY 
 
 NSPR_API(struct _PRCPU *)              _pr_currentCPU;
 NSPR_API(PRThread *)                   _pr_currentThread;
@@ -943,20 +939,16 @@ extern void _PR_MD_END_SUSPEND_ALL(void)
 #define    _PR_MD_END_SUSPEND_ALL _MD_END_SUSPEND_ALL
 
 extern void _PR_MD_BEGIN_RESUME_ALL(void);
 #define    _PR_MD_BEGIN_RESUME_ALL _MD_BEGIN_RESUME_ALL
 
 extern void _PR_MD_END_RESUME_ALL(void);
 #define    _PR_MD_END_RESUME_ALL _MD_END_RESUME_ALL
 
-#if defined(IRIX) 
-NSPR_API(void) _PR_IRIX_CHILD_PROCESS(void);
-#endif        /* IRIX */
-
 #endif        /* !_PR_LOCAL_THREADS_ONLY */
 
 extern void _PR_MD_CLEAN_THREAD(PRThread *thread);
 #define    _PR_MD_CLEAN_THREAD _MD_CLEAN_THREAD
 
 #ifdef HAVE_CUSTOM_USER_THREADS
 extern void _PR_MD_CREATE_PRIMORDIAL_USER_THREAD(PRThread *);
 #define    _PR_MD_CREATE_PRIMORDIAL_USER_THREAD _MD_CREATE_PRIMORDIAL_USER_THREAD
@@ -2135,33 +2127,16 @@ extern void _PR_MD_QUERY_FD_INHERITABLE(
 /* --- PR_GetRandomNoise() related things --- */
 
 extern PRSize _PR_MD_GetRandomNoise( void *buf, PRSize size );
 #define _PR_MD_GET_RANDOM_NOISE(buf,size) _PR_MD_GetRandomNoise((buf),(size))
 extern PRSize _pr_CopyLowBits( void *dest, PRSize dstlen, void *src, PRSize srclen );
 
 /* end PR_GetRandomNoise() related */
 
-#ifdef XP_BEOS
-
-extern PRLock *_connectLock;
-
-typedef struct _ConnectListNode {
-	PRInt32		osfd;
-	PRNetAddr	addr;
-	PRUint32	addrlen;
-	PRIntervalTime	timeout;
-} ConnectListNode;
-
-extern ConnectListNode connectList[64];
-
-extern PRUint32 connectCount;
-
-#endif /* XP_BEOS */
-
 #if defined(_WIN64) && defined(WIN95)
 typedef struct _PRFileDescList {
   PRFileDesc *fd;
   struct _PRFileDescList *next;
 } PRFileDescList;
 
 extern PRLock *_fd_waiting_for_overlapped_done_lock;
 extern PRFileDescList *_fd_waiting_for_overlapped_done;
--- a/nsprpub/pr/include/prnetdb.h
+++ b/nsprpub/pr/include/prnetdb.h
@@ -42,17 +42,17 @@ typedef struct PRHostEnt {
 #else
     PRInt32 h_addrtype; /* host address type */
     PRInt32 h_length;   /* length of address */
 #endif
     char **h_addr_list; /* list of addresses from name server */
 } PRHostEnt;
 
 /* A safe size to use that will mostly work... */
-#if (defined(AIX) && defined(_THREAD_SAFE)) || defined(OSF1)
+#if (defined(AIX) && defined(_THREAD_SAFE))
 #define PR_NETDB_BUF_SIZE sizeof(struct protoent_data)
 #else
 #define PR_NETDB_BUF_SIZE 1024
 #endif
 
 /***********************************************************************
 ** FUNCTION:	
 ** DESCRIPTION:	PR_GetHostByName()
--- a/nsprpub/pr/include/prtypes.h
+++ b/nsprpub/pr/include/prtypes.h
@@ -59,69 +59,32 @@
 #define PR_IMPLEMENT(__type) __declspec(dllexport) __type
 #define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type
 #define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type
 
 #define PR_CALLBACK
 #define PR_CALLBACK_DECL
 #define PR_STATIC_CALLBACK(__x) static __x
 
-#elif defined(XP_BEOS)
-
-#define PR_EXPORT(__type) extern __declspec(dllexport) __type
-#define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type
-#define PR_IMPORT(__type) extern __declspec(dllexport) __type
-#define PR_IMPORT_DATA(__type) extern __declspec(dllexport) __type
-
-#define PR_EXTERN(__type) extern __declspec(dllexport) __type
-#define PR_IMPLEMENT(__type) __declspec(dllexport) __type
-#define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type
-#define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type
-
-#define PR_CALLBACK
-#define PR_CALLBACK_DECL
-#define PR_STATIC_CALLBACK(__x) static __x
-
 #elif defined(XP_OS2) && defined(__declspec)
 
 #define PR_EXPORT(__type) extern __declspec(dllexport) __type
 #define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type
 #define PR_IMPORT(__type) extern  __declspec(dllimport) __type
 #define PR_IMPORT_DATA(__type) extern __declspec(dllimport) __type
 
 #define PR_EXTERN(__type) extern __declspec(dllexport) __type
 #define PR_IMPLEMENT(__type) __declspec(dllexport) __type
 #define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type
 #define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type
 
 #define PR_CALLBACK
 #define PR_CALLBACK_DECL
 #define PR_STATIC_CALLBACK(__x) static __x
 
-#elif defined(SYMBIAN)
-
-#define PR_EXPORT(__type) extern __declspec(dllexport) __type
-#define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type
-#ifdef __WINS__
-#define PR_IMPORT(__type) extern __declspec(dllexport) __type
-#define PR_IMPORT_DATA(__type) extern __declspec(dllexport) __type
-#else
-#define PR_IMPORT(__type) extern __declspec(dllimport) __type
-#define PR_IMPORT_DATA(__type) extern __declspec(dllimport) __type
-#endif
-
-#define PR_EXTERN(__type) extern __type
-#define PR_IMPLEMENT(__type) __type
-#define PR_EXTERN_DATA(__type) extern __type
-#define PR_IMPLEMENT_DATA(__type) __type
-
-#define PR_CALLBACK
-#define PR_CALLBACK_DECL
-#define PR_STATIC_CALLBACK(__x) static __x
-
 #else /* Unix */
 
 /* GCC 3.3 and later support the visibility attribute. */
 #if (__GNUC__ >= 4) || \
     (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
 #define PR_VISIBILITY_DEFAULT __attribute__((visibility("default")))
 #else
 #define PR_VISIBILITY_DEFAULT
--- a/nsprpub/pr/src/Makefile.in
+++ b/nsprpub/pr/src/Makefile.in
@@ -61,23 +61,16 @@ OS_LIBS			= -lsocket -lnsl -ldl -lc
 endif	# USE_PTHREADS
 ifeq ($(CPU_ARCH),sparc)
 ifndef USE_64
 DSO_LDOPTS	+= -Wl,-f,\$$ORIGIN/cpu/\$$ISALIST/lib$(ULTRASPARC_LIBRARY)$(LIBRARY_VERSION).so
 endif
 endif	# sparc
 endif	# SunOS
 
-ifeq ($(OS_ARCH), IRIX)
-ifeq ($(USE_PTHREADS), 1)
-OS_LIBS = -lpthread
-endif
-OS_LIBS += -lc
-endif
-
 ifeq ($(OS_ARCH),AIX)
 DSO_LDOPTS	+= -binitfini::_PR_Fini
 OS_LIBS		= -lodm -lcfg
 ifeq ($(CLASSIC_NSPR),1)
 ifeq ($(OS_RELEASE),4.1)
 OS_LIBS		+= -lsvld -lc
 else
 OS_LIBS		+= -ldl -lc
@@ -104,25 +97,16 @@ endif
 
 ifeq ($(OS_ARCH),OS2)
 MAPFILE = $(OBJDIR)/$(LIBRARY_NAME)$(LIBRARY_VERSION).def
 ADD_TO_DEF_FILE = cat $(srcdir)/os2extra.def >> $(MAPFILE)
 GARBAGE += $(MAPFILE)
 MKSHLIB += $(MAPFILE)
 endif
 
-ifeq ($(OS_ARCH),OSF1)
-ifeq ($(USE_PTHREADS), 1)
-OS_LIBS 	= -lpthread -lrt
-endif
-ifneq ($(OS_RELEASE),V2.0)
-OS_LIBS		+= -lc_r
-endif
-endif
-
 # Linux, GNU/Hurd, and GNU/kFreeBSD systems
 ifneq (,$(filter Linux GNU%,$(OS_ARCH)))
 ifeq ($(USE_PTHREADS), 1)
 ifeq ($(OS_TARGET),Android)
 # Android has no libpthread.so in NDK
 OS_LIBS		= -ldl
 else
 OS_LIBS		= -lpthread -ldl
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/.cvsignore
+++ /dev/null
@@ -1,1 +0,0 @@
-Makefile
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/Makefile.in
+++ /dev/null
@@ -1,31 +0,0 @@
-# 
-# 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/.
-
-
-#! gmake
-
-MOD_DEPTH	= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(MOD_DEPTH)/config/autoconf.mk
-
-include $(topsrcdir)/config/config.mk
-
-include $(srcdir)/bsrcs.mk
-CSRCS += $(BTCSRCS)
-
-TARGETS	= $(OBJS)
-
-INCLUDES = -I$(dist_includedir) -I$(topsrcdir)/pr/include -I$(topsrcdir)/pr/include/private
-
-include $(topsrcdir)/config/rules.mk
-
-DEFINES		+= -D_NSPR_BUILD_
-
-export:: $(TARGETS)
-
-
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/bsrcs.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# 
-# 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/.
-
-# this file lists the source files to be compiled (used in Makefile) and
-# then enumerated as object files (in objs.mk) for inclusion in the NSPR
-# shared library
-
-BTCSRCS = \
-	btthread.c \
-	btlocks.c \
-	btcvar.c \
-	btmon.c \
-	btsem.c \
-	btmisc.c \
-	$(NULL)
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/btcvar.c
+++ /dev/null
@@ -1,244 +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/. */
-
-#include <kernel/OS.h>
-
-#include "primpl.h"
-
-/*
-** Create a new condition variable.
-**
-** 	"lock" is the lock used to protect the condition variable.
-**
-** Condition variables are synchronization objects that threads can use
-** to wait for some condition to occur.
-**
-** This may fail if memory is tight or if some operating system resource
-** is low. In such cases, a NULL will be returned.
-*/
-PR_IMPLEMENT(PRCondVar*)
-    PR_NewCondVar (PRLock *lock)
-{
-    PRCondVar *cv = PR_NEW( PRCondVar );
-    PR_ASSERT( NULL != lock );
-    if( NULL != cv )
-    {
-	cv->lock = lock;
-	cv->sem = create_sem(0, "CVSem");
-	cv->handshakeSem = create_sem(0, "CVHandshake");
-	cv->signalSem = create_sem( 0, "CVSignal");
-	cv->signalBenCount = 0;
-	cv->ns = cv->nw = 0;
-	PR_ASSERT( cv->sem >= B_NO_ERROR );
-	PR_ASSERT( cv->handshakeSem >= B_NO_ERROR );
-	PR_ASSERT( cv->signalSem >= B_NO_ERROR );
-    }
-    return cv;
-} /* PR_NewCondVar */
-
-/*
-** Destroy a condition variable. There must be no thread
-** waiting on the condvar. The caller is responsible for guaranteeing
-** that the condvar is no longer in use.
-**
-*/
-PR_IMPLEMENT(void)
-    PR_DestroyCondVar (PRCondVar *cvar)
-{
-    status_t result = delete_sem( cvar->sem );
-    PR_ASSERT( result == B_NO_ERROR );
-    
-    result = delete_sem( cvar->handshakeSem );
-    PR_ASSERT( result == B_NO_ERROR );
-
-    result = delete_sem( cvar->signalSem );
-    PR_ASSERT( result == B_NO_ERROR );
-
-    PR_DELETE( cvar );
-}
-
-/*
-** The thread that waits on a condition is blocked in a "waiting on
-** condition" state until another thread notifies the condition or a
-** caller specified amount of time expires. The lock associated with
-** the condition variable will be released, which must have be held
-** prior to the call to wait.
-**
-** Logically a notified thread is moved from the "waiting on condition"
-** state and made "ready." When scheduled, it will attempt to reacquire
-** the lock that it held when wait was called.
-**
-** The timeout has two well known values, PR_INTERVAL_NO_TIMEOUT and
-** PR_INTERVAL_NO_WAIT. The former value requires that a condition be
-** notified (or the thread interrupted) before it will resume from the
-** wait. If the timeout has a value of PR_INTERVAL_NO_WAIT, the effect
-** is to release the lock, possibly causing a rescheduling within the
-** runtime, then immediately attempting to reacquire the lock and resume.
-**
-** Any other value for timeout will cause the thread to be rescheduled
-** either due to explicit notification or an expired interval. The latter
-** must be determined by treating time as one part of the monitored data
-** being protected by the lock and tested explicitly for an expired
-** interval.
-**
-** Returns PR_FAILURE if the caller has not locked the lock associated
-** with the condition variable or the thread was interrupted (PR_Interrupt()).
-** The particular reason can be extracted with PR_GetError().
-*/
-PR_IMPLEMENT(PRStatus)
-    PR_WaitCondVar (PRCondVar *cvar, PRIntervalTime timeout)
-{
-    status_t err;
-    if( timeout == PR_INTERVAL_NO_WAIT ) 
-    {
-        PR_Unlock( cvar->lock );
-        PR_Lock( cvar->lock );
-        return PR_SUCCESS;
-    }
-
-    if( atomic_add( &cvar->signalBenCount, 1 ) > 0 ) 
-    {
-        if (acquire_sem(cvar->signalSem) == B_INTERRUPTED) 
-        {
-            atomic_add( &cvar->signalBenCount, -1 );
-            return PR_FAILURE;
-        }
-    }
-    cvar->nw += 1;
-    if( atomic_add( &cvar->signalBenCount, -1 ) > 1 ) 
-    {
-        release_sem_etc(cvar->signalSem, 1, B_DO_NOT_RESCHEDULE);
-    }
-
-    PR_Unlock( cvar->lock );
-    if( timeout==PR_INTERVAL_NO_TIMEOUT ) 
-    {
-    	err = acquire_sem(cvar->sem);
-    } 
-    else 
-    {
-    	err = acquire_sem_etc(cvar->sem, 1, B_RELATIVE_TIMEOUT, PR_IntervalToMicroseconds(timeout) );
-    }
-
-    if( atomic_add( &cvar->signalBenCount, 1 ) > 0 ) 
-    {
-        while (acquire_sem(cvar->signalSem) == B_INTERRUPTED);
-    }
-
-    if (cvar->ns > 0)
-    {
-        release_sem_etc(cvar->handshakeSem, 1, B_DO_NOT_RESCHEDULE);
-        cvar->ns -= 1;
-    }
-    cvar->nw -= 1;
-    if( atomic_add( &cvar->signalBenCount, -1 ) > 1 ) 
-    {
-        release_sem_etc(cvar->signalSem, 1, B_DO_NOT_RESCHEDULE);
-    }
-
-    PR_Lock( cvar->lock );
-    if(err!=B_NO_ERROR) 
-    {
-        return PR_FAILURE;
-    }
-    return PR_SUCCESS;
-}
-
-/*
-** Notify ONE thread that is currently waiting on 'cvar'. Which thread is
-** dependent on the implementation of the runtime. Common sense would dictate
-** that all threads waiting on a single condition have identical semantics,
-** therefore which one gets notified is not significant. 
-**
-** The calling thead must hold the lock that protects the condition, as
-** well as the invariants that are tightly bound to the condition, when
-** notify is called.
-**
-** Returns PR_FAILURE if the caller has not locked the lock associated
-** with the condition variable.
-*/
-PR_IMPLEMENT(PRStatus)
-    PR_NotifyCondVar (PRCondVar *cvar)
-{
-    status_t err ;
-    if( atomic_add( &cvar->signalBenCount, 1 ) > 0 ) 
-    {
-        if (acquire_sem(cvar->signalSem) == B_INTERRUPTED) 
-        {
-            atomic_add( &cvar->signalBenCount, -1 );
-            return PR_FAILURE;
-        }
-    }
-    if (cvar->nw > cvar->ns)
-    {
-        cvar->ns += 1;
-        release_sem_etc(cvar->sem, 1, B_DO_NOT_RESCHEDULE);
-        if( atomic_add( &cvar->signalBenCount, -1 ) > 1 ) 
-        {
-            release_sem_etc(cvar->signalSem, 1, B_DO_NOT_RESCHEDULE);
-        }
-
-        while (acquire_sem(cvar->handshakeSem) == B_INTERRUPTED) 
-        {
-            err = B_INTERRUPTED; 
-        }
-    }
-    else
-    {
-        if( atomic_add( &cvar->signalBenCount, -1 ) > 1 )
-        {
-            release_sem_etc(cvar->signalSem, 1, B_DO_NOT_RESCHEDULE);
-        }
-    }
-    return PR_SUCCESS; 
-}
-
-/*
-** Notify all of the threads waiting on the condition variable. The order
-** that the threads are notified is indeterminant. The lock that protects
-** the condition must be held.
-**
-** Returns PR_FAILURE if the caller has not locked the lock associated
-** with the condition variable.
-*/
-PR_IMPLEMENT(PRStatus)
-    PR_NotifyAllCondVar (PRCondVar *cvar)
-{
-    int32 handshakes;
-    status_t err = B_OK;
-
-    if( atomic_add( &cvar->signalBenCount, 1 ) > 0 ) 
-    {
-        if (acquire_sem(cvar->signalSem) == B_INTERRUPTED) 
-        {
-            atomic_add( &cvar->signalBenCount, -1 );
-            return PR_FAILURE;
-        }
-    }
-
-    if (cvar->nw > cvar->ns)
-    {
-        handshakes = cvar->nw - cvar->ns;
-        cvar->ns = cvar->nw;				
-        release_sem_etc(cvar->sem, handshakes, B_DO_NOT_RESCHEDULE);	
-        if( atomic_add( &cvar->signalBenCount, -1 ) > 1 ) 
-        {
-            release_sem_etc(cvar->signalSem, 1, B_DO_NOT_RESCHEDULE);
-        }
-
-        while (acquire_sem_etc(cvar->handshakeSem, handshakes, 0, 0) == B_INTERRUPTED) 
-        {
-            err = B_INTERRUPTED; 
-        }
-    }
-    else
-    {
-        if( atomic_add( &cvar->signalBenCount, -1 ) > 1 ) 
-        {
-            release_sem_etc(cvar->signalSem, 1, B_DO_NOT_RESCHEDULE);
-        }
-    }
-    return PR_SUCCESS;
-}
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/btlocks.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/* -*- Mode: C++; 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/. */
-
-/*
-** File:        btlocks.c
-** Description: Implemenation for thread locks using bthreads
-** Exports:     prlock.h
-*/
-
-#include "primpl.h"
-
-#include <string.h>
-#include <sys/time.h>
-
-void
-_PR_InitLocks (void)
-{
-}
-
-PR_IMPLEMENT(PRLock*)
-    PR_NewLock (void)
-{
-    PRLock *lock;
-    status_t semresult;
-
-    if (!_pr_initialized) _PR_ImplicitInitialization();
-
-    lock = PR_NEWZAP(PRLock);
-    if (lock != NULL) {
-
-	lock->benaphoreCount = 0;
-	lock->semaphoreID = create_sem( 0, "nsprLockSem" );
-	if( lock->semaphoreID < B_NO_ERROR ) {
-
-	    PR_DELETE( lock );
-	    lock = NULL;
-	}
-    }
-
-    return lock;
-}
-
-PR_IMPLEMENT(void)
-    PR_DestroyLock (PRLock* lock)
-{
-    status_t result;
-
-    PR_ASSERT(NULL != lock);
-    result = delete_sem(lock->semaphoreID);
-    PR_ASSERT(result == B_NO_ERROR);
-    PR_DELETE(lock);
-}
-
-PR_IMPLEMENT(void)
-    PR_Lock (PRLock* lock)
-{
-    PR_ASSERT(lock != NULL);
-
-    if( atomic_add( &lock->benaphoreCount, 1 ) > 0 ) {
-
-	if( acquire_sem(lock->semaphoreID ) != B_NO_ERROR ) {
-
-	    atomic_add( &lock->benaphoreCount, -1 );
-	    return;
-	}
-    }
-
-    lock->owner = find_thread( NULL );
-}
-
-PR_IMPLEMENT(PRStatus)
-    PR_Unlock (PRLock* lock)
-{
-    PR_ASSERT(lock != NULL);
-    lock->owner = NULL;
-    if( atomic_add( &lock->benaphoreCount, -1 ) > 1 ) {
-
-	release_sem_etc( lock->semaphoreID, 1, B_DO_NOT_RESCHEDULE );
-    }
-
-    return PR_SUCCESS;
-}
-
-PR_IMPLEMENT(void)
-    PR_AssertCurrentThreadOwnsLock(PRLock *lock)
-{
-    PR_ASSERT(lock != NULL);
-    PR_ASSERT(lock->owner == find_thread( NULL ));
-}
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/btmisc.c
+++ /dev/null
@@ -1,72 +0,0 @@
-/* -*- Mode: C++; 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/. */
-
-#include "primpl.h"
-#include <stdio.h>
-
-// void _PR_InitCPUs(void) {PT_LOG("_PR_InitCPUs")}
-// void _MD_StartInterrupts(void) {PT_LOG("_MD_StartInterrupts")}
-
-/* this is a total hack.. */
-
-struct protoent* getprotobyname(const char* name)
-{
-    return 0;
-}
-
-struct protoent* getprotobynumber(int number)
-{
-    return 0;
-}
-
-/* this is needed by prinit for some reason */
-void
-_PR_InitStacks (void)
-{
-}
-
-/* this is needed by prinit for some reason */
-void
-_PR_InitTPD (void)
-{
-}
-
-/*
-** Create extra virtual processor threads. Generally used with MP systems.
-*/
-PR_IMPLEMENT(void)
-    PR_SetConcurrency (PRUintn numCPUs)
-{
-}
-
-/*
-** Set thread recycle mode to on (1) or off (0)
-*/
-PR_IMPLEMENT(void)
-    PR_SetThreadRecycleMode (PRUint32 flag)
-{
-}
-
-/*
-** Get context registers, return with error for now.
-*/
-
-PR_IMPLEMENT(PRWord *)
-_MD_HomeGCRegisters( PRThread *t, int isCurrent, int *np )
-{
-     return 0;
-}
-
-PR_IMPLEMENT(void *)
-PR_GetSP( PRThread *t )
-{
-    return 0;
-}
-
-PR_IMPLEMENT(PRStatus)
-PR_EnumerateThreads( PREnumerator func, void *arg )
-{
-    return PR_FAILURE;
-}
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/btmon.c
+++ /dev/null
@@ -1,201 +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/. */
-
-#include <kernel/OS.h>
-
-#include "primpl.h"
-
-/*
-** Create a new monitor. Monitors are re-entrant locks with a single built-in
-** condition variable.
-**
-** This may fail if memory is tight or if some operating system resource
-** is low.
-*/
-PR_IMPLEMENT(PRMonitor*)
-    PR_NewMonitor (void)
-{
-    PRMonitor *mon;
-    PRCondVar *cvar;
-    PRLock    *lock;
-
-    mon = PR_NEWZAP( PRMonitor );
-    if( mon )
-    {
-	lock = PR_NewLock();
-	if( !lock )
-        {
-	    PR_DELETE( mon );
-	    return( 0 );
-	}
-
-	cvar = PR_NewCondVar( lock );
-	if( !cvar )
-	{
-	    PR_DestroyLock( lock );
-	    PR_DELETE( mon );
-	    return( 0 );
-	}
-
-	mon->cvar = cvar;
-	mon->name = NULL;
-    }
-
-    return( mon );
-}
-
-PR_IMPLEMENT(PRMonitor*) PR_NewNamedMonitor(const char* name)
-{
-    PRMonitor* mon = PR_NewMonitor();
-    if( mon )
-    {
-        mon->name = name;
-    }
-    return mon;
-}
-
-/*
-** Destroy a monitor. The caller is responsible for guaranteeing that the
-** monitor is no longer in use. There must be no thread waiting on the
-** monitor's condition variable and that the lock is not held.
-**
-*/
-PR_IMPLEMENT(void)
-    PR_DestroyMonitor (PRMonitor *mon)
-{
-    PR_DestroyLock( mon->cvar->lock );
-    PR_DestroyCondVar( mon->cvar );
-    PR_DELETE( mon );
-}
-
-/*
-** Enter the lock associated with the monitor. If the calling thread currently
-** is in the monitor, the call to enter will silently succeed. In either case,
-** it will increment the entry count by one.
-*/
-PR_IMPLEMENT(void)
-    PR_EnterMonitor (PRMonitor *mon)
-{
-    if( mon->cvar->lock->owner == find_thread( NULL ) )
-    {
-	mon->entryCount++;
-
-    } else
-    {
-	PR_Lock( mon->cvar->lock );
-	mon->entryCount = 1;
-    }
-}
-
-/*
-** Decrement the entry count associated with the monitor. If the decremented
-** entry count is zero, the monitor is exited. Returns PR_FAILURE if the
-** calling thread has not entered the monitor.
-*/
-PR_IMPLEMENT(PRStatus)
-    PR_ExitMonitor (PRMonitor *mon)
-{
-    if( mon->cvar->lock->owner != find_thread( NULL ) )
-    {
-	return( PR_FAILURE );
-    }
-    if( --mon->entryCount == 0 )
-    {
-	return( PR_Unlock( mon->cvar->lock ) );
-    }
-    return( PR_SUCCESS );
-}
-
-/*
-** Wait for a notify on the monitor's condition variable. Sleep for "ticks"
-** amount of time (if "ticks" is PR_INTERVAL_NO_TIMEOUT then the sleep is
-** indefinite).
-**
-** While the thread is waiting it exits the monitor (as if it called
-** PR_ExitMonitor as many times as it had called PR_EnterMonitor).  When
-** the wait has finished the thread regains control of the monitors lock
-** with the same entry count as before the wait began.
-**
-** The thread waiting on the monitor will be resumed when the monitor is
-** notified (assuming the thread is the next in line to receive the
-** notify) or when the "ticks" timeout elapses.
-**
-** Returns PR_FAILURE if the caller has not entered the monitor.
-*/
-PR_IMPLEMENT(PRStatus)
-    PR_Wait (PRMonitor *mon, PRIntervalTime ticks)
-{
-    PRUint32 entryCount;
-    PRUintn  status;
-    PRThread *meThread;
-    thread_id me = find_thread( NULL );
-    meThread = PR_GetCurrentThread();
-
-    if( mon->cvar->lock->owner != me ) return( PR_FAILURE );
-
-    entryCount = mon->entryCount;
-    mon->entryCount = 0;
-
-    status = PR_WaitCondVar( mon->cvar, ticks );
-
-    mon->entryCount = entryCount;
-
-    return( status );
-}
-
-/*
-** Notify a thread waiting on the monitor's condition variable. If a thread
-** is waiting on the condition variable (using PR_Wait) then it is awakened
-** and attempts to reenter the monitor.
-*/
-PR_IMPLEMENT(PRStatus)
-    PR_Notify (PRMonitor *mon)
-{
-    if( mon->cvar->lock->owner != find_thread( NULL ) )
-    {
-	return( PR_FAILURE );
-    }
-
-    PR_NotifyCondVar( mon->cvar );
-    return( PR_SUCCESS );
-}
-
-/*
-** Notify all of the threads waiting on the monitor's condition variable.
-** All of threads waiting on the condition are scheduled to reenter the
-** monitor.
-*/
-PR_IMPLEMENT(PRStatus)
-    PR_NotifyAll (PRMonitor *mon)
-{
-    if( mon->cvar->lock->owner != find_thread( NULL ) )
-    {
-	return( PR_FAILURE );
-    }
-
-    PR_NotifyAllCondVar( mon->cvar );
-    return( PR_SUCCESS );
-}
-
-/*
-** Return the number of times that the current thread has entered the
-** lock. Returns zero if the current thread has not entered the lock.
-*/
-PR_IMPLEMENT(PRIntn)
-    PR_GetMonitorEntryCount(PRMonitor *mon)
-{
-    return( (mon->cvar->lock->owner == find_thread( NULL )) ?
-            mon->entryCount : 0 );
-}
-
-/*
-** If the current thread is in |mon|, this assertion is guaranteed to
-** succeed.  Otherwise, the behavior of this function is undefined.
-*/
-PR_IMPLEMENT(void)
-    PR_AssertCurrentThreadInMonitor(PRMonitor *mon)
-{
-    PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(mon->cvar->lock);
-}
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/btsem.c
+++ /dev/null
@@ -1,98 +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/. */
-
-#include <kernel/OS.h>
-
-#include "primpl.h"
-
-/*
-** Create a new semaphore object.
-*/
-PR_IMPLEMENT(PRSemaphore*)
-    PR_NewSem (PRUintn value)
-{
-	PRSemaphore *semaphore;
-
-	if (!_pr_initialized) _PR_ImplicitInitialization();
-
-	semaphore = PR_NEWZAP(PRSemaphore);
-	if (NULL != semaphore) {
-		if ((semaphore->sem = create_sem(value, "nspr_sem")) < B_NO_ERROR)
-			return NULL;
-		else 
-			return semaphore;
-	}
-	return NULL;
-}
-
-/*
-** Destroy the given semaphore object.
-**
-*/
-PR_IMPLEMENT(void)
-    PR_DestroySem (PRSemaphore *sem)
-{
-	status_t result;
-
-	PR_ASSERT(sem != NULL);
-	result = delete_sem(sem->sem);
-	PR_ASSERT(result == B_NO_ERROR);
-	PR_DELETE(sem);
-} 
-
-/*
-** Wait on a Semaphore.
-** 
-** This routine allows a calling thread to wait or proceed depending upon
-** the state of the semahore sem. The thread can proceed only if the
-** counter value of the semaphore sem is currently greater than 0. If the
-** value of semaphore sem is positive, it is decremented by one and the
-** routine returns immediately allowing the calling thread to continue. If
-** the value of semaphore sem is 0, the calling thread blocks awaiting the
-** semaphore to be released by another thread.
-** 
-** This routine can return PR_PENDING_INTERRUPT if the waiting thread 
-** has been interrupted.
-*/
-PR_IMPLEMENT(PRStatus)
-    PR_WaitSem (PRSemaphore *sem)
-{
-	PR_ASSERT(sem != NULL);
-	if (acquire_sem(sem->sem) == B_NO_ERROR)
-		return PR_SUCCESS;
-	else
-		return PR_FAILURE;
-}
-
-/*
-** This routine increments the counter value of the semaphore. If other
-** threads are blocked for the semaphore, then the scheduler will
-** determine which ONE thread will be unblocked.
-*/
-PR_IMPLEMENT(void)
-    PR_PostSem (PRSemaphore *sem)
-{
-	status_t result;
-
-	PR_ASSERT(sem != NULL);
-	result = release_sem_etc(sem->sem, 1, B_DO_NOT_RESCHEDULE);
-	PR_ASSERT(result == B_NO_ERROR);
-}
-
-/*
-** Returns the value of the semaphore referenced by sem without affecting
-** the state of the semaphore.  The value represents the semaphore value
-** at the time of the call, but may not be the actual value when the
-** caller inspects it.
-*/
-PR_IMPLEMENT(PRUintn)
-    PR_GetValueSem (PRSemaphore *sem)
-{
-	sem_info	info;
-
-	PR_ASSERT(sem != NULL);
-	get_sem_info(sem->sem, &info);
-	return info.count;
-}
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/btthread.c
+++ /dev/null
@@ -1,662 +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/. */
-
-#include <kernel/OS.h>
-#include <support/TLS.h>
-
-#include "prlog.h"
-#include "primpl.h"
-#include "prcvar.h"
-#include "prpdce.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-
-/* values for PRThread.state */
-#define BT_THREAD_PRIMORD   0x01    /* this is the primordial thread */
-#define BT_THREAD_SYSTEM    0x02    /* this is a system thread */
-#define BT_THREAD_JOINABLE  0x04	/* this is a joinable thread */
-
-struct _BT_Bookeeping
-{
-    PRLock *ml;                 /* a lock to protect ourselves */
-	sem_id cleanUpSem;		/* the primoridal thread will block on this
-							   sem while waiting for the user threads */
-    PRInt32 threadCount;	/* user thred count */
-
-} bt_book = { NULL, B_ERROR, 0 };
-
-
-#define BT_TPD_LIMIT 128	/* number of TPD slots we'll provide (arbitrary) */
-
-/* these will be used to map an index returned by PR_NewThreadPrivateIndex()
-   to the corresponding beos native TLS slot number, and to the destructor
-   for that slot - note that, because it is allocated globally, this data
-   will be automatically zeroed for us when the program begins */
-static int32 tpd_beosTLSSlots[BT_TPD_LIMIT];
-static PRThreadPrivateDTOR tpd_dtors[BT_TPD_LIMIT];
-
-static vint32 tpd_slotsUsed=0;	/* number of currently-allocated TPD slots */
-static int32 tls_prThreadSlot;	/* TLS slot in which PRThread will be stored */
-
-/* this mutex will be used to synchronize access to every
-   PRThread.md.joinSem and PRThread.md.is_joining (we could
-   actually allocate one per thread, but that seems a bit excessive,
-   especially considering that there will probably be little
-   contention, PR_JoinThread() is allowed to block anyway, and the code
-   protected by the mutex is short/fast) */
-static PRLock *joinSemLock;
-
-static PRUint32 _bt_MapNSPRToNativePriority( PRThreadPriority priority );
-static PRThreadPriority _bt_MapNativeToNSPRPriority( PRUint32 priority );
-static void _bt_CleanupThread(void *arg);
-static PRThread *_bt_AttachThread();
-
-void
-_PR_InitThreads (PRThreadType type, PRThreadPriority priority,
-                 PRUintn maxPTDs)
-{
-    PRThread *primordialThread;
-    PRUint32  beThreadPriority;
-
-	/* allocate joinSem mutex */
-	joinSemLock = PR_NewLock();
-	if (joinSemLock == NULL)
-	{
-		PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
-		return;
-    }
-
-    /*
-    ** Create and initialize NSPR structure for our primordial thread.
-    */
-    
-    primordialThread = PR_NEWZAP(PRThread);
-    if( NULL == primordialThread )
-    {
-        PR_SetError( PR_OUT_OF_MEMORY_ERROR, 0 );
-        return;
-    }
-
-	primordialThread->md.joinSem = B_ERROR;
-
-    /*
-    ** Set the priority to the desired level.
-    */
-
-    beThreadPriority = _bt_MapNSPRToNativePriority( priority );
-    
-    set_thread_priority( find_thread( NULL ), beThreadPriority );
-    
-    primordialThread->priority = priority;
-
-
-	/* set the thread's state - note that the thread is not joinable */
-    primordialThread->state |= BT_THREAD_PRIMORD;
-	if (type == PR_SYSTEM_THREAD)
-		primordialThread->state |= BT_THREAD_SYSTEM;
-
-    /*
-    ** Allocate a TLS slot for the PRThread structure (just using
-    ** native TLS, as opposed to NSPR TPD, will make PR_GetCurrentThread()
-    ** somewhat faster, and will leave one more TPD slot for our client)
-    */
-	
-	tls_prThreadSlot = tls_allocate();
-
-    /*
-    ** Stuff our new PRThread structure into our thread specific
-    ** slot.
-    */
-
-	tls_set(tls_prThreadSlot, primordialThread);
-    
-	/* allocate lock for bt_book */
-    bt_book.ml = PR_NewLock();
-    if( NULL == bt_book.ml )
-    {
-    	PR_SetError( PR_OUT_OF_MEMORY_ERROR, 0 );
-	return;
-    }
-}
-
-PRUint32
-_bt_MapNSPRToNativePriority( PRThreadPriority priority )
-    {
-    switch( priority )
-    {
-    	case PR_PRIORITY_LOW:	 return( B_LOW_PRIORITY );
-	case PR_PRIORITY_NORMAL: return( B_NORMAL_PRIORITY );
-	case PR_PRIORITY_HIGH:	 return( B_DISPLAY_PRIORITY );
-	case PR_PRIORITY_URGENT: return( B_URGENT_DISPLAY_PRIORITY );
-	default:		 return( B_NORMAL_PRIORITY );
-    }
-}
-
-PRThreadPriority
-_bt_MapNativeToNSPRPriority(PRUint32 priority)
-    {
-	if (priority < B_NORMAL_PRIORITY)
-		return PR_PRIORITY_LOW;
-	if (priority < B_DISPLAY_PRIORITY)
-		return PR_PRIORITY_NORMAL;
-	if (priority < B_URGENT_DISPLAY_PRIORITY)
-		return PR_PRIORITY_HIGH;
-	return PR_PRIORITY_URGENT;
-}
-
-PRUint32
-_bt_mapNativeToNSPRPriority( int32 priority )
-{
-    switch( priority )
-    {
-    	case PR_PRIORITY_LOW:	 return( B_LOW_PRIORITY );
-	case PR_PRIORITY_NORMAL: return( B_NORMAL_PRIORITY );
-	case PR_PRIORITY_HIGH:	 return( B_DISPLAY_PRIORITY );
-	case PR_PRIORITY_URGENT: return( B_URGENT_DISPLAY_PRIORITY );
-	default:		 return( B_NORMAL_PRIORITY );
-    }
-}
-
-/* This method is called by all NSPR threads as they exit */
-void _bt_CleanupThread(void *arg)
-{
-	PRThread *me = PR_GetCurrentThread();
-	int32 i;
-
-	/* first, clean up all thread-private data */
-	for (i = 0; i < tpd_slotsUsed; i++)
-	{
-		void *oldValue = tls_get(tpd_beosTLSSlots[i]);
-		if ( oldValue != NULL && tpd_dtors[i] != NULL )
-			(*tpd_dtors[i])(oldValue);
-	}
-
-	/* if this thread is joinable, wait for someone to join it */
-	if (me->state & BT_THREAD_JOINABLE)
-	{
-		/* protect access to our joinSem */
-		PR_Lock(joinSemLock);
-
-		if (me->md.is_joining)
-		{
-			/* someone is already waiting to join us (they've
-			   allocated a joinSem for us) - let them know we're
-			   ready */
-			delete_sem(me->md.joinSem);
-
-			PR_Unlock(joinSemLock);
-
-		}
-		else
-    {
-			/* noone is currently waiting for our demise - it
-			   is our responsibility to allocate the joinSem
-			   and block on it */
-			me->md.joinSem = create_sem(0, "join sem");
-
-			/* we're done accessing our joinSem */
-			PR_Unlock(joinSemLock);
-
-			/* wait for someone to join us */
-			while (acquire_sem(me->md.joinSem) == B_INTERRUPTED);
-	    }
-	}
-
-	/* if this is a user thread, we must update our books */
-	if ((me->state & BT_THREAD_SYSTEM) == 0)
-	{
-		/* synchronize access to bt_book */
-    PR_Lock( bt_book.ml );
-
-		/* decrement the number of currently-alive user threads */
-	bt_book.threadCount--;
-
-		if (bt_book.threadCount == 0 && bt_book.cleanUpSem != B_ERROR) {
-			/* we are the last user thread, and the primordial thread is
-			   blocked in PR_Cleanup() waiting for us to finish - notify
-			   it */
-			delete_sem(bt_book.cleanUpSem);
-	}
-
-    PR_Unlock( bt_book.ml );
-	}
-
-	/* finally, delete this thread's PRThread */
-	PR_DELETE(me);
-}
-
-/**
- * This is a wrapper that all threads invoke that allows us to set some
- * things up prior to a thread's invocation and clean up after a thread has
- * exited.
- */
-static void*
-_bt_root (void* arg)
-	{
-    PRThread *thred = (PRThread*)arg;
-    PRIntn rv;
-    void *privData;
-    status_t result;
-    int i;
-
-	/* save our PRThread object into our TLS */
-	tls_set(tls_prThreadSlot, thred);
-
-    thred->startFunc(thred->arg);  /* run the dang thing */
-
-	/* clean up */
-	_bt_CleanupThread(NULL);
-
-	return 0;
-}
-
-PR_IMPLEMENT(PRThread*)
-    PR_CreateThread (PRThreadType type, void (*start)(void* arg), void* arg,
-                     PRThreadPriority priority, PRThreadScope scope,
-                     PRThreadState state, PRUint32 stackSize)
-{
-    PRUint32 bePriority;
-
-    PRThread* thred;
-
-    if (!_pr_initialized) _PR_ImplicitInitialization();
-
-	thred = PR_NEWZAP(PRThread);
- 	if (thred == NULL)
-	{
-        PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
-        return NULL;
-    }
-
-    thred->md.joinSem = B_ERROR;
-
-        thred->arg = arg;
-        thred->startFunc = start;
-        thred->priority = priority;
-
-	if( state == PR_JOINABLE_THREAD )
-	{
-	    thred->state |= BT_THREAD_JOINABLE;
-	}
-
-        /* keep some books */
-
-	PR_Lock( bt_book.ml );
-
-	if (type == PR_USER_THREAD)
-	{
-	    bt_book.threadCount++;
-        }
-
-	PR_Unlock( bt_book.ml );
-
-	bePriority = _bt_MapNSPRToNativePriority( priority );
-
-        thred->md.tid = spawn_thread((thread_func)_bt_root, "moz-thread",
-                                     bePriority, thred);
-        if (thred->md.tid < B_OK) {
-            PR_SetError(PR_UNKNOWN_ERROR, thred->md.tid);
-            PR_DELETE(thred);
-			return NULL;
-        }
-
-        if (resume_thread(thred->md.tid) < B_OK) {
-            PR_SetError(PR_UNKNOWN_ERROR, 0);
-            PR_DELETE(thred);
-			return NULL;
-        }
-
-    return thred;
-    }
-
-PR_IMPLEMENT(PRThread*)
-	PR_AttachThread(PRThreadType type, PRThreadPriority priority,
-					PRThreadStack *stack)
-{
-	/* PR_GetCurrentThread() will attach a thread if necessary */
-	return PR_GetCurrentThread();
-}
-
-PR_IMPLEMENT(void)
-	PR_DetachThread()
-{
-	/* we don't support detaching */
-}
-
-PR_IMPLEMENT(PRStatus)
-    PR_JoinThread (PRThread* thred)
-{
-    status_t eval, status;
-
-    PR_ASSERT(thred != NULL);
-
-	if ((thred->state & BT_THREAD_JOINABLE) == 0)
-    {
-	PR_SetError( PR_INVALID_ARGUMENT_ERROR, 0 );
-	return( PR_FAILURE );
-    }
-
-	/* synchronize access to the thread's joinSem */
-	PR_Lock(joinSemLock);
-	
-	if (thred->md.is_joining)
-	{
-		/* another thread is already waiting to join the specified
-		   thread - we must fail */
-		PR_Unlock(joinSemLock);
-		return PR_FAILURE;
-	}
-
-	/* let others know we are waiting to join */
-	thred->md.is_joining = PR_TRUE;
-
-	if (thred->md.joinSem == B_ERROR)
-	{
-		/* the thread hasn't finished yet - it is our responsibility to
-		   allocate a joinSem and wait on it */
-		thred->md.joinSem = create_sem(0, "join sem");
-
-		/* we're done changing the joinSem now */
-		PR_Unlock(joinSemLock);
-
-		/* wait for the thread to finish */
-		while (acquire_sem(thred->md.joinSem) == B_INTERRUPTED);
-
-	}
-	else
-	{
-		/* the thread has already finished, and has allocated the
-		   joinSem itself - let it know it can finally die */
-		delete_sem(thred->md.joinSem);
-		
-		PR_Unlock(joinSemLock);
-    }
-
-	/* make sure the thread is dead */
-    wait_for_thread(thred->md.tid, &eval);
-
-    return PR_SUCCESS;
-}
-
-PR_IMPLEMENT(PRThread*)
-    PR_GetCurrentThread ()
-{
-    PRThread* thred;
-
-    if (!_pr_initialized) _PR_ImplicitInitialization();
-
-    thred = (PRThread *)tls_get( tls_prThreadSlot);
-	if (thred == NULL)
-	{
-		/* this thread doesn't have a PRThread structure (it must be
-		   a native thread not created by the NSPR) - assimilate it */
-		thred = _bt_AttachThread();
-	}
-    PR_ASSERT(NULL != thred);
-
-    return thred;
-}
-
-PR_IMPLEMENT(PRThreadScope)
-    PR_GetThreadScope (const PRThread* thred)
-{
-    PR_ASSERT(thred != NULL);
-    return PR_GLOBAL_THREAD;
-}
-
-PR_IMPLEMENT(PRThreadType)
-    PR_GetThreadType (const PRThread* thred)
-{
-    PR_ASSERT(thred != NULL);
-    return (thred->state & BT_THREAD_SYSTEM) ?
-        PR_SYSTEM_THREAD : PR_USER_THREAD;
-}
-
-PR_IMPLEMENT(PRThreadState)
-    PR_GetThreadState (const PRThread* thred)
-{
-    PR_ASSERT(thred != NULL);
-    return (thred->state & BT_THREAD_JOINABLE)?
-    					PR_JOINABLE_THREAD: PR_UNJOINABLE_THREAD;
-}
-
-PR_IMPLEMENT(PRThreadPriority)
-    PR_GetThreadPriority (const PRThread* thred)
-{
-    PR_ASSERT(thred != NULL);
-    return thred->priority;
-}  /* PR_GetThreadPriority */
-
-PR_IMPLEMENT(void) PR_SetThreadPriority(PRThread *thred,
-                                        PRThreadPriority newPri)
-{
-    PRUint32 bePriority;
-
-    PR_ASSERT( thred != NULL );
-
-    thred->priority = newPri;
-    bePriority = _bt_MapNSPRToNativePriority( newPri );
-    set_thread_priority( thred->md.tid, bePriority );
-}
-
-PR_IMPLEMENT(PRStatus)
-    PR_NewThreadPrivateIndex (PRUintn* newIndex,
-                              PRThreadPrivateDTOR destructor)
-{
-	int32    index;
-
-    if (!_pr_initialized) _PR_ImplicitInitialization();
-
-	/* reserve the next available tpd slot */
-	index = atomic_add( &tpd_slotsUsed, 1 );
-	if (index >= BT_TPD_LIMIT)
-	{
-		/* no slots left - decrement value, then fail */
-		atomic_add( &tpd_slotsUsed, -1 );
-		PR_SetError( PR_TPD_RANGE_ERROR, 0 );
-	    return( PR_FAILURE );
-	}
-
-	/* allocate a beos-native TLS slot for this index (the new slot
-	   automatically contains NULL) */
-	tpd_beosTLSSlots[index] = tls_allocate();
-
-	/* remember the destructor */
-	tpd_dtors[index] = destructor;
-
-    *newIndex = (PRUintn)index;
-
-    return( PR_SUCCESS );
-}
-
-PR_IMPLEMENT(PRStatus)
-    PR_SetThreadPrivate (PRUintn index, void* priv)
-{
-	void *oldValue;
-
-    /*
-    ** Sanity checking
-    */
-
-    if(index < 0 || index >= tpd_slotsUsed || index >= BT_TPD_LIMIT)
-    {
-		PR_SetError( PR_TPD_RANGE_ERROR, 0 );
-	return( PR_FAILURE );
-    }
-
-	/* if the old value isn't NULL, and the dtor for this slot isn't
-	   NULL, we must destroy the data */
-	oldValue = tls_get(tpd_beosTLSSlots[index]);
-	if (oldValue != NULL && tpd_dtors[index] != NULL)
-		(*tpd_dtors[index])(oldValue);
-
-	/* save new value */
-	tls_set(tpd_beosTLSSlots[index], priv);
-
-	    return( PR_SUCCESS );
-	}
-
-PR_IMPLEMENT(void*)
-    PR_GetThreadPrivate (PRUintn index)
-{
-	/* make sure the index is valid */
-	if (index < 0 || index >= tpd_slotsUsed || index >= BT_TPD_LIMIT)
-    {   
-		PR_SetError( PR_TPD_RANGE_ERROR, 0 );
-		return NULL;
-    }
-
-	/* return the value */
-	return tls_get( tpd_beosTLSSlots[index] );
-	}
-
-
-PR_IMPLEMENT(PRStatus)
-    PR_Interrupt (PRThread* thred)
-{
-    PRIntn rv;
-
-    PR_ASSERT(thred != NULL);
-
-    /*
-    ** there seems to be a bug in beos R5 in which calling
-    ** resume_thread() on a blocked thread returns B_OK instead
-    ** of B_BAD_THREAD_STATE (beos bug #20000422-19095).  as such,
-    ** to interrupt a thread, we will simply suspend then resume it
-    ** (no longer call resume_thread(), check for B_BAD_THREAD_STATE,
-    ** the suspend/resume to wake up a blocked thread).  this wakes
-    ** up blocked threads properly, and doesn't hurt unblocked threads
-    ** (they simply get stopped then re-started immediately)
-    */
-
-    rv = suspend_thread( thred->md.tid );
-    if( rv != B_NO_ERROR )
-    {
-        /* this doesn't appear to be a valid thread_id */
-        PR_SetError( PR_UNKNOWN_ERROR, rv );
-        return PR_FAILURE;
-    }
-
-    rv = resume_thread( thred->md.tid );
-    if( rv != B_NO_ERROR )
-    {
-        PR_SetError( PR_UNKNOWN_ERROR, rv );
-        return PR_FAILURE;
-    }
-
-    return PR_SUCCESS;
-}
-
-PR_IMPLEMENT(void)
-    PR_ClearInterrupt ()
-{
-}
-
-PR_IMPLEMENT(PRStatus)
-    PR_Yield ()
-{
-    /* we just sleep for long enough to cause a reschedule (100
-       microseconds) */
-    snooze(100);
-}
-
-#define BT_MILLION 1000000UL
-
-PR_IMPLEMENT(PRStatus)
-    PR_Sleep (PRIntervalTime ticks)
-{
-    bigtime_t tps;
-    status_t status;
-
-    if (!_pr_initialized) _PR_ImplicitInitialization();
-
-    tps = PR_IntervalToMicroseconds( ticks );
-
-    status = snooze(tps);
-    if (status == B_NO_ERROR) return PR_SUCCESS;
-
-    PR_SetError(PR_NOT_IMPLEMENTED_ERROR, status);
-    return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-    PR_Cleanup ()
-{
-    PRThread *me = PR_GetCurrentThread();
-
-    PR_ASSERT(me->state & BT_THREAD_PRIMORD);
-    if ((me->state & BT_THREAD_PRIMORD) == 0) {
-        return PR_FAILURE;
-    }
-
-    PR_Lock( bt_book.ml );
-
-	if (bt_book.threadCount != 0)
-    {
-		/* we'll have to wait for some threads to finish - create a
-		   sem to block on */
-		bt_book.cleanUpSem = create_sem(0, "cleanup sem");
-    }
-
-    PR_Unlock( bt_book.ml );
-
-	/* note that, if all the user threads were already dead, we
-	   wouldn't have created a sem above, so this acquire_sem()
-	   will fail immediately */
-	while (acquire_sem(bt_book.cleanUpSem) == B_INTERRUPTED);
-
-    return PR_SUCCESS;
-}
-
-PR_IMPLEMENT(void)
-    PR_ProcessExit (PRIntn status)
-{
-    exit(status);
-}
-
-PRThread *_bt_AttachThread()
-{
-	PRThread *thread;
-	thread_info tInfo;
-
-	/* make sure this thread doesn't already have a PRThread structure */
-	PR_ASSERT(tls_get(tls_prThreadSlot) == NULL);
-
-	/* allocate a PRThread structure for this thread */
-	thread = PR_NEWZAP(PRThread);
-	if (thread == NULL)
-	{
-		PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
-		return NULL;
-	}
-
-	/* get the native thread's current state */
-	get_thread_info(find_thread(NULL), &tInfo);
-
-	/* initialize new PRThread */
-	thread->md.tid = tInfo.thread;
-	thread->md.joinSem = B_ERROR;
-	thread->priority = _bt_MapNativeToNSPRPriority(tInfo.priority);
-
-	/* attached threads are always non-joinable user threads */
-	thread->state = 0;
-
-	/* increment user thread count */
-	PR_Lock(bt_book.ml);
-	bt_book.threadCount++;
-	PR_Unlock(bt_book.ml);
-
-	/* store this thread's PRThread */
-	tls_set(tls_prThreadSlot, thread);
-	
-	/* the thread must call _bt_CleanupThread() before it dies, in order
-	   to clean up its PRThread, synchronize with the primordial thread,
-	   etc. */
-	on_exit_thread(_bt_CleanupThread, NULL);
-	
-	return thread;
-}
deleted file mode 100644
--- a/nsprpub/pr/src/bthreads/objs.mk
+++ /dev/null
@@ -1,11 +0,0 @@
-# 
-# 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/.
-
-# This makefile appends to the variable OBJS the bthread object modules
-# that will be part of the nspr20 library.
-
-include $(srcdir)/bthreads/bsrcs.mk
-
-OBJS += $(BTCSRCS:%.c=bthreads/$(OBJDIR)/%.$(OBJ_SUFFIX))
--- a/nsprpub/pr/src/cplus/tests/Makefile.in
+++ b/nsprpub/pr/src/cplus/tests/Makefile.in
@@ -44,34 +44,16 @@ TARGETS = $(PROGS) $(OBJS)
 INCLUDES = -I.. -I$(dist_includedir)
 
 # Setting the variables LDOPTS and LIBPR.  We first initialize
 # them to the default values, then adjust them for some platforms.
 LDOPTS = -L$(dist_libdir)
 LIBPR = -lnspr$(MOD_MAJOR_VERSION)
 LIBPL = -lplc$(MOD_MAJOR_VERSION)
 
-ifeq ($(OS_ARCH), IRIX)
-    LDOPTS += -rpath $(PWD)/$(dist_libdir) -rdata_shared
-    # For 6.x machines, include this flag
-    ifeq ($(basename $(OS_RELEASE)),6)
-        ifeq ($(USE_N32),1)
-            LDOPTS += -n32
-        else
-            LDOPTS += -32
-        endif
-
-        ifeq ($(USE_PTHREADS), 1)
-            ifeq ($(OS_RELEASE), 6.2)
-                LDOPTS += -Wl,-woff,85
-            endif
-        endif
-    endif
-endif
-
 # Solaris
 ifeq ($(OS_ARCH), SunOS)
     ifdef NS_USE_GCC
         LDOPTS += -Xlinker -R -Xlinker $(PWD)/$(dist_libdir)
     else
         LDOPTS += -R $(PWD)/$(dist_libdir)
     endif
 
@@ -98,20 +80,16 @@ endif
 ifeq ($(OS_ARCH),OS2)
 LDOPTS += -Zomf -Zlinker /PM:VIO -lstdcpp
 endif
 
 ifneq ($(OS_ARCH), WINNT)
 PWD = $(shell pwd)
 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/pr/src/io/prfile.c
+++ b/nsprpub/pr/src/io/prfile.c
@@ -383,19 +383,16 @@ PR_IMPLEMENT(PRInt32) PR_GetSysfdTableMa
     return 16384;
 #elif defined (WIN16)
     return FOPEN_MAX;
 #elif defined(XP_OS2)
     ULONG ulReqCount = 0;
     ULONG ulCurMaxFH = 0;
     DosSetRelMaxFH(&ulReqCount, &ulCurMaxFH);
     return ulCurMaxFH;
-#elif defined(XP_BEOS)
-    PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
-   return -1;
 #else
     write me;
 #endif
 }
 
 PR_IMPLEMENT(PRInt32) PR_SetSysfdTableSize(int table_size)
 {
 #if defined(XP_UNIX) && !defined(AIX) && !defined(QNX)
@@ -429,17 +426,17 @@ PR_IMPLEMENT(PRInt32) PR_SetSysfdTableSi
       rc = DosSetMaxFH(table_size);
       if (rc == NO_ERROR)
         return table_size;
       else
         return -1;
     } 
     return tableMax;
 #elif defined(AIX) || defined(QNX) \
-        || defined(WIN32) || defined(WIN16) || defined(XP_BEOS)
+        || defined(WIN32) || defined(WIN16)
     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
     return -1;
 #else
     write me;
 #endif
 }
 
 PR_IMPLEMENT(PRStatus) PR_Delete(const char *name)
@@ -687,17 +684,17 @@ PR_IMPLEMENT(PRStatus) PR_CreatePipe(
     }
 #ifdef WINNT
     (*readPipe)->secret->md.sync_file_io = PR_TRUE;
     (*writePipe)->secret->md.sync_file_io = PR_TRUE;
 #endif
     (*readPipe)->secret->inheritable = _PR_TRI_TRUE;
     (*writePipe)->secret->inheritable = _PR_TRI_TRUE;
     return PR_SUCCESS;
-#elif defined(XP_UNIX) || defined(XP_OS2) || defined(XP_BEOS)
+#elif defined(XP_UNIX) || defined(XP_OS2)
 #ifdef XP_OS2
     HFILE pipefd[2];
 #else
     int pipefd[2];
 #endif
 
     if (!_pr_initialized) _PR_ImplicitInitialization();
 
@@ -717,23 +714,19 @@ PR_IMPLEMENT(PRStatus) PR_CreatePipe(
         return PR_FAILURE;
     }
     *writePipe = PR_AllocFileDesc(pipefd[1], &_pr_pipeMethods);
     if (NULL == *writePipe) {
         PR_Close(*readPipe);
         close(pipefd[1]);
         return PR_FAILURE;
     }
-#ifndef XP_BEOS /* Pipes are nonblocking on BeOS */
     _PR_MD_MAKE_NONBLOCK(*readPipe);
-#endif
     _PR_MD_INIT_FD_INHERITABLE(*readPipe, PR_FALSE);
-#ifndef XP_BEOS /* Pipes are nonblocking on BeOS */
     _PR_MD_MAKE_NONBLOCK(*writePipe);
-#endif
     _PR_MD_INIT_FD_INHERITABLE(*writePipe, PR_FALSE);
     return PR_SUCCESS;
 #else
     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
     return PR_FAILURE;
 #endif
 }
 
--- a/nsprpub/pr/src/io/prio.c
+++ b/nsprpub/pr/src/io/prio.c
@@ -218,17 +218,17 @@ PR_IMPLEMENT(PRInt32) PR_Poll(PRPollDesc
 
 /*
 ** Set the inheritance attribute of a file descriptor.
 */
 PR_IMPLEMENT(PRStatus) PR_SetFDInheritable(
     PRFileDesc *fd,
     PRBool inheritable)
 {
-#if defined(XP_UNIX) || defined(WIN32) || defined(XP_OS2) || defined(XP_BEOS)
+#if defined(XP_UNIX) || defined(WIN32) || defined(XP_OS2)
     /*
      * Only a non-layered, NSPR file descriptor can be inherited
      * by a child process.
      */
     if (fd->identity != PR_NSPR_IO_LAYER) {
         PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
         return PR_FAILURE;
     }
--- a/nsprpub/pr/src/io/prmapopt.c
+++ b/nsprpub/pr/src/io/prmapopt.c
@@ -57,34 +57,29 @@ PRStatus PR_CALLBACK _PR_SocketGetSocket
 
     rv = _PR_MapOptionName(data->option, &level, &name);
     if (PR_SUCCESS == rv)
     {
         switch (data->option)
         {
             case PR_SockOpt_Linger:
             {
-#if !defined(XP_BEOS) || defined(BONE_VERSION)
                 struct linger linger;
                 length = sizeof(linger);
                 rv = _PR_MD_GETSOCKOPT(
                     fd, level, name, (char *) &linger, &length);
                 if (PR_SUCCESS == rv)
                 {
                     PR_ASSERT(sizeof(linger) == length);
                     data->value.linger.polarity =
                         (linger.l_onoff) ? PR_TRUE : PR_FALSE;
                     data->value.linger.linger =
                         PR_SecondsToInterval(linger.l_linger);
                 }
                 break;
-#else
-                PR_SetError( PR_NOT_IMPLEMENTED_ERROR, 0 );
-                return PR_FAILURE;
-#endif
             }
             case PR_SockOpt_Reuseaddr:
             case PR_SockOpt_Keepalive:
             case PR_SockOpt_NoDelay:
             case PR_SockOpt_Broadcast:
             case PR_SockOpt_Reuseport:
             {
 #ifdef WIN32 /* Winsock */
@@ -216,27 +211,22 @@ PRStatus PR_CALLBACK _PR_SocketSetSocket
 
     rv = _PR_MapOptionName(data->option, &level, &name);
     if (PR_SUCCESS == rv)
     {
         switch (data->option)
         {
             case PR_SockOpt_Linger:
             {
-#if !defined(XP_BEOS) || defined(BONE_VERSION)
                 struct linger linger;
                 linger.l_onoff = data->value.linger.polarity;
                 linger.l_linger = PR_IntervalToSeconds(data->value.linger.linger);
                 rv = _PR_MD_SETSOCKOPT(
                     fd, level, name, (char*)&linger, sizeof(linger));
                 break;
-#else
-                PR_SetError( PR_NOT_IMPLEMENTED_ERROR, 0 );
-                return PR_FAILURE;
-#endif
             }
             case PR_SockOpt_Reuseaddr:
             case PR_SockOpt_Keepalive:
             case PR_SockOpt_NoDelay:
             case PR_SockOpt_Broadcast:
             case PR_SockOpt_Reuseport:
             {
 #ifdef WIN32 /* Winsock */
--- a/nsprpub/pr/src/io/prscanf.c
+++ b/nsprpub/pr/src/io/prscanf.c
@@ -360,21 +360,17 @@ GetFloat(ScanfState *state)
     *p = '\0';
     if (state->assign) {
         PRFloat64 dval = PR_strtod(buf, NULL);
 
         state->converted = PR_TRUE;
         if (state->sizeSpec == _PR_size_l) {
             *va_arg(state->ap, PRFloat64 *) = dval;
         } else if (state->sizeSpec == _PR_size_L) {
-#if defined(OSF1) || defined(IRIX)
-            *va_arg(state->ap, double *) = dval;
-#else
             *va_arg(state->ap, long double *) = dval;
-#endif
         } else {
             *va_arg(state->ap, float *) = (float) dval;
         }
     }
     return PR_SUCCESS;
 }
 
 /*
--- a/nsprpub/pr/src/io/prsocket.c
+++ b/nsprpub/pr/src/io/prsocket.c
@@ -376,35 +376,16 @@ static PRStatus PR_CALLBACK SocketConnec
 
     err = _MD_os2_get_nonblocking_connect_error(osfd);
     if (err != 0) {
         _PR_MD_MAP_CONNECT_ERROR(err);
         return PR_FAILURE;
     }
     return PR_SUCCESS;
 
-#elif defined(XP_BEOS)
-
-#ifdef BONE_VERSION  /* bug 122364 */
-    /* temporary workaround until getsockopt(SO_ERROR) works in BONE */
-    if (out_flags & PR_POLL_EXCEPT) {
-        PR_SetError(PR_CONNECT_REFUSED_ERROR, 0);
-        return PR_FAILURE;
-    }
-    PR_ASSERT(out_flags & PR_POLL_WRITE);
-    return PR_SUCCESS;
-#else
-    err = _MD_beos_get_nonblocking_connect_error(fd);
-    if( err != 0 ) {
-        _PR_MD_MAP_CONNECT_ERROR(err);
-        return PR_FAILURE;
-    }
-    else
-        return PR_SUCCESS;
-#endif /* BONE_VERSION */
 
 #else
     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
     return PR_FAILURE;
 #endif
 }
 
 PR_IMPLEMENT(PRStatus) PR_GetConnectStatus(const PRPollDesc *pd)
@@ -473,17 +454,17 @@ PRIntervalTime timeout)
 
 	/*
 	 * On some platforms, the new socket created by accept()
 	 * inherits the nonblocking (or overlapped io) attribute
 	 * of the listening socket.  As an optimization, these
 	 * platforms can skip the following _PR_MD_MAKE_NONBLOCK
 	 * call.
 	 */
-#if !defined(SOLARIS) && !defined(IRIX) && !defined(WINNT)
+#if !defined(SOLARIS) && !defined(WINNT)
 	_PR_MD_MAKE_NONBLOCK(fd2);
 #endif
 
 #ifdef _PR_INET6
 	if (addr && (AF_INET6 == addr->raw.family))
         addr->raw.family = PR_AF_INET6;
 #endif
 	PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE);
--- a/nsprpub/pr/src/linking/prlink.c
+++ b/nsprpub/pr/src/linking/prlink.c
@@ -2,20 +2,16 @@
 /* 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 "primpl.h"
 
 #include <string.h>
 
-#ifdef XP_BEOS
-#include <image.h>
-#endif
-
 #if defined(XP_MACOSX) && defined(USE_MACH_DYLD)
 #include <Carbon/Carbon.h>
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
 #ifdef XP_UNIX
 #ifdef USE_DLFCN
 #include <dlfcn.h>
@@ -33,20 +29,16 @@
 #define RTLD_LOCAL 0
 #endif
 #ifdef AIX
 #include <sys/ldr.h>
 #ifndef L_IGNOREUNLOAD /* AIX 4.3.3 does not have L_IGNOREUNLOAD. */
 #define L_IGNOREUNLOAD 0x10000000
 #endif
 #endif
-#ifdef OSF1
-#include <loader.h>
-#include <rld_interface.h>
-#endif
 #elif defined(USE_HPSHL)
 #include <dl.h>
 #elif defined(USE_MACH_DYLD)
 #include <mach-o/dyld.h>
 #endif
 #endif /* XP_UNIX */
 
 #define _PR_DEFAULT_LD_FLAGS PR_LD_LAZY
@@ -91,20 +83,16 @@ struct PRLibrary {
     shl_t                       dlh;
 #elif defined(USE_MACH_DYLD)
     NSModule                    dlh;
 #else
     void*                       dlh;
 #endif 
 #endif 
 
-#ifdef XP_BEOS
-    void*                       dlh;
-    void*                       stub_dlh;
-#endif
 };
 
 static PRLibrary *pr_loadmap;
 static PRLibrary *pr_exe_loadmap;
 static PRMonitor *pr_linker_lock;
 static char* _pr_currentLibPath = NULL;
 
 static PRLibrary *pr_LoadLibraryByPathname(const char *name, PRIntn flags);
@@ -271,33 +259,26 @@ PR_GetLibraryPath(void)
 #ifdef XP_PC
     ev = getenv("LD_LIBRARY_PATH");
     if (!ev) {
     ev = ".;\\lib";
     }
     ev = strdup(ev);
 #endif
 
-#if defined(XP_UNIX) || defined(XP_BEOS)
-#if defined(USE_DLFCN) || defined(USE_MACH_DYLD) || defined(XP_BEOS)
+#if defined(XP_UNIX)
+#if defined(USE_DLFCN) || defined(USE_MACH_DYLD)
     {
     char *p=NULL;
     int len;
 
-#ifdef XP_BEOS
-    ev = getenv("LIBRARY_PATH");
-    if (!ev) {
-        ev = "%A/lib:/boot/home/config/lib:/boot/beos/system/lib";
-    }
-#else
     ev = getenv("LD_LIBRARY_PATH");
     if (!ev) {
         ev = "/usr/lib:/lib";
     }
-#endif
     len = strlen(ev) + 1;        /* +1 for the null */
 
     p = (char*) malloc(len);
     if (p) {
         strcpy(p, ev);
     }   /* if (p)  */
     ev = p;
     PR_LOG(_pr_io_lm, PR_LOG_NOTICE, ("linker path '%s'", ev));
@@ -344,32 +325,32 @@ PR_GetLibraryName(const char *path, cons
     } else {
         if (path) {
             fullname = PR_smprintf("%s\\%s", path, lib);
         } else {
             fullname = PR_smprintf("%s", lib);
         }
     }
 #endif /* XP_PC */
-#if defined(XP_UNIX) || defined(XP_BEOS)
+#if defined(XP_UNIX)
     if (strstr(lib, PR_DLL_SUFFIX) == NULL)
     {
         if (path) {
             fullname = PR_smprintf("%s/lib%s%s", path, lib, PR_DLL_SUFFIX);
         } else {
             fullname = PR_smprintf("lib%s%s", lib, PR_DLL_SUFFIX);
         }
     } else {
         if (path) {
             fullname = PR_smprintf("%s/%s", path, lib);
         } else {
             fullname = PR_smprintf("%s", lib);
         }
     }
-#endif /* XP_UNIX || XP_BEOS */
+#endif /* XP_UNIX */
     return fullname;
 }
 
 /*
 ** Free the memory allocated, for the caller, by PR_GetLibraryName
 */
 PR_IMPLEMENT(void) 
 PR_FreeLibraryName(char *mem)
@@ -837,106 +818,16 @@ pr_LoadLibraryByPathname(const char *nam
     lm->next = pr_loadmap;
     pr_loadmap = lm;
     }
 #endif /* HAVE_DLL */
 #endif /* XP_UNIX && !(XP_MACOSX && USE_MACH_DYLD) */
 
     lm->refCount = 1;
 
-#ifdef XP_BEOS
-    {
-        image_info info;
-        int32 cookie = 0;
-        image_id imageid = B_ERROR;
-        image_id stubid = B_ERROR;
-        PRLibrary *p;
-
-        for (p = pr_loadmap; p != NULL; p = p->next) {
-            /* hopefully, our caller will always use the same string
-               to refer to the same library */
-            if (strcmp(name, p->name) == 0) {
-                /* we've already loaded this library */
-                imageid = info.id;
-                lm->refCount++;
-                break;
-            }
-        }
-
-        if(imageid == B_ERROR) {
-            /* it appears the library isn't yet loaded - load it now */
-            char stubName [B_PATH_NAME_LENGTH + 1];
-
-            /* the following is a work-around to a "bug" in the beos -
-               the beos system loader allows only 32M (system-wide)
-               to be used by code loaded as "add-ons" (code loaded
-               through the 'load_add_on()' system call, which includes
-               mozilla components), but allows 256M to be used by
-               shared libraries.
-               
-               unfortunately, mozilla is too large to fit into the
-               "add-on" space, so we must trick the loader into
-               loading some of the components as shared libraries.  this
-               is accomplished by creating a "stub" add-on (an empty
-               shared object), and linking it with the component
-               (the actual .so file generated by the build process,
-               without any modifications).  when this stub is loaded
-               by load_add_on(), the loader will automatically load the
-               component into the shared library space.
-            */
-
-            strcpy(stubName, name);
-            strcat(stubName, ".stub");
-
-            /* first, attempt to load the stub (thereby loading the
-               component as a shared library */
-            if ((stubid = load_add_on(stubName)) > B_ERROR) {
-                /* the stub was loaded successfully. */
-                imageid = B_FILE_NOT_FOUND;
-
-                cookie = 0;
-                while (get_next_image_info(0, &cookie, &info) == B_OK) {
-                    const char *endOfSystemName = strrchr(info.name, '/');
-                    const char *endOfPassedName = strrchr(name, '/');
-                    if( 0 == endOfSystemName ) 
-                        endOfSystemName = info.name;
-                    else
-                        endOfSystemName++;
-                    if( 0 == endOfPassedName )
-                        endOfPassedName = name;
-                    else
-                        endOfPassedName++;
-                    if (strcmp(endOfSystemName, endOfPassedName) == 0) {
-                        /* this is the actual component - remember it */
-                        imageid = info.id;
-                        break;
-                    }
-                }
-
-            } else {
-                /* we failed to load the "stub" - try to load the
-                   component directly as an add-on */
-                stubid = B_ERROR;
-                imageid = load_add_on(name);
-            }
-        }
-
-        if (imageid <= B_ERROR) {
-            oserr = imageid;
-            PR_DELETE( lm );
-            goto unlock;
-        }
-        lm->name = strdup(name);
-        lm->dlh = (void*)imageid;
-        lm->stub_dlh = (void*)stubid;
-        lm->next = pr_loadmap;
-        pr_loadmap = lm;
-    }
-#endif
-
     result = lm;    /* success */
     PR_LOG(_pr_linker_lm, PR_LOG_MIN, ("Loaded library %s (load lib)", lm->name));
 
   unlock:
     if (result == NULL) {
         PR_SetError(PR_LOAD_LIBRARY_ERROR, oserr);
         DLLErrorInternal(oserr);  /* sets error text */
     }
@@ -974,23 +865,16 @@ PR_UnloadLibrary(PRLibrary *lib)
 
     if (--lib->refCount > 0) {
     PR_LOG(_pr_linker_lm, PR_LOG_MIN,
            ("%s decr => %d",
         lib->name, lib->refCount));
     goto done;
     }
 
-#ifdef XP_BEOS
-    if(((image_id)lib->stub_dlh) == B_ERROR)
-        unload_add_on( (image_id) lib->dlh );
-    else
-        unload_add_on( (image_id) lib->stub_dlh);
-#endif
-
 #ifdef XP_UNIX
 #ifdef HAVE_DLL
 #ifdef USE_DLFCN
     result = dlclose(lib->dlh);
 #elif defined(USE_HPSHL)
     result = shl_unload(lib->dlh);
 #elif defined(USE_MACH_DYLD)
     if (lib->dlh)
@@ -1077,17 +961,17 @@ pr_FindSymbolInLib(PRLibrary *lm, const 
             if (strcmp(name, tp->name) == 0) {
                 return (void*) tp->fp;
             }
         }
         /* 
         ** If the symbol was not found in the static table then check if
         ** the symbol was exported in the DLL... Win16 only!!
         */
-#if !defined(WIN16) && !defined(XP_BEOS)
+#if !defined(WIN16)
         PR_SetError(PR_FIND_SYMBOL_ERROR, 0);
         return (void*)NULL;
 #endif
     }
     
 #ifdef XP_OS2
     rc = DosQueryProcAddr(lm->dlh, 0, (PSZ) name, (PFN *) &f);
 #if defined(NEED_LEADING_UNDERSCORE)
@@ -1144,22 +1028,16 @@ pr_FindSymbolInLib(PRLibrary *lm, const 
         if (symbol != NULL)
             f = NSAddressOfSymbol(symbol);
         else
             f = NULL;
     }
 #undef SYM_OFFSET
 #endif /* XP_MACOSX && USE_MACH_DYLD */
 
-#ifdef XP_BEOS
-    if( B_NO_ERROR != get_image_symbol( (image_id)lm->dlh, name, B_SYMBOL_TYPE_TEXT, &f ) ) {
-        f = NULL;
-    }
-#endif
-
 #ifdef XP_UNIX
 #ifdef HAVE_DLL
 #ifdef USE_DLFCN
     f = dlsym(lm->dlh, name);
 #elif defined(USE_HPSHL)
     if (shl_findsym(&lm->dlh, name, TYPE_PROCEDURE, &f) == -1) {
         f = NULL;
     }
@@ -1420,84 +1298,16 @@ PR_GetLibraryFilePathname(const char *na
         if (!infop->ldinfo_next) {
             PR_SetError(PR_LIBRARY_NOT_LOADED_ERROR, 0);
             result = NULL;
             break;
         }
     }
     PR_Free(info);
     return result;
-#elif defined(OSF1)
-    /* Contributed by Steve Streeter of HP */
-    ldr_process_t process, ldr_my_process();
-    ldr_module_t mod_id;
-    ldr_module_info_t info;
-    ldr_region_t regno;
-    ldr_region_info_t reginfo;
-    size_t retsize;
-    int rv;
-    char *result;
-
-    /* Get process for which dynamic modules will be listed */
-
-    process = ldr_my_process();
-
-    /* Attach to process */
-
-    rv = ldr_xattach(process);
-    if (rv) {
-        /* should not happen */
-        _PR_MD_MAP_DEFAULT_ERROR(_MD_ERRNO());
-        return NULL;
-    }
-
-    /* Print information for list of modules */
-
-    mod_id = LDR_NULL_MODULE;
-
-    for (;;) {
-
-        /* Get information for the next module in the module list. */
-
-        ldr_next_module(process, &mod_id);
-        if (ldr_inq_module(process, mod_id, &info, sizeof(info),
-                           &retsize) != 0) {
-            /* No more modules */
-            break;
-        }
-        if (retsize < sizeof(info)) {
-            continue;
-        }
-
-        /*
-         * Get information for each region in the module and check if any
-         * contain the address of this function.
-         */
-
-        for (regno = 0; ; regno++) {
-            if (ldr_inq_region(process, mod_id, regno, &reginfo,
-                               sizeof(reginfo), &retsize) != 0) {
-                /* No more regions */
-                break;
-            }
-            if (((unsigned long)reginfo.lri_mapaddr <=
-                (unsigned long)addr) &&
-                (((unsigned long)reginfo.lri_mapaddr + reginfo.lri_size) >
-                (unsigned long)addr)) {
-                /* Found it. */
-                result = PR_Malloc(strlen(info.lmi_name)+1);
-                if (result != NULL) {
-                    strcpy(result, info.lmi_name);
-                }
-                return result;
-            }
-        }
-    }
-    PR_SetError(PR_LIBRARY_NOT_LOADED_ERROR, 0);
-    return NULL;
 #elif defined(HPUX) && defined(USE_HPSHL)
     int index;
     struct shl_descriptor desc;
     char *result;
 
     for (index = 0; shl_get_r(index, &desc) == 0; index++) {
         if (strstr(desc.filename, name) != NULL) {
             result = PR_Malloc(strlen(desc.filename)+1);
--- a/nsprpub/pr/src/malloc/prmem.c
+++ b/nsprpub/pr/src/malloc/prmem.c
@@ -551,36 +551,16 @@ static pthread_mutex_t _PR_MD_malloc_cru
 					PRStatus rv;			\
 					rv = pthread_mutex_unlock(&_PR_MD_malloc_crustylock); \
 					PR_ASSERT(0 == rv);		\
 				}					\
 			  }
 #else /* _PR_PTHREADS */
 static _MDLock _PR_MD_malloc_crustylock;
 
-#ifdef IRIX
-#define _PR_Lock_Malloc() {						\
-			   PRIntn _is;					\
-    				if(PR_TRUE == _PR_malloc_initialised) { \
-				if (_PR_MD_GET_ATTACHED_THREAD() && 		\
-					!_PR_IS_NATIVE_THREAD( 		\
-					_PR_MD_GET_ATTACHED_THREAD()))	\
-						_PR_INTSOFF(_is); 	\
-					_PR_MD_LOCK(&_PR_MD_malloc_crustylock); \
-				}
-
-#define _PR_Unlock_Malloc() 	if(PR_TRUE == _PR_malloc_initialised) { \
-					_PR_MD_UNLOCK(&_PR_MD_malloc_crustylock); \
-				if (_PR_MD_GET_ATTACHED_THREAD() && 		\
-					!_PR_IS_NATIVE_THREAD( 		\
-					_PR_MD_GET_ATTACHED_THREAD()))	\
-						_PR_INTSON(_is);	\
-				}					\
-			  }
-#else	/* IRIX */
 #define _PR_Lock_Malloc() {						\
 			   PRIntn _is;					\
     				if(PR_TRUE == _PR_malloc_initialised) { \
 				if (_PR_MD_CURRENT_THREAD() && 		\
 					!_PR_IS_NATIVE_THREAD( 		\
 					_PR_MD_CURRENT_THREAD()))	\
 						_PR_INTSOFF(_is); 	\
 					_PR_MD_LOCK(&_PR_MD_malloc_crustylock); \
@@ -589,17 +569,16 @@ static _MDLock _PR_MD_malloc_crustylock;
 #define _PR_Unlock_Malloc() 	if(PR_TRUE == _PR_malloc_initialised) { \
 					_PR_MD_UNLOCK(&_PR_MD_malloc_crustylock); \
 				if (_PR_MD_CURRENT_THREAD() && 		\
 					!_PR_IS_NATIVE_THREAD( 		\
 					_PR_MD_CURRENT_THREAD()))	\
 						_PR_INTSON(_is);	\
 				}					\
 			  }
-#endif	/* IRIX	*/
 #endif /* _PR_PTHREADS */
 
 PR_IMPLEMENT(PRStatus) _PR_MallocInit(void)
 {
     PRStatus rv = PR_SUCCESS;
 
     if( PR_TRUE == _PR_malloc_initialised ) return PR_SUCCESS;
 
@@ -631,32 +610,16 @@ void *malloc(size_t size)
 {
     void *p;
     _PR_Lock_Malloc();
     p = _PR_UnlockedMalloc(size);
     _PR_Unlock_Malloc();
     return p;
 }
 
-#if defined(IRIX)
-void *memalign(size_t alignment, size_t size)
-{
-    void *p;
-    _PR_Lock_Malloc();
-    p = _PR_UnlockedMemalign(alignment, size);
-    _PR_Unlock_Malloc();
-    return p;
-}
-
-void *valloc(size_t size)
-{
-    return(memalign(sysconf(_SC_PAGESIZE),size));
-}
-#endif	/* IRIX */
-
 void free(void *ptr)
 {
     _PR_Lock_Malloc();
     _PR_UnlockedFree(ptr);
     _PR_Unlock_Malloc();
 }
 
 void *realloc(void *ptr, size_t size)
deleted file mode 100644
--- a/nsprpub/pr/src/md/beos/.cvsignore
+++ /dev/null
@@ -1,1 +0,0 @@
-Makefile
deleted file mode 100644
--- a/nsprpub/pr/src/md/beos/Makefile.in
+++ /dev/null
@@ -1,28 +0,0 @@
-# 
-# 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/.
-
-
-MOD_DEPTH	= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(MOD_DEPTH)/config/autoconf.mk
-
-include $(topsrcdir)/config/config.mk
-
-include $(srcdir)/bsrcs.mk
-CSRCS += $(MDCSRCS)
-
-TARGETS		= $(OBJS)
-
-INCLUDES = -I$(dist_includedir) -I$(topsrcdir)/pr/include -I$(topsrcdir)/pr/include/private
-
-DEFINES	+= -D_NSPR_BUILD_
-
-include $(topsrcdir)/config/rules.mk
-
-export:: $(TARGETS)
-
deleted file mode 100644
--- a/nsprpub/pr/src/md/beos/bcpu.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* -*- Mode: C++; 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/. */
-
-#include "primpl.h"
-
-PR_EXTERN(void) _PR_MD_INIT_CPUS();
-PR_EXTERN(void) _PR_MD_WAKEUP_CPUS();
-PR_EXTERN(void) _PR_MD_START_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_STOP_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_DISABLE_CLOCK_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_BLOCK_CLOCK_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_UNBLOCK_CLOCK_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_CLOCK_INTERRUPT(void);
-PR_EXTERN(void) _PR_MD_INIT_STACK(PRThreadStack *ts, PRIntn redzone);
-PR_EXTERN(void) _PR_MD_CLEAR_STACK(PRThreadStack* ts);
-PR_EXTERN(PRInt32) _PR_MD_GET_INTSOFF(void);
-PR_EXTERN(void) _PR_MD_SET_INTSOFF(PRInt32 _val);
-PR_EXTERN(_PRCPU*) _PR_MD_CURRENT_CPU(void);
-PR_EXTERN(void) _PR_MD_SET_CURRENT_CPU(_PRCPU *cpu);
-PR_EXTERN(void) _PR_MD_INIT_RUNNING_CPU(_PRCPU *cpu);
-PR_EXTERN(PRInt32) _PR_MD_PAUSE_CPU(PRIntervalTime timeout);
deleted file mode 100644
--- a/nsprpub/pr/src/md/beos/beos.c
+++ /dev/null
@@ -1,232 +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/. */
-
-#include "primpl.h"
-
-#include <signal.h>
-#include <unistd.h>
-#include <memory.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-#include <errno.h>
-
-/*
- * Make sure _PRSockLen_t is 32-bit, because we will cast a PRUint32* or
- * PRInt32* pointer to a _PRSockLen_t* pointer.
- */
-#define _PRSockLen_t int
-
-/*
-** Global lock variable used to bracket calls into rusty libraries that
-** aren't thread safe (like libc, libX, etc).
-*/
-static PRLock *_pr_rename_lock = NULL;
-static PRMonitor *_pr_Xfe_mon = NULL;
-
-/*
- * Variables used by the GC code, initialized in _MD_InitSegs().
- * _pr_zero_fd should be a static variable.  Unfortunately, there is
- * still some Unix-specific code left in function PR_GrowSegment()
- * in file memory/prseg.c that references it, so it needs
- * to be a global variable for now.
- */
-PRInt32 _pr_zero_fd = -1;
-static PRLock *_pr_md_lock = NULL;
-
-sigset_t timer_set;
-
-void _PR_UnixInit()
-{
-	struct sigaction sigact;
-	int rv;
-
-	sigemptyset(&timer_set);
-
-	sigact.sa_handler = SIG_IGN;
-	sigemptyset(&sigact.sa_mask);
-	sigact.sa_flags = 0;
-	rv = sigaction(SIGPIPE, &sigact, 0);
-	PR_ASSERT(0 == rv);
-
-	_pr_rename_lock = PR_NewLock();
-	PR_ASSERT(NULL != _pr_rename_lock);
-	_pr_Xfe_mon = PR_NewMonitor();
-	PR_ASSERT(NULL != _pr_Xfe_mon);
-}
-
-/*
- *-----------------------------------------------------------------------
- *
- * PR_Now --
- *
- *     Returns the current time in microseconds since the epoch.
- *     The epoch is midnight January 1, 1970 GMT.
- *     The implementation is machine dependent.  This is the Unix
- *     implementation.
- *     Cf. time_t time(time_t *tp)
- *
- *-----------------------------------------------------------------------
- */
-
-PR_IMPLEMENT(PRTime)
-PR_Now(void)
-{
-	struct timeval tv;
-	PRInt64 s, us, s2us;
-
-	GETTIMEOFDAY(&tv);
-	LL_I2L(s2us, PR_USEC_PER_SEC);
-	LL_I2L(s, tv.tv_sec);
-	LL_I2L(us, tv.tv_usec);
-	LL_MUL(s, s, s2us);
-	LL_ADD(s, s, us);
-	return s;
-}
-
-PRIntervalTime
-_PR_UNIX_GetInterval()
-{
-	struct timeval time;
-	PRIntervalTime ticks;
-
-	(void)GETTIMEOFDAY(&time);  /* fallicy of course */
-	ticks = (PRUint32)time.tv_sec * PR_MSEC_PER_SEC;  /* that's in milliseconds */
-	ticks += (PRUint32)time.tv_usec / PR_USEC_PER_MSEC;  /* so's that */
-	return ticks;
-}  /* _PR_SUNOS_GetInterval */
-
-PRIntervalTime _PR_UNIX_TicksPerSecond()
-{
-	return 1000;  /* this needs some work :) */
-}
-
-/************************************************************************/
-
-/*
-** Special hacks for xlib. Xlib/Xt/Xm is not re-entrant nor is it thread
-** safe.  Unfortunately, neither is mozilla. To make these programs work
-** in a pre-emptive threaded environment, we need to use a lock.
-*/
-
-void PR_XLock()
-{
-	PR_EnterMonitor(_pr_Xfe_mon);
-}
-
-void PR_XUnlock()
-{
-	PR_ExitMonitor(_pr_Xfe_mon);
-}
-
-PRBool PR_XIsLocked()
-{
-	return (PR_InMonitor(_pr_Xfe_mon)) ? PR_TRUE : PR_FALSE;
-}
-
-void PR_XWait(int ms)
-{
-	PR_Wait(_pr_Xfe_mon, PR_MillisecondsToInterval(ms));
-}
-
-void PR_XNotify(void)
-{
-	PR_Notify(_pr_Xfe_mon);
-}
-
-void PR_XNotifyAll(void)
-{
-	PR_NotifyAll(_pr_Xfe_mon);
-}
-
-#if !defined(BEOS)
-#ifdef HAVE_BSD_FLOCK
-
-#include <sys/file.h>
-
-PR_IMPLEMENT(PRStatus)
-_MD_LOCKFILE (PRInt32 f)
-{
-	PRInt32 rv;
-	rv = flock(f, LOCK_EX);
-	if (rv == 0)
-		return PR_SUCCESS;
-	_PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
-	return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-_MD_TLOCKFILE (PRInt32 f)
-{
-	PRInt32 rv;
-	rv = flock(f, LOCK_EX|LOCK_NB);
-	if (rv == 0)
-		return PR_SUCCESS;
-	_PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
-	return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-_MD_UNLOCKFILE (PRInt32 f)
-{
-	PRInt32 rv;
-	rv = flock(f, LOCK_UN);
-	if (rv == 0)
-		return PR_SUCCESS;
-	_PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
-	return PR_FAILURE;
-}
-#else
-
-PR_IMPLEMENT(PRStatus)
-_MD_LOCKFILE (PRInt32 f)
-{
-	PRInt32 rv;
-	rv = lockf(f, F_LOCK, 0);
-	if (rv == 0)
-		return PR_SUCCESS;
-	_PR_MD_MAP_LOCKF_ERROR(_MD_ERRNO());
-	return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-_MD_TLOCKFILE (PRInt32 f)
-{
-	PRInt32 rv;
-	rv = lockf(f, F_TLOCK, 0);
-	if (rv == 0)
-		return PR_SUCCESS;
-	_PR_MD_MAP_LOCKF_ERROR(_MD_ERRNO());
-	return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-_MD_UNLOCKFILE (PRInt32 f)
-{
-	PRInt32 rv;
-	rv = lockf(f, F_ULOCK, 0);
-	if (rv == 0)
-		return PR_SUCCESS;
-	_PR_MD_MAP_LOCKF_ERROR(_MD_ERRNO());
-	return PR_FAILURE;
-}
-#endif
-
-PR_IMPLEMENT(PRStatus)
-  _MD_GETHOSTNAME (char *name, PRUint32 namelen)
-{
-    PRIntn rv;
-
-    rv = gethostname(name, namelen);
-    if (0 == rv) {
-		return PR_SUCCESS;
-    }
-	_PR_MD_MAP_GETHOSTNAME_ERROR(_MD_ERRNO());
-    return PR_FAILURE;
-}
-
-#endif
deleted file mode 100644
--- a/nsprpub/pr/src/md/beos/beos_errors.c
+++ /dev/null
@@ -1,1494 +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/. */
-
-#include "prtypes.h"
-#include "md/_unix_errors.h"
-#include "prerror.h"
-#include <errno.h>
-
-void _MD_unix_map_opendir_error(int err)
-{
-	switch (err) {
-		case ENOTDIR:
-			PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
-			break;
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EMFILE:
-			PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case ENFILE:
-			PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case ELOOP:
-			PR_SetError(PR_LOOP_ERROR, err);
-			break;
-		case ENAMETOOLONG:
-			PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
-			break;
-		case ENOENT:
-			PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_closedir_error(int err)
-{
-	switch (err) {
-		case EINVAL:
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_readdir_error(int err)
-{
-
-	switch (err) {
-		case 0:
-		case ENOENT:
-			PR_SetError(PR_NO_MORE_FILES_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#ifdef IRIX
-#ifdef IRIX5_3
-#else
-		case EDIRCORRUPTED:
-			PR_SetError(PR_DIRECTORY_CORRUPTED_ERROR, err);
-			break;
-#endif
-#endif
-#ifdef EOVERFLOW
-		case EOVERFLOW:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-#endif
-		case EINVAL:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-#ifdef EBADMSG
-		case EBADMSG:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-#endif
-		case EDEADLK:
-			PR_SetError(PR_DEADLOCK_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case ENOLCK:
-			PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
-			break;
-#ifdef ENOLINK
-		case ENOLINK:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-#endif
-		case ENXIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_unlink_error(int err)
-{
-	switch (err) {
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EBUSY:
-			PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case ELOOP:
-			PR_SetError(PR_LOOP_ERROR, err);
-			break;
-		case ENAMETOOLONG:
-			PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
-			break;
-		case ENOENT:
-			PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
-			break;
-		case ENOTDIR:
-			PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
-			break;
-		case EPERM:
-			PR_SetError(PR_IS_DIRECTORY_ERROR, err);
-			break;
-		case EROFS:
-			PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_stat_error(int err)
-{
-	switch (err) {
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case ETIMEDOUT:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-		case ELOOP:
-			PR_SetError(PR_LOOP_ERROR, err);
-			break;
-		case ENAMETOOLONG:
-			PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
-			break;
-		case ENOENT:
-			PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
-			break;
-		case ENOTDIR:
-			PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
-			break;
-#ifdef EOVERFLOW
-		case EOVERFLOW:
-			PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_fstat_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case ETIMEDOUT:
-#ifdef ENOLINK
-		case ENOLINK:
-#endif
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-#ifdef EOVERFLOW
-		case EOVERFLOW:
-			PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_rename_error(int err)
-{
-	switch (err) {
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EBUSY:
-			PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
-			break;
-#ifdef EDQUOT
-		case EDQUOT:
-			PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
-			break;
-#endif
-		case EEXIST:
-			PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case EISDIR:
-			PR_SetError(PR_IS_DIRECTORY_ERROR, err);
-			break;
-		case ELOOP:
-			PR_SetError(PR_LOOP_ERROR, err);
-			break;
-		case ENAMETOOLONG:
-			PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
-			break;
-		case ENOENT:
-			PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
-			break;
-		case ENOSPC:
-			PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
-			break;
-		case ENOTDIR:
-			PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
-			break;
-		case EROFS:
-			PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
-			break;
-		case EXDEV:
-			PR_SetError(PR_NOT_SAME_DEVICE_ERROR, err);
-			break;
-		case EMLINK:
-			PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_access_error(int err)
-{
-	switch (err) {
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		case ELOOP:
-			PR_SetError(PR_LOOP_ERROR, err);
-			break;
-		case ETIMEDOUT:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-		case ENAMETOOLONG:
-			PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
-			break;
-		case ENOENT:
-			PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
-			break;
-		case ENOTDIR:
-			PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
-			break;
-		case EROFS:
-			PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_mkdir_error(int err)
-{
-	switch (err) {
-		case ENOTDIR:
-			PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
-			break;
-		case ENOENT:
-			PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
-			break;
-		case ENAMETOOLONG:
-			PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
-			break;
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EEXIST:
-			PR_SetError(PR_FILE_EXISTS_ERROR, err);
-			break;
-		case EROFS:
-			PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case ELOOP:
-			PR_SetError(PR_LOOP_ERROR, err);
-			break;
-		case EMLINK:
-			PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
-			break;
-		case ENOSPC:
-			PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
-			break;
-#ifdef EDQUOT
-		case EDQUOT:
-			PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
-			break;
-#endif
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_rmdir_error(int err)
-{
-
-	switch (err) {
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EBUSY:
-			PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
-			break;
-		case EEXIST:
-			PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
-			break;
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case ELOOP:
-			PR_SetError(PR_LOOP_ERROR, err);
-			break;
-		case ETIMEDOUT:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-		case ENAMETOOLONG:
-			PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
-			break;
-		case ENOENT:
-			PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
-			break;
-		case ENOTDIR:
-			PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
-			break;
-		case EROFS:
-			PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_read_error(int err)
-{
-	switch (err) {
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
-		case EWOULDBLOCK:
-#endif
-			PR_SetError(PR_WOULD_BLOCK_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#ifdef EBADMSG
-		case EBADMSG:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-#endif
-		case EDEADLK:
-			PR_SetError(PR_DEADLOCK_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_METHOD_ERROR, err);
-			break;
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case ENOLCK:
-			PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
-			break;
-		case ENXIO:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		case EISDIR:
-			PR_SetError(PR_IS_DIRECTORY_ERROR, err);
-			break;
-		case ECONNRESET:
-		case EPIPE:
-			PR_SetError(PR_CONNECT_RESET_ERROR, err);
-			break;
-#ifdef ENOLINK
-		case ENOLINK:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_write_error(int err)
-{
-	switch (err) {
-		case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
-		case EWOULDBLOCK:
-#endif
-			PR_SetError(PR_WOULD_BLOCK_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EDEADLK:
-			PR_SetError(PR_DEADLOCK_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EFBIG:
-			PR_SetError(PR_FILE_TOO_BIG_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_METHOD_ERROR, err);
-			break;
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case ENOLCK:
-			PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		case ENOSPC:
-			PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
-			break;
-		case ENXIO:
-			PR_SetError(PR_INVALID_METHOD_ERROR, err);
-			break;
-		case ERANGE:
-			PR_SetError(PR_INVALID_METHOD_ERROR, err);
-			break;
-		case ETIMEDOUT:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-		case ECONNRESET:
-		case EPIPE:
-			PR_SetError(PR_CONNECT_RESET_ERROR, err);
-			break;
-#ifdef EDQUOT
-		case EDQUOT:
-			PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
-			break;
-#endif
-#ifdef ENOLINK
-		case ENOLINK:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_lseek_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case ESPIPE:
-			PR_SetError(PR_INVALID_METHOD_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_fsync_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#ifdef ENOLINK
-		case ENOLINK:
-#endif
-		case ETIMEDOUT:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_METHOD_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_close_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-#ifdef ENOLINK
-		case ENOLINK:
-#endif
-		case ETIMEDOUT:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_socket_error(int err)
-{
-	switch (err) {
-		case EPROTONOSUPPORT:
-			PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
-			break;
-		case EMFILE:
-			PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case ENFILE:
-			PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-#if !defined(SCO)
-		case ENOBUFS:
-#endif /* !defined(SCO) */
-		case ENOMEM:
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_socketavailable_error(int err)
-{
-	PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-}
-
-void _MD_unix_map_recv_error(int err)
-{
-	switch (err) {
-		case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
-		case EWOULDBLOCK:
-#endif
-			PR_SetError(PR_WOULD_BLOCK_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case ENOMEM:
-			PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
-			break;
-		case ECONNRESET:
-		case EPIPE:
-			PR_SetError(PR_CONNECT_RESET_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_recvfrom_error(int err)
-{
-	switch (err) {
-		case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
-		case EWOULDBLOCK:
-#endif
-			PR_SetError(PR_WOULD_BLOCK_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case ENOMEM:
-			PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		case ECONNRESET:
-			PR_SetError(PR_CONNECT_RESET_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_send_error(int err)
-{
-	switch (err) {
-		case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
-		case EWOULDBLOCK:
-#endif
-			PR_SetError(PR_WOULD_BLOCK_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-#if !defined(BEOS)
-		case EMSGSIZE:
-#endif
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-#if !defined(SCO)
-		case ENOBUFS:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif /* !defined(SCO) */
-		case ECONNREFUSED:
-			PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
-			break;
-		case EISCONN:
-			PR_SetError(PR_IS_CONNECTED_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case ENOMEM:
-			PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		case ECONNRESET:
-		case EPIPE:
-			PR_SetError(PR_CONNECT_RESET_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_sendto_error(int err)
-{
-	switch (err) {
-		case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
-		case EWOULDBLOCK:
-#endif
-			PR_SetError(PR_WOULD_BLOCK_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-#if !defined(BEOS)
-		case EMSGSIZE:
-#endif
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-#if !defined(SCO)
-		case ENOBUFS:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif /* !defined(SCO) */
-		case ECONNREFUSED:
-			PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
-			break;
-		case EISCONN:
-			PR_SetError(PR_IS_CONNECTED_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case ENOMEM:
-			PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		case ECONNRESET:
-		case EPIPE:
-			PR_SetError(PR_CONNECT_RESET_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_writev_error(int err)
-{
-	switch (err) {
-		case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
-		case EWOULDBLOCK:
-#endif
-			PR_SetError(PR_WOULD_BLOCK_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		case ECONNRESET:
-		case EPIPE:
-			PR_SetError(PR_CONNECT_RESET_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_accept_error(int err)
-{
-	switch (err) {
-		case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
-		case EWOULDBLOCK:
-#endif
-			PR_SetError(PR_WOULD_BLOCK_ERROR, err);
-			break;
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-#if !defined(BEOS)
-		case EOPNOTSUPP:
-#endif
-		case ENODEV:
-			PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EMFILE:
-			PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case ENFILE:
-			PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case ENOMEM:
-			PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-#ifdef EPROTO
-		case EPROTO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_connect_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EADDRNOTAVAIL:
-			PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
-			break;
-		case EINPROGRESS:
-			PR_SetError(PR_IN_PROGRESS_ERROR, err);
-			break;
-		case EALREADY:
-			PR_SetError(PR_ALREADY_INITIATED_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case EAFNOSUPPORT:
-			PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
-			break;
-		case EISCONN:
-			PR_SetError(PR_IS_CONNECTED_ERROR, err);
-			break;
-		case ETIMEDOUT:
-			PR_SetError(PR_IO_TIMEOUT_ERROR, err);
-			break;
-		case ECONNREFUSED:
-			PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
-			break;
-		case ENETUNREACH:
-			PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
-			break;
-		case EADDRINUSE:
-			PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		/*
-		 * UNIX domain sockets are not supported in NSPR
-		 */
-		case EACCES:
-			PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		case EIO:
-#if defined(UNIXWARE)
-			/*
-			 * On some platforms, if we connect to a port on
-			 * the local host (the loopback address) that no
-			 * process is listening on, we get EIO instead
-			 * of ECONNREFUSED.
-			 */
-			PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
-#else
-			PR_SetError(PR_IO_ERROR, err);
-#endif
-			break;
-		case ELOOP:
-			PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
-			break;
-		case ENOENT:
-			PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		case ENXIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case EPROTOTYPE:
-			PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_bind_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EADDRNOTAVAIL:
-			PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
-			break;
-		case EADDRINUSE:
-			PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
-			break;
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_SOCKET_ADDRESS_IS_BOUND_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		/*
-		 * UNIX domain sockets are not supported in NSPR
-		 */
-		case EIO:
-		case EISDIR:
-		case ELOOP:
-		case ENOENT:
-		case ENOTDIR:
-		case EROFS:
-			PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_listen_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-#if !defined(BEOS)
-		case EOPNOTSUPP:
-			PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_shutdown_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case ENOTCONN:
-			PR_SetError(PR_NOT_CONNECTED_ERROR, err);
-			break;
-		case ENOMEM:
-			PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_socketpair_error(int err)
-{
-	switch (err) {
-		case EMFILE:
-			PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case ENOMEM:
-#ifdef ENOSR
-		case ENOSR:
-#endif
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		case EAFNOSUPPORT:
-		case EPROTONOSUPPORT:
-#if !defined(BEOS)
-		case EOPNOTSUPP:
-#endif
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_getsockname_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-#if !defined(SCO)
-		case ENOBUFS:
-#endif /* !defined(SCO) */
-		case ENOMEM:
-#ifdef ENOSR
-		case ENOSR:
-#endif
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_getpeername_error(int err)
-{
-
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case ENOTCONN:
-			PR_SetError(PR_NOT_CONNECTED_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-#if !defined(SCO)
-		case ENOBUFS:
-#endif /* !defined(SCO) */
-		case ENOMEM:
-#ifdef ENOSR
-		case ENOSR:
-#endif
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_getsockopt_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case ENOPROTOOPT:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
-			break;
-		case ENOMEM:
-#ifdef ENOSR
-		case ENOSR:
-#endif
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_setsockopt_error(int err)
-{
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-#if !defined(BEOS)
-		case ENOTSOCK:
-			PR_SetError(PR_NOT_SOCKET_ERROR, err);
-			break;
-#endif
-		case ENOPROTOOPT:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
-			break;
-		case ENOMEM:
-#ifdef ENOSR
-		case ENOSR:
-#endif
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_open_error(int err)
-{
-	switch (err) {
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case EAGAIN:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		case EBUSY:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case EEXIST:
-			PR_SetError(PR_FILE_EXISTS_ERROR, err);
-			break;
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		case EIO:
-			PR_SetError(PR_IO_ERROR, err);
-			break;
-		case EISDIR:
-			PR_SetError(PR_IS_DIRECTORY_ERROR, err);
-			break;
-		case ELOOP:
-			PR_SetError(PR_LOOP_ERROR, err);
-			break;
-		case EMFILE:
-			PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case ENAMETOOLONG:
-			PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
-			break;
-		case ENFILE:
-			PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
-			break;
-		case ENODEV:
-		case ENOENT:
-		case ENXIO:
-			PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
-			break;
-		case ENOMEM:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		case ENOSPC:
-			PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
-			break;
-#ifdef ENOSR
-		case ENOSR:
-#endif
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		case ENOTDIR:
-			PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
-			break;
-		case EPERM:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case ETIMEDOUT:
-			PR_SetError(PR_REMOTE_FILE_ERROR, err);
-			break;
-		case EROFS:
-			PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_mmap_error(int err)
-{
-
-	switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EAGAIN:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		case EACCES:
-			PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
-			break;
-		case ENOMEM:
-			PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-	}
-}
-
-void _MD_unix_map_gethostname_error(int err)
-{
-    switch (err) {
-		case EFAULT:
-			PR_SetError(PR_ACCESS_FAULT_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-    }
-}
-
-void _MD_unix_map_select_error(int err)
-{
-    switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EINTR:
-			PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
-			break;
-		case EINVAL:
-			PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-    }
-}
-
-void _MD_unix_map_poll_error(int err)
-{
-    PRErrorCode prerror;
-    switch (err) {
-        case EAGAIN:
-            prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
-            break;
-        case EINVAL:
-            prerror = PR_INVALID_ARGUMENT_ERROR;
-            break;
-        case EFAULT:
-            prerror = PR_ACCESS_FAULT_ERROR;
-            break;
-        default:
-            prerror = PR_UNKNOWN_ERROR;
-            break;
-    }
-    PR_SetError(prerror, err);
-}
-
-void _MD_unix_map_flock_error(int err)
-{
-    switch (err) {
-		case EBADF:
-		case EINVAL:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EWOULDBLOCK:
-			PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-    }
-}
-
-void _MD_unix_map_lockf_error(int err)
-{
-    switch (err) {
-		case EBADF:
-			PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-			break;
-		case EACCES:
-			PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
-			break;
-		case EDEADLK:
-			PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
-			break;
-		default:
-			PR_SetError(PR_UNKNOWN_ERROR, err);
-			break;
-    }
-}
-
-#ifdef HPUX11
-void _MD_hpux_map_sendfile_error(int oserror)
-{
-    PRErrorCode prerror;
-
-    switch (oserror) {
-        case ENOTSOCK:
-            prerror = PR_NOT_SOCKET_ERROR;
-            break;
-        case EFAULT:
-            prerror = PR_ACCESS_FAULT_ERROR;
-            break;
-        case ENOBUFS:
-            prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
-            break;
-        case EINVAL:
-            prerror = PR_INVALID_ARGUMENT_ERROR;
-            break;
-        case ENOTCONN:
-            prerror = PR_NOT_CONNECTED_ERROR;
-            break;
-        case EPIPE:
-            prerror = PR_CONNECT_RESET_ERROR;
-            break;
-        case ENOMEM:
-            prerror = PR_OUT_OF_MEMORY_ERROR;
-            break;
-        case EOPNOTSUPP:
-            prerror = PR_NOT_TCP_SOCKET_ERROR;
-            break;
-        default:
-            prerror = PR_UNKNOWN_ERROR;
-    }
-    PR_SetError(prerror, oserror); 
-}
-#endif /* HPUX11 */
deleted file mode 100644
--- a/nsprpub/pr/src/md/beos/bfile.c
+++ /dev/null
@@ -1,873 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; c-basic-offset: 8 -*- */
-/* 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 "primpl.h"
-
-/*
-** Global lock variable used to bracket calls into rusty libraries that
-** aren't thread safe (like libc, libX, etc).
-*/
-static PRLock *_pr_rename_lock = NULL; 
-
-void
-_MD_InitIO (void)
-{
-}
-
-PRStatus
-_MD_open_dir (_MDDir *md,const char *name)
-{
-int err;
-
-	md->d = opendir(name);
-	if (!md->d) {
-		err = _MD_ERRNO();
-		_PR_MD_MAP_OPENDIR_ERROR(err);
-		return PR_FAILURE;
-	}
-	return PR_SUCCESS;
-}
-
-char*
-_MD_read_dir (_MDDir *md, PRIntn flags)
-{
-struct dirent *de;
-int err;
-
-	for (;;) {
-		/*
-		 * XXX: readdir() is not MT-safe
-		 */
-		_MD_ERRNO() = 0;
-		de = readdir(md->d);
-
-		if (!de) {
-			err = _MD_ERRNO();
-			_PR_MD_MAP_READDIR_ERROR(err);
-			return 0;
-		}
-
-		if ((flags & PR_SKIP_DOT) &&
-		    (de->d_name[0] == '.') && (de->d_name[1] == 0))
-			continue;
-
-		if ((flags & PR_SKIP_DOT_DOT) &&
-		    (de->d_name[0] == '.') && (de->d_name[1] == '.') &&
-		    (de->d_name[2] == 0))
-			continue;
-
-		if ((flags & PR_SKIP_HIDDEN) && (de->d_name[1] == '.'))
-			continue;
-
-		break;
-	}
-	return de->d_name;
-}
-
-
-PRInt32
-_MD_close_dir (_MDDir *md)
-{
-int rv = 0, err;