11 files changed, 158 insertions, 40 deletions

diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 8cfcbd0fb8..5c5d9fd049 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -1122,6 +1122,7 @@ init_emulator(void)
 
 #endif /* USE_VM_PROBES */
 
+#ifdef USE_VM_PROBES
 void
 dtrace_drvport_str(ErlDrvPort drvport, char *port_buf)
 {
@@ -1131,7 +1132,7 @@ dtrace_drvport_str(ErlDrvPort drvport, char *port_buf)
                   port_channel_no(port->id),
                   port_number(port->id));
 }
-
+#endif
 /*
  * process_main() is called twice:
  * The first call performs some initialisation, including exporting
@@ -1304,6 +1305,7 @@ void process_main(void)
 	SWAPIN;
 	ASSERT(VALID_INSTR(next));
 
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(process_scheduled)) {
             DTRACE_CHARBUF(process_buf, DTRACE_TERM_BUF_SIZE);
             DTRACE_CHARBUF(fun_buf, DTRACE_TERM_BUF_SIZE);
@@ -1325,7 +1327,7 @@ void process_main(void)
 
             DTRACE2(process_scheduled, process_buf, fun_buf);
         }
-
+#endif
 	Goto(next);
     }
 
@@ -1591,13 +1593,16 @@ void process_main(void)
 
 
  OpCase(return): {
+#ifdef USE_VM_PROBES
     BeamInstr* fptr;
+#endif
     SET_I(c_p->cp);
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(function_return) && (fptr = find_function_from_pc(c_p->cp))) {
         DTRACE_RETURN(c_p, (Eterm)fptr[0], (Eterm)fptr[1], (Uint)fptr[2]);
     }
-
+#endif
     /*
      * We must clear the CP to make sure that a stale value do not
      * create a false module dependcy preventing code upgrading.
@@ -1954,12 +1959,13 @@ void process_main(void)
 	 }
 #endif
      }
+#ifdef USE_VM_PROBES
      if (DTRACE_ENABLED(message_receive)) {
          Eterm token2 = NIL;
          DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
-         ERTS_DECLARE_DUMMY(Sint tok_label) = 0;
-         ERTS_DECLARE_DUMMY(Sint tok_lastcnt) = 0;
-         ERTS_DECLARE_DUMMY(Sint tok_serial) = 0;
+         Sint tok_label = 0;
+         Sint tok_lastcnt = 0;
+         Sint tok_serial = 0;
 
          dtrace_proc_str(c_p, receiver_name);
          token2 = SEQ_TRACE_TOKEN(c_p);
@@ -1972,6 +1978,7 @@ void process_main(void)
                  receiver_name, size_object(ERL_MESSAGE_TERM(msgp)),
                  c_p->msg.len - 1, tok_label, tok_lastcnt, tok_serial);
      }
+#endif
      UNLINK_MESSAGE(c_p, msgp);
      JOIN_MESSAGE(c_p);
      CANCEL_TIMER(c_p);
@@ -3332,7 +3339,6 @@ void process_main(void)
 	    BifFunction vbf;
 
 	    DTRACE_NIF_ENTRY(c_p, (Eterm)I[-3], (Eterm)I[-2], (Uint)I[-1]);
-
 	    c_p->current = I-3; /* current and vbf set to please handle_error */ 
 	    SWAPOUT;
 	    c_p->fcalls = FCALLS - 1;
@@ -3356,7 +3362,6 @@ void process_main(void)
 	    ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
 
 	    DTRACE_NIF_RETURN(c_p, (Eterm)I[-3], (Eterm)I[-2], (Uint)I[-1]);
-
 	    goto apply_bif_or_nif_epilogue;
 	 
 	OpCase(apply_bif):
@@ -6082,13 +6087,14 @@ apply(Process* p, Eterm module, Eterm function, Eterm args, Eterm* reg)
 	save_calls(p, ep);
     }
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(function_entry) && ep->address) {
         BeamInstr *fptr = find_function_from_pc(ep->address);
         if (fptr) {
             DTRACE_CALL(p, (Eterm)fptr[0], (Eterm)fptr[1], (Uint)fptr[2]);
         }
     }
-
+#endif
     return ep->address;
 }
 
@@ -6138,13 +6144,14 @@ fixed_apply(Process* p, Eterm* reg, Uint arity)
 	save_calls(p, ep);
     }
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(function_entry)) {
         BeamInstr *fptr = find_function_from_pc(ep->address);
         if (fptr) {
             DTRACE_CALL(p, (Eterm)fptr[0], (Eterm)fptr[1], (Uint)fptr[2]);
         }
     }
-
+#endif
     return ep->address;
 }
 
@@ -6194,6 +6201,7 @@ erts_hibernate(Process* c_p, Eterm module, Eterm function, Eterm args, Eterm* re
 	c_p->max_arg_reg = sizeof(c_p->def_arg_reg)/sizeof(c_p->def_arg_reg[0]);
     }
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(process_hibernate)) {
         DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);
         DTRACE_CHARBUF(mfa, DTRACE_TERM_BUF_SIZE);
@@ -6201,7 +6209,7 @@ erts_hibernate(Process* c_p, Eterm module, Eterm function, Eterm args, Eterm* re
                           process_name, mfa);
         DTRACE2(process_hibernate, process_name, mfa);
     }
-
+#endif
     /*
      * Arrange for the process to be resumed at the given MFA with
      * the stack cleared.
@@ -6276,6 +6284,7 @@ call_fun(Process* p,		/* Current process. */
 	code_ptr = fe->address;
 	actual_arity = (int) code_ptr[-1];
 
+#ifdef USE_VM_PROBES
 	if (DTRACE_ENABLED(function_entry)) {
 	    BeamInstr *fptr = find_function_from_pc(code_ptr);
 
@@ -6283,7 +6292,7 @@ call_fun(Process* p,		/* Current process. */
 		DTRACE_CALL(p, fe->module, (Eterm)fptr[1], actual_arity);
 	    }
 	}
