From 8db78b0c92a26e2a7766f8ece2f0ed7abb5db791 Mon Sep 17 00:00:00 2001
From: Filipe David Manana <fdmanana@apache.org>
Date: Wed, 8 Jun 2011 17:33:18 +0100
Subject: Add NIF function enif_is_number

This function allows for easily determining if a term represents
or not a number (integer, float, small or big).
---
 erts/doc/src/erl_nif.xml                      |  4 ++++
 erts/emulator/beam/erl_nif.c                  |  5 +++++
 erts/emulator/beam/erl_nif_api_funcs.h        |  2 ++
 erts/emulator/test/nif_SUITE.erl              | 25 +++++++++++++++++++++++--
 erts/emulator/test/nif_SUITE_data/nif_SUITE.c |  4 +++-
 5 files changed, 37 insertions(+), 3 deletions(-)

(limited to 'erts')

diff --git a/erts/doc/src/erl_nif.xml b/erts/doc/src/erl_nif.xml
index cdce4ec0b8..0f05d79488 100644
--- a/erts/doc/src/erl_nif.xml
+++ b/erts/doc/src/erl_nif.xml
@@ -692,6 +692,10 @@ typedef enum {
       <fsummary>Determine if a term is an exception</fsummary>
       <desc><p>Return true if <c>term</c> is an exception.</p></desc>
     </func>
+    <func><name><ret>int</ret><nametext>enif_is_number(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
+      <fsummary>Determine if a term is a number (integer or float)</fsummary>
+      <desc><p>Return true if <c>term</c> is a number.</p></desc>
+    </func>
     <func><name><ret>int</ret><nametext>enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
       <fsummary>Determine if a term is a fun</fsummary>
       <desc><p>Return true if <c>term</c> is a fun.</p></desc>
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 68421b4387..7ea0e1f6b2 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -435,6 +435,11 @@ int enif_is_exception(ErlNifEnv* env, ERL_NIF_TERM term)
     return term == THE_NON_VALUE;
 }
 
+int enif_is_number(ErlNifEnv* env, ERL_NIF_TERM term)
+{
+    return is_number(term);
+}
+
 static void aligned_binary_dtor(struct enif_tmp_obj_t* obj)
 {
     erts_free_aligned_binary_bytes_extra((byte*)obj,ERTS_ALC_T_TMP);
diff --git a/erts/emulator/beam/erl_nif_api_funcs.h b/erts/emulator/beam/erl_nif_api_funcs.h
index c991b61abe..43d706dc72 100644
--- a/erts/emulator/beam/erl_nif_api_funcs.h
+++ b/erts/emulator/beam/erl_nif_api_funcs.h
@@ -136,6 +136,7 @@ ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_int64,(ErlNifEnv*, ErlNifSInt64));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_uint64,(ErlNifEnv*, ErlNifUInt64));
 #endif
 ERL_NIF_API_FUNC_DECL(int,enif_is_exception,(ErlNifEnv*, ERL_NIF_TERM term));
+ERL_NIF_API_FUNC_DECL(int,enif_is_number,(ErlNifEnv*, ERL_NIF_TERM term));
 
 /*
 ** Add new entries here to keep compatibility on Windows!!!
@@ -256,6 +257,7 @@ ERL_NIF_API_FUNC_DECL(int,enif_is_exception,(ErlNifEnv*, ERL_NIF_TERM term));
 #endif
 
 #  define enif_is_exception ERL_NIF_API_FUNC_MACRO(enif_is_exception)
+#  define enif_is_number ERL_NIF_API_FUNC_MACRO(enif_is_number)
 
 /*
 ** Add new entries here
diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index 91d695d979..8ed9ccd9ca 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -1121,7 +1121,28 @@ is_checks(Config) when is_list(Config) ->
     ?line ensure_lib_loaded(Config, 1),
     ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
 			self(), hd(erlang:ports()), [], [1,9,9,8],
-			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}),
+			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, 12),
+    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+			self(), hd(erlang:ports()), [], [1,9,9,8],
+			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, -12),
+    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+			self(), hd(erlang:ports()), [], [1,9,9,8],
+			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, 18446744073709551617),
+    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+			self(), hd(erlang:ports()), [], [1,9,9,8],
+			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, -18446744073709551617),
+    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+			self(), hd(erlang:ports()), [], [1,9,9,8],
+			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, 99.146),
+    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+			self(), hd(erlang:ports()), [], [1,9,9,8],
+			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, -99.146),
+    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+			self(), hd(erlang:ports()), [], [1,9,9,8],
+			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, 18446744073709551616.2e2),
+    ?line ok = check_is(hejsan, <<19,98>>, make_ref(), ok, fun() -> ok end,
+			self(), hd(erlang:ports()), [], [1,9,9,8],
+			{hejsan, "hejsan", [$h,"ejs",<<"an">>]}, -18446744073709551616.2e2),
     try
         ?line error = check_is_exception(),
         ?line throw(expected_badarg)
@@ -1251,7 +1272,7 @@ get_resource(_,_) -> ?nif_stub.
 release_resource(_) -> ?nif_stub.
 last_resource_dtor_call() -> ?nif_stub.
 make_new_resource(_,_) -> ?nif_stub.
-check_is(_,_,_,_,_,_,_,_,_,_) -> ?nif_stub.
+check_is(_,_,_,_,_,_,_,_,_,_,_) -> ?nif_stub.
 check_is_exception() -> ?nif_stub.
 length_test(_,_,_,_,_) -> ?nif_stub.
 make_atoms() -> ?nif_stub.
diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index 0bb93daa33..014215bd68 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -781,6 +781,7 @@ static ERL_NIF_TERM release_resource(ErlNifEnv* env, int argc, const ERL_NIF_TER
  * argv[7] an empty list
  * argv[8] a non-empty list
  * argv[9] a tuple
+ * argv[10] a number (small, big integer or float)
  */
 static ERL_NIF_TERM check_is(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
@@ -797,6 +798,7 @@ static ERL_NIF_TERM check_is(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
     if (!enif_is_list(env, argv[7])) return enif_make_badarg(env);
     if (!enif_is_list(env, argv[8])) return enif_make_badarg(env);
     if (!enif_is_tuple(env, argv[9])) return enif_make_badarg(env);
+    if (!enif_is_number(env, argv[10])) return enif_make_badarg(env);
 
     return ok_atom;
 }
@@ -1399,7 +1401,7 @@ static ErlNifFunc nif_funcs[] =
     {"release_resource", 1, release_resource},
     {"last_resource_dtor_call", 0, last_resource_dtor_call},
     {"make_new_resource", 2, make_new_resource},
-    {"check_is", 10, check_is},
+    {"check_is", 11, check_is},
     {"check_is_exception", 0, check_is_exception},
     {"length_test", 5, length_test},
     {"make_atoms", 0, make_atoms},
-- 
cgit v1.2.3


From 49854c414bc2d7ca0d538086476ca81c34d38fae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 7 Sep 2011 10:05:11 +0200
Subject: erts/configure.in: Remove useless --disable-fixalloc option

./configure --disable-fixalloc does not do anytning any longer,
since there is no longer any "fix allocators" (in the original
sense).
---
 erts/configure.in               | 7 -------
 erts/emulator/sys/vxworks/sys.c | 3 ---
 2 files changed, 10 deletions(-)

(limited to 'erts')

diff --git a/erts/configure.in b/erts/configure.in
index 3dbf98b876..2ae9c63215 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -259,13 +259,6 @@ AS_HELP_STRING([--enable-m32-build],
   esac
 ],enable_m32_build=no)
 
-AC_ARG_ENABLE(fixalloc,
-AS_HELP_STRING([--disable-fixalloc], [disable the use of fix_alloc]))
-if test x${enable_fixalloc} = xno ; then
-  AC_DEFINE(NO_FIX_ALLOC,[],
-	    [Define if you don't want the fix allocator in Erlang])
-fi
-
 AC_SUBST(PERFCTR_PATH)
 AC_ARG_WITH(perfctr,
 AS_HELP_STRING([--with-perfctr=PATH],
diff --git a/erts/emulator/sys/vxworks/sys.c b/erts/emulator/sys/vxworks/sys.c
index c6e7b65f32..a59e4ec26a 100644
--- a/erts/emulator/sys/vxworks/sys.c
+++ b/erts/emulator/sys/vxworks/sys.c
@@ -2025,9 +2025,6 @@ int erl_memory_show(int p0, int p1, int p2, int p3, int p4, int p5,
 	erts_printf("The memory block used by elib is save_malloc'ed "
 		   "at 0x%08x.\n", (unsigned int) alloc_pool_ptr);
     }
-#ifdef NO_FIX_ALLOC
-    erts_printf("Fix_alloc is disabled in this build\n");
-#endif
     erts_printf("Statistics from elib_malloc:\n");
     ELIB_LOCK;
 
-- 
cgit v1.2.3


From 3fcc5534a40dbe9af99f5e2a84c9e56130cf0464 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 7 Sep 2011 10:23:06 +0200
Subject: erts/configure.in: Don't check for the presence of mach-o/dyld.h

We no longer include mach-o/dyld.h (because we only support
MacOS X versions that have dlopen()).
---
 erts/autoconf/win32.config.cache.static | 1 -
 erts/configure.in                       | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/autoconf/win32.config.cache.static b/erts/autoconf/win32.config.cache.static
index d25b1df9d9..bbfe66ffdf 100755
--- a/erts/autoconf/win32.config.cache.static
+++ b/erts/autoconf/win32.config.cache.static
@@ -124,7 +124,6 @@ ac_cv_header_ieeefp_h=${ac_cv_header_ieeefp_h=no}
 ac_cv_header_inttypes_h=${ac_cv_header_inttypes_h=no}
 ac_cv_header_langinfo_h=${ac_cv_header_langinfo_h=no}
 ac_cv_header_limits_h=${ac_cv_header_limits_h=yes}
-ac_cv_header_mach_o_dyld_h=${ac_cv_header_mach_o_dyld_h=no}
 ac_cv_header_malloc_h=${ac_cv_header_malloc_h=yes}
 ac_cv_header_memory_h=${ac_cv_header_memory_h=yes}
 ac_cv_header_net_errno_h=${ac_cv_header_net_errno_h=no}
diff --git a/erts/configure.in b/erts/configure.in
index 2ae9c63215..bea1e14859 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -1477,7 +1477,7 @@ AC_CHECK_HEADERS(fcntl.h limits.h unistd.h syslog.h dlfcn.h ieeefp.h \
                  sys/types.h sys/stropts.h sys/sysctl.h \
                  sys/ioctl.h sys/time.h sys/uio.h \
                  sys/socket.h sys/sockio.h sys/socketio.h \
-                 net/errno.h malloc.h mach-o/dyld.h arpa/nameser.h \
+                 net/errno.h malloc.h arpa/nameser.h \
 		 pty.h util.h utmp.h langinfo.h poll.h sdkddkver.h)
 
 AC_CHECK_HEADER(sys/resource.h,
-- 
cgit v1.2.3


From 293e2c2fa1c0cca21c941fd15033d3251dfa0711 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 7 Sep 2011 10:38:39 +0200
Subject: erts/configure.in: Remove broken support for System V

If we are compiling on System V, the symbols NO_WEAK_PRAGMA and
SOCKOPT_CONNECT_STAT are defined, but they are never used.
---
 erts/configure.in                       | 10 ----------
 erts/emulator/drivers/common/inet_drv.c |  4 ++--
 2 files changed, 2 insertions(+), 12 deletions(-)

(limited to 'erts')

diff --git a/erts/configure.in b/erts/configure.in
index bea1e14859..77ea7a2471 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -907,16 +907,6 @@ fi
 
 AC_SUBST(ERLANG_OSTYPE)
 
-dnl Which sysv4 would this be, and what is it for???
-dnl XXX: replace with feature tests.
-case $host_os in
-  sysv4*)
-    AC_DEFINE(SOCKOPT_CONNECT_STAT,[],[Obscure SYSV feature])
-    AC_DEFINE(NO_PRAGMA_WEAK,[],[Obscure SYSV feature])
-    LIBS="$LIBS -lgen -lc -L /usr/ucblib -lucb"
-    ;;
-esac
-
 # Check how to export functions from the emulator executable, needed
 # when dynamically loaded drivers are loaded (so that they can find
 # emulator functions).
diff --git a/erts/emulator/drivers/common/inet_drv.c b/erts/emulator/drivers/common/inet_drv.c
index ebc4469a23..df1f19c482 100644
--- a/erts/emulator/drivers/common/inet_drv.c
+++ b/erts/emulator/drivers/common/inet_drv.c
@@ -9308,7 +9308,7 @@ static int tcp_inet_output(tcp_descriptor* desc, HANDLE event)
 		goto done;
 	    }
 	}
-#endif /* SOCKOPT_CONNECT_STAT */
+#endif /* SO_ERROR */
 #endif /* !__WIN32__ */
 
 	desc->inet.state = TCP_STATE_CONNECTED;
@@ -10113,7 +10113,7 @@ static int packet_inet_output(udp_descriptor* udesc, HANDLE event)
 		goto done;
 	    }
 	}
-#endif /* SOCKOPT_CONNECT_STAT */
+#endif /* SO_ERROR */
 #endif /* !__WIN32__ */
 
 	desc->state = PACKET_STATE_CONNECTED;
-- 
cgit v1.2.3


From c250fb907317bffbc17f7c3d962fa083d124f444 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 7 Sep 2011 11:04:21 +0200
Subject: erts/configure.in: Remove test for reversed setvbuf() arguments

The test is not needed, because no code tests whether SETVBUF_REVERSED
is defined.

Furthermore, AC_FUNC_SETVBUF_REVERSED is now documented like this:

Do nothing. Formerly, this macro checked whether setvbuf takes the
buffering type as its second argument and the buffer pointer as the
third, instead of the other way around, and defined
SETVBUF_REVERSED. However, the last systems to have the problem were
those based on SVR2, which became obsolete in 1987, and the macro is
no longer needed.
---
 erts/autoconf/win32.config.cache.static | 1 -
 erts/configure.in                       | 5 -----
 2 files changed, 6 deletions(-)

(limited to 'erts')

diff --git a/erts/autoconf/win32.config.cache.static b/erts/autoconf/win32.config.cache.static
index bbfe66ffdf..b387db2b22 100755
--- a/erts/autoconf/win32.config.cache.static
+++ b/erts/autoconf/win32.config.cache.static
@@ -96,7 +96,6 @@ ac_cv_func_sbrk=${ac_cv_func_sbrk=no}
 ac_cv_func_select=${ac_cv_func_select=no}
 ac_cv_func_setlocale=${ac_cv_func_setlocale=yes}
 ac_cv_func_setsid=${ac_cv_func_setsid=no}
-ac_cv_func_setvbuf_reversed=${ac_cv_func_setvbuf_reversed=yes}
 ac_cv_func_socket=${ac_cv_func_socket=no}
 ac_cv_func_strchr=${ac_cv_func_strchr=yes}
 ac_cv_func_strerror=${ac_cv_func_strerror=yes}
