var LibraryPThread = {

$PThread__postset: 'if (!ENVIRONMENT_IS_PTHREAD) PThread.initMainThreadBlock();',

$PThread__deps: ['$PROCINFO'],

$PThread: {

MAIN_THREAD_ID: 1, // A special constant that identifies the main JS thread ID.

mainThreadInfo: {

schedPolicy: 0/*SCHED_OTHER*/,

schedPrio: 0

},

// Since creating a new Web Worker is so heavy (it must reload the whole compiled script page!), maintain a pool of such

// workers that have already parsed and loaded the scripts.

unusedWorkerPool: [],

// The currently executing pthreads.

runningWorkers: [],

// Points to a pthread_t structure in the Emscripten main heap, allocated on demand if/when first needed.

// mainThreadBlock: undefined,

initMainThreadBlock: function() {

if (ENVIRONMENT_IS_PTHREAD) return undefined;

PThread.mainThreadBlock = allocate({{{ C_STRUCTS.pthread.__size__ }}}, "i32*", ALLOC_STATIC);

for (var i = 0; i < {{{ C_STRUCTS.pthread.__size__ }}}/4; ++i) HEAPU32[PThread.mainThreadBlock/4+i] = 0;

// The pthread struct has a field that points to itself - this is used as a magic ID to detect whether the pthread_t

// structure is 'alive'.

{{{ makeSetValue('PThread.mainThreadBlock', C_STRUCTS.pthread.self, 'PThread.mainThreadBlock', 'i32') }}};

// Allocate memory for thread-local storage.

var tlsMemory = allocate({{{ cDefine('PTHREAD_KEYS_MAX') }}} * 4, "i32*", ALLOC_STATIC);

for (var i = 0; i < {{{ cDefine('PTHREAD_KEYS_MAX') }}}; ++i) HEAPU32[tlsMemory/4+i] = 0;

Atomics.store(HEAPU32, (PThread.mainThreadBlock + {{{ C_STRUCTS.pthread.tsd }}} ) >> 2, tlsMemory); // Init thread-local-storage memory array.

Atomics.store(HEAPU32, (PThread.mainThreadBlock + {{{ C_STRUCTS.pthread.tid }}} ) >> 2, PThread.mainThreadBlock); // Main thread ID.

Atomics.store(HEAPU32, (PThread.mainThreadBlock + {{{ C_STRUCTS.pthread.pid }}} ) >> 2, PROCINFO.pid); // Process ID.

},

// Maps pthread_t to pthread info objects

pthreads: {},

pthreadIdCounter: 2, // 0: invalid thread, 1: main JS UI thread, 2+: IDs for pthreads

exitHandlers: null, // An array of C functions to run when this thread exits.

runExitHandlers: function() {

if (PThread.exitHandlers !== null) {

while (PThread.exitHandlers.length > 0) {

PThread.exitHandlers.pop()();

}

PThread.exitHandlers = null;

}

// Call into the musl function that runs destructors of all thread-specific data.

if (ENVIRONMENT_IS_PTHREAD && threadInfoStruct) ___pthread_tsd_run_dtors();

},

// Called when we are performing a pthread_exit(), either explicitly called by programmer,

// or implicitly when leaving the thread main function.

threadExit: function(exitCode) {

var tb = _pthread_self();

if (tb) { // If we haven't yet exited?

Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.threadExitCode }}} ) >> 2, exitCode);

// When we publish this, the main thread is free to deallocate the thread object and we are done.

// Therefore set threadInfoStruct = 0; above to 'release' the object in this worker thread.

Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 1);

// Disable all cancellation so that executing the cleanup handlers won't trigger another JS

// canceled exception to be thrown.

Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.canceldisable }}} ) >> 2, 1/*PTHREAD_CANCEL_DISABLE*/);

Atomics.store(HEAPU32, (tb + {{{ C_STRUCTS.pthread.cancelasync }}} ) >> 2, 0/*PTHREAD_CANCEL_DEFERRED*/);

PThread.runExitHandlers();

_emscripten_futex_wake(tb + {{{ C_STRUCTS.pthread.threadStatus }}}, {{{ cDefine('INT_MAX') }}});