-
+#endif
 	if (actual_arity == arity+num_free) {
 	    if (num_free == 0) {
 		return code_ptr;
diff --git a/erts/emulator/beam/copy.c b/erts/emulator/beam/copy.c
index 4ee60807d9..2c355fadfa 100644
--- a/erts/emulator/beam/copy.c
+++ b/erts/emulator/beam/copy.c
@@ -60,12 +60,14 @@ copy_object(Eterm obj, Process* to)
     Eterm* hp = HAlloc(to, size);
     Eterm res;
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(copy_object)) {
         DTRACE_CHARBUF(proc_name, 64);
 
         erts_snprintf(proc_name, sizeof(proc_name), "%T", to->id);
         DTRACE2(copy_object, proc_name, size);
     }
+#endif
     res = copy_struct(obj, size, &hp, &to->off_heap);
 #ifdef DEBUG
     if (eq(obj, res) == 0) {
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index e93176ba4e..802feaeb1c 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -745,13 +745,15 @@ erts_dsig_send_msg(ErtsDSigData *dsdp, Eterm remote, Eterm message)
     Eterm token = NIL;
     Process *sender = dsdp->proc;
     int res;
-    ERTS_DECLARE_DUMMY(Sint tok_label) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_lastcnt) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_serial) = 0;
-    ERTS_DECLARE_DUMMY(Uint msize) = 0;
+#ifdef USE_VM_PROBES
+    Sint tok_label = 0;
+    Sint tok_lastcnt = 0;
+    Sint tok_serial = 0;
+    Uint msize = 0;
     DTRACE_CHARBUF(node_name, 64);
     DTRACE_CHARBUF(sender_name, 64);
     DTRACE_CHARBUF(receiver_name, 64);
+#endif
 
     UseTmpHeapNoproc(5);
     if (SEQ_TRACE_TOKEN(sender) != NIL 
@@ -763,6 +765,7 @@ erts_dsig_send_msg(ErtsDSigData *dsdp, Eterm remote, Eterm message)
 	token = SEQ_TRACE_TOKEN(sender);
 	seq_trace_output(token, message, SEQ_TRACE_SEND, remote, sender);
     }
+#ifdef USE_VM_PROBES
     *node_name = *sender_name = *receiver_name = '\0';
     if (DTRACE_ENABLED(message_send) || DTRACE_ENABLED(message_send_remote)) {
         erts_snprintf(node_name, sizeof(node_name), "%T", dsdp->dep->sysname);
@@ -775,6 +778,7 @@ erts_dsig_send_msg(ErtsDSigData *dsdp, Eterm remote, Eterm message)
             tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
         }
     }
+#endif
 
     if (token != NIL)
 	ctl = TUPLE4(&ctl_heap[0],
@@ -798,13 +802,15 @@ erts_dsig_send_reg_msg(ErtsDSigData *dsdp, Eterm remote_name, Eterm message)
     Eterm token = NIL;
     Process *sender = dsdp->proc;
     int res;
-    ERTS_DECLARE_DUMMY(Sint tok_label) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_lastcnt) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_serial) = 0;
-    ERTS_DECLARE_DUMMY(Uint32 msize) = 0;
+#ifdef USE_VM_PROBES
+    Sint tok_label = 0;
+    Sint tok_lastcnt = 0;
+    Sint tok_serial = 0;
+    Uint32 msize = 0;
     DTRACE_CHARBUF(node_name, 64);
     DTRACE_CHARBUF(sender_name, 64);
     DTRACE_CHARBUF(receiver_name, 128);
+#endif
 
     UseTmpHeapNoproc(6);
     if (SEQ_TRACE_TOKEN(sender) != NIL
@@ -816,6 +822,7 @@ erts_dsig_send_reg_msg(ErtsDSigData *dsdp, Eterm remote_name, Eterm message)
 	token = SEQ_TRACE_TOKEN(sender);
 	seq_trace_output(token, message, SEQ_TRACE_SEND, remote_name, sender);
     }
+#ifdef USE_VM_PROBES
     *node_name = *sender_name = *receiver_name = '\0';
     if (DTRACE_ENABLED(message_send) || DTRACE_ENABLED(message_send_remote)) {
         erts_snprintf(node_name, sizeof(node_name), "%T", dsdp->dep->sysname);
@@ -829,6 +836,7 @@ erts_dsig_send_reg_msg(ErtsDSigData *dsdp, Eterm remote_name, Eterm message)
             tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
         }
     }
+#endif
 
     if (token != NIL)
 	ctl = TUPLE5(&ctl_heap[0], make_small(DOP_REG_SEND_TT),
@@ -853,14 +861,16 @@ erts_dsig_send_exit_tt(ErtsDSigData *dsdp, Eterm local, Eterm remote,
     Eterm ctl;
     DeclareTmpHeapNoproc(ctl_heap,6);
     int res;
+#ifdef USE_VM_PROBES
     Process *sender = dsdp->proc;
-    ERTS_DECLARE_DUMMY(Sint tok_label) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_lastcnt) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_serial) = 0;
+    Sint tok_label = 0;
+    Sint tok_lastcnt = 0;
+    Sint tok_serial = 0;
     DTRACE_CHARBUF(node_name, 64);
     DTRACE_CHARBUF(sender_name, 64);
     DTRACE_CHARBUF(remote_name, 128);
     DTRACE_CHARBUF(reason_str, 128);
