Forward port changes from v0.6 release branch

bettio · bettio · commit 50011440dfde · 2025-03-23T01:26:11.000+01:00
Merge fixes from release-0.6 branch, such as OTP-21 CI fix (#1587), silent CodeQL warning (#1582), `is_function/2` guard fix and missing `is_function/2` BIF (#1592).
diff --git a/.github/workflows/publish-docs.yaml b/.github/workflows/publish-docs.yaml
@@ -129,7 +129,7 @@ jobs:
           git add "doc/${{ github.ref_name }}"
           git add .
           git diff --exit-code Production || echo "Going to commit"
-          git diff --exit-code Production || git commit -m "Update Documentation"
+          git diff --exit-code Production || git commit -m "Update Documentation for ${{ github.ref_name }}"
           git log -1
       - name: Push changes
         if: github.repository == 'atomvm/AtomVM'
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -42,6 +42,7 @@ with nodejs and emscripten)
 - Added memory info in `out_of_memory` crash logs to help developers fix memory issues.
 - Added documentation and function specs for uart driver
 - Added `uart:read/2` with a timeout parameter.
+- Missing `erlang:is_function/2` BIF
 
 ### Fixed
 
@@ -87,6 +88,8 @@ memory error
 - Fixed concurrency and memory leak related to links and monitors
 - Fixed issues with parsing of line references for stack traces
 - Fixed memory corruption issue with `erlang:make_tuple/2`
+- Fix potential use after free with code generated from OTP <= 24
+- Fix `is_function/2` guard
 
 ### Changed
 
diff --git a/CMakeModules/FindDoxygen.cmake b/CMakeModules/FindDoxygen.cmake
@@ -0,0 +1,28 @@
+#
+# This file is part of AtomVM.
+#
+# Copyright 2021 Fred Dushin <fred@dushin.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
+#
+
+find_program(DOXYGEN_PATH doxygen)
+
+if (DOXYGEN_PATH)
+    set(DOXYGEN_FOUND TRUE)
+    set(DOXYGEN_BUILD_EXECUTABLE "${DOXYGEN_PATH}")
+elseif(DOXYGEN_FIND_REQUIRED)
+    message(FATAL_ERROR "Doxygen command (doxygen) not found")
+endif()
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
@@ -126,27 +126,30 @@ endif()
 ##
 find_package(Sphinx)
 if(SPHINX_FOUND)