threadInfoStruct = 0;

if (ENVIRONMENT_IS_PTHREAD) {

postMessage({ cmd: 'exit' });

}

}

},

threadCancel: function() {

PThread.runExitHandlers();

Atomics.store(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.threadExitCode }}} ) >> 2, -1/*PTHREAD_CANCELED*/);

Atomics.store(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 1); // Mark the thread as no longer running.

_emscripten_futex_wake(threadInfoStruct + {{{ C_STRUCTS.pthread.threadStatus }}}, {{{ cDefine('INT_MAX') }}}); // wake all threads

threadInfoStruct = selfThreadId = 0; // Not hosting a pthread anymore in this worker, reset the info structures to null.

postMessage({ cmd: 'cancelDone' });

},

terminateAllThreads: function() {

for (var t in PThread.pthreads) {

var pthread = PThread.pthreads[t];

if (pthread) {

PThread.freeThreadData(pthread);

if (pthread.worker) pthread.worker.terminate();

}

}

PThread.pthreads = {};

for (var t in PThread.unusedWorkerPool) {

var pthread = PThread.unusedWorkerPool[t];

if (pthread) {

PThread.freeThreadData(pthread);

if (pthread.worker) pthread.worker.terminate();

}

}

PThread.unusedWorkerPool = [];

for (var t in PThread.runningWorkers) {

var pthread = PThread.runningWorkers[t];

if (pthread) {

PThread.freeThreadData(pthread);

if (pthread.worker) pthread.worker.terminate();

}

}

PThread.runningWorkers = [];

},

freeThreadData: function(pthread) {

if (!pthread) return;

if (pthread.threadInfoStruct) {

var tlsMemory = {{{ makeGetValue('pthread.threadInfoStruct', C_STRUCTS.pthread.tsd, 'i32') }}};

{{{ makeSetValue('pthread.threadInfoStruct', C_STRUCTS.pthread.tsd, 0, 'i32') }}};

_free(pthread.tlsMemory);

_free(pthread.threadInfoStruct);

}

pthread.threadInfoStruct = 0;

if (pthread.allocatedOwnStack && pthread.stackBase) _free(pthread.stackBase);

pthread.stackBase = 0;

if (pthread.worker) pthread.worker.pthread = null;

},

// Allocates the given amount of new web workers and stores them in the pool of unused workers.

// onFinishedLoading: A callback function that will be called once all of the workers have been initialized and are

// ready to host pthreads. Optional. This is used to mitigate bug https://bugzilla.mozilla.org/show_bug.cgi?id=1049079

allocateUnusedWorkers: function(numWorkers, onFinishedLoading) {

if (typeof SharedArrayBuffer === 'undefined') return; // No multithreading support, no-op.

Module['print']('Preallocating ' + numWorkers + ' workers for a pthread spawn pool.');

var numWorkersLoaded = 0;

for (var i = 0; i < numWorkers; ++i) {

var worker = new Worker('pthread-main.js');

worker.onmessage = function(e) {

if (e.data.cmd === 'processQueuedMainThreadWork') {

// TODO: Must post message to main Emscripten thread in PROXY_TO_WORKER mode.

_emscripten_main_thread_process_queued_calls();

} else if (e.data.cmd === 'spawnThread') {

__spawn_thread(e.data);

} else if (e.data.cmd === 'cleanupThread') {

__cleanup_thread(e.data.thread);

} else if (e.data.cmd === 'killThread') {

__kill_thread(e.data.thread);

} else if (e.data.cmd === 'cancelThread') {

__cancel_thread(e.data.thread);

} else if (e.data.cmd === 'loaded') {

++numWorkersLoaded;

if (numWorkersLoaded === numWorkers && onFinishedLoading) {

onFinishedLoading();

}

} else if (e.data.cmd === 'print') {

Module['print']('Thread ' + e.data.threadId + ': ' + e.data.text);

} else if (e.data.cmd === 'printErr') {

Module['printErr']('Thread ' + e.data.threadId + ': ' + e.data.text);

} else if (e.data.cmd === 'exit') {

// todo

} else if (e.data.cmd === 'cancelDone') {

PThread.freeThreadData(worker.pthread);

worker.pthread = undefined; // Detach the worker from the pthread object, and return it to the worker pool as an unused worker.

PThread.unusedWorkerPool.push(worker);

// TODO: Free if detached.

PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker.pthread), 1); // Not a running Worker anymore.

} else {

Module['printErr']("worker sent an unknown command " + e.data.cmd);

}

};

