Add m-esr52 at 52.6.0

1 files changed, 229 insertions, 0 deletions

diff --git a/nsprpub/pr/src/md/unix/hpux.c b/nsprpub/pr/src/md/unix/hpux.c
new file mode 100644
index 000000000..56fddba29
--- /dev/null
+++ b/nsprpub/pr/src/md/unix/hpux.c
@@ -0,0 +1,229 @@
+/* -*- 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 <setjmp.h>
+
+#if defined(HPUX_LW_TIMER)
+
+#include <machine/inline.h>
+#include <machine/clock.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/pstat.h>
+
+int __lw_get_thread_times(int which, int64_t *sample, int64_t *time);
+
+static double msecond_per_itick;
+
+void _PR_HPUX_LW_IntervalInit(void)
+{
+    struct pst_processor psp;
+    int iticksperclktick, clk_tck;
+    int rv;
+
+    rv = pstat_getprocessor(&psp, sizeof(psp), 1, 0);
+    PR_ASSERT(rv != -1);
+
+    iticksperclktick = psp.psp_iticksperclktick;
+    clk_tck = sysconf(_SC_CLK_TCK);
+    msecond_per_itick = (1000.0)/(double)(iticksperclktick * clk_tck);
+}
+
+PRIntervalTime _PR_HPUX_LW_GetInterval(void)
+{
+    int64_t time, sample;
+
+    __lw_get_thread_times(1, &sample, &time);
+    /*
+     * Division is slower than float multiplication.
+     * return (time / iticks_per_msecond);
+     */
+    return (time * msecond_per_itick);
+}
+#endif  /* HPUX_LW_TIMER */
+
+#if !defined(PTHREADS_USER)
+
+void _MD_EarlyInit(void)
+{
+#ifndef _PR_PTHREADS
+    /*
+     * The following piece of code is taken from ns/nspr/src/md_HP-UX.c.
+     * In the comment for revision 1.6, dated 1995/09/11 23:33:34,
+     * robm says:
+     *     This version has some problems which need to be addressed.
+     *     First, intercept all system calls and prevent them from
+     *     executing the library code which performs stack switches
+     *     before normal system call invocation.  In order for library
+     *     calls which make system calls to work (like stdio), however,
+     *     we must also allocate our own stack and switch the primordial
+     *     stack to use it. This isn't so bad, except that I fudged the
+     *     backtrace length when copying the old stack to the new one.
+     *
+     * This is the original comment of robm in the code:
+     *    XXXrobm Horrific. To avoid a problem with HP's system call
+     *    code, we allocate a new stack for the primordial thread and
+     *    use it. However, we don't know how far back the original stack
+     *    goes. We should create a routine that performs a backtrace and
+     *    finds out just how much we need to copy. As a temporary measure,
+     *    I just copy an arbitrary guess.
+     *
+     * In an email to servereng dated 2 Jan 1997, Mike Patnode (mikep)
+     * suggests that this only needs to be done for HP-UX 9.
+     */
+#ifdef HPUX9
+#define PIDOOMA_STACK_SIZE 524288
+#define BACKTRACE_SIZE 8192
+    {
+        jmp_buf jb;
+        char *newstack;
+        char *oldstack;
+
+        if(!setjmp(jb)) {
+            newstack = (char *) PR_MALLOC(PIDOOMA_STACK_SIZE);
+	    oldstack = (char *) (*(((int *) jb) + 1) - BACKTRACE_SIZE);
+            memcpy(newstack, oldstack, BACKTRACE_SIZE);
+            *(((int *) jb) + 1) = (int) (newstack + BACKTRACE_SIZE);
+            longjmp(jb, 1);
+        }
+    }
+#endif  /* HPUX9 */
+#endif  /* !_PR_PTHREADS */
+}
+
+PRWord *_MD_HomeGCRegisters(PRThread *t, int isCurrent, int *np)
+{
+#ifndef _PR_PTHREADS
+    if (isCurrent) {
+	(void) setjmp(CONTEXT(t));
+    }
+    *np = sizeof(CONTEXT(t)) / sizeof(PRWord);
+    return (PRWord *) CONTEXT(t);
+#else
+	*np = 0;
+	return NULL;
+#endif
+}
+
+#ifndef _PR_PTHREADS
+void
+_MD_SET_PRIORITY(_MDThread *thread, PRUintn newPri)
+{
+    return;
+}
+
+PRStatus
+_MD_InitializeThread(PRThread *thread)
+{
+	return PR_SUCCESS;
+}
+
+PRStatus
+_MD_WAIT(PRThread *thread, PRIntervalTime ticks)
+{
+    PR_ASSERT(!(thread->flags & _PR_GLOBAL_SCOPE));
+    _PR_MD_SWITCH_CONTEXT(thread);
+    return PR_SUCCESS;
+}
+
+PRStatus
+_MD_WAKEUP_WAITER(PRThread *thread)
+{
+    if (thread) {
+	PR_ASSERT(!(thread->flags & _PR_GLOBAL_SCOPE));
+    }
+    return PR_SUCCESS;
+}
+
+/* These functions should not be called for HP-UX */
+void
+_MD_YIELD(void)
+{
+    PR_NOT_REACHED("_MD_YIELD should not be called for HP-UX.");
+}
+
+PRStatus
+_MD_CREATE_THREAD(
+    PRThread *thread,
+    void (*start) (void *),
+    PRThreadPriority priority,
+    PRThreadScope scope,
+    PRThreadState state,
+    PRUint32 stackSize)
+{
+    PR_NOT_REACHED("_MD_CREATE_THREAD should not be called for HP-UX.");
+}
+#endif /* _PR_PTHREADS */
+
+void
+_MD_suspend_thread(PRThread *thread)
+{
+#ifdef _PR_PTHREADS
+#endif
+}
+
+void
+_MD_resume_thread(PRThread *thread)
+{
+#ifdef _PR_PTHREADS
+#endif
+}
+#endif /* PTHREADS_USER */
+
+/*
+ * The HP version of strchr is buggy. It looks past the end of the
+ * string and causes a segmentation fault when our (NSPR) version
+ * of malloc is used.
+ *
+ * A better solution might be to put a cushion in our malloc just in
+ * case HP's version of strchr somehow gets used instead of this one.
+ */
+char *
+strchr(const char *s, int c)
+{
+    char ch;
+
+    if (!s) {
+        return NULL;
+    }
+
+    ch = (char) c;
+
+    while ((*s) && ((*s) != ch)) {
+        s++;
+    }
+
+    if ((*s) == ch) {
+        return (char *) s;
+    }
+
+    return NULL;
+}
+
+/*
+ * Implemementation of memcmp in HP-UX (verified on releases A.09.03,
+ * A.09.07, and B.10.10) dumps core if called with:
+ * 1. First operand with address = 1(mod 4).
+ * 2. Size = 1(mod 4)
+ * 3. Last byte of the second operand is the last byte of the page and 
+ *    next page is not accessible(not mapped or protected)
+ * Thus, using the following naive version (tons of optimizations are
+ * possible;^)
+ */
+
+int memcmp(const void *s1, const void *s2, size_t n)
+{
+    register unsigned char *p1 = (unsigned char *) s1,
+            *p2 = (unsigned char *) s2;
+
+    while (n-- > 0) {
+        register int r = ((int) ((unsigned int) *p1)) 
+                - ((int) ((unsigned int) *p2));
+        if (r) return r;
+        p1++; p2++;
+    }
+    return 0; 
+}