Skip to content

Commit 537afa8

Browse files
qubkaqubka
committed
Update api
1 parent 4a09701 commit 537afa8

File tree

4 files changed

+46
-46
lines changed

4 files changed

+46
-46
lines changed

‎CMakeLists.txt

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,7 @@ set(GOLM_PCH_FILE "src/pch.h")
4545
add_library(${PROJECT_NAME} SHARED ${GOLM_SOURCES})
4646
target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
4747

48-
set(GOLM_LINK_LIBRARIES plugify::plugify plugify::plugify-function plugify::plugify-assembly plugify::plugify-assembly asmjit::asmjit dyncall_s)
48+
set(GOLM_LINK_LIBRARIES plugify::plugify plugify::plugify-assembly asmjit::asmjit dyncall_s dyncallback_s)
4949

5050
if(NOT COMPILER_SUPPORTS_FORMAT)
5151
set(GOLM_LINK_LIBRARIES ${GOLM_LINK_LIBRARIES} fmt::fmt-header-only)

‎external/plugify

‎src/module.cpp

Lines changed: 41 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -330,13 +330,13 @@ LoadResult GoLanguageModule::OnPluginLoad(PluginRef plugin) {
330330
if (IsMethodPrimitive(method)) {
331331
methods.emplace_back(method, func);
332332
} else {
333-
auto function = std::make_unique<Function>(_rt);
334-
func = function->GetJitFunc(method, &InternalCall, func);
333+
JitCallback callback(_rt);
334+
func = callback.GetJitFunc(method, &InternalCall, func);
335335
if (!func) {
336336
funcErrors.emplace_back(method.GetName());
337337
continue;
338338
}
339-
_functions.emplace_back(std::move(function));
339+
_functions.emplace_back(std::move(callback));
340340
methods.emplace_back(method, func);
341341
}
342342
} else {
@@ -402,7 +402,7 @@ void GoLanguageModule::GetNativeMethod(std::string_view methodName, plugify::Mem
402402
}
403403

404404
// C++ to Go
405-
void GoLanguageModule::InternalCall(MethodRef method, MemAddr addr, const Parameters* p, uint8_t count, const ReturnValue* ret) {
405+
void GoLanguageModule::InternalCall(MethodRef method, MemAddr addr, const JitCallback::Parameters* p, uint8_t count, const JitCallback::Return* ret) {
406406
PropertyRef retProp = method.GetReturnType();
407407
ValueType retType = retProp.GetType();
408408
std::span<const PropertyRef> paramProps = method.GetParamTypes();
@@ -699,244 +699,244 @@ void GoLanguageModule::InternalCall(MethodRef method, MemAddr addr, const Parame
699699
}
700700
case ValueType::Bool: {
701701
bool val = dcCallBool(vm, addr);
702-
ret->SetReturnPtr(val);
702+
ret->SetReturn(val);
703703
break;
704704
}
705705
case ValueType::Char8: {
706706
char16_t val = static_cast<char16_t>(dcCallChar(vm, addr));
707-
ret->SetReturnPtr(val);
707+
ret->SetReturn(val);
708708
break;
709709
}
710710
case ValueType::Char16: {
711711
char16_t val = static_cast<char16_t>(dcCallShort(vm, addr));
712-
ret->SetReturnPtr(val);
712+
ret->SetReturn(val);
713713
break;
714714
}
715715
case ValueType::Int8: {
716716
int8_t val = dcCallChar(vm, addr);
717-
ret->SetReturnPtr(val);
717+
ret->SetReturn(val);
718718
break;
719719
}
720720
case ValueType::Int16: {
721721
int16_t val = dcCallShort(vm, addr);
722-
ret->SetReturnPtr(val);
722+
ret->SetReturn(val);
723723
break;
724724
}
725725
case ValueType::Int32: {
726726
int32_t val = dcCallInt(vm, addr);
727-
ret->SetReturnPtr(val);
727+
ret->SetReturn(val);
728728
break;
729729
}
730730
case ValueType::Int64: {
731731
int64_t val = dcCallLongLong(vm, addr);
732-
ret->SetReturnPtr(val);
732+
ret->SetReturn(val);
733733
break;
734734
}
735735
case ValueType::UInt8: {
736736
uint8_t val = static_cast<uint8_t>(dcCallChar(vm, addr));
737-
ret->SetReturnPtr(val);
737+
ret->SetReturn(val);
738738
break;
739739
}
740740
case ValueType::UInt16: {
741741
uint16_t val = static_cast<uint16_t>(dcCallShort(vm, addr));
742-
ret->SetReturnPtr(val);
742+
ret->SetReturn(val);
743743
break;
744744
}
745745
case ValueType::UInt32: {
746746
uint32_t val = static_cast<uint32_t>(dcCallInt(vm, addr));
747-
ret->SetReturnPtr(val);
747+
ret->SetReturn(val);
748748
break;
749749
}
750750
case ValueType::UInt64: {
751751
uint64_t val = static_cast<uint64_t>(dcCallLongLong(vm, addr));
752-
ret->SetReturnPtr(val);
752+
ret->SetReturn(val);
753753
break;
754754
}
755755
case ValueType::Pointer: {
756756
void* val = dcCallPointer(vm, addr);
757-
ret->SetReturnPtr(val);
757+
ret->SetReturn(val);
758758
break;
759759
}
760760
case ValueType::Float: {
761761
float val = dcCallFloat(vm, addr);
762-
ret->SetReturnPtr(val);
762+
ret->SetReturn(val);
763763
break;
764764
}
765765
case ValueType::Double: {
766766
double val = dcCallDouble(vm, addr);
767-
ret->SetReturnPtr(val);
767+
ret->SetReturn(val);
768768
break;
769769
}
770770
case ValueType::Function: {
771771
void* val = dcCallPointer(vm, addr);
772-
ret->SetReturnPtr(val);
772+
ret->SetReturn(val);
773773
break;
774774
}
775775
case ValueType::Vector2: {
776776
Vector2 source;
777777
dcCallAggr(vm, addr, ag, &source);
778-
ret->SetReturnPtr(source);
778+
ret->SetReturn(source);
779779
break;
780780
}
781781
#if GOLM_PLATFORM_WINDOWS
782782
case ValueType::Vector3: {
783783
auto* dest = p->GetArgument<Vector3*>(0);
784784
dcCallAggr(vm, addr, ag, dest);
785-
ret->SetReturnPtr(dest);
785+
ret->SetReturn(dest);
786786
break;
787787
}
788788
case ValueType::Vector4: {
789789
auto* dest = p->GetArgument<Vector4*>(0);
790790
dcCallAggr(vm, addr, ag, dest);
791-
ret->SetReturnPtr(dest);
791+
ret->SetReturn(dest);
792792
break;
793793
}
794794
#else
795795
case ValueType::Vector3: {
796796
Vector3 source;
797797
dcCallAggr(vm, addr, ag, &source);
798-
ret->SetReturnPtr(source);
798+
ret->SetReturn(source);
799799
break;
800800
}
801801
case ValueType::Vector4: {
802802
Vector4 source;
803803
dcCallAggr(vm, addr, ag, &source);
804-
ret->SetReturnPtr(source);
804+
ret->SetReturn(source);
805805
break;
806806
}
807807
#endif
808808
case ValueType::Matrix4x4: {
809809
auto* dest = p->GetArgument<Matrix4x4*>(0);
810810
dcCallAggr(vm, addr, ag, dest);
811-
ret->SetReturnPtr(dest);
811+
ret->SetReturn(dest);
812812
break;
813813
}
814814
case ValueType::String: {
815815
auto* dest = p->GetArgument<plg::string*>(0);
816816
GoString source;
817817
dcCallAggr(vm, addr, ag, &source);
818818
CopyGoStringToStringReturn(source, *dest);
819-
ret->SetReturnPtr(dest);
819+
ret->SetReturn(dest);
820820
break;
821821
}
822822
case ValueType::ArrayBool: {
823823
auto* dest = p->GetArgument<std::vector<bool>*>(0);
824824
GoSlice source;
825825
dcCallAggr(vm, addr, ag, &source);
826826
CopyGoSliceToVectorReturn(source, *dest);
827-
ret->SetReturnPtr(dest);
827+
ret->SetReturn(dest);
828828
break;
829829
}
830830
case ValueType::ArrayChar8: {
831831
auto* dest = p->GetArgument<std::vector<char>*>(0);
832832
GoSlice source;
833833
dcCallAggr(vm, addr, ag, &source);
834834
CopyGoSliceToVectorReturn(source, *dest);
835-
ret->SetReturnPtr(dest);
835+
ret->SetReturn(dest);
836836
break;
837837
}
838838
case ValueType::ArrayChar16: {
839839
auto* dest = p->GetArgument<std::vector<char16_t>*>(0);
840840
GoSlice source;
841841
dcCallAggr(vm, addr, ag, &source);
842842
CopyGoSliceToVectorReturn(source, *dest);
843-
ret->SetReturnPtr(dest);
843+
ret->SetReturn(dest);
844844
break;
845845
}
846846
case ValueType::ArrayInt8: {
847847
auto* dest = p->GetArgument<std::vector<int8_t>*>(0);
848848
GoSlice source;
849849
dcCallAggr(vm, addr, ag, &source);
850850
CopyGoSliceToVectorReturn(source, *dest);
851-
ret->SetReturnPtr(dest);
851+
ret->SetReturn(dest);
852852
break;
853853
}
854854
case ValueType::ArrayInt16: {
855855
auto* dest = p->GetArgument<std::vector<int16_t>*>(0);
856856
GoSlice source;
857857
dcCallAggr(vm, addr, ag, &source);
858858
CopyGoSliceToVectorReturn(source, *dest);
859-
ret->SetReturnPtr(dest);
859+
ret->SetReturn(dest);
860860
break;
861861
}
862862
case ValueType::ArrayInt32: {
863863
auto* dest = p->GetArgument<std::vector<int32_t>*>(0);
864864
GoSlice source;
865865
dcCallAggr(vm, addr, ag, &source);
866866
CopyGoSliceToVectorReturn(source, *dest);
867-
ret->SetReturnPtr(dest);
867+
ret->SetReturn(dest);
868868
break;
869869
}
870870
case ValueType::ArrayInt64: {
871871
auto* dest = p->GetArgument<std::vector<int64_t>*>(0);
872872
GoSlice source;
873873
dcCallAggr(vm, addr, ag, &source);
874874
CopyGoSliceToVectorReturn(source, *dest);
875-
ret->SetReturnPtr(dest);
875+
ret->SetReturn(dest);
876876
break;
877877
}
878878
case ValueType::ArrayUInt8: {
879879
auto* dest = p->GetArgument<std::vector<uint8_t>*>(0);
880880
GoSlice source;
881881
dcCallAggr(vm, addr, ag, &source);
882882
CopyGoSliceToVectorReturn(source, *dest);
883-
ret->SetReturnPtr(dest);
883+
ret->SetReturn(dest);
884884
break;
885885
}
886886
case ValueType::ArrayUInt16: {
887887
auto* dest = p->GetArgument<std::vector<uint16_t>*>(0);
888888
GoSlice source;
889889
dcCallAggr(vm, addr, ag, &source);
890890
CopyGoSliceToVectorReturn(source, *dest);
891-
ret->SetReturnPtr(dest);
891+
ret->SetReturn(dest);
892892
break;
893893
}
894894
case ValueType::ArrayUInt32: {
895895
auto* dest = p->GetArgument<std::vector<uint32_t>*>(0);
896896
GoSlice source;
897897
dcCallAggr(vm, addr, ag, &source);
898898
CopyGoSliceToVectorReturn(source, *dest);
899-
ret->SetReturnPtr(dest);
899+
ret->SetReturn(dest);
900900
break;
901901
}
902902
case ValueType::ArrayUInt64: {
903903
auto* dest = p->GetArgument<std::vector<uint64_t>*>(0);
904904
GoSlice source;
905905
dcCallAggr(vm, addr, ag, &source);
906906
CopyGoSliceToVectorReturn(source, *dest);
907-
ret->SetReturnPtr(dest);
907+
ret->SetReturn(dest);
908908
break;
909909
}
910910
case ValueType::ArrayPointer: {
911911
auto* dest = p->GetArgument<std::vector<uintptr_t>*>(0);
912912
GoSlice source;
913913
dcCallAggr(vm, addr, ag, &source);
914914
CopyGoSliceToVectorReturn(source, *dest);
915-
ret->SetReturnPtr(dest);
915+
ret->SetReturn(dest);
916916
break;
917917
}
918918
case ValueType::ArrayFloat: {
919919
auto* dest = p->GetArgument<std::vector<float>*>(0);
920920
GoSlice source;
921921
dcCallAggr(vm, addr, ag, &source);
922922
CopyGoSliceToVectorReturn(source, *dest);
923-
ret->SetReturnPtr(dest);
923+
ret->SetReturn(dest);
924924
break;
925925
}
926926
case ValueType::ArrayDouble: {
927927
auto* dest = p->GetArgument<std::vector<double>*>(0);
928928
GoSlice source;
929929
dcCallAggr(vm, addr, ag, &source);
930930
CopyGoSliceToVectorReturn(source, *dest);
931-
ret->SetReturnPtr(dest);
931+
ret->SetReturn(dest);
932932
break;
933933
}
934934
case ValueType::ArrayString: {
935935
auto* dest = p->GetArgument<std::vector<plg::string>*>(0);
936936
GoSlice source;
937937
dcCallAggr(vm, addr, ag, &source);
938938
CopyGoSliceToVectorReturn(source, *dest);
939-
ret->SetReturnPtr(dest);
939+
ret->SetReturn(dest);
940940
break;
941941
}
942942
default:

‎src/module.h

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
#include <asmjit/asmjit.h>
44
#include <module_export.h>
55
#include <plugify/assembly.h>
6-
#include <plugify/function.h>
6+
#include <plugify/jit/callback.h>
77
#include <plugify/language_module.h>
88
#include <plugify/module.h>
99

@@ -106,7 +106,7 @@ namespace golm {
106106
void GetNativeMethod(std::string_view methodName, plugify::MemAddr* addressDest);
107107

108108
private:
109-
static void InternalCall(plugify::MethodRef method, plugify::MemAddr data, const plugify::Parameters* params, uint8_t count, const plugify::ReturnValue* ret);
109+
static void InternalCall(plugify::MethodRef method, plugify::MemAddr data, const plugify::JitCallback::Parameters* params, uint8_t count, const plugify::JitCallback::Return* ret);
110110
static void DetectLeaks();
111111

112112
private:
@@ -116,7 +116,7 @@ namespace golm {
116116
std::map<plugify::UniqueId, AssemblyHolder> _assemblyMap;
117117
std::unordered_map<std::string, plugify::MemAddr, string_hash, std::equal_to<>> _nativesMap;
118118

119-
std::vector<std::unique_ptr<plugify::Function>> _functions;
119+
std::vector<plugify::JitCallback> _functions;
120120
std::vector<plugify::MemAddr*> _addresses;
121121

122122
static const std::array<void*, 35> _pluginApi;

0 commit comments

Comments
 (0)