worker.onerror = function(e) {

Module['printErr']('pthread sent an error! ' + e.message);

};

// Allocate tempDoublePtr for the worker. This is done here on the worker's behalf, since we may need to do this statically

// if the runtime has not been loaded yet, etc. - so we just use getMemory, which is main-thread only.

var tempDoublePtr = getMemory(8); // TODO: leaks. Cleanup after worker terminates.

// Ask the new worker to load up the Emscripten-compiled page. This is a heavy operation.

worker.postMessage({

cmd: 'load',

url: currentScriptUrl,

buffer: HEAPU8.buffer,

tempDoublePtr: tempDoublePtr,

PthreadWorkerInit: PthreadWorkerInit

}, [HEAPU8.buffer]);

PThread.unusedWorkerPool.push(worker);

}

},

getNewWorker: function() {

if (PThread.unusedWorkerPool.length == 0) PThread.allocateUnusedWorkers(1);

if (PThread.unusedWorkerPool.length > 0) return PThread.unusedWorkerPool.pop();

else return null;

},

busySpinWait: function(msecs) {

var t = performance.now() + msecs;

while(performance.now() < t) {

;

}

}

},

_kill_thread: function(pthread_ptr) {

if (ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _kill_thread() can only ever be called from main JS thread!';

if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _kill_thread!';

{{{ makeSetValue('pthread_ptr', C_STRUCTS.pthread.self, 0, 'i32') }}};

var pthread = PThread.pthreads[pthread_ptr];

pthread.worker.terminate();

PThread.freeThreadData(pthread);

// The worker was completely nuked (not just the pthread execution it was hosting), so remove it from running workers

// but don't put it back to the pool.

PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(pthread.worker.pthread), 1); // Not a running Worker anymore.

pthread.worker.pthread = undefined;

},

_cleanup_thread: function(pthread_ptr) {

if (ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _cleanup_thread() can only ever be called from main JS thread!';

if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _cleanup_thread!';

{{{ makeSetValue('pthread_ptr', C_STRUCTS.pthread.self, 0, 'i32') }}};

var pthread = PThread.pthreads[pthread_ptr];

var worker = pthread.worker;

PThread.freeThreadData(pthread);

worker.pthread = undefined; // Detach the worker from the pthread object, and return it to the worker pool as an unused worker.

PThread.unusedWorkerPool.push(worker);

PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker.pthread), 1); // Not a running Worker anymore.

},

_cancel_thread: function(pthread_ptr) {

if (ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _cancel_thread() can only ever be called from main JS thread!';

if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _cancel_thread!';

var pthread = PThread.pthreads[pthread_ptr];

pthread.worker.postMessage({ cmd: 'cancel' });

},

_spawn_thread: function(threadParams) {

if (ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _spawn_thread() can only ever be called from main JS thread!';

var worker = PThread.getNewWorker();

if (worker.pthread !== undefined) throw 'Internal error!';

if (!threadParams.pthread_ptr) throw 'Internal error, no pthread ptr!';

PThread.runningWorkers.push(worker);

// Allocate memory for thread-local storage and initialize it to zero.

var tlsMemory = _malloc({{{ cDefine('PTHREAD_KEYS_MAX') }}} * 4);

for (var i = 0; i < {{{ cDefine('PTHREAD_KEYS_MAX') }}}; ++i) {

{{{ makeSetValue('tlsMemory', 'i*4', 0, 'i32') }}};

}

var pthread = PThread.pthreads[threadParams.pthread_ptr] = { // Create a pthread info object to represent this thread.

worker: worker,

stackBase: threadParams.stackBase,

stackSize: threadParams.stackSize,

allocatedOwnStack: threadParams.allocatedOwnStack,

thread: threadParams.pthread_ptr,

threadInfoStruct: threadParams.pthread_ptr // Info area for this thread in Emscripten HEAP (shared)

};

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 0); // threadStatus <- 0, meaning not yet exited.

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.threadExitCode }}} ) >> 2, 0); // threadExitCode <- 0.

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.detached }}} ) >> 2, threadParams.detached);

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.tsd }}} ) >> 2, tlsMemory); // Init thread-local-storage memory array.

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.tsd_used }}} ) >> 2, 0); // Mark initial status to unused.

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.tid }}} ) >> 2, pthread.threadInfoStruct); // Main thread ID.

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.pid }}} ) >> 2, PROCINFO.pid); // Process ID.

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.attr }}}) >> 2, threadParams.stackSize);

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.stack_size }}}) >> 2, threadParams.stackSize);

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.stack }}}) >> 2, threadParams.stackBase);

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.attr }}} + 8) >> 2, threadParams.stackBase);

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.attr }}} + 12) >> 2, threadParams.detached);

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.attr }}} + 20) >> 2, threadParams.schedPolicy);

