← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/nsprpub/pr/include/md/_irix.h

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/nsprpub/pr/include/md/_irix.h
 
1
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 
2
/* 
 
3
 * The contents of this file are subject to the Mozilla Public
 
4
 * License Version 1.1 (the "License"); you may not use this file
 
5
 * except in compliance with the License. You may obtain a copy of
 
6
 * the License at http://www.mozilla.org/MPL/
 
7
 * 
 
8
 * Software distributed under the License is distributed on an "AS
 
9
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 
10
 * implied. See the License for the specific language governing
 
11
 * rights and limitations under the License.
 
12
 * 
 
13
 * The Original Code is the Netscape Portable Runtime (NSPR).
 
14
 * 
 
15
 * The Initial Developer of the Original Code is Netscape
 
16
 * Communications Corporation.  Portions created by Netscape are 
 
17
 * Copyright (C) 1998-2000 Netscape Communications Corporation.  All
 
18
 * Rights Reserved.
 
19
 * 
 
20
 * Contributor(s):
 
21
 * 
 
22
 * Alternatively, the contents of this file may be used under the
 
23
 * terms of the GNU General Public License Version 2 or later (the
 
24
 * "GPL"), in which case the provisions of the GPL are applicable 
 
25
 * instead of those above.  If you wish to allow use of your 
 
26
 * version of this file only under the terms of the GPL and not to
 
27
 * allow others to use your version of this file under the MPL,
 
28
 * indicate your decision by deleting the provisions above and
 
29
 * replace them with the notice and other provisions required by
 
30
 * the GPL.  If you do not delete the provisions above, a recipient
 
31
 * may use your version of this file under either the MPL or the
 
32
 * GPL.
 
33
 */
 
34
 
 
35
#ifndef nspr_irix_defs_h___
 
36
#define nspr_irix_defs_h___
 
37
 
 
38
#define _PR_HAVE_ATOMIC_CAS
 
39
 
 
40
/*
 
41
 * MipsPro assembler defines _LANGUAGE_ASSEMBLY
 
42
 */
 
43
#ifndef _LANGUAGE_ASSEMBLY
 
44
 
 
45
#include "prclist.h"
 
46
#include "prthread.h"
 
47
#include <sys/ucontext.h>
 
48
 
 
49
/*
 
50
 * Internal configuration macros
 
51
 */
 
52
 
 
53
#define PR_LINKER_ARCH          "irix"
 
54
#define _PR_SI_SYSNAME          "IRIX"
 
55
#define _PR_SI_ARCHITECTURE     "mips"
 
56
#define PR_DLL_SUFFIX           ".so"
 
57
 
 
58
#define _PR_VMBASE              0x30000000
 
59
#define _PR_STACK_VMBASE        0x50000000
 
60
#define _PR_NUM_GCREGS          9
 
61
#define _MD_MMAP_FLAGS          MAP_PRIVATE
 
62
 
 
63
#define _MD_DEFAULT_STACK_SIZE  65536L
 
64
#define _MD_MIN_STACK_SIZE      16384L
 
65
 
 
66
#undef  HAVE_STACK_GROWING_UP
 
67
#define HAVE_WEAK_IO_SYMBOLS
 
68
#define HAVE_WEAK_MALLOC_SYMBOLS
 
69
#define HAVE_DLL
 
70
#define USE_DLFCN
 
71
#define _PR_HAVE_ATOMIC_OPS
 
72
#define _PR_POLL_AVAILABLE
 
73
#define _PR_USE_POLL
 
74
#define _PR_STAT_HAS_ST_ATIM
 
75
#define _PR_HAVE_OFF64_T
 
76
#define HAVE_POINTER_LOCALTIME_R
 
77
#define _PR_HAVE_POSIX_SEMAPHORES
 
78
#define PR_HAVE_POSIX_NAMED_SHARED_MEMORY
 
79
#define _PR_ACCEPT_INHERIT_NONBLOCK
 
80
 
 
81
#ifdef _PR_INET6
 
82
#define _PR_HAVE_INET_NTOP
 
83
#define _PR_HAVE_GETIPNODEBYNAME
 
84
#define _PR_HAVE_GETIPNODEBYADDR
 