+#endif
 
     UseTmpHeapNoproc(6);
     if (token != NIL 
@@ -875,6 +885,7 @@ erts_dsig_send_exit_tt(ErtsDSigData *dsdp, Eterm local, Eterm remote,
     } else {
 	ctl = TUPLE4(&ctl_heap[0], make_small(DOP_EXIT), local, remote, reason);
     }
+#ifdef USE_VM_PROBES
     *node_name = *sender_name = *remote_name = '\0';
     if (DTRACE_ENABLED(process_exit_signal_remote)) {
         erts_snprintf(node_name, sizeof(node_name), "%T", dsdp->dep->sysname);
@@ -888,6 +899,7 @@ erts_dsig_send_exit_tt(ErtsDSigData *dsdp, Eterm local, Eterm remote,
             tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
         }
     }
+#endif
     DTRACE7(process_exit_signal_remote, sender_name, node_name,
             remote_name, reason_str, tok_label, tok_lastcnt, tok_serial);
     /* forced, i.e ignore busy */
@@ -1706,6 +1718,7 @@ dsig_send(ErtsDSigData *dsdp, Eterm ctl, Eterm msg, int force_busy)
 	    if (!(dep->qflgs & ERTS_DE_QFLG_BUSY)) {
 		if (suspended)
 		    resume = 1; /* was busy when we started, but isn't now */
+#ifdef USE_VM_PROBES
                 if (resume && DTRACE_ENABLED(dist_port_not_busy)) {
                     DTRACE_CHARBUF(port_str, 64);
                     DTRACE_CHARBUF(remote_str, 64);
@@ -1716,6 +1729,7 @@ dsig_send(ErtsDSigData *dsdp, Eterm ctl, Eterm msg, int force_busy)
                     DTRACE3(dist_port_not_busy, erts_this_node_sysname,
                             port_str, remote_str);
                 }
+#endif
 	    }
 	    else {
 		/* Enqueue suspended process on dist entry */
@@ -1765,6 +1779,7 @@ dsig_send(ErtsDSigData *dsdp, Eterm ctl, Eterm msg, int force_busy)
     }
 
     if (suspended) {
+#ifdef USE_VM_PROBES
         if (!resume && DTRACE_ENABLED(dist_port_busy)) {
             DTRACE_CHARBUF(port_str, 64);
             DTRACE_CHARBUF(remote_str, 64);
@@ -1776,6 +1791,7 @@ dsig_send(ErtsDSigData *dsdp, Eterm ctl, Eterm msg, int force_busy)
             DTRACE4(dist_port_busy, erts_this_node_sysname,
                     port_str, remote_str, pid_str);
         }
+#endif
 	if (!resume && erts_system_monitor_flags.busy_dist_port)
 	    monitor_generic(c_p, am_busy_dist_port, cid);
 	return ERTS_DSIG_SEND_YIELD;
@@ -1799,6 +1815,7 @@ dist_port_command(Port *prt, ErtsDistOutputBuf *obuf)
 		 "(%beu bytes) passed.\n",
 		 size);
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(dist_output)) {
         DTRACE_CHARBUF(port_str, 64);
         DTRACE_CHARBUF(remote_str, 64);
@@ -1809,6 +1826,7 @@ dist_port_command(Port *prt, ErtsDistOutputBuf *obuf)
         DTRACE4(dist_output, erts_this_node_sysname, port_str,
                 remote_str, size);
     }
+#endif
     prt->caller = NIL;
     fpe_was_unmasked = erts_block_fpe();
     (*prt->drv_ptr->output)((ErlDrvData) prt->drv_data,
@@ -1851,6 +1869,7 @@ dist_port_commandv(Port *prt, ErtsDistOutputBuf *obuf)
 
     ASSERT(prt->drv_ptr->outputv);
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(dist_outputv)) {
         DTRACE_CHARBUF(port_str, 64);
         DTRACE_CHARBUF(remote_str, 64);
@@ -1861,6 +1880,7 @@ dist_port_commandv(Port *prt, ErtsDistOutputBuf *obuf)
         DTRACE4(dist_outputv, erts_this_node_sysname, port_str,
                 remote_str, size);
     }
+#endif
     prt->caller = NIL;
     fpe_was_unmasked = erts_block_fpe();
     (*prt->drv_ptr->outputv)((ErlDrvData) prt->drv_data, &eiov);
@@ -2180,6 +2200,7 @@ erts_dist_command(Port *prt, int reds_limit)
 void
 erts_dist_port_not_busy(Port *prt)
 {
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(dist_port_not_busy)) {
         DTRACE_CHARBUF(port_str, 64);
         DTRACE_CHARBUF(remote_str, 64);
@@ -2190,6 +2211,7 @@ erts_dist_port_not_busy(Port *prt)
         DTRACE3(dist_port_not_busy, erts_this_node_sysname,
                 port_str, remote_str);
     }
+#endif
     erts_schedule_dist_command(prt, NULL);
 }
 
@@ -3127,6 +3149,7 @@ send_nodes_mon_msgs(Process *c_p, Eterm what, Eterm node, Eterm type, Eterm reas
     ASSERT(is_immed(what));
     ASSERT(is_immed(node));
     ASSERT(is_immed(type));
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(dist_monitor)) {
         DTRACE_CHARBUF(what_str, 12);
         DTRACE_CHARBUF(node_str, 64);
@@ -3140,6 +3163,7 @@ send_nodes_mon_msgs(Process *c_p, Eterm what, Eterm node, Eterm type, Eterm reas
         DTRACE5(dist_monitor, erts_this_node_sysname,
                 what_str, node_str, type_str, reason_str);
     }
+#endif
 
     ERTS_SMP_LC_ASSERT(!c_p
 		       || (erts_proc_lc_my_proc_locks(c_p)
diff --git a/erts/emulator/beam/erl_async.c b/erts/emulator/beam/erl_async.c
index b8cb3c6cc4..f0e98b33a5 100644
--- a/erts/emulator/beam/erl_async.c
+++ b/erts/emulator/beam/erl_async.c
@@ -270,6 +270,7 @@ static ERTS_INLINE void async_add(ErtsAsync *a, ErtsAsyncQ* q)
 #endif
 
     erts_thr_q_enqueue(&q->thr_q, a);
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(aio_pool_add)) {
         DTRACE_CHARBUF(port_str, 16);
 
@@ -278,6 +279,7 @@ static ERTS_INLINE void async_add(ErtsAsync *a, ErtsAsyncQ* q)
         len = -1;
         DTRACE2(aio_pool_add, port_str, len);
     }
+#endif
     gcc_optimizer_hack++;
 }
 
@@ -301,6 +303,7 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
 	    if (saved_fin_deq)
 		erts_thr_q_append_finalize_dequeue_data(&a->q.fin_deq, &fin_deq);
 #endif
+#ifdef USE_VM_PROBES
             if (DTRACE_ENABLED(aio_pool_get)) {
                 DTRACE_CHARBUF(port_str, 16);
 
@@ -309,6 +312,7 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
                 len = -1;
                 DTRACE2(aio_pool_get, port_str, len);
             }
+#endif
 	    return a;
 	}
 