Atomics.store(HEAPU32, (pthread.threadInfoStruct + {{{ C_STRUCTS.pthread.attr }}} + 24) >> 2, threadParams.schedPrio);

worker.pthread = pthread;

// Ask the worker to start executing its pthread entry point function.

worker.postMessage({

cmd: 'run',

start_routine: threadParams.startRoutine,

arg: threadParams.arg,

threadInfoStruct: threadParams.pthread_ptr,

selfThreadId: threadParams.pthread_ptr, // TODO: Remove this since thread ID is now the same as the thread address.

stackBase: threadParams.stackBase,

stackSize: threadParams.stackSize

});

},

#if USE_PTHREADS

_num_logical_cores__deps: ['emscripten_force_num_logical_cores'],

_num_logical_cores: '; if (ENVIRONMENT_IS_PTHREAD) __num_logical_cores = PthreadWorkerInit.__num_logical_cores; else { PthreadWorkerInit.__num_logical_cores = __num_logical_cores = allocate(1, "i32*", ALLOC_STATIC); HEAPU32[__num_logical_cores>>2] = navigator["hardwareConcurrency"] || ' + {{{ PTHREAD_HINT_NUM_CORES }}} + '; }',

#else

_num_logical_cores: 'allocate(1, "i32*", ALLOC_STATIC)',

#endif

emscripten_has_threading_support: function() {

#if USE_PTHREADS

return typeof SharedArrayBuffer !== 'undefined';

#else

return 0;

#endif

},

emscripten_num_logical_cores__deps: ['_num_logical_cores'],

emscripten_num_logical_cores: function() {

return {{{ makeGetValue('__num_logical_cores', 0, 'i32') }}};

},

emscripten_force_num_logical_cores: function(cores) {

{{{ makeSetValue('__num_logical_cores', 0, 'cores', 'i32') }}};

},

pthread_create__deps: ['_spawn_thread', 'pthread_getschedparam', 'pthread_self'],

