Merge branch 'dev' into major

4 files changed, 123 insertions, 86 deletions

diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 5edcd667e7..e3445bcdc5 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -100,14 +100,14 @@ static Uint combined_message_size(Process* p);
 static void remove_message_buffers(Process* p);
 static int major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl);
 static int minor_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl);
-static void do_minor(Process *p, int new_sz, Eterm* objv, int nobj);
+static void do_minor(Process *p, Uint new_sz, Eterm* objv, int nobj);
 static Eterm* sweep_rootset(Rootset *rootset, Eterm* htop, char* src, Uint src_size);
 static Eterm* sweep_one_area(Eterm* n_hp, Eterm* n_htop, char* src, Uint src_size);
 static Eterm* sweep_one_heap(Eterm* heap_ptr, Eterm* heap_end, Eterm* htop,
 			     char* src, Uint src_size);
 static Eterm* collect_heap_frags(Process* p, Eterm* heap,
 				 Eterm* htop, Eterm* objv, int nobj);
-static Uint adjust_after_fullsweep(Process *p, int size_before,
+static Uint adjust_after_fullsweep(Process *p, Uint size_before,
 				   int need, Eterm *objv, int nobj);
 static void shrink_new_heap(Process *p, Uint new_sz, Eterm *objv, int nobj);
 static void grow_new_heap(Process *p, Uint new_sz, Eterm* objv, int nobj);
@@ -441,7 +441,15 @@ erts_garbage_collect(Process* p, int need, Eterm* objv, int nobj)
     p->last_old_htop = p->old_htop;
 #endif
 
-    return ((int) (HEAP_TOP(p) - HEAP_START(p)) / 10);
+    /* FIXME: This function should really return an Sint, i.e., a possibly
+       64 bit wide signed integer, but that requires updating all the code
+       that calls it. For now, we just return INT_MAX if the result is too
+       large for an int. */
+    {
+      Sint result = (HEAP_TOP(p) - HEAP_START(p)) / 10;
+      if (result >= INT_MAX) return INT_MAX;
+      else return (int) result;
+    }
 }
 
 /*
@@ -599,7 +607,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals, Uint lit_size)
     char* area;
     Uint area_size;
     Eterm* old_htop;
-    int n;
+    Uint n;
 
     /*
      * Set GC state.
@@ -731,7 +739,7 @@ minor_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
          * This improved Estone by more than 1200 estones on my computer
          * (Ultra Sparc 10).
          */