diff --git a/erts/emulator/beam/erl_bif_port.c b/erts/emulator/beam/erl_bif_port.c
index 8caa64b97d..3056319809 100644
--- a/erts/emulator/beam/erl_bif_port.c
+++ b/erts/emulator/beam/erl_bif_port.c
@@ -344,6 +344,7 @@ port_call(Process* c_p, Eterm arg1, Eterm arg2, Eterm arg3)
 		 __FILE__, __LINE__, endp - (bytes + size));
     }
     erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(driver_call)) {
         DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);
         DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
@@ -352,6 +353,7 @@ port_call(Process* c_p, Eterm arg1, Eterm arg2, Eterm arg3)
         dtrace_port_str(p, port_str);
         DTRACE5(driver_call, process_str, port_str, p->name, op, real_size);
     }
+#endif
     prc  = (char *) port_resp;
     fpe_was_unmasked = erts_block_fpe();
     ret = drv->call((ErlDrvData)p->drv_data, 
@@ -548,6 +550,7 @@ BIF_RETTYPE port_connect_2(BIF_ALIST_2)
 
     prt->connected = pid; /* internal pid */
     erts_smp_port_unlock(prt);
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(port_connect)) {
         DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);
         DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
@@ -558,6 +561,7 @@ BIF_RETTYPE port_connect_2(BIF_ALIST_2)
         dtrace_proc_str(rp, newprocess_str);
         DTRACE4(port_connect, process_str, port_str, prt->name, newprocess_str);
     }
+#endif
     BIF_RET(am_true);
 }
 
@@ -923,6 +927,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
 
     port_num = erts_open_driver(driver, p->id, name_buf, &opts, err_nump);
+#ifdef USE_VM_PROBES
     if (port_num >= 0 && DTRACE_ENABLED(port_open)) {
         DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);
         DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
@@ -931,7 +936,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
         erts_snprintf(port_str, sizeof(port_str), "%T", erts_port[port_num].id);
         DTRACE3(port_open, process_str, name_buf, port_str);
     }
-
+#endif
     erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
 
     if (port_num < 0) {
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 2e340a7ef1..82f2dc6091 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -350,8 +350,9 @@ erts_garbage_collect(Process* p, int need, Eterm* objv, int nobj)
     Uint reclaimed_now = 0;
     int done = 0;
     Uint ms1, s1, us1;
+#ifdef USE_VM_PROBES
     DTRACE_CHARBUF(pidbuf, DTRACE_TERM_BUF_SIZE);
-
+#endif
     if (IS_TRACED_FL(p, F_TRACE_GC)) {
         trace_gc(p, am_gc_start);
     }
@@ -371,7 +372,7 @@ erts_garbage_collect(Process* p, int need, Eterm* objv, int nobj)
     if (GEN_GCS(p) >= MAX_GEN_GCS(p)) {
         FLAGS(p) |= F_NEED_FULLSWEEP;
     }
-
+#ifdef USE_VM_PROBES
     *pidbuf = '\0';
     if (DTRACE_ENABLED(gc_major_start)
         || DTRACE_ENABLED(gc_major_end)
@@ -379,7 +380,7 @@ erts_garbage_collect(Process* p, int need, Eterm* objv, int nobj)
         || DTRACE_ENABLED(gc_minor_end)) {
         dtrace_proc_str(p, pidbuf);
     }
-
+#endif
     /*
      * Test which type of GC to do.
      */
@@ -1132,12 +1133,14 @@ do_minor(Process *p, Uint new_sz, Eterm* objv, int nobj)
     sys_memcpy(n_heap + new_sz - n, p->stop, n * sizeof(Eterm));
     p->stop = n_heap + new_sz - n;
 
+#ifdef USE_VM_PROBES
     if (HEAP_SIZE(p) != new_sz && DTRACE_ENABLED(process_heap_grow)) {
         DTRACE_CHARBUF(pidbuf, DTRACE_TERM_BUF_SIZE);
 
         dtrace_proc_str(p, pidbuf);
         DTRACE3(process_heap_grow, pidbuf, HEAP_SIZE(p), new_sz);
     }
+#endif
 
     ERTS_HEAP_FREE(ERTS_ALC_T_HEAP,
 		   (void*)HEAP_START(p),
@@ -1360,12 +1363,14 @@ major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
     sys_memcpy(n_heap + new_sz - n, p->stop, n * sizeof(Eterm));
     p->stop = n_heap + new_sz - n;
 
+#ifdef USE_VM_PROBES
     if (HEAP_SIZE(p) != new_sz && DTRACE_ENABLED(process_heap_grow)) {
         DTRACE_CHARBUF(pidbuf, DTRACE_TERM_BUF_SIZE);
 
         dtrace_proc_str(p, pidbuf);
         DTRACE3(process_heap_grow, pidbuf, HEAP_SIZE(p), new_sz);
     }
+#endif
 
     ERTS_HEAP_FREE(ERTS_ALC_T_HEAP,
 		   (void *) HEAP_START(p),
@@ -2044,12 +2049,14 @@ grow_new_heap(Process *p, Uint new_sz, Eterm* objv, int nobj)
         HEAP_START(p) = new_heap;
     }
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(process_heap_grow)) {
 	DTRACE_CHARBUF(pidbuf, DTRACE_TERM_BUF_SIZE);
 
         dtrace_proc_str(p, pidbuf);
 	DTRACE3(process_heap_grow, pidbuf, HEAP_SIZE(p), new_sz);
     }
+#endif
 
     HEAP_SIZE(p) = new_sz;
 }
