The R13B03 release.OTP_R13B03

1 files changed, 1800 insertions, 0 deletions

diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
new file mode 100644
index 0000000000..1b64e23174
--- /dev/null
+++ b/erts/emulator/beam/global.h
@@ -0,0 +1,1800 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1996-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+
+#ifndef __GLOBAL_H__
+#define __GLOBAL_H__
+
+#include "sys.h"
+#include "erl_alloc.h"
+#include "erl_vm.h"
+#include "erl_node_container_utils.h"
+#include "hash.h"
+#include "index.h"
+#include "atom.h"
+#include "export.h"
+#include "module.h"
+#include "register.h"
+#include "erl_fun.h"
+#include "erl_node_tables.h"
+#include "benchmark.h"
+#include "erl_process.h"
+#include "erl_sys_driver.h"
+#include "erl_debug.h"
+
+typedef struct port Port;
+#include "erl_port_task.h"
+
+#define ERTS_MAX_NO_OF_ASYNC_THREADS 1024
+extern int erts_async_max_threads;
+#define ERTS_ASYNC_THREAD_MIN_STACK_SIZE 16	/* Kilo words */
+#define ERTS_ASYNC_THREAD_MAX_STACK_SIZE 8192	/* Kilo words */
+extern int erts_async_thread_suggested_stack_size;
+
+typedef struct erts_driver_t_ erts_driver_t;
+
+#define SMALL_IO_QUEUE 5   /* Number of fixed elements */
+
+typedef struct {
+    int size;       /* total size in bytes */
+
+    SysIOVec* v_start;
+    SysIOVec* v_end;
+    SysIOVec* v_head;
+    SysIOVec* v_tail;
+    SysIOVec  v_small[SMALL_IO_QUEUE];
+
+    ErlDrvBinary** b_start;
+    ErlDrvBinary** b_end;
+    ErlDrvBinary** b_head;
+    ErlDrvBinary** b_tail;
+    ErlDrvBinary*  b_small[SMALL_IO_QUEUE];
+} ErlIOQueue;
+
+typedef struct line_buf {  /* Buffer used in line oriented I/O */
+    int bufsiz;              /* Size of character buffer */
+    int ovlen;               /* Length of overflow data */
+    int ovsiz;               /* Actual size of overflow buffer */
+    char data[1];            /* Starting point of buffer data,
+			      data[0] is a flag indicating an unprocess CR,
+			      The rest is the overflow buffer. */
+} LineBuf;
+
+struct enif_environment_t /* ErlNifEnv */
+{
+    void* nif_data;
+    Process* proc;
+    Eterm* hp;
+    Eterm* hp_end;
+    unsigned heap_frag_sz;
+    int fpe_was_unmasked;
+};
+extern void erts_pre_nif(struct enif_environment_t*, Process*, void* nif_data);
+extern void erts_post_nif(struct enif_environment_t* env);
+extern Eterm erts_nif_taints(Process* p); 
+
+/*
+ * Port Specific Data.
+ *
+ * Only use PrtSD for very rarely used data.
+ */
+
+#define ERTS_PRTSD_SCHED_ID 0
+
+#define ERTS_PRTSD_SIZE 1
+
+typedef struct {
+    void *data[ERTS_PRTSD_SIZE];
+} ErtsPrtSD;
+
+#ifdef ERTS_SMP
+typedef struct ErtsXPortsList_ ErtsXPortsList;
+#endif
+
+/*
+ * Port locking:
+ *
+ * Locking is done either driver specific or port specific. When
+ * driver specific locking is used, all instances of the driver,
+ * i.e. ports running the driver, share the same lock. When port
+ * specific locking is used each instance have its own lock.
+ *
+ * Most fields in the Port structure are protected by the lock
+ * referred to by the lock field. I'v called it the port lock.
+ * This lock is shared between all ports running the same driver
+ * when driver specific locking is used.
+ *
+ * The 'sched' field is protected by the port tasks lock
+ * (see erl_port_tasks.c)
+ *
+ * The 'status' field is protected by a combination of the port lock,
+ * the port tasks lock, and the state_lck. It may be read if
+ * the state_lck, or the port lock is held. It may only be
+ * modified if both the port lock and the state_lck is held
+ * (with one exception; see below). When changeing status from alive
+ * to dead or vice versa, also the port task lock has to be held.
+ * This in order to guarantee that tasks are scheduled only for
+ * ports that are alive.
+ *
+ * The status field may be modified with only the state_lck
+ * held when status is changed from dead to alive. This since no
+ * threads can have any references to the port other than via the
+ * port table.
+ *
+ * /rickard
+ */
+
+struct port {
+    ErtsPortTaskSched sched;
+    ErtsPortTaskHandle timeout_task;
+#ifdef ERTS_SMP
+    erts_smp_atomic_t refc;
+    erts_smp_mtx_t *lock;
+    ErtsXPortsList *xports;
+    erts_smp_atomic_t run_queue;
+    erts_smp_spinlock_t state_lck;  /* protects: id, status, snapshot */
+#endif
+    Eterm id;                   /* The Port id of this port */
+    Eterm connected;            /* A connected process */
+    Eterm caller;		/* Current caller. */
+    Eterm data;			/* Data associated with port. */
+    ErlHeapFragment* bp;	/* Heap fragment holding data (NULL if imm data). */
+    ErtsLink *nlinks;
+    ErtsMonitor *monitors;      /* Only MON_ORIGIN monitors of pid's */
+    Uint bytes_in;		/* Number of bytes read */
+    Uint bytes_out;		/* Number of bytes written */
+#ifdef ERTS_SMP
+    ErtsSmpPTimer *ptimer;
+#else
+    ErlTimer tm;                 /* Timer entry */
+#endif
+    
+    Eterm tracer_proc;		/* If the port is traced, this is the tracer */
+    Uint trace_flags;		/* Trace flags */
+
+    ErlIOQueue ioq;              /* driver accessible i/o queue */
+    DistEntry *dist_entry;       /* Dist entry used in DISTRIBUTION */
+    char *name;		         /* String used in the open */
+    erts_driver_t* drv_ptr;
+    long drv_data;
+    ErtsProcList *suspended;	 /* List of suspended processes. */
+    LineBuf *linebuf;            /* Buffer to hold data not ready for
+				    process to get (line oriented I/O)*/
+    Uint32 status;		 /* Status and type flags */
+    int control_flags;		 /* Flags for port_control()  */
+    Uint32 snapshot;             /* Next snapshot that port should be part of */
+    struct reg_proc *reg;
+    ErlDrvPDL port_data_lock;
+
+    ErtsPrtSD *psd;		 /* Port specific data */
+};
+
+
+ERTS_GLB_INLINE ErtsRunQueue *erts_port_runq(Port *prt);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE ErtsRunQueue *
+erts_port_runq(Port *prt)
+{
+#ifdef ERTS_SMP
+    ErtsRunQueue *rq1, *rq2;
+    rq1 = (ErtsRunQueue *) erts_smp_atomic_read(&prt->run_queue);
+    while (1) {
+	erts_smp_runq_lock(rq1);
+	rq2 = (ErtsRunQueue *) erts_smp_atomic_read(&prt->run_queue);
+	if (rq1 == rq2)
+	    return rq1;
+	erts_smp_runq_unlock(rq1);
+	rq1 = rq2;
+    }
+#else
+    return erts_common_run_queue;
+#endif
+}
+
+#endif
+
+
+ERTS_GLB_INLINE void *erts_prtsd_get(Port *p, int ix);
+ERTS_GLB_INLINE void *erts_prtsd_set(Port *p, int ix, void *new);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE void *
+erts_prtsd_get(Port *prt, int ix)
+{
+    return prt->psd ? prt->psd->data[ix] : NULL;
+}
+
+ERTS_GLB_INLINE void *
+erts_prtsd_set(Port *prt, int ix, void *data)
+{
+    if (prt->psd) {
+	void *old = prt->psd->data[ix];
+	prt->psd->data[ix] = data;
+	return old;
+    }
+    else {
+	prt->psd = erts_alloc(ERTS_ALC_T_PRTSD, sizeof(ErtsPrtSD));
+	prt->psd->data[ix] = data;
+	return NULL;
+    }
+}
+
+#endif
+
+/* Driver handle (wrapper for old plain handle) */
+#define ERL_DE_OK      0
+#define ERL_DE_UNLOAD  1
+#define ERL_DE_FORCE_UNLOAD 2 
+#define ERL_DE_RELOAD  3
+#define ERL_DE_FORCE_RELOAD  4
+#define ERL_DE_PERMANENT 5
+
+#define ERL_DE_PROC_LOADED 0
+#define ERL_DE_PROC_AWAIT_UNLOAD 1
+#define ERL_DE_PROC_AWAIT_UNLOAD_ONLY 2
+#define ERL_DE_PROC_AWAIT_LOAD 3
+
+/* Flags for process entries */
+#define ERL_DE_FL_DEREFERENCED 1
+
+/* Flags for drivers, put locking policy here /PaN */
+#define ERL_DE_FL_KILL_PORTS 1
+
+#define ERL_FL_CONSISTENT_MASK ( ERL_DE_FL_KILL_PORTS )
+
+/* System specific load errors are returned as positive values */
+#define ERL_DE_NO_ERROR 0
+#define ERL_DE_LOAD_ERROR_NO_INIT -1
+#define ERL_DE_LOAD_ERROR_FAILED_INIT -2
+#define ERL_DE_LOAD_ERROR_BAD_NAME -3
+#define ERL_DE_LOAD_ERROR_NAME_TO_LONG -4
+#define ERL_DE_LOAD_ERROR_INCORRECT_VERSION -5
+#define ERL_DE_ERROR_NO_DDLL_FUNCTIONALITY -6
+#define ERL_DE_ERROR_UNSPECIFIED -7
+#define ERL_DE_LOOKUP_ERROR_NOT_FOUND -8
+#define ERL_DE_DYNAMIC_ERROR_OFFSET -10
+
+typedef struct de_proc_entry {
+    Process *proc;                   /* The process... */
+    Uint    awaiting_status;         /* PROC_LOADED == Have loaded the driver
+			                PROC_AWAIT_UNLOAD == Wants to be notified 
+			                when we have unloaded the driver (was locked)
+			                PROC_AWAIT_LOAD == Wants to be notified when we
+			                reloaded the driver (old was locked) */
+    Uint    flags;                   /* ERL_FL_DE_DEREFERENCED when reload in progress */
+    Eterm   heap[REF_THING_SIZE];    /* "ref heap" */
+    struct  de_proc_entry *next;
+} DE_ProcEntry;
+
+typedef struct {
+    void         *handle;             /* Handle for DLL or SO (for dyn. drivers). */
+    DE_ProcEntry *procs;              /* List of pids that have loaded this driver,
+				         or that wait for it to change state */
+    erts_refc_t  refc;                /* Number of ports/processes having
+					 references to the driver */
+    Uint         port_count;          /* Number of ports using the driver */
+    Uint         flags;               /* ERL_DE_FL_KILL_PORTS */
+    int          status;              /* ERL_DE_xxx */
+    char         *full_path;          /* Full path of the driver */
+    char         *reload_full_path;   /* If status == ERL_DE_RELOAD, this contains
+				         full name of driver (path) */
+    char         *reload_driver_name; /* ... and this contains the driver name */
+    Uint         reload_flags;        /* flags for reloaded driver */
+} DE_Handle;
+
+/*
+ * This structure represents a link to the next driver.
+ */
+
+struct erts_driver_t_ {
+    erts_driver_t *next;
+    erts_driver_t *prev;
+    char *name;
+    struct {
+	int major;
+	int minor;
+    } version;
+    int flags;
+    DE_Handle *handle;
+#ifdef ERTS_SMP
+    erts_smp_mtx_t *lock;
+#endif
+    ErlDrvEntry *entry;
+    ErlDrvData (*start)(ErlDrvPort port, char *command, SysDriverOpts* opts);
+    void (*stop)(ErlDrvData drv_data);
+    void (*finish)(void);
+    void (*flush)(ErlDrvData drv_data);
+    void (*output)(ErlDrvData drv_data, char *buf, int len);
+    void (*outputv)(ErlDrvData drv_data, ErlIOVec *ev); /* Might be NULL */
+    int (*control)(ErlDrvData drv_data, unsigned int command, char *buf, 
+		   int len, char **rbuf, int rlen); /* Might be NULL */
+    int (*call)(ErlDrvData drv_data, unsigned int command, char *buf, 
+		int len, char **rbuf, int rlen, unsigned int *flags); /* Might be NULL */ 
+    void (*event)(ErlDrvData drv_data, ErlDrvEvent event,
+		  ErlDrvEventData event_data);
+    void (*ready_input)(ErlDrvData drv_data, ErlDrvEvent event); 
+    void (*ready_output)(ErlDrvData drv_data, ErlDrvEvent event);  
+    void (*timeout)(ErlDrvData drv_data);
+    void (*ready_async)(ErlDrvData drv_data, ErlDrvThreadData thread_data); /* Might be NULL */ 
+    void (*process_exit)(ErlDrvData drv_data, ErlDrvMonitor *monitor);
+    void (*stop_select)(ErlDrvEvent event, void*); /* Might be NULL */
+};
+
+extern erts_driver_t *driver_list;
+extern erts_smp_mtx_t erts_driver_list_lock;
+
+extern void erts_ddll_init(void);
+extern void erts_ddll_lock_driver(DE_Handle *dh, char *name);
+
+/* These are for bookkeeping */
+extern void erts_ddll_increment_port_count(DE_Handle *dh);
+extern void erts_ddll_decrement_port_count(DE_Handle *dh);
+
+/* These makes things happen, drivers may be scheduled for unload etc */
+extern void erts_ddll_reference_driver(DE_Handle *dh);
+extern void erts_ddll_reference_referenced_driver(DE_Handle *dh);
+extern void erts_ddll_dereference_driver(DE_Handle *dh);
+
+extern char *erts_ddll_error(int code);
+extern void erts_ddll_proc_dead(Process *p, ErtsProcLocks plocks);
+extern int erts_ddll_driver_ok(DE_Handle *dh);
+extern void erts_ddll_remove_monitor(Process *p,
+				     Eterm ref,
+				     ErtsProcLocks plocks);
+extern Eterm erts_ddll_monitor_driver(Process *p,
+				      Eterm description,
+				      ErtsProcLocks plocks);
+/*
+ * Max no. of drivers (linked in and dynamically loaded). Each table
+ * entry uses 4 bytes.
+ */
+#define DRIVER_TAB_SIZE 32
+
+/*
+** Just like the driver binary but with initial flags
+** Note that the two structures Binary and ErlDrvBinary HAVE to
+** be equal except for extra fields in the beginning of the struct.
+** ErlDrvBinary is defined in erl_driver.h.
+** When driver_alloc_binary is called, a Binary is allocated, but 
+** the pointer returned is to the address of the first element that
+** also occurs in the ErlDrvBinary struct (driver.*binary takes care if this).
+** The driver need never know about additions to the internal Binary of the
+** emulator. One should however NEVER be sloppy when mixing ErlDrvBinary
+** and Binary, the macros below can convert one type to the other, as they both
+** in reality are equal.
+*/
+typedef struct binary {
+    Uint flags;
+    erts_refc_t refc;
+#ifdef ARCH_32
+    Uint32 align__; /* *DO NOT USE* only for alignment. */
+#endif
+    /* Add fields BEFORE this, otherwise the drivers crash */
+    long orig_size;
+    char orig_bytes[1]; /* to be continued */
+} Binary;
+
+/*
+ * 'Binary' alignment:
+ *   Address of orig_bytes[0] of a Binary should always be 8-byte aligned.
+ * It is assumed that the flags, refc, and orig_size fields are 4 bytes on
+ * 32-bits architectures and 8 bytes on 64-bits architectures.
+ */
+
+/*
+ * "magic" binary.
+ */
+typedef struct {
+    void (*destructor)(Binary *);
+    char magic_bin_data[1];
+} ErtsBinaryMagicPart;
+
+#define ERTS_MAGIC_BIN_DESTRUCTOR(BP) \
+  (((ErtsBinaryMagicPart *) (BP)->orig_bytes)->destructor)
+#define ERTS_MAGIC_BIN_DATA(BP) \
+  ((void *) (((ErtsBinaryMagicPart *) (BP)->orig_bytes)->magic_bin_data))
+#define ERTS_MAGIC_BIN_DATA_SIZE(BP) \
+  ((BP)->orig_size - (sizeof(ErtsBinaryMagicPart) - 1))
+
+#define Binary2ErlDrvBinary(B) ((ErlDrvBinary *) (&((B)->orig_size)))
+#define ErlDrvBinary2Binary(D) ((Binary *) \
+				(((char *) (D)) - \
+				 ((char *) &(((Binary *) 0)->orig_size))))
+
+/* A "magic" binary flag */
+#define BIN_FLAG_MAGIC      1
+#define BIN_FLAG_USR1       2 /* Reserved for use by different modules too mark */
+#define BIN_FLAG_USR2       4 /*  certain binaries as special (used by ets) */
+#define BIN_FLAG_DRV        8
+
+/*
+ * This structure represents one type of a binary in a process.
+ */
+
+typedef struct proc_bin {
+    Eterm thing_word;		/* Subtag REFC_BINARY_SUBTAG. */
+    Uint size;			/* Binary size in bytes. */
+    struct proc_bin *next;	/* Pointer to next ProcBin. */
+    Binary *val;		/* Pointer to Binary structure. */
+    byte *bytes;		/* Pointer to the actual data bytes. */
+    Uint flags;			/* Flag word. */
+} ProcBin;
+
+#define PB_IS_WRITABLE 1	/* Writable (only one reference to ProcBin) */
+#define PB_ACTIVE_WRITER 2	/* There is an active writer */
+
+/*
+ * ProcBin size in Eterm words.
+ */
+#define PROC_BIN_SIZE (sizeof(ProcBin)/sizeof(Eterm))
+
+ERTS_GLB_INLINE Eterm erts_mk_magic_binary_term(Eterm **hpp,
+						ErlOffHeap *ohp,
+						Binary *mbp);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE Eterm
+erts_mk_magic_binary_term(Eterm **hpp, ErlOffHeap *ohp, Binary *mbp)
+{
+    ProcBin *pb = (ProcBin *) *hpp;
+    *hpp += PROC_BIN_SIZE;
+
+    ASSERT(mbp->flags & BIN_FLAG_MAGIC);
+
+    pb->thing_word = HEADER_PROC_BIN;
+    pb->size = 0;
+    pb->next = ohp->mso;
+    ohp->mso = pb;
+    pb->val = mbp;
+    pb->bytes = (byte *) mbp->orig_bytes;
+    pb->flags = 0;
+
+    erts_refc_inc(&mbp->refc, 1);
+
+    return make_binary(pb);    
+}
+
+#endif
+
+#define ERTS_TERM_IS_MAGIC_BINARY(T) \
+  (is_binary((T)) \
+   && (thing_subtag(*binary_val((T))) == REFC_BINARY_SUBTAG) \
+   && (((ProcBin *) binary_val((T)))->val->flags & BIN_FLAG_MAGIC))
+
+/* arrays that get malloced at startup */
+extern Port* erts_port;
+extern erts_smp_atomic_t erts_ports_alive;
+
+extern Uint erts_max_ports;
+extern Uint erts_port_tab_index_mask;
+extern erts_smp_atomic_t erts_ports_snapshot;
+extern erts_smp_atomic_t erts_dead_ports_ptr;
+
+ERTS_GLB_INLINE void erts_may_save_closed_port(Port *prt);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE void erts_may_save_closed_port(Port *prt)
+{
+    ERTS_SMP_LC_ASSERT(erts_smp_lc_spinlock_is_locked(&prt->state_lck));
+    if (prt->snapshot != erts_smp_atomic_read(&erts_ports_snapshot)) {
+	/* Dead ports are added from the end of the snapshot buffer */
+	Eterm* tombstone = (Eterm*) erts_smp_atomic_addtest(&erts_dead_ports_ptr,
+							    -(long)sizeof(Eterm));
+	ASSERT(tombstone+1 != NULL);
+	ASSERT(prt->snapshot == (Uint32) erts_smp_atomic_read(&erts_ports_snapshot) - 1);
+	*tombstone = prt->id;
+    }
+    /*else no ongoing snapshot or port was already included or created after snapshot */
+}
+
+#endif
+
+/* controls warning mapping in error_logger */
+
+extern Eterm node_cookie;
+extern erts_smp_atomic_t erts_bytes_out;	/* no bytes written out */
+extern erts_smp_atomic_t erts_bytes_in;		/* no bytes sent into the system */
+extern Uint display_items;	/* no of items to display in traces etc */
+extern Uint display_loads;	/* print info about loaded modules */
+
+extern int erts_backtrace_depth;
+extern erts_smp_atomic_t erts_max_gen_gcs;
+
+extern int erts_disable_tolerant_timeofday;
+
+#ifdef HYBRID
+
+/* Message Area heap pointers */
+extern Eterm *global_heap;             /* Heap start */
+extern Eterm *global_hend;             /* Heap end */
+extern Eterm *global_htop;             /* Heap top (heap pointer) */
+extern Eterm *global_saved_htop;       /* Saved heap top (heap pointer) */
+extern Uint   global_heap_sz;          /* Heap size, in words */
+extern Eterm *global_old_heap;         /* Old generation */
+extern Eterm *global_old_hend;
+extern ErlOffHeap erts_global_offheap; /* Global MSO (OffHeap) list */
+
+extern Uint16 global_gen_gcs;
+extern Uint16 global_max_gen_gcs;
+extern Uint   global_gc_flags;
+
+#ifdef INCREMENTAL
+#define ACTIVATE(p)
+#define DEACTIVATE(p)
+#define IS_ACTIVE(p) 1
+
+#define INC_ACTIVATE(p) do {                                           \
+    if ((p)->active) {                                                 \
+        if ((p)->active_next != NULL) {                                \
+            (p)->active_next->active_prev = (p)->active_prev;          \
+            if ((p)->active_prev) {                                    \
+                (p)->active_prev->active_next = (p)->active_next;      \
+            } else {                                                   \
+                inc_active_proc = (p)->active_next;                    \
+            }                                                          \
+            inc_active_last->active_next = (p);                        \
+            (p)->active_next = NULL;                                   \
+            (p)->active_prev = inc_active_last;                        \
+            inc_active_last = (p);                                     \
+        }                                                              \
+    } else {                                                           \
+        (p)->active_next = NULL;                                       \
+        (p)->active_prev = inc_active_last;                            \
+        if (inc_active_last) {                                         \
+            inc_active_last->active_next = (p);                        \
+        } else {                                                       \
+            inc_active_proc = (p);                                     \
+        }                                                              \
+        inc_active_last = (p);                                         \
+        (p)->active = 1;                                               \
+    }                                                                  \
+} while(0);
+
+#define INC_DEACTIVATE(p) do {                                         \
+    ASSERT((p)->active == 1);                                          \
+    if ((p)->active_next == NULL) {                                    \
+        inc_active_last = (p)->active_prev;                            \
+    } else {                                                           \
+        (p)->active_next->active_prev = (p)->active_prev;              \
+    }                                                                  \
+    if ((p)->active_prev == NULL) {                                    \
+        inc_active_proc = (p)->active_next;                            \
+    } else {                                                           \
+        (p)->active_prev->active_next = (p)->active_next;              \
+    }                                                                  \
+    (p)->active = 0;                                                   \
+} while(0);
+
+#define INC_IS_ACTIVE(p)  ((p)->active != 0)
+
+#else
+extern Eterm *global_old_htop;
+extern Eterm *global_high_water;
+#define ACTIVATE(p)   (p)->active = 1;
+#define DEACTIVATE(p) (p)->active = 0;
+#define IS_ACTIVE(p)  ((p)->active != 0)
+#define INC_ACTIVATE(p)
+#define INC_IS_ACTIVE(p) 1
+#endif /* INCREMENTAL */
+
+#else
+#  define ACTIVATE(p)
+#  define DEACTIVATE(p)
+#  define IS_ACTIVE(p) 1
+#  define INC_ACTIVATE(p)
+#endif /* HYBRID */
+
+#ifdef HYBRID
+extern Uint global_heap_min_sz;
+#endif
+
+extern int bif_reductions;      /* reductions + fcalls (when doing call_bif) */
+extern int stackdump_on_exit;
+
+/*
+ * Here is an implementation of a lightweiht stack.
+ *
+ * Use it like this:
+ *
+ * DECLARE_ESTACK(Stack)	(At the start of a block)
+ * ...
+ * ESTACK_PUSH(Stack, Term)
+ * ...
+ * if (ESTACK_ISEMPTY(Stack)) {
+ *    Stack is empty
+ * } else {
+ *    Term = ESTACK_POP(Stack);
+ *    Process popped Term here
+ * }
+ * ...
+ * DESTROY_ESTACK(Stack)
+ */
+
+
+void erl_grow_stack(Eterm** start, Eterm** sp, Eterm** end);
+#define ESTK_CONCAT(a,b) a##b
+#define ESTK_SUBSCRIPT(s,i) *((Eterm *)((byte *)ESTK_CONCAT(s,_start) + (i)))
+#define DEF_ESTACK_SIZE (16)
+
+#define DECLARE_ESTACK(s)						\
+    Eterm ESTK_CONCAT(s,_default_stack)[DEF_ESTACK_SIZE];		\
+    Eterm* ESTK_CONCAT(s,_start) = ESTK_CONCAT(s,_default_stack);	\
+    Eterm* ESTK_CONCAT(s,_sp) = ESTK_CONCAT(s,_start);			\
+    Eterm* ESTK_CONCAT(s,_end) = ESTK_CONCAT(s,_start) + DEF_ESTACK_SIZE
+
+#define DESTROY_ESTACK(s)						\
+do {									\
+    if (ESTK_CONCAT(s,_start) != ESTK_CONCAT(s,_default_stack)) {	\
+	erts_free(ERTS_ALC_T_ESTACK, ESTK_CONCAT(s,_start));		\
+    }									\
+} while(0)
+
+#define ESTACK_PUSH(s, x)						\
+do {									\
+    if (ESTK_CONCAT(s,_sp) == ESTK_CONCAT(s,_end)) {			\
+	erl_grow_stack(&ESTK_CONCAT(s,_start), &ESTK_CONCAT(s,_sp),	\
+	               &ESTK_CONCAT(s,_end));				\
+    }									\
+    *ESTK_CONCAT(s,_sp)++ = (x);					\
+} while(0)
+
+#define ESTACK_PUSH2(s, x, y)						\
+do {									\
+    if (ESTK_CONCAT(s,_sp) > ESTK_CONCAT(s,_end) - 2) {			\
+	erl_grow_stack(&ESTK_CONCAT(s,_start), &ESTK_CONCAT(s,_sp),	\
+		&ESTK_CONCAT(s,_end));	\
+    }									\
+    *ESTK_CONCAT(s,_sp)++ = (x);					\
+    *ESTK_CONCAT(s,_sp)++ = (y);					\
+} while(0)
+
+#define ESTACK_PUSH3(s, x, y, z)					\
+do {									\
+    if (ESTK_CONCAT(s,_sp) > ESTK_CONCAT(s,_end) - 3) {			\
+	erl_grow_stack(&ESTK_CONCAT(s,_start), &ESTK_CONCAT(s,_sp),	\
+		&ESTK_CONCAT(s,_end));					\
+    }									\
+    *ESTK_CONCAT(s,_sp)++ = (x);					\
+    *ESTK_CONCAT(s,_sp)++ = (y);					\
+    *ESTK_CONCAT(s,_sp)++ = (z);					\
+} while(0)
+
+#define ESTACK_COUNT(s) (ESTK_CONCAT(s,_sp) - ESTK_CONCAT(s,_start))
+
+#define ESTACK_ISEMPTY(s) (ESTK_CONCAT(s,_sp) == ESTK_CONCAT(s,_start))
+#define ESTACK_POP(s) (*(--ESTK_CONCAT(s,_sp)))
+
+
+/* port status flags */
+
+#define ERTS_PORT_SFLG_CONNECTED	((Uint32) (1 <<  0))
+/* Port have begun exiting */
+#define ERTS_PORT_SFLG_EXITING		((Uint32) (1 <<  1))
+/* Distribution port */
+#define ERTS_PORT_SFLG_DISTRIBUTION	((Uint32) (1 <<  2))
+#define ERTS_PORT_SFLG_BINARY_IO	((Uint32) (1 <<  3))
+#define ERTS_PORT_SFLG_SOFT_EOF		((Uint32) (1 <<  4))
+/* Flow control */
+#define ERTS_PORT_SFLG_PORT_BUSY	((Uint32) (1 <<  5))
+/* Port is closing (no i/o accepted) */
+#define ERTS_PORT_SFLG_CLOSING		((Uint32) (1 <<  6))
+/* Send a closed message when terminating */
+#define ERTS_PORT_SFLG_SEND_CLOSED	((Uint32) (1 <<  7))
+/* Line orinted io on port */  
+#define ERTS_PORT_SFLG_LINEBUF_IO	((Uint32) (1 <<  8))
+/* Immortal port (only certain system ports) */
+#define ERTS_PORT_SFLG_IMMORTAL		((Uint32) (1 <<  9))
+#define ERTS_PORT_SFLG_FREE		((Uint32) (1 << 10))
+#define ERTS_PORT_SFLG_FREE_SCHEDULED	((Uint32) (1 << 11))
+#define ERTS_PORT_SFLG_INITIALIZING	((Uint32) (1 << 12))
+/* Port uses port specific locking (opposed to driver specific locking) */
+#define ERTS_PORT_SFLG_PORT_SPECIFIC_LOCK ((Uint32) (1 << 13))
+#define ERTS_PORT_SFLG_INVALID		((Uint32) (1 << 14))
+#ifdef DEBUG
+/* Only debug: make sure all flags aren't cleared unintentionally */
+#define ERTS_PORT_SFLG_PORT_DEBUG	((Uint32) (1 << 31))
+#endif
+
+/* Combinations of port status flags */ 
+#define ERTS_PORT_SFLGS_DEAD						\
+  (ERTS_PORT_SFLG_FREE							\
+   | ERTS_PORT_SFLG_FREE_SCHEDULED					\
+   | ERTS_PORT_SFLG_INITIALIZING)
+#define ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP				\
+  (ERTS_PORT_SFLGS_DEAD | ERTS_PORT_SFLG_INVALID)
+#define ERTS_PORT_SFLGS_INVALID_LOOKUP					\
+  (ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP				\
+   | ERTS_PORT_SFLG_CLOSING)
+#define ERTS_PORT_SFLGS_INVALID_TRACER_LOOKUP				\
+  (ERTS_PORT_SFLGS_INVALID_LOOKUP					\
+   | ERTS_PORT_SFLG_PORT_BUSY						\
+   | ERTS_PORT_SFLG_DISTRIBUTION)
+
+/* binary.c */
+
+void erts_emasculate_writable_binary(ProcBin* pb);
+Eterm erts_new_heap_binary(Process *p, byte *buf, int len, byte** datap);
+Eterm erts_new_mso_binary(Process*, byte*, int);
+Eterm new_binary(Process*, byte*, int);
+Eterm erts_realloc_binary(Eterm bin, size_t size);
+void erts_cleanup_mso(ProcBin* pb);
+
+/* erl_bif_info.c */
+
+void erts_bif_info_init(void);
+
+/* bif.c */
+Eterm erts_make_ref(Process *);
+Eterm erts_make_ref_in_buffer(Eterm buffer[REF_THING_SIZE]);
+void erts_queue_monitor_message(Process *,
+				ErtsProcLocks*,
+				Eterm,
+				Eterm,
+				Eterm,
+				Eterm);
+void erts_init_bif(void);
+
+/* erl_bif_port.c */
+
+/* erl_bif_trace.c */
+void erts_system_monitor_clear(Process *c_p);
+void erts_system_profile_clear(Process *c_p);
+
+/* beam_load.c */
+int erts_load_module(Process *c_p, ErtsProcLocks c_p_locks,
+		     Eterm group_leader, Eterm* mod, byte* code, int size);
+void init_load(void);
+Eterm* find_function_from_pc(Eterm* pc);
+Eterm erts_module_info_0(Process* p, Eterm module);
+Eterm erts_module_info_1(Process* p, Eterm module, Eterm what);
+Eterm erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info);
+
+/* break.c */
+void init_break_handler(void);
+void erts_set_ignore_break(void);
+void erts_replace_intr(void);
+void process_info(int, void *);
+void print_process_info(int, void *, Process*);
+void info(int, void *);
+void loaded(int, void *);
+
+/* config.c */
+
+__decl_noreturn void __noreturn erl_exit(int n, char*, ...);
+__decl_noreturn void __noreturn erl_exit0(char *, int, int n, char*, ...);
+void erl_error(char*, va_list);
+
+#define ERL_EXIT0(n,f)		erl_exit0(__FILE__, __LINE__, n, f)
+#define ERL_EXIT1(n,f,a)	erl_exit0(__FILE__, __LINE__, n, f, a)
+#define ERL_EXIT2(n,f,a,b)	erl_exit0(__FILE__, __LINE__, n, f, a, b)
+#define ERL_EXIT3(n,f,a,b,c)	erl_exit0(__FILE__, __LINE__, n, f, a, b, c)
+
+/* copy.c */
+void init_copy(void);
+Eterm copy_object(Eterm, Process*);
+Uint size_object(Eterm);
+Eterm copy_struct(Eterm, Uint, Eterm**, ErlOffHeap*);
+Eterm copy_shallow(Eterm*, Uint, Eterm**, ErlOffHeap*);
+
+#ifdef HYBRID
+#define RRMA_DEFAULT_SIZE 256
+#define RRMA_STORE(p,ptr,src) do {                                      \
+  ASSERT((p)->rrma != NULL);                                            \
+  ASSERT((p)->rrsrc != NULL);                                           \
+  (p)->rrma[(p)->nrr] = (ptr);                                          \
+  (p)->rrsrc[(p)->nrr++] = (src);                                       \
+  if ((p)->nrr == (p)->rrsz)                                            \
+  {                                                                     \
+      (p)->rrsz *= 2;                                                   \
+      (p)->rrma = (Eterm *) erts_realloc(ERTS_ALC_T_ROOTSET,            \
+                                         (void*)(p)->rrma,              \
+                                         sizeof(Eterm) * (p)->rrsz);    \
+      (p)->rrsrc = (Eterm **) erts_realloc(ERTS_ALC_T_ROOTSET,          \
+                                           (void*)(p)->rrsrc,           \
+                                            sizeof(Eterm) * (p)->rrsz); \
+  }                                                                     \
+} while(0)
+
+/* Note that RRMA_REMOVE decreases the given index after deletion. 
+ * This is done so that a loop with an increasing index can call
+ * remove without having to decrease the index to see the element
+ * placed in the hole after the deleted element.
+ */
+#define RRMA_REMOVE(p,index) do {                                 \
+        p->rrsrc[index] = p->rrsrc[--p->nrr];                     \
+        p->rrma[index--] = p->rrma[p->nrr];                       \
+    } while(0);
+
+
+/* The MessageArea STACKs are used while copying messages to the
+ * message area.
+ */
+#define MA_STACK_EXTERNAL_DECLARE(type,_s_)     \
+    typedef type ma_##_s_##_type;               \
+    extern ma_##_s_##_type *ma_##_s_##_stack;   \
+    extern Uint ma_##_s_##_top;                 \
+    extern Uint ma_##_s_##_size;
+
+#define MA_STACK_DECLARE(_s_)                                           \
+    ma_##_s_##_type *ma_##_s_##_stack; Uint ma_##_s_##_top; Uint ma_##_s_##_size;
+
+#define MA_STACK_ALLOC(_s_) do {                                        \
+    ma_##_s_##_top = 0;                                                 \
+    ma_##_s_##_size = 512;                                              \
+    ma_##_s_##_stack = (ma_##_s_##_type*)erts_alloc(ERTS_ALC_T_OBJECT_STACK, \
+                       sizeof(ma_##_s_##_type) * ma_##_s_##_size);      \
+} while(0)
+
+
+#define MA_STACK_PUSH(_s_,val) do {                                     \
+    ma_##_s_##_stack[ma_##_s_##_top++] = (val);                         \
+    if (ma_##_s_##_top == ma_##_s_##_size)                              \
+    {                                                                   \
+        ma_##_s_##_size *= 2;                                           \
+        ma_##_s_##_stack =                                              \
+            (ma_##_s_##_type*) erts_realloc(ERTS_ALC_T_OBJECT_STACK,    \
+                                           (void*)ma_##_s_##_stack,     \
+                            sizeof(ma_##_s_##_type) * ma_##_s_##_size); \
+    }                                                                   \
+} while(0)
+
+#define MA_STACK_POP(_s_) (ma_##_s_##_top != 0 ? ma_##_s_##_stack[--ma_##_s_##_top] : 0)
+#define MA_STACK_TOP(_s_) (ma_##_s_##_stack[ma_##_s_##_top - 1])
+#define MA_STACK_UPDATE(_s_,offset,value)                               \
+  *(ma_##_s_##_stack[ma_##_s_##_top - 1] + (offset)) = (value)
+#define MA_STACK_SIZE(_s_) (ma_##_s_##_top)
+#define MA_STACK_ELM(_s_,i) ma_##_s_##_stack[i]
+
+MA_STACK_EXTERNAL_DECLARE(Eterm,src);
+MA_STACK_EXTERNAL_DECLARE(Eterm*,dst);
+MA_STACK_EXTERNAL_DECLARE(Uint,offset);
+
+
+#ifdef INCREMENTAL
+extern Eterm *ma_pending_stack;
+extern Uint ma_pending_top;
+extern Uint ma_pending_size;
+
+#define NO_COPY(obj) (IS_CONST(obj) ||                         \
+                      (((ptr_val(obj) >= global_heap) &&       \
+                        (ptr_val(obj) < global_htop)) ||       \
+                       ((ptr_val(obj) >= inc_fromspc) &&       \
+                        (ptr_val(obj) < inc_fromend)) ||       \
+                       ((ptr_val(obj) >= global_old_heap) &&   \
+                        (ptr_val(obj) < global_old_hend))))
+
+#else
+
+#define NO_COPY(obj) (IS_CONST(obj) ||                        \
+                      (((ptr_val(obj) >= global_heap) &&      \
+                        (ptr_val(obj) < global_htop)) ||      \
+                       ((ptr_val(obj) >= global_old_heap) &&  \
+                        (ptr_val(obj) < global_old_hend))))
+
+#endif /* INCREMENTAL */
+
+#define LAZY_COPY(from,obj) do {                     \
+  if (!NO_COPY(obj)) {                               \
+      BM_LAZY_COPY_START;                            \
+      BM_COUNT(messages_copied);                     \
+      obj = copy_struct_lazy(from,obj,0);            \
+      BM_LAZY_COPY_STOP;                             \
+  }                                                  \
+} while(0)
+
+Eterm copy_struct_lazy(Process*, Eterm, Uint);
+
+#endif /* HYBRID */
+
+/* Utilities */
+extern void erts_delete_nodes_monitors(Process *, ErtsProcLocks);
+extern Eterm erts_monitor_nodes(Process *, Eterm, Eterm);
+extern Eterm erts_processes_monitoring_nodes(Process *);
+extern int erts_do_net_exits(DistEntry*, Eterm);
+extern int distribution_info(int, void *);
+extern int is_node_name_atom(Eterm a);
+
+extern int erts_net_message(Port *, DistEntry *, byte *, int, byte *, int);
+
+extern void init_dist(void);
+extern int stop_dist(void);
+
+void erl_progressf(char* format, ...);
+
+#ifdef MESS_DEBUG
+void print_pass_through(int, byte*, int);
+#endif
+
+/* beam_emu.c */
+int catchlevel(Process*);
+void init_emulator(_VOID_);
+void process_main(void);
+Eterm build_stacktrace(Process* c_p, Eterm exc);
+Eterm expand_error_value(Process* c_p, Uint freason, Eterm Value);
+
+/* erl_init.c */
+
+typedef struct {
+    Eterm delay_time;
+    int context_reds;
+    int input_reds;
+} ErtsModifiedTimings;
+
+extern Export *erts_delay_trap;
+extern int erts_modified_timing_level;
+extern ErtsModifiedTimings erts_modified_timings[];
+#define ERTS_USE_MODIFIED_TIMING() \
+  (erts_modified_timing_level >= 0)
+#define ERTS_MODIFIED_TIMING_DELAY \
+  (erts_modified_timings[erts_modified_timing_level].delay_time)
+#define ERTS_MODIFIED_TIMING_CONTEXT_REDS \
+  (erts_modified_timings[erts_modified_timing_level].context_reds)
+#define ERTS_MODIFIED_TIMING_INPUT_REDS \
+  (erts_modified_timings[erts_modified_timing_level].input_reds)
+
+extern Eterm erts_error_logger_warnings;
+extern int erts_initialized;
+extern int erts_compat_rel;
+extern int erts_use_sender_punish;
+void erts_short_init(void);
+void erl_start(int, char**);
+void erts_usage(void);
+Eterm erts_preloaded(Process* p);
+/* erl_md5.c */
+
+typedef struct {
+    Uint32 state[4];		/* state (ABCD) */
+    Uint32 count[2];		/* number of bits, modulo 2^64 (lsb first) */
+    unsigned char buffer[64];	/* input buffer */
+} MD5_CTX;
+
+void MD5Init(MD5_CTX *);
+void MD5Update(MD5_CTX *, unsigned char *, unsigned int);
+void MD5Final(unsigned char [16], MD5_CTX *);
+
+/* ggc.c */
+
+
+typedef struct {
+    Uint garbage_collections;
+    Uint reclaimed;
+} ErtsGCInfo;
+
+void erts_gc_info(ErtsGCInfo *gcip);
+void erts_init_gc(void);
+int erts_garbage_collect(Process*, int, Eterm*, int);
+void erts_garbage_collect_hibernate(Process* p);
+Eterm erts_gc_after_bif_call(Process* p, Eterm result, Eterm* regs, Uint arity);
+void erts_garbage_collect_literals(Process* p, Eterm* literals, Uint lit_size);
+Uint erts_next_heap_size(Uint, Uint);
+Eterm erts_heap_sizes(Process* p);
+
+void erts_offset_off_heap(ErlOffHeap *, Sint, Eterm*, Eterm*);
+void erts_offset_heap_ptr(Eterm*, Uint, Sint, Eterm*, Eterm*);
+void erts_offset_heap(Eterm*, Uint, Sint, Eterm*, Eterm*);
+
+#ifdef HYBRID
+int erts_global_garbage_collect(Process*, int, Eterm*, int);
+#endif
+
+/* io.c */
+
+struct erl_drv_port_data_lock {
+    erts_mtx_t mtx;
+    erts_atomic_t refc;
+};
+
+typedef struct {
+    char *name;
+    char *driver_name;
+} ErtsPortNames;
+
+#define ERTS_SPAWN_DRIVER 1
+#define ERTS_SPAWN_EXECUTABLE 2
+#define ERTS_SPAWN_ANY (ERTS_SPAWN_DRIVER | ERTS_SPAWN_EXECUTABLE)
+
+int erts_add_driver_entry(ErlDrvEntry *drv, DE_Handle *handle, int driver_list_locked);
+void erts_destroy_driver(erts_driver_t *drv);
+void erts_wake_process_later(Port*, Process*);
+int erts_open_driver(erts_driver_t*, Eterm, char*, SysDriverOpts*, int *);
+int erts_is_port_ioq_empty(Port *);
+void erts_terminate_port(Port *);
+void close_port(Eterm);
+void init_io(void);
+void cleanup_io(void);
+void erts_do_exit_port(Port *, Eterm, Eterm);
+void erts_port_command(Process *, Eterm, Port *, Eterm);
+Eterm erts_port_control(Process*, Port*, Uint, Eterm);
+int erts_write_to_port(Eterm caller_id, Port *p, Eterm list);
+void print_port_info(int, void *, int);
+void erts_raw_port_command(Port*, byte*, Uint);
+void driver_report_exit(int, int);
+LineBuf* allocate_linebuf(int);
+int async_ready(Port *, void*);
+Sint erts_test_next_port(int, Uint);
+ErtsPortNames *erts_get_port_names(Eterm);
+void erts_free_port_names(ErtsPortNames *);
+Uint erts_port_ioq_size(Port *pp);
+void erts_stale_drv_select(Eterm, ErlDrvEvent, int, int);
+void erts_port_cleanup(Port *);
+void erts_fire_port_monitor(Port *prt, Eterm ref);
+#ifdef ERTS_SMP
+void erts_smp_xports_unlock(Port *);
+#endif
+
+#if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
+int erts_lc_is_port_locked(Port *);
+#endif
+
+ERTS_GLB_INLINE void erts_smp_port_state_lock(Port*);
+ERTS_GLB_INLINE void erts_smp_port_state_unlock(Port*);
+
+ERTS_GLB_INLINE int erts_smp_port_trylock(Port *prt);
+ERTS_GLB_INLINE void erts_smp_port_lock(Port *prt);
+ERTS_GLB_INLINE void erts_smp_port_unlock(Port *prt);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE void
+erts_smp_port_state_lock(Port* prt)
+{
+#ifdef ERTS_SMP
+    erts_smp_spin_lock(&prt->state_lck);
+#endif
+}
+
+ERTS_GLB_INLINE void
+erts_smp_port_state_unlock(Port *prt)
+{
+#ifdef ERTS_SMP
+    erts_smp_spin_unlock(&prt->state_lck);
+#endif
+}
+
+
+ERTS_GLB_INLINE int
+erts_smp_port_trylock(Port *prt)
+{
+#ifdef ERTS_SMP
+    int res;
+
+    ASSERT(erts_smp_atomic_read(&prt->refc) > 0);
+    erts_smp_atomic_inc(&prt->refc);
+    res = erts_smp_mtx_trylock(prt->lock);
+    if (res == EBUSY) {
+	erts_smp_atomic_dec(&prt->refc);
+    }
+
+    return res;
+#else /* !ERTS_SMP */
+    return 0;
+#endif
+}
+
+ERTS_GLB_INLINE void
+erts_smp_port_lock(Port *prt)
+{
+#ifdef ERTS_SMP
+    ASSERT(erts_smp_atomic_read(&prt->refc) > 0);
+    erts_smp_atomic_inc(&prt->refc);
+    erts_smp_mtx_lock(prt->lock);
+#endif
+}
+
+ERTS_GLB_INLINE void
+erts_smp_port_unlock(Port *prt)
+{
+#ifdef ERTS_SMP
+    long refc;
+    refc = erts_smp_atomic_dectest(&prt->refc);
+    ASSERT(refc >= 0);
+    if (refc == 0)
+	erts_port_cleanup(prt);
+    else
+	erts_smp_mtx_unlock(prt->lock);
+#endif
+}
+
+#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */
+
+
+#define ERTS_INVALID_PORT_OPT(PP, ID, FLGS) \
+  (!(PP) || ((PP)->status & (FLGS)) || (PP)->id != (ID))
+
+/* port lookup */
+
+#define INVALID_PORT(PP, ID) \
+  ERTS_INVALID_PORT_OPT((PP), (ID), ERTS_PORT_SFLGS_INVALID_LOOKUP)
+
+/* Invalidate trace port if anything suspicious, for instance
+ * that the port is a distribution port or it is busy.
+ */
+#define INVALID_TRACER_PORT(PP, ID)					\
+  ERTS_INVALID_PORT_OPT((PP), (ID), ERTS_PORT_SFLGS_INVALID_TRACER_LOOKUP)
+
+#define ERTS_PORT_SCHED_ID(P, ID) \
+  ((Uint) erts_prtsd_set((P), ERTS_PSD_SCHED_ID, (void *) (ID)))
+
+#ifdef ERTS_SMP
+Port *erts_de2port(DistEntry *, Process *, ErtsProcLocks);
+#endif
+
+#define erts_id2port(ID, P, PL) \
+  erts_id2port_sflgs((ID), (P), (PL), ERTS_PORT_SFLGS_INVALID_LOOKUP)
+
+ERTS_GLB_INLINE Port*erts_id2port_sflgs(Eterm, Process *, ErtsProcLocks, Uint32);
+ERTS_GLB_INLINE void erts_port_release(Port *);
+ERTS_GLB_INLINE Port*erts_drvport2port(ErlDrvPort);
+ERTS_GLB_INLINE Port*erts_drvportid2port(Eterm);
+ERTS_GLB_INLINE Uint32 erts_portid2status(Eterm id);
+ERTS_GLB_INLINE int erts_is_port_alive(Eterm id);
+ERTS_GLB_INLINE int erts_is_valid_tracer_port(Eterm id);
+ERTS_GLB_INLINE void erts_port_status_bandor_set(Port *, Uint32, Uint32);
+ERTS_GLB_INLINE void erts_port_status_band_set(Port *, Uint32);
+ERTS_GLB_INLINE void erts_port_status_bor_set(Port *, Uint32);
+ERTS_GLB_INLINE void erts_port_status_set(Port *, Uint32);
+ERTS_GLB_INLINE Uint32 erts_port_status_get(Port *);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE Port*
+erts_id2port_sflgs(Eterm id, Process *c_p, ErtsProcLocks c_p_locks, Uint32 sflgs)
+{
+#ifdef ERTS_SMP
+    int no_proc_locks = !c_p || !c_p_locks;
+#endif
+    Port *prt;
+
+    if (is_not_internal_port(id))
+	return NULL;
+
+    prt = &erts_port[internal_port_index(id)];
+
+    erts_smp_port_state_lock(prt);
+    if (ERTS_INVALID_PORT_OPT(prt, id, sflgs)) {
+	erts_smp_port_state_unlock(prt);
+	prt = NULL;
+    }
+#ifdef ERTS_SMP
+    else {
+	erts_smp_atomic_inc(&prt->refc);
+	erts_smp_port_state_unlock(prt);
+
+	if (no_proc_locks)
+	    erts_smp_mtx_lock(prt->lock);
+	else if (erts_smp_mtx_trylock(prt->lock) == EBUSY) {
+	    /* Unlock process locks, and acquire locks in lock order... */
+	    erts_smp_proc_unlock(c_p, c_p_locks);
+	    erts_smp_mtx_lock(prt->lock);
+	    erts_smp_proc_lock(c_p, c_p_locks);
+	}
+
+	/* The id may not have changed... */
+	ERTS_SMP_LC_ASSERT(prt->id == id);
+	/* ... but status may have... */
+	if (prt->status & sflgs) {
+	    erts_smp_port_unlock(prt); /* Also decrements refc... */
+	    prt = NULL;
+	}
+    }
+#endif
+
+    return prt;
+}
+
+ERTS_GLB_INLINE void
+erts_port_release(Port *prt)
+{
+#ifdef ERTS_SMP
+    erts_smp_port_unlock(prt);
+#else
+    if (prt->status & ERTS_PORT_SFLGS_DEAD)
+	erts_port_cleanup(prt);
+#endif
+}
+
+ERTS_GLB_INLINE Port*
+erts_drvport2port(ErlDrvPort drvport)
+{
+    int ix = (int) drvport;
+    if (ix < 0 || erts_max_ports <= ix)
+	return NULL;
+    if (erts_port[ix].status & ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP)
+	return NULL;
+    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(&erts_port[ix]));
+    return &erts_port[ix];
+}
+
+ERTS_GLB_INLINE Port*
+erts_drvportid2port(Eterm id)
+{
+    int ix;
+    if (is_not_internal_port(id))
+	return NULL;
+    ix = (int) internal_port_index(id);
+    if (erts_max_ports <= ix)
+	return NULL;
+    if (erts_port[ix].status & ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP)
+	return NULL;
+    if (erts_port[ix].id != id)
+	return NULL;
+    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(&erts_port[ix]));
+    return &erts_port[ix];
+}
+
+ERTS_GLB_INLINE Uint32
+erts_portid2status(Eterm id)
+{
+    if (is_not_internal_port(id))
+	return ERTS_PORT_SFLG_INVALID;
+    else {
+	Uint32 status;
+	int ix = internal_port_index(id);
+	if (erts_max_ports <= ix)
+	    return ERTS_PORT_SFLG_INVALID;
+	erts_smp_port_state_lock(&erts_port[ix]);
+	if (erts_port[ix].id == id)
+	    status = erts_port[ix].status;
+	else
+	    status = ERTS_PORT_SFLG_INVALID;
+	erts_smp_port_state_unlock(&erts_port[ix]);
+	return status;
+    }
+}
+
+ERTS_GLB_INLINE int
+erts_is_port_alive(Eterm id)
+{
+    return !(erts_portid2status(id) & (ERTS_PORT_SFLG_INVALID
+				       | ERTS_PORT_SFLGS_DEAD));
+}
+
+ERTS_GLB_INLINE int
+erts_is_valid_tracer_port(Eterm id)
+{
+    return !(erts_portid2status(id) & ERTS_PORT_SFLGS_INVALID_TRACER_LOOKUP);
+}
+
+ERTS_GLB_INLINE void erts_port_status_bandor_set(Port *prt,
+						 Uint32 band_status,
+						 Uint32 bor_status)
+{
+    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+    erts_smp_port_state_lock(prt);
+    prt->status &= band_status;
+    prt->status |= bor_status;
+    erts_smp_port_state_unlock(prt);
+}
+
+ERTS_GLB_INLINE void erts_port_status_band_set(Port *prt, Uint32 status)
+{
+    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+    erts_smp_port_state_lock(prt);
+    prt->status &= status;
+    erts_smp_port_state_unlock(prt);
+}
+
+ERTS_GLB_INLINE void erts_port_status_bor_set(Port *prt, Uint32 status)
+{
+    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+    erts_smp_port_state_lock(prt);
+    prt->status |= status;
+    erts_smp_port_state_unlock(prt);
+}
+
+ERTS_GLB_INLINE void erts_port_status_set(Port *prt, Uint32 status)
+{
+    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+    erts_smp_port_state_lock(prt);
+    prt->status = status;
+    erts_smp_port_state_unlock(prt);
+}
+
+ERTS_GLB_INLINE Uint32 erts_port_status_get(Port *prt)
+{
+    Uint32 res;
+    erts_smp_port_state_lock(prt);
+    res = prt->status;
+    erts_smp_port_state_unlock(prt);
+    return res;
+}
+#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */
+
+/* erl_drv_thread.c */
+void erl_drv_thr_init(void);
+
+/* time.c */
+
+ERTS_GLB_INLINE long do_time_read_and_reset(void);
+#ifdef ERTS_TIMER_THREAD
+ERTS_GLB_INLINE int next_time(void);
+ERTS_GLB_INLINE void bump_timer(long);
+#else
+int next_time(void);
+void bump_timer(long);
+extern erts_smp_atomic_t do_time;	/* set at clock interrupt */
+ERTS_GLB_INLINE void do_time_add(long);
+#endif
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+#ifdef ERTS_TIMER_THREAD
+ERTS_GLB_INLINE long do_time_read_and_reset(void) { return 0; }
+ERTS_GLB_INLINE int next_time(void) { return -1; }
+ERTS_GLB_INLINE void bump_timer(long ignore) { }
+#else
+ERTS_GLB_INLINE long do_time_read_and_reset(void)
+{
+    return erts_smp_atomic_xchg(&do_time, 0L);
+}
+ERTS_GLB_INLINE void do_time_add(long elapsed)
+{
+    erts_smp_atomic_add(&do_time, elapsed);
+}
+#endif
+
+#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */
+
+void init_time(void);
+void erl_set_timer(ErlTimer*, ErlTimeoutProc, ErlCancelProc, void*, Uint);
+void erl_cancel_timer(ErlTimer*);
+Uint time_left(ErlTimer *);
+
+Uint erts_timer_wheel_memory_size(void);
+
+#if (defined(HAVE_GETHRVTIME) || defined(HAVE_CLOCK_GETTIME))
+#  ifndef HAVE_ERTS_NOW_CPU
+#    define HAVE_ERTS_NOW_CPU
+#    ifdef HAVE_GETHRVTIME
+#      define erts_start_now_cpu() sys_start_hrvtime()
+#      define erts_stop_now_cpu()  sys_stop_hrvtime()
+#    endif
+#  endif
+void erts_get_now_cpu(Uint* megasec, Uint* sec, Uint* microsec);
+#endif
+
+void erts_get_timeval(SysTimeval *tv);
+long erts_get_time(void);
+
+extern SysTimeval erts_first_emu_time;
+
+void erts_get_emu_time(SysTimeval *);
+
+ERTS_GLB_INLINE int erts_cmp_timeval(SysTimeval *t1p, SysTimeval *t2p);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE int
+erts_cmp_timeval(SysTimeval *t1p, SysTimeval *t2p)
+{
+    if (t1p->tv_sec == t2p->tv_sec) {
+	if (t1p->tv_usec < t2p->tv_usec)
+	    return -1;
+	else if (t1p->tv_usec > t2p->tv_usec)
+	    return 1;
+	return 0;
+    }
+    return t1p->tv_sec < t2p->tv_sec ? -1 : 1;
+}
+
+#endif
+
+#ifdef DEBUG
+void p_slpq(_VOID_);
+#endif
+
+/* utils.c */
+
+void erts_cleanup_offheap(ErlOffHeap *offheap);
+void erts_cleanup_externals(ExternalThing *);
+
+Uint erts_fit_in_bits(Uint);
+int list_length(Eterm);
+Export* erts_find_function(Eterm, Eterm, unsigned int);
+int erts_is_builtin(Eterm, Eterm, int);
+Uint32 make_broken_hash(Eterm);
+Uint32 block_hash(byte *, unsigned, Uint32);
+Uint32 make_hash2(Eterm);
+Uint32 make_hash(Eterm);
+
+
+Eterm erts_bld_atom(Uint **hpp, Uint *szp, char *str);
+Eterm erts_bld_uint(Uint **hpp, Uint *szp, Uint ui);
+Eterm erts_bld_uint64(Uint **hpp, Uint *szp, Uint64 ui64);
+Eterm erts_bld_sint64(Uint **hpp, Uint *szp, Sint64 si64);
+Eterm erts_bld_cons(Uint **hpp, Uint *szp, Eterm car, Eterm cdr);
+Eterm erts_bld_tuple(Uint **hpp, Uint *szp, Uint arity, ...);
+Eterm erts_bld_tuplev(Uint **hpp, Uint *szp, Uint arity, Eterm terms[]);
+Eterm erts_bld_string_n(Uint **hpp, Uint *szp, const char *str, Sint len);
+#define erts_bld_string(hpp,szp,str) erts_bld_string_n(hpp,szp,str,strlen(str))
+Eterm erts_bld_list(Uint **hpp, Uint *szp, Sint length, Eterm terms[]);
+Eterm erts_bld_2tup_list(Uint **hpp, Uint *szp,
+			 Sint length, Eterm terms1[], Uint terms2[]);
+Eterm
+erts_bld_atom_uint_2tup_list(Uint **hpp, Uint *szp,
+			     Sint length, Eterm atoms[], Uint uints[]);
+Eterm
+erts_bld_atom_2uint_3tup_list(Uint **hpp, Uint *szp, Sint length,
+			      Eterm atoms[], Uint uints1[], Uint uints2[]);
+
+Eterm store_external_or_ref_in_proc_(Process *, Eterm);
+Eterm store_external_or_ref_(Uint **, ExternalThing **, Eterm);
+
+#define NC_HEAP_SIZE(NC) \
+ (ASSERT_EXPR(is_node_container((NC))), \
+  IS_CONST((NC)) ? 0 : (thing_arityval(*boxed_val((NC))) + 1))
+#define STORE_NC(Hpp, ETpp, NC) \
+ (ASSERT_EXPR(is_node_container((NC))), \
+  IS_CONST((NC)) ? (NC) : store_external_or_ref_((Hpp), (ETpp), (NC)))
+#define STORE_NC_IN_PROC(Pp, NC) \
+ (ASSERT_EXPR(is_node_container((NC))), \
+  IS_CONST((NC)) ? (NC) : store_external_or_ref_in_proc_((Pp), (NC)))
+
+void erts_init_utils(void);
+void erts_init_utils_mem(void);
+
+erts_dsprintf_buf_t *erts_create_tmp_dsbuf(Uint);
+void erts_destroy_tmp_dsbuf(erts_dsprintf_buf_t *);
+
+int eq(Eterm, Eterm);
+#define EQ(x,y) (((x) == (y)) || (is_not_both_immed((x),(y)) && eq((x),(y))))
+
+Sint cmp(Eterm, Eterm);
+#define cmp_lt(a,b)	(cmp((a),(b)) < 0)
+#define cmp_le(a,b)	(cmp((a),(b)) <= 0)
+#define cmp_eq(a,b)	(cmp((a),(b)) == 0)
+#define cmp_ne(a,b)	(cmp((a),(b)) != 0)
+#define cmp_ge(a,b)	(cmp((a),(b)) >= 0)
+#define cmp_gt(a,b)	(cmp((a),(b)) > 0)
+
+#define CMP_LT(a,b)	((a) != (b) && cmp_lt((a),(b)))
+#define CMP_GE(a,b)	((a) == (b) || cmp_ge((a),(b)))
+#define CMP_EQ(a,b)	((a) == (b) || cmp_eq((a),(b)))
+#define CMP_NE(a,b)	((a) != (b) && cmp_ne((a),(b)))
+
+int term_to_Uint(Eterm term, Uint *up);
+
+#ifdef HAVE_ERTS_NOW_CPU
+extern int erts_cpu_timestamp;
+#endif
+/* erl_bif_chksum.c */
+void erts_init_bif_chksum(void);
+/* erl_bif_re.c */
+void erts_init_bif_re(void);
+Sint erts_re_set_loop_limit(Sint limit);
+/* erl_unicode.c */
+void erts_init_unicode(void);
+Sint erts_unicode_set_loop_limit(Sint limit);
+/* erl_trace.c */
+void erts_init_trace(void);
+void erts_trace_check_exiting(Eterm exiting);
+Eterm erts_set_system_seq_tracer(Process *c_p,
+				 ErtsProcLocks c_p_locks,
+				 Eterm new);
+Eterm erts_get_system_seq_tracer(void);
+void erts_change_default_tracing(int setflags, Uint *flagsp, Eterm *tracerp);
+void erts_get_default_tracing(Uint *flagsp, Eterm *tracerp);
+void erts_set_system_monitor(Eterm monitor);
+Eterm erts_get_system_monitor(void);
+
+#ifdef ERTS_SMP
+void erts_check_my_tracer_proc(Process *);
+void erts_block_sys_msg_dispatcher(void);
+void erts_release_sys_msg_dispatcher(void);
+void erts_foreach_sys_msg_in_q(void (*func)(Eterm,
+					    Eterm,
+					    Eterm,
+					    ErlHeapFragment *));
+void erts_queue_error_logger_message(Eterm, Eterm, ErlHeapFragment *);
+#endif
+
+void erts_send_sys_msg_proc(Eterm, Eterm, Eterm, ErlHeapFragment *);
+void trace_send(Process*, Eterm, Eterm);
+void trace_receive(Process*, Eterm);
+Uint32 erts_call_trace(Process *p, Eterm mfa[], Binary *match_spec, Eterm* args,
+		       int local, Eterm *tracer_pid);
+void erts_trace_return(Process* p, Eterm* fi, Eterm retval, Eterm *tracer_pid);
+void erts_trace_exception(Process* p, Eterm mfa[], Eterm class, Eterm value, 
+			  Eterm *tracer);
+void erts_trace_return_to(Process *p, Uint *pc);
+void trace_sched(Process*, Eterm);
+void trace_proc(Process*, Process*, Eterm, Eterm);
+void trace_proc_spawn(Process*, Eterm pid, Eterm mod, Eterm func, Eterm args);
+void save_calls(Process *p, Export *);
+void trace_gc(Process *p, Eterm what);
+/* port tracing */
+void trace_virtual_sched(Process*, Eterm);
+void trace_sched_ports(Port *pp, Eterm);
+void trace_sched_ports_where(Port *pp, Eterm, Eterm);
+void trace_port(Port *, Eterm what, Eterm data);
+void trace_port_open(Port *, Eterm calling_pid, Eterm drv_name);
+
+/* system_profile */
+void erts_set_system_profile(Eterm profile);
+Eterm erts_get_system_profile(void);
+void profile_scheduler(Eterm scheduler_id, Eterm);
+void profile_scheduler_q(Eterm scheduler_id, Eterm state, Eterm no_schedulers, Uint Ms, Uint s, Uint us);
+void profile_runnable_proc(Process* p, Eterm status);
+void profile_runnable_port(Port* p, Eterm status);
+void erts_system_profile_setup_active_schedulers(void);
+
+/* system_monitor */
+void monitor_long_gc(Process *p, Uint time);
+void monitor_large_heap(Process *p);
+void monitor_generic(Process *p, Eterm type, Eterm spec);
+Uint erts_trace_flag2bit(Eterm flag);
+int erts_trace_flags(Eterm List, 
+		 Uint *pMask, Eterm *pTracer, int *pCpuTimestamp);
+Eterm erts_bif_trace(int bif_index, Process* p, 
+		     Eterm arg1, Eterm arg2, Eterm arg3, Uint *I);
+
+#ifdef ERTS_SMP
+void erts_send_pending_trace_msgs(ErtsSchedulerData *esdp);
+#define ERTS_SMP_CHK_PEND_TRACE_MSGS(ESDP)				\
+do {									\
+    if ((ESDP)->pending_trace_msgs)					\
+	erts_send_pending_trace_msgs((ESDP));				\
+} while (0)
+#else
+#define ERTS_SMP_CHK_PEND_TRACE_MSGS(ESDP)
+#endif
+
+void bin_write(int, void*, byte*, int);
+int intlist_to_buf(Eterm, char*, int); /* most callers pass plain char*'s */
+
+struct Sint_buf {
+#ifdef ARCH_64
+    char s[22];
+#else
+    char s[12];
+#endif
+};	
+char* Sint_to_buf(Sint, struct Sint_buf*);
+
+Eterm buf_to_intlist(Eterm**, char*, int, Eterm); /* most callers pass plain char*'s */
+int io_list_to_buf(Eterm, char*, int);
+int io_list_to_buf2(Eterm, char*, int);
+int io_list_len(Eterm);
+int is_string(Eterm);
+void erl_at_exit(FUNCTION(void,(*),(void*)), void*);
+Eterm collect_memory(Process *);
+void dump_memory_to_fd(int);
+int dump_memory_data(const char *);
+
+Eterm erts_mixed_plus(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_mixed_minus(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_mixed_times(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_mixed_div(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_int_div(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_int_rem(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_band(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_bor(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_bxor(Process* p, Eterm arg1, Eterm arg2);
+Eterm erts_bnot(Process* p, Eterm arg);
+
+Eterm erts_gc_mixed_plus(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_mixed_minus(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_mixed_times(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_mixed_div(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_int_div(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_int_rem(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_band(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_bor(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_bxor(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_bnot(Process* p, Eterm* reg, Uint live);
+
+Eterm erts_gc_length_1(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_size_1(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_bit_size_1(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_byte_size_1(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_abs_1(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_float_1(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_round_1(Process* p, Eterm* reg, Uint live);
+Eterm erts_gc_trunc_1(Process* p, Eterm* reg, Uint live);
+
+Uint erts_current_reductions(Process* current, Process *p);
+
+int erts_print_system_version(int to, void *arg, Process *c_p);
+
+/*
+ * Interface to erl_init
+ */
+void erl_init(void);
+void erts_first_process(Eterm modname, void* code, unsigned size, int argc, char** argv);
+
+#define seq_trace_output(token, msg, type, receiver, process) \
+seq_trace_output_generic((token), (msg), (type), (receiver), (process), NIL)
+#define seq_trace_output_exit(token, msg, type, receiver, exitfrom) \
+seq_trace_output_generic((token), (msg), (type), (receiver), NULL, (exitfrom))
+void seq_trace_output_generic(Eterm token, Eterm msg, Uint type, 
+			      Eterm receiver, Process *process, Eterm exitfrom);
+
+int seq_trace_update_send(Process *process);
+
+Eterm erts_seq_trace(Process *process, 
+		     Eterm atom_type, Eterm atom_true_or_false, 
+		     int build_result);
+
+struct trace_pattern_flags {
+    unsigned int breakpoint : 1; /* Set if any other is set */
+    unsigned int local      : 1; /* Local call trace breakpoint */
+    unsigned int meta       : 1; /* Metadata trace breakpoint */
+    unsigned int call_count : 1; /* Fast call count breakpoint */
+};
+extern const struct trace_pattern_flags erts_trace_pattern_flags_off;
+int erts_set_trace_pattern(Eterm* mfa, int specified, 
+			   Binary* match_prog_set, Binary *meta_match_prog_set,
+			   int on, struct trace_pattern_flags,
+			   Eterm meta_tracer_pid);
+void
+erts_get_default_trace_pattern(int *trace_pattern_is_on,
+			       Binary **match_spec,
+			       Binary **meta_match_spec,
+			       struct trace_pattern_flags *trace_pattern_flags,
+			       Eterm *meta_tracer_pid);
+void erts_bif_trace_init(void);
+
+/*
+** Call_trace uses this API for the parameter matching functions
+*/
+    struct erl_heap_fragment* saved_program_buf;
+
+#define MatchSetRef(MPSP) 			\
+do {						\
+    if ((MPSP) != NULL) {			\
+	erts_refc_inc(&(MPSP)->refc, 1);	\
+    }						\
+} while (0)
+
+#define MatchSetUnref(MPSP)					\
+do {								\
+    if (((MPSP) != NULL) && erts_refc_dectest(&(MPSP)->refc, 0) <= 0) { \
+	erts_bin_free(MPSP);					\
+    }								\
+} while(0)
+
+#define MatchSetGetSource(MPSP) erts_match_set_get_source(MPSP)
+
+extern Binary *erts_match_set_compile(Process *p, Eterm matchexpr);
+Eterm erts_match_set_lint(Process *p, Eterm matchexpr); 
+extern void erts_match_set_release_result(Process* p);
+extern Eterm erts_match_set_run(Process *p, Binary *mpsp, 
+				Eterm *args, int num_args,
+				Uint32 *return_flags);
+extern Eterm erts_match_set_get_source(Binary *mpsp);
+extern void erts_match_prog_foreach_offheap(Binary *b,
+					    void (*)(ErlOffHeap *, void *),
+					    void *);
+
+#define MATCH_SET_RETURN_TRACE 0x1 /* return trace requested */
+#define MATCH_SET_RETURN_TO_TRACE 0x2 /* Misleading name, it is not actually
+					 set by the match program, but by the
+					 breakpoint functions */
+#define MATCH_SET_EXCEPTION_TRACE 0x4 /* exception trace requested */
+#define MATCH_SET_RX_TRACE (MATCH_SET_RETURN_TRACE|MATCH_SET_EXCEPTION_TRACE)
+/*
+ * Flag values when tracing bif
+ */
+#define BIF_TRACE_AS_LOCAL  0x1
+#define BIF_TRACE_AS_GLOBAL 0x2
+#define BIF_TRACE_AS_META   0x4
+
+extern erts_driver_t vanilla_driver;
+extern erts_driver_t spawn_driver;
+extern erts_driver_t fd_driver;
+
+/* Should maybe be placed in erl_message.h, but then we get an include mess. */
+
+ERTS_GLB_INLINE Eterm *
+erts_alloc_message_heap(Uint size,
+			ErlHeapFragment **bpp,
+			ErlOffHeap **ohpp,
+			Process *receiver,
+			ErtsProcLocks *receiver_locks);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+/*
+ * NOTE: erts_alloc_message_heap() releases msg q and status
+ *       lock on receiver without ensuring that other locks are
+ *       held. User is responsible to ensure that the receiver
+ *       pointer cannot become invalid until after message has
+ *       been passed. This is normal done either by increasing
+ *       reference count on process (preferred) or by holding
+ *       main or link lock over the whole message passing
+ *       operation.
+ */
+
+ERTS_GLB_INLINE Eterm *
+erts_alloc_message_heap(Uint size,
+			ErlHeapFragment **bpp,
+			ErlOffHeap **ohpp,
+			Process *receiver,
+			ErtsProcLocks *receiver_locks)
+{
+    Eterm *hp;
+#ifdef ERTS_SMP
+    int locked_main = 0;
+    ErtsProcLocks ulocks = *receiver_locks & ERTS_PROC_LOCKS_MSG_SEND;
+#endif
+
+    if (size > (Uint) INT_MAX)
+	erl_exit(ERTS_ABORT_EXIT, "HUGE size (%bpu)\n", size);
+
+    if (
+#if defined(ERTS_SMP)
+	*receiver_locks & ERTS_PROC_LOCK_MAIN
+#else
+	1
+#endif
+	) {
+#ifdef ERTS_SMP
+    try_allocate_on_heap:
+#endif
+	if (ERTS_PROC_IS_EXITING(receiver)
+	    || HEAP_LIMIT(receiver) - HEAP_TOP(receiver) <= size) {
+#ifdef ERTS_SMP
+	    if (locked_main)
+		ulocks |= ERTS_PROC_LOCK_MAIN;
+#endif
+	    goto allocate_in_mbuf;
+	}
+#ifdef ERTS_SMP
+	if (ulocks) {
+	    erts_smp_proc_unlock(receiver, ulocks);
+	    *receiver_locks &= ~ulocks;
+	}
+#endif
+	hp = HEAP_TOP(receiver);
+	HEAP_TOP(receiver) = hp + size;
+	*bpp = NULL;
+	*ohpp = &MSO(receiver);
+    }
+#ifdef ERTS_SMP
+    else if (erts_smp_proc_trylock(receiver, ERTS_PROC_LOCK_MAIN) == 0) {
+	locked_main = 1;
+	*receiver_locks |= ERTS_PROC_LOCK_MAIN;
+	goto try_allocate_on_heap;
+    }
+#endif
+    else {
+	ErlHeapFragment *bp;
+    allocate_in_mbuf:
+#ifdef ERTS_SMP
+	if (ulocks) {
+	    *receiver_locks &= ~ulocks;
+	    erts_smp_proc_unlock(receiver, ulocks);
+	}
+#endif
+	bp = new_message_buffer(size);
+	hp = bp->mem;
+	*bpp = bp;
+	*ohpp = &bp->off_heap;
+    }
+
+    return hp;
+}
+
+#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */
+
+#endif