pthread_create: function(pthread_ptr, attr, start_routine, arg) {

// When running in PROXY_TO_WORKER=1 mode, the pthread creation needs to be forwarded to the main browser thread, and not the main C runtime thread,

// so the following is valid only when in non-proxy-to-worker mode.

#if !PROXY_TO_WORKER

if (ENVIRONMENT_IS_PTHREAD) return _emscripten_sync_run_in_main_thread_4({{{ cDefine('EM_PROXIED_PTHREAD_CREATE') }}}, pthread_ptr, attr, start_routine, arg);

#endif

if (typeof SharedArrayBuffer === 'undefined') {

Module['printErr']('Current environment does not support SharedArrayBuffer, pthreads are not available!');

return {{{ cDefine('EAGAIN') }}};

}

if (!pthread_ptr) {

Module['printErr']('pthread_create called with a null thread pointer!');

return {{{ cDefine('EINVAL') }}};

}

var stackSize = 0;

var stackBase = 0;

var detached = 0; // Default thread attr is PTHREAD_CREATE_JOINABLE, i.e. start as not detached.

var schedPolicy = 0; /*SCHED_OTHER*/

var schedPrio = 0;

if (attr) {

stackSize = {{{ makeGetValue('attr', 0, 'i32') }}};

stackBase = {{{ makeGetValue('attr', 8, 'i32') }}};

detached = {{{ makeGetValue('attr', 12/*_a_detach*/, 'i32') }}} != 0/*PTHREAD_CREATE_JOINABLE*/;

var inheritSched = {{{ makeGetValue('attr', 16/*_a_sched*/, 'i32') }}} == 0/*PTHREAD_INHERIT_SCHED*/;

if (inheritSched) {

var prevSchedPolicy = {{{ makeGetValue('attr', 20/*_a_policy*/, 'i32') }}};

var prevSchedPrio = {{{ makeGetValue('attr', 24/*_a_prio*/, 'i32') }}};

_pthread_getschedparam(_pthread_self(), attr + 20, attr + 24);

schedPolicy = {{{ makeGetValue('attr', 20/*_a_policy*/, 'i32') }}};

schedPrio = {{{ makeGetValue('attr', 24/*_a_prio*/, 'i32') }}};

{{{ makeSetValue('attr', 20/*_a_policy*/, 'prevSchedPolicy', 'i32') }}};

{{{ makeSetValue('attr', 24/*_a_prio*/, 'prevSchedPrio', 'i32') }}};

} else {

schedPolicy = {{{ makeGetValue('attr', 20/*_a_policy*/, 'i32') }}};

schedPrio = {{{ makeGetValue('attr', 24/*_a_prio*/, 'i32') }}};

}

}

stackSize += 81920 /*DEFAULT_STACK_SIZE*/;

var allocatedOwnStack = stackBase == 0; // If allocatedOwnStack == true, then the pthread impl maintains the stack allocation.

if (allocatedOwnStack) {

stackBase = _malloc(stackSize); // Allocate a stack if the user doesn't want to place the stack in a custom memory area.

} else {

// Musl stores the stack base address assuming stack grows downwards, so adjust it to Emscripten convention that the

// stack grows upwards instead.

stackBase -= stackSize;

assert(stackBase > 0);

}

// Allocate thread block (pthread_t structure).

var threadInfoStruct = _malloc({{{ C_STRUCTS.pthread.__size__ }}});

for (var i = 0; i < {{{ C_STRUCTS.pthread.__size__ }}} >> 2; ++i) HEAPU32[(threadInfoStruct>>2) + i] = 0; // zero-initialize thread structure.

{{{ makeSetValue('pthread_ptr', 0, 'threadInfoStruct', 'i32') }}};

// The pthread struct has a field that points to itself - this is used as a magic ID to detect whether the pthread_t

// structure is 'alive'.

{{{ makeSetValue('threadInfoStruct', C_STRUCTS.pthread.self, 'threadInfoStruct', 'i32') }}};

var threadParams = {

stackBase: stackBase,

stackSize: stackSize,

allocatedOwnStack: allocatedOwnStack,

schedPolicy: schedPolicy,

schedPrio: schedPrio,

detached: detached,

startRoutine: start_routine,

pthread_ptr: threadInfoStruct,

arg: arg,

};

if (ENVIRONMENT_IS_WORKER) {

// The prepopulated pool of web workers that can host pthreads is stored in the main JS thread. Therefore if a

// pthread is attempting to spawn a new thread, the thread creation must be deferred to the main JS thread.

threadParams.cmd = 'spawnThread';

postMessage(threadParams);

} else {

// We are the main thread, so we have the pthread warmup pool in this thread and can fire off JS thread creation

// directly ourselves.

__spawn_thread(threadParams);

}

return 0;

},

// TODO HACK! Remove this function, it is a JS side copy of the function pthread_testcancel() in library_pthread.c.

// Just call pthread_testcancel() everywhere.

_pthread_testcancel_js: function() {

if (!ENVIRONMENT_IS_PTHREAD) return;

if (!threadInfoStruct) return;

var cancelDisabled = Atomics.load(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.canceldisable }}} ) >> 2);