@@ -2089,12 +2096,14 @@ shrink_new_heap(Process *p, Uint new_sz, Eterm *objv, int nobj)
         HEAP_START(p) = new_heap;
     }
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(process_heap_shrink)) {
 	DTRACE_CHARBUF(pidbuf, DTRACE_TERM_BUF_SIZE);
 
         dtrace_proc_str(p, pidbuf);
 	DTRACE3(process_heap_shrink, pidbuf, HEAP_SIZE(p), new_sz);
     }
+#endif
 
     HEAP_SIZE(p) = new_sz;
 }
diff --git a/erts/emulator/beam/erl_message.c b/erts/emulator/beam/erl_message.c
index 7de30d25ed..4cdf2d7d09 100644
--- a/erts/emulator/beam/erl_message.c
+++ b/erts/emulator/beam/erl_message.c
@@ -336,9 +336,11 @@ erts_queue_dist_message(Process *rcvr,
 			Eterm token)
 {
     ErlMessage* mp;
-    ERTS_DECLARE_DUMMY(Sint tok_label) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_lastcnt) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_serial) = 0;
+#ifdef USE_VM_PROBES
+    Sint tok_label = 0;
+    Sint tok_lastcnt = 0;
+    Sint tok_serial = 0;
+#endif
 #ifdef ERTS_SMP
     ErtsProcLocks need_locks;
 #endif
