godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9d16250353
godot/modules/gdscript/gdscript_byte_codegen.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1694 lines
61 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 12:25:55 +00:00
/**************************************************************************/
/* gdscript_byte_codegen.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
#include "gdscript_byte_codegen.h"
#include "core/debugger/engine_debugger.h"
#include "gdscript.h"
uint32_t GDScriptByteCodeGenerator::add_parameter(const StringName &p_name, bool p_is_optional, const GDScriptDataType &p_type) {
#ifdef TOOLS_ENABLED
function->arg_names.push_back(p_name);
#endif
function->_argument_count++;
function->argument_types.push_back(p_type);
if (p_is_optional) {
function->_default_arg_count++;
}
return add_local(p_name, p_type);
}
uint32_t GDScriptByteCodeGenerator::add_local(const StringName &p_name, const GDScriptDataType &p_type) {
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
int stack_pos = locals.size() + RESERVED_STACK;
locals.push_back(StackSlot(p_type.builtin_type));
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
add_stack_identifier(p_name, stack_pos);
return stack_pos;
}
uint32_t GDScriptByteCodeGenerator::add_local_constant(const StringName &p_name, const Variant &p_constant) {
int index = add_or_get_constant(p_constant);
local_constants[p_name] = index;
return index;
}
uint32_t GDScriptByteCodeGenerator::add_or_get_constant(const Variant &p_constant) {
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
return get_constant_pos(p_constant);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
uint32_t GDScriptByteCodeGenerator::add_or_get_name(const StringName &p_name) {
return get_name_map_pos(p_name);
}
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
uint32_t GDScriptByteCodeGenerator::add_temporary(const GDScriptDataType &p_type) {
Variant::Type temp_type = Variant::NIL;
if (p_type.has_type) {
if (p_type.kind == GDScriptDataType::BUILTIN) {
switch (p_type.builtin_type) {
case Variant::NIL:
case Variant::BOOL:
case Variant::INT:
case Variant::FLOAT:
case Variant::STRING:
case Variant::VECTOR2:
case Variant::VECTOR2I:
case Variant::RECT2:
case Variant::RECT2I:
case Variant::VECTOR3:
case Variant::VECTOR3I:
case Variant::TRANSFORM2D:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
case Variant::VECTOR4:
case Variant::VECTOR4I:
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
case Variant::PLANE:
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
case Variant::QUATERNION:
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
case Variant::AABB:
case Variant::BASIS:
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00:00
case Variant::TRANSFORM3D:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
case Variant::PROJECTION:
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
case Variant::COLOR:
case Variant::STRING_NAME:
case Variant::NODE_PATH:
case Variant::RID:
case Variant::OBJECT:
case Variant::CALLABLE:
case Variant::SIGNAL:
case Variant::DICTIONARY:
case Variant::ARRAY:
temp_type = p_type.builtin_type;
break;
case Variant::PACKED_BYTE_ARRAY:
case Variant::PACKED_INT32_ARRAY:
case Variant::PACKED_INT64_ARRAY:
case Variant::PACKED_FLOAT32_ARRAY:
case Variant::PACKED_FLOAT64_ARRAY:
case Variant::PACKED_STRING_ARRAY:
case Variant::PACKED_VECTOR2_ARRAY:
case Variant::PACKED_VECTOR3_ARRAY:
case Variant::PACKED_COLOR_ARRAY:
case Variant::VARIANT_MAX:
// Packed arrays are reference counted, so we don't use the pool for them.
temp_type = Variant::NIL;
break;
}
} else {
temp_type = Variant::OBJECT;
}
}
if (!temporaries_pool.has(temp_type)) {
temporaries_pool[temp_type] = List<int>();
}
List<int> &pool = temporaries_pool[temp_type];
if (pool.is_empty()) {
StackSlot new_temp(temp_type);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
int idx = temporaries.size();
pool.push_back(idx);
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
temporaries.push_back(new_temp);
}
int slot = pool.front()->get();
pool.pop_front();
used_temporaries.push_back(slot);
return slot;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::pop_temporary() {
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
ERR_FAIL_COND(used_temporaries.is_empty());
int slot_idx = used_temporaries.back()->get();
const StackSlot &slot = temporaries[slot_idx];
temporaries_pool[slot.type].push_back(slot_idx);
used_temporaries.pop_back();
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
GDScript default argument override bug fix Fix: #41766
2020-09-04 21:46:23 +00:00
void GDScriptByteCodeGenerator::start_parameters() {
if (function->_default_arg_count > 0) {
append(GDScriptFunction::OPCODE_JUMP_TO_DEF_ARGUMENT);
function->default_arguments.push_back(opcodes.size());
}
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
void GDScriptByteCodeGenerator::end_parameters() {
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
function->default_arguments.reverse();
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-12 21:12:42 +00:00
void GDScriptByteCodeGenerator::write_start(GDScript *p_script, const StringName &p_function_name, bool p_static, Variant p_rpc_config, const GDScriptDataType &p_return_type) {
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
function = memnew(GDScriptFunction);
debug_stack = EngineDebugger::is_active();
function->name = p_function_name;
function->_script = p_script;
GDScript: Fix subclass script path issues
2022-12-01 10:20:42 +00:00
function->source = p_script->get_script_path();
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
#ifdef DEBUG_ENABLED
function->func_cname = (String(function->source) + " - " + String(p_function_name)).utf8();
function->_func_cname = function->func_cname.get_data();
#endif
function->_static = p_static;
function->return_type = p_return_type;
[Net] Single `rpc` annotation. "sync" no longer part of mode. - Move the "sync" property for RPCs to RPCConfig. - Unify GDScript annotations into a single one: - `@rpc(master)` # default - `@rpc(puppet)` - `@rpc(any)` # former `@remote` - Implement three additional `@rpc` options: - The second parameter is the "sync" option (which also calls the function locally when RPCing). One of "sync", "nosync". - The third parameter is the transfer mode (reliable, unreliable, ordered). - The third parameter is the channel (unused for now).
2021-06-24 08:28:15 +00:00
function->rpc_config = p_rpc_config;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
function->_argument_count = 0;
}
GDScriptFunction *GDScriptByteCodeGenerator::write_end() {
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
#ifdef DEBUG_ENABLED
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
if (!used_temporaries.is_empty()) {
ERR_PRINT("Non-zero temporary variables at end of function: " + itos(used_temporaries.size()));
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
}
#endif
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_END);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
for (int i = 0; i < temporaries.size(); i++) {
GDScript: Fix crash caused by uninitialized temp stack slots This adds initialization to every typed temporary stack slot at the beginning of the function call instead of emitting instructions, since those might be in a conditional branch and not be called.
2021-05-17 13:59:43 +00:00
int stack_index = i + max_locals + RESERVED_STACK;
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
for (int j = 0; j < temporaries[i].bytecode_indices.size(); j++) {
GDScript: Fix crash caused by uninitialized temp stack slots This adds initialization to every typed temporary stack slot at the beginning of the function call instead of emitting instructions, since those might be in a conditional branch and not be called.
2021-05-17 13:59:43 +00:00
opcodes.write[temporaries[i].bytecode_indices[j]] = stack_index | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
}
if (temporaries[i].type != Variant::NIL) {
function->temporary_slots[stack_index] = temporaries[i].type;
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
}
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
if (constant_map.size()) {
function->_constant_count = constant_map.size();
function->constants.resize(constant_map.size());
function->_constants_ptr = function->constants.ptrw();
Add a new HashMap implementation Adds a new, cleaned up, HashMap implementation. * Uses Robin Hood Hashing (https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing). * Keeps elements in a double linked list for simpler, ordered, iteration. * Allows keeping iterators for later use in removal (Unlike Map<>, it does not do much for performance vs keeping the key, but helps replace old code). * Uses a more modern C++ iterator API, deprecates the old one. * Supports custom allocator (in case there is a wish to use a paged one). This class aims to unify all the associative template usage and replace it by this one: * Map<> (whereas key order does not matter, which is 99% of cases) * HashMap<> * OrderedHashMap<> * OAHashMap<>
2022-05-08 08:09:19 +00:00
for (const KeyValue<Variant, int> &K : constant_map) {
function->constants.write[K.value] = K.key;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
} else {
function->_constants_ptr = nullptr;
function->_constant_count = 0;
}
if (name_map.size()) {
function->global_names.resize(name_map.size());
function->_global_names_ptr = &function->global_names[0];
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<StringName, int> &E : name_map) {
function->global_names.write[E.value] = E.key;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
function->_global_names_count = function->global_names.size();
} else {
function->_global_names_ptr = nullptr;
function->_global_names_count = 0;
}
if (opcodes.size()) {
function->code = opcodes;
function->_code_ptr = &function->code[0];
function->_code_size = opcodes.size();
} else {
function->_code_ptr = nullptr;
function->_code_size = 0;
}
if (function->default_arguments.size()) {
GDScript default argument override bug fix Fix: #41766
2020-09-04 21:46:23 +00:00
function->_default_arg_count = function->default_arguments.size() - 1;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
function->_default_arg_ptr = &function->default_arguments[0];
} else {
function->_default_arg_count = 0;
function->_default_arg_ptr = nullptr;
}
GDScript: Add faster operator for known types It now uses the direct operator function pointer, which increases performance in evaluation.
2020-11-13 19:47:45 +00:00
if (operator_func_map.size()) {
function->operator_funcs.resize(operator_func_map.size());
function->_operator_funcs_count = function->operator_funcs.size();
function->_operator_funcs_ptr = function->operator_funcs.ptr();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedOperatorEvaluator, int> &E : operator_func_map) {
function->operator_funcs.write[E.value] = E.key;
GDScript: Add faster operator for known types It now uses the direct operator function pointer, which increases performance in evaluation.
2020-11-13 19:47:45 +00:00
}
} else {
function->_operator_funcs_count = 0;
function->_operator_funcs_ptr = nullptr;
}
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
if (setters_map.size()) {
function->setters.resize(setters_map.size());
function->_setters_count = function->setters.size();
function->_setters_ptr = function->setters.ptr();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedSetter, int> &E : setters_map) {
function->setters.write[E.value] = E.key;
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
}
} else {
function->_setters_count = 0;
function->_setters_ptr = nullptr;
}
if (getters_map.size()) {
function->getters.resize(getters_map.size());
function->_getters_count = function->getters.size();
function->_getters_ptr = function->getters.ptr();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedGetter, int> &E : getters_map) {
function->getters.write[E.value] = E.key;
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
}
} else {
function->_getters_count = 0;
function->_getters_ptr = nullptr;
}
if (keyed_setters_map.size()) {
function->keyed_setters.resize(keyed_setters_map.size());
function->_keyed_setters_count = function->keyed_setters.size();
function->_keyed_setters_ptr = function->keyed_setters.ptr();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedKeyedSetter, int> &E : keyed_setters_map) {
function->keyed_setters.write[E.value] = E.key;
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
}
} else {
function->_keyed_setters_count = 0;
function->_keyed_setters_ptr = nullptr;
}
if (keyed_getters_map.size()) {
function->keyed_getters.resize(keyed_getters_map.size());
function->_keyed_getters_count = function->keyed_getters.size();
function->_keyed_getters_ptr = function->keyed_getters.ptr();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedKeyedGetter, int> &E : keyed_getters_map) {
function->keyed_getters.write[E.value] = E.key;
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
}
} else {
function->_keyed_getters_count = 0;
function->_keyed_getters_ptr = nullptr;
}
if (indexed_setters_map.size()) {
function->indexed_setters.resize(indexed_setters_map.size());
function->_indexed_setters_count = function->indexed_setters.size();
function->_indexed_setters_ptr = function->indexed_setters.ptr();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedIndexedSetter, int> &E : indexed_setters_map) {
function->indexed_setters.write[E.value] = E.key;
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
}
} else {
function->_indexed_setters_count = 0;
function->_indexed_setters_ptr = nullptr;
}
if (indexed_getters_map.size()) {
function->indexed_getters.resize(indexed_getters_map.size());
function->_indexed_getters_count = function->indexed_getters.size();
function->_indexed_getters_ptr = function->indexed_getters.ptr();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedIndexedGetter, int> &E : indexed_getters_map) {
function->indexed_getters.write[E.value] = E.key;
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
}
} else {
function->_indexed_getters_count = 0;
function->_indexed_getters_ptr = nullptr;
}
GDScript: Add faster call instructions for builtin methods Methods from builtin types can be called by using the function pointer when the argument and base types are known at compile time.
2020-11-18 13:32:28 +00:00
if (builtin_method_map.size()) {
function->builtin_methods.resize(builtin_method_map.size());
GDScript: Add faster instruction for validated constructor Only for built-in types.
2020-11-18 14:37:08 +00:00
function->_builtin_methods_ptr = function->builtin_methods.ptr();
GDScript: Add faster call instructions for builtin methods Methods from builtin types can be called by using the function pointer when the argument and base types are known at compile time.
2020-11-18 13:32:28 +00:00
function->_builtin_methods_count = builtin_method_map.size();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedBuiltInMethod, int> &E : builtin_method_map) {
function->builtin_methods.write[E.value] = E.key;
GDScript: Add faster call instructions for builtin methods Methods from builtin types can be called by using the function pointer when the argument and base types are known at compile time.
2020-11-18 13:32:28 +00:00
}
} else {
function->_builtin_methods_ptr = nullptr;
function->_builtin_methods_count = 0;
}
GDScript: Add faster instruction for validated constructor Only for built-in types.
2020-11-18 14:37:08 +00:00
if (constructors_map.size()) {
function->constructors.resize(constructors_map.size());
function->_constructors_ptr = function->constructors.ptr();
function->_constructors_count = constructors_map.size();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedConstructor, int> &E : constructors_map) {
function->constructors.write[E.value] = E.key;
GDScript: Add faster instruction for validated constructor Only for built-in types.
2020-11-18 14:37:08 +00:00
}
} else {
function->_constructors_ptr = nullptr;
function->_constructors_count = 0;
}
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
if (utilities_map.size()) {
function->utilities.resize(utilities_map.size());
function->_utilities_ptr = function->utilities.ptr();
function->_utilities_count = utilities_map.size();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<Variant::ValidatedUtilityFunction, int> &E : utilities_map) {
function->utilities.write[E.value] = E.key;
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
}
} else {
function->_utilities_ptr = nullptr;
function->_utilities_count = 0;
}
if (gds_utilities_map.size()) {
function->gds_utilities.resize(gds_utilities_map.size());
function->_gds_utilities_ptr = function->gds_utilities.ptr();
function->_gds_utilities_count = gds_utilities_map.size();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<GDScriptUtilityFunctions::FunctionPtr, int> &E : gds_utilities_map) {
function->gds_utilities.write[E.value] = E.key;
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
}
} else {
function->_gds_utilities_ptr = nullptr;
function->_gds_utilities_count = 0;
}
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
if (method_bind_map.size()) {
function->methods.resize(method_bind_map.size());
function->_methods_ptr = function->methods.ptrw();
function->_methods_count = method_bind_map.size();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<MethodBind *, int> &E : method_bind_map) {
function->methods.write[E.value] = E.key;
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
}
} else {
function->_methods_ptr = nullptr;
function->_methods_count = 0;
}
GDScript: Implement lambdas compilation and runtime
2021-03-28 14:03:13 +00:00
if (lambdas_map.size()) {
function->lambdas.resize(lambdas_map.size());
function->_lambdas_ptr = function->lambdas.ptrw();
function->_lambdas_count = lambdas_map.size();
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<GDScriptFunction *, int> &E : lambdas_map) {
function->lambdas.write[E.value] = E.key;
GDScript: Implement lambdas compilation and runtime
2021-03-28 14:03:13 +00:00
}
} else {
function->_lambdas_ptr = nullptr;
function->_lambdas_count = 0;
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
if (debug_stack) {
function->stack_debug = stack_debug;
}
GDScript: Pool temporary values by type on the stack So the stack slots perform less type changes, which is useful for future optimizations.
2021-04-14 17:35:51 +00:00
function->_stack_size = RESERVED_STACK + max_locals + temporaries.size();
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
function->_instruction_args_size = instr_args_max;
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
function->_ptrcall_args_size = ptrcall_max;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
#ifdef DEBUG_ENABLED
function->operator_names = operator_names;
function->setter_names = setter_names;
function->getter_names = getter_names;
function->builtin_methods_names = builtin_methods_names;
function->constructors_names = constructors_names;
function->utilities_names = utilities_names;
function->gds_utilities_names = gds_utilities_names;
#endif
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
ended = true;
return function;
}
#ifdef DEBUG_ENABLED
void GDScriptByteCodeGenerator::set_signature(const String &p_signature) {
function->profile.signature = p_signature;
}
#endif
void GDScriptByteCodeGenerator::set_initial_line(int p_line) {
function->_initial_line = p_line;
}
GDScript: Add faster operator for known types It now uses the direct operator function pointer, which increases performance in evaluation.
2020-11-13 19:47:45 +00:00
#define HAS_BUILTIN_TYPE(m_var) \
(m_var.type.has_type && m_var.type.kind == GDScriptDataType::BUILTIN)
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
#define IS_BUILTIN_TYPE(m_var, m_type) \
(m_var.type.has_type && m_var.type.kind == GDScriptDataType::BUILTIN && m_var.type.builtin_type == m_type)
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
void GDScriptByteCodeGenerator::write_type_adjust(const Address &p_target, Variant::Type p_new_type) {
switch (p_new_type) {
case Variant::BOOL:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_BOOL);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::INT:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_INT);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::FLOAT:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_FLOAT);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::STRING:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_STRING);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::VECTOR2:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR2);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::VECTOR2I:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR2I);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::RECT2:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_RECT2);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::RECT2I:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_RECT2I);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::VECTOR3:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::VECTOR3I:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3I);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::TRANSFORM2D:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_TRANSFORM2D);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
case Variant::VECTOR4:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
break;
case Variant::VECTOR4I:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_VECTOR3I);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
break;
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
case Variant::PLANE:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PLANE);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
case Variant::QUATERNION:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_QUATERNION);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::AABB:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_AABB);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::BASIS:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_BASIS);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00:00
case Variant::TRANSFORM3D:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_TRANSFORM3D);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
case Variant::PROJECTION:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PROJECTION);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
break;
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
case Variant::COLOR:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_COLOR);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::STRING_NAME:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_STRING_NAME);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::NODE_PATH:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_NODE_PATH);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::RID:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_RID);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::OBJECT:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_OBJECT);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::CALLABLE:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_CALLABLE);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::SIGNAL:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_SIGNAL);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::DICTIONARY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_DICTIONARY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_BYTE_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_BYTE_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_INT32_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_INT32_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_INT64_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_INT64_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_FLOAT32_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_FLOAT32_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_FLOAT64_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_FLOAT64_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_STRING_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_STRING_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_VECTOR2_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_VECTOR2_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_VECTOR3_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_VECTOR3_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::PACKED_COLOR_ARRAY:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_TYPE_ADJUST_PACKED_COLOR_ARRAY);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
break;
case Variant::NIL:
case Variant::VARIANT_MAX:
return;
}
append(p_target);
}
GDScript: Improve handling of operators - Use the new functions in Variant to determine the validity and resulting type of operators. - Split the operator function in codegen between binary and unary, since the unary ones have now a special requirement of having the second argument to be the NIL type when requesting info.
2020-11-26 17:41:55 +00:00
void GDScriptByteCodeGenerator::write_unary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand) {
if (HAS_BUILTIN_TYPE(p_left_operand)) {
// Gather specific operator.
Variant::ValidatedOperatorEvaluator op_func = Variant::get_validated_operator_evaluator(p_operator, p_left_operand.type.builtin_type, Variant::NIL);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_OPERATOR_VALIDATED);
GDScript: Improve handling of operators - Use the new functions in Variant to determine the validity and resulting type of operators. - Split the operator function in codegen between binary and unary, since the unary ones have now a special requirement of having the second argument to be the NIL type when requesting info.
2020-11-26 17:41:55 +00:00
append(p_left_operand);
append(Address());
append(p_target);
append(op_func);
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
#ifdef DEBUG_ENABLED
add_debug_name(operator_names, get_operation_pos(op_func), Variant::get_operator_name(p_operator));
#endif
GDScript: Improve handling of operators - Use the new functions in Variant to determine the validity and resulting type of operators. - Split the operator function in codegen between binary and unary, since the unary ones have now a special requirement of having the second argument to be the NIL type when requesting info.
2020-11-26 17:41:55 +00:00
return;
}
// No specific types, perform variant evaluation.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_OPERATOR);
GDScript: Improve handling of operators - Use the new functions in Variant to determine the validity and resulting type of operators. - Split the operator function in codegen between binary and unary, since the unary ones have now a special requirement of having the second argument to be the NIL type when requesting info.
2020-11-26 17:41:55 +00:00
append(p_left_operand);
append(Address());
append(p_target);
append(p_operator);
}
void GDScriptByteCodeGenerator::write_binary_operator(const Address &p_target, Variant::Operator p_operator, const Address &p_left_operand, const Address &p_right_operand) {
GDScript: Add faster operator for known types It now uses the direct operator function pointer, which increases performance in evaluation.
2020-11-13 19:47:45 +00:00
if (HAS_BUILTIN_TYPE(p_left_operand) && HAS_BUILTIN_TYPE(p_right_operand)) {
GDScript: Fix setting type of operator return value Also write type adjust when needed for binary operators.
2021-06-17 23:00:28 +00:00
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);
}
}
GDScript: Add faster operator for known types It now uses the direct operator function pointer, which increases performance in evaluation.
2020-11-13 19:47:45 +00:00
// 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);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_OPERATOR_VALIDATED);
GDScript: Add faster operator for known types It now uses the direct operator function pointer, which increases performance in evaluation.
2020-11-13 19:47:45 +00:00
append(p_left_operand);
append(p_right_operand);
append(p_target);
append(op_func);
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
#ifdef DEBUG_ENABLED
add_debug_name(operator_names, get_operation_pos(op_func), Variant::get_operator_name(p_operator));
#endif
GDScript: Add faster operator for known types It now uses the direct operator function pointer, which increases performance in evaluation.
2020-11-13 19:47:45 +00:00
return;
}
// No specific types, perform variant evaluation.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_OPERATOR);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_left_operand);
append(p_right_operand);
append(p_target);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_operator);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_type_test(const Address &p_target, const Address &p_source, const Address &p_type) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_EXTENDS_TEST);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_source);
append(p_type);
append(p_target);
}
void GDScriptByteCodeGenerator::write_type_test_builtin(const Address &p_target, const Address &p_source, Variant::Type p_type) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_IS_BUILTIN);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_source);
append(p_target);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_type);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_and_left_operand(const Address &p_left_operand) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_left_operand);
logic_op_jump_pos1.push_back(opcodes.size());
append(0); // Jump target, will be patched.
}
void GDScriptByteCodeGenerator::write_and_right_operand(const Address &p_right_operand) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_right_operand);
logic_op_jump_pos2.push_back(opcodes.size());
append(0); // Jump target, will be patched.
}
void GDScriptByteCodeGenerator::write_end_and(const Address &p_target) {
// If here means both operands are true.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TRUE);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
// Jump away from the fail condition.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(opcodes.size() + 3);
// Here it means one of operands is false.
patch_jump(logic_op_jump_pos1.back()->get());
patch_jump(logic_op_jump_pos2.back()->get());
logic_op_jump_pos1.pop_back();
logic_op_jump_pos2.pop_back();
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_FALSE);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
}
void GDScriptByteCodeGenerator::write_or_left_operand(const Address &p_left_operand) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP_IF);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_left_operand);
logic_op_jump_pos1.push_back(opcodes.size());
append(0); // Jump target, will be patched.
}
void GDScriptByteCodeGenerator::write_or_right_operand(const Address &p_right_operand) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP_IF);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_right_operand);
logic_op_jump_pos2.push_back(opcodes.size());
append(0); // Jump target, will be patched.
}
void GDScriptByteCodeGenerator::write_end_or(const Address &p_target) {
// If here means both operands are false.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_FALSE);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
// Jump away from the success condition.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(opcodes.size() + 3);
Fix gdscript and operator
2020-12-16 12:41:10 +00:00
// Here it means one of operands is true.
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
patch_jump(logic_op_jump_pos1.back()->get());
patch_jump(logic_op_jump_pos2.back()->get());
logic_op_jump_pos1.pop_back();
logic_op_jump_pos2.pop_back();
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TRUE);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
}
void GDScriptByteCodeGenerator::write_start_ternary(const Address &p_target) {
ternary_result.push_back(p_target);
}
void GDScriptByteCodeGenerator::write_ternary_condition(const Address &p_condition) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_condition);
ternary_jump_fail_pos.push_back(opcodes.size());
append(0); // Jump target, will be patched.
}
void GDScriptByteCodeGenerator::write_ternary_true_expr(const Address &p_expr) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(ternary_result.back()->get());
append(p_expr);
// Jump away from the false path.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
ternary_jump_skip_pos.push_back(opcodes.size());
append(0);
// Fail must jump here.
patch_jump(ternary_jump_fail_pos.back()->get());
ternary_jump_fail_pos.pop_back();
}
void GDScriptByteCodeGenerator::write_ternary_false_expr(const Address &p_expr) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(ternary_result.back()->get());
append(p_expr);
}
void GDScriptByteCodeGenerator::write_end_ternary() {
patch_jump(ternary_jump_skip_pos.back()->get());
ternary_jump_skip_pos.pop_back();
Fix nested ternary-if codegen (#55582)
2021-12-04 02:05:56 +00:00
ternary_result.pop_back();
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_set(const Address &p_target, const Address &p_index, const Address &p_source) {
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
if (HAS_BUILTIN_TYPE(p_target)) {
Only emit typed member setters if safe to do so Instructions are now only emitted if input type matches expected type. Otherwise usual setter fallback.
2021-10-05 10:39:13 +00:00
if (IS_BUILTIN_TYPE(p_index, Variant::INT) && Variant::get_member_validated_indexed_setter(p_target.type.builtin_type) &&
IS_BUILTIN_TYPE(p_source, Variant::get_indexed_element_type(p_target.type.builtin_type))) {
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
// Use indexed setter instead.
Variant::ValidatedIndexedSetter setter = Variant::get_member_validated_indexed_setter(p_target.type.builtin_type);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_SET_INDEXED_VALIDATED);
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
append(p_target);
append(p_index);
append(p_source);
append(setter);
return;
} else if (Variant::get_member_validated_keyed_setter(p_target.type.builtin_type)) {
Variant::ValidatedKeyedSetter setter = Variant::get_member_validated_keyed_setter(p_target.type.builtin_type);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_SET_KEYED_VALIDATED);
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
append(p_target);
append(p_index);
append(p_source);
append(setter);
return;
}
}
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_SET_KEYED);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
append(p_index);
append(p_source);
}
void GDScriptByteCodeGenerator::write_get(const Address &p_target, const Address &p_index, const Address &p_source) {
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
if (HAS_BUILTIN_TYPE(p_source)) {
if (IS_BUILTIN_TYPE(p_index, Variant::INT) && Variant::get_member_validated_indexed_getter(p_source.type.builtin_type)) {
// Use indexed getter instead.
Variant::ValidatedIndexedGetter getter = Variant::get_member_validated_indexed_getter(p_source.type.builtin_type);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_GET_INDEXED_VALIDATED);
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
append(p_source);
append(p_index);
append(p_target);
append(getter);
return;
} else if (Variant::get_member_validated_keyed_getter(p_source.type.builtin_type)) {
Variant::ValidatedKeyedGetter getter = Variant::get_member_validated_keyed_getter(p_source.type.builtin_type);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_GET_KEYED_VALIDATED);
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
append(p_source);
append(p_index);
append(p_target);
append(getter);
return;
}
}
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_GET_KEYED);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_source);
append(p_index);
append(p_target);
}
void GDScriptByteCodeGenerator::write_set_named(const Address &p_target, const StringName &p_name, const Address &p_source) {
Only emit typed member setters if safe to do so Instructions are now only emitted if input type matches expected type. Otherwise usual setter fallback.
2021-10-05 10:39:13 +00:00
if (HAS_BUILTIN_TYPE(p_target) && Variant::get_member_validated_setter(p_target.type.builtin_type, p_name) &&
IS_BUILTIN_TYPE(p_source, Variant::get_member_type(p_target.type.builtin_type, p_name))) {
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
Variant::ValidatedSetter setter = Variant::get_member_validated_setter(p_target.type.builtin_type, p_name);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_SET_NAMED_VALIDATED);
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
append(p_target);
append(p_source);
append(setter);
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
#ifdef DEBUG_ENABLED
add_debug_name(setter_names, get_setter_pos(setter), p_name);
#endif
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
return;
}
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_SET_NAMED);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
append(p_source);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_get_named(const Address &p_target, const StringName &p_name, const Address &p_source) {
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
if (HAS_BUILTIN_TYPE(p_source) && Variant::get_member_validated_getter(p_source.type.builtin_type, p_name)) {
Variant::ValidatedGetter getter = Variant::get_member_validated_getter(p_source.type.builtin_type, p_name);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_GET_NAMED_VALIDATED);
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
append(p_source);
append(p_target);
append(getter);
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
#ifdef DEBUG_ENABLED
add_debug_name(getter_names, get_getter_pos(getter), p_name);
#endif
GDScript: Add speficic set/get instructions When the base type is known at compile-time, we can get a direct function pointer that is faster than the regular set/get paths.
2020-11-16 15:59:53 +00:00
return;
}
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_GET_NAMED);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_source);
append(p_target);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_set_member(const Address &p_value, const StringName &p_name) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_SET_MEMBER);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_value);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_get_member(const Address &p_target, const StringName &p_name) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_GET_MEMBER);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
void GDScriptByteCodeGenerator::write_assign_with_conversion(const Address &p_target, const Address &p_source) {
switch (p_target.type.kind) {
case GDScriptDataType::BUILTIN: {
if (p_target.type.builtin_type == Variant::ARRAY && p_target.type.has_container_element_type()) {
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
const GDScriptDataType &element_type = p_target.type.get_container_element_type();
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_ARRAY);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
append(p_source);
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
append(get_constant_pos(element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
append(element_type.builtin_type);
append(element_type.native_type);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
} else {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
append(p_source);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
append(p_target.type.builtin_type);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
} break;
case GDScriptDataType::NATIVE: {
int class_idx = GDScriptLanguage::get_singleton()->get_global_map()[p_target.type.native_type];
Variant nc = GDScriptLanguage::get_singleton()->get_global_array()[class_idx];
class_idx = get_constant_pos(nc) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_NATIVE);
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 15:32:35 +00:00
append(p_target);
append(p_source);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
append(class_idx);
} break;
case GDScriptDataType::SCRIPT:
case GDScriptDataType::GDSCRIPT: {
Variant script = p_target.type.script_type;
int idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_SCRIPT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
append(p_source);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
append(idx);
} break;
default: {
ERR_PRINT("Compiler bug: unresolved assign.");
// Shouldn't get here, but fail-safe to a regular assignment
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
append(p_source);
}
}
}
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
void GDScriptByteCodeGenerator::write_assign(const Address &p_target, const Address &p_source) {
if (p_target.type.kind == GDScriptDataType::BUILTIN && p_target.type.builtin_type == Variant::ARRAY && p_target.type.has_container_element_type()) {
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
const GDScriptDataType &element_type = p_target.type.get_container_element_type();
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_ARRAY);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
append(p_target);
append(p_source);
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
append(get_constant_pos(element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
append(element_type.builtin_type);
append(element_type.native_type);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
} else if (p_target.type.kind == GDScriptDataType::BUILTIN && p_source.type.kind == GDScriptDataType::BUILTIN && p_target.type.builtin_type != p_source.type.builtin_type) {
// Need conversion.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
append(p_target);
append(p_source);
append(p_target.type.builtin_type);
} else {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 17:05:31 +00:00
append(p_target);
append(p_source);
}
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
void GDScriptByteCodeGenerator::write_assign_true(const Address &p_target) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_TRUE);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
}
void GDScriptByteCodeGenerator::write_assign_false(const Address &p_target) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN_FALSE);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
}
GDScript: Fix missing conversion for default argument values
2023-01-06 09:49:06 +00:00
void GDScriptByteCodeGenerator::write_assign_default_parameter(const Address &p_dst, const Address &p_src, bool p_use_conversion) {
if (p_use_conversion) {
write_assign_with_conversion(p_dst, p_src);
} else {
write_assign(p_dst, p_src);
}
GDScript default argument override bug fix Fix: #41766
2020-09-04 21:46:23 +00:00
function->default_arguments.push_back(opcodes.size());
}
GDScript: Fix loading of interdependent autoloads Move the autoload resolution to runtime by loading it into the stack with an extra instruction. This allows an autoload to use another autoload singleton independent of load order.
2021-09-01 19:01:39 +00:00
void GDScriptByteCodeGenerator::write_store_global(const Address &p_dst, int p_global_index) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_STORE_GLOBAL);
GDScript: Fix loading of interdependent autoloads Move the autoload resolution to runtime by loading it into the stack with an extra instruction. This allows an autoload to use another autoload singleton independent of load order.
2021-09-01 19:01:39 +00:00
append(p_dst);
append(p_global_index);
}
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
void GDScriptByteCodeGenerator::write_store_named_global(const Address &p_dst, const StringName &p_global) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_STORE_NAMED_GLOBAL);
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
append(p_dst);
append(p_global);
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
void GDScriptByteCodeGenerator::write_cast(const Address &p_target, const Address &p_source, const GDScriptDataType &p_type) {
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
int index = 0;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
switch (p_type.kind) {
case GDScriptDataType::BUILTIN: {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_CAST_TO_BUILTIN);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
index = p_type.builtin_type;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
} break;
case GDScriptDataType::NATIVE: {
int class_idx = GDScriptLanguage::get_singleton()->get_global_map()[p_type.native_type];
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
Variant nc = GDScriptLanguage::get_singleton()->get_global_array()[class_idx];
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_CAST_TO_NATIVE);
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
index = get_constant_pos(nc) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
} break;
case GDScriptDataType::SCRIPT:
case GDScriptDataType::GDSCRIPT: {
Variant script = p_type.script_type;
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
int idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_CAST_TO_SCRIPT);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
index = idx;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
} break;
default: {
return;
}
}
append(p_source);
append(p_target);
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(index);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
GDScriptCodeGenerator::Address GDScriptByteCodeGenerator::get_call_target(const GDScriptCodeGenerator::Address &p_target, Variant::Type p_type) {
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
if (p_target.mode == Address::NIL) {
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
GDScriptDataType type;
if (p_type != Variant::NIL) {
type.has_type = true;
type.kind = GDScriptDataType::BUILTIN;
type.builtin_type = p_type;
}
uint32_t addr = add_temporary(type);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
pop_temporary();
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
return Address(Address::TEMPORARY, addr, type);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
} else {
return p_target;
}
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
void GDScriptByteCodeGenerator::write_call(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_base);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
append(p_function_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_super_call(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_SELF_BASE, 1 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
append(p_function_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_call_async(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_ASYNC, 2 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_base);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
append(p_function_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
void GDScriptByteCodeGenerator::write_call_gdscript_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_GDSCRIPT_UTILITY, 1 + p_arguments.size());
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
GDScriptUtilityFunctions::FunctionPtr gds_function = GDScriptUtilityFunctions::get_function(p_function);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
append(gds_function);
#ifdef DEBUG_ENABLED
add_debug_name(gds_utilities_names, get_gds_utility_pos(gds_function), p_function);
#endif
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
void GDScriptByteCodeGenerator::write_call_utility(const Address &p_target, const StringName &p_function, const Vector<Address> &p_arguments) {
bool is_validated = true;
if (Variant::is_utility_function_vararg(p_function)) {
is_validated = true; // Vararg works fine with any argument, since they can be any type.
} else if (p_arguments.size() == Variant::get_utility_function_argument_count(p_function)) {
bool all_types_exact = true;
for (int i = 0; i < p_arguments.size(); i++) {
if (!IS_BUILTIN_TYPE(p_arguments[i], Variant::get_utility_function_argument_type(p_function, i))) {
all_types_exact = false;
break;
}
}
is_validated = all_types_exact;
}
if (is_validated) {
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
Variant::Type result_type = Variant::has_utility_function_return_value(p_function) ? Variant::get_utility_function_return_type(p_function) : Variant::NIL;
Address target = get_call_target(p_target, result_type);
Variant::Type temp_type = temporaries[target.address].type;
if (result_type != temp_type) {
write_type_adjust(target, result_type);
}
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_UTILITY_VALIDATED, 1 + p_arguments.size());
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
append(target);
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
append(p_arguments.size());
append(Variant::get_validated_utility_function(p_function));
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
#ifdef DEBUG_ENABLED
add_debug_name(utilities_names, get_utility_pos(Variant::get_validated_utility_function(p_function)), p_function);
#endif
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
} else {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_UTILITY, 1 + p_arguments.size());
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 14:56:32 +00:00
append(p_arguments.size());
append(p_function);
}
}
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, bool p_is_static, const Vector<Address> &p_arguments) {
GDScript: Add faster call instructions for builtin methods Methods from builtin types can be called by using the function pointer when the argument and base types are known at compile time.
2020-11-18 13:32:28 +00:00
bool is_validated = false;
// Check if all types are correct.
if (Variant::is_builtin_method_vararg(p_type, p_method)) {
is_validated = true; // Vararg works fine with any argument, since they can be any type.
} else if (p_arguments.size() == Variant::get_builtin_method_argument_count(p_type, p_method)) {
bool all_types_exact = true;
for (int i = 0; i < p_arguments.size(); i++) {
if (!IS_BUILTIN_TYPE(p_arguments[i], Variant::get_builtin_method_argument_type(p_type, p_method, i))) {
all_types_exact = false;
break;
}
}
is_validated = all_types_exact;
}
if (!is_validated) {
// Perform regular call.
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
if (p_is_static) {
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_BUILTIN_STATIC, p_arguments.size() + 1);
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
append(get_call_target(p_target));
append(p_type);
append(p_method);
append(p_arguments.size());
} else {
write_call(p_target, p_base, p_method, p_arguments);
}
GDScript: Add faster call instructions for builtin methods Methods from builtin types can be called by using the function pointer when the argument and base types are known at compile time.
2020-11-18 13:32:28 +00:00
return;
}
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
Variant::Type result_type = Variant::get_builtin_method_return_type(p_type, p_method);
Address target = get_call_target(p_target, result_type);
Variant::Type temp_type = temporaries[target.address].type;
if (result_type != temp_type) {
write_type_adjust(target, result_type);
GDScript: Adjust type of temporaries when needed
2021-04-16 15:04:08 +00:00
}
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_BUILTIN_TYPE_VALIDATED, 2 + p_arguments.size());
GDScript: Add faster call instructions for builtin methods Methods from builtin types can be called by using the function pointer when the argument and base types are known at compile time.
2020-11-18 13:32:28 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
append(p_base);
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
append(target);
GDScript: Add faster call instructions for builtin methods Methods from builtin types can be called by using the function pointer when the argument and base types are known at compile time.
2020-11-18 13:32:28 +00:00
append(p_arguments.size());
append(Variant::get_validated_builtin_method(p_type, p_method));
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
#ifdef DEBUG_ENABLED
add_debug_name(builtin_methods_names, get_builtin_method_pos(Variant::get_validated_builtin_method(p_type, p_method)), p_method);
#endif
GDScript: Add faster call instructions for builtin methods Methods from builtin types can be called by using the function pointer when the argument and base types are known at compile time.
2020-11-18 13:32:28 +00:00
}
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
void GDScriptByteCodeGenerator::write_call_builtin_type(const Address &p_target, const Address &p_base, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) {
write_call_builtin_type(p_target, p_base, p_type, p_method, false, p_arguments);
}
GDScript: Add support for builtin static method calls
2021-05-16 14:48:53 +00:00
GDScript: Fix temp values being written without proper clear Temporary values in the stack were not being properly cleared when the return value of calls were discarded, which can cause memory issues especially for reference types like PackedByteArray.
2023-01-11 17:24:23 +00:00
void GDScriptByteCodeGenerator::write_call_builtin_type_static(const Address &p_target, Variant::Type p_type, const StringName &p_method, const Vector<Address> &p_arguments) {
write_call_builtin_type(p_target, Address(), p_type, p_method, true, p_arguments);
GDScript: Add support for builtin static method calls
2021-05-16 14:48:53 +00:00
}
GDScript: Add support for static method calls in native types
2022-04-06 17:14:38 +00:00
void GDScriptByteCodeGenerator::write_call_native_static(const Address &p_target, const StringName &p_class, const StringName &p_method, const Vector<Address> &p_arguments) {
bool is_validated = false;
MethodBind *method = ClassDB::get_method(p_class, p_method);
if (!is_validated) {
// Perform regular call.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_NATIVE_STATIC, p_arguments.size() + 1);
GDScript: Add support for static method calls in native types
2022-04-06 17:14:38 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Add support for static method calls in native types
2022-04-06 17:14:38 +00:00
append(method);
append(p_arguments.size());
return;
}
}
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
void GDScriptByteCodeGenerator::write_call_method_bind(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL_METHOD_BIND : GDScriptFunction::OPCODE_CALL_METHOD_BIND_RET, 2 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_base);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
append(p_method);
}
void GDScriptByteCodeGenerator::write_call_ptrcall(const Address &p_target, const Address &p_base, MethodBind *p_method, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
#define CASE_TYPE(m_type) \
case Variant::m_type: \
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_PTRCALL_##m_type, 2 + p_arguments.size()); \
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
break
bool is_ptrcall = true;
if (p_method->has_return()) {
MethodInfo info;
ClassDB::get_method_info(p_method->get_instance_class(), p_method->get_name(), &info);
switch (info.return_val.type) {
CASE_TYPE(BOOL);
CASE_TYPE(INT);
CASE_TYPE(FLOAT);
CASE_TYPE(STRING);
CASE_TYPE(VECTOR2);
CASE_TYPE(VECTOR2I);
CASE_TYPE(RECT2);
CASE_TYPE(RECT2I);
CASE_TYPE(VECTOR3);
CASE_TYPE(VECTOR3I);
CASE_TYPE(TRANSFORM2D);
CASE_TYPE(PLANE);
CASE_TYPE(AABB);
CASE_TYPE(BASIS);
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00:00
CASE_TYPE(TRANSFORM3D);
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
CASE_TYPE(COLOR);
CASE_TYPE(STRING_NAME);
CASE_TYPE(NODE_PATH);
CASE_TYPE(RID);
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
CASE_TYPE(QUATERNION);
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
CASE_TYPE(OBJECT);
CASE_TYPE(CALLABLE);
CASE_TYPE(SIGNAL);
CASE_TYPE(DICTIONARY);
CASE_TYPE(ARRAY);
CASE_TYPE(PACKED_BYTE_ARRAY);
CASE_TYPE(PACKED_INT32_ARRAY);
CASE_TYPE(PACKED_INT64_ARRAY);
CASE_TYPE(PACKED_FLOAT32_ARRAY);
CASE_TYPE(PACKED_FLOAT64_ARRAY);
CASE_TYPE(PACKED_STRING_ARRAY);
CASE_TYPE(PACKED_VECTOR2_ARRAY);
CASE_TYPE(PACKED_VECTOR3_ARRAY);
CASE_TYPE(PACKED_COLOR_ARRAY);
default:
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL_METHOD_BIND : GDScriptFunction::OPCODE_CALL_METHOD_BIND_RET, 2 + p_arguments.size());
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
is_ptrcall = false;
break;
}
} else {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_PTRCALL_NO_RETURN, 2 + p_arguments.size());
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_base);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
GDScript: Add faster call instructions for native methods
2020-11-17 13:44:52 +00:00
append(p_method);
if (is_ptrcall) {
alloc_ptrcall(p_arguments.size());
}
#undef CASE_TYPE
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_call_self(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
append(GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
append(p_function_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
Fix error when calling coroutine with await in _ready The code paths for calling async functions seemed to be missing in some cases, causing a debug break and false positive error.
2020-12-04 23:42:45 +00:00
void GDScriptByteCodeGenerator::write_call_self_async(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CALL_ASYNC, 2 + p_arguments.size());
Fix error when calling coroutine with await in _ready The code paths for calling async functions seemed to be missing in some cases, causing a debug break and false positive error.
2020-12-04 23:42:45 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
append(GDScriptFunction::ADDR_SELF);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
Fix error when calling coroutine with await in _ready The code paths for calling async functions seemed to be missing in some cases, causing a debug break and false positive error.
2020-12-04 23:42:45 +00:00
append(p_arguments.size());
append(p_function_name);
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
void GDScriptByteCodeGenerator::write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(p_target.mode == Address::NIL ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN, 2 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_base);
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
append(p_function_name);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
void GDScriptByteCodeGenerator::write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures, bool p_use_self) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(p_use_self ? GDScriptFunction::OPCODE_CREATE_SELF_LAMBDA : GDScriptFunction::OPCODE_CREATE_LAMBDA, 1 + p_captures.size());
GDScript: Implement lambdas compilation and runtime
2021-03-28 14:03:13 +00:00
for (int i = 0; i < p_captures.size(); i++) {
append(p_captures[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Implement lambdas compilation and runtime
2021-03-28 14:03:13 +00:00
append(p_captures.size());
append(p_function);
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
void GDScriptByteCodeGenerator::write_construct(const Address &p_target, Variant::Type p_type, const Vector<Address> &p_arguments) {
GDScript: Add faster instruction for validated constructor Only for built-in types.
2020-11-18 14:37:08 +00:00
// Try to find an appropriate constructor.
bool all_have_type = true;
Vector<Variant::Type> arg_types;
for (int i = 0; i < p_arguments.size(); i++) {
if (!HAS_BUILTIN_TYPE(p_arguments[i])) {
all_have_type = false;
break;
}
arg_types.push_back(p_arguments[i].type.builtin_type);
}
if (all_have_type) {
int valid_constructor = -1;
for (int i = 0; i < Variant::get_constructor_count(p_type); i++) {
if (Variant::get_constructor_argument_count(p_type, i) != p_arguments.size()) {
continue;
}
int types_correct = true;
for (int j = 0; j < arg_types.size(); j++) {
if (arg_types[j] != Variant::get_constructor_argument_type(p_type, i, j)) {
types_correct = false;
break;
}
}
if (types_correct) {
valid_constructor = i;
break;
}
}
if (valid_constructor >= 0) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_VALIDATED, 1 + p_arguments.size());
GDScript: Add faster instruction for validated constructor Only for built-in types.
2020-11-18 14:37:08 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Add faster instruction for validated constructor Only for built-in types.
2020-11-18 14:37:08 +00:00
append(p_arguments.size());
append(Variant::get_validated_constructor(p_type, valid_constructor));
GDScript: Add names for disassembling function pointers When instructions use function pointers, it's not possible to retrieve their original names in the disassembly. This stores the names in vectors (in debug builds) so they can be shown.
2022-12-29 13:47:53 +00:00
#ifdef DEBUG_ENABLED
add_debug_name(constructors_names, get_constructor_pos(Variant::get_validated_constructor(p_type, valid_constructor)), Variant::get_type_name(p_type));
#endif
GDScript: Add faster instruction for validated constructor Only for built-in types.
2020-11-18 14:37:08 +00:00
return;
}
}
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT, 1 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
append(p_type);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_construct_array(const Address &p_target, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_ARRAY, 1 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 15:32:35 +00:00
void GDScriptByteCodeGenerator::write_construct_typed_array(const Address &p_target, const GDScriptDataType &p_element_type, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_TYPED_ARRAY, 2 + p_arguments.size());
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 15:32:35 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
append(get_constant_pos(p_element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 15:32:35 +00:00
append(p_arguments.size());
append(p_element_type.builtin_type);
append(p_element_type.native_type);
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
void GDScriptByteCodeGenerator::write_construct_dictionary(const Address &p_target, const Vector<Address> &p_arguments) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode_and_argcount(GDScriptFunction::OPCODE_CONSTRUCT_DICTIONARY, 1 + p_arguments.size());
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for (int i = 0; i < p_arguments.size(); i++) {
append(p_arguments[i]);
}
GDScript: Don't use the NIL address to hold return value of functions This prevents that the NIL address is filled with another value, which causes problems for some instructions that read from NIL.
2023-01-09 12:20:18 +00:00
append(get_call_target(p_target));
GDScript: Gather instructions arguments beforehand Almost all instructions need variant arguments. With this change they are loaded in an array before each instruction call. This makes the addressing code be localized to less places, improving compilation overhead and binary size by a small margin. This should not affect performance.
2020-11-13 13:31:14 +00:00
append(p_arguments.size() / 2); // This is number of key-value pairs, so only half of actual arguments.
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_await(const Address &p_target, const Address &p_operand) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_AWAIT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_operand);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_AWAIT_RESUME);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_target);
}
void GDScriptByteCodeGenerator::write_if(const Address &p_condition) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_condition);
if_jmp_addrs.push_back(opcodes.size());
append(0); // Jump destination, will be patched.
}
void GDScriptByteCodeGenerator::write_else() {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP); // Jump from true if block;
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
int else_jmp_addr = opcodes.size();
append(0); // Jump destination, will be patched.
patch_jump(if_jmp_addrs.back()->get());
if_jmp_addrs.pop_back();
if_jmp_addrs.push_back(else_jmp_addr);
}
void GDScriptByteCodeGenerator::write_endif() {
patch_jump(if_jmp_addrs.back()->get());
if_jmp_addrs.pop_back();
}
GDScript: Fix setter being called in chains for shared types When a type is shared (i.e. passed by reference) it doesn't need to be called in a setter chain (e.g. `a.b.c = 0`) since it will be updated in place. This commit adds an instruction that jumps when the value is shared so it can be used to skip those cases and avoid redundant calls of setters. It also solves issues when assigning to sub-properties of read-only properties.
2022-06-27 15:09:51 +00:00
void GDScriptByteCodeGenerator::write_jump_if_shared(const Address &p_value) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_SHARED);
GDScript: Fix setter being called in chains for shared types When a type is shared (i.e. passed by reference) it doesn't need to be called in a setter chain (e.g. `a.b.c = 0`) since it will be updated in place. This commit adds an instruction that jumps when the value is shared so it can be used to skip those cases and avoid redundant calls of setters. It also solves issues when assigning to sub-properties of read-only properties.
2022-06-27 15:09:51 +00:00
append(p_value);
if_jmp_addrs.push_back(opcodes.size());
append(0); // Jump destination, will be patched.
}
void GDScriptByteCodeGenerator::write_end_jump_if_shared() {
patch_jump(if_jmp_addrs.back()->get());
if_jmp_addrs.pop_back();
}
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
void GDScriptByteCodeGenerator::start_for(const GDScriptDataType &p_iterator_type, const GDScriptDataType &p_list_type) {
Address counter(Address::LOCAL_VARIABLE, add_local("@counter_pos", p_iterator_type), p_iterator_type);
Address container(Address::LOCAL_VARIABLE, add_local("@container_pos", p_list_type), p_list_type);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
// Store state.
for_counter_variables.push_back(counter);
for_container_variables.push_back(container);
}
void GDScriptByteCodeGenerator::write_for_assignment(const Address &p_variable, const Address &p_list) {
const Address &container = for_container_variables.back()->get();
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
// Assign container.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSIGN);
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
append(container);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_list);
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
for_iterator_variables.push_back(p_variable);
}
void GDScriptByteCodeGenerator::write_for() {
const Address &iterator = for_iterator_variables.back()->get();
const Address &counter = for_counter_variables.back()->get();
const Address &container = for_container_variables.back()->get();
current_breaks_to_patch.push_back(List<int>());
GDScript: Add typed iterate instructions
2020-10-07 12:36:48 +00:00
GDScriptFunction::Opcode begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN;
GDScriptFunction::Opcode iterate_opcode = GDScriptFunction::OPCODE_ITERATE;
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
if (container.type.has_type) {
if (container.type.kind == GDScriptDataType::BUILTIN) {
switch (container.type.builtin_type) {
GDScript: Add typed iterate instructions
2020-10-07 12:36:48 +00:00
case Variant::INT:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_INT;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_INT;
break;
case Variant::FLOAT:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_FLOAT;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_FLOAT;
break;
case Variant::VECTOR2:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_VECTOR2;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_VECTOR2;
break;
case Variant::VECTOR2I:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_VECTOR2I;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_VECTOR2I;
break;
case Variant::VECTOR3:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_VECTOR3;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_VECTOR3;
break;
case Variant::VECTOR3I:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_VECTOR3I;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_VECTOR3I;
break;
case Variant::STRING:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_STRING;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_STRING;
break;
case Variant::DICTIONARY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_DICTIONARY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_DICTIONARY;
break;
case Variant::ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_ARRAY;
break;
case Variant::PACKED_BYTE_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_BYTE_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_BYTE_ARRAY;
break;
case Variant::PACKED_INT32_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_INT32_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_INT32_ARRAY;
break;
case Variant::PACKED_INT64_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_INT64_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_INT64_ARRAY;
break;
case Variant::PACKED_FLOAT32_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_FLOAT32_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_FLOAT32_ARRAY;
break;
case Variant::PACKED_FLOAT64_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_FLOAT64_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_FLOAT64_ARRAY;
break;
case Variant::PACKED_STRING_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_STRING_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_STRING_ARRAY;
break;
case Variant::PACKED_VECTOR2_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_VECTOR2_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_VECTOR2_ARRAY;
break;
case Variant::PACKED_VECTOR3_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_VECTOR3_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_VECTOR3_ARRAY;
break;
case Variant::PACKED_COLOR_ARRAY:
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_PACKED_COLOR_ARRAY;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_PACKED_COLOR_ARRAY;
break;
default:
break;
}
} else {
begin_opcode = GDScriptFunction::OPCODE_ITERATE_BEGIN_OBJECT;
iterate_opcode = GDScriptFunction::OPCODE_ITERATE_OBJECT;
}
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
// Begin loop.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(begin_opcode);
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
append(counter);
append(container);
append(iterator);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for_jmp_addrs.push_back(opcodes.size());
append(0); // End of loop address, will be patched.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(opcodes.size() + 6); // Skip over 'continue' code.
// Next iteration.
int continue_addr = opcodes.size();
continue_addrs.push_back(continue_addr);
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(iterate_opcode);
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
append(counter);
append(container);
append(iterator);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
for_jmp_addrs.push_back(opcodes.size());
append(0); // Jump destination, will be patched.
}
void GDScriptByteCodeGenerator::write_endfor() {
// Jump back to loop check.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(continue_addrs.back()->get());
continue_addrs.pop_back();
// Patch end jumps (two of them).
for (int i = 0; i < 2; i++) {
patch_jump(for_jmp_addrs.back()->get());
for_jmp_addrs.pop_back();
}
// Patch break statements.
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const int &E : current_breaks_to_patch.back()->get()) {
patch_jump(E);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
current_breaks_to_patch.pop_back();
GDScript: Fix mishandling of stack pointers - Replace the for loop temporaries by locals. They cause conflicts with the stack when being popped, while locals are properly handled in the scope. - Change the interface for the codegen so the for loop list doesn't live through the whole block if it's a temporary. - Keep track of the actual amount of local variables in the stack. Using the size of the map is misleading in cases where multiple locals have the same name (which is allowed when there's no shadowing). - Added a few debug checks for temporaries, to avoid them being wrongly manipulated in the future. They should not live more than a line of code. - Rearrange some of compiler code to make sure the temporaries don't live across blocks.
2020-11-22 15:24:40 +00:00
// Pop state.
for_iterator_variables.pop_back();
for_counter_variables.pop_back();
for_container_variables.pop_back();
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::start_while_condition() {
current_breaks_to_patch.push_back(List<int>());
continue_addrs.push_back(opcodes.size());
}
void GDScriptByteCodeGenerator::write_while(const Address &p_condition) {
// Condition check.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP_IF_NOT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_condition);
while_jmp_addrs.push_back(opcodes.size());
append(0); // End of loop address, will be patched.
}
void GDScriptByteCodeGenerator::write_endwhile() {
// Jump back to loop check.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(continue_addrs.back()->get());
continue_addrs.pop_back();
// Patch end jump.
patch_jump(while_jmp_addrs.back()->get());
while_jmp_addrs.pop_back();
// Patch break statements.
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const int &E : current_breaks_to_patch.back()->get()) {
patch_jump(E);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
current_breaks_to_patch.pop_back();
}
void GDScriptByteCodeGenerator::write_break() {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
current_breaks_to_patch.back()->get().push_back(opcodes.size());
append(0);
}
void GDScriptByteCodeGenerator::write_continue() {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_JUMP);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(continue_addrs.back()->get());
}
void GDScriptByteCodeGenerator::write_breakpoint() {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_BREAKPOINT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_newline(int p_line) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_LINE);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_line);
current_line = p_line;
}
void GDScriptByteCodeGenerator::write_return(const Address &p_return_value) {
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
if (!function->return_type.has_type || p_return_value.type.has_type) {
// Either the function is untyped or the return value is also typed.
// If this is a typed function, then we need to check for potential conversions.
if (function->return_type.has_type) {
if (function->return_type.kind == GDScriptDataType::BUILTIN && function->return_type.builtin_type == Variant::ARRAY && function->return_type.has_container_element_type()) {
// Typed array.
const GDScriptDataType &element_type = function->return_type.get_container_element_type();
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_ARRAY);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
append(get_constant_pos(element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
append(element_type.builtin_type);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(element_type.native_type);
} else if (function->return_type.kind == GDScriptDataType::BUILTIN && p_return_value.type.kind == GDScriptDataType::BUILTIN && function->return_type.builtin_type != p_return_value.type.builtin_type) {
// Add conversion.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_BUILTIN);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
append(function->return_type.builtin_type);
} else {
// Just assign.
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
}
} else {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
}
} else {
switch (function->return_type.kind) {
case GDScriptDataType::BUILTIN: {
if (function->return_type.builtin_type == Variant::ARRAY && function->return_type.has_container_element_type()) {
const GDScriptDataType &element_type = function->return_type.get_container_element_type();
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_ARRAY);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
append(get_constant_pos(element_type.script_type) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS));
append(element_type.builtin_type);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(element_type.native_type);
} else {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_BUILTIN);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
append(function->return_type.builtin_type);
}
} break;
case GDScriptDataType::NATIVE: {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_NATIVE);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
int class_idx = GDScriptLanguage::get_singleton()->get_global_map()[function->return_type.native_type];
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
Variant nc = GDScriptLanguage::get_singleton()->get_global_array()[class_idx];
class_idx = get_constant_pos(nc) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(class_idx);
} break;
case GDScriptDataType::GDSCRIPT:
case GDScriptDataType::SCRIPT: {
Variant script = function->return_type.script_type;
Reduce number of addressing modes in GDScript VM There's now only 3 addressing modes: stack, constant, and member. Self, class, and nil are now present respectively in the first 3 stack slots. Global and class constants are moved to local constants when compiling. Named globals is only present on editor to use on tool singletons, so its use now emits a new instruction to copy the global to the stack. This allow us to further optimize the VM later by embedding the addressing modes in the instructions themselves, which is better done with less permutations.
2021-04-08 14:55:24 +00:00
int script_idx = get_constant_pos(script) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN_TYPED_SCRIPT);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
append(script_idx);
} break;
default: {
ERR_PRINT("Compiler bug: unresolved return.");
// Shouldn't get here, but fail-safe to a regular return;
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_RETURN);
GDScript: Properly validate return type When the type cannot be validated at compile time, the runtime must do a check to ensure type safety is kept, as the code might be assuming the return type is correct in another place, leading to crashes if the contract is broken.
2021-04-02 13:34:44 +00:00
append(p_return_value);
} break;
}
}
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
}
void GDScriptByteCodeGenerator::write_assert(const Address &p_test, const Address &p_message) {
Optimizations for GDScript VM * Removed instruction argument count and instruction prefetching. This is now done on the fly. Reduces jumps. * OPCODE_DISPATCH now goes directly to the next instruction, like in Godot 3.x. I have nothing I can use to test performance, so if anyone wants to lend a hand and compare with master (both on debug and release), it would be very welcome.
2023-01-02 14:29:44 +00:00
append_opcode(GDScriptFunction::OPCODE_ASSERT);
Add GDScript code generation interface Implement the abstraction by targeting the current VM.
2020-07-28 18:17:49 +00:00
append(p_test);
append(p_message);
}
void GDScriptByteCodeGenerator::start_block() {
push_stack_identifiers();
}
void GDScriptByteCodeGenerator::end_block() {
pop_stack_identifiers();
}
GDScriptByteCodeGenerator::~GDScriptByteCodeGenerator() {
if (!ended && function != nullptr) {
memdelete(function);
}
}
Reference in New Issue Copy Permalink