85
#define _PR_HAVE_GETADDRINFO
 
86
#endif
 
87
 
 
88
/* Initialization entry points */
 
89
NSPR_API(void) _MD_EarlyInit(void);
 
90
#define _MD_EARLY_INIT _MD_EarlyInit
 
91
 
 
92
NSPR_API(void) _MD_IrixInit(void);
 
93
#define _MD_FINAL_INIT _MD_IrixInit
 
94
 
 
95
#define _MD_INIT_IO()
 
96
 
 
97
/* Timer operations */
 
98
NSPR_API(PRIntervalTime) _MD_IrixGetInterval(void);
 
99
#define _MD_GET_INTERVAL _MD_IrixGetInterval
 
100
 
 
101
NSPR_API(PRIntervalTime) _MD_IrixIntervalPerSec(void);
 
102
#define _MD_INTERVAL_PER_SEC _MD_IrixIntervalPerSec
 
103
 
 
104
/* GC operations */
 
105
NSPR_API(void *) _MD_GetSP(PRThread *thread);
 
106
#define    _MD_GET_SP _MD_GetSP
 
107
 
 
108
/* The atomic operations */
 
109
#include <mutex.h>
 
110
#define _MD_INIT_ATOMIC()
 
111
#define _MD_ATOMIC_INCREMENT(val) add_then_test((unsigned long*)val, 1)
 
112
#define _MD_ATOMIC_ADD(ptr, val) add_then_test((unsigned long*)ptr, (unsigned long)val)
 
113
#define _MD_ATOMIC_DECREMENT(val) add_then_test((unsigned long*)val, 0xffffffff)
 
114
#define _MD_ATOMIC_SET(val, newval) test_and_set((unsigned long*)val, newval)
 
115
 
 
116
#if defined(_PR_PTHREADS)
 
117
#else /* defined(_PR_PTHREADS) */
 
118
 
 
119
/************************************************************************/
 
120
 
 
121
#include <setjmp.h>
 
122
#include <errno.h>
 
123
#include <unistd.h>
 
124
#include <bstring.h>
 
125
#include <sys/time.h>
 
126
#include <ulocks.h>
 
127
#include <sys/prctl.h>
 
128
 
 
129
 
 
130
/*
 
131
 * Data region private to each sproc. This region is setup by calling
 
132
 * mmap(...,MAP_LOCAL,...). The private data is mapped at the same
 
133
 * address in every sproc, but every sproc gets a private mapping.
 
134
 *
 
135
 * Just make sure that this structure fits in a page, as only one page
 
136
 * is allocated for the private region.
 
137
 */
 
138
struct sproc_private_data {
 
139
    struct PRThread *me;
 
140
    struct _PRCPU *cpu;
 
141
    struct PRThread *last;
 
142
    PRUintn intsOff;
 
143
        int             sproc_pid;
 
144
};
 
145
 
 
146
extern char *_nspr_sproc_private;
 
147
 
 
148
#define _PR_PRDA() ((struct sproc_private_data *) _nspr_sproc_private)
 
149
#define _MD_SET_CURRENT_THREAD(_thread) _PR_PRDA()->me = (_thread)
 
150
#define _MD_THIS_THREAD() (_PR_PRDA()->me)
 
151
#define _MD_LAST_THREAD() (_PR_PRDA()->last)
 
152
#define _MD_SET_LAST_THREAD(_thread) _PR_PRDA()->last = (_thread)
 
153
#define _MD_CURRENT_CPU() (_PR_PRDA()->cpu)
 
154
#define _MD_SET_CURRENT_CPU(_cpu) _PR_PRDA()->cpu = (_cpu)
 
155
#define _MD_SET_INTSOFF(_val) (_PR_PRDA()->intsOff = _val)
 
156
#define _MD_GET_INTSOFF() (_PR_PRDA()->intsOff)
 
157
 
 
158
#define _MD_SET_SPROC_PID(_val) (_PR_PRDA()->sproc_pid = _val)
 
159
#define _MD_GET_SPROC_PID() (_PR_PRDA()->sproc_pid)
 
160
 
 
161
NSPR_API(struct PRThread*) _MD_get_attached_thread(void);
 
