// am so lazy, so reusing jis2sjis
int s1 = ((bytes [i] - 1) >> 1) + ((bytes [i] <= 0x5e) ? 0x71 : 0xb1);
int s2 = bytes [i + 1] + (((bytes [i] & 1) != 0) ? 0x20 : 0x7e);
- int v = (s1 - 0x81) * 0xBC;
+ int v = (s1 <= 0x9F ? (s1 - 0x81) : (s1 - 0xc1)) * 0xBC;
v += s2 - 0x41;
int ch = ToChar (v);
\e$BF|K\8lJQ49$N\e(IC=B\e$B"+H>3Q\e(I6E\e$B$b\e(I!T/B9@^H\e(B
+[\e$BlM\e(B]
Mono Directions
\e$BF|K\8lJQ49$N\ eC=B\ f"+H>3Q\ e6E\ f$b\ e!T/B9@^H\ f\e(B
+[\e$BlM\e(B]
Mono Directions
ÆüËܸìÊÑ´¹¤Î\8eÃ\8e½\8e¢«È¾³Ñ\8e¶\8eŤâ\8e¡\8eÔ\8e¯\8eÂ\8e¹\8eÀ\8eÞ\8eÈ
+[ìÍ]
Mono Directions
\93ú\96{\8cê\95Ï\8a·\82ÌýÂ\81©\94¼\8ap¶Å\82à¡Ô¯Â¹ÀÞÈ
+[æË]
Mono Directions
日本語変換のﾃｽﾂ←半角ｶﾅも｡ﾔｯﾂｹﾀﾞﾈ
+[賤]
Mono Directions
{
OracleCommand cmd = CreateCommand ();
- cmd.CommandText = "SSELECT OWNER, OBJECT_NAME, SUBOBJECT_NAME, OBJECT_ID, DATA_OBJECT_ID, LAST_DDL_TIME, " +
+ cmd.CommandText = "SELECT OWNER, OBJECT_NAME, SUBOBJECT_NAME, OBJECT_ID, DATA_OBJECT_ID, LAST_DDL_TIME, " +
" TIMESTAMP, STATUS, TEMPORARY, GENERATED, SECONDARY, CREATED " +
" FROM ALL_OBJECTS " +
" WHERE OBJECT_TYPE = '" + objType + "' " +
<Types>
<Namespace Name="System.Net.Http">
<Type Name="ByteArrayContent" Kind="Class" />
+ <Type Name="CFNetworkHandler" Kind="Class" />
<Type Name="ClientCertificateOption" Kind="Enumeration" />
<Type Name="DelegatingHandler" Kind="Class" />
<Type Name="FormUrlEncodedContent" Kind="Class" />
public static bool Wait(object obj, int millisecondsTimeout, bool exitContext) {
try {
- if (exitContext) {
-#if MONOTOUCH
- throw new NotSupportedException ("exitContext == true is not supported");
-#else
+#if !DISABLE_REMOTING
+ if (exitContext)
SynchronizationAttribute.ExitContext ();
#endif
- }
return Wait (obj, millisecondsTimeout);
}
finally {
- if (exitContext) SynchronizationAttribute.EnterContext ();
+#if !DISABLE_REMOTING
+ if (exitContext)
+ SynchronizationAttribute.EnterContext ();
+#endif
}
}
public static bool Wait(object obj, TimeSpan timeout, bool exitContext) {
try {
- if (exitContext) {
-#if MONOTOUCH
- throw new NotSupportedException ("exitContext == true is not supported");
-#else
+#if !DISABLE_REMOTING
+ if (exitContext)
SynchronizationAttribute.ExitContext ();
#endif
- }
return Wait (obj, timeout);
}
finally {
- if (exitContext) SynchronizationAttribute.EnterContext ();
+#if !DISABLE_REMOTING
+ if (exitContext)
+ SynchronizationAttribute.EnterContext ();
+#endif
}
}
static int WaitMultiple(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext, bool WaitAll)
{
-#if MONOTOUCH
- if (exitContext)
- throw new NotSupportedException ("exitContext == true is not supported");
-#endif
-
int release_last = -1;
try {
+#if !DISABLE_REMOTING
if (exitContext)
SynchronizationAttribute.ExitContext ();
+#endif
for (int i = 0; i < waitHandles.Length; ++i) {
try {
}
if (WaitAll)
- return WaitAll_internal (waitHandles, millisecondsTimeout, exitContext);
+ return WaitAll_internal (waitHandles, millisecondsTimeout);
else
- return WaitAny_internal (waitHandles, millisecondsTimeout, exitContext);
+ return WaitAny_internal (waitHandles, millisecondsTimeout);
} finally {
for (int i = release_last; i >= 0; --i) {
waitHandles [i].SafeWaitHandle.DangerousRelease ();
}
+#if !DISABLE_REMOTING
if (exitContext)
SynchronizationAttribute.EnterContext ();
+#endif
}
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern int WaitAll_internal(WaitHandle[] handles, int ms, bool exitContext);
+ private static extern int WaitAll_internal(WaitHandle[] handles, int ms);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern int WaitAny_internal(WaitHandle[] handles, int ms, bool exitContext);
+ private static extern int WaitAny_internal(WaitHandle[] handles, int ms);
static int WaitOneNative (SafeHandle waitableSafeHandle, uint millisecondsTimeout, bool hasThreadAffinity, bool exitContext)
{
-#if MONOTOUCH
- if (exitContext)
- throw new NotSupportedException ("exitContext == true is not supported");
-#endif
-
bool release = false;
try {
+#if !DISABLE_REMOTING
if (exitContext)
SynchronizationAttribute.ExitContext ();
+#endif
waitableSafeHandle.DangerousAddRef (ref release);
- return WaitOne_internal (waitableSafeHandle.DangerousGetHandle (), (int) millisecondsTimeout, exitContext);
+ return WaitOne_internal (waitableSafeHandle.DangerousGetHandle (), (int) millisecondsTimeout);
} finally {
if (release)
waitableSafeHandle.DangerousRelease ();
+#if !DISABLE_REMOTING
if (exitContext)
SynchronizationAttribute.EnterContext ();
+#endif
}
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- static extern int WaitOne_internal(IntPtr handle, int ms, bool exitContext);
+ static extern int WaitOne_internal(IntPtr handle, int ms);
static int SignalAndWaitOne (SafeWaitHandle waitHandleToSignal,SafeWaitHandle waitHandleToWaitOn, int millisecondsTimeout, bool hasThreadAffinity, bool exitContext)
{
waitHandleToSignal.DangerousAddRef (ref releaseHandleToSignal);
waitHandleToWaitOn.DangerousAddRef (ref releaseHandleToWaitOn);
- return SignalAndWait_Internal (waitHandleToSignal.DangerousGetHandle (), waitHandleToWaitOn.DangerousGetHandle (), millisecondsTimeout, exitContext);
+ return SignalAndWait_Internal (waitHandleToSignal.DangerousGetHandle (), waitHandleToWaitOn.DangerousGetHandle (), millisecondsTimeout);
} finally {
if (releaseHandleToSignal)
waitHandleToSignal.DangerousRelease ();
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- static extern int SignalAndWait_Internal (IntPtr toSignal, IntPtr toWaitOn, int ms, bool exitContext);
+ static extern int SignalAndWait_Internal (IntPtr toSignal, IntPtr toWaitOn, int ms);
}
}
* of icalls, do not require an increment.
*/
#pragma warning disable 169
- private const int mono_corlib_version = 145;
+ private const int mono_corlib_version = 146;
#pragma warning restore 169
[ComVisible (true)]
}
}
- delegate int IntNoArgs ();
+ public delegate int IntNoArgs ();
[Test]
public void CreateDelegateWithAbstractMethods ()
* Changes which are already detected at runtime, like the addition
* of icalls, do not require an increment.
*/
-#define MONO_CORLIB_VERSION 145
+#define MONO_CORLIB_VERSION 146
typedef struct
{
return FALSE;
}
+static gboolean debug_check;
+
MonoClass *
mono_class_get_generic_type_definition (MonoClass *klass)
{
{
int access_level;
+ if (access_klass == member_klass)
+ return TRUE;
+
if (access_klass->image->assembly && access_klass->image->assembly->corlib_internal)
return TRUE;
gboolean
mono_method_can_access_method (MonoMethod *method, MonoMethod *called)
{
- int can = can_access_member (method->klass, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
- if (!can) {
- MonoClass *nested = method->klass->nested_in;
- while (nested) {
- can = can_access_member (nested, called->klass, NULL, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
- if (can)
- return TRUE;
- nested = nested->nested_in;
- }
+ gboolean res = mono_method_can_access_method_full (method, called, NULL);
+ if (!res) {
+ printf ("FAILED TO VERIFY %s calling %s\n", mono_method_full_name (method, 1), mono_method_full_name (called, 1));
+ debug_check = TRUE;
+ mono_method_can_access_method_full (method, called, NULL);
+ debug_check = FALSE;
}
- /*
- * FIXME:
- * with generics calls to explicit interface implementations can be expressed
- * directly: the method is private, but we must allow it. This may be opening
- * a hole or the generics code should handle this differently.
- * Maybe just ensure the interface type is public.
- */
- if ((called->flags & METHOD_ATTRIBUTE_VIRTUAL) && (called->flags & METHOD_ATTRIBUTE_FINAL))
- return TRUE;
- return can;
+
+ return res;
}
/*
gboolean
mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass)
{
+ if (debug_check) printf ("CHECKING %s -> %s (%p)\n", mono_method_full_name (method, 1), mono_method_full_name (called, 1), context_klass);
MonoClass *access_class = method->klass;
MonoClass *member_class = called->klass;
int can = can_access_member (access_class, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
if (!can) {
+ if (debug_check) printf ("\tcan_access_member failed\n");
MonoClass *nested = access_class->nested_in;
while (nested) {
can = can_access_member (nested, member_class, context_klass, called->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK);
break;
nested = nested->nested_in;
}
+ if (!can && debug_check) printf ("\tcan_access_member nest check failed\n");
}
if (!can)
return FALSE;
+ if (debug_check) printf ("\ttype checking %s(%p) -> %s(%p)\n",
+ mono_type_get_full_name (access_class), access_class,
+ mono_type_get_full_name (member_class), member_class);
can = can_access_type (access_class, member_class);
if (!can) {
+ if (debug_check) printf ("\tcan_access_type check failed\n");
MonoClass *nested = access_class->nested_in;
while (nested) {
can = can_access_type (nested, member_class);
break;
nested = nested->nested_in;
}
+ if (!can && debug_check) printf ("\tcan_access_type nest check failed\n");
}
if (!can)
if (called->is_inflated) {
MonoMethodInflated * infl = (MonoMethodInflated*)called;
- if (infl->context.method_inst && !can_access_instantiation (access_class, infl->context.method_inst))
+ if (infl->context.method_inst && !can_access_instantiation (access_class, infl->context.method_inst)) {
+ if (debug_check) printf ("\tginst check failed\n");
return FALSE;
+ }
}
return TRUE;
sccs [i]->is_alive = TRUE;
}
+/* This bridge keeps all peers with __test > 0 */
+static void
+bridge_test_positive_status (int num_sccs, MonoGCBridgeSCC **sccs, int num_xrefs, MonoGCBridgeXRef *xrefs)
+{
+ int i;
+
+ if (!mono_bridge_test_field) {
+ mono_bridge_test_field = mono_class_get_field_from_name (mono_object_get_class (sccs[0]->objs [0]), "__test");
+ g_assert (mono_bridge_test_field);
+ }
+
+ /*We mark all objects in a scc with live objects as reachable by scc*/
+ for (i = 0; i < num_sccs; ++i) {
+ int j;
+ for (j = 0; j < sccs [i]->num_objs; ++j) {
+ if (test_scc (sccs [i], j)) {
+ sccs [i]->is_alive = TRUE;
+ break;
+ }
+ }
+ }
+}
+
+
static void
register_test_bridge_callbacks (const char *bridge_class_name)
{
callbacks.bridge_version = SGEN_BRIDGE_VERSION;
callbacks.bridge_class_kind = bridge_test_bridge_class_kind;
callbacks.is_bridge_object = bridge_test_is_bridge_object;
- callbacks.cross_references = bridge_class_name[0] == '2' ? bridge_test_cross_reference2 : bridge_test_cross_reference;
+
+ switch (bridge_class_name [0]) {
+ case '2':
+ bridge_class = bridge_class_name + 1;
+ callbacks.cross_references = bridge_test_cross_reference2;
+ break;
+ case '3':
+ bridge_class = bridge_class_name + 1;
+ callbacks.cross_references = bridge_test_positive_status;
+ break;
+ default:
+ bridge_class = bridge_class_name;
+ callbacks.cross_references = bridge_test_cross_reference;
+ }
mono_gc_register_bridge_callbacks (&callbacks);
- bridge_class = bridge_class_name + (bridge_class_name[0] == '2' ? 1 : 0);
}
gboolean
void ves_icall_System_Threading_Events_CloseEvent_internal (HANDLE handle);
HANDLE ves_icall_System_Threading_Events_OpenEvent_internal (MonoString *name, gint32 rights, gint32 *error);
-gint32 ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext);
-gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext);
-gint32 ves_icall_System_Threading_WaitHandle_WaitOne_internal(HANDLE handle, gint32 ms, gboolean exitContext);
-gint32 ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, HANDLE toWait, gint32 ms, gboolean exitContext);
+gint32 ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms);
+gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms);
+gint32 ves_icall_System_Threading_WaitHandle_WaitOne_internal(HANDLE handle, gint32 ms);
+gint32 ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, HANDLE toWait, gint32 ms);
MonoArray* ves_icall_System_Threading_Thread_ByteArrayToRootDomain (MonoArray *arr);
MonoArray* ves_icall_System_Threading_Thread_ByteArrayToCurrentDomain (MonoArray *arr);
return ret;
}
-/* FIXME: exitContext isnt documented */
-gint32 ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext)
+gint32 ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms)
{
HANDLE *handles;
guint32 numhandles;
return ret == WAIT_FAILED ? 0x7fffffff : ret;
}
-/* FIXME: exitContext isnt documented */
-gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext)
+gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms)
{
HANDLE handles [MAXIMUM_WAIT_OBJECTS];
uintptr_t numhandles;
}
}
-/* FIXME: exitContext isnt documented */
-gint32 ves_icall_System_Threading_WaitHandle_WaitOne_internal(HANDLE handle, gint32 ms, gboolean exitContext)
+gint32 ves_icall_System_Threading_WaitHandle_WaitOne_internal(HANDLE handle, gint32 ms)
{
guint32 ret;
MonoInternalThread *thread = mono_thread_internal_current ();
}
gint32
-ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, HANDLE toWait, gint32 ms, gboolean exitContext)
+ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, HANDLE toWait, gint32 ms)
{
guint32 ret;
MonoInternalThread *thread = mono_thread_internal_current ();
/* Wrappers around the image writer functions */
+#define MAX_SYMBOL_SIZE 256
+
+static inline const char *
+mangle_symbol (const char * symbol, char * mangled_symbol, gsize length)
+{
+ gsize needed_size = length;
+
+ g_assert (NULL != symbol);
+ g_assert (NULL != mangled_symbol);
+ g_assert (0 != length);
+
+#if defined(TARGET_WIN32) && defined(TARGET_X86)
+ if (symbol && '_' != symbol [0]) {
+ needed_size = g_snprintf (mangled_symbol, length, "_%s", symbol);
+ } else {
+ needed_size = g_snprintf (mangled_symbol, length, "%s", symbol);
+ }
+#else
+ needed_size = g_snprintf (mangled_symbol, length, "%s", symbol);
+#endif
+
+ g_assert (0 <= needed_size && needed_size < length);
+ return mangled_symbol;
+}
+
+static inline char *
+mangle_symbol_alloc (const char * symbol)
+{
+ g_assert (NULL != symbol);
+
+#if defined(TARGET_WIN32) && defined(TARGET_X86)
+ if (symbol && '_' != symbol [0]) {
+ return g_strdup_printf ("_%s", symbol);
+ }
+ else {
+ return g_strdup_printf ("%s", symbol);
+ }
+#else
+ return g_strdup_printf ("%s", symbol);
+#endif
+}
+
static inline void
emit_section_change (MonoAotCompile *acfg, const char *section_name, int subsection_index)
{
mono_img_writer_emit_section_change (acfg->w, section_name, subsection_index);
}
+#if defined(TARGET_WIN32) && defined(TARGET_X86)
+
+static inline void
+emit_local_symbol (MonoAotCompile *acfg, const char *name, const char *end_label, gboolean func)
+{
+ const char * mangled_symbol_name = name;
+ char * mangled_symbol_name_alloc = NULL;
+
+ if (TRUE == func) {
+ mangled_symbol_name_alloc = mangle_symbol_alloc (name);
+ mangled_symbol_name = mangled_symbol_name_alloc;
+ }
+
+ if (name != mangled_symbol_name && 0 != g_strcasecmp (name, mangled_symbol_name)) {
+ mono_img_writer_emit_label (acfg->w, mangled_symbol_name);
+ }
+ mono_img_writer_emit_local_symbol (acfg->w, mangled_symbol_name, end_label, func);
+
+ if (NULL != mangled_symbol_name_alloc) {
+ g_free (mangled_symbol_name_alloc);
+ }
+}
+
+#else
+
static inline void
emit_local_symbol (MonoAotCompile *acfg, const char *name, const char *end_label, gboolean func)
{
- mono_img_writer_emit_local_symbol (acfg->w, name, end_label, func);
+ mono_img_writer_emit_local_symbol (acfg->w, name, end_label, func);
}
+#endif
+
static inline void
emit_label (MonoAotCompile *acfg, const char *name)
{
}
#endif
+#if defined(TARGET_WIN32) && defined(TARGET_X86)
+
+static G_GNUC_UNUSED void
+emit_global_inner (MonoAotCompile *acfg, const char *name, gboolean func)
+{
+ const char * mangled_symbol_name = name;
+ char * mangled_symbol_name_alloc = NULL;
+
+ mangled_symbol_name_alloc = mangle_symbol_alloc (name);
+ mangled_symbol_name = mangled_symbol_name_alloc;
+
+ if (0 != g_strcasecmp (name, mangled_symbol_name)) {
+ mono_img_writer_emit_label (acfg->w, mangled_symbol_name);
+ }
+ mono_img_writer_emit_global (acfg->w, mangled_symbol_name, func);
+
+ if (NULL != mangled_symbol_name_alloc) {
+ g_free (mangled_symbol_name_alloc);
+ }
+}
+
+#else
+
static G_GNUC_UNUSED void
emit_global_inner (MonoAotCompile *acfg, const char *name, gboolean func)
{
mono_img_writer_emit_global (acfg->w, name, func);
}
+#endif
+
static void
emit_global (MonoAotCompile *acfg, const char *name, gboolean func)
{
g_ptr_array_add (acfg->globals, g_strdup (name));
mono_img_writer_emit_local_symbol (acfg->w, name, NULL, func);
} else {
- mono_img_writer_emit_global (acfg->w, name, func);
+ emit_global_inner (acfg, name, func);
}
}
static void
emit_info_symbol (MonoAotCompile *acfg, const char *name)
{
- char symbol [256];
+ char symbol [MAX_SYMBOL_SIZE];
if (acfg->llvm) {
emit_label (acfg, name);
arch_emit_objc_selector_ref (MonoAotCompile *acfg, guint8 *code, int index, int *code_size)
{
#if defined(TARGET_ARM)
- char symbol1 [256];
- char symbol2 [256];
+ char symbol1 [MAX_SYMBOL_SIZE];
+ char symbol2 [MAX_SYMBOL_SIZE];
int lindex = acfg->objc_selector_index_2 ++;
/* Emit ldr.imm/b */
prefix = "_";
#endif
+#if defined(TARGET_WIN32) && defined(TARGET_X86)
+ char adjustedPrefix [MAX_SYMBOL_SIZE];
+ prefix = mangle_symbol (prefix, adjustedPrefix, G_N_ELEMENTS (adjustedPrefix));
+#endif
+
len = strlen (name1);
name2 = (char *)malloc (strlen (prefix) + len + 16);
memcpy (name2, prefix, strlen (prefix));
/* Need to add a prefix to create unique symbols */
prefix = g_strdup_printf ("plt_%s_", acfg->assembly_name_sym);
} else {
+#if defined(TARGET_WIN32) && defined(TARGET_X86)
+ prefix = mangle_symbol_alloc ("plt_");
+#else
prefix = g_strdup ("plt_");
+#endif
}
switch (ji->type) {
static G_GNUC_UNUSED void
emit_trampoline_full (MonoAotCompile *acfg, int got_offset, MonoTrampInfo *info, gboolean emit_tinfo)
{
- char start_symbol [256];
- char end_symbol [256];
- char symbol [256];
+ char start_symbol [MAX_SYMBOL_SIZE];
+ char end_symbol [MAX_SYMBOL_SIZE];
+ char symbol [MAX_SYMBOL_SIZE];
guint32 buf_size, info_offset;
MonoJumpInfo *patch_info;
guint8 *buf, *p;
/* Emit debug info */
if (unwind_ops) {
- char symbol2 [256];
+ char symbol2 [MAX_SYMBOL_SIZE];
sprintf (symbol, "%s", name);
sprintf (symbol2, "%snamed_%s", acfg->temp_prefix, name);
static void
emit_trampolines (MonoAotCompile *acfg)
{
- char symbol [256];
- char end_symbol [256];
+ char symbol [MAX_SYMBOL_SIZE];
+ char end_symbol [MAX_SYMBOL_SIZE];
int i, tramp_got_offset;
int ntype;
#ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
{
int oindex, i, prev_index;
gboolean saved_unbox_info = FALSE;
- char symbol [256];
+ char symbol [MAX_SYMBOL_SIZE];
if (acfg->aot_opts.llvm_only)
return;
* To work around linker issues, we emit a table of branches, and disassemble them at runtime.
* This is PIE code, and the linker can update it if needed.
*/
+
sprintf (symbol, "method_addresses");
emit_section_change (acfg, ".text", 1);
emit_alignment_code (acfg, 8);
if (acfg->cfgs [i]) {
if (acfg->aot_opts.llvm_only && acfg->cfgs [i]->compile_llvm)
/* Obtained by calling a generated function in the LLVM image */
- arch_emit_direct_call (acfg, "method_addresses", FALSE, FALSE, NULL, &call_size);
+ arch_emit_direct_call (acfg, symbol, FALSE, FALSE, NULL, &call_size);
else
arch_emit_direct_call (acfg, acfg->cfgs [i]->asm_symbol, FALSE, acfg->thumb_mixed && acfg->cfgs [i]->compile_llvm, NULL, &call_size);
} else {
- arch_emit_direct_call (acfg, "method_addresses", FALSE, FALSE, NULL, &call_size);
+ arch_emit_direct_call (acfg, symbol, FALSE, FALSE, NULL, &call_size);
}
#endif
}
static void
emit_got (MonoAotCompile *acfg)
{
- char symbol [256];
+ char symbol [MAX_SYMBOL_SIZE];
if (acfg->aot_opts.llvm_only)
return;
static void
emit_aot_file_info (MonoAotCompile *acfg, MonoAotFileInfo *info)
{
- char symbol [256];
+ char symbol [MAX_SYMBOL_SIZE];
int i, sindex;
const char **symbols;
init_aot_file_info (acfg, info);
if (acfg->aot_opts.static_link) {
- char symbol [256];
+ char symbol [MAX_SYMBOL_SIZE];
char *p;
/*
}
#endif
- rename (tmp_outfile_name, outfile_name);
+ if (0 != rename (tmp_outfile_name, outfile_name)) {
+ if (G_FILE_ERROR_EXIST == g_file_error_from_errno (errno)) {
+ /* Since we are rebuilding the module we need to be able to replace any old copies. Remove old file and retry rename operation. */
+ unlink (outfile_name);
+ rename (tmp_outfile_name, outfile_name);
+ }
+ }
#if defined(TARGET_MACH)
command = g_strdup_printf ("dsymutil \"%s\"", outfile_name);
return hidden;
if (closure->predicate (obj, closure->data))
- return NULL;
+ return MONO_GC_HANDLE_METADATA_POINTER (sgen_client_default_metadata (), GC_HANDLE_TYPE_IS_WEAK (handle_type));
return hidden;
}
void
sgen_los_free_object (LOSObject *obj)
{
- SGEN_ASSERT (0, !obj->cardtable_mod_union, "We should never free a LOS object with a mod-union table.");
+ if (obj->cardtable_mod_union)
+ sgen_card_table_free_mod_union (obj->cardtable_mod_union, (char*)obj->data, sgen_los_object_size (obj));
#ifndef LOS_DUMMY
mword size = sgen_los_object_size (obj);
for (bigobj = los_object_list; bigobj;) {
SGEN_ASSERT (0, !SGEN_OBJECT_IS_PINNED (bigobj->data), "Who pinned a LOS object?");
- if (bigobj->cardtable_mod_union) {
- sgen_card_table_free_mod_union (bigobj->cardtable_mod_union, (char*)bigobj->data, sgen_los_object_size (bigobj));
- bigobj->cardtable_mod_union = NULL;
- }
-
if (sgen_los_object_is_pinned (bigobj->data)) {
+ if (bigobj->cardtable_mod_union) {
+ mword obj_size = sgen_los_object_size (bigobj);
+ mword num_cards = sgen_card_table_number_of_cards_in_range ((mword) bigobj->data, obj_size);
+ memset (bigobj->cardtable_mod_union, 0, num_cards);
+ }
+
sgen_los_unpin_object (bigobj->data);
sgen_update_heap_boundaries ((mword)bigobj->data, (mword)bigobj->data + sgen_los_object_size (bigobj));
} else {
* list, where it will either be freed later on, or reused in nursery collections.
*/
static void
-ms_free_block (void *block)
+ms_free_block (MSBlockInfo *info)
{
void *empty;
+ char *block = MS_BLOCK_FOR_BLOCK_INFO (info);
sgen_memgov_release_space (MS_BLOCK_SIZE, SPACE_MAJOR);
+ if (info->cardtable_mod_union)
+ sgen_card_table_free_mod_union (info->cardtable_mod_union, block, MS_BLOCK_SIZE);
memset (block, 0, MS_BLOCK_SIZE);
do {
count = MS_BLOCK_FREE / block->obj_size;
- if (block->cardtable_mod_union) {
- sgen_card_table_free_mod_union (block->cardtable_mod_union, MS_BLOCK_FOR_BLOCK_INFO (block), MS_BLOCK_SIZE);
- block->cardtable_mod_union = NULL;
- }
+ if (block->cardtable_mod_union)
+ memset (block->cardtable_mod_union, 0, CARDS_PER_BLOCK);
/* Count marked objects in the block */
for (i = 0; i < MS_NUM_MARK_WORDS; ++i)
MSBlockInfo *block;
FOREACH_BLOCK_NO_LOCK (block) {
- size_t num_cards;
- guint8 *mod_union = get_cardtable_mod_union_for_block (block, TRUE);
- sgen_card_table_update_mod_union (mod_union, MS_BLOCK_FOR_BLOCK_INFO (block), MS_BLOCK_SIZE, &num_cards);
- SGEN_ASSERT (6, num_cards == CARDS_PER_BLOCK, "Number of cards calculation is wrong");
+ gpointer *card_start = (gpointer*) sgen_card_table_get_card_address ((mword)MS_BLOCK_FOR_BLOCK_INFO (block));
+ gboolean has_dirty_cards = FALSE;
+ int i;
+ for (i = 0; i < CARDS_PER_BLOCK / sizeof(gpointer); i++) {
+ if (card_start [i]) {
+ has_dirty_cards = TRUE;
+ break;
+ }
+ }
+ if (has_dirty_cards) {
+ size_t num_cards;
+ guint8 *mod_union = get_cardtable_mod_union_for_block (block, TRUE);
+ sgen_card_table_update_mod_union (mod_union, MS_BLOCK_FOR_BLOCK_INFO (block), MS_BLOCK_SIZE, &num_cards);
+ SGEN_ASSERT (6, num_cards == CARDS_PER_BLOCK, "Number of cards calculation is wrong");
+ }
} END_FOREACH_BLOCK_NO_LOCK;
}
@$(MCS) -r:TestDriver.dll $(srcdir)/debug-casts.cs
@$(RUNTIME) --debug=casts debug-casts.exe
-EXTRA_DIST += sgen-bridge.cs sgen-descriptors.cs sgen-gshared-vtype.cs sgen-bridge-major-fragmentation.cs sgen-domain-unload.cs sgen-weakref-stress.cs sgen-cementing-stress.cs sgen-case-23400.cs finalizer-wait.cs critical-finalizers.cs sgen-domain-unload-2.cs sgen-suspend.cs sgen-new-threads-dont-join-stw.cs sgen-bridge-xref.cs bug-17590.cs sgen-toggleref.cs
+EXTRA_DIST += sgen-bridge.cs sgen-descriptors.cs sgen-gshared-vtype.cs sgen-bridge-major-fragmentation.cs sgen-domain-unload.cs sgen-weakref-stress.cs sgen-cementing-stress.cs sgen-case-23400.cs finalizer-wait.cs critical-finalizers.cs sgen-domain-unload-2.cs sgen-suspend.cs sgen-new-threads-dont-join-stw.cs sgen-bridge-xref.cs bug-17590.cs sgen-toggleref.cs sgen-bridge-gchandle.cs
sgen-tests:
sgen-bridge2-tests-ms-split-tarjan-bridge: $(SGEN_BRIDGE2_TESTS) test-runner.exe
MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=2Bridge" MONO_GC_PARAMS="bridge-implementation=tarjan,minor=split" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE2_TESTS)
+
+SGEN_BRIDGE3_TESTS= \
+ sgen-bridge-gchandle.exe
+
+sgen-bridge3-tests: $(SGEN_BRIDGE3_TESTS)
+ $(MAKE) sgen-bridge3-tests-plain
+ $(MAKE) sgen-bridge3-tests-ms-conc
+ $(MAKE) sgen-bridge3-tests-ms-split
+ $(MAKE) sgen-bridge3-tests-plain-new-bridge
+ $(MAKE) sgen-bridge3-tests-ms-conc-new-bridge
+ $(MAKE) sgen-bridge3-tests-ms-split-new-bridge
+ $(MAKE) sgen-bridge3-tests-plain-tarjan-bridge
+ $(MAKE) sgen-bridge3-tests-ms-split-tarjan-bridge
+
+sgen-bridge3-tests-plain: $(SGEN_bridge3_TESTS) test-runner.exe
+ MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=3Bridge" MONO_GC_PARAMS="" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE3_TESTS)
+sgen-bridge3-tests-ms-conc: $(SGEN_BRIDGE3_TESTS) test-runner.exe
+ MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=3Bridge" MONO_GC_PARAMS="major=marksweep-conc" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE3_TESTS)
+sgen-bridge3-tests-ms-split: $(SGEN_BRIDGE3_TESTS) test-runner.exe
+ MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=3Bridge" MONO_GC_PARAMS="minor=split" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE3_TESTS)
+sgen-bridge3-tests-plain-new-bridge: $(SGEN_BRIDGE3_TESTS) test-runner.exe
+ MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=3Bridge" MONO_GC_PARAMS="bridge-implementation=new" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE3_TESTS)
+sgen-bridge3-tests-ms-conc-new-bridge: $(SGEN_BRIDGE3_TESTS) test-runner.exe
+ MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=3Bridge" MONO_GC_PARAMS="bridge-implementation=new,major=marksweep-conc" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE3_TESTS)
+sgen-bridge3-tests-ms-split-new-bridge: $(SGEN_BRIDGE3_TESTS) test-runner.exe
+ MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=3Bridge" MONO_GC_PARAMS="bridge-implementation=new,minor=split" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE3_TESTS)
+sgen-bridge3-tests-plain-tarjan-bridge: $(SGEN_BRIDGE3_TESTS) test-runner.exe
+ MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=3Bridge" MONO_GC_PARAMS="bridge-implementation=tarjan" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE3_TESTS)
+sgen-bridge3-tests-ms-split-tarjan-bridge: $(SGEN_BRIDGE3_TESTS) test-runner.exe
+ MONO_ENV_OPTIONS="--gc=sgen" MONO_GC_DEBUG="bridge=3Bridge" MONO_GC_PARAMS="bridge-implementation=tarjan,minor=split" $(RUNTIME) ./test-runner.exe --testsuite-name $@ --timeout 900 $(SGEN_BRIDGE3_TESTS)
+
+
AOT_CONFIGURATIONS= \
"|regular" \
"--gc=boehm|boehm"
--- /dev/null
+using System;
+using System.Collections;
+using System.Threading;
+using System.Runtime.InteropServices;
+
+
+public class Bridge {
+ public int __test;
+ public string id;
+
+ ~Bridge () {
+ try {Console.WriteLine ("bridge {0} gone", id);} catch (Exception) {}
+ }
+}
+
+
+/*
+Test scenario:
+ Alloc a bridge and create a gc handle to it
+ Get it collected.
+ Create another one and see it steal the handle of the previous one.
+
+
+*/
+class Driver {
+ public static GCHandle weak_track_handle;
+ public static GCHandle weak_track_handle2;
+
+ static void CreateFirstBridge () {
+ Bridge b = new Bridge() {
+ __test = 0,
+ id = "first",
+ };
+ weak_track_handle = GCHandle.Alloc (b, GCHandleType.WeakTrackResurrection);
+ }
+
+ static void CreateSecondBridge () {
+ Bridge b = new Bridge() {
+ __test = 1,
+ id = "second",
+ };
+ weak_track_handle2 = GCHandle.Alloc (b, GCHandleType.WeakTrackResurrection);
+ }
+
+ static void DumpHandle (GCHandle h, string name) {
+ Console.WriteLine ("{0}:{1:X} alloc:{2} hasValue:{2}", name, (IntPtr)h, h.IsAllocated, h.Target == null);
+ }
+
+ static int Main () {
+ var t = new Thread (CreateFirstBridge);
+ t.Start ();
+ t.Join ();
+
+ GC.Collect ();
+ GC.WaitForPendingFinalizers ();
+ Console.WriteLine ("GC DONE");
+
+ DumpHandle (weak_track_handle, "weak-track1");
+
+ t = new Thread (CreateSecondBridge);
+ t.Start ();
+ t.Join ();
+
+ GC.Collect ();
+ GC.WaitForPendingFinalizers ();
+ Console.WriteLine ("GC DONE");
+ DumpHandle (weak_track_handle, "weak-track1");
+ DumpHandle (weak_track_handle2, "weak-track2");
+ Console.WriteLine ("DONE");
+
+ if ((IntPtr)weak_track_handle == (IntPtr)weak_track_handle2) {
+ Console.WriteLine ("FIRST HANDLE GOT DEALLOCATED!");
+ return 1;
+ }
+
+ return 0;
+ }
+}
projects / mono.git / commitdiff