mono/mini/fsacheck.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3
   4 #include <mono/metadata/appdomain.h>
   5 #include <mono/metadata/assembly.h>
   6 #include <mono/metadata/debug-helpers.h>
   7 #include <mono/metadata/object.h>
   8 #include <mono/jit/jit.h>
   9
  10 extern void* mono_aot_module_mscorlib_info;
  11 extern void* mono_aot_module_System_Core_info;
  12 extern void* mono_aot_module_System_info;
  13 extern void* mono_aot_module_Mono_Posix_info;
  14 extern void* mono_aot_module_System_Configuration_info;
  15 extern void* mono_aot_module_System_Security_info;
  16 extern void* mono_aot_module_System_Xml_info;
  17 /* extern void* mono_aot_module_System_Threading_info; */
  18 extern void* mono_aot_module_Mono_Security_info;
  19 extern void* mono_aot_module_Mono_Simd_info;
  20 extern void* mono_aot_module_TestDriver_info;
  21
  22 extern void* mono_aot_module_basic_info;
  23 extern void* mono_aot_module_basic_float_info;
  24 extern void* mono_aot_module_basic_long_info;
  25 extern void* mono_aot_module_basic_calls_info;
  26 extern void* mono_aot_module_basic_simd_info;
  27 extern void* mono_aot_module_objects_info;
  28 extern void* mono_aot_module_arrays_info;
  29 extern void* mono_aot_module_basic_math_info;
  30 extern void* mono_aot_module_exceptions_info;
  31 extern void* mono_aot_module_devirtualization_info;
  32 extern void* mono_aot_module_generics_info;
  33 extern void* mono_aot_module_generics_variant_types_info;
  34 extern void* mono_aot_module_basic_simd_info;
  35 /* extern void* mono_aot_module_thread_stress_info; */
  36
  37
  38 extern void mono_aot_register_module(void *aot_info);
  39 extern void mono_aot_init(void);
  40 extern void mono_jit_set_aot_only(mono_bool aot_only);
  41 extern MonoDomain * mini_init (const char *filename, const char *runtime_version);
  42
  43
  44 void try_one(char *mname) {
  45   MonoDomain *domain;
  46   MonoAssembly *ma;
  47   MonoImage *mi;
  48   MonoClass *mc;
  49   MonoMethodDesc *mmd;
  50   MonoMethod *mm;
  51   MonoObject *mo;
  52   MonoArray *arg_array;
  53   void *args [1];
  54   char *cstr_arg = "20";
  55
  56   mono_jit_set_aot_only(1);
  57   domain = mono_jit_init(mname);
  58   printf("mono domain: %p\n", domain);
  59
  60   ma = mono_domain_assembly_open(domain, mname);
  61   if (0 == ma) {
  62     printf("ERROR: could not open mono assembly\n");
  63     exit(-1);
  64   }
  65   printf("opened mono assembly: %p\n", ma);
  66
  67   mi = mono_assembly_get_image(ma);
  68   printf("mono image: %p\n", mi);
  69
  70   mo = mono_string_new(domain, cstr_arg);
  71   mc = mono_class_from_name(mono_get_corlib(), "System", "String");
  72   printf("string class: %p\n", mc);
  73   arg_array = mono_array_new(domain, mc, 1);
  74   mono_array_setref(arg_array, 0, mo);
  75   args[0] = arg_array;
  76
  77   mmd = mono_method_desc_new("Tests:Main()", 1);
  78   mm = mono_method_desc_search_in_image(mmd, mi);
  79   if (0 == mm) {
  80     mmd = mono_method_desc_new("Tests:Main(string[])", 1);
  81     mm = mono_method_desc_search_in_image(mmd, mi);
  82     if (0 == mm) {
  83       mmd = mono_method_desc_new("SimdTests:Main(string[])", 1);
  84       mm = mono_method_desc_search_in_image(mmd, mi);
  85       if (0 == mm) {
  86         printf("Couldn't find Tests:Main(), Tests:Main(string[]) or SimdTests:Main(string[])\n");
  87         exit(-1);
  88       }
  89     }
  90   }
  91   printf("mono desc method: %p\n", mmd);
  92   printf("mono method: %p\n", mm);
  93
  94   mo = mono_runtime_invoke(mm, NULL, args, NULL);
  95   printf("mono object: %p\n", mo);
  96
  97   mono_jit_cleanup(domain);
  98 }
  99
 100 int main(int argc, char *argv[]) {
 101   mono_aot_register_module(mono_aot_module_mscorlib_info);
 102   mono_aot_register_module(mono_aot_module_TestDriver_info);
 103   mono_aot_register_module(mono_aot_module_System_Core_info);
 104   mono_aot_register_module(mono_aot_module_System_info);
 105   mono_aot_register_module(mono_aot_module_Mono_Posix_info);
 106   mono_aot_register_module(mono_aot_module_System_Configuration_info);
 107   mono_aot_register_module(mono_aot_module_System_Security_info);
 108   mono_aot_register_module(mono_aot_module_System_Xml_info);
 109   mono_aot_register_module(mono_aot_module_Mono_Security_info);
 110   /*  mono_aot_register_module(mono_aot_module_System_Threading_info); */
 111   mono_aot_register_module(mono_aot_module_Mono_Simd_info);
 112
 113   mono_aot_register_module(mono_aot_module_basic_info);
 114   mono_aot_register_module(mono_aot_module_basic_float_info);
 115   mono_aot_register_module(mono_aot_module_basic_long_info);
 116   mono_aot_register_module(mono_aot_module_basic_calls_info);
 117   mono_aot_register_module(mono_aot_module_basic_simd_info);
 118   mono_aot_register_module(mono_aot_module_objects_info);
 119   mono_aot_register_module(mono_aot_module_arrays_info);
 120   mono_aot_register_module(mono_aot_module_basic_math_info);
 121   mono_aot_register_module(mono_aot_module_exceptions_info);
 122   mono_aot_register_module(mono_aot_module_devirtualization_info);
 123   /*
 124   mono_aot_register_module(mono_aot_module_generics_info);
 125   mono_aot_register_module(mono_aot_module_generics_variant_types_info);
 126   */
 127
 128   /*  mono_aot_register_module(mono_aot_module_thread_stress_info); */
 129   if (argc < 2) {
 130     printf("no test specified; running basic.exe\n");
 131     printf("==========================\n");
 132     try_one("basic.exe");
 133     printf("==========================\n");
 134   } else {
 135     printf("\nProgram %s %s output:\n", argv[0], argv[1]);
 136     printf("==========================\n\n");
 137     try_one(argv[1]);
 138   }
 139
 140   return 0;
 141 }
 142 #include <stdio.h>
 143 #include <stdlib.h>
 144
 145 #include <mono/metadata/appdomain.h>
 146 #include <mono/metadata/assembly.h>
 147 #include <mono/metadata/debug-helpers.h>
 148 #include <mono/metadata/object.h>
 149 #include <mono/jit/jit.h>
 150
 151 extern void* mono_aot_module_mscorlib_info;
 152 extern void* mono_aot_module_System_Core_info;
 153 extern void* mono_aot_module_System_info;
 154 extern void* mono_aot_module_Mono_Posix_info;
 155 extern void* mono_aot_module_System_Configuration_info;
 156 extern void* mono_aot_module_System_Security_info;
 157 extern void* mono_aot_module_System_Xml_info;
 158 /* extern void* mono_aot_module_System_Threading_info; */
 159 extern void* mono_aot_module_Mono_Security_info;
 160 extern void* mono_aot_module_Mono_Simd_info;
 161 extern void* mono_aot_module_TestDriver_info;
 162
 163 extern void* mono_aot_module_basic_info;
 164 extern void* mono_aot_module_basic_float_info;
 165 extern void* mono_aot_module_basic_long_info;
 166 extern void* mono_aot_module_basic_calls_info;
 167 extern void* mono_aot_module_basic_simd_info;
 168 extern void* mono_aot_module_objects_info;
 169 extern void* mono_aot_module_arrays_info;
 170 extern void* mono_aot_module_basic_math_info;
 171 extern void* mono_aot_module_exceptions_info;
 172 extern void* mono_aot_module_devirtualization_info;
 173 extern void* mono_aot_module_generics_info;
 174 extern void* mono_aot_module_generics_variant_types_info;
 175 extern void* mono_aot_module_basic_simd_info;
 176 /* extern void* mono_aot_module_thread_stress_info; */
 177
 178
 179 extern void mono_aot_register_module(void *aot_info);
 180 extern void mono_aot_init(void);
 181 extern void mono_jit_set_aot_only(mono_bool aot_only);
 182 extern MonoDomain * mini_init (const char *filename, const char *runtime_version);
 183
 184
 185 void try_one(char *mname) {
 186   MonoDomain *domain;
 187   MonoAssembly *ma;
 188   MonoImage *mi;
 189   MonoClass *mc;
 190   MonoMethodDesc *mmd;
 191   MonoMethod *mm;
 192   MonoObject *mo;
 193   MonoArray *arg_array;
 194   void *args [1];
 195   char *cstr_arg = "20";
 196
 197   mono_jit_set_aot_only(1);
 198   domain = mono_jit_init(mname);
 199   printf("mono domain: %p\n", domain);
 200
 201   ma = mono_domain_assembly_open(domain, mname);
 202   if (0 == ma) {
 203     printf("ERROR: could not open mono assembly\n");
 204     exit(-1);
 205   }
 206   printf("opened mono assembly: %p\n", ma);
 207
 208   mi = mono_assembly_get_image(ma);
 209   printf("mono image: %p\n", mi);
 210
 211   mo = mono_string_new(domain, cstr_arg);
 212   mc = mono_class_from_name(mono_get_corlib(), "System", "String");
 213   printf("string class: %p\n", mc);
 214   arg_array = mono_array_new(domain, mc, 1);
 215   mono_array_setref(arg_array, 0, mo);
 216   args[0] = arg_array;
 217
 218   mmd = mono_method_desc_new("Tests:Main()", 1);
 219   mm = mono_method_desc_search_in_image(mmd, mi);
 220   if (0 == mm) {
 221     mmd = mono_method_desc_new("Tests:Main(string[])", 1);
 222     mm = mono_method_desc_search_in_image(mmd, mi);
 223     if (0 == mm) {
 224       mmd = mono_method_desc_new("SimdTests:Main(string[])", 1);
 225       mm = mono_method_desc_search_in_image(mmd, mi);
 226       if (0 == mm) {
 227         printf("Couldn't find Tests:Main(), Tests:Main(string[]) or SimdTests:Main(string[])\n");
 228         exit(-1);
 229       }
 230     }
 231   }
 232   printf("mono desc method: %p\n", mmd);
 233   printf("mono method: %p\n", mm);
 234
 235   mo = mono_runtime_invoke(mm, NULL, args, NULL);
 236   printf("mono object: %p\n", mo);
 237
 238   mono_jit_cleanup(domain);
 239 }
 240
 241 int main(int argc, char *argv[]) {
 242   mono_aot_register_module(mono_aot_module_mscorlib_info);
 243   mono_aot_register_module(mono_aot_module_TestDriver_info);
 244   mono_aot_register_module(mono_aot_module_System_Core_info);
 245   mono_aot_register_module(mono_aot_module_System_info);
 246   mono_aot_register_module(mono_aot_module_Mono_Posix_info);
 247   mono_aot_register_module(mono_aot_module_System_Configuration_info);
 248   mono_aot_register_module(mono_aot_module_System_Security_info);
 249   mono_aot_register_module(mono_aot_module_System_Xml_info);
 250   mono_aot_register_module(mono_aot_module_Mono_Security_info);
 251   /*  mono_aot_register_module(mono_aot_module_System_Threading_info); */
 252   mono_aot_register_module(mono_aot_module_Mono_Simd_info);
 253
 254   mono_aot_register_module(mono_aot_module_basic_info);
 255   mono_aot_register_module(mono_aot_module_basic_float_info);
 256   mono_aot_register_module(mono_aot_module_basic_long_info);
 257   mono_aot_register_module(mono_aot_module_basic_calls_info);
 258   mono_aot_register_module(mono_aot_module_basic_simd_info);
 259   mono_aot_register_module(mono_aot_module_objects_info);
 260   mono_aot_register_module(mono_aot_module_arrays_info);
 261   mono_aot_register_module(mono_aot_module_basic_math_info);
 262   mono_aot_register_module(mono_aot_module_exceptions_info);
 263   mono_aot_register_module(mono_aot_module_devirtualization_info);
 264   /*
 265   mono_aot_register_module(mono_aot_module_generics_info);
 266   mono_aot_register_module(mono_aot_module_generics_variant_types_info);
 267   */
 268
 269   /*  mono_aot_register_module(mono_aot_module_thread_stress_info); */
 270   if (argc < 2) {
 271     printf("no test specified; running basic.exe\n");
 272     printf("==========================\n");
 273     try_one("basic.exe");
 274     printf("==========================\n");
 275   } else {
 276     printf("\nProgram %s %s output:\n", argv[0], argv[1]);
 277     printf("==========================\n\n");
 278     try_one(argv[1]);
 279   }
 280
 281   return 0;
 282 }