162
NSPR_API(struct PRThread*) _MD_get_current_thread(void);
 
163
#define _MD_GET_ATTACHED_THREAD()       _MD_get_attached_thread()
 
164
#define _MD_CURRENT_THREAD()    _MD_get_current_thread()
 
165
 
 
166
#define _MD_CHECK_FOR_EXIT() {                                  \
 
167
                if (_pr_irix_exit_now) {                                \
 
168
                        _PR_POST_SEM(_pr_irix_exit_sem);        \
 
169
                        _MD_Wakeup_CPUs();                                      \
 
170
                        _exit(0);                                                       \
 
171
                }                                                                               \
 
172
        }
 
173
                
 
174
#define _MD_ATTACH_THREAD(threadp)
 
175
 
 
176
#define _MD_SAVE_ERRNO(_thread)                 (_thread)->md.errcode = errno;
 
177
#define _MD_RESTORE_ERRNO(_thread)              errno = (_thread)->md.errcode;
 
178
 
 
179
extern struct _PRCPU  *_pr_primordialCPU;
 
180
extern usema_t *_pr_irix_exit_sem;
 
181
extern PRInt32 _pr_irix_exit_now;
 
182
extern int _pr_irix_primoridal_cpu_fd[];
 
183
extern PRInt32 _pr_irix_process_exit;
 
184
extern PRInt32 _pr_irix_process_exit_code;
 
185
 
 
186
/* Thread operations */
 
187
#define _PR_LOCK_HEAP() {                                               \
 
188
                        PRIntn _is;                                     \
 
189
                                if (_pr_primordialCPU) {                \
 
190
                                if (_MD_GET_ATTACHED_THREAD() &&                \
 
191
                                        !_PR_IS_NATIVE_THREAD(          \
 
192
                                        _MD_GET_ATTACHED_THREAD()))     \
 
193
                                                _PR_INTSOFF(_is);       \
 
194
                                        _PR_LOCK(_pr_heapLock);         \
 
195
                                }
 
196
 
 
197
#define _PR_UNLOCK_HEAP()       if (_pr_primordialCPU)  {               \
 
198
                                        _PR_UNLOCK(_pr_heapLock);       \
 
199
                                if (_MD_GET_ATTACHED_THREAD() &&                \
 
200
                                        !_PR_IS_NATIVE_THREAD(          \
 
201
                                        _MD_GET_ATTACHED_THREAD()))     \
 
202
                                                _PR_INTSON(_is);        \
 
203
                                }                                       \
 
204
                          }
 
205
 
 
206
#define _PR_OPEN_POLL_SEM(_sem)  usopenpollsema(_sem, 0666)
 
207
#define _PR_WAIT_SEM(_sem) uspsema(_sem)
 
208
#define _PR_POST_SEM(_sem) usvsema(_sem)
 
209
 
 
210
#define _MD_CVAR_POST_SEM(threadp)      usvsema((threadp)->md.cvar_pollsem)
 
211
 
 
212
#define _MD_IOQ_LOCK()
 
213
#define _MD_IOQ_UNLOCK()
 
214
 
 
215
struct _MDLock {
 
216
    ulock_t lock;
 
217
        usptr_t *arena;
 
218
};
 
219
 
 
220
/*
 
221
 * disable pre-emption for the LOCAL threads when calling the arena lock
 
222
 * routines
 
223
 */
 
224
 
 
225
#define _PR_LOCK(lock) {                                                \
 
226
                PRIntn _is;                                             \
 
227
                PRThread *me = _MD_GET_ATTACHED_THREAD();                       \
 
228
                if (me && !_PR_IS_NATIVE_THREAD(me))                    \
 
229
                        _PR_INTSOFF(_is);                               \
 
230
                ussetlock(lock);                                        \
 
231
                if (me && !_PR_IS_NATIVE_THREAD(me))                    \
 
232
                        _PR_FAST_INTSON(_is);                           \
 
233
        }
 
234
 
 
235
#define _PR_UNLOCK(lock) {                                              \
 
236
                PRIntn _is;                                             \
 
237
                PRThread *me = _MD_GET_ATTACHED_THREAD();                       \
 
238
                if (me && !_PR_IS_NATIVE_THREAD(me))                    \
 