if (cancelDisabled) return;

var canceled = Atomics.load(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2);

if (canceled == 2) throw 'Canceled!';

},

pthread_join__deps: ['_cleanup_thread', '_pthread_testcancel_js'],

pthread_join: function(thread, status) {

if (!thread) {

Module['printErr']('pthread_join attempted on a null thread pointer!');

return ERRNO_CODES.ESRCH;

}

if (ENVIRONMENT_IS_PTHREAD && selfThreadId == thread) {

Module['printErr']('PThread ' + thread + ' is attempting to join to itself!');

return ERRNO_CODES.EDEADLK;

}

else if (!ENVIRONMENT_IS_PTHREAD && PThread.mainThreadBlock == thread) {

Module['printErr']('Main thread ' + thread + ' is attempting to join to itself!');

return ERRNO_CODES.EDEADLK;

}

var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};

if (self != thread) {

Module['printErr']('pthread_join attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');

return ERRNO_CODES.ESRCH;

}

var detached = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detached }}} ) >> 2);

if (detached) {

Module['printErr']('Attempted to join thread ' + thread + ', which was already detached!');

return ERRNO_CODES.EINVAL; // The thread is already detached, can no longer join it!

}

for (;;) {

var threadStatus = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2);

if (threadStatus == 1) { // Exited?

var threadExitCode = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadExitCode }}} ) >> 2);

if (status) {{{ makeSetValue('status', 0, 'threadExitCode', 'i32') }}};

Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detached }}} ) >> 2, 1); // Mark the thread as detached.

if (!ENVIRONMENT_IS_WORKER) __cleanup_thread(thread);

else postMessage({ cmd: 'cleanupThread', thread: thread});

return 0;

}

// TODO HACK! Replace the _js variant with just _pthread_testcancel:

//_pthread_testcancel();

__pthread_testcancel_js();

// In main runtime thread (the thread that initialized the Emscripten C runtime and launched main()), assist pthreads in performing operations

// that they need to access the Emscripten main runtime for.

if (!ENVIRONMENT_IS_PTHREAD) _emscripten_main_thread_process_queued_calls();

_emscripten_futex_wait(thread + {{{ C_STRUCTS.pthread.threadStatus }}}, threadStatus, 100);

}

},

pthread_kill__deps: ['_kill_thread'],

pthread_kill: function(thread, signal) {

if (signal < 0 || signal >= 65/*_NSIG*/) return ERRNO_CODES.EINVAL;

if (thread == PThread.MAIN_THREAD_ID) {

if (signal == 0) return 0; // signal == 0 is a no-op.

Module['printErr']('Main thread (id=' + thread + ') cannot be killed with pthread_kill!');

return ERRNO_CODES.ESRCH;

}

if (!thread) {

Module['printErr']('pthread_kill attempted on a null thread pointer!');

return ERRNO_CODES.ESRCH;

}

var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};

if (self != thread) {

Module['printErr']('pthread_kill attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');

return ERRNO_CODES.ESRCH;

}

if (signal != 0) {

if (!ENVIRONMENT_IS_WORKER) __kill_thread(thread);

else postMessage({ cmd: 'killThread', thread: thread});

}

return 0;

},

pthread_cancel__deps: ['_cancel_thread'],

pthread_cancel: function(thread) {

if (thread == PThread.MAIN_THREAD_ID) {

Module['printErr']('Main thread (id=' + thread + ') cannot be canceled!');

return ERRNO_CODES.ESRCH;

}

if (!thread) {

Module['printErr']('pthread_cancel attempted on a null thread pointer!');

return ERRNO_CODES.ESRCH;

}

var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};

if (self != thread) {

Module['printErr']('pthread_cancel attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');

return ERRNO_CODES.ESRCH;

}

Atomics.compareExchange(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 0, 2); // Signal the thread that it needs to cancel itself.

if (!ENVIRONMENT_IS_WORKER) __cancel_thread(thread);

else postMessage({ cmd: 'cancelThread', thread: thread});