+  find_package(Doxygen)
+  if(DOXYGEN_FOUND)
+    message("Doxygen found: ${DOXYGEN_BUILD_EXECUTABLE}")
     message("Sphinx found: ${SPHINX_BUILD_EXECUTABLE}")
     configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
     file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/pdf_stylesheet.rts DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
     file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/pdf_template.rtt DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
     file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/apidocs/libatomvm)
     add_custom_target(sphinx-html
-        ${SPHINX_BUILD_EXECUTABLE} -q -b html -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src/ ${CMAKE_CURRENT_BINARY_DIR}/html/
+        ${SPHINX_BUILD_EXECUTABLE} -q --doctree-dir ${CMAKE_CURRENT_BINARY_DIR}/doctree -b html -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src/ ${CMAKE_CURRENT_BINARY_DIR}/html/
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
         COMMENT "Generating Sphinx HTML documentation" VERBATIM
         DEPENDS ${DOTFILE_TARGETS} ${ERLANG_EDOC_TARGETS}
     )
 
     add_custom_target(sphinx-pdf
-        ${SPHINX_BUILD_EXECUTABLE} -q -D exclude_patterns=apidocs/libatomvm/** -b rinoh -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src/ ${CMAKE_CURRENT_BINARY_DIR}/pdf/
+        ${SPHINX_BUILD_EXECUTABLE} -q --doctree-dir ${CMAKE_CURRENT_BINARY_DIR}/doctree -D exclude_patterns=apidocs/libatomvm/** -b rinoh -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src/ ${CMAKE_CURRENT_BINARY_DIR}/pdf/
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
         COMMENT "Generating Sphinx PDF documentation" VERBATIM
         DEPENDS ${DOTFILE_TARGETS} ${ERLANG_EDOC_TARGETS}
     )
 
     add_custom_target(sphinx-epub
-        ${SPHINX_BUILD_EXECUTABLE} -q -D exclude_patterns=apidocs/libatomvm/**,LICENSES/** -b epub -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src/ ${CMAKE_CURRENT_BINARY_DIR}/epub/
+        ${SPHINX_BUILD_EXECUTABLE} -q --doctree-dir ${CMAKE_CURRENT_BINARY_DIR}/doctree -D exclude_patterns=apidocs/libatomvm/**,LICENSES/** -b epub -c ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src/ ${CMAKE_CURRENT_BINARY_DIR}/epub/
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
         COMMENT "Generating Sphinx EPub documentation" VERBATIM
         DEPENDS ${DOTFILE_TARGETS} ${ERLANG_EDOC_TARGETS}
@@ -162,6 +165,9 @@ if(SPHINX_FOUND)
         )
     endif()
 
+  else()
+    message("Unable to find Doxygen -- no Sphinx documentation will be generated")
+  endif()
 else()
     message("Unable to find Sphinx -- no Sphinx documentation will be generated")
 endif()
diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
@@ -2304,7 +2304,7 @@ DIRECTORY_GRAPH        = YES
 # The default value is: png.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_IMAGE_FORMAT       = png
+DOT_IMAGE_FORMAT       = svg
 
 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
 # enable generation of interactive SVG images that allow zooming and panning.
diff --git a/doc/conf.py.in b/doc/conf.py.in
@@ -60,6 +60,8 @@ extensions = [
     'sphinx.ext.graphviz'
 ]
 
+graphviz_output_format = 'svg'
+
 suppress_warnings = [
     'epub.unknown_project_files',
     'misc.highlighting_failure',
@@ -167,9 +169,11 @@ tag_list = sorted(repo.tags, key=lambda t: t.commit.committed_datetime)
 latest_tag = tag_list[-1]
 versions = list()
 release_list = list()
+omit_tag_list = [ 'v0.6.0-alpha.0', 'v0.6.0-alpha.1', 'v0.6.0-alpha.2', 'v0.6.0-beta.0', 'v0.6.0-beta.1', 'v0.6.0-rc.0' ]
 for tag in tag_list:
-    versions.append(tag.name)
-    release_list.append(tag.name)
+    if tag.name not in omit_tag_list:
+        versions.append(tag.name)
+        release_list.append(tag.name)
 
 omit_branch_list = [ 'release-0.5' ]
 branch_list = sorted(repo.branches, key=lambda t: t.commit.committed_datetime)
diff --git a/src/libAtomVM/bif.c b/src/libAtomVM/bif.c
@@ -151,6 +151,50 @@ term bif_erlang_is_function_1(Context *ctx, uint32_t fail_label, term arg1)
     return term_is_function(arg1) ? TRUE_ATOM : FALSE_ATOM;
 }
 
+term bif_erlang_is_function_2(Context *ctx, uint32_t fail_label, term arg1, term arg2)
+{
+    VALIDATE_VALUE_BIF(fail_label, arg2, term_is_any_integer);
+
+    if (!term_is_integer(arg2)) {
+        // function takes any positive integer, including big integers
+        // but internally we use only small integers
+        return FALSE_ATOM;
+    }
+    avm_int_t arity = term_to_int(arg2);
+    if (arity < 0) {
+        RAISE_ERROR_BIF(fail_label, BADARG_ATOM);
+    }
+
+    if (!term_is_function(arg1)) {
+        return FALSE_ATOM;
+    }
+
+    // following part has been taken from opcodesswitch.h
+    // TODO: factor this out
+    const term *boxed_value = term_to_const_term_ptr(arg1);
+
+    Module *fun_module = (Module *) boxed_value[1];
+    term index_or_module = boxed_value[2];
+
+    uint32_t fun_arity;
+
+    if (term_is_atom(index_or_module)) {
+        fun_arity = term_to_int(boxed_value[3]);
+
+    } else {
+        uint32_t fun_index = term_to_int32(index_or_module);
+
+        uint32_t fun_label;
+        uint32_t fun_arity_and_freeze;
+        uint32_t fun_n_freeze;
+
+        module_get_fun(fun_module, fun_index, &fun_label, &fun_arity_and_freeze, &fun_n_freeze);
+        fun_arity = fun_arity_and_freeze - fun_n_freeze;
+    }
+
+    return (arity == ((avm_int_t) fun_arity)) ? TRUE_ATOM : FALSE_ATOM;
+}
+
 term bif_erlang_is_integer_1(Context *ctx, uint32_t fail_label, term arg1)
 {
     UNUSED(ctx);
diff --git a/src/libAtomVM/bif.h b/src/libAtomVM/bif.h
@@ -51,6 +51,7 @@ term bif_erlang_is_binary_1(Context *ctx, uint32_t fail_label, term arg1);
 term bif_erlang_is_boolean_1(Context *ctx, uint32_t fail_label, term arg1);
 term bif_erlang_is_float_1(Context *ctx, uint32_t fail_label, term arg1);
 term bif_erlang_is_function_1(Context *ctx, uint32_t fail_label, term arg1);
+term bif_erlang_is_function_2(Context *ctx, uint32_t fail_label, term arg1, term arg2);
 term bif_erlang_is_integer_1(Context *ctx, uint32_t fail_label, term arg1);
 term bif_erlang_is_list_1(Context *ctx, uint32_t fail_label, term arg1);
 term bif_erlang_is_number_1(Context *ctx, uint32_t fail_label, term arg1);
diff --git a/src/libAtomVM/bifs.gperf b/src/libAtomVM/bifs.gperf
@@ -46,6 +46,7 @@ erlang:is_binary/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlan
 erlang:is_boolean/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlang_is_boolean_1}
 erlang:is_float/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlang_is_float_1}
 erlang:is_function/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlang_is_function_1}
+erlang:is_function/2, {.bif.base.type = BIFFunctionType, .bif.bif2_ptr = bif_erlang_is_function_2}
 erlang:is_integer/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlang_is_integer_1}
 erlang:is_list/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlang_is_list_1}
 erlang:is_number/1, {.bif.base.type = BIFFunctionType, .bif.bif1_ptr = bif_erlang_is_number_1}
diff --git a/src/libAtomVM/context.c b/src/libAtomVM/context.c
@@ -588,10 +588,10 @@ term context_get_monitor_pid(Context *ctx, uint64_t ref_ticks, bool *is_monitori
         if (monitor->ref_ticks == ref_ticks) {
             if ((monitor->monitor_obj & 0x3) == CONTEXT_MONITOR_MONITORED_PID_TAG) {
                 *is_monitoring = false;
-                return term_from_local_process_id(monitor->monitor_obj >> 4);
+                return term_from_local_process_id((uint32_t) (monitor->monitor_obj >> 4));
             } else if ((monitor->monitor_obj & 0x3) == CONTEXT_MONITOR_MONITORING_PID_TAG) {
                 *is_monitoring = true;
-                return term_from_local_process_id(monitor->monitor_obj >> 4);
+                return term_from_local_process_id((uint32_t) (monitor->monitor_obj >> 4));
             } else {
                 return term_invalid_term();
             }
diff --git a/src/libAtomVM/opcodesswitch.h b/src/libAtomVM/opcodesswitch.h
@@ -4419,9 +4419,6 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                 uint32_t unit;
                 DECODE_LITERAL(unit, pc);
                 term src;
-                #ifdef IMPL_EXECUTE_LOOP
-                    const uint8_t *src_pc = pc;
-                #endif
                 DECODE_COMPACT_TERM(src, pc)
                 term flags;
                 UNUSED(flags);
@@ -4449,8 +4446,10 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
 
                     size_t src_size = term_binary_size(src);
                     TRIM_LIVE_REGS(live);
+                    // there is always room for a MAX_REG + 1 register, used as working register
+                    x_regs[live] = src;
                     // TODO: further investigate extra_val
-                    if (UNLIKELY(memory_ensure_free_with_roots(ctx, src_size + term_binary_heap_size(size_val / 8) + extra_val, live, x_regs, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+                    if (UNLIKELY(memory_ensure_free_with_roots(ctx, src_size + term_binary_heap_size(size_val / 8) + extra_val, live + 1, x_regs, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
                         RAISE_ERROR(OUT_OF_MEMORY_ATOM);
                     }
                 #endif
@@ -4460,7 +4459,7 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                 
                 #ifdef IMPL_EXECUTE_LOOP
                     TRACE("bs_append/8, fail=%u size=%li unit=%u src=0x%lx dreg=%c%i\n", (unsigned) fail, size_val, (unsigned) unit, src, T_DEST_REG(dreg));
-                    DECODE_COMPACT_TERM(src, src_pc)
+                    src = x_regs[live];
                     term t = term_create_empty_binary(src_size + size_val / 8, &ctx->heap, ctx->global);
                     memcpy((void *) term_binary_data(t), (void *) term_binary_data(src), src_size);
 
@@ -5186,9 +5185,6 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                 uint32_t fail;
                 DECODE_LABEL(fail, pc)
                 term src;
-                #ifdef IMPL_EXECUTE_LOOP
-                    const uint8_t *src_pc = pc;
-                #endif
                 DECODE_COMPACT_TERM(src, pc);
                 uint32_t live;
                 DECODE_LITERAL(live, pc);
@@ -5240,8 +5236,10 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                         term_set_match_state_offset(src, bs_offset + size_val * unit);
 
                         TRIM_LIVE_REGS(live);
+                        // there is always room for a MAX_REG + 1 register, used as working register
+                        x_regs[live] = bs_bin;
                         size_t heap_size = term_sub_binary_heap_size(bs_bin, size_val);
-                        if (UNLIKELY(memory_ensure_free_with_roots(ctx, heap_size, live, x_regs, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+                        if (UNLIKELY(memory_ensure_free_with_roots(ctx, heap_size, live + 1, x_regs, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
                             RAISE_ERROR(OUT_OF_MEMORY_ATOM);
                         }
                 #endif
@@ -5250,9 +5248,7 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                 DECODE_DEST_REGISTER(dreg, pc);
 
                 #ifdef IMPL_EXECUTE_LOOP
-                        // re-compute src
-                        DECODE_COMPACT_TERM(src, src_pc);
-                        bs_bin = term_get_match_state_binary(src);
+                        bs_bin = x_regs[live];
 
                         term t = term_maybe_create_sub_binary(bs_bin, bs_offset / unit, size_val, &ctx->heap, ctx->global);
                         WRITE_REGISTER(dreg, t);
@@ -5439,18 +5435,20 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                 DECODE_LABEL(label, pc)
                 term arg1;
                 DECODE_COMPACT_TERM(arg1, pc)
-                unsigned int arity;
-                DECODE_INTEGER(arity, pc)
+                term arity_term;
+                DECODE_COMPACT_TERM(arity_term, pc)
 
                 #ifdef IMPL_EXECUTE_LOOP
                     TRACE("is_function2/3, label=%i, arg1=%lx, arity=%i\n", label, arg1, arity);
 
-                    if (term_is_function(arg1)) {
+                    if (term_is_function(arg1) && term_is_integer(arity_term)) {
                         const term *boxed_value = term_to_const_term_ptr(arg1);
 
                         Module *fun_module = (Module *) boxed_value[1];
                         term index_or_module = boxed_value[2];
 
+                        avm_int_t arity = term_to_int(arity_term);
+
                         uint32_t fun_arity;
 
                         if (term_is_atom(index_or_module)) {
@@ -5467,7 +5465,7 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                             fun_arity = fun_arity_and_freeze - fun_n_freeze;
                         }
 
-                        if (arity != fun_arity) {
+                        if ((arity < 0) || (arity != (avm_int_t) fun_arity)) {
                             pc = mod->labels[label];
                         }
                     } else {
diff --git a/tests/erlang_tests/CMakeLists.txt b/tests/erlang_tests/CMakeLists.txt
@@ -195,6 +195,7 @@ compile_erlang(test_funs8)
 compile_erlang(test_funs9)
 compile_erlang(test_funs10)
 compile_erlang(test_funs11)
+compile_erlang(test_funs12)
 
 compile_erlang(test_make_fun3)
 
@@ -676,6 +677,7 @@ add_custom_target(erlang_test_modules DEPENDS
     test_funs9.beam
     test_funs10.beam
     test_funs11.beam
+    test_funs12.beam
 
     test_make_fun3.beam
 
diff --git a/tests/erlang_tests/test_funs12.erl b/tests/erlang_tests/test_funs12.erl
@@ -0,0 +1,61 @@
+%
+% This file is part of AtomVM.
+%
+% Copyright 2025 Davide Bettio <davide@uninstall.it>
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%    http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+%
+% SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
+%
+
+-module(test_funs12).
+-export([start/0, check_guard/3, check_bool/3, discard/1, get_fun/0]).
+
+start() ->
+    CheckGuardFun = fun ?MODULE:check_guard/3,
+    SelfFun = fun erlang:self/0,
+    {A, F} = ?MODULE:get_fun(),
+    true = ?MODULE:check_guard(3, CheckGuardFun, 3),
+    false = ?MODULE:check_guard([], CheckGuardFun, []),
+    true = ?MODULE:check_bool(SelfFun, F, 1),
+    false = ?MODULE:check_bool([], {}, 1),
+    ok = expect_error(fun() -> ?MODULE:check_bool({}, [], not_integer) end, error, badarg),
+    ok = expect_error(fun() -> ?MODULE:check_bool(SelfFun, F, not_integer) end, error, badarg),
+    ok = expect_error(fun() -> ?MODULE:check_bool(SelfFun, F, -20) end, error, badarg),
+    1 = ?MODULE:check_guard(A, F, A),
+    ?MODULE:check_guard(0, SelfFun, 0).
+
+check_guard(A, B, A) when A > 1 andalso is_function(B, A) ->
+    discard(B);
+check_guard(A, B, A) when is_function(B, A) ->
+    A;
+check_guard(A, _B, A) when A < 0 ->
+    error;
+check_guard(_A, _B, _A) ->
+    false.
+
+discard(_X) ->
+    true.
+
+check_bool(A, B, C) ->
+    is_function(A, C) or is_function(B, C).
+
+get_fun() ->
+    {1, fun(X) -> X + 1 end}.
+
+expect_error(Fun, A, B) ->
+    try Fun() of
+        Result -> {error, Result}
+    catch
+        A:B -> ok
+    end.
diff --git a/tests/test.c b/tests/test.c
@@ -234,6 +234,7 @@ struct Test tests[] = {
     TEST_CASE_EXPECTED(test_funs9, 3555),
     TEST_CASE_EXPECTED(test_funs10, 6817),
     TEST_CASE_EXPECTED(test_funs11, 817),
+    TEST_CASE(test_funs12),
     TEST_CASE(test_make_fun3),
     TEST_CASE(fun_call_bif),
 