-        size_t new_sz = erts_next_heap_size(HEAP_TOP(p) - HEAP_START(p), 1);
+        Uint new_sz = erts_next_heap_size(HEAP_TOP(p) - HEAP_START(p), 1);
 
         /* Create new, empty old_heap */
         n_old = (Eterm *) ERTS_HEAP_ALLOC(ERTS_ALC_T_OLD_HEAP,
@@ -871,12 +879,12 @@ minor_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
 #endif /* HIPE */
 
 static void
-do_minor(Process *p, int new_sz, Eterm* objv, int nobj)
+do_minor(Process *p, Uint new_sz, Eterm* objv, int nobj)
 {
     Rootset rootset;            /* Rootset for GC (stack, dictionary, etc). */
     Roots* roots;
     Eterm* n_htop;
-    int n;
+    Uint n;
     Eterm* ptr;
     Eterm val;
     Eterm gval;
@@ -1079,14 +1087,14 @@ major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
 {
     Rootset rootset;
     Roots* roots;
-    int size_before;
+    Uint size_before;
     Eterm* n_heap;
     Eterm* n_htop;
     char* src = (char *) HEAP_START(p);
     Uint src_size = (char *) HEAP_TOP(p) - src;
     char* oh = (char *) OLD_HEAP(p);
     Uint oh_size = (char *) OLD_HTOP(p) - oh;
-    int n;
+    Uint n;
     Uint new_sz;
     Uint fragments = MBUF_SIZE(p) + combined_message_size(p);
     ErlMessage *msgp;
@@ -1312,10 +1320,10 @@ major_collection(Process* p, int need, Eterm* objv, int nobj, Uint *recl)
 }
 
 static Uint
-adjust_after_fullsweep(Process *p, int size_before, int need, Eterm *objv, int nobj)
+adjust_after_fullsweep(Process *p, Uint size_before, int need, Eterm *objv, int nobj)
 {
-    int wanted, sz, size_after, need_after;
-    int stack_size = STACK_SZ_ON_HEAP(p);
+    Uint wanted, sz, size_after, need_after;
+    Uint stack_size = STACK_SZ_ON_HEAP(p);
     Uint reclaimed_now;
 
     size_after = (HEAP_TOP(p) - HEAP_START(p));
@@ -1915,8 +1923,8 @@ static void
 grow_new_heap(Process *p, Uint new_sz, Eterm* objv, int nobj)
 {
     Eterm* new_heap;
-    int heap_size = HEAP_TOP(p) - HEAP_START(p);
-    int stack_size = p->hend - p->stop;
+    Uint heap_size = HEAP_TOP(p) - HEAP_START(p);
+    Uint stack_size = p->hend - p->stop;
     Sint offs;
 
     ASSERT(HEAP_SIZE(p) < new_sz);
@@ -1954,10 +1962,10 @@ static void
 shrink_new_heap(Process *p, Uint new_sz, Eterm *objv, int nobj)
 {
     Eterm* new_heap;
-    int heap_size = HEAP_TOP(p) - HEAP_START(p);
+    Uint heap_size = HEAP_TOP(p) - HEAP_START(p);
     Sint offs;
 
-    int stack_size = p->hend - p->stop;
+    Uint stack_size = p->hend - p->stop;
 
     ASSERT(new_sz < p->heap_sz);
     sys_memmove(p->heap + new_sz - stack_size, p->stop, stack_size *
diff --git a/erts/emulator/test/mtx_SUITE_data/mtx_SUITE.c b/erts/emulator/test/mtx_SUITE_data/mtx_SUITE.c
index 818023211c..0e4065c26b 100644
--- a/erts/emulator/test/mtx_SUITE_data/mtx_SUITE.c
+++ b/erts/emulator/test/mtx_SUITE_data/mtx_SUITE.c
@@ -552,13 +552,19 @@ create_rwlock(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 static ERL_NIF_TERM
 rwlock_op(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 {
-    rwlock_resource_t *rwlr;
+    /*
+     * Use a union for pointer type conversion to avoid compiler warnings
+     * about strict-aliasing violations with gcc-4.1. gcc >= 4.2 does not
+     * emit the warning.
+     * TODO: Reconsider use of union once gcc-4.1 is obsolete?
+     */
+    union { void* vp; rwlock_resource_t *p; } rwlr;
     int blocking, write, wait_locked, wait_unlocked;
 
     if (argc != 5)
 	goto badarg;
 
-    if (!enif_get_resource(env, argv[0], enif_priv_data(env), (void **) &rwlr))
+    if (!enif_get_resource(env, argv[0], enif_priv_data(env), &rwlr.vp))
 	goto badarg;
 
     blocking = get_bool(env, argv[1]);
@@ -581,22 +587,22 @@ rwlock_op(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 
     if (write) {
 	if (blocking)
-	    RWMUTEX_WLOCK(rwlr->rwlock);
+	    RWMUTEX_WLOCK(rwlr.p->rwlock);
 	else
-	    while (EBUSY == RWMUTEX_TRYWLOCK(rwlr->rwlock));
-	if (rwlr->lock_check) {
-	    ASSERT(!ATOMIC_READ(&rwlr->is_locked));
-	    ATOMIC_SET(&rwlr->is_locked, -1);
+	    while (EBUSY == RWMUTEX_TRYWLOCK(rwlr.p->rwlock));
+	if (rwlr.p->lock_check) {
+	    ASSERT(!ATOMIC_READ(&rwlr.p->is_locked));
+	    ATOMIC_SET(&rwlr.p->is_locked, -1);
 	}
     }
     else {
 	if (blocking)
-	    RWMUTEX_RLOCK(rwlr->rwlock);
+	    RWMUTEX_RLOCK(rwlr.p->rwlock);
 	else
-	    while (EBUSY == RWMUTEX_TRYRLOCK(rwlr->rwlock));
-	if (rwlr->lock_check) {
-	    ASSERT(ATOMIC_READ(&rwlr->is_locked) >= 0);
-	    ATOMIC_INC(&rwlr->is_locked);
+	    while (EBUSY == RWMUTEX_TRYRLOCK(rwlr.p->rwlock));
+	if (rwlr.p->lock_check) {
+	    ASSERT(ATOMIC_READ(&rwlr.p->is_locked) >= 0);
+	    ATOMIC_INC(&rwlr.p->is_locked);
 	}
     }
 
@@ -604,18 +610,18 @@ rwlock_op(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
 	milli_sleep(wait_locked);
 
     if (write) {
-	if (rwlr->lock_check) {
-	    ASSERT(ATOMIC_READ(&rwlr->is_locked) == -1);
-	    ATOMIC_SET(&rwlr->is_locked, 0);
+	if (rwlr.p->lock_check) {
+	    ASSERT(ATOMIC_READ(&rwlr.p->is_locked) == -1);
+	    ATOMIC_SET(&rwlr.p->is_locked, 0);
 	}
-	RWMUTEX_WUNLOCK(rwlr->rwlock);
+	RWMUTEX_WUNLOCK(rwlr.p->rwlock);
     }
     else {
-	if (rwlr->lock_check) {
-	    ASSERT(ATOMIC_READ(&rwlr->is_locked) > 0);
-	    ATOMIC_DEC(&rwlr->is_locked);
+	if (rwlr.p->lock_check) {
+	    ASSERT(ATOMIC_READ(&rwlr.p->is_locked) > 0);
+	    ATOMIC_DEC(&rwlr.p->is_locked);
 	}
-	RWMUTEX_RUNLOCK(rwlr->rwlock);
+	RWMUTEX_RUNLOCK(rwlr.p->rwlock);
     }
 
     if (wait_unlocked)
diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index bdf1549862..cf2ec4aaf0 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -41,7 +41,18 @@ typedef struct
     CallInfo* call_history;
     NifModPrivData* nif_mod;
     union { ErlNifResourceType* t; long l; } rt_arr[2];
-}PrivData;
+} PrivData;
+
+/*
+ * Use a union for pointer type conversion to avoid compiler warnings
+ * about strict-aliasing violations with gcc-4.1. gcc >= 4.2 does not
+ * emit the warning.
+ * TODO: Reconsider use of union once gcc-4.1 is obsolete?
+ */
+typedef union {
+    void* vp;
+    struct make_term_info* p;
+} mti_t;
 
 void add_call(ErlNifEnv* env, PrivData* data, const char* func_name)
 {
@@ -707,7 +718,7 @@ static ERL_NIF_TERM get_resource_type(ErlNifEnv* env, int argc, const ERL_NIF_TE
 static ERL_NIF_TERM alloc_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     ErlNifBinary data_bin;
-    union { ErlNifResourceType* t; long l;} type;
+    union { ErlNifResourceType* t; long l; } type;
     union { void* p; long l;} data;
     if (!enif_get_long(env, argv[0], &type.l)
 	|| !enif_inspect_binary(env, argv[1], &data_bin)
@@ -731,7 +742,7 @@ static ERL_NIF_TERM make_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM a
 static ERL_NIF_TERM make_new_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     ErlNifBinary data_bin;
-    union { ErlNifResourceType* t; long l;} type;
+    union { ErlNifResourceType* t; long l; } type;
     void* data;
     ERL_NIF_TERM ret;
     if (!enif_get_long(env, argv[0], &type.l)
@@ -749,7 +760,7 @@ static ERL_NIF_TERM make_new_resource(ErlNifEnv* env, int argc, const ERL_NIF_TE
 static ERL_NIF_TERM make_new_resource_binary(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     ErlNifBinary data_bin;
-    union { struct binary_resource* p; void* vp; long l;} br;
+    union { struct binary_resource* p; void* vp; long l; } br;
     void* buf;
     ERL_NIF_TERM ret;
     if (!enif_inspect_binary(env, argv[0], &data_bin)
@@ -1269,10 +1280,7 @@ static void msgenv_dtor(ErlNifEnv* env, void* obj)
 
 static ERL_NIF_TERM clear_msgenv(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    union {
-	void* vp;
-	struct make_term_info* p;
-    }mti;
+    mti_t mti;
     if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)) {
 	return enif_make_badarg(env);
     }
@@ -1285,7 +1293,7 @@ static ERL_NIF_TERM clear_msgenv(ErlNifEnv* env, int argc, const ERL_NIF_TERM ar
 
 static ERL_NIF_TERM grow_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    union { void* vp; struct make_term_info* p; }mti;
+    mti_t mti;
     ERL_NIF_TERM term;
     if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)
 	|| (argc>2 && !enif_get_uint(env,argv[2], &mti.p->n))) {
@@ -1301,7 +1309,7 @@ static ERL_NIF_TERM grow_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[
 
 static ERL_NIF_TERM send_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    union { void* vp; struct make_term_info* p; }mti;
+    mti_t mti;
     ErlNifPid to;
     ERL_NIF_TERM copy;
     int res;
@@ -1316,7 +1324,7 @@ static ERL_NIF_TERM send_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[
 
 static ERL_NIF_TERM send3_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    union { void* vp; struct make_term_info* p; }mti;
+    mti_t mti;
     ErlNifPid to;
     ERL_NIF_TERM copy;
     int res;
@@ -1334,7 +1342,7 @@ static ERL_NIF_TERM send3_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv
 void* threaded_sender(void *arg)
 {
 
-    union { void* vp; struct make_term_info* p; }mti;
+    mti_t mti;
     mti.vp = arg;
 
     enif_mutex_lock(mti.p->mtx);
@@ -1349,7 +1357,7 @@ void* threaded_sender(void *arg)
 
 static ERL_NIF_TERM send_blob_thread(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    union { void* vp; struct make_term_info* p; }mti;
+    mti_t mti;
     ERL_NIF_TERM copy;
     if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)
 	|| !enif_get_local_pid(env,argv[1], &mti.p->to_pid)) {
@@ -1375,7 +1383,7 @@ static ERL_NIF_TERM send_blob_thread(ErlNifEnv* env, int argc, const ERL_NIF_TER
 
 static ERL_NIF_TERM join_send_thread(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    union { void* vp; struct make_term_info* p; }mti;
+    mti_t mti;
     int err;
     if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)) {
 	return enif_make_badarg(env);
@@ -1392,7 +1400,7 @@ static ERL_NIF_TERM join_send_thread(ErlNifEnv* env, int argc, const ERL_NIF_TER
 
 static ERL_NIF_TERM copy_blob(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    union { void* vp; struct make_term_info* p; }mti;
+    mti_t mti;
     if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)) {
 	return enif_make_badarg(env);
     }
diff --git a/erts/example/matrix_nif.c b/erts/example/matrix_nif.c
index c5e01dade5..43f9526ae3 100644
--- a/erts/example/matrix_nif.c
+++ b/erts/example/matrix_nif.c
@@ -31,7 +31,19 @@ typedef struct
     unsigned nrows;
     unsigned ncols;
     double* data;
-}Matrix;
+} Matrix;
+
+/*
+ * Use a union for pointer type conversion to avoid compiler warnings
+ * about strict-aliasing violations with gcc-4.1. gcc >= 4.2 does not
+ * emit the warning.
+ * TODO: Reconsider use of union once gcc-4.1 is obsolete?
+ */
+typedef union
+{
+    void* vp;
+    Matrix* p;
+} mx_t;
 
 #define POS(MX, ROW, COL) ((MX)->data[(ROW)* (MX)->ncols + (COL)])
 
@@ -44,8 +56,9 @@ static ErlNifResourceType* resource_type = NULL;
 
 static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 {
-    ErlNifResourceType* rt = enif_open_resource_type(env, "matrix_nif_example",
-						     matrix_dtor, 
+    ErlNifResourceType* rt = enif_open_resource_type(env, NULL,
+						     "matrix_nif_example",
+						     matrix_dtor,
 						     ERL_NIF_RT_CREATE, NULL);
     if (rt == NULL) {
 	return -1;
@@ -90,12 +103,12 @@ static ERL_NIF_TERM create(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     }
 
     ret = enif_make_resource(env, mx);
-    enif_release_resource(env, mx);
+    enif_release_resource(mx);
     return ret;
 
 badarg:
     if (mx != NULL) {
-	enif_release_resource(env,mx);
+	enif_release_resource(mx);
     }
     return enif_make_badarg(env);
 }
@@ -104,14 +117,14 @@ badarg:
 static ERL_NIF_TERM pos(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     /* pos(Matrix, Row, Column) -> float() */
-    Matrix* mx;
+    mx_t mx;
     unsigned i, j;
-    if (!enif_get_resource(env, argv[0], resource_type, (void**)&mx) ||
-	!enif_get_uint(env, argv[1], &i) || (--i >= mx->nrows) ||
-	!enif_get_uint(env, argv[2], &j) || (--j >= mx->ncols)) {
+    if (!enif_get_resource(env, argv[0], resource_type, &mx.vp) ||
+	!enif_get_uint(env, argv[1], &i) || (--i >= mx.p->nrows) ||
+	!enif_get_uint(env, argv[2], &j) || (--j >= mx.p->ncols)) {
 	return enif_make_badarg(env);
     }
-    return enif_make_double(env, POS(mx, i,j));
+    return enif_make_double(env, POS(mx.p, i,j));
 }
 
 static ERL_NIF_TERM add(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
@@ -119,37 +132,38 @@ static ERL_NIF_TERM add(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     /* add(Matrix_A, Matrix_B) -> Matrix_Sum */
     unsigned i, j;
     ERL_NIF_TERM ret;
-    Matrix* mxA = NULL;
-    Matrix* mxB = NULL;
-    Matrix* mxS = NULL;
+    mx_t mxA, mxB, mxS;
+    mxA.p = NULL;
+    mxB.p = NULL;
+    mxS.p = NULL;
 
-    if (!enif_get_resource(env, argv[0], resource_type, (void**)&mxA) ||
-	!enif_get_resource(env, argv[1], resource_type, (void**)&mxB) ||
-	mxA->nrows != mxB->nrows ||
-	mxB->ncols != mxB->ncols) {
+    if (!enif_get_resource(env, argv[0], resource_type, &mxA.vp) ||
+	!enif_get_resource(env, argv[1], resource_type, &mxB.vp) ||
+	mxA.p->nrows != mxB.p->nrows ||
+	mxB.p->ncols != mxB.p->ncols) {
 
     	return enif_make_badarg(env);
     }
-    mxS = alloc_matrix(env, mxA->nrows, mxA->ncols);
-    for (i = 0; i < mxA->nrows; i++) {
-	for (j = 0; j < mxA->ncols; j++) {
-	    POS(mxS, i, j) = POS(mxA, i, j) + POS(mxB, i, j);
+    mxS.p = alloc_matrix(env, mxA.p->nrows, mxA.p->ncols);
+    for (i = 0; i < mxA.p->nrows; i++) {
+	for (j = 0; j < mxA.p->ncols; j++) {
+	    POS(mxS.p, i, j) = POS(mxA.p, i, j) + POS(mxB.p, i, j);
 	}
     }
-    ret = enif_make_resource(env, mxS);
-    enif_release_resource(env, mxS);
+    ret = enif_make_resource(env, mxS.p);
+    enif_release_resource(mxS.p);
     return ret;
 }
 
 static ERL_NIF_TERM size_of(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     /* size(Matrix) -> {Nrows, Ncols} */
-    Matrix* mx;
-    if (!enif_get_resource(env, argv[0], resource_type, (void**)&mx)) {
+    mx_t mx;
+    if (!enif_get_resource(env, argv[0], resource_type, &mx.vp)) {
 	return enif_make_badarg(env);
     }
-    return enif_make_tuple2(env, enif_make_uint(env, mx->nrows),
-			    enif_make_uint(env, mx->ncols));
+    return enif_make_tuple2(env, enif_make_uint(env, mx.p->nrows),
+			    enif_make_uint(env, mx.p->ncols));
 }
 
 static ERL_NIF_TERM to_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
@@ -157,16 +171,17 @@ static ERL_NIF_TERM to_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     /* to_term(Matrix) -> [[first row], [second row], ...,[last row]] */
     unsigned i, j;
     ERL_NIF_TERM res;
-    Matrix* mx = NULL;
+    mx_t mx;
+    mx.p = NULL;
 
-    if (!enif_get_resource(env, argv[0], resource_type, (void**)&mx)) {	
+    if (!enif_get_resource(env, argv[0], resource_type, &mx.vp)) {
     	return enif_make_badarg(env);
     }
     res = enif_make_list(env, 0);
-    for (i = mx->nrows; i-- > 0; ) {
+    for (i = mx.p->nrows; i-- > 0; ) {
 	ERL_NIF_TERM row = enif_make_list(env, 0);
-	for (j = mx->ncols; j-- > 0; ) {
-	    row = enif_make_list_cell(env, enif_make_double(env, POS(mx,i,j)),
+	for (j = mx.p->ncols; j-- > 0; ) {
+	    row = enif_make_list_cell(env, enif_make_double(env, POS(mx.p,i,j)),
 				      row);
 	}
 	res = enif_make_list_cell(env, row, res);
@@ -183,17 +198,17 @@ static int get_number(ErlNifEnv* env, ERL_NIF_TERM term, double* dp)
 
 static Matrix* alloc_matrix(ErlNifEnv* env, unsigned nrows, unsigned ncols)
 {
-    Matrix* mx = enif_alloc_resource(env, resource_type, sizeof(Matrix));
+    Matrix* mx = enif_alloc_resource(resource_type, sizeof(Matrix));
     mx->nrows = nrows;
     mx->ncols = ncols;
-    mx->data = enif_alloc(env, nrows*ncols*sizeof(double));
+    mx->data = enif_alloc(nrows*ncols*sizeof(double));
     return mx;
 }
 
 static void matrix_dtor(ErlNifEnv* env, void* obj)
 {
     Matrix* mx = (Matrix*) obj;
-    enif_free(env, mx->data);
+    enif_free(mx->data);
     mx->data = NULL;
 }