return 0;

},

pthread_detach: function(thread) {

if (!thread) {

Module['printErr']('pthread_detach attempted on a null thread pointer!');

return ERRNO_CODES.ESRCH;

}

var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};

if (self != thread) {

Module['printErr']('pthread_detach attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');

return ERRNO_CODES.ESRCH;

}

var threadStatus = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2);

// Follow musl convention: detached:0 means not detached, 1 means the thread was created as detached, and 2 means that the thread was detached via pthread_detach.

var wasDetached = Atomics.compareExchange(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detached }}} ) >> 2, 0, 2);

return wasDetached ? (threadStatus == 0/*running*/ ? ERRNO_CODES.EINVAL : ERRNO_CODES.ESRCH) : 0;

},

pthread_exit__deps: ['exit'],

pthread_exit: function(status) {

if (!ENVIRONMENT_IS_PTHREAD) _exit(status);

else PThread.threadExit(status);

},

// Public pthread_self() function which returns a unique ID for the thread.

pthread_self: function() {

if (ENVIRONMENT_IS_PTHREAD) return threadInfoStruct;

return PThread.mainThreadBlock; // Main JS thread.

},

emscripten_is_main_runtime_thread: function() {

return !ENVIRONMENT_IS_PTHREAD;

},

emscripten_is_main_browser_thread: function() {

return !ENVIRONMENT_IS_WORKER;

},

pthread_getschedparam: function(thread, policy, schedparam) {

if (!policy && !schedparam) return ERRNO_CODES.EINVAL;

if (!thread) {

Module['printErr']('pthread_getschedparam called with a null thread pointer!');

return ERRNO_CODES.ESRCH;

}

var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};

if (self != thread) {

Module['printErr']('pthread_getschedparam attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');

return ERRNO_CODES.ESRCH;

}

var schedPolicy = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.attr }}} + 20 ) >> 2);

var schedPrio = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.attr }}} + 24 ) >> 2);

if (policy) {{{ makeSetValue('policy', 0, 'schedPolicy', 'i32') }}};

if (schedparam) {{{ makeSetValue('schedparam', 0, 'schedPrio', 'i32') }}};

return 0;

},

pthread_setschedparam: function(thread, policy, schedparam) {

if (!thread) {

Module['printErr']('pthread_setschedparam called with a null thread pointer!');

return ERRNO_CODES.ESRCH;

}

var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};

if (self != thread) {

Module['printErr']('pthread_setschedparam attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');

return ERRNO_CODES.ESRCH;

}

if (!schedparam) return ERRNO_CODES.EINVAL;

var newSchedPrio = {{{ makeGetValue('schedparam', 0, 'i32') }}};

if (newSchedPrio < 0) return ERRNO_CODES.EINVAL;

if (policy == 1/*SCHED_FIFO*/ || policy == 2/*SCHED_RR*/) {

if (newSchedPrio > 99) return ERRNO_CODES.EINVAL;

} else {

if (newSchedPrio > 1) return ERRNO_CODES.EINVAL;

}

Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.attr }}} + 20) >> 2, policy);

Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.attr }}} + 24) >> 2, newSchedPrio);

return 0;

},

// Marked as obsolescent in pthreads specification: http://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_getconcurrency.html

pthread_getconcurrency: function() {

return 0;

},

// Marked as obsolescent in pthreads specification.

pthread_setconcurrency: function(new_level) {

// no-op

return 0;

},

pthread_mutexattr_getprioceiling: function(attr, prioceiling) {

// Not supported either in Emscripten or musl, return a faked value.

if (prioceiling) {{{ makeSetValue('prioceiling', 0, 99, 'i32') }}};

return 0;

},

pthread_mutexattr_setprioceiling: function(attr, prioceiling) {

// Not supported either in Emscripten or musl, return an error.

return ERRNO_CODES.EPERM;

},

pthread_getcpuclockid: function(thread, clock_id) {

return ERRNO_CODES.ENOENT; // pthread API recommends returning this error when "Per-thread CPU time clocks are not supported by the system."

},