diff --git a/erts/configure.in b/erts/configure.in
index 77ea7a2471..4cb573b061 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -1792,11 +1792,6 @@ AC_CHECK_FUNCS([ieee_handler fpsetmask finite isnan isinf res_gethostbyname dlop
 
 AC_CHECK_DECLS([posix2time],,,[#include <time.h>])
 
-if test "X$host" = "Xwin32"; then
-	ac_cv_func_setvbuf_reversed=yes
-fi
-AC_FUNC_SETVBUF_REVERSED	
-
 disable_vfork=false
 if test "x$EMU_THR_LIB_NAME" != "x"; then
 	AC_MSG_CHECKING([if vfork is known to hang multithreaded applications])
-- 
cgit v1.2.3


From 5dcee558b61f0f5dd70e18a530a2bb97c479aab5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Sun, 4 Sep 2011 07:58:30 +0200
Subject: Pre-build the tuples returned by os:type/0 and os:version/0

Pre-building the tuples returned by os:type/0 (system_info(os_type))
and os:version() (system_info(os_version)) saves some run-time and
avoids building garbage in the calling process.
---
 erts/emulator/beam/erl_bif_info.c | 48 +++++++++++++++++++++++----------------
 1 file changed, 28 insertions(+), 20 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index e17325b64f..de5e4046fa 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -119,6 +119,10 @@ static char erts_system_version[] = ("Erlang " ERLANG_OTP_RELEASE
 # define PERFMON_GETPCR			_IOR('P', 2, unsigned long long)
 #endif
 
+/* Cached, pre-built {OsType,OsFlavor} and {Major,Minor,Build} tuples */
+static Eterm os_type_tuple;
+static Eterm os_version_tuple;
+
 static Eterm
 current_function(Process* p, Process* rp, Eterm** hpp, int full_info);
 static Eterm current_stacktrace(Process* p, Process* rp, Eterm** hpp);
@@ -2227,16 +2231,7 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
 	return erts_instr_get_type_info(BIF_P);
     }
     else if (BIF_ARG_1 == am_os_type) {
-       Eterm type = am_atom_put(os_type, strlen(os_type));
-       Eterm flav, tup;
-       char *buf = erts_alloc(ERTS_ALC_T_TMP, 1024); /* More than enough */
-
-       os_flavor(buf, 1024);
-       flav = am_atom_put(buf, strlen(buf));
-       hp = HAlloc(BIF_P, 3);
-       tup = TUPLE2(hp, type, flav);
-       erts_free(ERTS_ALC_T_TMP, (void *) buf);
-       BIF_RET(tup);
+	BIF_RET(os_type_tuple);
     }
     else if (BIF_ARG_1 == am_allocator) {
 	BIF_RET(erts_allocator_options((void *) BIF_P));
@@ -2262,16 +2257,7 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
         BIF_RET(am_false);
     }
     else if (BIF_ARG_1 == am_os_version) {
-       int major, minor, build;
-       Eterm tup;
-
-       os_version(&major, &minor, &build);
-       hp = HAlloc(BIF_P, 4);
-       tup = TUPLE3(hp,
-		    make_small(major),
-		    make_small(minor),
-		    make_small(build));
-       BIF_RET(tup);
+	BIF_RET(os_version_tuple);
     }
     else if (BIF_ARG_1 == am_version) {
 	int n = strlen(ERLANG_VERSION);
@@ -4107,6 +4093,27 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
     BIF_ERROR(BIF_P, BADARG);
 }
 
+static void os_info_init(void)
+{
+    Eterm type = am_atom_put(os_type, strlen(os_type));
+    Eterm flav;
+    int major, minor, build;
+    char* buf = erts_alloc(ERTS_ALC_T_TMP, 1024); /* More than enough */
+    Eterm* hp;
+
+    os_flavor(buf, 1024);
+    flav = am_atom_put(buf, strlen(buf));
+    erts_free(ERTS_ALC_T_TMP, (void *) buf);
+    hp = erts_alloc(ERTS_ALC_T_LL_TEMP_TERM, (3+4)*sizeof(Eterm));
+    os_type_tuple = TUPLE2(hp, type, flav);
+    hp += 3;
+    os_version(&major, &minor, &build);
+    os_version_tuple = TUPLE3(hp,
+			      make_small(major),
+			      make_small(minor),
+			      make_small(build));
+}
+
 void
 erts_bif_info_init(void)
 {
@@ -4114,4 +4121,5 @@ erts_bif_info_init(void)
     erts_smp_atomic_init_nob(&hipe_test_reschedule_flag, 0);
 
     process_info_init();
+    os_info_init();
 }
-- 
cgit v1.2.3


From 8f4523c56f243aa4fc4ff4415f89dd1924e49d62 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Sun, 4 Sep 2011 08:10:52 +0200
Subject: sys.c for Unix: Undo caching of utsname in os_flavor()

Since his function will be called only once, caching is a waste of
memory.
---
 erts/emulator/sys/unix/sys.c | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 82d2c64d81..d7f8ac60a9 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -931,18 +931,13 @@ void
 os_flavor(char* namebuf, 	/* Where to return the name. */
 	  unsigned size) 	/* Size of name buffer. */
 {
-    static int called = 0;
-    static struct utsname uts;	/* Information about the system. */
-
-    if (!called) {
-	char* s;
+    struct utsname uts;		/* Information about the system. */
+    char* s;
 
-	(void) uname(&uts);
-	called = 1;
-	for (s = uts.sysname; *s; s++) {
-	    if (isupper((int) *s)) {
-		*s = tolower((int) *s);
-	    }
+    (void) uname(&uts);
+    for (s = uts.sysname; *s; s++) {
+	if (isupper((int) *s)) {
+	    *s = tolower((int) *s);
 	}
     }
     strcpy(namebuf, uts.sysname);
-- 
cgit v1.2.3


From 802dd95ab279c3d9b56d5beae6519b1cfd16f325 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Mon, 13 Jun 2011 14:23:09 +0200
Subject: Remove optimization of 'move R R'

Ancient versions of BEAM compiler could generate move instruction with
the same source and destination registers, so the loader would optimize
away such instructions.
---
 erts/emulator/beam/ops.tab | 2 --
 1 file changed, 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index 538f0b94af..1dba2128f4 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -310,8 +310,6 @@ raise s s
 badarg j
 system_limit j
 
-move R R =>
-
 move C=cxy r | jump Lbl => move_jump Lbl C
 
 %macro: move_jump MoveJump -nonext
-- 
cgit v1.2.3


From 5a037222bcf42cab8bb3887c716b618e0d5c39e3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 15 Jun 2011 08:26:21 +0200
Subject: Remove the special instructions for the hybrid heap emulator

The hybrid-heap emulator is broken since R12, so there is no
need to keep those instructions.
---
 erts/emulator/beam/beam_emu.c | 86 -------------------------------------------
 erts/emulator/beam/ops.tab    | 20 ----------
 2 files changed, 106 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 4b5b5cbdaa..eec9ecb410 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -4862,92 +4862,6 @@ void process_main(void)
      Goto(*I);
  }
 
- /*
-  * Instructions for allocating on the message area.
-  */
-
- OpCase(i_global_cons):
- {
-     BeamInstr *next;
-#ifdef HYBRID
-     Eterm *hp;
-
-     PreFetch(0,next);
-     TestGlobalHeap(2,2,hp);
-     hp[0] = r(0);
-     hp[1] = x(1);
-     r(0) = make_list(hp);
-#ifndef INCREMENTAL
-     global_htop += 2;
-#endif
-     NextPF(0,next);
-#else
-     PreFetch(0,next);
-     c_p->freason = EXC_INTERNAL_ERROR;
-     goto find_func_info;
-#endif
- }
-
- OpCase(i_global_tuple):
- {
-     BeamInstr *next;
-     int len;
-#ifdef HYBRID
-     Eterm list;
-     Eterm *hp;
-#endif
-
-     if ((len = list_length(r(0))) < 0) {
-         goto badarg;
-     }
-
-     PreFetch(0,next);
-#ifdef HYBRID
-     TestGlobalHeap(len + 1,1,hp);
-     list = r(0);
-     r(0) = make_tuple(hp);
-     *hp++ = make_arityval(len);
-     while(is_list(list))
-     {
-         Eterm* cons = list_val(list);
-         *hp++ = CAR(cons);
-         list = CDR(cons);
-     }
-#ifndef INCREMENTAL
-     global_htop += len + 1;
-#endif
-     NextPF(0,next);
-#else
-     c_p->freason = EXC_INTERNAL_ERROR;
-     goto find_func_info;
-#endif
- }
-
- OpCase(i_global_copy):
- {
-     BeamInstr *next;
-     PreFetch(0,next);
-#ifdef HYBRID
-     if (!IS_CONST(r(0)))
-     {
-         BM_SWAP_TIMER(system,copy);
-         SWAPOUT;
-         reg[0] = r(0);
-         reg[1] = NIL;
-         r(0) = copy_struct_lazy(c_p,r(0),0);
-         ASSERT(ma_src_top == 0);
-         ASSERT(ma_dst_top == 0);
-         ASSERT(ma_offset_top == 0);
-         SWAPIN;
-         BM_SWAP_TIMER(copy,system);
-     }
-     NextPF(0,next);
-#else
-     c_p->freason = EXC_INTERNAL_ERROR;
-     goto find_func_info;
-#endif
- }
-
  /*
   * New floating point instructions.
   */
diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index 1dba2128f4..b2f82a5df1 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -88,9 +88,6 @@ i_time_breakpoint
 i_return_time_trace
 i_return_to_trace
 i_yield
-i_global_cons
-i_global_tuple
-i_global_copy
 
 return
 
@@ -905,23 +902,6 @@ call_ext u==3 u$func:erlang:hibernate/3 => i_hibernate
 call_ext_last u==3 u$func:erlang:hibernate/3 D => i_hibernate
 call_ext_only u==3 u$func:erlang:hibernate/3 => i_hibernate
 
-#
-# Hybrid memory architecture need special cons and tuple instructions
-# that allocate on the message area. These looks like BIFs in the BEAM code.
-#
-
-call_ext u==2 u$func:hybrid:cons/2 => i_global_cons
-call_ext_last u==2 u$func:hybrid:cons/2 D => i_global_cons | deallocate_return D
-call_ext_only Ar=u==2 u$func:hybrid:cons/2 => i_global_cons | return
-
-call_ext u==1 u$func:hybrid:tuple/1 => i_global_tuple
-call_ext_last u==1 u$func:hybrid:tuple/1 D => i_global_tuple | deallocate_return D
-call_ext_only Ar=u==1 u$func:hybrid:tuple/1 => i_global_tuple | return
-
-call_ext u==1 u$func:hybrid:copy/1 => i_global_copy
-call_ext_last u==1 u$func:hybrid:copy/1 D => i_global_copy | deallocate_return D
-call_ext_only u==1 Ar=u$func:hybrid:copy/1 => i_global_copy | return
-
 #
 # The general case for BIFs that have no special instructions.
 # A BIF used in the tail must be followed by a return instruction.
-- 
cgit v1.2.3


From 8f52f4b5d92197de19dd5df29513a9dcb5437280 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 11 Aug 2011 11:19:29 +0200
Subject: Remove too_old_compiler handling for very old instruction variants

is_list/2 and other test instructions with a zero label was last
generated by the v1 BEAM compiler which was last supported in R6B.

Since BEAM modules produced by that compiler will be rejected with
a nice error message for other reasons (e.g. by the test for the
module_info/0,1 functions), retaining those transformations serves
no useful purpose.
---
 erts/emulator/beam/ops.tab | 24 +++---------------------
 1 file changed, 3 insertions(+), 21 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index b2f82a5df1..dcfd9063d9 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -25,31 +25,13 @@
 # instruction transformations; thus, they never occur in BEAM files.
 #
 
-# Special instruction used to generate an error message when
-# trying to load a module compiled by the V1 compiler (R5 & R6).
-# (Specially treated in beam_load.c.)
+# The too_old_compiler/0 instruction is specially handled in beam_load.c
+# to produce a user-friendly message informing the user that the module
+# needs to be re-compiled with a modern compiler.
 
 too_old_compiler/0
 too_old_compiler
 
-#
-# Obsolete instruction usage follow. (Nowdays we use f with
-# a zero label instead of p.)
-#
-
-is_list p S => too_old_compiler
-is_nonempty_list p R => too_old_compiler
-is_nil p R => too_old_compiler
-
-is_tuple p S => too_old_compiler
-test_arity p S Arity => too_old_compiler
-
-is_integer p R => too_old_compiler
-is_float p R => too_old_compiler
-is_atom p R => too_old_compiler
-
-is_eq_exact p S1 S2 => too_old_compiler
-
 # In R9C and earlier, the loader used to insert special instructions inside
 # the module_info/0,1 functions. (In R10B and later, the compiler inserts
 # an explicit call to an undocumented BIF, so that no loader trickery is
-- 
cgit v1.2.3


From 3b3bb767433a333750b090908fa370d957bbbfa2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Mon, 13 Jun 2011 14:38:52 +0200
Subject: Generalize and rename is_set_var_instr() to is_instr()

It is more useful to have a helper function that can test for
any instruction.
---
 erts/emulator/utils/beam_makeops | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index ebf7db3277..75047f22bd 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1437,7 +1437,7 @@ sub tr_gen_from {
 		    push(@code, &make_op($var, 'set_var', $var{$var}));
 		}
 	    }
-	    if (is_set_var_instr($code[$#code])) {
+	    if (is_instr($code[$#code], 'set_var')) {
 		my $ref = pop @code;
 		my $comment = $ref->[2];
 		my $var = $ref->[1][1];
@@ -1560,7 +1560,7 @@ sub tr_gen_to {
 	    }
 	    push(@code, &make_op('', 'next_arg'));
 	}
-	pop(@code) if $code[$#code]->[1][0] eq 'next_arg';
+	pop(@code) if is_instr($code[$#code], 'next_arg');
     }
 
     push(@code, &make_op('', 'end'));
@@ -1597,10 +1597,10 @@ sub make_op {
     [scalar(@op), [@op], $comment];
 }
 
-sub is_set_var_instr {
-    my($ref) = @_;
+sub is_instr {
+    my($ref,$op) = @_;
     return 0 unless ref($ref) eq 'ARRAY';
-    $ref->[1][0] eq 'set_var';
+    $ref->[1][0] eq $op;
 }
 
 sub tr_gen_call {
-- 
cgit v1.2.3


From ce653bf162c96e1da12b8a11688aa15ddf7d1a02 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Mon, 13 Jun 2011 14:53:31 +0200
Subject: Remove redundant 'next_arg' before 'next_instr'

Fix the incorrect code that attempted to remove a single
'next_arg' instructions before 'next_instr'.
---
 erts/emulator/utils/beam_makeops | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index 75047f22bd..b5187dd676 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1446,8 +1446,9 @@ sub tr_gen_from {
 		push(@code, &make_op('', 'next_arg'));
 	    }
 	}
+	# Remove redundant 'next_arg' instructions before 'next_instr'.
+	pop(@code) while is_instr($code[$#code], 'next_arg');
 	push(@code, &make_op('', 'next_instr'));
-	pop(@code) if $code[$#code]->[1][0] eq 'next_arg';
     }
 
     #
-- 
cgit v1.2.3


From 929c67fdaca5de8ea9ac3c602acbbaccd074a492 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Mon, 13 Jun 2011 14:19:48 +0200
Subject: In transformations, don't store variables that are never used

This optimization will save some space (in the loader tables) and
some loading time.
---
 erts/emulator/utils/beam_makeops | 57 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 53 insertions(+), 4 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index b5187dd676..f1fa71fd9e 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1304,7 +1304,8 @@ sub tr_gen {
 
     foreach $ref (@g) {
 	my($line, $orig_transform, $from_ref, $to_ref) = @$ref;
-	my $so_far = tr_gen_from($line, @$from_ref);
+	my $used_ref = used_vars($from_ref, $to_ref);
+	my $so_far = tr_gen_from($line, $used_ref, @$from_ref);
 	tr_gen_to($line, $orig_transform, $so_far, @$to_ref);
     }
 
@@ -1342,8 +1343,48 @@ sub tr_gen {
     print "};\n\n";
 }
 
+sub used_vars {
+    my($from_ref,$to_ref) = @_;
+    my %used;
+    my %seen;
+
+    foreach my $ref (@$from_ref) {
+	my($name,$arity,@ops) = @$ref;
+	if ($name =~ /^[.]/) {
+	    foreach my $var (@ops) {
+		$used{$var} = 1;
+	    }
+	} else {
+	    # Any variable that is used at least twice on the
+	    # left-hand side is used. (E.g. "move R R".)
+	    foreach my $op (@ops) {
+		my($var, $type, $type_val) = @$op;
+		next if $var eq '';
+		$used{$var} = 1 if $seen{$var};
+		$seen{$var} = 1;
+	    }
+	}
+    }
+
+    foreach my $ref (@$to_ref) {
+	my($name, $arity, @ops) = @$ref;
+	if ($name =~ /^[.]/) {
+	    foreach my $var (@ops) {
+		$used{$var} = 1;
+	    }
+	} else {
+	    foreach my $op (@ops) {
+		my($var, $type, $type_val) = @$op;
+		next if $var eq '';
+		$used{$var} = 1;
+	    }
+	}
+    }
+    \%used;
+}
+
 sub tr_gen_from {
-    my($line, @tr) = @_;
+    my($line,$used_ref,@tr) = @_;
     my(%var) = ();
     my(%var_type);
     my($var_num) = 0;
@@ -1353,6 +1394,7 @@ sub tr_gen_from {
     my(@fix_pred_funcs);
     my($op, $ref);		# Loop variables.
     my $where = "left side of transformation in line $line: ";
+    my %var_used = %$used_ref;
 
     foreach $ref (@tr) {
 	my($name, $arity, @ops) = @$ref;
@@ -1387,6 +1429,7 @@ sub tr_gen_from {
 	$min_window++;
 	foreach $op (@ops) {
 	    my($var, $type, $type_val, $cond, $val) = @$op;
+	    my $ignored_var = "$var (ignored)";
 
 	    if ($type ne '' && $type ne '*') {
 		#
@@ -1394,6 +1437,7 @@ sub tr_gen_from {
 		# their own built-in type test and don't need to
 		# be guarded with a type test instruction.
 		#
+		$ignored_var = '';
 		unless ($cond eq 'is_bif' or
 			$cond eq 'is_not_bif' or
 			$cond eq 'is_func') {
@@ -1415,22 +1459,27 @@ sub tr_gen_from {
 
 	    if ($cond eq 'is_func') {
 		my($m, $f, $a) = split(/:/, $val);
+		$ignored_var = '';
 		push(@code, &make_op('', "$cond", "am_$m",
 				     "am_$f", $a));
 	    } elsif ($cond ne '') {
+		$ignored_var = '';
 		push(@code, &make_op('', "$cond", $val));
 	    }
 
 	    if ($var ne '') {
 		if (defined $var{$var}) {
+		    $ignored_var = '';
 		    push(@code, &make_op($var, 'is_same_var', $var{$var}));
 		} elsif ($type eq '*') {
 		    #
 		    # Reserve a hole for a 'rest_args' instruction.
 		    #
+		    $ignored_var = '';
 		    push(@fix_rest_args, scalar(@code));
 		    push(@code, $var);
-		} else {
+		} elsif ($var_used{$var}) {
+		    $ignored_var = '';
 		    $var_type{$var} = 'scalar';
 		    $var{$var} = $var_num;
 		    $var_num++;
@@ -1443,7 +1492,7 @@ sub tr_gen_from {
 		my $var = $ref->[1][1];
 		push(@code, make_op($comment, 'set_var_next_arg', $var));
 	    } else {
-		push(@code, &make_op('', 'next_arg'));
+		push(@code, &make_op($ignored_var, 'next_arg'));
 	    }
 	}
 	# Remove redundant 'next_arg' instructions before 'next_instr'.
-- 
cgit v1.2.3


From eea824979a7e8dfd760b943b1790663849862342 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Mon, 13 Jun 2011 16:14:48 +0200
Subject: Add some more information in instruction comments

---
 erts/emulator/utils/beam_makeops | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index f1fa71fd9e..ec3d6c067d 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1451,7 +1451,7 @@ sub tr_gen_from {
 			push(@code, &make_op($types, 'is_type', $type_mask));
 		    } else {
 			$cond = '';
-			push(@code, &make_op($types, 'is_type_eq',
+			push(@code, &make_op("$types== $val", 'is_type_eq',
 					     $type_mask, $val));
 		    }
 		}
@@ -1629,7 +1629,8 @@ sub tr_gen_to {
 	if defined @{$gen_transform{$key}}; # Fail
     my(@prefix) = (&make_op($comment), &make_op('', 'try_me_else', &tr_code_len(@code)));
     unshift(@code, @prefix);
-    push(@{$gen_transform{$key}}, @code, &make_op('', 'fail'));
+    push(@{$gen_transform{$key}},
+	 @code,	 make_op(""), make_op("$key", 'fail'));
 }
 
 sub tr_code_len {
-- 
cgit v1.2.3


From fe32a91def97823b036ccad946b84853688b41af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Mon, 13 Jun 2011 17:43:59 +0200
Subject: Get rid of redundant 'try_me_else' and 'fail' instructions

If the left part of a transformation will always match, omit the
the 'try_me_else' and 'fail' instructions.

As part of this optimization, make it an error to have a
transformation that can never be reached because of a previous
transformation that will always match. (Remove one transformation
from ops.tab that was found to be unreachable.)
---
 erts/emulator/beam/beam_load.c   |  1 -
 erts/emulator/beam/ops.tab       |  2 --
 erts/emulator/utils/beam_makeops | 43 ++++++++++++++++++++++++++++++++++------
 3 files changed, 37 insertions(+), 9 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 16dd5795c7..4da411be1f 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -4238,7 +4238,6 @@ transform_engine(LoaderState* st)
     ASSERT(restart != NULL);
     pc = restart;
     ASSERT(*pc < NUM_TOPS);	/* Valid instruction? */
-    ASSERT(*pc == TOP_try_me_else || *pc == TOP_fail);
     instr = st->genop;
 
 #define RETURN(r) rval = (r); goto do_return;
diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index dcfd9063d9..08d2e35fbb 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -595,8 +595,6 @@ get_tuple_element Reg P Dst => i_get_tuple_element Reg P Dst | original_reg Reg
 
 original_reg Reg Pos =>
 
-get_tuple_element Reg P Dst => i_get_tuple_element Reg P Dst
-
 original_reg/2
 
 extract_next_element D1=xy | original_reg Reg P1 | get_tuple_element Reg P2 D2=xy | \
diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index ec3d6c067d..7b66496856 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1395,18 +1395,24 @@ sub tr_gen_from {
     my($op, $ref);		# Loop variables.
     my $where = "left side of transformation in line $line: ";
     my %var_used = %$used_ref;
+    my $may_fail = 0;
+    my $is_first = 1;
 
     foreach $ref (@tr) {
 	my($name, $arity, @ops) = @$ref;
 	my($key) = "$name/$arity";
 	my($opnum);
 
+	$may_fail = 1 unless $is_first;
+	$is_first = 0;
+
 	#
 	# A name starting with a period is a C pred function to be called.
 	#
 
 	if ($name =~ /^\.(\w+)/) {
 	    $name = $1;
+	    $may_fail = 1;
 	    my $var;
 	    my(@args);
 
@@ -1432,6 +1438,8 @@ sub tr_gen_from {
 	    my $ignored_var = "$var (ignored)";
 
 	    if ($type ne '' && $type ne '*') {
+		$may_fail = 1;
+
 		#
 		# The is_bif, is_not_bif, and is_func instructions have
 		# their own built-in type test and don't need to
@@ -1460,16 +1468,19 @@ sub tr_gen_from {
 	    if ($cond eq 'is_func') {
 		my($m, $f, $a) = split(/:/, $val);
 		$ignored_var = '';
+		$may_fail = 1;
 		push(@code, &make_op('', "$cond", "am_$m",
 				     "am_$f", $a));
 	    } elsif ($cond ne '') {
 		$ignored_var = '';
+		$may_fail = 1;
 		push(@code, &make_op('', "$cond", $val));
 	    }
 
 	    if ($var ne '') {
 		if (defined $var{$var}) {
 		    $ignored_var = '';
+		    $may_fail = 1;
 		    push(@code, &make_op($var, 'is_same_var', $var{$var}));
 		} elsif ($type eq '*') {
 		    #
@@ -1504,7 +1515,8 @@ sub tr_gen_from {
     # Insert the commit operation.
     #
     pop(@code);		# Get rid of 'next_instr'
-    push(@code, &make_op('', 'commit'));
+
+    push(@code, make_op($may_fail ? '' : 'always reached', 'commit'));
 
     #
     # If there is an rest_args instruction, we must insert its correct
@@ -1553,6 +1565,10 @@ sub tr_gen_to {
     my($op, $ref);		# Loop variables.
     my($where) = "right side of transformation in line $line: ";
 
+    my $last_instr = $code[$#code];
+    my $cannot_fail = is_instr($last_instr, 'commit') &&
+	(get_comment($last_instr) =~ /^always/);
+
     foreach $ref (@tr) {
 	my($name, $arity, @ops) = @$ref;
 
@@ -1625,12 +1641,20 @@ sub tr_gen_to {
     $min_window{$key} = $min_window
 	if $min_window{$key} > $min_window;
 
-    pop(@{$gen_transform{$key}})
+    my $prev_last;
+    $prev_last = pop(@{$gen_transform{$key}})
 	if defined @{$gen_transform{$key}}; # Fail
-    my(@prefix) = (&make_op($comment), &make_op('', 'try_me_else', &tr_code_len(@code)));
-    unshift(@code, @prefix);
-    push(@{$gen_transform{$key}},
-	 @code,	 make_op(""), make_op("$key", 'fail'));
+
+    if ($prev_last && !is_instr($prev_last, 'fail')) {
+	error("Line $line: A previous transformation shadows '$orig_transform'");
+    }
+    unless ($cannot_fail) {
+	unshift(@code, make_op('', 'try_me_else',
+			       tr_code_len(@code)));
+	push(@code, make_op(""), make_op("$key", 'fail'));
+    }
+    unshift(@code, make_op($comment));
+    push(@{$gen_transform{$key}}, @code),
 }
 
 sub tr_code_len {
@@ -1654,6 +1678,13 @@ sub is_instr {
     $ref->[1][0] eq $op;
 }
 
+sub get_comment {
+    my($ref,$op) = @_;
+    return '' unless ref($ref) eq 'ARRAY';
+    $ref->[2];
+}
+
+
 sub tr_gen_call {
     my(@call_table) = @_;
     my($i);
-- 
cgit v1.2.3


From 5bd8f04a8a4b5c7a3f859355dd47dab27c6fa494 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 15 Jun 2011 07:29:52 +0200
Subject: Remove some unnecessary type constraints in transformations

We don't need type constraints that essentially are assertions;
the wrong type will be detected and loading aborted when no specific
instruction can be found.
---
 erts/emulator/beam/ops.tab | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index 08d2e35fbb..fc98c399c1 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -919,9 +919,9 @@ move S=c r | call_ext Ar=u Func=u$is_not_bif => i_move_call_ext S r Func
 move S=c r | call_ext_last Ar=u Func=u$is_not_bif D => i_move_call_ext_last Func D S r
 move S=c r | call_ext_only Ar=u Func=u$is_not_bif => i_move_call_ext_only Func S r 
 
-call_ext Ar=u Func        => i_call_ext Func
-call_ext_last Ar=u Func D => i_call_ext_last Func D
-call_ext_only Ar=u Func   => i_call_ext_only Func
+call_ext Ar Func        => i_call_ext Func
+call_ext_last Ar Func D => i_call_ext_last Func D
+call_ext_only Ar Func   => i_call_ext_only Func
 
 i_apply
 i_apply_last P
@@ -955,7 +955,7 @@ bif1 p Bif S1 Dst => bif1_body Bif S1 Dst
 bif1_body Bif Literal=q Dst => move Literal x | bif1_body Bif x Dst
 
 bif2 p Bif S1 S2 Dst => i_fetch S1 S2 | i_bif2_body Bif Dst
-bif2 Fail=f Bif S1 S2 Dst => i_fetch S1 S2 | i_bif2 Fail Bif Dst
+bif2 Fail Bif S1 S2 Dst => i_fetch S1 S2 | i_bif2 Fail Bif Dst
 
 i_get s d
 
@@ -1038,8 +1038,8 @@ i_move_call_ext_only e c r
 
 # Fun calls.
 
-call_fun Arity=u | deallocate D | return => i_call_fun_last Arity D
-call_fun Arity=u => i_call_fun Arity
+call_fun Arity | deallocate D | return => i_call_fun_last Arity D
+call_fun Arity => i_call_fun Arity
 
 i_call_fun I
 i_call_fun_last I P
@@ -1295,13 +1295,13 @@ i_bs_utf16_size s d
 
 bs_put_utf8 Fail=j Flags=u Literal=q => \
 	move Literal x | bs_put_utf8 Fail Flags x
-bs_put_utf8 Fail=j u Src=s => i_bs_put_utf8 Fail Src
+bs_put_utf8 Fail u Src=s => i_bs_put_utf8 Fail Src
 
 i_bs_put_utf8 j s
 
 bs_put_utf16 Fail=j Flags=u Literal=q => \
 	move Literal x | bs_put_utf16 Fail Flags x
-bs_put_utf16 Fail=j Flags=u Src=s => i_bs_put_utf16 Fail Flags Src
+bs_put_utf16 Fail Flags=u Src=s => i_bs_put_utf16 Fail Flags Src
 
 i_bs_put_utf16 j I s
 
-- 
cgit v1.2.3


From 207436c383995dc6fcea1953f9188f8df280bd81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 15 Jun 2011 08:03:25 +0200
Subject: Combine a 'call' instruction with the following 'end' instruction

A 'call' instruction in the loader transformation language is
always followed by an 'end' instruction, so we can replace the
'call' instruction with a 'call_end' instruction.
---
 erts/emulator/beam/beam_load.c   | 6 +++---
 erts/emulator/utils/beam_makeops | 5 +++--
 2 files changed, 6 insertions(+), 5 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 4da411be1f..0d639572e0 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -4458,8 +4458,8 @@ transform_engine(LoaderState* st)
 #endif
 	    break;
 
-#if defined(TOP_call)
-	case TOP_call:
+#if defined(TOP_call_end)
+	case TOP_call_end:
 	    {
 		GenOp** lastp;
 		GenOp* new_instr;
@@ -4496,7 +4496,7 @@ transform_engine(LoaderState* st)
 		*lastp = st->genop;
 		st->genop = new_instr;
 	    }
-	    break;
+	    RETURN(TE_OK);
 #endif
 	case TOP_new_instr:
 	    /*
diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index 7b66496856..2272a941bb 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1591,7 +1591,7 @@ sub tr_gen_to {
 		}
 	    }
 	    pop(@code);	# Get rid of 'next_instr'
-	    push(@code, &make_op("$name()", 'call', scalar(@call_table)));
+	    push(@code, make_op("$name()", 'call_end', scalar(@call_table)));
 	    push(@call_table, [$name, @args]);
 	    last;
 	}
@@ -1629,7 +1629,8 @@ sub tr_gen_to {
 	pop(@code) if is_instr($code[$#code], 'next_arg');
     }
 
-    push(@code, &make_op('', 'end'));
+    push(@code, make_op('', 'end'))
+	unless is_instr($code[$#code], 'call_end');
 
     #
     # Chain together all codes segments having the same first operation.
-- 
cgit v1.2.3


From cac63dbe2da001e050be70664cb6421cdea33430 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 5 Aug 2011 14:49:34 +0200
Subject: Merge 'new_instr' and 'store_op' into 'new_instr'

Since the 'new_instr' instruction always occurs before the
'store_op' instruction, we can merge the instructions into one.
Also, there is no need to include the arity of the BEAM
instruction as an operand, since the arity can be looked up
based on the opcode.
---
 erts/emulator/beam/beam_load.c   | 6 ++----
 erts/emulator/utils/beam_makeops | 5 ++---
 2 files changed, 4 insertions(+), 7 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 0d639572e0..551bc399e7 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -4505,12 +4505,10 @@ transform_engine(LoaderState* st)
 	    NEW_GENOP(st, instr);
 	    instr->next = st->genop;
 	    st->genop = instr;
+	    instr->op = op = *pc++;
+	    instr->arity = gen_opc[op].arity;
 	    ap = 0;
 	    break;
-	case TOP_store_op:
-	    instr->op = *pc++;
-	    instr->arity = *pc++;
-	    break;
 	case TOP_store_type:
 	    i = *pc++;
 	    instr->a[ap].type = i;
diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index 2272a941bb..d71531a1f1 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1590,7 +1590,7 @@ sub tr_gen_to {
 		    push(@args, "var+$var{$var}");
 		}
 	    }
-	    pop(@code);	# Get rid of 'next_instr'
+	    pop(@code);	# Get rid of 'commit' instruction
 	    push(@code, make_op("$name()", 'call_end', scalar(@call_table)));
 	    push(@call_table, [$name, @args]);
 	    last;
@@ -1609,8 +1609,7 @@ sub tr_gen_to {
 	# Create code to build the generic instruction.
 	#
 
-	push(@code, &make_op('', 'new_instr'));
-	push(@code, &make_op("$name/$arity", 'store_op', $opnum, $arity));
+	push(@code, make_op("$name/$arity", 'new_instr', $opnum));
 	foreach $op (@ops) {
 	    my($var, $type, $type_val) = @$op;
 
-- 
cgit v1.2.3


From 3f8f70e8594ee956dba7edb3602dc9e26e144a69 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 5 Aug 2011 15:15:43 +0200
Subject: Merge 'next_instr' and 'is_op' into 'next_instr'

'next_instr' is always followed by 'is_op'.
---
 erts/emulator/beam/beam_load.c   |  8 +++-----
 erts/emulator/utils/beam_makeops | 11 ++++-------
 2 files changed, 7 insertions(+), 12 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 551bc399e7..e858305e9c 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -4250,7 +4250,9 @@ transform_engine(LoaderState* st)
 	op = *pc++;
 
 	switch (op) {
-	case TOP_is_op:
+	case TOP_next_instr:
+	    instr = instr->next;
+	    ap = 0;
 	    if (instr == NULL) {
 		/*
 		 * We'll need at least one more instruction to decide whether
@@ -4437,10 +4439,6 @@ transform_engine(LoaderState* st)
 	case TOP_next_arg:
 	    ap++;
 	    break;
-	case TOP_next_instr:
-	    instr = instr->next;
-	    ap = 0;
-	    break;
 	case TOP_commit:
 	    instr = instr->next; /* The next_instr was optimized away. */
 
diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index d71531a1f1..5e86356e10 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1416,10 +1416,8 @@ sub tr_gen_from {
 	    my $var;
 	    my(@args);
 
-	    my $next_instr = pop(@code); # Get rid of 'next_instr'
 	    push(@fix_pred_funcs, scalar(@code));
 	    push(@code, [$name, @ops]);
-	    push(@code, $next_instr);
 	    next;
 	}
 
@@ -1431,7 +1429,7 @@ sub tr_gen_from {
 	    unless defined $gen_opnum{$name,$arity};
 	$opnum = $gen_opnum{$name,$arity};
 
-	push(@code, &make_op("$name/$arity", 'is_op', $opnum));
+	push(@code, make_op("$name/$arity", 'next_instr', $opnum));
 	$min_window++;
 	foreach $op (@ops) {
 	    my($var, $type, $type_val, $cond, $val) = @$op;
@@ -1506,16 +1504,15 @@ sub tr_gen_from {
 		push(@code, &make_op($ignored_var, 'next_arg'));
 	    }
 	}
-	# Remove redundant 'next_arg' instructions before 'next_instr'.
+
+	# Remove redundant 'next_arg' instructions before the end
+	# of the instruction.
 	pop(@code) while is_instr($code[$#code], 'next_arg');
-	push(@code, &make_op('', 'next_instr'));
     }
 
     #
     # Insert the commit operation.
     #
-    pop(@code);		# Get rid of 'next_instr'
-
     push(@code, make_op($may_fail ? '' : 'always reached', 'commit'));
 
     #
-- 
cgit v1.2.3


From e87760199eb9d3c02480e92a0bcf76864c750972 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Mon, 8 Aug 2011 09:42:26 +0200
Subject: Combine 'store_var' with 'next_arg'

'store_var' is always followed by 'next_arg'.
---
 erts/emulator/beam/beam_load.c   | 3 ++-
 erts/emulator/utils/beam_makeops | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index e858305e9c..7d2b4dea28 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -4516,11 +4516,12 @@ transform_engine(LoaderState* st)
 	    i = *pc++;
 	    instr->a[ap].val = i;
 	    break;
-	case TOP_store_var:
+	case TOP_store_var_next_arg:
 	    i = *pc++;
 	    ASSERT(i < TE_MAX_VARS);
 	    instr->a[ap].type = var[i].type;
 	    instr->a[ap].val = var[i].val;
+	    ap++;
 	    break;
 	case TOP_try_me_else:
 	    restart = pc + 1;
diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index 5e86356e10..9c7e5e94a5 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1613,14 +1613,14 @@ sub tr_gen_to {
 	    if ($var ne '') {
 		&error($where, "variable '$var' unbound")
 		    unless defined $var{$var};
-		push(@code, &make_op($var, 'store_var', $var{$var}));
+		push(@code, &make_op($var, 'store_var_next_arg', $var{$var}));
 	    } elsif ($type ne '') {
 		push(@code, &make_op('', 'store_type', "TAG_$type"));
 		if ($type_val) {
 		    push(@code, &make_op('', 'store_val', $type_val));
 		}
+		push(@code, make_op('', 'next_arg'));
 	    }
-	    push(@code, &make_op('', 'next_arg'));
 	}
 	pop(@code) if is_instr($code[$#code], 'next_arg');
     }
-- 
cgit v1.2.3


From 2a30746d09f467c13e9361774867462ae4f2bd32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 9 Aug 2011 16:49:39 +0200
Subject: Introduce 'try_me_else_fail'

---
 erts/emulator/beam/beam_load.c   |  6 +++++-
 erts/emulator/utils/beam_makeops | 21 ++++++++++++++++++++-
 2 files changed, 25 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 7d2b4dea28..655b5496a8 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -4225,6 +4225,7 @@ transform_engine(LoaderState* st)
     GenOp* instr;
     Uint* pc;
     int rval;
+    static Uint restart_fail[1] = {TOP_fail};
 
     ASSERT(gen_opc[st->genop->op].transform != -1);
     pc = op_transform + gen_opc[st->genop->op].transform;
@@ -4528,10 +4529,13 @@ transform_engine(LoaderState* st)
 	    restart += *pc++;
 	    ASSERT(*pc < NUM_TOPS); /* Valid instruction? */
 	    break;
+	case TOP_try_me_else_fail:
+	    restart = restart_fail;
+	    break;
 	case TOP_end:
 	    RETURN(TE_OK);
 	case TOP_fail:
-	    RETURN(TE_FAIL)
+	    RETURN(TE_FAIL);
 	default:
 	    ASSERT(0);
 	}
diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index 9c7e5e94a5..367f089401 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -186,6 +186,12 @@ sub define_type_bit {
     define_type_bit('Q', $type_bit{'u'});
 }
 
+#
+# Pre-define the 'fail' instruction. It is used internally
+# by the 'try_me_else_fail' instruction.
+#
+$match_engine_ops{'TOP_fail'} = 1;
+
 #
 # Sanity checks.
 #
@@ -1316,7 +1322,20 @@ sub tr_gen {
     print "Uint op_transform[] = {\n";
     foreach $key (keys %gen_transform) {
 	$gen_transform_offset{$key} = $offset;
-	foreach $instr (@{$gen_transform{$key}}) {
+	my @instr = @{$gen_transform{$key}};
+
+	#
+	# If the last instruction is 'fail', remove it and
+	# convert the previous 'try_me_else' to 'try_me_else_fail'.
+	#
+	if (is_instr($instr[$#instr], 'fail')) {
+	    pop(@instr);
+	    my $i = $#instr;
+	    $i-- while !is_instr($instr[$i], 'try_me_else');
+	    $instr[$i] = make_op('', 'try_me_else_fail');
+	}
+
+	foreach $instr (@instr) {
 	    my($size, $instr_ref, $comment) = @$instr;
 	    my($op, @args) = @$instr_ref;
 	    print "    ";
-- 
cgit v1.2.3


From f2e79b0670d1c56205ae89ac248de53f46d56ee8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 10 Aug 2011 15:14:36 +0200
Subject: Refactor 'too_old_compiler' handling

In the handling of generic instructions, we used to always
test whether the instruction was 'too_old_compiler' and abort
loading with a special error message.

Refactor the code so that we only do test if we an error
has occurred. That will allow us to make the test more expensive
in the future, allowing us to customize error messages for certain
opcode without any cost in the successful case.
---
 erts/emulator/beam/beam_emu.c  |  1 -
 erts/emulator/beam/beam_load.c | 22 +++++++++++++---------
 erts/emulator/beam/ops.tab     |  2 +-
 3 files changed, 14 insertions(+), 11 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index eec9ecb410..5691f7aec1 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -5155,7 +5155,6 @@ void process_main(void)
 
  OpCase(int_code_end):
  OpCase(label_L):
- OpCase(too_old_compiler):
  OpCase(on_load):
  OpCase(line_I):
     erl_exit(1, "meta op\n");
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 655b5496a8..7c32518ba9 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -1886,14 +1886,6 @@ load_code(LoaderState* stp)
 	    goto get_next_instr;
 	}
 
-	/*
-	 * Special error message instruction.
-	 */
-	if (stp->genop->op == genop_too_old_compiler_0) {
-	    LoadError0(stp, "please re-compile this module with an " 
-		       ERLANG_OTP_RELEASE " compiler");
-	}
-
 	/*
 	 * From the collected generic instruction, find the specific
 	 * instruction.
@@ -1945,7 +1937,17 @@ load_code(LoaderState* stp)
 			       ERLANG_OTP_RELEASE " compiler ");
 		}
 
-		LoadError0(stp, "no specific operation found");
+		/*
+		 * Some generic instructions should have a special
+		 * error message.
+		 */
+		switch (stp->genop->op) {
+		case genop_too_old_compiler_0:
+		    LoadError0(stp, "please re-compile this module with an "
+			       ERLANG_OTP_RELEASE " compiler");
+		default:
+		    LoadError0(stp, "no specific operation found");
+		}
 	    }
 
 	    stp->specific_op = specific;
@@ -2409,6 +2411,8 @@ load_code(LoaderState* stp)
 #define no_fpe_signals(St) 0
 #endif
 
+#define never(St) 0
+
 /*
  * Predicate that tests whether a jump table can be used.
  */
diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index fc98c399c1..327c4e8651 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -30,7 +30,7 @@
 # needs to be re-compiled with a modern compiler.
 
 too_old_compiler/0
-too_old_compiler
+too_old_compiler | never() =>
 
 # In R9C and earlier, the loader used to insert special instructions inside
 # the module_info/0,1 functions. (In R10B and later, the compiler inserts
-- 
cgit v1.2.3


From c75c84657c1b65c5df24e3c9316a25cb67803873 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 10 Aug 2011 08:16:07 +0200
Subject: Simplify transformations of gc_bif[123] instructions

Each gc_bif[123] instruction must have both a transformation in
ops.tab and special code in gen_guard_bif[123]().

Rewrite it to do most of the work in gen_guard_bif[123]().
---
 erts/emulator/beam/beam_load.c | 77 ++++++++++++++++++++++++++++++------------
 erts/emulator/beam/ops.tab     | 36 +++++++-------------
 2 files changed, 68 insertions(+), 45 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 7c32518ba9..de4b32b238 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -1945,6 +1945,16 @@ load_code(LoaderState* stp)
 		case genop_too_old_compiler_0:
 		    LoadError0(stp, "please re-compile this module with an "
 			       ERLANG_OTP_RELEASE " compiler");
+		case genop_unsupported_guard_bif_3:
+		    {
+			Eterm Mod = (Eterm) stp->genop->a[0].val;
+			Eterm Name = (Eterm) stp->genop->a[1].val;
+			Uint arity = (Uint) stp->genop->a[2].val;
+			FREE_GENOP(stp, stp->genop);
+			stp->genop = 0;
+			LoadError3(stp, "unsupported guard BIF: %T:%T/%d\n",
+				   Mod, Name, arity);
+		    }
 		default:
 		    LoadError0(stp, "no specific operation found");
 		}
@@ -3668,10 +3678,7 @@ gen_guard_bif1(LoaderState* stp, GenOpArg Fail, GenOpArg Live, GenOpArg Bif,
     BifFunction bf;
 
     NEW_GENOP(stp, op);
-    op->op = genop_i_gc_bif1_5;
-    op->arity = 5;
-    op->a[0] = Fail;
-    op->a[1].type = TAG_u;
+    op->next = NULL;
     bf = stp->import[Bif.val].bf;
     /* The translations here need to have a reverse counterpart in
        beam_emu.c:translate_gc_bif for error handling to work properly. */
@@ -3692,19 +3699,30 @@ gen_guard_bif1(LoaderState* stp, GenOpArg Fail, GenOpArg Live, GenOpArg Bif,
     } else if (bf == trunc_1) {
 	op->a[1].val = (BeamInstr) (void *) erts_gc_trunc_1;
     } else {
-	abort();
+	op->op = genop_unsupported_guard_bif_3;
+	op->arity = 3;
+	op->a[0].type = TAG_a;
+	op->a[0].val = stp->import[Bif.val].module;
+	op->a[1].type = TAG_a;
+	op->a[1].val = stp->import[Bif.val].function;
+	op->a[2].type = TAG_u;
+	op->a[2].val = stp->import[Bif.val].arity;
+	return op;
     }
+    op->op = genop_i_gc_bif1_5;
+    op->arity = 5;
+    op->a[0] = Fail;
+    op->a[1].type = TAG_u;
     op->a[2] = Src;
     op->a[3] = Live;
     op->a[4] = Dst;
-    op->next = NULL;
     return op;
 }
 
 /*
- * This is used by the ops.tab rule that rewrites gc_bifs with two parameters
+ * This is used by the ops.tab rule that rewrites gc_bifs with two parameters.
  * The instruction returned is then again rewritten to an i_load instruction
- * folowed by i_gc_bif2_jIId, to handle literals properly.
+ * followed by i_gc_bif2_jIId, to handle literals properly.
  * As opposed to the i_gc_bif1_jIsId, the instruction  i_gc_bif2_jIId is
  * always rewritten, regardless of if there actually are any literals.
  */
@@ -3716,31 +3734,39 @@ gen_guard_bif2(LoaderState* stp, GenOpArg Fail, GenOpArg Live, GenOpArg Bif,
     BifFunction bf;
 
     NEW_GENOP(stp, op);
-    op->op = genop_ii_gc_bif2_6;
-    op->arity = 6;
-    op->a[0] = Fail;
-    op->a[1].type = TAG_u;
+    op->next = NULL;
     bf = stp->import[Bif.val].bf;
     /* The translations here need to have a reverse counterpart in
        beam_emu.c:translate_gc_bif for error handling to work properly. */
     if (bf == binary_part_2) {
 	op->a[1].val = (BeamInstr) (void *) erts_gc_binary_part_2;
     } else {
-	abort();
+	op->op = genop_unsupported_guard_bif_3;
+	op->arity = 3;
+	op->a[0].type = TAG_a;
+	op->a[0].val = stp->import[Bif.val].module;
+	op->a[1].type = TAG_a;
+	op->a[1].val = stp->import[Bif.val].function;
+	op->a[2].type = TAG_u;
+	op->a[2].val = stp->import[Bif.val].arity;
+	return op;
     }
+    op->op = genop_ii_gc_bif2_6;
+    op->arity = 6;
+    op->a[0] = Fail;
+    op->a[1].type = TAG_u;
     op->a[2] = S1;
     op->a[3] = S2;
     op->a[4] = Live;
     op->a[5] = Dst;
-    op->next = NULL;
     return op;
 }
 
 /*
- * This is used by the ops.tab rule that rewrites gc_bifs with three parameters
+ * This is used by the ops.tab rule that rewrites gc_bifs with three parameters.
  * The instruction returned is then again rewritten to a move instruction that
  * uses r[0] for temp storage, followed by an i_load instruction,
- * folowed by i_gc_bif3_jIsId, to handle literals properly. Rewriting
+ * followed by i_gc_bif3_jIsId, to handle literals properly. Rewriting
  * always occur, as with the gc_bif2 counterpart.
  */
 static GenOp*
@@ -3751,18 +3777,27 @@ gen_guard_bif3(LoaderState* stp, GenOpArg Fail, GenOpArg Live, GenOpArg Bif,
     BifFunction bf;
 
     NEW_GENOP(stp, op);
-    op->op = genop_ii_gc_bif3_7;
-    op->arity = 7;
-    op->a[0] = Fail;
-    op->a[1].type = TAG_u;
+    op->next = NULL;
     bf = stp->import[Bif.val].bf;
     /* The translations here need to have a reverse counterpart in
        beam_emu.c:translate_gc_bif for error handling to work properly. */
     if (bf == binary_part_3) {
 	op->a[1].val = (BeamInstr) (void *) erts_gc_binary_part_3;
     } else {
-	abort();
+	op->op = genop_unsupported_guard_bif_3;
+	op->arity = 3;
+	op->a[0].type = TAG_a;
+	op->a[0].val = stp->import[Bif.val].module;
+	op->a[1].type = TAG_a;
+	op->a[1].val = stp->import[Bif.val].function;
+	op->a[2].type = TAG_u;
+	op->a[2].val = stp->import[Bif.val].arity;
+	return op;
     }
+    op->op = genop_ii_gc_bif3_7;
+    op->arity = 7;
+    op->a[0] = Fail;
+    op->a[1].type = TAG_u;
     op->a[2] = S1;
     op->a[3] = S2;
     op->a[4] = S3;
diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index 327c4e8651..34bd5d0653 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -1466,34 +1466,13 @@ bif1 Fail u$bif:erlang:trunc/1 s d => too_old_compiler
 #
 # Guard BIFs.
 #
-gc_bif1 Fail I Bif=u$bif:erlang:length/1 Src Dst=d => \
+gc_bif1 Fail I Bif Src Dst => \
 	gen_guard_bif1(Fail, I, Bif, Src, Dst)
 
-gc_bif1 Fail I Bif=u$bif:erlang:size/1 Src Dst=d => \
-	gen_guard_bif1(Fail, I, Bif, Src, Dst)
-
-gc_bif1 Fail I Bif=u$bif:erlang:bit_size/1 Src Dst=d => \
-	gen_guard_bif1(Fail, I, Bif, Src, Dst)
-
-gc_bif1 Fail I Bif=u$bif:erlang:byte_size/1 Src Dst=d => \
-	gen_guard_bif1(Fail, I, Bif, Src, Dst)
-
-gc_bif1 Fail I Bif=u$bif:erlang:abs/1 Src Dst=d => \
-	gen_guard_bif1(Fail, I, Bif, Src, Dst)
-
-gc_bif1 Fail I Bif=u$bif:erlang:float/1 Src Dst=d => \
-	gen_guard_bif1(Fail, I, Bif, Src, Dst)
-
-gc_bif1 Fail I Bif=u$bif:erlang:round/1 Src Dst=d => \
-	gen_guard_bif1(Fail, I, Bif, Src, Dst)
-
-gc_bif1 Fail I Bif=u$bif:erlang:trunc/1 Src Dst=d => \
-	gen_guard_bif1(Fail, I, Bif, Src, Dst)
-
-gc_bif2 Fail I Bif=u$bif:erlang:binary_part/2 S1 S2 Dst=d => \
+gc_bif2 Fail I Bif S1 S2 Dst => \
 	gen_guard_bif2(Fail, I, Bif, S1, S2, Dst)
 
-gc_bif3 Fail I Bif=u$bif:erlang:binary_part/3 S1 S2 S3 Dst=d => \
+gc_bif3 Fail I Bif S1 S2 S3 Dst => \
 	gen_guard_bif3(Fail, I, Bif, S1, S2, S3, Dst)
 
 i_gc_bif1 Fail Bif V=q Live D => move V x | i_gc_bif1 Fail Bif x Live D
@@ -1511,6 +1490,15 @@ ii_gc_bif3/7
 ii_gc_bif3 Fail Bif S1 S2 S3 Live D => move S1 x | i_fetch S2 S3 | i_gc_bif3 Fail Bif x Live D
 
 i_gc_bif3 j I s I d
+
+#
+# The following instruction is specially handled in beam_load.c
+# to produce a user-friendly message if an unsupported guard BIF is
+# encountered.
+#
+unsupported_guard_bif/3
+unsupported_guard_bif A B C | never() =>
+
 #
 # R13B03
 #
-- 
cgit v1.2.3


From 39c0668121ff347877090e3ed237214f873c3e55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 11 Aug 2011 10:39:01 +0200
Subject: Share code for call of predicate and transformation functions

---
 erts/emulator/utils/beam_makeops | 32 ++++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index 367f089401..fa3f3ed5e3 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -105,7 +105,9 @@ my %match_engine_ops;		# All opcodes for the match engine.
 my %gen_transform_offset;
 my @transformations;
 my @call_table;
+my %call_table;
 my @pred_table;
+my %pred_table;
 
 # Operand types for generic instructions.
 
@@ -1562,9 +1564,8 @@ sub tr_gen_from {
 		push(@args, "var+$var{$var}");
 	    }
 	}
-	splice(@code, $index, 1, &make_op("$name()",
-					  'pred', scalar(@pred_table)));
-	push(@pred_table, [$name, @args]);
+	my $pi = tr_next_index(\@pred_table, \%pred_table, $name, @args);
+	splice(@code, $index, 1, make_op("$name()", 'pred', $pi));
     }
 
     $te_max_vars = $var_num
@@ -1607,8 +1608,9 @@ sub tr_gen_to {
 		}
 	    }
 	    pop(@code);	# Get rid of 'commit' instruction
-	    push(@code, make_op("$name()", 'call_end', scalar(@call_table)));
-	    push(@call_table, [$name, @args]);
+	    my $index = tr_next_index(\@call_table, \%call_table,
+				      $name, @args);
+	    push(@code, make_op("$name()", 'call_end', $index));
 	    last;
 	}
 
@@ -1700,16 +1702,26 @@ sub get_comment {
     $ref->[2];
 }
 
+sub tr_next_index {
+    my($lref,$href,$name,@args) = @_;
+    my $code = "RVAL = $name(" . join(', ', 'st', @args) . "); break;\n";
+    my $index;
+
+    if (defined $$href{$code}) {
+	$index = $$href{$code};
+    } else {
+	$index = scalar(@$lref);
+	push(@$lref, $code);
+	$$href{$code} = $index;
+    }
+    $index;
+}
 
 sub tr_gen_call {
     my(@call_table) = @_;
     my($i);
 
-    print "\n";
     for ($i = 0; $i < @call_table; $i++) {
-	my $ref = $call_table[$i];
-	my($name, @args) = @$ref;
-	print "case $i: RVAL = $name(", join(', ', 'st', @args), "); break;\n";
+	print "case $i: $call_table[$i]";
     }
-    print "\n";
 }
-- 
cgit v1.2.3


From 09a5930d116bc4ebfac9404845bed8181662a0db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 11 Aug 2011 10:42:02 +0200
Subject: Print transformtions sorted on the name of the first instruction

---
 erts/emulator/utils/beam_makeops | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index fa3f3ed5e3..58c36c3bdc 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -1322,7 +1322,7 @@ sub tr_gen {
     #
     my($offset) = 0;
     print "Uint op_transform[] = {\n";
-    foreach $key (keys %gen_transform) {
+    foreach $key (sort keys %gen_transform) {
 	$gen_transform_offset{$key} = $offset;
 	my @instr = @{$gen_transform{$key}};
 
-- 
cgit v1.2.3


From e04883d448df6e622535020449903e2f2a0f32c9 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Tue, 26 Jul 2011 17:11:41 +0200
Subject: Update integer and floating point number comparisons

For floating point values which are greater than 9007199254740990.0 or
smaller than -9007199254740990.0, the floating point numbers are now
converted to integers during comparison with an integer. This makes
number comparisons transitive for large floating point numbers.
---
 erts/emulator/beam/big.c    | 57 +++++++++++++++++++++++++++++++++++++++++++
 erts/emulator/beam/big.h    |  1 +
 erts/emulator/beam/erl_vm.h |  2 +-
 erts/emulator/beam/utils.c  | 59 ++++++++++++++++++++++++++++++++++++---------
 4 files changed, 107 insertions(+), 12 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/big.c b/erts/emulator/beam/big.c
index d18de9ae5d..51e5d2d305 100644
--- a/erts/emulator/beam/big.c
+++ b/erts/emulator/beam/big.c
@@ -1584,6 +1584,63 @@ big_to_double(Wterm x, double* resp)
     return 0;
 }
 
+Eterm
+double_to_big(double x, Eterm *heap)
+{
+    int is_negative;
+    int ds;
+    ErtsDigit* xp;
+    Eterm tmp_res;
+    int i;
+    size_t sz;
+    Eterm* hp;
+    double dbase;
+
+    if ((x < (double) (MAX_SMALL + 1)) && (x > (double) (MIN_SMALL - 1))) {
+	Sint xi = x;
+	return make_small(xi);
+    }
+
+    if (x >= 0) {
+	is_negative = 0;
+    } else {
+	is_negative = 1;
+	x = -x;
+    }
+
+    /* Unscale & (calculate exponent) */
+    ds = 0;
+    dbase = ((double) (D_MASK) + 1);
+    while (x >= 1.0) {
+	x /= dbase; /* "shift" right */
+	ds++;
+    }
+    sz = BIG_NEED_SIZE(ds); /* number of words including arity */
+
+    hp = heap;
+    tmp_res = make_big(hp);
+    xp = (ErtsDigit*) (hp + 1);
+
+    for (i = ds - 1; i >= 0; i--) {
+	ErtsDigit d;
+
+	x *= dbase; /* "shift" left */
+	d = x; /* trunc */
+	xp[i] = d; /* store digit */
+	x -= d; /* remove integer part */
+    }
+    while ((ds & (BIG_DIGITS_PER_WORD - 1)) != 0) {
+	xp[ds++] = 0;
+    }
+
+    if (is_negative) {
+	*hp = make_neg_bignum_header(sz-1);
+    } else {
+	*hp = make_pos_bignum_header(sz-1);
+    }
+    return tmp_res;
+}
+
 
 /*
  ** Estimate the number of decimal digits (include sign)
diff --git a/erts/emulator/beam/big.h b/erts/emulator/beam/big.h
index 2afc37004f..256f1c2b45 100644
--- a/erts/emulator/beam/big.h
+++ b/erts/emulator/beam/big.h
@@ -140,6 +140,7 @@ Eterm big_lshift(Eterm, Sint, Eterm*);
 int big_comp (Wterm, Wterm);
 int big_ucomp (Eterm, Eterm);
 int big_to_double(Wterm x, double* resp);
+Eterm double_to_big(double, Eterm*);
 Eterm small_to_big(Sint, Eterm*);
 Eterm uint_to_big(Uint, Eterm*);
 Eterm uword_to_big(UWord, Eterm*);
diff --git a/erts/emulator/beam/erl_vm.h b/erts/emulator/beam/erl_vm.h
index e7fd144ec3..ed9139518c 100644
--- a/erts/emulator/beam/erl_vm.h
+++ b/erts/emulator/beam/erl_vm.h
@@ -55,7 +55,7 @@
    heap data on the C stack or if we use the buffers in the scheduler data. */
 #define TMP_HEAP_SIZE 128            /* Number of Eterm in the schedulers
 				        small heap for transient heap data */
-#define CMP_TMP_HEAP_SIZE       2    /* cmp wants its own tmp-heap... */
+#define CMP_TMP_HEAP_SIZE       16   /* cmp wants its own tmp-heap... */
 #define ERL_ARITH_TMP_HEAP_SIZE 4    /* as does erl_arith... */
 #define BEAM_EMU_TMP_HEAP_SIZE  2    /* and beam_emu... */
 
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 3f6accba2d..e67a793b9a 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -2642,7 +2642,7 @@ tailrecur_ne:
 	FloatDef f1, f2;
 	Eterm big;
 #if HEAP_ON_C_STACK
-	Eterm big_buf[2]; /* If HEAP_ON_C_STACK */
+	Eterm big_buf[16]; /* If HEAP_ON_C_STACK */
 #else
 	Eterm *big_buf = erts_get_scheduler_data()->cmp_tmp_heap;
 #endif
@@ -2661,33 +2661,70 @@ tailrecur_ne:
 	    j = big_comp(big, bw);
 	    break;
 	case SMALL_FLOAT:
-	    f1.fd = signed_val(a);
 	    GET_DOUBLE(bw, f2);
-	    j = float_comp(f1.fd, f2.fd);
+	    if ((f2.fd < 9007199254740990.0 && f2.fd > -9007199254740990.0)) // Float is within the no loss limit
+		    {
+		f1.fd = signed_val(a);
+		j = float_comp(f1.fd, f2.fd);
+	    } else if (f2.fd > (double) (MAX_SMALL + 1)) { // Float is a positive bignum, i.e. bigger
+		j = -1;
+	    } else if (f2.fd < (double) (MIN_SMALL - 1)) { // Float is a negative bignum, i.e. smaller
+		j = 1;
+	    } else { // Float is a Sint but less precise it
+		j = signed_val(a) - (Sint) f2.fd;
+	    }
 	    break;
 	case BIG_SMALL:
 	    big = small_to_big(signed_val(b), big_buf);
 	    j = big_comp(aw, big);
 	    break;
 	case BIG_FLOAT:
-	    if (big_to_double(aw, &f1.fd) < 0) {
+	    GET_DOUBLE(bw, f2);
+	    if ((f2.fd < 9007199254740990.0 && f2.fd > -9007199254740990.0)) {
+		if (big_to_double(aw, &f1.fd) < 0) {
+		    j = big_sign(a) ? -1 : 1;
+		} else {
+		    j = float_comp(f1.fd, f2.fd);
+		}
+	    } else if ((f2.fd < (double) (MAX_SMALL + 1)) && (f2.fd > (double) (MIN_SMALL - 1))) { // Float is a Sint
+		j = big_sign(a) ? -1 : 1;
+	    } else if (big_arity(a) > ((1 << 10) / D_EXP)) { // If bignum size is larger than largest/smallest float
 		j = big_sign(a) ? -1 : 1;
 	    } else {
-		GET_DOUBLE(bw, f2);
-		j = float_comp(f1.fd, f2.fd);
+		big = double_to_big(f2.fd, big_buf);
+		j = big_comp(aw, big);
 	    }
 	    break;
 	case FLOAT_SMALL:
 	    GET_DOUBLE(aw, f1);
-	    f2.fd = signed_val(b);
-	    j = float_comp(f1.fd, f2.fd);
+	    if ((f1.fd < 9007199254740990.0 && f1.fd > -9007199254740990.0)) // Float is within the no loss limit
+		    {
+		f2.fd = signed_val(b);
+		j = float_comp(f1.fd, f2.fd);
+	    } else if (f1.fd > (double) (MAX_SMALL + 1)) { // Float is a positive bignum, i.e. bigger
+		j = 1;
+	    } else if (f1.fd < (double) (MIN_SMALL - 1)) { // Float is a negative bignum, i.e. smaller
+		j = -1;
+	    } else { // Float is a Sint but less precise it
+		j = (Sint) f1.fd - signed_val(b);
+	    }
 	    break;
 	case FLOAT_BIG:
-	    if (big_to_double(bw, &f2.fd) < 0) {
+	    GET_DOUBLE(aw, f1);
+	    if ((f1.fd < 9007199254740990.0 && f1.fd > -9007199254740990.0)) {
+		if (big_to_double(bw, &f2.fd) < 0) {
+		    j = big_sign(b) ? 1 : -1;
+		} else {
+		    j = float_comp(f1.fd, f2.fd);
+		}
+	    } else if ((f1.fd < (double) (MAX_SMALL + 1))
+		    && (f1.fd > (double) (MIN_SMALL - 1))) { // Float is a Sint
+		j = big_sign(b) ? 1 : -1;
+	    } else if (big_arity(b) > ((1 << 10) / D_EXP)) { // If bignum size is larger than largest/smallest float
 		j = big_sign(b) ? 1 : -1;
 	    } else {
-		GET_DOUBLE(aw, f1);
-		j = float_comp(f1.fd, f2.fd);
+		big = double_to_big(f1.fd, big_buf);
+		j = big_comp(big, bw);
 	    }
 	    break;
 	default:
-- 
cgit v1.2.3


From 5d4e1831fafb5c2cb119d4b2cc5a704f3b9c1c55 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Wed, 27 Jul 2011 14:52:29 +0200
Subject: Add float vs integer comparison tests

---
 erts/emulator/test/float_SUITE.erl | 44 +++++++++++++++++++++++++++++++++++---
 1 file changed, 41 insertions(+), 3 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/test/float_SUITE.erl b/erts/emulator/test/float_SUITE.erl
index 736510339f..e2e9b9120c 100644
--- a/erts/emulator/test/float_SUITE.erl
+++ b/erts/emulator/test/float_SUITE.erl
@@ -25,7 +25,7 @@
 	 init_per_group/2,end_per_group/2,
 	 init_per_testcase/2,end_per_testcase/2,
 	 fpe/1,fp_drv/1,fp_drv_thread/1,denormalized/1,match/1,
-	 bad_float_unpack/1]).
+	 bad_float_unpack/1,cmp_zero/1, cmp_integer/1, cmp_bignum/1]).
 -export([otp_7178/1]).
 
 
@@ -41,10 +41,10 @@ suite() -> [{ct_hooks,[ts_install_cth]}].
 
 all() -> 
     [fpe, fp_drv, fp_drv_thread, otp_7178, denormalized,
-     match, bad_float_unpack].
+     match, bad_float_unpack, {group, comparison}].
 
 groups() -> 
-    [].
+    [{comparison, [parallel], [cmp_zero, cmp_integer, cmp_bignum]}].
 
 init_per_suite(Config) ->
     Config.
@@ -187,6 +187,44 @@ bad_float_unpack(Config) when is_list(Config) ->
 bad_float_unpack_match(<<F:64/float>>) -> F;
 bad_float_unpack_match(<<I:64/integer-signed>>) -> I.
 
+cmp_zero(_Config) ->
+    cmp(0.5e-323,0).
+
+cmp_integer(_Config) ->
+    Axis = (1 bsl 53)-2.0, %% The point where floating points become unprecise
+    span_cmp(Axis,2,200),
+    cmp(Axis*Axis, round(Axis)).
+
+cmp_bignum(_Config) ->
+    span_cmp((1 bsl 58) - 1.0),%% Smallest bignum float
+
+    %% Test I to I+1 bignum segment overflow
+    [span_cmp((1 bsl (32*I)) - 1.0) || I <- lists:seq(2,30)],
+
+    cmp((1 bsl (64*16)) - 1, (1 bsl (64*15)) * 1.0),
+    ok.
+
+span_cmp(Axis) ->
+    span_cmp(Axis, 50).
+span_cmp(Axis, Length) ->
+    span_cmp(Axis, round(Axis) bsr 52, Length).
+span_cmp(Axis, Incr, Length) ->
+    [cmp(round(Axis*-1.0)+1+I*Incr,Axis*-1.0+I*Incr)
+     || I <- lists:seq((Length div 2)*-1,(Length div 2))],
+    [cmp(round(Axis)+1+I*Incr,Axis+I*Incr) ||
+	I <- lists:seq((Length div 2)*-1,(Length div 2))].
+
+cmp(Big,Small) ->
+    BigSmall = lists:flatten(
+		 io_lib:format("~p > ~p",[Big,Small])),
+    SmallBig = lists:flatten(
+		 io_lib:format("~p < ~p",[Big,Small])),
+    {_,_,_,true} = {Big,Small,BigSmall,
+		    Big > Small},
+    {_,_,_,false} = {Big,Small,SmallBig,
+		     Big < Small},
+    {BigSmall, SmallBig}.
+
 id(I) -> I.
     
 start_node(Config) when is_list(Config) ->
-- 
cgit v1.2.3


From b47a8245774ee1d57872d99015081e6307e037f1 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Wed, 27 Jul 2011 16:41:13 +0200
Subject: Optimise bugnum and small comparison

As it is possible to assume that bignums are bigger than smalls,
we can just check the sign of the bignum.
---
 erts/emulator/beam/utils.c | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index e67a793b9a..5e22aa42c8 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -2657,8 +2657,10 @@ tailrecur_ne:
 
 	switch(_NUMBER_CODE(a_tag, b_tag)) {
 	case SMALL_BIG:
-	    big = small_to_big(signed_val(a), big_buf);
-	    j = big_comp(big, bw);
+	    j = big_sign(bw) ? 1 : -1;
+	    break;
+	case BIG_SMALL:
+	    j = big_sign(aw) ? -1 : 1;
 	    break;
 	case SMALL_FLOAT:
 	    GET_DOUBLE(bw, f2);
@@ -2674,10 +2676,6 @@ tailrecur_ne:
 		j = signed_val(a) - (Sint) f2.fd;
 	    }
 	    break;
-	case BIG_SMALL:
-	    big = small_to_big(signed_val(b), big_buf);
-	    j = big_comp(aw, big);
-	    break;
 	case BIG_FLOAT:
 	    GET_DOUBLE(bw, f2);
 	    if ((f2.fd < 9007199254740990.0 && f2.fd > -9007199254740990.0)) {
-- 
cgit v1.2.3


From 1224324e4ee4526397725c4aaaf8885ec7da0c4e Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Wed, 27 Jul 2011 16:46:08 +0200
Subject: Add heauristics bignum vs float checks

These tests are useful when the difference between the
bignum and float is larger than one bignum segment.
---
 erts/emulator/beam/utils.c | 67 +++++++++++++++++++++++++++++-----------------
 1 file changed, 42 insertions(+), 25 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 5e22aa42c8..91e4e50e15 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -2653,6 +2653,8 @@ tailrecur_ne:
 	Eterm aw = a;
 	Eterm bw = b;
 #endif
+#define MAX_LOSSLESS_FLOAT ((double)((1L << 53) - 2))
+#define MIN_LOSSLESS_FLOAT ((double)(((1L << 53) - 2)*-1))
 	b_tag = tag_val_def(bw);
 
 	switch(_NUMBER_CODE(a_tag, b_tag)) {
@@ -2664,30 +2666,39 @@ tailrecur_ne:
 	    break;
 	case SMALL_FLOAT:
 	    GET_DOUBLE(bw, f2);
-	    if ((f2.fd < 9007199254740990.0 && f2.fd > -9007199254740990.0)) // Float is within the no loss limit
-		    {
-		f1.fd = signed_val(a);
+	    if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
+		// Float is within the no loss limit
+		f1.fd = signed_val(aw);
 		j = float_comp(f1.fd, f2.fd);
-	    } else if (f2.fd > (double) (MAX_SMALL + 1)) { // Float is a positive bignum, i.e. bigger
+	    } else if (f2.fd > (double) (MAX_SMALL + 1)) {
+		// Float is a positive bignum, i.e. bigger
 		j = -1;
-	    } else if (f2.fd < (double) (MIN_SMALL - 1)) { // Float is a negative bignum, i.e. smaller
+	    } else if (f2.fd < (double) (MIN_SMALL - 1)) {
+		// Float is a negative bignum, i.e. smaller
 		j = 1;
-	    } else { // Float is a Sint but less precise it
-		j = signed_val(a) - (Sint) f2.fd;
+	    } else { // Float is a Sint but less precise
+		j = signed_val(aw) - (Sint) f2.fd;
 	    }
 	    break;
 	case BIG_FLOAT:
 	    GET_DOUBLE(bw, f2);
-	    if ((f2.fd < 9007199254740990.0 && f2.fd > -9007199254740990.0)) {
+	    if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
+		// Float is within the no loss limit
 		if (big_to_double(aw, &f1.fd) < 0) {
-		    j = big_sign(a) ? -1 : 1;
+		    j = big_sign(aw) ? -1 : 1;
 		} else {
 		    j = float_comp(f1.fd, f2.fd);
 		}
-	    } else if ((f2.fd < (double) (MAX_SMALL + 1)) && (f2.fd > (double) (MIN_SMALL - 1))) { // Float is a Sint
-		j = big_sign(a) ? -1 : 1;
-	    } else if (big_arity(a) > ((1 << 10) / D_EXP)) { // If bignum size is larger than largest/smallest float
-		j = big_sign(a) ? -1 : 1;
+	    } else if ((f2.fd < (double) (MAX_SMALL + 1))
+		    && (f2.fd > (double) (MIN_SMALL - 1))) {
+		// Float is a Sint
+		j = big_sign(aw) ? -1 : 1;
+	    } else if ( (( 1 << (big_arity(aw)*D_EXP))-1) > f2.fd) {
+		// If bignum size shows that it is bigger than the float
+		j = -1;
+	    } else if ( (( 1 << (big_arity(aw)*D_EXP))-1)*-1 < f2.fd) {
+		// If bignum size shows that it is smaller than the float
+		j = 1;
 	    } else {
 		big = double_to_big(f2.fd, big_buf);
 		j = big_comp(aw, big);
@@ -2695,31 +2706,37 @@ tailrecur_ne:
 	    break;
 	case FLOAT_SMALL:
 	    GET_DOUBLE(aw, f1);
-	    if ((f1.fd < 9007199254740990.0 && f1.fd > -9007199254740990.0)) // Float is within the no loss limit
-		    {
-		f2.fd = signed_val(b);
+	    if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
+		// Float is within the no loss limit
+		f2.fd = signed_val(bw);
 		j = float_comp(f1.fd, f2.fd);
-	    } else if (f1.fd > (double) (MAX_SMALL + 1)) { // Float is a positive bignum, i.e. bigger
+	    } else if (f1.fd > (double) (MAX_SMALL + 1)) {
+		// Float is a positive bignum, i.e. bigger
 		j = 1;
-	    } else if (f1.fd < (double) (MIN_SMALL - 1)) { // Float is a negative bignum, i.e. smaller
+	    } else if (f1.fd < (double) (MIN_SMALL - 1)) {
+		// Float is a negative bignum, i.e. smaller
 		j = -1;
 	    } else { // Float is a Sint but less precise it
-		j = (Sint) f1.fd - signed_val(b);
+		j = (Sint) f1.fd - signed_val(bw);
 	    }
 	    break;
 	case FLOAT_BIG:
 	    GET_DOUBLE(aw, f1);
-	    if ((f1.fd < 9007199254740990.0 && f1.fd > -9007199254740990.0)) {
-		if (big_to_double(bw, &f2.fd) < 0) {
-		    j = big_sign(b) ? 1 : -1;
+	    if (f1.fd < MAX_LOSSLESS_FLOAT && f1.fd > MIN_LOSSLESS_FLOAT) {
+		if (big_to_double(bw, &f1.fd) < 0) {
+		    j = big_sign(bw) ? 1 : -1;
 		} else {
 		    j = float_comp(f1.fd, f2.fd);
 		}
 	    } else if ((f1.fd < (double) (MAX_SMALL + 1))
 		    && (f1.fd > (double) (MIN_SMALL - 1))) { // Float is a Sint
-		j = big_sign(b) ? 1 : -1;
-	    } else if (big_arity(b) > ((1 << 10) / D_EXP)) { // If bignum size is larger than largest/smallest float
-		j = big_sign(b) ? 1 : -1;
+		j = big_sign(bw) ? 1 : -1;
+	    } else if ( (( 1 << (big_arity(bw)*D_EXP))-1) > f1.fd) {
+		// If bignum size shows that it is bigger than the float
+		j = 1;
+	    } else if ( (( 1 << (big_arity(bw)*D_EXP))-1)*-1 < f1.fd) {
+		// If bignum size shows that it is smaller than the float
+		j = -1;
 	    } else {
 		big = double_to_big(f1.fd, big_buf);
 		j = big_comp(big, bw);
-- 
cgit v1.2.3


From 5afcc1900d858984143c673aca5c1639d12f9e84 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Tue, 11 Oct 2011 17:18:15 +0200
Subject: Update heauristic to work on halfword

---
 erts/emulator/beam/erl_vm.h |  2 +-
 erts/emulator/beam/utils.c  | 45 ++++++++++++++++++++-------------------------
 2 files changed, 21 insertions(+), 26 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_vm.h b/erts/emulator/beam/erl_vm.h
index ed9139518c..f810392e60 100644
--- a/erts/emulator/beam/erl_vm.h
+++ b/erts/emulator/beam/erl_vm.h
@@ -55,7 +55,7 @@
    heap data on the C stack or if we use the buffers in the scheduler data. */
 #define TMP_HEAP_SIZE 128            /* Number of Eterm in the schedulers
 				        small heap for transient heap data */
-#define CMP_TMP_HEAP_SIZE       16   /* cmp wants its own tmp-heap... */
+#define CMP_TMP_HEAP_SIZE       32   /* cmp wants its own tmp-heap... */
 #define ERL_ARITH_TMP_HEAP_SIZE 4    /* as does erl_arith... */
 #define BEAM_EMU_TMP_HEAP_SIZE  2    /* and beam_emu... */
 
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 91e4e50e15..85e8c86d53 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -2653,8 +2653,8 @@ tailrecur_ne:
 	Eterm aw = a;
 	Eterm bw = b;
 #endif
-#define MAX_LOSSLESS_FLOAT ((double)((1L << 53) - 2))
-#define MIN_LOSSLESS_FLOAT ((double)(((1L << 53) - 2)*-1))
+#define MAX_LOSSLESS_FLOAT ((double)((1LL << 53) - 2))
+#define MIN_LOSSLESS_FLOAT ((double)(((1LL << 53) - 2)*-1))
 	b_tag = tag_val_def(bw);
 
 	switch(_NUMBER_CODE(a_tag, b_tag)) {
@@ -2682,23 +2682,20 @@ tailrecur_ne:
 	    break;
 	case BIG_FLOAT:
 	    GET_DOUBLE(bw, f2);
-	    if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
+	    if ((f2.fd < (double) (MAX_SMALL + 1))
+		    && (f2.fd > (double) (MIN_SMALL - 1))) {
+		// Float is a Sint
+		j = big_sign(aw) ? -1 : 1;
+	    } else if ( (pow(2.0,(big_arity(aw)-1.0)*D_EXP)-1.0) > fabs(f2.fd)) {
+		// If bignum size shows that it is bigger or smaller than the float
+		j = big_sign(aw) ? -1 : 1;
+	    } else if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
 		// Float is within the no loss limit
 		if (big_to_double(aw, &f1.fd) < 0) {
 		    j = big_sign(aw) ? -1 : 1;
 		} else {
 		    j = float_comp(f1.fd, f2.fd);
 		}
-	    } else if ((f2.fd < (double) (MAX_SMALL + 1))
-		    && (f2.fd > (double) (MIN_SMALL - 1))) {
-		// Float is a Sint
-		j = big_sign(aw) ? -1 : 1;
-	    } else if ( (( 1 << (big_arity(aw)*D_EXP))-1) > f2.fd) {
-		// If bignum size shows that it is bigger than the float
-		j = -1;
-	    } else if ( (( 1 << (big_arity(aw)*D_EXP))-1)*-1 < f2.fd) {
-		// If bignum size shows that it is smaller than the float
-		j = 1;
 	    } else {
 		big = double_to_big(f2.fd, big_buf);
 		j = big_comp(aw, big);
@@ -2706,7 +2703,7 @@ tailrecur_ne:
 	    break;
 	case FLOAT_SMALL:
 	    GET_DOUBLE(aw, f1);
-	    if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
+	    if (f1.fd < MAX_LOSSLESS_FLOAT && f1.fd > MIN_LOSSLESS_FLOAT) {
 		// Float is within the no loss limit
 		f2.fd = signed_val(bw);
 		j = float_comp(f1.fd, f2.fd);
@@ -2722,21 +2719,19 @@ tailrecur_ne:
 	    break;
 	case FLOAT_BIG:
 	    GET_DOUBLE(aw, f1);
-	    if (f1.fd < MAX_LOSSLESS_FLOAT && f1.fd > MIN_LOSSLESS_FLOAT) {
-		if (big_to_double(bw, &f1.fd) < 0) {
+	    if ((f1.fd < (double) (MAX_SMALL + 1))
+		    && (f1.fd > (double) (MIN_SMALL - 1))) { // Float is a Sint
+		j = big_sign(bw) ? 1 : -1;
+	    } else if ((pow(2.0, (big_arity(bw) - 1.0) * D_EXP) - 1.0) > fabs(f1.fd)) {
+		// If bignum size shows that it is bigger than the float
+		j = big_sign(bw) ? 1 : -1;
+	    } else if (f1.fd < MAX_LOSSLESS_FLOAT && f1.fd >MIN_LOSSLESS_FLOAT) {
+		// Float is within the no loss limit
+		if (big_to_double(bw, &f2.fd) < 0) {
 		    j = big_sign(bw) ? 1 : -1;
 		} else {
 		    j = float_comp(f1.fd, f2.fd);
 		}
-	    } else if ((f1.fd < (double) (MAX_SMALL + 1))
-		    && (f1.fd > (double) (MIN_SMALL - 1))) { // Float is a Sint
-		j = big_sign(bw) ? 1 : -1;
-	    } else if ( (( 1 << (big_arity(bw)*D_EXP))-1) > f1.fd) {
-		// If bignum size shows that it is bigger than the float
-		j = 1;
-	    } else if ( (( 1 << (big_arity(bw)*D_EXP))-1)*-1 < f1.fd) {
-		// If bignum size shows that it is smaller than the float
-		j = -1;
 	    } else {
 		big = double_to_big(f1.fd, big_buf);
 		j = big_comp(big, bw);
-- 
cgit v1.2.3


From 0ab6d70a34f5e2fbfdeb6235024a1d5e83cab64f Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Tue, 11 Oct 2011 17:18:41 +0200
Subject: Expand tests for float and number comparison

---
 erts/emulator/test/float_SUITE.erl | 36 ++++++++++++++++++++++++++----------
 1 file changed, 26 insertions(+), 10 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/test/float_SUITE.erl b/erts/emulator/test/float_SUITE.erl
index e2e9b9120c..a8cc3b9a3f 100644
--- a/erts/emulator/test/float_SUITE.erl
+++ b/erts/emulator/test/float_SUITE.erl
@@ -193,7 +193,7 @@ cmp_zero(_Config) ->
 cmp_integer(_Config) ->
     Axis = (1 bsl 53)-2.0, %% The point where floating points become unprecise
     span_cmp(Axis,2,200),
-    cmp(Axis*Axis, round(Axis)).
+    cmp(Axis*Axis,round(Axis)).
 
 cmp_bignum(_Config) ->
     span_cmp((1 bsl 58) - 1.0),%% Smallest bignum float
@@ -202,23 +202,39 @@ cmp_bignum(_Config) ->
     [span_cmp((1 bsl (32*I)) - 1.0) || I <- lists:seq(2,30)],
 
     cmp((1 bsl (64*16)) - 1, (1 bsl (64*15)) * 1.0),
+    [cmp((1 bsl (32*I)) - 1, (1 bsl (32*(I-2))) * 1.0) || I <- lists:seq(3,30)],
     ok.
 
 span_cmp(Axis) ->
-    span_cmp(Axis, 50).
+    span_cmp(Axis, 25).
 span_cmp(Axis, Length) ->
     span_cmp(Axis, round(Axis) bsr 52, Length).
 span_cmp(Axis, Incr, Length) ->
-    [cmp(round(Axis*-1.0)+1+I*Incr,Axis*-1.0+I*Incr)
-     || I <- lists:seq((Length div 2)*-1,(Length div 2))],
-    [cmp(round(Axis)+1+I*Incr,Axis+I*Incr) ||
-	I <- lists:seq((Length div 2)*-1,(Length div 2))].
-
-cmp(Big,Small) ->
+    [span_cmp(Axis, Incr, Length, 1 bsl (1 bsl I)) || I <- lists:seq(0,6)].
+span_cmp(Axis, Incr, Length, Diff) ->
+    [begin
+	 cmp(round(Axis*-1.0)+Diff+I*Incr,Axis*-1.0+I*Incr),
+	 cmp(Axis*-1.0+I*Incr,round(Axis*-1.0)-Diff+I*Incr)
+     end || I <- lists:seq((Length div 2)*-1,(Length div 2))],
+    [begin
+	 cmp(round(Axis)+Diff+I*Incr,Axis+I*Incr),
+	 cmp(Axis+I*Incr,round(Axis)-Diff+I*Incr)
+     end || I <- lists:seq((Length div 2)*-1,(Length div 2))].
+
+cmp(Big,Small) when is_float(Big) ->
+    BigSmall = lists:flatten(
+		 io_lib:format("~f > ~p",[Big,Small])),
+    SmallBig = lists:flatten(
+		 io_lib:format("~f < ~p",[Big,Small])),
+    cmp(Big,Small,BigSmall,SmallBig);
+cmp(Big,Small) when is_float(Small) ->
     BigSmall = lists:flatten(
-		 io_lib:format("~p > ~p",[Big,Small])),
+		 io_lib:format("~p > ~f",[Big,Small])),
     SmallBig = lists:flatten(
-		 io_lib:format("~p < ~p",[Big,Small])),
+		 io_lib:format("~p < ~f",[Big,Small])),
+    cmp(Big,Small,BigSmall,SmallBig).
+
+cmp(Big,Small,BigSmall,SmallBig) ->
     {_,_,_,true} = {Big,Small,BigSmall,
 		    Big > Small},
     {_,_,_,false} = {Big,Small,SmallBig,
-- 
cgit v1.2.3


From f99fd21debc8274dbdecd595e1666436ec962ccd Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Fri, 29 Jul 2011 15:47:06 +0200
Subject: Update size of tmp cmp bignum buffer

This is needed for use on 32 bit with very large floats.
---
 erts/emulator/beam/utils.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 85e8c86d53..5822b2e1d9 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -2642,7 +2642,7 @@ tailrecur_ne:
 	FloatDef f1, f2;
 	Eterm big;
 #if HEAP_ON_C_STACK
-	Eterm big_buf[16]; /* If HEAP_ON_C_STACK */
+	Eterm big_buf[32]; /* If HEAP_ON_C_STACK */
 #else
 	Eterm *big_buf = erts_get_scheduler_data()->cmp_tmp_heap;
 #endif
-- 
cgit v1.2.3


From 6c1a36a91a0b214d598f845bed2b649a4de8ae3f Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Mon, 8 Aug 2011 16:13:32 +0200
Subject: Cleanup double_to_bignum conversion code

---
 erts/emulator/beam/big.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/big.c b/erts/emulator/beam/big.c
index 51e5d2d305..b90ea6b478 100644
--- a/erts/emulator/beam/big.c
+++ b/erts/emulator/beam/big.c
@@ -1584,23 +1584,22 @@ big_to_double(Wterm x, double* resp)
     return 0;
 }
 
+/*
+ * Logic has been copied from erl_bif_guard.c and slightly
+ * modified to use a static instead of dynamic heap
+ */
 Eterm
 double_to_big(double x, Eterm *heap)
 {
     int is_negative;
     int ds;
     ErtsDigit* xp;
-    Eterm tmp_res;
+    Eterm res;
     int i;
     size_t sz;
     Eterm* hp;
     double dbase;
 
-    if ((x < (double) (MAX_SMALL + 1)) && (x > (double) (MIN_SMALL - 1))) {
-	Sint xi = x;
-	return make_small(xi);
-    }
-
     if (x >= 0) {
 	is_negative = 0;
     } else {
@@ -1618,7 +1617,7 @@ double_to_big(double x, Eterm *heap)
     sz = BIG_NEED_SIZE(ds); /* number of words including arity */
 
     hp = heap;
-    tmp_res = make_big(hp);
+    res = make_big(hp);
     xp = (ErtsDigit*) (hp + 1);
 
     for (i = ds - 1; i >= 0; i--) {
@@ -1638,7 +1637,7 @@ double_to_big(double x, Eterm *heap)
     } else {
 	*hp = make_pos_bignum_header(sz-1);
     }
-    return tmp_res;
+    return res;
 }
 
 
-- 
cgit v1.2.3


From 0e88b9724ddd2d5ccd1def55ab2044e7665ca9e4 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Mon, 8 Aug 2011 18:46:56 +0200
Subject: Add tests for comparing large floats and small bignums

---
 erts/emulator/test/float_SUITE.erl | 38 +++++++++++++++++++++++++-------------
 1 file changed, 25 insertions(+), 13 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/test/float_SUITE.erl b/erts/emulator/test/float_SUITE.erl
index a8cc3b9a3f..bf0fbc70bc 100644
--- a/erts/emulator/test/float_SUITE.erl
+++ b/erts/emulator/test/float_SUITE.erl
@@ -203,6 +203,7 @@ cmp_bignum(_Config) ->
 
     cmp((1 bsl (64*16)) - 1, (1 bsl (64*15)) * 1.0),
     [cmp((1 bsl (32*I)) - 1, (1 bsl (32*(I-2))) * 1.0) || I <- lists:seq(3,30)],
+    [cmp((1 bsl (64*15)) * 1.0, (1 bsl (32*(I)))) || I <- lists:seq(1,29)],
     ok.
 
 span_cmp(Axis) ->
@@ -222,24 +223,35 @@ span_cmp(Axis, Incr, Length, Diff) ->
      end || I <- lists:seq((Length div 2)*-1,(Length div 2))].
 
 cmp(Big,Small) when is_float(Big) ->
-    BigSmall = lists:flatten(
+    BigGtSmall = lists:flatten(
 		 io_lib:format("~f > ~p",[Big,Small])),
-    SmallBig = lists:flatten(
+    BigLtSmall = lists:flatten(
 		 io_lib:format("~f < ~p",[Big,Small])),
-    cmp(Big,Small,BigSmall,SmallBig);
+    SmallGtBig = lists:flatten(
+		   io_lib:format("~p > ~f",[Small,Big])),
+    SmallLtBig = lists:flatten(
+		   io_lib:format("~p < ~f",[Small,Big])),
+    cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig);
 cmp(Big,Small) when is_float(Small) ->
-    BigSmall = lists:flatten(
-		 io_lib:format("~p > ~f",[Big,Small])),
-    SmallBig = lists:flatten(
-		 io_lib:format("~p < ~f",[Big,Small])),
-    cmp(Big,Small,BigSmall,SmallBig).
-
-cmp(Big,Small,BigSmall,SmallBig) ->
-    {_,_,_,true} = {Big,Small,BigSmall,
+    BigGtSmall = lists:flatten(
+		   io_lib:format("~p > ~f",[Big,Small])),
+    BigLtSmall = lists:flatten(
+		   io_lib:format("~p < ~f",[Big,Small])),
+    SmallGtBig = lists:flatten(
+		   io_lib:format("~f > ~p",[Small,Big])),
+    SmallLtBig = lists:flatten(
+		   io_lib:format("~f < ~p",[Small,Big])),
+    cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig).
+
+cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig) ->
+    {_,_,_,true} = {Big,Small,BigGtSmall,
 		    Big > Small},
-    {_,_,_,false} = {Big,Small,SmallBig,
+    {_,_,_,false} = {Big,Small,BigLtSmall,
 		     Big < Small},
-    {BigSmall, SmallBig}.
+    {_,_,_,false} = {Big,Small,SmallGtBig,
+		     Small > Big},
+    {_,_,_,true} = {Big,Small,SmallLtBig,
+		    Small < Big}.
 
 id(I) -> I.
     
-- 
cgit v1.2.3


From 3b62e52f16ef72ce4224a61dc9e6bc7ab53234a1 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Mon, 8 Aug 2011 18:48:16 +0200
Subject: Optimize comparison of huge floats and smaller bignums

---
 erts/emulator/beam/utils.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 5822b2e1d9..f296ccbadd 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -2686,9 +2686,12 @@ tailrecur_ne:
 		    && (f2.fd > (double) (MIN_SMALL - 1))) {
 		// Float is a Sint
 		j = big_sign(aw) ? -1 : 1;
-	    } else if ( (pow(2.0,(big_arity(aw)-1.0)*D_EXP)-1.0) > fabs(f2.fd)) {
-		// If bignum size shows that it is bigger or smaller than the float
+	    } else if ((pow(2.0,(big_arity(aw)-1.0)*D_EXP)-1.0) > fabs(f2.fd)) {
+		// If bignum size shows that it is bigger than the abs float
 		j = big_sign(aw) ? -1 : 1;
+	    } else if ((pow(2.0,(big_arity(aw))*D_EXP)-1.0) < fabs(f2.fd)) {
+		// If bignum size shows that it is smaller than the abs float
+		j = f2.fd < 0 ? 1 : -1;
 	    } else if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
 		// Float is within the no loss limit
 		if (big_to_double(aw, &f1.fd) < 0) {
@@ -2723,9 +2726,12 @@ tailrecur_ne:
 		    && (f1.fd > (double) (MIN_SMALL - 1))) { // Float is a Sint
 		j = big_sign(bw) ? 1 : -1;
 	    } else if ((pow(2.0, (big_arity(bw) - 1.0) * D_EXP) - 1.0) > fabs(f1.fd)) {
-		// If bignum size shows that it is bigger than the float
+		// If bignum size shows that it is bigger than the abs float
 		j = big_sign(bw) ? 1 : -1;
-	    } else if (f1.fd < MAX_LOSSLESS_FLOAT && f1.fd >MIN_LOSSLESS_FLOAT) {
+	    } else if ((pow(2.0,(big_arity(bw))*D_EXP)-1.0) < fabs(f1.fd)) {
+		// If bignum size shows that it is smaller than the abs float
+		j = f1.fd < 0 ? -1 : 1;
+	    } else if (f1.fd < MAX_LOSSLESS_FLOAT && f1.fd > MIN_LOSSLESS_FLOAT) {
 		// Float is within the no loss limit
 		if (big_to_double(bw, &f2.fd) < 0) {
 		    j = big_sign(bw) ? 1 : -1;
-- 
cgit v1.2.3


From 3dc379948b1d7ce6c4f35f56df937603a6013f24 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Mon, 3 Oct 2011 19:08:20 +0200
Subject: Add tests for equality checking

Test for checking equality on all float exponents
Test in equality for all comparison tests
---
 erts/emulator/test/float_SUITE.erl | 41 ++++++++++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 6 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/test/float_SUITE.erl b/erts/emulator/test/float_SUITE.erl
index bf0fbc70bc..46466427c5 100644
--- a/erts/emulator/test/float_SUITE.erl
+++ b/erts/emulator/test/float_SUITE.erl
@@ -198,13 +198,19 @@ cmp_integer(_Config) ->
 cmp_bignum(_Config) ->
     span_cmp((1 bsl 58) - 1.0),%% Smallest bignum float
 
-    %% Test I to I+1 bignum segment overflow
+    %% Test when the big num goes from I to I+1 in size
     [span_cmp((1 bsl (32*I)) - 1.0) || I <- lists:seq(2,30)],
 
+    %% Test bignum greater then largest float
     cmp((1 bsl (64*16)) - 1, (1 bsl (64*15)) * 1.0),
+    %% Test when num is much larger then float
     [cmp((1 bsl (32*I)) - 1, (1 bsl (32*(I-2))) * 1.0) || I <- lists:seq(3,30)],
+    %% Test when float is much larger than num
     [cmp((1 bsl (64*15)) * 1.0, (1 bsl (32*(I)))) || I <- lists:seq(1,29)],
-    ok.
+
+    %% Test that all int == float works as they should
+    [true = 1 bsl N == (1 bsl N)*1.0 || N <- lists:seq(0, 1023)],
+    [true = (1 bsl N)*-1 == (1 bsl N)*-1.0 || N <- lists:seq(0, 1023)].
 
 span_cmp(Axis) ->
     span_cmp(Axis, 25).
@@ -212,6 +218,14 @@ span_cmp(Axis, Length) ->
     span_cmp(Axis, round(Axis) bsr 52, Length).
 span_cmp(Axis, Incr, Length) ->
     [span_cmp(Axis, Incr, Length, 1 bsl (1 bsl I)) || I <- lists:seq(0,6)].
+%% This function creates tests around number axis. Both <, > and == is tested
+%% for both negative and positive numbers.
+%%
+%% Axis: The number around which to do the tests eg. (1 bsl 58) - 1.0
+%% Incr: How much to increment the test numbers inbetween each test.
+%% Length: Length/2 is the number of Incr away from Axis to test on the
+%%         negative and positive plane.
+%% Diff: How much the float and int should differ when comparing
 span_cmp(Axis, Incr, Length, Diff) ->
     [begin
 	 cmp(round(Axis*-1.0)+Diff+I*Incr,Axis*-1.0+I*Incr),
@@ -227,23 +241,34 @@ cmp(Big,Small) when is_float(Big) ->
 		 io_lib:format("~f > ~p",[Big,Small])),
     BigLtSmall = lists:flatten(
 		 io_lib:format("~f < ~p",[Big,Small])),
+    BigEqSmall = lists:flatten(
+		 io_lib:format("~f == ~p",[Big,Small])),
     SmallGtBig = lists:flatten(
 		   io_lib:format("~p > ~f",[Small,Big])),
     SmallLtBig = lists:flatten(
 		   io_lib:format("~p < ~f",[Small,Big])),
-    cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig);
+    SmallEqBig = lists:flatten(
+		   io_lib:format("~p == ~f",[Small,Big])),
+    cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig,
+	SmallEqBig,BigEqSmall);
 cmp(Big,Small) when is_float(Small) ->
     BigGtSmall = lists:flatten(
 		   io_lib:format("~p > ~f",[Big,Small])),
     BigLtSmall = lists:flatten(
 		   io_lib:format("~p < ~f",[Big,Small])),
+    BigEqSmall = lists:flatten(
+		   io_lib:format("~p == ~f",[Big,Small])),
     SmallGtBig = lists:flatten(
 		   io_lib:format("~f > ~p",[Small,Big])),
     SmallLtBig = lists:flatten(
 		   io_lib:format("~f < ~p",[Small,Big])),
-    cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig).
+    SmallEqBig = lists:flatten(
+		   io_lib:format("~f == ~p",[Small,Big])),
+    cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig,
+	SmallEqBig,BigEqSmall).
 
-cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig) ->
+cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig,
+    SmallEqBig,BigEqSmall) ->
     {_,_,_,true} = {Big,Small,BigGtSmall,
 		    Big > Small},
     {_,_,_,false} = {Big,Small,BigLtSmall,
@@ -251,7 +276,11 @@ cmp(Big,Small,BigGtSmall,BigLtSmall,SmallGtBig,SmallLtBig) ->
     {_,_,_,false} = {Big,Small,SmallGtBig,
 		     Small > Big},
     {_,_,_,true} = {Big,Small,SmallLtBig,
-		    Small < Big}.
+		    Small < Big},
+    {_,_,_,false} = {Big,Small,SmallEqBig,
+		     Small == Big},
+    {_,_,_,false} = {Big,Small,BigEqSmall,
+		     Big == Small}.
 
 id(I) -> I.
     
-- 
cgit v1.2.3


From f82d49ab3e65f52fd7b6dd7d9e8913543b7a1375 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Mon, 3 Oct 2011 19:09:55 +0200
Subject: Do small optimisation on platforms with 32 bit Eterm

On 32 bit we know that a comparison with a lossfull double
and a short will always give the float is being superior.
So therefore we only have to check the sign on the double.
---
 erts/emulator/beam/utils.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'erts')

diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index f296ccbadd..825cb140b2 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -2670,6 +2670,7 @@ tailrecur_ne:
 		// Float is within the no loss limit
 		f1.fd = signed_val(aw);
 		j = float_comp(f1.fd, f2.fd);
+#if ERTS_SIZEOF_ETERM == 8
 	    } else if (f2.fd > (double) (MAX_SMALL + 1)) {
 		// Float is a positive bignum, i.e. bigger
 		j = -1;
@@ -2679,6 +2680,12 @@ tailrecur_ne:
 	    } else { // Float is a Sint but less precise
 		j = signed_val(aw) - (Sint) f2.fd;
 	    }
+#else
+	    } else {
+		// If float is positive it is bigger than small
+		j = (f2.fd > 0.0) ? -1 : 1;
+	    }
+#endif // ERTS_SIZEOF_ETERM == 8
 	    break;
 	case BIG_FLOAT:
 	    GET_DOUBLE(bw, f2);
@@ -2710,6 +2717,7 @@ tailrecur_ne:
 		// Float is within the no loss limit
 		f2.fd = signed_val(bw);
 		j = float_comp(f1.fd, f2.fd);
+#if ERTS_SIZEOF_ETERM == 8
 	    } else if (f1.fd > (double) (MAX_SMALL + 1)) {
 		// Float is a positive bignum, i.e. bigger
 		j = 1;
@@ -2719,6 +2727,12 @@ tailrecur_ne:
 	    } else { // Float is a Sint but less precise it
 		j = (Sint) f1.fd - signed_val(bw);
 	    }
+#else
+	    } else {
+		// If float is positive it is bigger than small
+		j = (f1.fd > 0.0) ? 1 : -1;
+	    }
+#endif // ERTS_SIZEOF_ETERM == 8
 	    break;
 	case FLOAT_BIG:
 	    GET_DOUBLE(aw, f1);
-- 
cgit v1.2.3


From a0f45f929092c8d3355a8604780a4f4df49f3759 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 12 Oct 2011 12:27:08 +0200
Subject: make_preload: Don't output a C comment start inside a comment

We already avoid outputting a comment terminator ("*/") inside
a comment to avoid causing a syntax error. Also avoid outputting
the start of a comment ("/*") to avoid causing a compiler warning.

Noticed-by: Tuncer Ayaz
---
 erts/emulator/utils/make_preload | 1 +
 1 file changed, 1 insertion(+)

(limited to 'erts')

diff --git a/erts/emulator/utils/make_preload b/erts/emulator/utils/make_preload
index d0671e998d..d22f08f993 100755
--- a/erts/emulator/utils/make_preload
+++ b/erts/emulator/utils/make_preload
@@ -88,6 +88,7 @@ foreach $file (@ARGV) {
 	print "unsigned char preloaded_$module", "[] = {\n";
 	for ($i = 0; $i < length($_); $i++) {
 	    if ($i % 8 == 0 && $comment ne '') {
+		$comment =~ s@/\*@..@g; # Comment start -- avoid warning.
 		$comment =~ s@\*/@..@g; # Comment terminator.
 		print " /* $comment */\n  ";
 		$comment = '';
-- 
cgit v1.2.3


From 34db76765561487e526fe66d3d19ecf3b3fb9dc8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 30 Aug 2011 11:51:11 +0200
Subject: Allow noncharacter code points in unicode encoding and decoding

The two noncharacter code points 16#FFFE and 16#FFFF were not
allowed to be encoded or decoded using the unicode module or
bit syntax. That causes an inconsistency, since the noncharacters
16#FDD0 to 16#FDEF could be encoded/decoded.

There is two ways to fix that inconsistency.

We have chosen to allow 16#FFFE and 16#FFFF to be encoded and
decoded, because the noncharacters could be useful internally
within an application and it will make encoding and decoding
slightly faster.

Reported-by: Alisdair Sullivan
---
 erts/emulator/beam/beam_emu.c       |  7 +++----
 erts/emulator/beam/erl_bits.c       | 12 +++---------
 erts/emulator/beam/erl_unicode.c    | 24 +++++-------------------
 erts/emulator/test/bs_utf_SUITE.erl | 12 +++---------
 4 files changed, 14 insertions(+), 41 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 4b5b5cbdaa..62a14dbacf 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -3967,8 +3967,7 @@ void process_main(void)
       * too big numbers).
       */
      if (is_not_small(val) || val > make_small(0x10FFFFUL) ||
-	 (make_small(0xD800UL) <= val && val <= make_small(0xDFFFUL)) ||
-	 val == make_small(0xFFFEUL) || val == make_small(0xFFFFUL)) {
+	 (make_small(0xD800UL) <= val && val <= make_small(0xDFFFUL))) {
 	 goto badarg;
      }
      Next(2);
@@ -3987,8 +3986,8 @@ void process_main(void)
       * the valid range).
       */
      if (is_not_small(tmp_arg1) || tmp_arg1 > make_small(0x10FFFFUL) ||
-	 (make_small(0xD800UL) <= tmp_arg1 && tmp_arg1 <= make_small(0xDFFFUL)) ||
-	 tmp_arg1 == make_small(0xFFFEUL) || tmp_arg1 == make_small(0xFFFFUL)) {
+	 (make_small(0xD800UL) <= tmp_arg1 &&
+	  tmp_arg1 <= make_small(0xDFFFUL))) {
 	 ErlBinMatchBuffer *mb = ms_matchbuffer(tmp_arg2);
 
 	 mb->offset -= 32;
diff --git a/erts/emulator/beam/erl_bits.c b/erts/emulator/beam/erl_bits.c
index 326a5c136b..6f7309f493 100644
--- a/erts/emulator/beam/erl_bits.c
+++ b/erts/emulator/beam/erl_bits.c
@@ -845,8 +845,7 @@ erts_bs_put_utf8(ERL_BITS_PROTO_1(Eterm arg))
 	dst[1] = 0x80 | (val & 0x3F);
 	num_bits = 16;
     } else if (val < 0x10000UL) {
-	if ((0xD800 <= val && val <= 0xDFFF) ||
-	    val == 0xFFFE || val == 0xFFFF) {
+	if (0xD800 <= val && val <= 0xDFFF) {
 	    return 0;
 	}
 	dst[0] = 0xE0 | (val >> 12);
@@ -886,8 +885,7 @@ erts_bs_put_utf16(ERL_BITS_PROTO_2(Eterm arg, Uint flags))
 	return 0;
     }
     val = unsigned_val(arg);
-    if (val > 0x10FFFF || (0xD800 <= val && val <= 0xDFFF) ||
-	val == 0xFFFE || val == 0xFFFF) {
+    if (val > 0x10FFFF || (0xD800 <= val && val <= 0xDFFF)) {
 	return 0;
     }
 
@@ -1652,8 +1650,7 @@ erts_bs_get_utf8(ErlBinMatchBuffer* mb)
 	    return THE_NON_VALUE;
 	}
 	result = (((result << 6) + a) << 6) + b - (Eterm) 0x000E2080UL;
-	if ((0xD800 <= result && result <= 0xDFFF) ||
-	    result == 0xFFFE || result == 0xFFFF) {
+	if (0xD800 <= result && result <= 0xDFFF) {
 	    return THE_NON_VALUE;
 	}
 	mb->offset += 24;
@@ -1723,9 +1720,6 @@ erts_bs_get_utf16(ErlBinMatchBuffer* mb, Uint flags)
 	w1 = (src[0] << 8) | src[1];
     }
     if (w1 < 0xD800 || w1 > 0xDFFF) {
-	if (w1 == 0xFFFE || w1 == 0xFFFF) {
-	    return THE_NON_VALUE;
-	}
 	mb->offset += 16;
 	return make_small(w1);
     } else if (w1 > 0xDBFF) {
diff --git a/erts/emulator/beam/erl_unicode.c b/erts/emulator/beam/erl_unicode.c
index 158eb361a4..bd5f3cc4c1 100644
--- a/erts/emulator/beam/erl_unicode.c
+++ b/erts/emulator/beam/erl_unicode.c
@@ -348,12 +348,6 @@ static int copy_utf8_bin(byte *target, byte *source, Uint size,
 		return copied;
 	    }
 
-	    if (((*source) == 0xEF) && (source[1] == 0xBF) &&
-		((source[2] == 0xBE) || (source[2] == 0xBF))) {
-		*err_pos = source;
-		return copied;
-	    }
-		
 	    *(target++) = *(source++);
 	    *(target++) = *(source++);
 	    *(target++) = *(source++);
@@ -714,9 +708,8 @@ L_Again:   /* Restart with sublist, old listend was pushed on stack */
 			    target[(*pos)++] = (((byte) (x & 0x3F)) | 
 						((byte) 0x80));
 			} else if (x < 0x10000) {
-			    if ((x >= 0xD800 && x <= 0xDFFF) ||
-				(x == 0xFFFE) ||
-				(x == 0xFFFF)) { /* Invalid unicode range */
+			    if (x >= 0xD800 && x <= 0xDFFF) {
+				/* Invalid unicode range */
 				*err = 1;
 				goto done;
 			    }
@@ -1230,10 +1223,6 @@ int erts_analyze_utf8(byte *source, Uint size,
 		((source[1] & 0x20) != 0)) {
 		return ERTS_UTF8_ERROR;
 	    }
-	    if (((*source) == 0xEF) && (source[1] == 0xBF) &&
-		((source[2] == 0xBE) || (source[2] == 0xBF))) {
-		return ERTS_UTF8_ERROR;
-	    }
 	    source += 3;
 	    size -= 3;
 	} else if (((*source) & ((byte) 0xF8)) == 0xF0) {
@@ -2166,9 +2155,8 @@ L_Again:   /* Restart with sublist, old listend was pushed on stack */
 			    } else if (x < 0x800) {
 				need += 2;
 			    } else if (x < 0x10000) {
-				if ((x >= 0xD800 && x <= 0xDFFF) ||
-				    (x == 0xFFFE) ||
-				    (x == 0xFFFF)) { /* Invalid unicode range */
+				if (x >= 0xD800 && x <= 0xDFFF) {
+				    /* Invalid unicode range */
 				    DESTROY_ESTACK(stack);
 				    return ((Sint) -1);
 				}
@@ -2314,9 +2302,7 @@ L_Again:   /* Restart with sublist, old listend was pushed on stack */
 				*p++ = (((byte) (x & 0x3F)) | 
 					((byte) 0x80));
 			    } else if (x < 0x10000) {
-				ASSERT(!((x >= 0xD800 && x <= 0xDFFF) ||
-					 (x == 0xFFFE) ||
-					 (x == 0xFFFF)));
+				ASSERT(!(x >= 0xD800 && x <= 0xDFFF));
 				*p++ = (((byte) (x >> 12)) | 
 					((byte) 0xE0));
 				*p++ = ((((byte) (x >> 6)) & 0x3F)  | 
diff --git a/erts/emulator/test/bs_utf_SUITE.erl b/erts/emulator/test/bs_utf_SUITE.erl
index 72c656c400..4ab7d674a6 100644
--- a/erts/emulator/test/bs_utf_SUITE.erl
+++ b/erts/emulator/test/bs_utf_SUITE.erl
@@ -64,8 +64,7 @@ end_per_group(_GroupName, Config) ->
 
 utf8_roundtrip(Config) when is_list(Config) ->
     ?line utf8_roundtrip(0, 16#D7FF),
-    ?line utf8_roundtrip(16#E000, 16#FFFD),
-    ?line utf8_roundtrip(16#10000, 16#10FFFF),
+    ?line utf8_roundtrip(16#E000, 16#10FFFF),
     ok.
 
 utf8_roundtrip(First, Last) when First =< Last ->
@@ -91,8 +90,7 @@ utf16_roundtrip(Config) when is_list(Config) ->
 
 do_utf16_roundtrip(Fun) ->
     do_utf16_roundtrip(0, 16#D7FF, Fun),
-    do_utf16_roundtrip(16#E000, 16#FFFD, Fun),
-    do_utf16_roundtrip(16#10000, 16#10FFFF, Fun).
+    do_utf16_roundtrip(16#E000, 16#10FFFF, Fun).
 
 do_utf16_roundtrip(First, Last, Fun) when First =< Last ->
     Fun(First),
@@ -129,8 +127,7 @@ utf32_roundtrip(Config) when is_list(Config) ->
 
 do_utf32_roundtrip(Fun) ->
     do_utf32_roundtrip(0, 16#D7FF, Fun),
-    do_utf32_roundtrip(16#E000, 16#FFFD, Fun),
-    do_utf32_roundtrip(16#10000, 16#10FFFF, Fun).
+    do_utf32_roundtrip(16#E000, 16#10FFFF, Fun).
 
 do_utf32_roundtrip(First, Last, Fun) when First =< Last ->
     Fun(First),
@@ -158,7 +155,6 @@ utf32_little_roundtrip(Char) ->
 utf8_illegal_sequences(Config) when is_list(Config) ->
     ?line fail_range(16#10FFFF+1, 16#10FFFF+512), %Too large.
     ?line fail_range(16#D800, 16#DFFF),		%Reserved for UTF-16.
-    ?line fail_range(16#FFFE, 16#FFFF),		%Non-characters.
 
     %% Illegal first character.
     ?line [fail(<<I,16#8F,16#8F,16#8F>>) || I <- lists:seq(16#80, 16#BF)],
@@ -251,7 +247,6 @@ fail_1(_) -> ok.
 utf16_illegal_sequences(Config) when is_list(Config) ->
     ?line utf16_fail_range(16#10FFFF+1, 16#10FFFF+512), %Too large.
     ?line utf16_fail_range(16#D800, 16#DFFF),		%Reserved for UTF-16.
-    ?line utf16_fail_range(16#FFFE, 16#FFFF),		%Non-characters.
 
     ?line lonely_hi_surrogate(16#D800, 16#DFFF),
     ?line leading_lo_surrogate(16#DC00, 16#DFFF),
@@ -300,7 +295,6 @@ leading_lo_surrogate(_, _, _) -> ok.
 utf32_illegal_sequences(Config) when is_list(Config) ->
     ?line utf32_fail_range(16#10FFFF+1, 16#10FFFF+512), %Too large.
     ?line utf32_fail_range(16#D800, 16#DFFF),		%Reserved for UTF-16.
-    ?line utf32_fail_range(16#FFFE, 16#FFFF),		%Non-characters.
     ?line utf32_fail_range(-100, -1),
     ok.
 
-- 
cgit v1.2.3


From 6a37976806f9a0998d0970c17f0e176b6e19bdad Mon Sep 17 00:00:00 2001
From: Hans Bolinder <hasse@erlang.org>
Date: Thu, 6 Oct 2011 15:08:09 +0200
Subject: Correct the docs

---
 erts/doc/src/erl.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/doc/src/erl.xml b/erts/doc/src/erl.xml
index 8502ceadd2..39c79a29df 100644
--- a/erts/doc/src/erl.xml
+++ b/erts/doc/src/erl.xml
@@ -994,7 +994,7 @@
           the <c><![CDATA[-extra]]></c> section, i.e. the end of the command line
           following after an <c><![CDATA[-extra]]></c> flag.</p>
       </item>
-      <tag><c><![CDATA[ERL_ZFLAGS]]></c>and <c><![CDATA[ERL_FLAGS]]></c></tag>
+      <tag><c><![CDATA[ERL_ZFLAGS]]></c> and <c><![CDATA[ERL_FLAGS]]></c></tag>
       <item>
         <p>The content of these environment variables will be added to the
           end of the command line for <c><![CDATA[erl]]></c>.</p>
-- 
cgit v1.2.3


From d76f146406eff8650969253708291c98a4110351 Mon Sep 17 00:00:00 2001
From: Tuncer Ayaz <tuncer.ayaz@gmail.com>
Date: Fri, 13 May 2011 17:27:29 +0200
Subject: erts: convert variadic nif funs into inline funs

---
 erts/emulator/beam/erl_nif_api_funcs.h | 194 +++++++++++++++++++++++++++++++++
 1 file changed, 194 insertions(+)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_nif_api_funcs.h b/erts/emulator/beam/erl_nif_api_funcs.h
index 18f2c022eb..0753c56c9b 100644
--- a/erts/emulator/beam/erl_nif_api_funcs.h
+++ b/erts/emulator/beam/erl_nif_api_funcs.h
@@ -266,6 +266,195 @@ ERL_NIF_API_FUNC_DECL(int,enif_is_number,(ErlNifEnv*, ERL_NIF_TERM term));
 */
 #endif
 
+
+#if defined(__GNUC__)
+
+#  define ERL_NIF_INLINE __inline__
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple1(ErlNifEnv* env,
+						    ERL_NIF_TERM e1)
+{
+    return enif_make_tuple(env, 1, e1);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple2(ErlNifEnv* env,
+						    ERL_NIF_TERM e1,
+						    ERL_NIF_TERM e2)
+{
+    return enif_make_tuple(env, 2, e1, e2);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple3(ErlNifEnv* env,
+						    ERL_NIF_TERM e1,
+						    ERL_NIF_TERM e2,
+						    ERL_NIF_TERM e3)
+{
+    return enif_make_tuple(env, 3, e1, e2, e3);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple4(ErlNifEnv* env,
+						    ERL_NIF_TERM e1,
+						    ERL_NIF_TERM e2,
+						    ERL_NIF_TERM e3,
+						    ERL_NIF_TERM e4)
+{
+    return enif_make_tuple(env, 4, e1, e2, e3, e4);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple5(ErlNifEnv* env,
+						    ERL_NIF_TERM e1,
+						    ERL_NIF_TERM e2,
+						    ERL_NIF_TERM e3,
+						    ERL_NIF_TERM e4,
+						    ERL_NIF_TERM e5)
+{
+    return enif_make_tuple(env, 5, e1, e2, e3, e4, e5);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple6(ErlNifEnv* env,
+						    ERL_NIF_TERM e1,
+						    ERL_NIF_TERM e2,
+						    ERL_NIF_TERM e3,
+						    ERL_NIF_TERM e4,
+						    ERL_NIF_TERM e5,
+						    ERL_NIF_TERM e6)
+{
+    return enif_make_tuple(env, 6, e1, e2, e3, e4, e5, e6);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple7(ErlNifEnv* env,
+						    ERL_NIF_TERM e1,
+						    ERL_NIF_TERM e2,
+						    ERL_NIF_TERM e3,
+						    ERL_NIF_TERM e4,
+						    ERL_NIF_TERM e5,
+						    ERL_NIF_TERM e6,
+						    ERL_NIF_TERM e7)
+{
+    return enif_make_tuple(env, 7, e1, e2, e3, e4, e5, e6, e7);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple8(ErlNifEnv* env,
+						    ERL_NIF_TERM e1,
+						    ERL_NIF_TERM e2,
+						    ERL_NIF_TERM e3,
+						    ERL_NIF_TERM e4,
+						    ERL_NIF_TERM e5,
+						    ERL_NIF_TERM e6,
+						    ERL_NIF_TERM e7,
+						    ERL_NIF_TERM e8)
+{
+    return enif_make_tuple(env, 8, e1, e2, e3, e4, e5, e6, e7, e8);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_tuple9(ErlNifEnv* env,
+						    ERL_NIF_TERM e1,
+						    ERL_NIF_TERM e2,
+						    ERL_NIF_TERM e3,
+						    ERL_NIF_TERM e4,
+						    ERL_NIF_TERM e5,
+						    ERL_NIF_TERM e6,
+						    ERL_NIF_TERM e7,
+						    ERL_NIF_TERM e8,
+						    ERL_NIF_TERM e9)
+{
+    return enif_make_tuple(env, 9, e1, e2, e3, e4, e5, e6, e7, e8, e9);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list1(ErlNifEnv* env,
+						   ERL_NIF_TERM e1)
+{
+    return enif_make_list(env, 1, e1);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list2(ErlNifEnv* env,
+						   ERL_NIF_TERM e1,
+						   ERL_NIF_TERM e2)
+{
+    return enif_make_list(env, 2, e1, e2);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list3(ErlNifEnv* env,
+						   ERL_NIF_TERM e1,
+						   ERL_NIF_TERM e2,
+						   ERL_NIF_TERM e3)
+{
+    return enif_make_list(env, 3, e1, e2, e3);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list4(ErlNifEnv* env,
+						   ERL_NIF_TERM e1,
+						   ERL_NIF_TERM e2,
+						   ERL_NIF_TERM e3,
+						   ERL_NIF_TERM e4)
+{
+    return enif_make_list(env, 4, e1, e2, e3, e4);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list5(ErlNifEnv* env,
+						   ERL_NIF_TERM e1,
+						   ERL_NIF_TERM e2,
+						   ERL_NIF_TERM e3,
+						   ERL_NIF_TERM e4,
+						   ERL_NIF_TERM e5)
+{
+    return enif_make_list(env, 5, e1, e2, e3, e4, e5);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list6(ErlNifEnv* env,
+						   ERL_NIF_TERM e1,
+						   ERL_NIF_TERM e2,
+						   ERL_NIF_TERM e3,
+						   ERL_NIF_TERM e4,
+						   ERL_NIF_TERM e5,
+						   ERL_NIF_TERM e6)
+{
+    return enif_make_list(env, 6, e1, e2, e3, e4, e5, e6);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list7(ErlNifEnv* env,
+						   ERL_NIF_TERM e1,
+						   ERL_NIF_TERM e2,
+						   ERL_NIF_TERM e3,
+						   ERL_NIF_TERM e4,
+						   ERL_NIF_TERM e5,
+						   ERL_NIF_TERM e6,
+						   ERL_NIF_TERM e7)
+{
+    return enif_make_list(env, 7, e1, e2, e3, e4, e5, e6, e7);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list8(ErlNifEnv* env,
+						   ERL_NIF_TERM e1,
+						   ERL_NIF_TERM e2,
+						   ERL_NIF_TERM e3,
+						   ERL_NIF_TERM e4,
+						   ERL_NIF_TERM e5,
+						   ERL_NIF_TERM e6,
+						   ERL_NIF_TERM e7,
+						   ERL_NIF_TERM e8)
+{
+    return enif_make_list(env, 8, e1, e2, e3, e4, e5, e6, e7, e8);
+}
+
+static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list9(ErlNifEnv* env,
+						   ERL_NIF_TERM e1,
+						   ERL_NIF_TERM e2,
+						   ERL_NIF_TERM e3,
+						   ERL_NIF_TERM e4,
+						   ERL_NIF_TERM e5,
+						   ERL_NIF_TERM e6,
+						   ERL_NIF_TERM e7,
+						   ERL_NIF_TERM e8,
+						   ERL_NIF_TERM e9)
+{
+    return enif_make_list(env, 9, e1, e2, e3, e4, e5, e6, e7, e8, e9);
+}
+
+#  undef ERL_NIF_INLINE
+
+#else
+
 #ifndef enif_make_list1
 #  define enif_make_list1(ENV,E1) enif_make_list(ENV,1,E1)
 #  define enif_make_list2(ENV,E1,E2) enif_make_list(ENV,2,E1,E2)
@@ -285,6 +474,11 @@ ERL_NIF_API_FUNC_DECL(int,enif_is_number,(ErlNifEnv*, ERL_NIF_TERM term));
 #  define enif_make_tuple7(ENV,E1,E2,E3,E4,E5,E6,E7) enif_make_tuple(ENV,7,E1,E2,E3,E4,E5,E6,E7)
 #  define enif_make_tuple8(ENV,E1,E2,E3,E4,E5,E6,E7,E8) enif_make_tuple(ENV,8,E1,E2,E3,E4,E5,E6,E7,E8)
 #  define enif_make_tuple9(ENV,E1,E2,E3,E4,E5,E6,E7,E8,E9) enif_make_tuple(ENV,9,E1,E2,E3,E4,E5,E6,E7,E8,E9)
+#endif
+
+#endif /* defined(__GNUC__) */
+
+#ifndef enif_make_pid
 
 #  define enif_make_pid(ENV, PID) ((const ERL_NIF_TERM)((PID)->pid))
 
-- 
cgit v1.2.3


From ff1fb99fb54ef93cd778366993a448fde2b44d82 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Wed, 19 Oct 2011 16:28:10 +0200
Subject: Fix erroneous merge resolution

Previously removed code erroneously reappeared in a merge to the master
branch (ec36499d7e329b4dc69a1a3be3422eac7907c260).
---
 erts/aclocal.m4 | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'erts')

diff --git a/erts/aclocal.m4 b/erts/aclocal.m4
index 27f643921e..bd228a2d1f 100644
--- a/erts/aclocal.m4
+++ b/erts/aclocal.m4
@@ -1366,9 +1366,6 @@ case "$GCC-$host_cpu" in
     ;;
 esac
 
-test $enable_ethread_pre_pentium4_compatibility = yes &&
-  AC_DEFINE(ETHR_PRE_PENTIUM4_COMPAT, 1, [Define if you want compatibility with x86 processors before pentium4.])
-
 AC_DEFINE(ETHR_HAVE_ETHREAD_DEFINES, 1, \
 [Define if you have all ethread defines])
 
-- 
cgit v1.2.3


From 4db2084d5742e54a35da5326ea0d20eac3a3f2c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 26 Aug 2011 10:18:45 +0200
Subject: erts/nt_SUITE: Eliminate use of deprecated regexp module

---
 erts/test/nt_SUITE.erl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'erts')

diff --git a/erts/test/nt_SUITE.erl b/erts/test/nt_SUITE.erl
index 7d6da28ad6..f9bd15a0ce 100644
--- a/erts/test/nt_SUITE.erl
+++ b/erts/test/nt_SUITE.erl
@@ -490,12 +490,12 @@ middleman(Waitfor) ->
 match_event(_X, []) ->
     nomatch;
 match_event({Time,Cat,Fac,Sev,Mes},[{Pid,Ref,{Cat,Fac,Sev,MesRE}} | Tail]) ->
-    case regexp:match(Mes,MesRE) of
-	{match,_,_} ->
+    case re:run(Mes,MesRE,[{capture,none}]) of
+	match ->
 	    %%io:format("Match!~n"),
 	    {ok,{Pid,Ref,Time,Mes},Tail};
-	_Z ->
-	    %%io:format("No match (~p)~n",[_Z]),
+	nomatch ->
+	    %%io:format("No match~n"),
 	    case match_event({Time,Cat,Fac,Sev,Mes},Tail) of
 		{ok,X,Rest} ->
 		    {ok,X,[{Pid,Ref,{Cat,Fac,Sev,MesRE}} | Rest]};
-- 
cgit v1.2.3


From 14417cb51972e0116a89ab546933e2073c459bf1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 26 Aug 2011 09:33:26 +0200
Subject: erts/z_SUITE: Eliminate use of deprecated regexp module

---
 erts/test/z_SUITE.erl | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

(limited to 'erts')

diff --git a/erts/test/z_SUITE.erl b/erts/test/z_SUITE.erl
index 8fceab32a6..482ecb8fba 100644
--- a/erts/test/z_SUITE.erl
+++ b/erts/test/z_SUITE.erl
@@ -166,9 +166,12 @@ core_search_conf(RunByTS, DBTop, XDir) ->
 
 file_inspect(#core_search_conf{file = File}, Core) ->
     FRes0 = os:cmd(File ++ " " ++ Core),
-    FRes = case regexp:match(FRes0, Core) of
-	       {match, S, E} ->
+    FRes = case string:str(FRes0, Core) of
+	       0 ->
+		   FRes0;
+	       S ->
 		   L = length(FRes0),
+		   E = length(Core),
 		   case S of
 		       1 ->
 			   lists:sublist(FRes0, E+1, L+1);
@@ -178,19 +181,13 @@ file_inspect(#core_search_conf{file = File}, Core) ->
 			       " "
 			       ++
 			       lists:sublist(FRes0, E+1, L+1)
-		   end;
-	       _ -> FRes0
+		   end
 	   end,
-    case regexp:match(FRes, "[Tt][Ee][Xx][Tt]") of
+    case re:run(FRes, "text|ascii", [caseless,{capture,none}]) of
+	match ->
+	    not_a_core;
 	nomatch ->
-	    case regexp:match(FRes, "[Aa][Ss][Cc][Ii][Ii]") of
-		nomatch ->
-		    probably_a_core;
-		_ ->
-		    not_a_core
-	    end;
-	_ ->
-	    not_a_core
+	    probably_a_core
     end.
 
 mk_readable(F) ->
-- 
cgit v1.2.3


From c8053ef7b602e8c47b6fa8919b9bbff996d3a81b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 20 Oct 2011 14:17:52 +0200
Subject: Remove unused */doc/src/make.dep files

These dependency files was once used when building the documentation,
but are no longer needed.
---
 erts/doc/src/make.dep | 32 --------------------------------
 1 file changed, 32 deletions(-)
 delete mode 100644 erts/doc/src/make.dep

(limited to 'erts')

diff --git a/erts/doc/src/make.dep b/erts/doc/src/make.dep
deleted file mode 100644
index 98bac78235..0000000000
--- a/erts/doc/src/make.dep
+++ /dev/null
@@ -1,32 +0,0 @@
-# ----------------------------------------------------
-# >>>> Do not edit this file <<<<
-# This file was automaticly generated by
-# /home/gandalf/otp/bin/docdepend
-# ----------------------------------------------------
-
-
-# ----------------------------------------------------
-# TeX files that the DVI file depend on
-# ----------------------------------------------------
-
-book.dvi: absform.tex alt_dist.tex book.tex crash_dump.tex \
-		driver.tex driver_entry.tex epmd.tex erl.tex \
-		erl_dist_protocol.tex erl_driver.tex erl_ext_dist.tex \
-		erl_prim_loader.tex erl_set_memory_block.tex \
-		erlang.tex erlc.tex erlsrv.tex erts_alloc.tex \
-		escript.tex inet_cfg.tex init.tex match_spec.tex \
-		part.tex ref_man.tex run_erl.tex start.tex \
-		start_erl.tex tty.tex werl.tex zlib.tex
-
-# ----------------------------------------------------
-# Source inlined when transforming from source to LaTeX
-# ----------------------------------------------------
-
-book.tex: ref_man.xml
-
-# ----------------------------------------------------
-# Pictures that the DVI file depend on
-# ----------------------------------------------------
-
-book.dvi: erl_ext_fig.ps
-
-- 
cgit v1.2.3


From 7738a364192d95e82e45349b99dd177c660fb314 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Thu, 27 Oct 2011 15:48:19 +0200
Subject: erts: Make erl_nif.h compile with gcc on Windows

and some added comments
---
 erts/emulator/beam/erl_nif_api_funcs.h | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_nif_api_funcs.h b/erts/emulator/beam/erl_nif_api_funcs.h
index 0753c56c9b..6396af09d0 100644
--- a/erts/emulator/beam/erl_nif_api_funcs.h
+++ b/erts/emulator/beam/erl_nif_api_funcs.h
@@ -267,7 +267,11 @@ ERL_NIF_API_FUNC_DECL(int,enif_is_number,(ErlNifEnv*, ERL_NIF_TERM term));
 #endif
 
 
-#if defined(__GNUC__)
+#if defined(__GNUC__) && !(defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_))
+
+/* Inline functions for compile time type checking of arguments to
+   variadic functions.
+*/
 
 #  define ERL_NIF_INLINE __inline__
 
@@ -453,7 +457,7 @@ static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list9(ErlNifEnv* env,
 
 #  undef ERL_NIF_INLINE
 
-#else
+#else /* fallback with macros */
 
 #ifndef enif_make_list1
 #  define enif_make_list1(ENV,E1) enif_make_list(ENV,1,E1)
@@ -476,7 +480,7 @@ static ERL_NIF_INLINE ERL_NIF_TERM enif_make_list9(ErlNifEnv* env,
 #  define enif_make_tuple9(ENV,E1,E2,E3,E4,E5,E6,E7,E8,E9) enif_make_tuple(ENV,9,E1,E2,E3,E4,E5,E6,E7,E8,E9)
 #endif
 
-#endif /* defined(__GNUC__) */
+#endif /* __GNUC__ && !WIN32 */
 
 #ifndef enif_make_pid
 
-- 
cgit v1.2.3


From 82e41d4b3a57774a23a57d345637a0e19e8727d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Mon, 31 Oct 2011 14:00:42 +0100
Subject: beam_load.c: Clarify error message when loading unsupported BEAM
 files

Make it clear for the user what has happened and how to fix it when
an attempt is made to load a BEAM file containing new instructions
that the current run-time system cannot handle.

Suggested-by: Thomas Lindgren
---
 erts/emulator/beam/beam_load.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index de4b32b238..57f5ad0a62 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -1570,10 +1570,15 @@ read_code_header(LoaderState* stp)
     /*
      * Verify the number of the highest opcode used.
      */
-
     GetInt(stp, 4, opcode_max);
     if (opcode_max > MAX_GENERIC_OPCODE) {
-	LoadError2(stp, "use of opcode %d; this emulator supports only up to %d",
+	LoadError2(stp,
+		   "This BEAM file was compiled for a later version"
+		   " of the run-time system than " ERLANG_OTP_RELEASE ".\n"
+		   "  To fix this, please recompile this module with an "
+		   ERLANG_OTP_RELEASE " compiler.\n"
+		   "  (Use of opcode %d; this emulator supports "
+		   "only up to %d.)",
 		   opcode_max, MAX_GENERIC_OPCODE);
     }
 
-- 
cgit v1.2.3


From 71f2687e53ef52ae94ab3569a601456d1e906a59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 26 May 2010 11:49:25 +0200
Subject: beam_loader: Support external funs in the literal pool

A future release of the compiler might want to treat external
funs as literals. Make sure that the loader can cope with an
export entry being created from both an entry in the literal
pool and from the export table (i.e. if an external fun refers
to an exported function in the same module).
---
 erts/emulator/beam/beam_bif_load.c | 2 --
 erts/emulator/beam/beam_load.c     | 8 ++++++++
 2 files changed, 8 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index 2561d7a630..8c1f85ea37 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -66,8 +66,6 @@ load_module_2(BIF_ALIST_2)
     erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
     erts_smp_block_system(0);
 
-    erts_export_consolidate();
-
     hp = HAlloc(BIF_P, 3);
     sz = binary_size(BIF_ARG_2);
     if ((i = erts_load_module(BIF_P, 0,
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 57f5ad0a62..d82b5dbcac 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -757,6 +757,14 @@ bin_load(Process *c_p, ErtsProcLocks c_p_locks,
 	}
     }
 
+    /*
+     * Since the literal table *may* have contained external
+     * funs (containing references to export entries), now is
+     * the time to consolidate the export tables.
+     */
+
+    erts_export_consolidate();
+
     /*
      * Load the code chunk.
      */
-- 
cgit v1.2.3


From ff432e262e65243cbc983fcb002527f8fae8c78b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 9 Apr 2010 15:50:17 +0200
Subject: EEP-23: Allow variables in fun M:F/A

Currently, the external fun syntax "fun M:F/A" only supports
literals. That is, "fun lists:reverse/1" is allowed but not
"fun M:F/A".

In many real-life situations, some or all of M, F, A are
not known until run-time, and one is forced to either use
the undocumented erlang:make_fun/3 BIF or to use a
"tuple fun" (which is deprecated).

EEP-23 suggests that the parser (erl_parse) should immediately
transform "fun M:F/A" to "erlang:make_fun(M, F, A)". We have
not followed that approach in this implementation, because we
want the abstract code to mirror the source code as closely
as possible, and we also consider erlang:make_fun/3 to
be an implementation detail that we might want to remove in
the future.

Instead, we will change the abstract format for "fun M:F/A" (in a way
that is not backwards compatible), and while we are at it, we will
move the translation from "fun M:F/A" to "erlang:make_fun(M, F, A)"
from sys_pre_expand down to the v3_core pass. We will also update
the debugger and xref to use the new format.

We did consider making the abstract format backward compatible if
no variables were used in the fun, but decided against it. Keeping
it backward compatible would mean that there would be different
abstract formats for the no-variable and variable case, and tools
would have to handle both formats, probably forever.

Reference: http://www.erlang.org/eeps/eep-0023.html
---
 erts/doc/src/absform.xml          | 3 ++-
 erts/emulator/test/code_SUITE.erl | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/doc/src/absform.xml b/erts/doc/src/absform.xml
index 4c84412dd6..88e8b284fb 100644
--- a/erts/doc/src/absform.xml
+++ b/erts/doc/src/absform.xml
@@ -285,7 +285,8 @@
       <item>If E is <c><![CDATA[fun Name / Arity]]></c>, then
        Rep(E) = <c><![CDATA[{'fun',LINE,{function,Name,Arity}}]]></c>.</item>
       <item>If E is <c><![CDATA[fun Module:Name/Arity]]></c>, then
-       Rep(E) = <c><![CDATA[{'fun',LINE,{function,Module,Name,Arity}}]]></c>.</item>
+       Rep(E) = <c><![CDATA[{'fun',LINE,{function,Rep(Module),Rep(Name),Rep(Arity)}}]]></c>.
+      (Before the R15 release: Rep(E) = <c><![CDATA[{'fun',LINE,{function,Module,Name,Arity}}]]></c>.)</item>
       <item>If E is <c><![CDATA[fun Fc_1 ; ... ; Fc_k end]]></c> 
        where each <c><![CDATA[Fc_i]]></c> is a function clause then Rep(E) =
       <c><![CDATA[{'fun',LINE,{clauses,[Rep(Fc_1), ..., Rep(Fc_k)]}}]]></c>.</item>
diff --git a/erts/emulator/test/code_SUITE.erl b/erts/emulator/test/code_SUITE.erl
index 29cbdedd17..db26655c15 100644
--- a/erts/emulator/test/code_SUITE.erl
+++ b/erts/emulator/test/code_SUITE.erl
@@ -278,7 +278,8 @@ t_check_old_code(Config) when is_list(Config) ->
 
 external_fun(Config) when is_list(Config) ->
     ?line false = erlang:function_exported(another_code_test, x, 1),
-    ?line ExtFun = erlang:make_fun(id(another_code_test), x, 1),
+    AnotherCodeTest = id(another_code_test),
+    ExtFun = fun AnotherCodeTest:x/1,
     ?line {'EXIT',{undef,_}} = (catch ExtFun(answer)),
     ?line false = erlang:function_exported(another_code_test, x, 1),
     ?line false = lists:member(another_code_test, erlang:loaded()),
-- 
cgit v1.2.3


From af5edfe20b24116fa892a37a746f4053fde6039b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 29 Sep 2011 08:13:24 +0200
Subject: beam_asm: Strenghten the calculation of Uniq for funs

Funs are identified by a triple, <Module,Uniq,Index>, where Module is
the module name, Uniq is a 27 bit hash value of some intermediate
representation of the code for the fun, and index is a small integer.

When a fun is loaded, the triple for the fun will be compared to
previously loaded funs. If all elements in the triple in the newly
loaded fun are the same, the newly loaded fun will replace the previous
fun. The idea is that if Uniq are the same, the code for the fun is also
the same.

The problem is that Uniq is only based on the intermediate representation
of the fun itself. If the fun calls local functions in the same module,
Uniq may remain the same even if the behavior of the fun has been changed.

See

  http://erlang.org/pipermail/erlang-bugs/2007-June/000368.htlm

for an example.

As a long-term plan to fix this problem, the NewIndex and NewUniq
fields was added to each fun in the R8 release (where NewUniq is the
MD5 of the BEAM code for the module). Unfortunately, it turns
out that the compiler does not assign unique value to NewIndex (if it
isn't tested, it doesn't work), so we cannot use the
<Module,NewUniq,NewIndex> triple as identification.

It would be possible to use <Module,NewUniq,Index>, but that seems
ugly. Therefore, fix the problem by making Uniq more unique by
taking 27 bits from the MD5 for the BEAM code. That only requires
a change to the compiler.

Also update a test case for cover, which now fails because of the
stronger Uniq calculation. (The comment in test case about why the
Pid2 process survived is not correct.)
---
 erts/doc/src/erlang.xml                            |  9 +++++--
 erts/emulator/test/code_SUITE.erl                  | 28 +++++++++++++++++--
 .../test/code_SUITE_data/fun_confusion.erl         | 31 ++++++++++++++++++++++
 3 files changed, 64 insertions(+), 4 deletions(-)
 create mode 100644 erts/emulator/test/code_SUITE_data/fun_confusion.erl

(limited to 'erts')

diff --git a/erts/doc/src/erlang.xml b/erts/doc/src/erlang.xml
index 45b66a4909..5d7ff7613b 100644
--- a/erts/doc/src/erlang.xml
+++ b/erts/doc/src/erlang.xml
@@ -1196,11 +1196,16 @@ true
           </item>
           <tag><c>{new_uniq, Uniq}</c></tag>
           <item>
-            <p><c>Uniq</c> (a binary) is a unique value for this fun.</p>
+            <p><c>Uniq</c> (a binary) is a unique value for this fun.
+	    It is calculated from the compiled code for the entire module.</p>
           </item>
           <tag><c>{uniq, Uniq}</c></tag>
           <item>
-            <p><c>Uniq</c> (an integer) is a unique value for this fun.</p>
+            <p><c>Uniq</c> (an integer) is a unique value for this fun.
+	    Starting in the R15 release, this integer is calculated from
+	    the compiled code for the entire module. Before R15, this
+	    integer was based on only the body of the fun.
+	    </p>
           </item>
         </taglist>
       </desc>
diff --git a/erts/emulator/test/code_SUITE.erl b/erts/emulator/test/code_SUITE.erl
index 29cbdedd17..6bce448842 100644
--- a/erts/emulator/test/code_SUITE.erl
+++ b/erts/emulator/test/code_SUITE.erl
@@ -25,7 +25,7 @@
 	 t_check_process_code_ets/1,
 	 external_fun/1,get_chunk/1,module_md5/1,make_stub/1,
 	 make_stub_many_funs/1,constant_pools/1,
-	 false_dependency/1,coverage/1]).
+	 false_dependency/1,coverage/1,fun_confusion/1]).
 
 -include_lib("test_server/include/test_server.hrl").
 
@@ -35,7 +35,7 @@ all() ->
     [new_binary_types, t_check_process_code,
      t_check_process_code_ets, t_check_old_code, external_fun, get_chunk,
      module_md5, make_stub, make_stub_many_funs,
-     constant_pools, false_dependency, coverage].
+     constant_pools, false_dependency, coverage, fun_confusion].
 
 groups() -> 
     [].
@@ -555,6 +555,30 @@ coverage(Config) when is_list(Config) ->
     ?line {'EXIT',{badarg,_}} = (catch erlang:module_loaded(42)),
     ok.
 
+fun_confusion(Config) when is_list(Config) ->
+    Data = ?config(data_dir, Config),
+    Src = filename:join(Data, "fun_confusion"),
+    Mod = fun_confusion,
+
+    %% Load first version of module.
+    compile_load(Mod, Src, 1),
+    F1 = Mod:f(),
+    1 = F1(),
+
+    %% Load second version of module.
+    compile_load(Mod, Src, 2),
+    F2 = Mod:f(),
+
+    %% F1 should refer to the old code, not the newly loaded code.
+    1 = F1(),
+    2 = F2(),
+    ok.
+
+compile_load(Mod, Src, Ver) ->
+    {ok,Mod,Code1} = compile:file(Src, [binary,{d,version,Ver}]),
+    {module,Mod} = code:load_binary(Mod, "fun_confusion.beam", Code1),
+    ok.
+
 %% Utilities.
 
 make_sub_binary(Bin) when is_binary(Bin) ->
diff --git a/erts/emulator/test/code_SUITE_data/fun_confusion.erl b/erts/emulator/test/code_SUITE_data/fun_confusion.erl
new file mode 100644
index 0000000000..16000861df
--- /dev/null
+++ b/erts/emulator/test/code_SUITE_data/fun_confusion.erl
@@ -0,0 +1,31 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2011. 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%
+%%
+
+-module(fun_confusion).
+
+-export([f/0]).
+
+f() ->
+    fun() -> version() end.
+
+version() ->
+    %% Changing the value returned here should change
+    %% the identity of the fun in f/0.
+    ?version.
+
-- 
cgit v1.2.3


From 7e35f3585ae396b7e19a4a5d09f1b378806d523a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 15:39:56 +0100
Subject: erts: remove debug variables in beam_bp

---
 erts/emulator/beam/beam_bp.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 773baad01f..c90795c343 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -612,9 +612,13 @@ static void bp_hash_delete(bp_time_hash_t *hash) {
 static void bp_time_diff(bp_data_time_item_t *item, /* out */
 	process_breakpoint_time_t *pbt,             /* in  */
 	Uint ms, Uint s, Uint us) {
-    int dms,ds,dus;
+    int ds,dus;
+#ifdef DEBUG
+    int dms;
+
 
     dms = ms - pbt->ms;
+#endif
     ds  = s  - pbt->s;
     dus = us - pbt->us;
 
@@ -622,7 +626,9 @@ static void bp_time_diff(bp_data_time_item_t *item, /* out */
      * this is ok.
      */
 
+#ifdef DEBUG
     ASSERT(dms >= 0 || ds >= 0 || dus >= 0);
+#endif
 
     if (dus < 0) {
 	dus += 1000000;
-- 
cgit v1.2.3


From b37aca2a4ac3e79c39ab4dd588eda2b6bd77d311 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 15:41:27 +0100
Subject: erts: "initialized" is only used with CHLDWTHR

---
 erts/emulator/sys/unix/sys.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 82d2c64d81..94ec8dc8a0 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -2892,8 +2892,8 @@ smp_sig_notify(char c)
 static void *
 signal_dispatcher_thread_func(void *unused)
 {
-    int initialized = 0;
 #if !CHLDWTHR
+    int initialized = 0;
     int notify_check_children = 0;
 #endif
 #ifdef ERTS_ENABLE_LOCK_CHECK
@@ -2933,8 +2933,8 @@ signal_dispatcher_thread_func(void *unused)
 	     */
 	    switch (buf[i]) {
 	    case 0: /* Emulator initialized */
-		initialized = 1;
 #if !CHLDWTHR
+		initialized = 1;
 		if (!notify_check_children)
 #endif
 		    break;
-- 
cgit v1.2.3


From 3a1e846e08b28fd38df5fa36c4b5ec13c420d1d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 15:44:37 +0100
Subject: erts: Remove unused variable in ttsl_drv

---
 erts/emulator/drivers/unix/ttsl_drv.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/drivers/unix/ttsl_drv.c b/erts/emulator/drivers/unix/ttsl_drv.c
index d782b044a9..45d39a559f 100644
--- a/erts/emulator/drivers/unix/ttsl_drv.c
+++ b/erts/emulator/drivers/unix/ttsl_drv.c
@@ -242,7 +242,7 @@ static ErlDrvData ttysl_start(ErlDrvPort port, char* buf)
 #ifndef HAVE_TERMCAP
     return ERL_DRV_ERROR_GENERAL;
 #else
-    char *s, *t, c, *l;
+    char *s, *t, *l;
     int canon, echo, sig;	/* Terminal characteristics */
     int flag;
     extern int using_oldshell; /* set this to let the rest of erts know */
@@ -262,7 +262,6 @@ static ErlDrvData ttysl_start(ErlDrvPort port, char* buf)
 	s++;
 	/* Find end of this argument (start of next) and insert NUL. */
 	if ((t = strchr(s, ' '))) {
-	    c = *t;
 	    *t = '\0';
 	}
 	if ((flag = ((*s == '+') ? 1 : ((*s == '-') ? -1 : 0)))) {
-- 
cgit v1.2.3


From 5e8fa1d015f87dcbf2e6b84d5cc4161478851f41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 15:45:28 +0100
Subject: erts: Remove lock_check debug variables

---
 erts/emulator/beam/erl_process_lock.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_process_lock.c b/erts/emulator/beam/erl_process_lock.c
index 83379d7352..b4d20480c5 100644
--- a/erts/emulator/beam/erl_process_lock.c
+++ b/erts/emulator/beam/erl_process_lock.c
@@ -669,7 +669,9 @@ proc_safelock(Process *a_proc,
 	      ErtsProcLocks b_need_locks)
 {
     Process *p1, *p2;
+#ifdef ERTS_ENABLE_LOCK_CHECK
     Eterm pid1, pid2;
+#endif
     erts_pix_lock_t *pix_lck1, *pix_lck2;
     ErtsProcLocks need_locks1, have_locks1, need_locks2, have_locks2;
     ErtsProcLocks unlock_mask;
@@ -684,24 +686,32 @@ proc_safelock(Process *a_proc,
     if (a_proc) {
 	if (a_proc->id < b_proc->id) {
 	    p1 = a_proc;
+#ifdef ERTS_ENABLE_LOCK_CHECK
 	    pid1 = a_proc->id;
+#endif
 	    pix_lck1 = a_pix_lck;
 	    need_locks1 = a_need_locks;
 	    have_locks1 = a_have_locks;
 	    p2 = b_proc;
+#ifdef ERTS_ENABLE_LOCK_CHECK
 	    pid2 = b_proc->id;
+#endif
 	    pix_lck2 = b_pix_lck;
 	    need_locks2 = b_need_locks;
 	    have_locks2 = b_have_locks;
 	}
 	else if (a_proc->id > b_proc->id) {
 	    p1 = b_proc;
+#ifdef ERTS_ENABLE_LOCK_CHECK
 	    pid1 = b_proc->id;
+#endif
 	    pix_lck1 = b_pix_lck;
 	    need_locks1 = b_need_locks;
 	    have_locks1 = b_have_locks;
 	    p2 = a_proc;
+#ifdef ERTS_ENABLE_LOCK_CHECK
 	    pid2 = a_proc->id;
+#endif
 	    pix_lck2 = a_pix_lck;
 	    need_locks2 = a_need_locks;
 	    have_locks2 = a_have_locks;
@@ -710,12 +720,16 @@ proc_safelock(Process *a_proc,
 	    ERTS_LC_ASSERT(a_proc == b_proc);
 	    ERTS_LC_ASSERT(a_proc->id == b_proc->id);
 	    p1 = a_proc;
+#ifdef ERTS_ENABLE_LOCK_CHECK
 	    pid1 = a_proc->id;
+#endif
 	    pix_lck1 = a_pix_lck;
 	    need_locks1 = a_need_locks | b_need_locks;
 	    have_locks1 = a_have_locks | b_have_locks;
 	    p2 = NULL;
+#ifdef ERTS_ENABLE_LOCK_CHECK
 	    pid2 = 0;
+#endif
 	    pix_lck2 = NULL;
 	    need_locks2 = 0;
 	    have_locks2 = 0;
@@ -723,12 +737,16 @@ proc_safelock(Process *a_proc,
     }
     else {
 	p1 = b_proc;
+#ifdef ERTS_ENABLE_LOCK_CHECK
 	pid1 = b_proc->id;
+#endif
 	pix_lck1 = b_pix_lck;
 	need_locks1 = b_need_locks;
 	have_locks1 = b_have_locks;
 	p2 = NULL;
+#ifdef ERTS_ENABLE_LOCK_CHECK
 	pid2 = 0;
+#endif
 	pix_lck2 = NULL;
 	need_locks2 = 0;
 	have_locks2 = 0;
-- 
cgit v1.2.3


From 4ceec9775e33de5587ed31b3c1902825ad0a0996 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 15:47:26 +0100
Subject: erts: Remove dead code in efile_drv

---
 erts/emulator/drivers/common/efile_drv.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/drivers/common/efile_drv.c b/erts/emulator/drivers/common/efile_drv.c
index 68987b3493..52f1b5312b 100644
--- a/erts/emulator/drivers/common/efile_drv.c
+++ b/erts/emulator/drivers/common/efile_drv.c
@@ -2493,13 +2493,20 @@ file_flush(ErlDrvData e) {
 static int 
 file_control(ErlDrvData e, unsigned int command, 
 			 char* buf, int len, char **rbuf, int rlen) {
+    /*
+     *  warning: variable ‘desc’ set but not used 
+     *  [-Wunused-but-set-variable]
+     *  ... no kidding ...
+     *
+     *
     file_descriptor *desc = (file_descriptor *)e;
     switch (command) {
     default:
 	return 0;
-    } /* switch (command) */
+    } 
     ASSERT(0);
-    desc = NULL; /* XXX Avoid warning while empty switch */
+    desc = NULL; 
+    */
     return 0;
 }
 
-- 
cgit v1.2.3


From 23e1f63738cef1a82e2dc18fe395ac208fdee5fc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 15:54:39 +0100
Subject: erts: Remove debug variables in erl_db

---
 erts/emulator/beam/erl_db.c      | 11 ++++++++++-
 erts/emulator/beam/erl_db_util.c |  7 ++++++-
 2 files changed, 16 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_db.c b/erts/emulator/beam/erl_db.c
index 0327850cb9..ee6e1771d0 100644
--- a/erts/emulator/beam/erl_db.c
+++ b/erts/emulator/beam/erl_db.c
@@ -1297,7 +1297,9 @@ BIF_RETTYPE ets_new_2(BIF_ALIST_2)
     Uint32 status;
     Sint keypos;
     int is_named, is_fine_locked, frequent_read, is_compressed;
+#ifdef DEBUG
     int cret;
+#endif
     DeclareTmpHeap(meta_tuple,3,BIF_P);
     DbTableMethod* meth;
     erts_smp_rwmtx_t *mmtl;
@@ -1445,7 +1447,10 @@ BIF_RETTYPE ets_new_2(BIF_ALIST_2)
     tb->common.fixations = NULL;
     tb->common.compress = is_compressed;
 
-    cret = meth->db_create(BIF_P, tb);
+#ifdef DEBUG
+    cret = 
+#endif
+	meth->db_create(BIF_P, tb);
     ASSERT(cret == DB_ERROR_NONE);
 
     erts_smp_spin_lock(&meta_main_tab_main_lock);
@@ -2606,7 +2611,9 @@ BIF_RETTYPE ets_info_1(BIF_ALIST_1)
     int i;
     Eterm* hp;
     /*Process* rp = NULL;*/
+    /* If/when we implement lockless private tables:
     Eterm owner;
+    */
 
     if ((tb = db_get_table(BIF_P, BIF_ARG_1, DB_INFO, LCK_READ)) == NULL) {
 	if (is_atom(BIF_ARG_1) || is_small(BIF_ARG_1)) {
@@ -2615,7 +2622,9 @@ BIF_RETTYPE ets_info_1(BIF_ALIST_1)
 	BIF_ERROR(BIF_P, BADARG);
     }
 
+    /* If/when we implement lockless private tables:
     owner = tb->common.owner;
+    */
 
     /* If/when we implement lockless private tables:
     if ((tb->common.status & DB_PRIVATE) && owner != BIF_P->id) {
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index 7dfbb2ed02..42079a7cee 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -2846,7 +2846,9 @@ void* db_store_term_comp(DbTableCommon *tb, DbTerm* old, Uint offset, Eterm obj)
     Uint new_sz = offset + db_size_dbterm_comp(tb, obj);
     byte* basep;
     DbTerm* newp;
+#ifdef DEBUG
     byte* top;
+#endif
 
     ASSERT(tb->compress);
     if (old != 0) {
@@ -2868,7 +2870,10 @@ void* db_store_term_comp(DbTableCommon *tb, DbTerm* old, Uint offset, Eterm obj)
     }
 
     newp->size = size_object(obj);
-    top = copy_to_comp(tb, obj, newp, new_sz);
+#ifdef DEBUG
+    top = 
+#endif
+	copy_to_comp(tb, obj, newp, new_sz);
     ASSERT(top <= basep + new_sz);
 
     /* ToDo: Maybe realloc if ((basep+new_sz) - top) > WASTED_SPACE_LIMIT */
-- 
cgit v1.2.3


From 7566b2afc2a3bd509ea0bf744e87770643ce3477 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 15:57:09 +0100
Subject: erts: Remove cp on exiting and trapping processes

---
 erts/emulator/beam/bif.c |  9 +++------
 erts/emulator/beam/bif.h | 11 +++++++++++
 2 files changed, 14 insertions(+), 6 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c
index 5b3261077b..76086860dd 100644
--- a/erts/emulator/beam/bif.c
+++ b/erts/emulator/beam/bif.c
@@ -4291,8 +4291,7 @@ void
 erts_bif_prep_await_proc_exit_data_trap(Process *c_p, Eterm pid, Eterm ret)
 {
     if (skip_current_msgq(c_p)) {
-	Eterm unused;
-	ERTS_BIF_PREP_TRAP3(unused, await_proc_exit_trap, c_p, pid, am_data, ret);
+	ERTS_BIF_PREP_TRAP3_NO_RET(await_proc_exit_trap, c_p, pid, am_data, ret);
     }
 }
 
@@ -4300,8 +4299,7 @@ void
 erts_bif_prep_await_proc_exit_reason_trap(Process *c_p, Eterm pid)
 {
     if (skip_current_msgq(c_p)) {
-	Eterm unused;
-	ERTS_BIF_PREP_TRAP3(unused, await_proc_exit_trap, c_p,
+	ERTS_BIF_PREP_TRAP3_NO_RET(await_proc_exit_trap, c_p,
 			    pid, am_reason, am_undefined);
     }
 }
@@ -4316,7 +4314,6 @@ erts_bif_prep_await_proc_exit_apply_trap(Process *c_p,
 {
     ASSERT(is_atom(module) && is_atom(function));
     if (skip_current_msgq(c_p)) {
-	Eterm unused;
 	Eterm term;
 	Eterm *hp;
 	int i;
@@ -4328,7 +4325,7 @@ erts_bif_prep_await_proc_exit_apply_trap(Process *c_p,
 	    hp += 2;
 	}
 	term = TUPLE3(hp, module, function, term);
-	ERTS_BIF_PREP_TRAP3(unused, await_proc_exit_trap, c_p, pid, am_apply, term);
+	ERTS_BIF_PREP_TRAP3_NO_RET(await_proc_exit_trap, c_p, pid, am_apply, term);
     }
 }
 
diff --git a/erts/emulator/beam/bif.h b/erts/emulator/beam/bif.h
index 8faa09feb8..66f152a6ea 100644
--- a/erts/emulator/beam/bif.h
+++ b/erts/emulator/beam/bif.h
@@ -160,6 +160,17 @@ do {							\
     (Ret) = THE_NON_VALUE;				\
 } while (0)
 
+#define ERTS_BIF_PREP_TRAP3_NO_RET(Trap, Proc, A0, A1, A2)\
+do {							\
+    (Proc)->arity = 3;					\
+    (Proc)->def_arg_reg[0] = (Eterm) (A0);		\
+    (Proc)->def_arg_reg[1] = (Eterm) (A1);		\
+    (Proc)->def_arg_reg[2] = (Eterm) (A2);		\
+    *((UWord *) (UWord) ((Proc)->def_arg_reg + 3)) = (UWord) ((Trap)->address);	\
+    (Proc)->freason = TRAP;				\
+} while (0)
+
+
 #define BIF_TRAP0(p, Trap_) do {			\
       (p)->arity = 0;					\
       *((UWord *) (UWord) ((p)->def_arg_reg + 3)) = (UWord) ((Trap_)->address);	\
-- 
cgit v1.2.3


From 02d6b0770538dcb2f0be1755b6db2139498a47b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 15:59:16 +0100
Subject: erts: Remove debug variable in list_to_binary

---
 erts/emulator/beam/binary.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/binary.c b/erts/emulator/beam/binary.c
index 1fb39c6c67..29461877c5 100644
--- a/erts/emulator/beam/binary.c
+++ b/erts/emulator/beam/binary.c
@@ -356,8 +356,10 @@ BIF_RETTYPE erts_list_to_binary_bif(Process *p, Eterm arg)
 {
     Eterm bin;
     Uint size;
-    int offset;
     byte* bytes;
+#ifdef DEBUG
+    int offset;
+#endif
 
     if (is_nil(arg)) {
 	BIF_RET(new_binary(p,(byte*)"",0));
@@ -372,7 +374,11 @@ BIF_RETTYPE erts_list_to_binary_bif(Process *p, Eterm arg)
     }
     bin = new_binary(p, (byte *)NULL, size);
     bytes = binary_bytes(bin);
-    offset = io_list_to_buf(arg, (char*) bytes, size);
+#ifdef DEBUG
+    offset = 
+#endif
+	io_list_to_buf(arg, (char*) bytes, size);
+
     ASSERT(offset == 0);
     BIF_RET(bin);
     
-- 
cgit v1.2.3


From 4e73d4bee3fd7744ebaf9f672a0ab5bc6528301f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 7 Nov 2011 16:01:21 +0100
Subject: erts: Remove unused variable in enif_make_binary

---
 erts/emulator/beam/erl_nif.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 51f1fad811..224931c3fb 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -681,6 +681,7 @@ Eterm enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term,
     ErlSubBin* sb;
     Eterm orig;
     Uint offset, bit_offset, bit_size; 
+#ifdef DEBUG
     unsigned src_size;
 
     ASSERT(is_binary(bin_term));
@@ -688,6 +689,7 @@ Eterm enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term,
     ASSERT(pos <= src_size);
     ASSERT(size <= src_size);
     ASSERT(pos + size <= src_size);   
+#endif
     sb = (ErlSubBin*) alloc_heap(env, ERL_SUB_BIN_SIZE);
     ERTS_GET_REAL_BIN(bin_term, orig, offset, bit_offset, bit_size);
     sb->thing_word = HEADER_SUB_BIN;
-- 
cgit v1.2.3