239
                        _PR_INTSOFF(_is);                               \
 
240
                usunsetlock(lock);                                      \
 
241
                if (me && !_PR_IS_NATIVE_THREAD(me))                    \
 
242
                        _PR_FAST_INTSON(_is);                           \
 
243
        }
 
244
 
 
245
NSPR_API(PRStatus) _MD_NEW_LOCK(struct _MDLock *md);
 
246
NSPR_API(void) _MD_FREE_LOCK(struct _MDLock *lockp);
 
247
 
 
248
#define _MD_LOCK(_lockp) _PR_LOCK((_lockp)->lock)
 
249
#define _MD_UNLOCK(_lockp) _PR_UNLOCK((_lockp)->lock)
 
250
#define _MD_TEST_AND_LOCK(_lockp) (uscsetlock((_lockp)->lock, 1) == 0)
 
251
 
 
252
extern ulock_t _pr_heapLock;
 
253
 
 
254
struct _MDThread {
 
255
    jmp_buf jb;
 
256
    usptr_t     *pollsem_arena;
 
257
    usema_t     *cvar_pollsem;
 
258
    PRInt32     cvar_pollsemfd;
 
259
    PRInt32     cvar_pollsem_select;    /* acquire sem by calling select */
 
260
    PRInt32     cvar_wait;              /* if 1, thread is waiting on cvar Q */
 
261
    PRInt32     id;
 
262
    PRInt32     suspending_id;
 
263
    int errcode;
 
264
};
 
265
 
 
266
struct _MDThreadStack {
 
267
    PRInt8 notused;
 
268
};
 
269
 
 
270
struct _MDSemaphore {
 
271
    usema_t *sem;
 
272
};
 
273
 
 
274
struct _MDCVar {
 
275
    ulock_t mdcvar_lock;
 
276
};
 
277
 
 
278
struct _MDSegment {
 
279
    PRInt8 notused;
 
280
};
 
281
 
 
282
/*
 
283
 * md-specific cpu structure field
 
284
 */
 
285
#define _PR_MD_MAX_OSFD FD_SETSIZE
 
286
 
 
287
struct _MDCPU_Unix {
 
288
    PRCList ioQ;
 
289
    PRUint32 ioq_timeout;
 
290
    PRInt32 ioq_max_osfd;
 
291
    PRInt32 ioq_osfd_cnt;
 
292
#ifndef _PR_USE_POLL
 
293
    fd_set fd_read_set, fd_write_set, fd_exception_set;
 
294
    PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD],
 
295
                                fd_exception_cnt[_PR_MD_MAX_OSFD];
 
296
#else
 
297
        struct pollfd *ioq_pollfds;
 
298
        int ioq_pollfds_size;
 
299
#endif  /* _PR_USE_POLL */
 
300
};
 
301
 
 
302
#define _PR_IOQ(_cpu)                   ((_cpu)->md.md_unix.ioQ)
 
303
#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu))
 
304
#define _PR_FD_READ_SET(_cpu)           ((_cpu)->md.md_unix.fd_read_set)
 
305
#define _PR_FD_READ_CNT(_cpu)           ((_cpu)->md.md_unix.fd_read_cnt)
 
306
#define _PR_FD_WRITE_SET(_cpu)          ((_cpu)->md.md_unix.fd_write_set)
 
307
#define _PR_FD_WRITE_CNT(_cpu)          ((_cpu)->md.md_unix.fd_write_cnt)
 
308
#define _PR_FD_EXCEPTION_SET(_cpu)      ((_cpu)->md.md_unix.fd_exception_set)
 
309
#define _PR_FD_EXCEPTION_CNT(_cpu)      ((_cpu)->md.md_unix.fd_exception_cnt)
 
310
#define _PR_IOQ_TIMEOUT(_cpu)           ((_cpu)->md.md_unix.ioq_timeout)
 
311
#define _PR_IOQ_MAX_OSFD(_cpu)          ((_cpu)->md.md_unix.ioq_max_osfd)
 
312
#define _PR_IOQ_OSFD_CNT(_cpu)          ((_cpu)->md.md_unix.ioq_osfd_cnt)
 
