Calling randi() % floor(2.0) causes engine to crash silently

[jtiai]

Godot version

4.1.1.stable

System information

Godot v4.1.1.stable - Windows 10.0.22621 - Vulkan (Forward+) - dedicated NVIDIA GeForce RTX 2060 (NVIDIA; 31.0.15.3640) - Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz (12 Threads)

Issue description

The following code causes game to crash silently:

var result = randi() % floor(10.0)

Steps to reproduce

Create a node, add the following code in _ready()

func _ready():
    var result = randi() % floor(10.0)
    print("Result: ", result)

Minimal reproduction project

N/A

[AThousandShips]

Does this happen if you do:

func _ready():
    var result = randi() % floori(10.0)
    print("Result: ", result)

There is no % operator between int and float, but it shouldn't crash

[dalexeev]

# Crash.
var a: int = 1
const b: Variant = 10.0
var result = a % b

# Runtime error: Invalid operands 'int' and 'float' in operator '%'.
var a: int = 1
var b: Variant = 10.0
var result = a % b

[Chaosus]

Confirmed. Seems due to incorrect access to null pointer in gdscript vm:

[dalexeev]

godot/modules/gdscript/gdscript_byte_codegen.cpp

Lines 588 to 625 in 7df3933

	void GDScriptByteCodeGenerator::write_binary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand, const Address &p_right_operand) {
	// Avoid validated evaluator for modulo and division when operands are int, since there's no check for division by zero.
	if (HAS_BUILTIN_TYPE(p_left_operand) && HAS_BUILTIN_TYPE(p_right_operand) && ((p_operator != Variant::OP_DIVIDE && p_operator != Variant::OP_MODULE) || p_left_operand.type.builtin_type != Variant::INT || p_right_operand.type.builtin_type != Variant::INT)) {
	if (p_target.mode == Address::TEMPORARY) {
	Variant::Type result_type = Variant::get_operator_return_type(p_operator, p_left_operand.type.builtin_type, p_right_operand.type.builtin_type);
	Variant::Type temp_type = temporaries[p_target.address].type;
	if (result_type != temp_type) {
	write_type_adjust(p_target, result_type);
	}
	}
	// Gather specific operator.
	Variant::ValidatedOperatorEvaluator op_func = Variant::get_validated_operator_evaluator(p_operator, p_left_operand.type.builtin_type, p_right_operand.type.builtin_type);
	append_opcode(GDScriptFunction::OPCODE_OPERATOR_VALIDATED);
	append(p_left_operand);
	append(p_right_operand);
	append(p_target);
	append(op_func);
	#ifdef DEBUG_ENABLED
	add_debug_name(operator_names, get_operation_pos(op_func), Variant::get_operator_name(p_operator));
	#endif
	return;
	}
	// No specific types, perform variant evaluation.
	append_opcode(GDScriptFunction::OPCODE_OPERATOR);
	append(p_left_operand);
	append(p_right_operand);
	append(p_target);
	append(p_operator);
	append(0); // Signature storage.
	append(0); // Return type storage.
	constexpr int _pointer_size = sizeof(Variant::ValidatedOperatorEvaluator) / sizeof(*(opcodes.ptr()));
	for (int i = 0; i < _pointer_size; i++) {
	append(0); // Space for function pointer.
	}
	}

 0: line 2:     var a: int = 1
 2: assign stack(3) = const(1)
 5: line 3:     const b: Variant = 10.0
 7: line 4:     var result = a % b
 9: validated operator stack(6) = stack(3) % const(10)
 14: assign stack(5) = stack(6)
 17: assign stack(6) = false
 19: == END ==

 0: line 2:     var a: int = 1
 2: assign stack(3) = const(1)
 5: line 3:     var b: Variant = 10.0
 7: assign stack(4) = const(10)
 10: line 4:    var result = a % b
 12: operator stack(6) = stack(3) % stack(4)
 21: assign stack(5) = stack(6)
 24: assign stack(6) = false
 26: == END ==