# This can be reset to 0 when Mono's version number is bumped
# since it's part of the corlib version (the prefix '1' in the full
# version number is to ensure the number isn't treated as octal in C)
-MONO_CORLIB_COUNTER=1
+MONO_CORLIB_COUNTER=2
MONO_CORLIB_VERSION=`printf "1%02d%02d%02d%03d" $MONO_VERSION_MAJOR $MONO_VERSION_MINOR $MONO_VERSION_BUILD $MONO_CORLIB_COUNTER`
AC_DEFINE_UNQUOTED(MONO_CORLIB_VERSION,$MONO_CORLIB_VERSION,[Version of the corlib-runtime interface])
mkinstalldirs \
MonoIcon.png \
README \
- ScalableMonoIcon.svg \
- winexe.in
+ ScalableMonoIcon.svg
dist-local: dist-default
LIB_REFS = System
LIB_MCS_FLAGS = /unsafe
TEST_MCS_FLAGS = $(LIB_MCS_FLAGS)
-XTEST_LIB_REFS = System Facades/System.Threading.Tasks System.Runtime.InteropServices.RuntimeInformation System.Core System.Numerics.Vectors Microsoft.CSharp
+XTEST_LIB_REFS = System Facades/System.Threading.Tasks Facades/System.Runtime.InteropServices.RuntimeInformation System.Core System.Numerics.Vectors Microsoft.CSharp
XTEST_LIB_FLAGS = -unsafe
RESX_RESOURCE_STRING = \
SetResults(SocketError.Success, bytesTransferred, flags);
current_socket = connectSocket;
- Complete ();
OnCompleted (this);
}
XUNIT_LIBS := xunit.core xunit.abstractions xunit.execution.desktop xunit.assert
LIBRARY = Xunit.NetCore.Extensions.dll
-LIB_REFS = System System.Core System.Runtime.InteropServices.RuntimeInformation Facades/System.Runtime Facades/System.Threading.Tasks
+LIB_REFS = System System.Core Facades/System.Runtime.InteropServices.RuntimeInformation Facades/System.Runtime Facades/System.Threading.Tasks
LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/../external/xunit-binaries/%.dll,$(XUNIT_LIBS))
EXTRA_DISTFILES =
// handle.h HandleStackMark
struct HandleStackMark {
- int size;
+ int size, interior_size;
IntPtr chunk;
}
#if LIBC
private static TimeZoneInfo FindSystemTimeZoneByFileName (string id, string filepath)
{
- if (!File.Exists (filepath))
- throw new TimeZoneNotFoundException ();
-
- using (FileStream stream = File.OpenRead (filepath)) {
+ FileStream stream = null;
+ try {
+ stream = File.OpenRead (filepath);
+ } catch (Exception ex) {
+ throw new TimeZoneNotFoundException ("Couldn't read time zone file " + filepath, ex);
+ }
+ try {
return BuildFromStream (id, stream);
+ } finally {
+ if (stream != null)
+ stream.Dispose();
}
}
#endif
{
static partial class Debug
{
- static readonly string NewLine = Environment.NewLine;
-
static void ShowAssertDialog (string stackTrace, string message, string detailMessage)
{
// FIXME should we g_error in this case?
internal override DirectoryInfo CreateObject(SearchResult result)
{
String name = result.FullPath;
- String permissionName = name + "\\.";
#if MONO_FEATURE_CAS
+ String permissionName = name + "\\.";
+
#if FEATURE_CORECLR
FileSecurityState state = new FileSecurityState(FileSecurityStateAccess.Read, String.Empty, permissionName);
state.EnsureState();
if (isDir)
{
String name = result.FullPath;
- String permissionName = name + "\\.";
#if MONO_FEATURE_CAS
+ String permissionName = name + "\\.";
+
#if FEATURE_CORECLR
FileSecurityState state = new FileSecurityState(FileSecurityStateAccess.Read, String.Empty, permissionName);
state.EnsureState();
--- /dev/null
+// CS1031: Type expected
+// Line: 16
+
+public class B<Y> where Y: B<Y>
+{
+}
+
+public class A<X>: B<A<X>>
+{
+}
+
+public class Repro
+{
+ public static void Main (string[] args)
+ {
+ var h = typeof (B<A<>>);
+ }
+}
\ No newline at end of file
else if (the_token == Token.INTERR_NULLABLE || the_token == Token.STAR)
goto again;
else if (the_token == Token.OP_GENERICS_LT) {
- if (!parse_less_than (ref genericDimension))
+ int unused = 0;
+ if (!parse_less_than (ref unused))
return false;
goto again;
} else if (the_token == Token.OPEN_BRACKET) {
}
if (error != null) {
+ Console.Error.WriteLine ("Failure to load i18n assemblies, the following directories were searched for the assemblies:");
+ foreach (var path in link_paths){
+ Console.Error.WriteLine (" Path: " + path);
+ }
+ if (custom_mode){
+ Console.WriteLine ("In Custom mode, you need to provide the directory to lookup assemblies from using -L");
+ }
+
Error ("Couldn't load one or more of the i18n assemblies: " + error);
Environment.Exit (1);
}
Assembly a = null;
try {
+ if (!quiet)
+ Console.WriteLine ("Attempting to load assembly: {0}", assembly);
a = universe.LoadFile (assembly);
+ if (!quiet)
+ Console.WriteLine ("Assembly {0} loaded successfully.", assembly);
+
} catch (FileNotFoundException){
Error ($"Cannot find assembly `{assembly}'");
} catch (IKVM.Reflection.BadImageFormatException f) {
string total_log = "";
foreach (string dir in link_paths){
string full_path = Path.Combine (dir, assembly);
+ if (!quiet)
+ Console.WriteLine ("Attempting to load assembly from: " + full_path);
if (!assembly.EndsWith (".dll") && !assembly.EndsWith (".exe"))
full_path += ".dll";
char *class_name = mono_type_get_full_name (klass);
char *type_name = mono_type_full_name (field->type);
- mono_class_set_type_load_failure (klass, "");
- g_warning ("Invalid type %s for instance field %s:%s", type_name, class_name, field->name);
+ mono_class_set_type_load_failure (klass, "Invalid type %s for instance field %s:%s", type_name, class_name, field->name);
g_free (class_name);
g_free (type_name);
break;
#define THIS_IS_AN_OK_NUMBER_OF_HANDLES 100
-enum {
- HANDLE_CHUNK_PTR_OBJ = 0x0, /* chunk element points to beginning of a managed object */
- HANDLE_CHUNK_PTR_INTERIOR = 0x1, /* chunk element points into the middle of a managed object */
- HANDLE_CHUNK_PTR_MASK = 0x1
-};
-
-/* number of bits in each word of the interior pointer bitmap */
-#define INTERIOR_HANDLE_BITMAP_BITS_PER_WORD (sizeof(guint32) << 3)
-
-static gboolean
-bitset_bits_test (guint32 *bitmaps, int idx)
-{
- int w = idx / INTERIOR_HANDLE_BITMAP_BITS_PER_WORD;
- int b = idx % INTERIOR_HANDLE_BITMAP_BITS_PER_WORD;
- guint32 bitmap = bitmaps [w];
- guint32 mask = 1u << b;
- return ((bitmap & mask) != 0);
-}
-
-static void
-bitset_bits_set (guint32 *bitmaps, int idx)
-{
- int w = idx / INTERIOR_HANDLE_BITMAP_BITS_PER_WORD;
- int b = idx % INTERIOR_HANDLE_BITMAP_BITS_PER_WORD;
- guint32 *bitmap = &bitmaps [w];
- guint32 mask = 1u << b;
- *bitmap |= mask;
-}
-static void
-bitset_bits_clear (guint32 *bitmaps, int idx)
-{
- int w = idx / INTERIOR_HANDLE_BITMAP_BITS_PER_WORD;
- int b = idx % INTERIOR_HANDLE_BITMAP_BITS_PER_WORD;
- guint32 *bitmap = &bitmaps [w];
- guint32 mask = ~(1u << b);
- *bitmap &= mask;
-}
-
-static gpointer*
-chunk_element_objslot_init (HandleChunk *chunk, int idx, gboolean interior)
-{
- if (interior)
- bitset_bits_set (chunk->interior_bitmap, idx);
- else
- bitset_bits_clear (chunk->interior_bitmap, idx);
- return &chunk->elems [idx].o;
-}
-
static HandleChunkElem*
chunk_element (HandleChunk *chunk, int idx)
{
return &chunk->elems[idx];
}
-static guint
-chunk_element_kind (HandleChunk *chunk, int idx)
-{
- return bitset_bits_test (chunk->interior_bitmap, idx) ? HANDLE_CHUNK_PTR_INTERIOR : HANDLE_CHUNK_PTR_OBJ;
-}
-
static HandleChunkElem*
handle_to_chunk_element (MonoObjectHandle o)
{
}
#endif
-MonoRawHandle
-#ifndef MONO_HANDLE_TRACK_OWNER
-mono_handle_new (MonoObject *object)
-#else
-mono_handle_new (MonoObject *object, const char *owner)
-#endif
-{
-#ifndef MONO_HANDLE_TRACK_OWNER
- return mono_handle_new_full (object, FALSE);
-#else
- return mono_handle_new_full (object, FALSE, owner);
-#endif
-}
/* Actual handles implementation */
MonoRawHandle
#ifndef MONO_HANDLE_TRACK_OWNER
-mono_handle_new_full (gpointer rawptr, gboolean interior)
+mono_handle_new (MonoObject *obj)
#else
-mono_handle_new_full (gpointer rawptr, gboolean interior, const char *owner)
+mono_handle_new (MonoObject *obj, const char *owner)
#endif
{
MonoThreadInfo *info = mono_thread_info_current ();
retry:
if (G_LIKELY (top->size < OBJECTS_PER_HANDLES_CHUNK)) {
int idx = top->size;
- gpointer* objslot = chunk_element_objslot_init (top, idx, interior);
+ gpointer* objslot = &top->elems [idx].o;
/* can be interrupted anywhere here, so:
* 1. make sure the new slot is null
* 2. make the new slot scannable (increment size)
mono_memory_write_barrier ();
top->size++;
mono_memory_write_barrier ();
- *objslot = rawptr;
+ *objslot = obj;
SET_OWNER (top,idx);
SET_SP (handles, top, idx);
return objslot;
}
HandleChunk *new_chunk = g_new (HandleChunk, 1);
new_chunk->size = 0;
- memset (new_chunk->interior_bitmap, 0, INTERIOR_HANDLE_BITMAP_WORDS);
new_chunk->prev = top;
new_chunk->next = NULL;
/* make sure size == 0 before new chunk is visible */
goto retry;
}
+MonoRawHandle
+#ifndef MONO_HANDLE_TRACK_OWNER
+mono_handle_new_interior (gpointer rawptr)
+#else
+mono_handle_new_interior (gpointer rawptr, const char *owner)
+#endif
+{
+ MonoThreadInfo *info = mono_thread_info_current ();
+ HandleStack *handles = (HandleStack *)info->handle_stack;
+ HandleChunk *top = handles->interior;
+#ifdef MONO_HANDLE_TRACK_SP
+ mono_handle_chunk_leak_check (handles);
+#endif
+ g_assert (top);
+
+ /*
+ * Don't extend the chunk now, interior handles are
+ * only used for icall arguments, they shouldn't
+ * overflow.
+ */
+ g_assert (top->size < OBJECTS_PER_HANDLES_CHUNK);
+ int idx = top->size;
+ gpointer *objslot = &top->elems [idx].o;
+ *objslot = NULL;
+ mono_memory_write_barrier ();
+ top->size++;
+ mono_memory_write_barrier ();
+ *objslot = rawptr;
+ SET_OWNER (top,idx);
+ SET_SP (handles, top, idx);
+ return objslot;
+}
HandleStack*
mono_handle_stack_alloc (void)
{
- HandleStack *stack = g_new (HandleStack, 1);
- HandleChunk *chunk = g_new (HandleChunk, 1);
+ HandleStack *stack = g_new0 (HandleStack, 1);
+ HandleChunk *chunk = g_new0 (HandleChunk, 1);
+ HandleChunk *interior = g_new0 (HandleChunk, 1);
- chunk->size = 0;
- memset (chunk->interior_bitmap, 0, INTERIOR_HANDLE_BITMAP_WORDS);
- chunk->prev = chunk->next = NULL;
mono_memory_write_barrier ();
stack->top = stack->bottom = chunk;
+ stack->interior = interior;
#ifdef MONO_HANDLE_TRACK_OWNER
stack->stackmark_sp = NULL;
#endif
c = next;
}
g_free (c);
+ g_free (stack->interior);
g_free (stack);
}
Note that if we're running, we know the world is stopped.
*/
- HandleChunk *cur = stack->bottom;
- HandleChunk *last = stack->top;
+ if (precise) {
+ HandleChunk *cur = stack->bottom;
+ HandleChunk *last = stack->top;
- if (!cur)
- return;
-
- while (cur) {
- /* assume that object pointers will be much more common than interior pointers.
- * scan the object pointers by iterating over the chunk elements.
- * scan the interior pointers by iterating over the bitmap bits.
- */
- if (precise) {
+ while (cur) {
for (int i = 0; i < cur->size; ++i) {
HandleChunkElem* elem = chunk_element (cur, i);
- int kind = chunk_element_kind (cur, i);
gpointer* obj_slot = &elem->o;
- if (kind == HANDLE_CHUNK_PTR_OBJ && *obj_slot != NULL)
+ if (*obj_slot != NULL)
func (obj_slot, gc_data);
}
- } else {
- int elem_idx = 0;
- for (int i = 0; i < INTERIOR_HANDLE_BITMAP_WORDS; ++i) {
- elem_idx = i * INTERIOR_HANDLE_BITMAP_BITS_PER_WORD;
- if (elem_idx >= cur->size)
- break;
- /* no interior pointers in the range */
- if (cur->interior_bitmap [i] == 0)
- continue;
- for (int j = 0; j < INTERIOR_HANDLE_BITMAP_BITS_PER_WORD && elem_idx < cur->size; ++j,++elem_idx) {
- HandleChunkElem *elem = chunk_element (cur, elem_idx);
- int kind = chunk_element_kind (cur, elem_idx);
- gpointer *ptr_slot = &elem->o;
- if (kind == HANDLE_CHUNK_PTR_INTERIOR && *ptr_slot != NULL)
- func (ptr_slot, gc_data);
- }
- }
+ if (cur == last)
+ break;
+ cur = cur->next;
+ }
+ } else {
+ HandleChunk *cur = stack->interior;
+
+ if (!cur)
+ return;
+ for (int i = 0; i < cur->size; ++i) {
+ HandleChunkElem* elem = chunk_element (cur, i);
+ gpointer* ptr_slot = &elem->o;
+ if (*ptr_slot != NULL)
+ func (ptr_slot, gc_data);
}
- if (cur == last)
- break;
- cur = cur->next;
}
}
HandleChunk *chunk = chunk_element_to_chunk_idx (stack, elem, &elem_idx);
/* gchandles cannot deal with interior pointers */
g_assert (chunk != NULL);
- g_assert (chunk_element_kind (chunk, elem_idx) != HANDLE_CHUNK_PTR_INTERIOR);
return mono_gchandle_new (MONO_HANDLE_RAW (handle), pinned);
}
G_BEGIN_DECLS
-
/*
Handle stack.
#endif
} HandleChunkElem;
-/* number of guint32's needed to store the interior pointers bitmap */
-#define INTERIOR_HANDLE_BITMAP_WORDS ((OBJECTS_PER_HANDLES_CHUNK + 31) / 32)
-
struct _HandleChunk {
int size; //number of handles
- /* bits in the range 0..size-1 of interior_bitmap are valid; rest are ignored. */
- guint32 interior_bitmap [INTERIOR_HANDLE_BITMAP_WORDS];
HandleChunk *prev, *next;
HandleChunkElem elems [OBJECTS_PER_HANDLES_CHUNK];
};
#ifdef MONO_HANDLE_TRACK_SP
gpointer stackmark_sp; // C stack pointer top when from most recent mono_stack_mark_init
#endif
+ /* Chunk for storing interior pointers. Not extended right now */
+ HandleChunk *interior;
} HandleStack;
+// Keep this in sync with RuntimeStructs.cs
typedef struct {
- int size;
+ int size, interior_size;
HandleChunk *chunk;
#ifdef MONO_HANDLE_TRACK_SP
gpointer prev_sp; // C stack pointer from prior mono_stack_mark_init
#ifndef MONO_HANDLE_TRACK_OWNER
MonoRawHandle mono_handle_new (MonoObject *object);
MonoRawHandle mono_handle_new_full (gpointer rawptr, gboolean interior);
+MonoRawHandle mono_handle_new_interior (gpointer rawptr);
#else
MonoRawHandle mono_handle_new (MonoObject *object, const char* owner);
MonoRawHandle mono_handle_new_full (gpointer rawptr, gboolean interior, const char *owner);
+MonoRawHandle mono_handle_new_interior (gpointer rawptr, const char *owner);
#endif
-
void mono_handle_stack_scan (HandleStack *stack, GcScanFunc func, gpointer gc_data, gboolean precise);
gboolean mono_handle_stack_is_empty (HandleStack *stack);
HandleStack* mono_handle_stack_alloc (void);
HandleStack *handles = (HandleStack *)info->handle_stack;
stackmark->size = handles->top->size;
stackmark->chunk = handles->top;
+ stackmark->interior_size = handles->interior->size;
#ifdef MONO_HANDLE_TRACK_SP
stackmark->prev_sp = handles->stackmark_sp;
handles->stackmark_sp = sptop;
old_top->size = stackmark->size;
mono_memory_write_barrier ();
handles->top = old_top;
+ handles->interior->size = stackmark->interior_size;
#ifdef MONO_HANDLE_TRACK_SP
mono_memory_write_barrier (); /* write to top before prev_sp */
handles->stackmark_sp = stackmark->prev_sp;
mono_handle_array_getref (MONO_HANDLE_CAST(MonoObject, (DEST)), (HANDLE), (IDX)); \
} while (0)
-/* Handles into the interior of objects.
- *
- * Typically when working with value types, we pass them by reference. In the case where the value type
- * is a field in a managed class, the reference will be a pointer into the middle of a managed object.
- * We need to identify such pointers in order for SGen to scan them correctly.
- */
-
-#ifndef MONO_HANDLE_TRACK_OWNER
-#define MONO_HANDLE_NEW_GET_VALPTR(HANDLE,TYPE,FIELD) (TYPE_VALUE_HANDLE_NAME(TYPE))(mono_handle_new_full (&(HANDLE)->__raw->FIELD), TRUE))
-#else
-#define MONO_HANDLE_NEW_GET_VALPTR(HANDLE,TYPE,FIELD) (TYPE_VALUE_HANDLE_NAME(TYPE))(mono_handle_new_full (&(HANDLE)->__raw->FIELD), TRUE, HANDLE_OWNER_STRINGIFY(__FILE__, __LINE__))
-#endif
-
-
#define MONO_HANDLE_ASSIGN(DESTH, SRCH) \
mono_handle_assign (MONO_HANDLE_CAST (MonoObject, (DESTH)), MONO_HANDLE_CAST(MonoObject, (SRCH)))
mono_icall_end (MonoThreadInfo *info, HandleStackMark *stackmark, MonoError *error);
static MonoObjectHandle
-mono_icall_handle_new_full (gpointer rawobj, MonoBoolean interior);
+mono_icall_handle_new (gpointer rawobj);
+
+static MonoObjectHandle
+mono_icall_handle_new_interior (gpointer rawobj);
/* Lazy class loading functions */
static GENERATE_GET_CLASS_WITH_CACHE (string_builder, "System.Text", "StringBuilder");
register_icall (mono_threads_detach_coop, "mono_threads_detach_coop", "void ptr ptr", TRUE);
register_icall (mono_icall_start, "mono_icall_start", "ptr ptr ptr", TRUE);
register_icall (mono_icall_end, "mono_icall_end", "void ptr ptr ptr", TRUE);
- register_icall (mono_icall_handle_new_full, "mono_icall_handle_new_full", "ptr ptr bool", TRUE);
+ register_icall (mono_icall_handle_new, "mono_icall_handle_new", "ptr ptr", TRUE);
+ register_icall (mono_icall_handle_new_interior, "mono_icall_handle_new_interior", "ptr ptr", TRUE);
mono_cominterop_init ();
mono_remoting_init ();
mono_mb_emit_ldloc (mb, 0);
mono_mb_emit_icall (mb, conv_to_icall (MONO_MARSHAL_CONV_FTN_DEL, NULL));
mono_mb_emit_stloc (mb, 3);
- } else if (klass == mono_defaults.stringbuilder_class){
- // FIXME: implement
+ } else if (klass == mono_defaults.stringbuilder_class) {
+ // FIXME:
+ char *msg = g_strdup_printf ("Return marshalling of stringbuilders is not implemented.");
+ mono_mb_emit_exception_marshal_directive (mb, msg);
} else {
/* set src */
mono_mb_emit_stloc (mb, 0);
mono_mb_emit_byte (mb, CEE_LDARG_0);
/* TODO support adding wrappers to non-static struct methods */
g_assert (!mono_class_is_valuetype(mono_method_get_class (method)));
- mono_mb_emit_byte (mb, CEE_LDC_I4_0);
- mono_mb_emit_icall (mb, mono_icall_handle_new_full);
+ mono_mb_emit_icall (mb, mono_icall_handle_new);
}
for (i = 0; i < sig->param_count; i++) {
/* load each argument. references into the managed heap get wrapped in handles */
mono_mb_emit_ldarg (mb, j);
break;
case ICALL_HANDLES_WRAP_OBJ:
- /* argI = mono_handle_new_full (argI_raw, FALSE) */
+ /* argI = mono_handle_new (argI_raw) */
mono_mb_emit_ldarg (mb, j);
- mono_mb_emit_byte (mb, CEE_LDC_I4_0);
- mono_mb_emit_icall (mb, mono_icall_handle_new_full);
+ mono_mb_emit_icall (mb, mono_icall_handle_new);
break;
case ICALL_HANDLES_WRAP_OBJ_INOUT:
- /* handleI = argI = mono_handle_new_full (NULL, FALSE) */
+ /* handleI = argI = mono_handle_new (NULL) */
mono_mb_emit_byte (mb, CEE_LDNULL);
- mono_mb_emit_byte (mb, CEE_LDC_I4_0);
- mono_mb_emit_icall (mb, mono_icall_handle_new_full);
+ mono_mb_emit_icall (mb, mono_icall_handle_new);
/* tmp = argI */
mono_mb_emit_byte (mb, CEE_DUP);
/* handleI = tmp */
mono_mb_emit_stloc (mb, handles_locals[j].handle);
break;
case ICALL_HANDLES_WRAP_VALUETYPE_REF:
- /* (void) mono_handle_new_full (argI, TRUE); argI */
+ /* (void) mono_handle_new (argI); argI */
mono_mb_emit_ldarg (mb, j);
mono_mb_emit_byte (mb, CEE_DUP);
- mono_mb_emit_byte (mb, CEE_LDC_I4_1);
- mono_mb_emit_icall (mb, mono_icall_handle_new_full);
+ mono_mb_emit_icall (mb, mono_icall_handle_new_interior);
mono_mb_emit_byte (mb, CEE_POP);
#if 0
fprintf (stderr, " Method %s.%s.%s has byref valuetype argument %d\n", method->klass->name_space, method->klass->name, method->name, i);
}
static MonoObjectHandle
-mono_icall_handle_new_full (gpointer rawobj, MonoBoolean interior)
+mono_icall_handle_new (gpointer rawobj)
+{
+#ifdef MONO_HANDLE_TRACK_OWNER
+ return mono_handle_new (rawobj, "<marshal args>");
+#else
+ return mono_handle_new (rawobj);
+#endif
+}
+
+static MonoObjectHandle
+mono_icall_handle_new_interior (gpointer rawobj)
{
#ifdef MONO_HANDLE_TRACK_OWNER
- return mono_handle_new_full (rawobj, interior, "<marshal args>");
+ return mono_handle_new_interior (rawobj, "<marshal args>");
#else
- return mono_handle_new_full (rawobj, interior);
+ return mono_handle_new_interior (rawobj);
#endif
}
vt-sync-method.exe \
resolve_method_bug.2.exe \
resolve_field_bug.2.exe \
- resolve_type_bug.2.exe
+ resolve_type_bug.2.exe \
+ bug-81691.exe \
+ bug-327438.2.exe
# Tests which rely on remoting
PROFILE_DISABLED_TESTS += \
sgen-domain-unload-2.exe
PROFILE_DISABLED_TESTS += \
- appdomain-loader.exe
+ appdomain-loader.exe \
+ assemblyresolve_event3.exe \
+ appdomain-serialize-exception.exe
endif
if HYBRID_AOT_TESTS
GACTESTLIB_SRCS= $(V1_SRC) $(V2_SRC)
GACTESTLIB_DLLS= $(SIGNED_V1_DLL) $(SIGNED_V2_DLL) $(UNSIGNED_V1_DLL) $(UNSIGNED_V2_DLL)
-if FULL_AOT_TESTS
-GACTESTLIB_DLLS_AOT=$(GACTESTLIB_DLLS:.dll=.dll$(PLATFORM_AOT_SUFFIX))
-APP_SIGNED_V1_AOT=$(APP_SIGNED_V1_EXE:.exe=.exe$(PLATFORM_AOT_SUFFIX))
-endif
-
-if HYBRID_AOT_TESTS
-GACTESTLIB_DLLS_AOT=$(GACTESTLIB_DLLS:.dll=.dll$(PLATFORM_AOT_SUFFIX))
-APP_SIGNED_V1_AOT=$(APP_SIGNED_V1_EXE:.exe=.exe$(PLATFORM_AOT_SUFFIX))
-endif
+#if FULL_AOT_TESTS
+#GACTESTLIB_DLLS_AOT=$(GACTESTLIB_DLLS:.dll=.dll$(PLATFORM_AOT_SUFFIX))
+#APP_SIGNED_V1_AOT=$(APP_SIGNED_V1_EXE:.exe=.exe$(PLATFORM_AOT_SUFFIX))
+#endif
+
+#if HYBRID_AOT_TESTS
+#GACTESTLIB_DLLS_AOT=$(GACTESTLIB_DLLS:.dll=.dll$(PLATFORM_AOT_SUFFIX))
+#APP_SIGNED_V1_AOT=$(APP_SIGNED_V1_EXE:.exe=.exe$(PLATFORM_AOT_SUFFIX))
+#endif
SIGNING_KEY= $(srcdir)/testkey.snk