@@ -380,6 +382,7 @@ erts_queue_dist_message(Process *rcvr,
 	message_free(mp);
 	msg = erts_msg_distext2heap(rcvr, rcvr_locks, &mbuf, &token, dist_ext);
 	if (is_value(msg))
+#ifdef USE_VM_PROBES
             if (DTRACE_ENABLED(message_queued)) {
                 DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
 
@@ -393,6 +396,7 @@ erts_queue_dist_message(Process *rcvr,
                         receiver_name, size_object(msg), rcvr->msg.len,
                         tok_label, tok_lastcnt, tok_serial);
             }
+#endif
 	    erts_queue_message(rcvr, rcvr_locks, mbuf, msg, token
 #ifdef USE_VM_PROBES
 			       , NIL
@@ -415,6 +419,7 @@ erts_queue_dist_message(Process *rcvr,
 #endif
 	mp->next = NULL;
 
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(message_queued)) {
             DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
 
@@ -431,6 +436,7 @@ erts_queue_dist_message(Process *rcvr,
             DTRACE6(message_queued, receiver_name, -1, rcvr->msg.len + 1,
                     tok_label, tok_lastcnt, tok_serial);
         }
+#endif
 	mp->data.dist_ext = dist_ext;
 	LINK_MESSAGE(rcvr, mp);
 
@@ -515,11 +521,12 @@ erts_queue_message(Process* receiver,
     LINK_MESSAGE(receiver, mp);
 #endif
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(message_queued)) {
         DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
-        ERTS_DECLARE_DUMMY(Sint tok_label) = 0;
-        ERTS_DECLARE_DUMMY(Sint tok_lastcnt) = 0;
-        ERTS_DECLARE_DUMMY(Sint tok_serial) = 0;
+        Sint tok_label = 0;
+        Sint tok_lastcnt = 0;
+        Sint tok_serial = 0;
 
         dtrace_proc_str(receiver, receiver_name);
         if (seq_trace_token != NIL && is_tuple(seq_trace_token)) {
@@ -531,7 +538,7 @@ erts_queue_message(Process* receiver,
                 receiver_name, size_object(message), receiver->msg.len,
                 tok_label, tok_lastcnt, tok_serial);
     }
-
+#endif
     notify_new_message(receiver);
 
     if (IS_TRACED_FL(receiver, F_TRACE_RECEIVE)) {
@@ -884,21 +891,24 @@ erts_send_message(Process* sender,
     Uint msize;
     ErlHeapFragment* bp = NULL;
     Eterm token = NIL;
+#ifdef USE_VM_PROBES
     DTRACE_CHARBUF(sender_name, 64);
     DTRACE_CHARBUF(receiver_name, 64);
-    ERTS_DECLARE_DUMMY(Sint tok_label) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_lastcnt) = 0;
-    ERTS_DECLARE_DUMMY(Sint tok_serial) = 0;
-
+    Sint tok_label = 0;
+    Sint tok_lastcnt = 0;
+    Sint tok_serial = 0;
+#endif
     BM_STOP_TIMER(system);
     BM_MESSAGE(message,sender,receiver);
     BM_START_TIMER(send);
 
+ #ifdef USE_VM_PROBES
     *sender_name = *receiver_name = '\0';
-    if (DTRACE_ENABLED(message_send)) {
+   if (DTRACE_ENABLED(message_send)) {
         erts_snprintf(sender_name, sizeof(sender_name), "%T", sender->id);
         erts_snprintf(receiver_name, sizeof(receiver_name), "%T", receiver->id);
     }
+#endif
     if (SEQ_TRACE_TOKEN(sender) != NIL && !(flags & ERTS_SND_FLG_NO_SEQ_TRACE)) {
         Eterm* hp;
 	Eterm stoken = SEQ_TRACE_TOKEN(sender);
@@ -956,6 +966,7 @@ erts_send_message(Process* sender,
         BM_MESSAGE_COPIED(msize);
         BM_SWAP_TIMER(copy,send);
 
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(message_send)) {
 	    if (stoken != NIL && stoken != am_have_dt_utag) {
 		tok_label = signed_val(SEQ_TRACE_T_LABEL(stoken));
@@ -965,6 +976,7 @@ erts_send_message(Process* sender,
 	    DTRACE6(message_send, sender_name, receiver_name,
 		    msize, tok_label, tok_lastcnt, tok_serial);
         }
+#endif
         erts_queue_message(receiver,
 			   receiver_locks,
 			   bp,
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 156783d057..40f2fde578 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -66,7 +66,9 @@ static void add_readonly_check(ErlNifEnv*, unsigned char* ptr, unsigned sz);
 static int is_offheap(const ErlOffHeap* off_heap);
 #endif
 
+#ifdef USE_VM_PROBES
 void dtrace_nifenv_str(ErlNifEnv *, char *);
+#endif
 
 #define MIN_HEAP_FRAG_SZ 200
 static Eterm* alloc_heap_heavy(ErlNifEnv* env, unsigned need, Eterm* hp);
@@ -1784,10 +1786,12 @@ void erl_nif_init()
     resource_type_list.name = THE_NON_VALUE;
 }
 
+#ifdef USE_VM_PROBES
 void dtrace_nifenv_str(ErlNifEnv *env, char *process_buf)
 {
     dtrace_pid_str(env->proc->id, process_buf);
 }
+#endif
 
 #ifdef READONLY_CHECK
 /* Use checksums to assert that NIFs do not write into inspected binaries
diff --git a/erts/emulator/beam/erl_port_task.c b/erts/emulator/beam/erl_port_task.c
index 25bba5cf17..a8cb4563d6 100644
--- a/erts/emulator/beam/erl_port_task.c
+++ b/erts/emulator/beam/erl_port_task.c
@@ -62,6 +62,7 @@ do {					\
     (P)->sched.next = NULL;		\
 } while (0)
 
+#ifdef USE_VM_PROBES
 #define DTRACE_DRIVER(PROBE_NAME, PP)                              \
     if (DTRACE_ENABLED(driver_ready_input)) {                      \
         DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);         \
@@ -71,6 +72,9 @@ do {					\
         dtrace_port_str(PP, port_str);                             \
         DTRACE3(PROBE_NAME, process_str, port_str, PP->name);      \
     }
+#else
+#define  DTRACE_DRIVER(PROBE_NAME, PP) do {} while(0)
+#endif
 
 erts_smp_atomic_t erts_port_task_outstanding_io_tasks;
 
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index f678d4159d..ff4e9c3d88 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -6219,12 +6219,14 @@ Process *schedule(Process *p, int calls)
     int actual_reds;
     int reds;
 
+#ifdef USE_VM_PROBES
     if (p != NULL && DTRACE_ENABLED(process_unscheduled)) {
         DTRACE_CHARBUF(process_buf, DTRACE_TERM_BUF_SIZE);
 
         dtrace_proc_str(p, process_buf);
         DTRACE1(process_unscheduled, process_buf);
     }
+#endif
 
     if (ERTS_USE_MODIFIED_TIMING()) {
 	context_reds = ERTS_MODIFIED_TIMING_CONTEXT_REDS;
@@ -7400,6 +7402,7 @@ erl_create_process(Process* parent, /* Parent of process (default group leader).
 
     VERBOSE(DEBUG_PROCESSES, ("Created a new process: %T\n",p->id));
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(process_spawn)) {
         DTRACE_CHARBUF(process_name, DTRACE_TERM_BUF_SIZE);
         DTRACE_CHARBUF(mfa, DTRACE_TERM_BUF_SIZE);
@@ -7407,6 +7410,7 @@ erl_create_process(Process* parent, /* Parent of process (default group leader).
         dtrace_fun_decode(p, mod, func, arity, process_name, mfa);
         DTRACE2(process_spawn, process_name, mfa);
     }
+#endif
 
  error:
 
@@ -7988,6 +7992,7 @@ send_exit_signal(Process *c_p,		/* current process if and only
 
     ASSERT(reason != THE_NON_VALUE);
 
+#ifdef USE_VM_PROBES
     if(DTRACE_ENABLED(process_exit_signal) && is_pid(from)) {
         DTRACE_CHARBUF(sender_str, DTRACE_TERM_BUF_SIZE);
         DTRACE_CHARBUF(receiver_str, DTRACE_TERM_BUF_SIZE);
@@ -7998,6 +8003,7 @@ send_exit_signal(Process *c_p,		/* current process if and only
         erts_snprintf(reason_buf, sizeof(reason_buf) - 1, "%T", reason);
         DTRACE3(process_exit_signal, sender_str, receiver_str, reason_buf);
     }
+#endif
 
     if (ERTS_PROC_IS_TRAPPING_EXITS(rp)
 	&& (reason != am_kill || (flags & ERTS_XSIG_FLG_IGN_KILL))) {
@@ -8430,6 +8436,7 @@ erts_do_exit_process(Process* p, Eterm reason)
     p->arity = 0;		/* No live registers */
     p->fvalue = reason;
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(process_exit)) {
         DTRACE_CHARBUF(process_buf, DTRACE_TERM_BUF_SIZE);
         DTRACE_CHARBUF(reason_buf, 256);
@@ -8438,6 +8445,7 @@ erts_do_exit_process(Process* p, Eterm reason)
         erts_snprintf(reason_buf, sizeof(reason_buf) - 1, "%T", reason);
         DTRACE2(process_exit, process_buf, reason_buf);
     }
+#endif
 
 #ifdef ERTS_SMP
     ERTS_SMP_CHK_HAVE_ONLY_MAIN_PROC_LOCK(p);
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 9425576980..8a2a43bebd 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -181,6 +181,7 @@ typedef struct line_buf_context {
 
 #define LINEBUF_INITIAL 100
 
+#ifdef USE_VM_PROBES
 #define DTRACE_FORMAT_COMMON_PID_AND_PORT(PID, PORT)         \
     DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);       \
     DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);          \
@@ -193,7 +194,7 @@ typedef struct line_buf_context {
                                                              \
     dtrace_proc_str((PID), process_str);                     \
     dtrace_port_str((PORT), port_str);
-
+#endif
 
 /* The 'number' field in a port now has two parts: the lowest bits
    contain the index in the port table, and the higher bits are a counter
@@ -653,10 +654,12 @@ erts_open_driver(erts_driver_t* driver,	/* Pointer to driver. */
 	    trace_sched_ports_where(port, am_in, am_start);
 	}
 	port->caller = pid;
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(driver_start)) {
             DTRACE_FORMAT_COMMON_PID_AND_PORT(pid, port)
             DTRACE3(driver_start, process_str, driver->name, port_str);
         }
+#endif
 	fpe_was_unmasked = erts_block_fpe();
 	drv_data = (*driver->start)((ErlDrvPort)(port_ix),
 				    name, opts);
@@ -1188,10 +1191,12 @@ int erts_write_to_port(Eterm caller_id, Port *p, Eterm list)
 	ev.size = size;  /* total size */
 	ev.iov = ivp;
 	ev.binv = bvp;
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(driver_outputv)) {
             DTRACE_FORMAT_COMMON_PID_AND_PORT(caller_id, p)
             DTRACE4(driver_outputv, process_str, port_str, p->name, size);
         }
+#endif
 	fpe_was_unmasked = erts_block_fpe();
 	(*drv->outputv)((ErlDrvData)p->drv_data, &ev);
 	erts_unblock_fpe(fpe_was_unmasked);
@@ -1211,17 +1216,21 @@ int erts_write_to_port(Eterm caller_id, Port *p, Eterm list)
 	buf = erts_alloc(ERTS_ALC_T_TMP, size+1);
 	r = io_list_to_buf(list, buf, size);
 
+#ifdef USE_VM_PROBES
 	if(DTRACE_ENABLED(port_command)) {
             DTRACE_FORMAT_COMMON_PID_AND_PORT(caller_id, p)
 	    DTRACE4(port_command, process_str, port_str, p->name, "command");
 	}
+#endif
 
 	if (r >= 0) {
 	    size -= r;
+#ifdef USE_VM_PROBES
             if (DTRACE_ENABLED(driver_output)) {
                 DTRACE_FORMAT_COMMON_PID_AND_PORT(caller_id, p)
                 DTRACE4(driver_output, process_str, port_str, p->name, size);
             }
+#endif
 	    fpe_was_unmasked = erts_block_fpe();
 	    (*drv->output)((ErlDrvData)p->drv_data, buf, size);
 	    erts_unblock_fpe(fpe_was_unmasked);
@@ -1245,10 +1254,12 @@ int erts_write_to_port(Eterm caller_id, Port *p, Eterm list)
 	     */
 	    buf = erts_alloc(ERTS_ALC_T_TMP, size+1); 
 	    r = io_list_to_buf(list, buf, size);
+#ifdef USE_VM_PROBES
             if (DTRACE_ENABLED(driver_output)) {
                 DTRACE_FORMAT_COMMON_PID_AND_PORT(caller_id, p)
                 DTRACE4(driver_output, process_str, port_str, p->name, size);
             }
+#endif
 	    fpe_was_unmasked = erts_block_fpe();
 	    (*drv->output)((ErlDrvData)p->drv_data, buf, size);
 	    erts_unblock_fpe(fpe_was_unmasked);
@@ -1857,10 +1868,12 @@ static void flush_port(Port *p)
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
 
     if (p->drv_ptr->flush != NULL) {
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(driver_flush)) {
             DTRACE_FORMAT_COMMON_PID_AND_PORT(p->connected, p)
             DTRACE3(driver_flush, process_str, port_str, p->name);
         }
+#endif
         if (IS_TRACED_FL(p, F_TRACE_SCHED_PORTS)) {
 	    trace_sched_ports_where(p, am_in, am_flush);
 	}
@@ -1916,10 +1929,12 @@ terminate_port(Port *prt)
     drv = prt->drv_ptr;
     if ((drv != NULL) && (drv->stop != NULL)) {
 	int fpe_was_unmasked = erts_block_fpe();
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(driver_stop)) {
             DTRACE_FORMAT_COMMON_PID_AND_PORT(prt->connected, prt)
             DTRACE3(driver_stop, process_str, drv->name, port_str);
         }
+#endif
 	(*drv->stop)((ErlDrvData)prt->drv_data);
 	erts_unblock_fpe(fpe_was_unmasked);
 #ifdef ERTS_SMP
@@ -2081,6 +2096,7 @@ erts_do_exit_port(Port *p, Eterm from, Eterm reason)
 
    rreason = (reason == am_kill) ? am_killed : reason;
 
+#ifdef USE_VM_PROBES
    if (DTRACE_ENABLED(port_exit)) {
        DTRACE_CHARBUF(from_str, DTRACE_TERM_BUF_SIZE);
        DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
@@ -2091,6 +2107,7 @@ erts_do_exit_port(Port *p, Eterm from, Eterm reason)
        erts_snprintf(rreason_str, sizeof(rreason_str), "%T", rreason);
        DTRACE4(port_exit, from_str, port_str, p->name, rreason_str);
    }
+#endif
 
    if ((p->status & (ERTS_PORT_SFLGS_DEAD
 		     | ERTS_PORT_SFLG_EXITING
@@ -2193,10 +2210,12 @@ void erts_port_command(Process *proc,
 		erts_port_status_bor_set(port, ERTS_PORT_SFLG_SEND_CLOSED);
 		erts_do_exit_port(port, pid, am_normal);
 
+#ifdef USE_VM_PROBES
 		if(DTRACE_ENABLED(port_command)) {
                     DTRACE_FORMAT_COMMON_PROC_AND_PORT(proc, port)
 		    DTRACE4(port_command, process_str, port_str, port->name, "close");
 		}
+#endif
 		goto done;
 	    } else if (is_tuple_arity(tp[2], 2)) {
 		tp = tuple_val(tp[2]);
@@ -2204,10 +2223,12 @@ void erts_port_command(Process *proc,
 		    if (erts_write_to_port(caller_id, port, tp[2]) == 0)
 			goto done;
 		} else if ((tp[1] == am_connect) && is_internal_pid(tp[2])) {
+#ifdef USE_VM_PROBES
 		    if(DTRACE_ENABLED(port_command)) {
                         DTRACE_FORMAT_COMMON_PROC_AND_PORT(proc, port)
 			DTRACE4(port_command, process_str, port_str, port->name, "connect");
 		    }
+#endif
 		    port->connected = tp[2];
 		    deliver_result(port->id, pid, am_connected);
 		    goto done;
@@ -2310,12 +2331,14 @@ erts_port_control(Process* p, Port* prt, Uint command, Eterm iolist)
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
     ERTS_SMP_CHK_NO_PROC_LOCKS;
 
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(port_control) || DTRACE_ENABLED(driver_control)) {
         DTRACE_FORMAT_COMMON_PROC_AND_PORT(p, prt);
         DTRACE4(port_control, process_str, port_str, prt->name, command);
         DTRACE5(driver_control, process_str, port_str, prt->name,
                 command, to_len);
     }
+#endif
 
     /*
      * Call the port's control routine.
@@ -2457,7 +2480,9 @@ print_port_info(int to, void *arg, int i)
 void
 set_busy_port(ErlDrvPort port_num, int on)
 {
+#ifdef USE_VM_PROBES
     DTRACE_CHARBUF(port_str, 16);
+#endif
 
     ERTS_SMP_CHK_NO_PROC_LOCKS;
 
@@ -2466,22 +2491,26 @@ set_busy_port(ErlDrvPort port_num, int on)
     if (on) {
         erts_port_status_bor_set(&erts_port[port_num],
 				 ERTS_PORT_SFLG_PORT_BUSY);
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(port_busy)) {
             erts_snprintf(port_str, sizeof(port_str),
                           "%T", erts_port[port_num].id);
             DTRACE1(port_busy, port_str);
         }
+#endif
     } else {
         ErtsProcList* plp = erts_port[port_num].suspended;
         erts_port_status_band_set(&erts_port[port_num],
 				  ~ERTS_PORT_SFLG_PORT_BUSY);
         erts_port[port_num].suspended = NULL;
 
+#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(port_not_busy)) {
             erts_snprintf(port_str, sizeof(port_str),
                           "%T", erts_port[port_num].id);
             DTRACE1(port_not_busy, port_str);
         }
+#endif
 	if (erts_port[port_num].dist_entry) {
 	    /*
 	     * Processes suspended on distribution ports are
@@ -2499,6 +2528,7 @@ set_busy_port(ErlDrvPort port_num, int on)
 	 */
 
         if (plp) {
+#ifdef USE_VM_PROBES
             /*
              * Hrm, for blocked dist ports, plp always seems to be NULL.
              * That's not so fun.
@@ -2519,6 +2549,7 @@ set_busy_port(ErlDrvPort port_num, int on)
                     DTRACE2(process_port_unblocked, pid_str, port_str);
                 }
             }
+#endif
             /* First proc should be resumed last */
 	    if (plp->next) {
 		erts_resume_processes(plp->next);
@@ -2565,12 +2596,14 @@ void erts_raw_port_command(Port* p, byte* buf, Uint len)
 		 p->drv_ptr->name ? p->drv_ptr->name : "unknown");
 
     p->caller = NIL;
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(driver_output)) {
         DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
 
         dtrace_port_str(p, port_str);
         DTRACE4(driver_output, "-raw-", port_str, p->name, len);
     }
+#endif
     fpe_was_unmasked = erts_block_fpe();
     (*p->drv_ptr->output)((ErlDrvData)p->drv_data, (char*) buf, (int) len);
     erts_unblock_fpe(fpe_was_unmasked);
@@ -2586,10 +2619,12 @@ int async_ready(Port *p, void* data)
 	ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
 	ASSERT(!(p->status & ERTS_PORT_SFLGS_DEAD));
 	if (p->drv_ptr->ready_async != NULL) {
+#ifdef USE_VM_PROBES
             if (DTRACE_ENABLED(driver_ready_async)) {
                 DTRACE_FORMAT_COMMON_PID_AND_PORT(p->connected, p)
                 DTRACE3(driver_ready_async, process_str, port_str, p->name);
             }
+#endif
 	    (*p->drv_ptr->ready_async)((ErlDrvData)p->drv_data, data);
 	    need_free = 0;
 #ifdef ERTS_SMP
@@ -4573,10 +4608,12 @@ void erts_fire_port_monitor(Port *prt, Eterm ref)
     ASSERT(callback != NULL);
     ref_to_driver_monitor(ref,&drv_monitor);
     DRV_MONITOR_UNLOCK_PDL(prt);
+#ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(driver_process_exit)) {
         DTRACE_FORMAT_COMMON_PID_AND_PORT(prt->connected, prt)
         DTRACE3(driver_process_exit, process_str, port_str, prt->name);
     }
+#endif
     fpe_was_unmasked = erts_block_fpe();
     (*callback)((ErlDrvData) (prt->drv_data), &drv_monitor);
     erts_unblock_fpe(fpe_was_unmasked);