Enable a bunch of p/invokes

Author: grendello

src/native/clr/host/CMakeLists.txt

@@ -30,8 +30,11 @@ set(XAMARIN_MONODROID_SOURCES
   host.cc
   host-jni.cc
   host-util.cc
+  internal-pinvokes.cc
   os-bridge.cc
+  runtime-util.cc
   typemap.cc
+  xamarin_getifaddrs.cc
 )
 
 list(APPEND LOCAL_CLANG_CHECK_SOURCES

src/native/clr/host/host.cc

@@ -13,6 +13,7 @@
 #include <host/host-jni.hh>
 #include <host/host-util.hh>
 #include <host/os-bridge.hh>
+#include <host/runtime-util.hh>
 #include <runtime-base/android-system.hh>
 #include <runtime-base/jni-wrappers.hh>
 #include <runtime-base/logger.hh>
@@ -264,7 +265,7 @@ void Host::Java_mono_android_Runtime_initInternal (JNIEnv *env, jclass runtimeCl
 
 	size_t total_time_index;
 	if (FastTiming::enabled ()) [[unlikely]] {
-		_timing = std::make_unique<Timing> ();
+		_timing = std::make_shared<Timing> ();
 		total_time_index = internal_timing.start_event (TimingEventKind::TotalRuntimeInit);
 	}
 
@@ -278,6 +279,8 @@ void Host::Java_mono_android_Runtime_initInternal (JNIEnv *env, jclass runtimeCl
 	Util::set_environment_variable_for_directory ("HOME", home);
 	create_xdg_directories_and_environment (home);
 
+	java_TimeZone = RuntimeUtil::get_class_from_runtime_field (env, runtimeClass, "java_util_TimeZone", true);
+
 	AndroidSystem::detect_embedded_dso_mode (applicationDirs);
 	AndroidSystem::set_running_in_emulator (isEmulator);
 	AndroidSystem::set_primary_override_dir (home);

src/native/clr/host/internal-pinvokes.cc

@@ -0,0 +1,194 @@
+#include <host/host.hh>
+#include <host/os-bridge.hh>
+#include <host/typemap.hh>
+#include <runtime-base/android-system.hh>
+#include <runtime-base/cpu-arch.hh>
+#include <runtime-base/internal-pinvokes.hh>
+#include <runtime-base/jni-remapping.hh>
+
+using namespace xamarin::android;
+
+int _monodroid_gref_get () noexcept
+{
+	return OSBridge::get_gc_gref_count ();
+}
+
+void _monodroid_gref_log (const char *message) noexcept
+{
+}
+
+int _monodroid_gref_log_new (jobject curHandle, char curType, jobject newHandle, char newType, const char *threadName, int threadId, const char *from, int from_writable) noexcept
+{
+	return OSBridge::_monodroid_gref_log_new (curHandle, curType, newHandle, newType, threadName, threadId, from, from_writable);
+}
+
+void _monodroid_gref_log_delete (jobject handle, char type, const char *threadName, int threadId, const char *from, int from_writable) noexcept
+{
+}
+
+const char* clr_typemap_managed_to_java (const char *typeName, const uint8_t *mvid) noexcept
+{
+	return TypeMapper::typemap_managed_to_java (typeName, mvid);
+}
+
+bool clr_typemap_java_to_managed (const char *java_type_name, char const** assembly_name, uint32_t *managed_type_token_id) noexcept
+{
+	return TypeMapper::typemap_java_to_managed (java_type_name, assembly_name, managed_type_token_id);
+}
+
+void monodroid_log (LogLevel level, LogCategories category, const char *message) noexcept
+{
+	switch (level) {
+		case LogLevel::Verbose:
+		case LogLevel::Debug:
+			log_debug_nocheck (category, std::string_view { message });
+			break;
+
+		case LogLevel::Info:
+			log_info_nocheck (category, std::string_view { message });
+			break;
+
+		case LogLevel::Warn:
+		case LogLevel::Silent: // warn is always printed
+			log_warn (category, std::string_view { message });
+			break;
+
+		case LogLevel::Error:
+			log_error (category, std::string_view { message });
+			break;
+
+		case LogLevel::Fatal:
+			log_fatal (category, std::string_view { message });
+			break;
+
+		default:
+		case LogLevel::Unknown:
+		case LogLevel::Default:
+			log_info_nocheck (category, std::string_view { message });
+			break;
+	}
+}
+
+char* monodroid_TypeManager_get_java_class_name (jclass klass) noexcept
+{
+	return Host::get_java_class_name_for_TypeManager (klass);
+}
+
+void monodroid_free (void *ptr) noexcept
+{
+	free (ptr);
+}
+
+const char*
+_monodroid_lookup_replacement_type (const char *jniSimpleReference)
+{
+	return JniRemapping::lookup_replacement_type (jniSimpleReference);
+}
+
+const JniRemappingReplacementMethod*
+_monodroid_lookup_replacement_method_info (const char *jniSourceType, const char *jniMethodName, const char *jniMethodSignature)
+{
+	return JniRemapping::lookup_replacement_method_info (jniSourceType, jniMethodName, jniMethodSignature);
+}
+
+managed_timing_sequence* monodroid_timing_start (const char *message)
+{
+	// Technically a reference here is against the idea of shared pointers, but
+	// in this instance it's fine since we know we won't be storing the pointer
+	// and this way things are slightly faster.
+	std::shared_ptr<Timing> const &timing = Host::get_timing ();
+	if (!timing) {
+		return nullptr;
+	}
+
+	managed_timing_sequence *ret = timing->get_available_sequence ();
+	if (message != nullptr) {
+		log_write (LOG_TIMING, LogLevel::Info, message);
+	}
+	ret->period.mark_start ();
+	return ret;
+}
+
+void monodroid_timing_stop (managed_timing_sequence *sequence, const char *message)
+{
+	static constexpr const char DEFAULT_MESSAGE[] = "Managed Timing";
+	if (sequence == nullptr) {
+		return;
+	}
+
+	std::shared_ptr<Timing> const &timing = Host::get_timing ();
+	if (!timing) [[unlikely]] {
+		return;
+	}
+
+	sequence->period.mark_end ();
+	Timing::info (sequence->period, message == nullptr ? DEFAULT_MESSAGE : message);
+	timing->release_sequence (sequence);
+}
+
+void _monodroid_weak_gref_new (jobject curHandle, char curType, jobject newHandle, char newType, const char *threadName, int threadId, const char *from, int from_writable)
+{
+	OSBridge::_monodroid_weak_gref_new (curHandle, curType, newHandle, newType, threadName, threadId, from, from_writable);
+}
+
+int _monodroid_weak_gref_get ()
+{
+	return OSBridge::get_gc_weak_gref_count ();
+}
+
+int _monodroid_max_gref_get ()
+{
+	return static_cast<int>(AndroidSystem::get_max_gref_count ());
+}
+
+void _monodroid_weak_gref_delete (jobject handle, char type, const char *threadName, int threadId, const char *from, int from_writable)
+{
+	OSBridge::_monodroid_weak_gref_delete (handle, type, threadName, threadId, from, from_writable);
+}
+
+void _monodroid_lref_log_new (int lrefc, jobject handle, char type, const char *threadName, int threadId, const char *from, int from_writable)
+{
+	OSBridge::_monodroid_lref_log_new (lrefc, handle, type, threadName, threadId, from, from_writable);
+}
+
+void _monodroid_lref_log_delete (int lrefc, jobject handle, char type, const char *threadName, int threadId, const char *from, int from_writable)
+{
+	OSBridge::_monodroid_lref_log_delete (lrefc, handle, type, threadName, threadId, from, from_writable);
+}
+
+void _monodroid_gc_wait_for_bridge_processing ()
+{
+	// mono_gc_wait_for_bridge_processing (); - replace with the new GC bridge call, when we have it
+}
+
+void _monodroid_detect_cpu_and_architecture (uint16_t *built_for_cpu, uint16_t *running_on_cpu, unsigned char *is64bit)
+{
+	abort_if_invalid_pointer_argument (built_for_cpu, "built_for_cpu");
+	abort_if_invalid_pointer_argument (running_on_cpu, "running_on_cpu");
+	abort_if_invalid_pointer_argument (is64bit, "is64bit");
+
+	bool _64bit;
+	monodroid_detect_cpu_and_architecture (*built_for_cpu, *running_on_cpu, _64bit);
+	*is64bit = _64bit;
+}
+
+void* _monodroid_timezone_get_default_id ()
+{
+	JNIEnv *env			 = OSBridge::ensure_jnienv ();
+	jmethodID getDefault = env->GetStaticMethodID (Host::get_java_class_TimeZone (), "getDefault", "()Ljava/util/TimeZone;");
+	jmethodID getID		 = env->GetMethodID (Host::get_java_class_TimeZone (), "getID",		 "()Ljava/lang/String;");
+	jobject d			 = env->CallStaticObjectMethod (Host::get_java_class_TimeZone (), getDefault);
+	jstring id			 = reinterpret_cast<jstring> (env->CallObjectMethod (d, getID));
+	const char *mutf8	 = env->GetStringUTFChars (id, nullptr);
+	if (mutf8 == nullptr) {
+		log_error (LOG_DEFAULT, "Failed to convert Java TimeZone ID to UTF8 (out of memory?)"sv);
+		env->DeleteLocalRef (id);
+		env->DeleteLocalRef (d);
+		return nullptr;
+	}
+	char *def_id		 = strdup (mutf8);
+	env->ReleaseStringUTFChars (id, mutf8);
+	env->DeleteLocalRef (id);
+	env->DeleteLocalRef (d);
+	return def_id;
+}