pthread_setschedprio: function(thread, prio) {

if (!thread) {

Module['printErr']('pthread_setschedprio called with a null thread pointer!');

return ERRNO_CODES.ESRCH;

}

var self = {{{ makeGetValue('thread', C_STRUCTS.pthread.self, 'i32') }}};

if (self != thread) {

Module['printErr']('pthread_setschedprio attempted on thread ' + thread + ', which does not point to a valid thread, or does not exist anymore!');

return ERRNO_CODES.ESRCH;

}

if (prio < 0) return ERRNO_CODES.EINVAL;

var schedPolicy = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.attr }}} + 20 ) >> 2);

if (schedPolicy == 1/*SCHED_FIFO*/ || schedPolicy == 2/*SCHED_RR*/) {

if (prio > 99) return ERRNO_CODES.EINVAL;

} else {

if (prio > 1) return ERRNO_CODES.EINVAL;

}

Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.attr }}} + 24) >> 2, prio);

return 0;

},

pthread_cleanup_push: function(routine, arg) {

if (PThread.exitHandlers === null) {

PThread.exitHandlers = [];

if (!ENVIRONMENT_IS_PTHREAD) {

__ATEXIT__.push(function() { PThread.runExitHandlers(); });

}

}

PThread.exitHandlers.push(function() { Runtime.dynCall('vi', routine, [arg]) });

},

pthread_cleanup_pop: function(execute) {

var routine = PThread.exitHandlers.pop();

if (execute) routine();

},

// pthread_sigmask - examine and change mask of blocked signals

pthread_sigmask: function(how, set, oldset) {

Module['printErr']('pthread_sigmask() is not supported: this is a no-op.');

return 0;

},

pthread_atfork: function(prepare, parent, child) {

Module['printErr']('fork() is not supported: pthread_atfork is a no-op.');

return 0;

},

// Returns 0 on success, or one of the values -ETIMEDOUT, -EWOULDBLOCK or -EINVAL on error.

emscripten_futex_wait: function(addr, val, timeout) {

if (addr <= 0 || addr > HEAP8.length || addr&3 != 0) return -{{{ cDefine('EINVAL') }}};

// dump('futex_wait addr:' + addr + ' by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');

var ret = Atomics.futexWait(HEAP32, addr >> 2, val, timeout);

// dump('futex_wait done by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');

if (ret == Atomics.TIMEDOUT) return -{{{ cDefine('ETIMEDOUT') }}};

if (ret == Atomics.NOTEQUAL) return -{{{ cDefine('EWOULDBLOCK') }}};

if (ret == 0) return 0;

throw 'Atomics.futexWait returned an unexpected value ' + ret;

},

// Returns the number of threads (>= 0) woken up, or the value -EINVAL on error.

// Pass count == INT_MAX to wake up all threads.

emscripten_futex_wake: function(addr, count) {

if (addr <= 0 || addr > HEAP8.length || addr&3 != 0 || count < 0) return -{{{ cDefine('EINVAL') }}};

// dump('futex_wake addr:' + addr + ' by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');

var ret = Atomics.futexWake(HEAP32, addr >> 2, count);

if (ret >= 0) return ret;

throw 'Atomics.futexWake returned an unexpected value ' + ret;

},

// Returns the number of threads (>= 0) woken up, or one of the values -EINVAL or -EAGAIN on error.

emscripten_futex_wake_or_requeue: function(addr, count, cmpValue, addr2) {

if (addr <= 0 || addr2 <= 0 || addr >= HEAP8.length || addr2 >= HEAP8.length || count < 0

|| addr&3 != 0 || addr2&3 != 0) {

return -{{{ cDefine('EINVAL') }}};

}

var ret = Atomics.futexWakeOrRequeue(HEAP32, addr >> 2, count, cmpValue, addr >> 2);

if (ret == Atomics.NOTEQUAL) return -{{{ cDefine('EAGAIN') }}};

if (ret >= 0) return ret;

throw 'Atomics.futexWakeOrRequeue returned an unexpected value ' + ret;

},

};

autoAddDeps(LibraryPThread, '$PThread');

mergeInto(LibraryManager.library, LibraryPThread);