313
#define _PR_IOQ_POLLFDS(_cpu)           ((_cpu)->md.md_unix.ioq_pollfds)
 
314
#define _PR_IOQ_POLLFDS_SIZE(_cpu)      ((_cpu)->md.md_unix.ioq_pollfds_size)
 
315
 
 
316
#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu)  32
 
317
 
 
318
 
 
319
struct _MDCPU {
 
320
    PRInt32 id;
 
321
    PRInt32 suspending_id;
 
322
    struct _MDCPU_Unix md_unix;
 
323
};
 
324
 
 
325
/*
 
326
** Initialize the thread context preparing it to execute _main.
 
327
*/
 
328
#define _MD_INIT_CONTEXT(_thread, _sp, _main, status)         \
 
329
    PR_BEGIN_MACRO                                    \
 
330
        int *jb = (_thread)->md.jb;                   \
 
331
    *status = PR_TRUE;              \
 
332
        (void) setjmp(jb);                            \
 
333
        (_thread)->md.jb[JB_SP] = (int) ((_sp) - 64); \
 
334
        (_thread)->md.jb[JB_PC] = (int) _main;        \
 
335
        _thread->no_sched = 0; \
 
336
    PR_END_MACRO
 
337
 
 
338
/*
 
339
** Switch away from the current thread context by saving its state and
 
340
** calling the thread scheduler. Reload cpu when we come back from the
 
341
** context switch because it might have changed.
 
342
*
 
343
*  XXX RUNQ lock needed before clearing _PR_NO_SCHED flag, because the
 
344
*      thread may be unr RUNQ?
 
345
*/
 
346
#define _MD_SWITCH_CONTEXT(_thread) \
 
347
    PR_BEGIN_MACRO    \
 
348
    PR_ASSERT(_thread->no_sched); \
 
349
    if (!setjmp(_thread->md.jb)) { \
 
350
        _MD_SAVE_ERRNO(_thread) \
 
351
        _MD_SET_LAST_THREAD(_thread); \
 
352
        _PR_Schedule(); \
 
353
    } else {      \
 
354
        PR_ASSERT(_MD_LAST_THREAD() !=_MD_CURRENT_THREAD()); \
 
355
            _MD_LAST_THREAD()->no_sched = 0;                    \
 
356
    }             \
 
357
    PR_END_MACRO
 
358
 
 
359
/*
 
360
** Restore a thread context that was saved by _MD_SWITCH_CONTEXT or
 
361
** initialized by _MD_INIT_CONTEXT.
 
362
*/
 
363
#define _MD_RESTORE_CONTEXT(_newThread) \
 
364
    PR_BEGIN_MACRO \
 
365
    int *jb = (_newThread)->md.jb; \
 
366
    _MD_RESTORE_ERRNO(_newThread) \
 
367
    _MD_SET_CURRENT_THREAD(_newThread); \
 
368
    _newThread->no_sched = 1;           \
 
369
    longjmp(jb, 1); \
 
370
    PR_END_MACRO
 
371
 
 
372
NSPR_API(PRStatus) _MD_InitThread(struct PRThread *thread,
 
373
                                                                PRBool wakeup_parent);
 
374
NSPR_API(PRStatus) _MD_InitAttachedThread(struct PRThread *thread,
 
375
                                                                        PRBool wakeup_parent);
 
376
#define _MD_INIT_THREAD(thread)                         _MD_InitThread(thread, PR_TRUE)
 
377
#define _MD_INIT_ATTACHED_THREAD(thread)                \
 
378
                                                _MD_InitAttachedThread(thread, PR_FALSE)
 
379
 
 
380
NSPR_API(void) _MD_ExitThread(struct PRThread *thread);
 
381
#define _MD_EXIT_THREAD _MD_ExitThread
 
382
 
 
383
NSPR_API(void) _MD_SuspendThread(struct PRThread *thread);
 
384
#define _MD_SUSPEND_THREAD _MD_SuspendThread
 
385
 
 
386
NSPR_API(void) _MD_ResumeThread(struct PRThread *thread);
 
387
#define _MD_RESUME_THREAD _MD_ResumeThread
 
388
 
 
389
NSPR_API(void) _MD_SuspendCPU(struct _PRCPU *thread);
 
390
#define _MD_SUSPEND_CPU _MD_SuspendCPU
 
391
 
 
392
NSPR_API(void) _MD_ResumeCPU(struct _PRCPU *thread);
 
393
#define _MD_RESUME_CPU _MD_ResumeCPU
 
394
 
 
395
#define _MD_BEGIN_SUSPEND_ALL()
 
396
#define _MD_END_SUSPEND_ALL()
 
397
#define _MD_BEGIN_RESUME_ALL()
 
398
#define _MD_END_RESUME_ALL()
 
399
 
 
400
NSPR_API(void) _MD_InitLocks(void);
 
401
#define _MD_INIT_LOCKS _MD_InitLocks
 
402
 
 
403
NSPR_API(void) _MD_CleanThread(struct PRThread *thread);
 
404
#define _MD_CLEAN_THREAD _MD_CleanThread
 
405
 
 
406
#define _MD_YIELD()    sginap(0)
 
407
 
 
408
/* The _PR_MD_WAIT_LOCK and _PR_MD_WAKEUP_WAITER functions put to sleep and
 
409
 * awaken a thread which is waiting on a lock or cvar.
 
410
 */
 
411
NSPR_API(PRStatus) _MD_wait(struct PRThread *, PRIntervalTime timeout);
 
412
#define _MD_WAIT _MD_wait
 
413
 
 
414
NSPR_API(void) _PR_MD_primordial_cpu();
 
415
NSPR_API(void) _PR_MD_WAKEUP_PRIMORDIAL_CPU();
 
416
 
 
417
NSPR_API(PRStatus) _MD_WakeupWaiter(struct PRThread *);
 
418
#define _MD_WAKEUP_WAITER _MD_WakeupWaiter
 
419
 
 
420
NSPR_API(void ) _MD_exit(PRIntn status);
 
421
#define _MD_EXIT        _MD_exit
 
422
 
 
423
#include "prthread.h"
 
424
 
 
425
NSPR_API(void) _MD_SetPriority(struct _MDThread *thread,
 
426
        PRThreadPriority newPri);
 
427
#define _MD_SET_PRIORITY _MD_SetPriority
 
428
 
 
429
NSPR_API(PRStatus) _MD_CreateThread(
 
430
                        struct PRThread *thread,
 
431
                        void (*start) (void *),
 
432
                        PRThreadPriority priority,
 
433
                        PRThreadScope scope,
 
434
                        PRThreadState state,
 
435
                        PRUint32 stackSize);
 
436
#define _MD_CREATE_THREAD _MD_CreateThread
 
437
 
 
438
extern void _MD_CleanupBeforeExit(void);
 
439
#define _MD_CLEANUP_BEFORE_EXIT _MD_CleanupBeforeExit
 
440
 
 
441
NSPR_API(void) _PR_MD_PRE_CLEANUP(PRThread *me);
 
442
 
 
443
 
 
444
/* The following defines the unwrapped versions of select() and poll(). */
 
445
extern int _select(int nfds, fd_set *readfds, fd_set *writefds,
 
446
        fd_set *exceptfds, struct timeval *timeout);
 
447
#define _MD_SELECT      _select
 
448
 
 
449
#include <stropts.h>
 
450
#include <poll.h>
 
451
#define _MD_POLL _poll
 
452
extern int _poll(struct pollfd *fds, unsigned long nfds, int timeout);
 
453
 
 
454
 
 
455
#define HAVE_THREAD_AFFINITY 1
 
456
 
 
457
NSPR_API(PRInt32) _MD_GetThreadAffinityMask(PRThread *unused, PRUint32 *mask);
 
458
#define _MD_GETTHREADAFFINITYMASK _MD_GetThreadAffinityMask
 
459
 
 
460
NSPR_API(void) _MD_InitRunningCPU(struct _PRCPU *cpu);
 
461
#define    _MD_INIT_RUNNING_CPU _MD_InitRunningCPU
 
462
 
 
463
#endif  /* defined(_PR_PTHREADS) */
 
464
 
 
465
#endif /* _LANGUAGE_ASSEMBLY */
 
466
 
 
467
#endif /* nspr_irix_defs_h___ */