?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge -r151658:151801 from mono-2-6 branch
[mono-project.git] / mono / mini / driver.c
blobc4e7f4ccdb3e8cab92a77971aed296e5ce853db1
1 /*
2 * driver.c: The new mono JIT compiler.
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 * Dietmar Maurer (dietmar@ximian.com)
7 *
8 * (C) 2002-2003 Ximian, Inc.
9 * (C) 2003-2006 Novell, Inc.
10 */
11
12 #include <config.h>
13 #include <signal.h>
14 #if HAVE_SCHED_SETAFFINITY
15 #include <sched.h>
16 #endif
17 #ifdef HAVE_UNISTD_H
18 #include <unistd.h>
19 #endif
20
21 #include <mono/metadata/assembly.h>
22 #include <mono/metadata/loader.h>
23 #include <mono/metadata/tabledefs.h>
24 #include <mono/metadata/class.h>
25 #include <mono/metadata/object.h>
26 #include <mono/metadata/exception.h>
27 #include <mono/metadata/opcodes.h>
28 #include <mono/metadata/mono-endian.h>
29 #include <mono/metadata/tokentype.h>
30 #include <mono/metadata/tabledefs.h>
31 #include <mono/metadata/threads.h>
32 #include <mono/metadata/marshal.h>
33 #include <mono/metadata/socket-io.h>
34 #include <mono/metadata/appdomain.h>
35 #include <mono/metadata/debug-helpers.h>
36 #include <mono/io-layer/io-layer.h>
37 #include "mono/metadata/profiler.h"
38 #include <mono/metadata/profiler-private.h>
39 #include <mono/metadata/mono-config.h>
40 #include <mono/metadata/environment.h>
41 #include <mono/metadata/verify.h>
42 #include <mono/metadata/verify-internals.h>
43 #include <mono/metadata/mono-debug.h>
44 #include <mono/metadata/security-manager.h>
45 #include <mono/metadata/security-core-clr.h>
46 #include <mono/metadata/gc-internal.h>
47 #include <mono/metadata/coree.h>
48 #include <mono/metadata/attach.h>
49 #include "mono/utils/mono-counters.h"
50 #include <mono/utils/gc_wrapper.h>
51
52 #include "mini.h"
53 #include "jit.h"
54 #include <string.h>
55 #include <ctype.h>
56 #include <locale.h>
57 #include "version.h"
58 #include "debugger-agent.h"
59
60 static FILE *mini_stats_fd = NULL;
61
62 static void mini_usage (void);
63
64 #ifdef PLATFORM_WIN32
65 /* Need this to determine whether to detach console */
66 #include <mono/metadata/cil-coff.h>
67 /* This turns off command line globbing under win32 */
68 int _CRT_glob = 0;
69 #endif
70
71 typedef void (*OptFunc) (const char *p);
72
73 #undef OPTFLAG
74 #ifdef HAVE_ARRAY_ELEM_INIT
75 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
76 #define MSGSTRFIELD1(line) str##line
77
78 static const struct msgstr_t {
79 #define OPTFLAG(id,shift,name,desc) char MSGSTRFIELD(__LINE__) [sizeof (name) + sizeof (desc)];
80 #include "optflags-def.h"
81 #undef OPTFLAG
82 } opstr = {
83 #define OPTFLAG(id,shift,name,desc) name "\0" desc,
84 #include "optflags-def.h"
85 #undef OPTFLAG
86 };
87 static const gint16 opt_names [] = {
88 #define OPTFLAG(id,shift,name,desc) [(shift)] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
89 #include "optflags-def.h"
90 #undef OPTFLAG
91 };
92
93 #define optflag_get_name(id) ((const char*)&opstr + opt_names [(id)])
94 #define optflag_get_desc(id) (optflag_get_name(id) + 1 + strlen (optflag_get_name(id)))
95
96 #else /* !HAVE_ARRAY_ELEM_INIT */
97 typedef struct {
98 const char* name;
99 const char* desc;
100 } OptName;
101
102 #define OPTFLAG(id,shift,name,desc) {name,desc},
103 static const OptName
104 opt_names [] = {
105 #include "optflags-def.h"
106 {NULL, NULL}
107 };
108 #define optflag_get_name(id) (opt_names [(id)].name)
109 #define optflag_get_desc(id) (opt_names [(id)].desc)
110
111 #endif
112
113 static const OptFunc
114 opt_funcs [sizeof (int) * 8] = {
115 NULL
116 };
117
118
119 #define DEFAULT_OPTIMIZATIONS ( \
120 MONO_OPT_PEEPHOLE | \
121 MONO_OPT_CFOLD | \
122 MONO_OPT_INLINE | \
123 MONO_OPT_CONSPROP | \
124 MONO_OPT_COPYPROP | \
125 MONO_OPT_TREEPROP | \
126 MONO_OPT_DEADCE | \
127 MONO_OPT_BRANCH | \
128 MONO_OPT_LINEARS | \
129 MONO_OPT_INTRINS | \
130 MONO_OPT_LOOP | \
131 MONO_OPT_EXCEPTION | \
132 MONO_OPT_CMOV | \
133 MONO_OPT_GSHARED | \
134 MONO_OPT_SIMD | \
135 MONO_OPT_AOT)
136
137 #define EXCLUDED_FROM_ALL (MONO_OPT_SHARED | MONO_OPT_PRECOMP)
138
139 static guint32
140 parse_optimizations (const char* p)
141 {
142 /* the default value */
143 guint32 opt = DEFAULT_OPTIMIZATIONS;
144 guint32 exclude = 0;
145 const char *n;
146 int i, invert, len;
147
148 /* call out to cpu detection code here that sets the defaults ... */
149 opt |= mono_arch_cpu_optimizazions (&exclude);
150 opt &= ~exclude;
151 if (!p)
152 return opt;
153
154 while (*p) {
155 if (*p == '-') {
156 p++;
157 invert = TRUE;
158 } else {
159 invert = FALSE;
160 }
161 for (i = 0; i < G_N_ELEMENTS (opt_names) && optflag_get_name (i); ++i) {
162 n = optflag_get_name (i);
163 len = strlen (n);
164 if (strncmp (p, n, len) == 0) {
165 if (invert)
166 opt &= ~ (1 << i);
167 else
168 opt |= 1 << i;
169 p += len;
170 if (*p == ',') {
171 p++;
172 break;
173 } else if (*p == '=') {
174 p++;
175 if (opt_funcs [i])
176 opt_funcs [i] (p);
177 while (*p && *p++ != ',');
178 break;
179 }
180 /* error out */
181 break;
182 }
183 }
184 if (i == G_N_ELEMENTS (opt_names) || !optflag_get_name (i)) {
185 if (strncmp (p, "all", 3) == 0) {
186 if (invert)
187 opt = 0;
188 else
189 opt = ~(EXCLUDED_FROM_ALL | exclude);
190 p += 3;
191 if (*p == ',')
192 p++;
193 } else {
194 fprintf (stderr, "Invalid optimization name `%s'\n", p);
195 exit (1);
196 }
197 }
198 }
199 return opt;
200 }
201
202 static gboolean
203 parse_debug_options (const char* p)
204 {
205 MonoDebugOptions *opt = mini_get_debug_options ();
206
207 do {
208 if (!*p) {
209 fprintf (stderr, "Syntax error; expected debug option name\n");
210 return FALSE;
211 }
212
213 if (!strncmp (p, "casts", 5)) {
214 opt->better_cast_details = TRUE;
215 p += 5;
216 } else if (!strncmp (p, "mdb-optimizations", 17)) {
217 opt->mdb_optimizations = TRUE;
218 p += 17;
219 } else if (!strncmp (p, "gdb", 3)) {
220 opt->gdb = TRUE;
221 p += 3;
222 } else {
223 fprintf (stderr, "Invalid debug option `%s', use --help-debug for details\n", p);
224 return FALSE;
225 }
226
227 if (*p == ',') {
228 p++;
229 if (!*p) {
230 fprintf (stderr, "Syntax error; expected debug option name\n");
231 return FALSE;
232 }
233 }
234 } while (*p);
235
236 return TRUE;
237 }
238
239 typedef struct {
240 const char name [6];
241 const char desc [18];
242 MonoGraphOptions value;
243 } GraphName;
244
245 static const GraphName
246 graph_names [] = {
247 {"cfg", "Control Flow", MONO_GRAPH_CFG},
248 {"dtree", "Dominator Tree", MONO_GRAPH_DTREE},
249 {"code", "CFG showing code", MONO_GRAPH_CFG_CODE},
250 {"ssa", "CFG after SSA", MONO_GRAPH_CFG_SSA},
251 {"optc", "CFG after IR opts", MONO_GRAPH_CFG_OPTCODE}
252 };
253
254 static MonoGraphOptions
255 mono_parse_graph_options (const char* p)
256 {
257 const char *n;
258 int i, len;
259
260 for (i = 0; i < G_N_ELEMENTS (graph_names); ++i) {
261 n = graph_names [i].name;
262 len = strlen (n);
263 if (strncmp (p, n, len) == 0)
264 return graph_names [i].value;
265 }
266
267 fprintf (stderr, "Invalid graph name provided: %s\n", p);
268 exit (1);
269 }
270
271 int
272 mono_parse_default_optimizations (const char* p)
273 {
274 guint32 opt;
275
276 opt = parse_optimizations (p);
277 return opt;
278 }
279
280 static char*
281 opt_descr (guint32 flags) {
282 GString *str = g_string_new ("");
283 int i, need_comma;
284
285 need_comma = 0;
286 for (i = 0; i < G_N_ELEMENTS (opt_names); ++i) {
287 if (flags & (1 << i)) {
288 if (need_comma)
289 g_string_append_c (str, ',');
290 g_string_append (str, optflag_get_name (i));
291 need_comma = 1;
292 }
293 }
294 return g_string_free (str, FALSE);
295 }
296
297 static const guint32
298 opt_sets [] = {
299 0,
300 MONO_OPT_PEEPHOLE,
301 MONO_OPT_BRANCH,
302 MONO_OPT_CFOLD,
303 MONO_OPT_FCMOV,
304 #ifdef MONO_ARCH_SIMD_INTRINSICS
305 MONO_OPT_SIMD,
306 MONO_OPT_SSE2,
307 MONO_OPT_SIMD | MONO_OPT_SSE2,
308 #endif
309 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_INTRINS,
310 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS,
311 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP,
312 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_CFOLD,
313 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE,
314 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS,
315 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_SSA,
316 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_EXCEPTION,
317 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_EXCEPTION | MONO_OPT_CMOV,
318 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_EXCEPTION | MONO_OPT_ABCREM,
319 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_EXCEPTION | MONO_OPT_ABCREM | MONO_OPT_SSAPRE,
320 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_ABCREM,
321 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_TREEPROP,
322 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_SSAPRE,
323 MONO_OPT_BRANCH | MONO_OPT_PEEPHOLE | MONO_OPT_LINEARS | MONO_OPT_COPYPROP | MONO_OPT_CONSPROP | MONO_OPT_DEADCE | MONO_OPT_LOOP | MONO_OPT_INLINE | MONO_OPT_INTRINS | MONO_OPT_ABCREM | MONO_OPT_SHARED,
324 DEFAULT_OPTIMIZATIONS,
325 };
326
327 typedef int (*TestMethod) (void);
328
329 #if 0
330 static void
331 domain_dump_native_code (MonoDomain *domain) {
332 // need to poke into the domain, move to metadata/domain.c
333 // need to empty jit_info_table and code_mp
334 }
335 #endif
336
337 static int
338 mini_regression (MonoImage *image, int verbose, int *total_run)
339 {
340 guint32 i, opt, opt_flags;
341 MonoMethod *method;
342 MonoCompile *cfg;
343 char *n;
344 int result, expected, failed, cfailed, run, code_size, total;
345 TestMethod func;
346 GTimer *timer = g_timer_new ();
347 MonoDomain *domain = mono_domain_get ();
348 guint32 exclude = 0;
349
350 mono_arch_cpu_optimizazions (&exclude);
351
352 if (mini_stats_fd) {
353 fprintf (mini_stats_fd, "$stattitle = \'Mono Benchmark Results (various optimizations)\';\n");
354
355 fprintf (mini_stats_fd, "$graph->set_legend(qw(");
356 for (opt = 0; opt < G_N_ELEMENTS (opt_sets); opt++) {
357 opt_flags = opt_sets [opt];
358 n = opt_descr (opt_flags);
359 if (!n [0])
360 n = (char *)"none";
361 if (opt)
362 fprintf (mini_stats_fd, " ");
363 fprintf (mini_stats_fd, "%s", n);
364
365
366 }
367 fprintf (mini_stats_fd, "));\n");
368
369 fprintf (mini_stats_fd, "@data = (\n");
370 fprintf (mini_stats_fd, "[");
371 }
372
373 /* load the metadata */
374 for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
375 method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
376 if (!method)
377 continue;
378 mono_class_init (method->klass);
379
380 if (!strncmp (method->name, "test_", 5) && mini_stats_fd) {
381 fprintf (mini_stats_fd, "\"%s\",", method->name);
382 }
383 }
384 if (mini_stats_fd)
385 fprintf (mini_stats_fd, "],\n");
386
387
388 total = 0;
389 *total_run = 0;
390 for (opt = 0; opt < G_N_ELEMENTS (opt_sets); ++opt) {
391 double elapsed, comp_time, start_time;
392
393 opt_flags = opt_sets [opt] & ~exclude;
394 mono_set_defaults (verbose, opt_flags);
395 n = opt_descr (opt_flags);
396 g_print ("Test run: image=%s, opts=%s\n", mono_image_get_filename (image), n);
397 g_free (n);
398 cfailed = failed = run = code_size = 0;
399 comp_time = elapsed = 0.0;
400
401 /* fixme: ugly hack - delete all previously compiled methods */
402 g_hash_table_destroy (domain_jit_info (domain)->jit_trampoline_hash);
403 domain_jit_info (domain)->jit_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
404 mono_internal_hash_table_destroy (&(domain->jit_code_hash));
405 mono_jit_code_hash_init (&(domain->jit_code_hash));
406
407 g_timer_start (timer);
408 if (mini_stats_fd)
409 fprintf (mini_stats_fd, "[");
410 for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
411 method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
412 if (!method)
413 continue;
414 if (strncmp (method->name, "test_", 5) == 0) {
415 expected = atoi (method->name + 5);
416 run++;
417 start_time = g_timer_elapsed (timer, NULL);
418 comp_time -= start_time;
419 cfg = mini_method_compile (method, opt_flags, mono_get_root_domain (), TRUE, FALSE, 0);
420 comp_time += g_timer_elapsed (timer, NULL);
421 if (cfg->exception_type == MONO_EXCEPTION_NONE) {
422 if (verbose >= 2)
423 g_print ("Running '%s' ...\n", method->name);
424 #ifdef MONO_USE_AOT_COMPILER
425 if ((func = mono_aot_get_method (mono_get_root_domain (), method)))
426 ;
427 else
428 #endif
429 func = (TestMethod)(gpointer)cfg->native_code;
430 func = (TestMethod)mono_create_ftnptr (mono_get_root_domain (), func);
431 result = func ();
432 if (result != expected) {
433 failed++;
434 g_print ("Test '%s' failed result (got %d, expected %d).\n", method->name, result, expected);
435 }
436 code_size += cfg->code_len;
437 mono_destroy_compile (cfg);
438
439 } else {
440 cfailed++;
441 if (verbose)
442 g_print ("Test '%s' failed compilation.\n", method->name);
443 }
444 if (mini_stats_fd)
445 fprintf (mini_stats_fd, "%f, ",
446 g_timer_elapsed (timer, NULL) - start_time);
447 }
448 }
449 if (mini_stats_fd)
450 fprintf (mini_stats_fd, "],\n");
451 g_timer_stop (timer);
452 elapsed = g_timer_elapsed (timer, NULL);
453 if (failed > 0 || cfailed > 0){
454 g_print ("Results: total tests: %d, failed: %d, cfailed: %d (pass: %.2f%%)\n",
455 run, failed, cfailed, 100.0*(run-failed-cfailed)/run);
456 } else {
457 g_print ("Results: total tests: %d, all pass \n", run);
458 }
459
460 g_print ("Elapsed time: %f secs (%f, %f), Code size: %d\n\n", elapsed,
461 elapsed - comp_time, comp_time, code_size);
462 total += failed + cfailed;
463 *total_run += run;
464 }
465
466 if (mini_stats_fd) {
467 fprintf (mini_stats_fd, ");\n");
468 fflush (mini_stats_fd);
469 }
470
471 g_timer_destroy (timer);
472 return total;
473 }
474
475 static int
476 mini_regression_list (int verbose, int count, char *images [])
477 {
478 int i, total, total_run, run;
479 MonoAssembly *ass;
480
481 total_run = total = 0;
482 for (i = 0; i < count; ++i) {
483 ass = mono_assembly_open (images [i], NULL);
484 if (!ass) {
485 g_warning ("failed to load assembly: %s", images [i]);
486 continue;
487 }
488 total += mini_regression (mono_assembly_get_image (ass), verbose, &run);
489 total_run += run;
490 }
491 if (total > 0){
492 g_print ("Overall results: tests: %d, failed: %d, opt combinations: %d (pass: %.2f%%)\n",
493 total_run, total, (int)G_N_ELEMENTS (opt_sets), 100.0*(total_run-total)/total_run);
494 } else {
495 g_print ("Overall results: tests: %d, 100%% pass, opt combinations: %d\n",
496 total_run, (int)G_N_ELEMENTS (opt_sets));
497 }
498
499 return total;
500 }
501
502 #ifdef MONO_JIT_INFO_TABLE_TEST
503 typedef struct _JitInfoData
504 {
505 guint start;
506 guint length;
507 MonoJitInfo *ji;
508 struct _JitInfoData *next;
509 } JitInfoData;
510
511 typedef struct
512 {
513 guint start;
514 guint length;
515 int num_datas;
516 JitInfoData *data;
517 } Region;
518
519 typedef struct
520 {
521 int num_datas;
522 int num_regions;
523 Region *regions;
524 int num_frees;
525 JitInfoData *frees;
526 } ThreadData;
527
528 static int num_threads;
529 static ThreadData *thread_datas;
530 static MonoDomain *test_domain;
531
532 static JitInfoData*
533 alloc_random_data (Region *region)
534 {
535 JitInfoData **data;
536 JitInfoData *prev;
537 guint prev_end;
538 guint next_start;
539 guint max_len;
540 JitInfoData *d;
541 int num_retries = 0;
542 int pos, i;
543
544 restart:
545 prev = NULL;
546 data = &region->data;
547 pos = random () % (region->num_datas + 1);
548 i = 0;
549 while (*data != NULL) {
550 if (i++ == pos)
551 break;
552 prev = *data;
553 data = &(*data)->next;
554 }
555
556 if (prev == NULL)
557 g_assert (*data == region->data);
558 else
559 g_assert (prev->next == *data);
560
561 if (prev == NULL)
562 prev_end = region->start;
563 else
564 prev_end = prev->start + prev->length;
565
566 if (*data == NULL)
567 next_start = region->start + region->length;
568 else
569 next_start = (*data)->start;
570
571 g_assert (prev_end <= next_start);
572
573 max_len = next_start - prev_end;
574 if (max_len < 128) {
575 if (++num_retries >= 10)
576 return NULL;
577 goto restart;
578 }
579 if (max_len > 1024)
580 max_len = 1024;
581
582 d = g_new0 (JitInfoData, 1);
583 d->start = prev_end + random () % (max_len / 2);
584 d->length = random () % MIN (max_len, next_start - d->start) + 1;
585
586 g_assert (d->start >= prev_end && d->start + d->length <= next_start);
587
588 d->ji = g_new0 (MonoJitInfo, 1);
589 d->ji->method = (MonoMethod*) 0xABadBabe;
590 d->ji->code_start = (gpointer)(gulong) d->start;
591 d->ji->code_size = d->length;
592 d->ji->cas_inited = 1; /* marks an allocated jit info */
593
594 d->next = *data;
595 *data = d;
596
597 ++region->num_datas;
598
599 return d;
600 }
601
602 static JitInfoData**
603 choose_random_data (Region *region)
604 {
605 int n;
606 int i;
607 JitInfoData **d;
608
609 g_assert (region->num_datas > 0);
610
611 n = random () % region->num_datas;
612
613 for (d = &region->data, i = 0;
614 i < n;
615 d = &(*d)->next, ++i)
616 ;
617
618 return d;
619 }
620
621 static Region*
622 choose_random_region (ThreadData *td)
623 {
624 return &td->regions [random () % td->num_regions];
625 }
626
627 static ThreadData*
628 choose_random_thread (void)
629 {
630 return &thread_datas [random () % num_threads];
631 }
632
633 static void
634 free_jit_info_data (ThreadData *td, JitInfoData *free)
635 {
636 free->next = td->frees;
637 td->frees = free;
638
639 if (++td->num_frees >= 1000) {
640 int i;
641
642 for (i = 0; i < 500; ++i)
643 free = free->next;
644
645 while (free->next != NULL) {
646 JitInfoData *next = free->next->next;
647
648 //g_free (free->next->ji);
649 g_free (free->next);
650 free->next = next;
651
652 --td->num_frees;
653 }
654 }
655 }
656
657 #define NUM_THREADS 8
658 #define REGIONS_PER_THREAD 10
659 #define REGION_SIZE 0x10000
660
661 #define MAX_ADDR (REGION_SIZE * REGIONS_PER_THREAD * NUM_THREADS)
662
663 #define MODE_ALLOC 1
664 #define MODE_FREE 2
665
666 static void
667 test_thread_func (ThreadData *td)
668 {
669 int mode = MODE_ALLOC;
670 int i = 0;
671 gulong lookup_successes = 0, lookup_failures = 0;
672 MonoDomain *domain = test_domain;
673 int thread_num = (int)(td - thread_datas);
674 gboolean modify_thread = thread_num < NUM_THREADS / 2; /* only half of the threads modify the table */
675
676 for (;;) {
677 int alloc;
678 int lookup = 1;
679
680 if (td->num_datas == 0) {
681 lookup = 0;
682 alloc = 1;
683 } else if (modify_thread && random () % 1000 < 5) {
684 lookup = 0;
685 if (mode == MODE_ALLOC)
686 alloc = (random () % 100) < 70;
687 else if (mode == MODE_FREE)
688 alloc = (random () % 100) < 30;
689 }
690
691 if (lookup) {
692 /* modify threads sometimes look up their own jit infos */
693 if (modify_thread && random () % 10 < 5) {
694 Region *region = choose_random_region (td);
695
696 if (region->num_datas > 0) {
697 JitInfoData **data = choose_random_data (region);
698 guint pos = (*data)->start + random () % (*data)->length;
699 MonoJitInfo *ji;
700
701 ji = mono_jit_info_table_find (domain, (char*)(gulong) pos);
702
703 g_assert (ji->cas_inited);
704 g_assert ((*data)->ji == ji);
705 }
706 } else {
707 int pos = random () % MAX_ADDR;
708 char *addr = (char*)(gulong) pos;
709 MonoJitInfo *ji;
710
711 ji = mono_jit_info_table_find (domain, addr);
712
713 /*
714 * FIXME: We are actually not allowed
715 * to do this. By the time we examine
716 * the ji another thread might already
717 * have removed it.
718 */
719 if (ji != NULL) {
720 g_assert (addr >= (char*)ji->code_start && addr < (char*)ji->code_start + ji->code_size);
721 ++lookup_successes;
722 } else
723 ++lookup_failures;
724 }
725 } else if (alloc) {
726 JitInfoData *data = alloc_random_data (choose_random_region (td));
727
728 if (data != NULL) {
729 mono_jit_info_table_add (domain, data->ji);
730
731 ++td->num_datas;
732 }
733 } else {
734 Region *region = choose_random_region (td);
735
736 if (region->num_datas > 0) {
737 JitInfoData **data = choose_random_data (region);
738 JitInfoData *free;
739
740 mono_jit_info_table_remove (domain, (*data)->ji);
741
742 //(*data)->ji->cas_inited = 0; /* marks a free jit info */
743
744 free = *data;
745 *data = (*data)->next;
746
747 free_jit_info_data (td, free);
748
749 --region->num_datas;
750 --td->num_datas;
751 }
752 }
753
754 if (++i % 100000 == 0) {
755 int j;
756 g_print ("num datas %d (%ld - %ld): %d", (int)(td - thread_datas),
757 lookup_successes, lookup_failures, td->num_datas);
758 for (j = 0; j < td->num_regions; ++j)
759 g_print (" %d", td->regions [j].num_datas);
760 g_print ("\n");
761 }
762
763 if (td->num_datas < 100)
764 mode = MODE_ALLOC;
765 else if (td->num_datas > 2000)
766 mode = MODE_FREE;
767 }
768 }
769
770 /*
771 static void
772 small_id_thread_func (gpointer arg)
773 {
774 MonoThread *thread = mono_thread_current ();
775 MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
776
777 g_print ("my small id is %d\n", (int)thread->small_id);
778 mono_hazard_pointer_clear (hp, 1);
779 sleep (3);
780 g_print ("done %d\n", (int)thread->small_id);
781 }
782 */
783
784 static void
785 jit_info_table_test (MonoDomain *domain)
786 {
787 int i;
788
789 g_print ("testing jit_info_table\n");
790
791 num_threads = NUM_THREADS;
792 thread_datas = g_new0 (ThreadData, num_threads);
793
794 for (i = 0; i < num_threads; ++i) {
795 int j;
796
797 thread_datas [i].num_regions = REGIONS_PER_THREAD;
798 thread_datas [i].regions = g_new0 (Region, REGIONS_PER_THREAD);
799
800 for (j = 0; j < REGIONS_PER_THREAD; ++j) {
801 thread_datas [i].regions [j].start = (num_threads * j + i) * REGION_SIZE;
802 thread_datas [i].regions [j].length = REGION_SIZE;
803 }
804 }
805
806 test_domain = domain;
807
808 /*
809 for (i = 0; i < 72; ++i)
810 mono_thread_create (domain, small_id_thread_func, NULL);
811
812 sleep (2);
813 */
814
815 for (i = 0; i < num_threads; ++i)
816 mono_thread_create (domain, test_thread_func, &thread_datas [i]);
817 }
818 #endif
819
820 enum {
821 DO_BENCH,
822 DO_REGRESSION,
823 DO_COMPILE,
824 DO_EXEC,
825 DO_DRAW,
826 DO_DEBUGGER
827 };
828
829 typedef struct CompileAllThreadArgs {
830 MonoAssembly *ass;
831 int verbose;
832 guint32 opts;
833 } CompileAllThreadArgs;
834
835 static void
836 compile_all_methods_thread_main (CompileAllThreadArgs *args)
837 {
838 MonoAssembly *ass = args->ass;
839 int verbose = args->verbose;
840 MonoImage *image = mono_assembly_get_image (ass);
841 MonoMethod *method;
842 MonoCompile *cfg;
843 int i, count = 0, fail_count = 0;
844
845 for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
846 guint32 token = MONO_TOKEN_METHOD_DEF | (i + 1);
847 MonoMethodSignature *sig;
848
849 if (mono_metadata_has_generic_params (image, token))
850 continue;
851
852 method = mono_get_method (image, token, NULL);
853 if (!method)
854 continue;
855 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
856 (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
857 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
858 (method->flags & METHOD_ATTRIBUTE_ABSTRACT))
859 continue;
860
861 if (method->klass->generic_container)
862 continue;
863 sig = mono_method_signature (method);
864 if (!sig) {
865 char * desc = mono_method_full_name (method, TRUE);
866 g_print ("Could not retrieve method signature for %s\n", desc);
867 g_free (desc);
868 fail_count ++;
869 continue;
870 }
871
872 if (sig->has_type_parameters)
873 continue;
874
875 count++;
876 if (verbose) {
877 char * desc = mono_method_full_name (method, TRUE);
878 g_print ("Compiling %d %s\n", count, desc);
879 g_free (desc);
880 }
881 cfg = mini_method_compile (method, args->opts, mono_get_root_domain (), FALSE, FALSE, 0);
882 if (cfg->exception_type != MONO_EXCEPTION_NONE) {
883 printf ("Compilation of %s failed with exception '%s':\n", mono_method_full_name (cfg->method, TRUE), cfg->exception_message);
884 fail_count ++;
885 }
886 mono_destroy_compile (cfg);
887 }
888
889 if (fail_count)
890 exit (1);
891 }
892
893 static void
894 compile_all_methods (MonoAssembly *ass, int verbose, guint32 opts)
895 {
896 CompileAllThreadArgs args;
897
898 args.ass = ass;
899 args.verbose = verbose;
900 args.opts = opts;
901
902 /*
903 * Need to create a mono thread since compilation might trigger
904 * running of managed code.
905 */
906 mono_thread_create (mono_domain_get (), compile_all_methods_thread_main, &args);
907
908 mono_thread_manage ();
909 }
910
911 /**
912 * mono_jit_exec:
913 * @assembly: reference to an assembly
914 * @argc: argument count
915 * @argv: argument vector
916 *
917 * Start execution of a program.
918 */
919 int
920 mono_jit_exec (MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[])
921 {
922 MonoImage *image = mono_assembly_get_image (assembly);
923 MonoMethod *method;
924 guint32 entry = mono_image_get_entry_point (image);
925
926 if (!entry) {
927 g_print ("Assembly '%s' doesn't have an entry point.\n", mono_image_get_filename (image));
928 /* FIXME: remove this silly requirement. */
929 mono_environment_exitcode_set (1);
930 return 1;
931 }
932
933 method = mono_get_method (image, entry, NULL);
934 if (method == NULL){
935 g_print ("The entry point method could not be loaded\n");
936 mono_environment_exitcode_set (1);
937 return 1;
938 }
939
940 return mono_runtime_run_main (method, argc, argv, NULL);
941 }
942
943 typedef struct
944 {
945 MonoDomain *domain;
946 const char *file;
947 int argc;
948 char **argv;
949 guint32 opts;
950 char *aot_options;
951 } MainThreadArgs;
952
953 static void main_thread_handler (gpointer user_data)
954 {
955 MainThreadArgs *main_args = user_data;
956 MonoAssembly *assembly;
957
958 if (mono_compile_aot) {
959 int i, res;
960
961 /* Treat the other arguments as assemblies to compile too */
962 for (i = 0; i < main_args->argc; ++i) {
963 assembly = mono_domain_assembly_open (main_args->domain, main_args->argv [i]);
964 if (!assembly) {
965 fprintf (stderr, "Can not open image %s\n", main_args->argv [i]);
966 exit (1);
967 }
968 /* Check that the assembly loaded matches the filename */
969 {
970 MonoImageOpenStatus status;
971 MonoImage *img;
972
973 img = mono_image_open (main_args->argv [i], &status);
974 if (img && strcmp (img->name, assembly->image->name)) {
975 fprintf (stderr, "Error: Loaded assembly '%s' doesn't match original file name '%s'. Set MONO_PATH to the assembly's location.\n", assembly->image->name, img->name);
976 exit (1);
977 }
978 }
979 res = mono_compile_assembly (assembly, main_args->opts, main_args->aot_options);
980 if (res != 0) {
981 fprintf (stderr, "AOT of image %s failed.\n", main_args->argv [i]);
982 exit (1);
983 }
984 }
985 } else {
986 assembly = mono_domain_assembly_open (main_args->domain, main_args->file);
987 if (!assembly){
988 fprintf (stderr, "Can not open image %s\n", main_args->file);
989 exit (1);
990 }
991
992 /*
993 * This must be done in a thread managed by mono since it can invoke
994 * managed code.
995 */
996 if (main_args->opts & MONO_OPT_PRECOMP)
997 mono_precompile_assemblies ();
998
999 mono_jit_exec (main_args->domain, assembly, main_args->argc, main_args->argv);
1000 }
1001 }
1002
1003 static int
1004 load_agent (MonoDomain *domain, char *desc)
1005 {
1006 char* col = strchr (desc, ':');
1007 char *agent, *args;
1008 MonoAssembly *agent_assembly;
1009 MonoImage *image;
1010 MonoMethod *method;
1011 guint32 entry;
1012 MonoArray *main_args;
1013 gpointer pa [1];
1014 MonoImageOpenStatus open_status;
1015
1016 if (col) {
1017 agent = g_memdup (desc, col - desc + 1);
1018 agent [col - desc] = '\0';
1019 args = col + 1;
1020 } else {
1021 agent = g_strdup (desc);
1022 args = NULL;
1023 }
1024
1025 agent_assembly = mono_assembly_open (agent, &open_status);
1026 if (!agent_assembly) {
1027 fprintf (stderr, "Cannot open agent assembly '%s': %s.\n", agent, mono_image_strerror (open_status));
1028 g_free (agent);
1029 return 2;
1030 }
1031
1032 /*
1033 * Can't use mono_jit_exec (), as it sets things which might confuse the
1034 * real Main method.
1035 */
1036 image = mono_assembly_get_image (agent_assembly);
1037 entry = mono_image_get_entry_point (image);
1038 if (!entry) {
1039 g_print ("Assembly '%s' doesn't have an entry point.\n", mono_image_get_filename (image));
1040 g_free (agent);
1041 return 1;
1042 }
1043
1044 method = mono_get_method (image, entry, NULL);
1045 if (method == NULL){
1046 g_print ("The entry point method of assembly '%s' could not be loaded\n", agent);
1047 g_free (agent);
1048 return 1;
1049 }
1050
1051 mono_thread_set_main (mono_thread_current ());
1052
1053 if (args) {
1054 main_args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, 1);
1055 mono_array_set (main_args, MonoString*, 0, mono_string_new (domain, args));
1056 } else {
1057 main_args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, 0);
1058 }
1059
1060 g_free (agent);
1061
1062 pa [0] = main_args;
1063 /* Pass NULL as 'exc' so unhandled exceptions abort the runtime */
1064 mono_runtime_invoke (method, NULL, pa, NULL);
1065
1066 return 0;
1067 }
1068
1069 static void
1070 mini_usage_jitdeveloper (void)
1071 {
1072 int i;
1073
1074 fprintf (stdout,
1075 "Runtime and JIT debugging options:\n"
1076 " --breakonex Inserts a breakpoint on exceptions\n"
1077 " --break METHOD Inserts a breakpoint at METHOD entry\n"
1078 " --break-at-bb METHOD N Inserts a breakpoint in METHOD at BB N\n"
1079 " --compile METHOD Just compile METHOD in assembly\n"
1080 " --compile-all Compiles all the methods in the assembly\n"
1081 " --ncompile N Number of times to compile METHOD (default: 1)\n"
1082 " --print-vtable Print the vtable of all used classes\n"
1083 " --regression Runs the regression test contained in the assembly\n"
1084 " --statfile FILE Sets the stat file to FILE\n"
1085 " --stats Print statistics about the JIT operations\n"
1086 " --wapi=hps|semdel|seminfo IO-layer maintenance\n"
1087 " --inject-async-exc METHOD OFFSET Inject an asynchronous exception at METHOD\n"
1088 " --verify-all Run the verifier on all methods\n"
1089 " --full-aot Avoid JITting any code\n"
1090 " --agent=ASSEMBLY[:ARG] Loads the specific agent assembly and executes its Main method with the given argument before loading the main assembly.\n"
1091 " --no-x86-stack-align Don't align stack on x86\n"
1092 "\n"
1093 "Other options:\n"
1094 " --graph[=TYPE] METHOD Draws a graph of the specified method:\n");
1095
1096 for (i = 0; i < G_N_ELEMENTS (graph_names); ++i) {
1097 fprintf (stdout, " %-10s %s\n", graph_names [i].name, graph_names [i].desc);
1098 }
1099 }
1100
1101 static void
1102 mini_usage_list_opt (void)
1103 {
1104 int i;
1105
1106 for (i = 0; i < G_N_ELEMENTS (opt_names); ++i)
1107 fprintf (stdout, " %-10s %s\n", optflag_get_name (i), optflag_get_desc (i));
1108 }
1109
1110 static void
1111 mini_usage (void)
1112 {
1113 fprintf (stdout,
1114 "Usage is: mono [options] program [program-options]\n"
1115 "\n"
1116 "Development:\n"
1117 " --aot Compiles the assembly to native code\n"
1118 " --debug[=<options>] Enable debugging support, use --help-debug for details\n"
1119 " --debugger-agent=options Enable the debugger agent\n"
1120 " --profile[=profiler] Runs in profiling mode with the specified profiler module\n"
1121 " --trace[=EXPR] Enable tracing, use --help-trace for details\n"
1122 " --help-devel Shows more options available to developers\n"
1123 "\n"
1124 "Runtime:\n"
1125 " --config FILE Loads FILE as the Mono config\n"
1126 " --verbose, -v Increases the verbosity level\n"
1127 " --help, -h Show usage information\n"
1128 " --version, -V Show version information\n"
1129 " --runtime=VERSION Use the VERSION runtime, instead of autodetecting\n"
1130 " --optimize=OPT Turns on or off a specific optimization\n"
1131 " Use --list-opt to get a list of optimizations\n"
1132 " --security[=mode] Turns on the unsupported security manager (off by default)\n"
1133 " mode is one of cas, core-clr, verifiable or validil\n"
1134 " --attach=OPTIONS Pass OPTIONS to the attach agent in the runtime.\n"
1135 " Currently the only supported option is 'disable'.\n"
1136 );
1137 }
1138
1139 static void
1140 mini_trace_usage (void)
1141 {
1142 fprintf (stdout,
1143 "Tracing options:\n"
1144 " --trace[=EXPR] Trace every call, optional EXPR controls the scope\n"
1145 "\n"
1146 "EXPR is composed of:\n"
1147 " all All assemblies\n"
1148 " none No assemblies\n"
1149 " program Entry point assembly\n"
1150 " assembly Specifies an assembly\n"
1151 " M:Type:Method Specifies a method\n"
1152 " N:Namespace Specifies a namespace\n"
1153 " T:Type Specifies a type\n"
1154 " EXPR Includes expression\n"
1155 " -EXPR Excludes expression\n"
1156 " EXPR,EXPR Multiple expressions\n"
1157 " disabled Don't print any output until toggled via SIGUSR2\n");
1158 }
1159
1160 static void
1161 mini_debug_usage (void)
1162 {
1163 fprintf (stdout,
1164 "Debugging options:\n"
1165 " --debug[=OPTIONS] Enable debugging support, optional OPTIONS is a comma\n"
1166 " separated list of options\n"
1167 "\n"
1168 "OPTIONS is composed of:\n"
1169 " casts Enable more detailed InvalidCastException messages.\n"
1170 " mdb-optimizations Disable some JIT optimizations which are normally\n"
1171 " disabled when running inside the debugger.\n"
1172 " This is useful if you plan to attach to the running\n"
1173 " process with the debugger.\n");
1174 }
1175
1176 #if defined(MONO_ARCH_ARCHITECTURE)
1177 /* Redefine ARCHITECTURE to include more information */
1178 #undef ARCHITECTURE
1179 #define ARCHITECTURE MONO_ARCH_ARCHITECTURE
1180 #endif
1181
1182 static const char info[] =
1183 #ifdef HAVE_KW_THREAD
1184 "\tTLS: __thread\n"
1185 #else
1186 "\tTLS: normal\n"
1187 #endif /* HAVE_KW_THREAD */
1188 "\tGC: " USED_GC_NAME "\n"
1189 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
1190 "\tSIGSEGV: altstack\n"
1191 #else
1192 "\tSIGSEGV: normal\n"
1193 #endif
1194 #ifdef HAVE_EPOLL
1195 "\tNotifications: epoll\n"
1196 #else
1197 "\tNotification: Thread + polling\n"
1198 #endif
1199 "\tArchitecture: " ARCHITECTURE "\n"
1200 "\tDisabled: " DISABLED_FEATURES "\n"
1201 "";
1202
1203 #ifndef MONO_ARCH_AOT_SUPPORTED
1204 #define error_if_aot_unsupported() do {fprintf (stderr, "AOT compilation is not supported on this platform.\n"); exit (1);} while (0)
1205 #else
1206 #define error_if_aot_unsupported()
1207 #endif
1208
1209 #ifdef PLATFORM_WIN32
1210 BOOL APIENTRY DllMain (HMODULE module_handle, DWORD reason, LPVOID reserved)
1211 {
1212 if (!GC_DllMain (module_handle, reason, reserved))
1213 return FALSE;
1214
1215 switch (reason)
1216 {
1217 case DLL_PROCESS_ATTACH:
1218 mono_install_runtime_load (mini_init);
1219 break;
1220 case DLL_PROCESS_DETACH:
1221 if (coree_module_handle)
1222 FreeLibrary (coree_module_handle);
1223 break;
1224 }
1225 return TRUE;
1226 }
1227 #endif
1228
1229 static gboolean enable_debugging;
1230
1231 /*
1232 * mono_jit_parse_options:
1233 *
1234 * Process the command line options in ARGV as done by the runtime executable.
1235 * This should be called before mono_jit_init ().
1236 */
1237 void
1238 mono_jit_parse_options (int argc, char * argv[])
1239 {
1240 int i;
1241
1242 /*
1243 * Some options have no effect here, since they influence the behavior of
1244 * mono_main ().
1245 */
1246
1247 /* FIXME: Avoid code duplication */
1248 for (i = 0; i < argc; ++i) {
1249 if (argv [i] [0] != '-')
1250 break;
1251 if (strncmp (argv [i], "--debugger-agent=", 17) == 0) {
1252 MonoDebugOptions *opt = mini_get_debug_options ();
1253
1254 mono_debugger_agent_parse_options (argv [i] + 17);
1255 opt->mdb_optimizations = TRUE;
1256 enable_debugging = TRUE;
1257 } else {
1258 fprintf (stderr, "Unsupported command line option: '%s'\n", argv [i]);
1259 exit (1);
1260 }
1261 }
1262 }
1263
1264 int
1265 mono_main (int argc, char* argv[])
1266 {
1267 MainThreadArgs main_args;
1268 MonoAssembly *assembly;
1269 MonoMethodDesc *desc;
1270 MonoMethod *method;
1271 MonoCompile *cfg;
1272 MonoDomain *domain;
1273 MonoImageOpenStatus open_status;
1274 const char* aname, *mname = NULL;
1275 char *config_file = NULL;
1276 int i, count = 1;
1277 guint32 opt, action = DO_EXEC;
1278 MonoGraphOptions mono_graph_options = 0;
1279 int mini_verbose = 0;
1280 gboolean enable_profile = FALSE;
1281 char *trace_options = NULL;
1282 char *profile_options = NULL;
1283 char *aot_options = NULL;
1284 char *forced_version = NULL;
1285 GPtrArray *agents = NULL;
1286 char *attach_options = NULL;
1287 #ifdef MONO_JIT_INFO_TABLE_TEST
1288 int test_jit_info_table = FALSE;
1289 #endif
1290
1291 setlocale (LC_ALL, "");
1292
1293 #if HAVE_SCHED_SETAFFINITY
1294 if (getenv ("MONO_NO_SMP")) {
1295 unsigned long proc_mask = 1;
1296 #ifdef GLIBC_BEFORE_2_3_4_SCHED_SETAFFINITY
1297 sched_setaffinity (getpid(), (gpointer)&proc_mask);
1298 #else
1299 sched_setaffinity (getpid(), sizeof (unsigned long), (gpointer)&proc_mask);
1300 #endif
1301 }
1302 #endif
1303 if (!g_thread_supported ())
1304 g_thread_init (NULL);
1305
1306 if (mono_running_on_valgrind () && getenv ("MONO_VALGRIND_LEAK_CHECK")) {
1307 GMemVTable mem_vtable;
1308
1309 /*
1310 * Instruct glib to use the system allocation functions so valgrind
1311 * can track the memory allocated by the g_... functions.
1312 */
1313 memset (&mem_vtable, 0, sizeof (mem_vtable));
1314 mem_vtable.malloc = malloc;
1315 mem_vtable.realloc = realloc;
1316 mem_vtable.free = free;
1317 mem_vtable.calloc = calloc;
1318
1319 g_mem_set_vtable (&mem_vtable);
1320 }
1321
1322 g_log_set_always_fatal (G_LOG_LEVEL_ERROR);
1323 g_log_set_fatal_mask (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR);
1324
1325 opt = parse_optimizations (NULL);
1326
1327 for (i = 1; i < argc; ++i) {
1328 if (argv [i] [0] != '-')
1329 break;
1330 if (strcmp (argv [i], "--regression") == 0) {
1331 action = DO_REGRESSION;
1332 } else if (strcmp (argv [i], "--verbose") == 0 || strcmp (argv [i], "-v") == 0) {
1333 mini_verbose++;
1334 } else if (strcmp (argv [i], "--version") == 0 || strcmp (argv [i], "-V") == 0) {
1335 char *build = mono_get_runtime_build_info ();
1336 g_print ("Mono JIT compiler version %s\nCopyright (C) 2002-2010 Novell, Inc and Contributors. www.mono-project.com\n", build);
1337 g_free (build);
1338 g_print (info);
1339 if (mini_verbose) {
1340 const char *cerror;
1341 const char *clibpath;
1342 mono_init ("mono");
1343 cerror = mono_check_corlib_version ();
1344 clibpath = mono_defaults.corlib? mono_image_get_filename (mono_defaults.corlib): "unknown";
1345 if (cerror) {
1346 g_print ("The currently installed mscorlib doesn't match this runtime version.\n");
1347 g_print ("The error is: %s\n", cerror);
1348 g_print ("mscorlib.dll loaded at: %s\n", clibpath);
1349 return 1;
1350 }
1351 }
1352 return 0;
1353 } else if (strcmp (argv [i], "--help") == 0 || strcmp (argv [i], "-h") == 0) {
1354 mini_usage ();
1355 return 0;
1356 } else if (strcmp (argv [i], "--help-trace") == 0){
1357 mini_trace_usage ();
1358 return 0;
1359 } else if (strcmp (argv [i], "--help-devel") == 0){
1360 mini_usage_jitdeveloper ();
1361 return 0;
1362 } else if (strcmp (argv [i], "--help-debug") == 0){
1363 mini_debug_usage ();
1364 return 0;
1365 } else if (strcmp (argv [i], "--list-opt") == 0){
1366 mini_usage_list_opt ();
1367 return 0;
1368 } else if (strncmp (argv [i], "--statfile", 10) == 0) {
1369 if (i + 1 >= argc){
1370 fprintf (stderr, "error: --statfile requires a filename argument\n");
1371 return 1;
1372 }
1373 mini_stats_fd = fopen (argv [++i], "w+");
1374 } else if (strncmp (argv [i], "--optimize=", 11) == 0) {
1375 opt = parse_optimizations (argv [i] + 11);
1376 } else if (strncmp (argv [i], "-O=", 3) == 0) {
1377 opt = parse_optimizations (argv [i] + 3);
1378 } else if (strcmp (argv [i], "--config") == 0) {
1379 if (i +1 >= argc){
1380 fprintf (stderr, "error: --config requires a filename argument\n");
1381 return 1;
1382 }
1383 config_file = argv [++i];
1384 } else if (strcmp (argv [i], "--ncompile") == 0) {
1385 if (i + 1 >= argc){
1386 fprintf (stderr, "error: --ncompile requires an argument\n");
1387 return 1;
1388 }
1389 count = atoi (argv [++i]);
1390 action = DO_BENCH;
1391 } else if (strcmp (argv [i], "--trace") == 0) {
1392 trace_options = (char*)"";
1393 } else if (strncmp (argv [i], "--trace=", 8) == 0) {
1394 trace_options = &argv [i][8];
1395 } else if (strcmp (argv [i], "--breakonex") == 0) {
1396 mono_break_on_exc = TRUE;
1397 } else if (strcmp (argv [i], "--break") == 0) {
1398 if (i+1 >= argc){
1399 fprintf (stderr, "Missing method name in --break command line option\n");
1400 return 1;
1401 }
1402
1403 if (!mono_debugger_insert_breakpoint (argv [++i], FALSE))
1404 fprintf (stderr, "Error: invalid method name '%s'\n", argv [i]);
1405 } else if (strcmp (argv [i], "--break-at-bb") == 0) {
1406 if (i + 2 >= argc) {
1407 fprintf (stderr, "Missing method name or bb num in --break-at-bb command line option.");
1408 return 1;
1409 }
1410 mono_break_at_bb_method = mono_method_desc_new (argv [++i], TRUE);
1411 if (mono_break_at_bb_method == NULL) {
1412 fprintf (stderr, "Method name is in a bad format in --break-at-bb command line option.");
1413 return 1;
1414 }
1415 mono_break_at_bb_bb_num = atoi (argv [++i]);
1416 } else if (strcmp (argv [i], "--inject-async-exc") == 0) {
1417 if (i + 2 >= argc) {
1418 fprintf (stderr, "Missing method name or position in --inject-async-exc command line option\n");
1419 return 1;
1420 }
1421 mono_inject_async_exc_method = mono_method_desc_new (argv [++i], TRUE);
1422 if (mono_inject_async_exc_method == NULL) {
1423 fprintf (stderr, "Method name is in a bad format in --inject-async-exc command line option\n");
1424 return 1;
1425 }
1426 mono_inject_async_exc_pos = atoi (argv [++i]);
1427 } else if (strcmp (argv [i], "--verify-all") == 0) {
1428 mono_verifier_enable_verify_all ();
1429 } else if (strcmp (argv [i], "--full-aot") == 0) {
1430 mono_aot_only = TRUE;
1431 } else if (strcmp (argv [i], "--print-vtable") == 0) {
1432 mono_print_vtable = TRUE;
1433 } else if (strcmp (argv [i], "--stats") == 0) {
1434 mono_counters_enable (-1);
1435 mono_stats.enabled = TRUE;
1436 mono_jit_stats.enabled = TRUE;
1437 #ifndef DISABLE_AOT
1438 } else if (strcmp (argv [i], "--aot") == 0) {
1439 error_if_aot_unsupported ();
1440 mono_compile_aot = TRUE;
1441 } else if (strncmp (argv [i], "--aot=", 6) == 0) {
1442 error_if_aot_unsupported ();
1443 mono_compile_aot = TRUE;
1444 aot_options = &argv [i][6];
1445 #endif
1446 } else if (strcmp (argv [i], "--compile-all") == 0) {
1447 action = DO_COMPILE;
1448 } else if (strncmp (argv [i], "--runtime=", 10) == 0) {
1449 forced_version = &argv [i][10];
1450 } else if (strcmp (argv [i], "--profile") == 0) {
1451 enable_profile = TRUE;
1452 profile_options = NULL;
1453 } else if (strncmp (argv [i], "--profile=", 10) == 0) {
1454 enable_profile = TRUE;
1455 profile_options = argv [i] + 10;
1456 } else if (strncmp (argv [i], "--agent=", 8) == 0) {
1457 if (agents == NULL)
1458 agents = g_ptr_array_new ();
1459 g_ptr_array_add (agents, argv [i] + 8);
1460 } else if (strncmp (argv [i], "--attach=", 9) == 0) {
1461 attach_options = argv [i] + 9;
1462 } else if (strcmp (argv [i], "--compile") == 0) {
1463 if (i + 1 >= argc){
1464 fprintf (stderr, "error: --compile option requires a method name argument\n");
1465 return 1;
1466 }
1467
1468 mname = argv [++i];
1469 action = DO_BENCH;
1470 } else if (strncmp (argv [i], "--graph=", 8) == 0) {
1471 if (i + 1 >= argc){
1472 fprintf (stderr, "error: --graph option requires a method name argument\n");
1473 return 1;
1474 }
1475
1476 mono_graph_options = mono_parse_graph_options (argv [i] + 8);
1477 mname = argv [++i];
1478 action = DO_DRAW;
1479 } else if (strcmp (argv [i], "--graph") == 0) {
1480 if (i + 1 >= argc){
1481 fprintf (stderr, "error: --graph option requires a method name argument\n");
1482 return 1;
1483 }
1484
1485 mname = argv [++i];
1486 mono_graph_options = MONO_GRAPH_CFG;
1487 action = DO_DRAW;
1488 } else if (strcmp (argv [i], "--debug") == 0) {
1489 enable_debugging = TRUE;
1490 } else if (strncmp (argv [i], "--debug=", 8) == 0) {
1491 enable_debugging = TRUE;
1492 if (!parse_debug_options (argv [i] + 8))
1493 return 1;
1494 } else if (strncmp (argv [i], "--debugger-agent=", 17) == 0) {
1495 MonoDebugOptions *opt = mini_get_debug_options ();
1496
1497 mono_debugger_agent_parse_options (argv [i] + 17);
1498 opt->mdb_optimizations = TRUE;
1499 enable_debugging = TRUE;
1500 } else if (strcmp (argv [i], "--security") == 0) {
1501 mono_verifier_set_mode (MONO_VERIFIER_MODE_VERIFIABLE);
1502 mono_security_set_mode (MONO_SECURITY_MODE_CAS);
1503 mono_activate_security_manager ();
1504 } else if (strncmp (argv [i], "--security=", 11) == 0) {
1505 if (strcmp (argv [i] + 11, "temporary-smcs-hack") == 0) {
1506 mono_security_set_mode (MONO_SECURITY_MODE_SMCS_HACK);
1507 } else if (strcmp (argv [i] + 11, "core-clr") == 0) {
1508 mono_verifier_set_mode (MONO_VERIFIER_MODE_VERIFIABLE);
1509 mono_security_set_mode (MONO_SECURITY_MODE_CORE_CLR);
1510 } else if (strcmp (argv [i] + 11, "core-clr-test") == 0) {
1511 /* fixme should we enable verifiable code here?*/
1512 mono_security_set_mode (MONO_SECURITY_MODE_CORE_CLR);
1513 mono_security_core_clr_test = TRUE;
1514 } else if (strcmp (argv [i] + 11, "cas") == 0){
1515 mono_verifier_set_mode (MONO_VERIFIER_MODE_VERIFIABLE);
1516 mono_security_set_mode (MONO_SECURITY_MODE_CAS);
1517 mono_activate_security_manager ();
1518 } else if (strcmp (argv [i] + 11, "validil") == 0) {
1519 mono_verifier_set_mode (MONO_VERIFIER_MODE_VALID);
1520 } else if (strcmp (argv [i] + 11, "verifiable") == 0) {
1521 mono_verifier_set_mode (MONO_VERIFIER_MODE_VERIFIABLE);
1522 } else {
1523 fprintf (stderr, "error: --security= option has invalid argument (cas, core-clr, verifiable or validil)\n");
1524 return 1;
1525 }
1526 } else if (strcmp (argv [i], "--desktop") == 0) {
1527 #if defined (HAVE_BOEHM_GC)
1528 GC_dont_expand = 1;
1529 #endif
1530 /* Put desktop-specific optimizations here */
1531 } else if (strcmp (argv [i], "--server") == 0){
1532 /* Put server-specific optimizations here */
1533 } else if (strcmp (argv [i], "--inside-mdb") == 0) {
1534 action = DO_DEBUGGER;
1535 } else if (strncmp (argv [i], "--wapi=", 7) == 0) {
1536 if (strcmp (argv [i] + 7, "hps") == 0) {
1537 return mini_wapi_hps (argc - i, argv + i);
1538 } else if (strcmp (argv [i] + 7, "semdel") == 0) {
1539 return mini_wapi_semdel (argc - i, argv + i);
1540 } else if (strcmp (argv [i] + 7, "seminfo") == 0) {
1541 return mini_wapi_seminfo (argc - i, argv + i);
1542 } else {
1543 fprintf (stderr, "Invalid --wapi suboption: '%s'\n", argv [i]);
1544 return 1;
1545 }
1546 } else if (strcmp (argv [i], "--no-x86-stack-align") == 0) {
1547 mono_do_x86_stack_align = FALSE;
1548 #ifdef MONO_JIT_INFO_TABLE_TEST
1549 } else if (strcmp (argv [i], "--test-jit-info-table") == 0) {
1550 test_jit_info_table = TRUE;
1551 #endif
1552 } else {
1553 fprintf (stderr, "Unknown command line option: '%s'\n", argv [i]);
1554 return 1;
1555 }
1556 }
1557
1558 if (!argv [i]) {
1559 mini_usage ();
1560 return 1;
1561 }
1562
1563 if (getenv ("MONO_XDEBUG"))
1564 enable_debugging = TRUE;
1565
1566 #ifdef MONO_CROSS_COMPILE
1567 if (!mono_compile_aot) {
1568 fprintf (stderr, "This mono runtime is compiled for cross-compiling. Only the --aot option is supported.");
1569 exit (1);
1570 }
1571 #endif
1572
1573 if ((action == DO_EXEC) && mono_debug_using_mono_debugger ())
1574 action = DO_DEBUGGER;
1575
1576 if (mono_compile_aot || action == DO_EXEC || action == DO_DEBUGGER) {
1577 g_set_prgname (argv[i]);
1578 }
1579
1580 if (enable_profile)
1581 mono_profiler_load (profile_options);
1582
1583 mono_attach_parse_options (attach_options);
1584
1585 if (trace_options != NULL){
1586 /*
1587 * Need to call this before mini_init () so we can trace methods
1588 * compiled there too.
1589 */
1590 mono_jit_trace_calls = mono_trace_parse_options (trace_options);
1591 if (mono_jit_trace_calls == NULL)
1592 exit (1);
1593 }
1594
1595 #ifdef DISABLE_JIT
1596 if (!mono_aot_only) {
1597 fprintf (stderr, "This runtime has been configured with --enable-minimal=jit, so the --full-aot command line option is required.\n");
1598 exit (1);
1599 }
1600 #endif
1601
1602 if (action == DO_DEBUGGER) {
1603 enable_debugging = TRUE;
1604
1605 #ifdef MONO_DEBUGGER_SUPPORTED
1606 mono_debug_init (MONO_DEBUG_FORMAT_DEBUGGER);
1607 #else
1608 g_print ("The Mono Debugger is not supported on this platform.\n");
1609 return 1;
1610 #endif
1611 } else if (enable_debugging)
1612 mono_debug_init (MONO_DEBUG_FORMAT_MONO);
1613
1614 #ifdef MONO_DEBUGGER_SUPPORTED
1615 if (enable_debugging) {
1616 if ((opt & MONO_OPT_GSHARED) == 0)
1617 mini_debugger_set_attach_ok ();
1618 }
1619 #endif
1620
1621 mono_set_defaults (mini_verbose, opt);
1622 mono_setup_vtable_in_class_init = FALSE;
1623 domain = mini_init (argv [i], forced_version);
1624
1625 if (agents) {
1626 int i;
1627
1628 for (i = 0; i < agents->len; ++i) {
1629 int res = load_agent (domain, (char*)g_ptr_array_index (agents, i));
1630 if (res) {
1631 g_ptr_array_free (agents, TRUE);
1632 mini_cleanup (domain);
1633 return 1;
1634 }
1635 }
1636
1637 g_ptr_array_free (agents, TRUE);
1638 }
1639
1640 switch (action) {
1641 case DO_REGRESSION:
1642 if (mini_regression_list (mini_verbose, argc -i, argv + i)) {
1643 g_print ("Regression ERRORS!\n");
1644 mini_cleanup (domain);
1645 return 1;
1646 }
1647 mini_cleanup (domain);
1648 return 0;
1649 case DO_BENCH:
1650 if (argc - i != 1 || mname == NULL) {
1651 g_print ("Usage: mini --ncompile num --compile method assembly\n");
1652 mini_cleanup (domain);
1653 return 1;
1654 }
1655 aname = argv [i];
1656 break;
1657 case DO_COMPILE:
1658 if (argc - i != 1) {
1659 mini_usage ();
1660 mini_cleanup (domain);
1661 return 1;
1662 }
1663 aname = argv [i];
1664 break;
1665 case DO_DRAW:
1666 if (argc - i != 1 || mname == NULL) {
1667 mini_usage ();
1668 mini_cleanup (domain);
1669 return 1;
1670 }
1671 aname = argv [i];
1672 break;
1673 default:
1674 if (argc - i < 1) {
1675 mini_usage ();
1676 mini_cleanup (domain);
1677 return 1;
1678 }
1679 aname = argv [i];
1680 break;
1681 }
1682
1683 /* Parse gac loading options before loading assemblies. */
1684 if (mono_compile_aot || action == DO_EXEC || action == DO_DEBUGGER) {
1685 mono_config_parse (config_file);
1686 }
1687
1688 #ifdef MONO_JIT_INFO_TABLE_TEST
1689 if (test_jit_info_table)
1690 jit_info_table_test (domain);
1691 #endif
1692
1693 assembly = mono_assembly_open (aname, &open_status);
1694 if (!assembly) {
1695 fprintf (stderr, "Cannot open assembly '%s': %s.\n", aname, mono_image_strerror (open_status));
1696 mini_cleanup (domain);
1697 return 2;
1698 }
1699
1700 if (trace_options != NULL)
1701 mono_trace_set_assembly (assembly);
1702
1703 if (mono_compile_aot || action == DO_EXEC) {
1704 const char *error;
1705
1706 //mono_set_rootdir ();
1707
1708 error = mono_check_corlib_version ();
1709 if (error) {
1710 fprintf (stderr, "Corlib not in sync with this runtime: %s\n", error);
1711 fprintf (stderr, "Loaded from: %s\n",
1712 mono_defaults.corlib? mono_image_get_filename (mono_defaults.corlib): "unknown");
1713 fprintf (stderr, "Download a newer corlib or a newer runtime at http://www.go-mono.com/daily.\n");
1714 exit (1);
1715 }
1716
1717 #ifdef PLATFORM_WIN32
1718 /* Detach console when executing IMAGE_SUBSYSTEM_WINDOWS_GUI on win32 */
1719 if (!enable_debugging && !mono_compile_aot && ((MonoCLIImageInfo*)(mono_assembly_get_image (assembly)->image_info))->cli_header.nt.pe_subsys_required == IMAGE_SUBSYSTEM_WINDOWS_GUI)
1720 FreeConsole ();
1721 #endif
1722
1723 main_args.domain = domain;
1724 main_args.file = aname;
1725 main_args.argc = argc - i;
1726 main_args.argv = argv + i;
1727 main_args.opts = opt;
1728 main_args.aot_options = aot_options;
1729 #if RUN_IN_SUBTHREAD
1730 mono_runtime_exec_managed_code (domain, main_thread_handler, &main_args);
1731 #else
1732 main_thread_handler (&main_args);
1733 mono_thread_manage ();
1734 #endif
1735
1736 /*
1737 * On unix, WaitForMultipleObjects for threads is implemented by waiting on
1738 * a cond variable, which is set by the thread when it exits _mono code_,
1739 * but it could still be running libc code. On amd64, the libc thread exit
1740 * code does a stack unwind, and if it encounters a frame pointing to native
1741 * code which is in memory which is no longer mapped (because the runtime has
1742 * shut down), it will crash:
1743 * http://mail-archives.apache.org/mod_mbox/harmony-dev/200801.mbox/%3C200801130327.41572.gshimansky@apache.org%3E
1744 * Testcase: tests/main-exit-background-change.exe.
1745 * To make this race less frequent, we avoid freeing the global code manager.
1746 * Since mono_main () is hopefully only used by the runtime executable, this
1747 * will only cause a shutdown leak. This workaround also has the advantage
1748 * that it can be back-ported to 2.0 safely.
1749 * FIXME: Fix this properly by waiting for threads to really exit using
1750 * pthread_join (). This cannot be done currently as the io-layer calls
1751 * pthread_detach ().
1752 */
1753 #ifdef __x86_64__
1754 mono_dont_free_global_codeman = TRUE;
1755 #endif
1756
1757 mini_cleanup (domain);
1758
1759 /* Look up return value from System.Environment.ExitCode */
1760 i = mono_environment_exitcode_get ();
1761 return i;
1762 } else if (action == DO_COMPILE) {
1763 compile_all_methods (assembly, mini_verbose, opt);
1764 mini_cleanup (domain);
1765 return 0;
1766 } else if (action == DO_DEBUGGER) {
1767 #ifdef MONO_DEBUGGER_SUPPORTED
1768 const char *error;
1769
1770 error = mono_check_corlib_version ();
1771 if (error) {
1772 fprintf (stderr, "Corlib not in sync with this runtime: %s\n", error);
1773 fprintf (stderr, "Download a newer corlib or a newer runtime at http://www.go-mono.com/daily.\n");
1774 exit (1);
1775 }
1776
1777 mini_debugger_main (domain, assembly, argc - i, argv + i);
1778 mini_cleanup (domain);
1779 return 0;
1780 #else
1781 return 1;
1782 #endif
1783 }
1784 desc = mono_method_desc_new (mname, 0);
1785 if (!desc) {
1786 g_print ("Invalid method name %s\n", mname);
1787 mini_cleanup (domain);
1788 return 3;
1789 }
1790 method = mono_method_desc_search_in_image (desc, mono_assembly_get_image (assembly));
1791 if (!method) {
1792 g_print ("Cannot find method %s\n", mname);
1793 mini_cleanup (domain);
1794 return 3;
1795 }
1796
1797 if (action == DO_DRAW) {
1798 int part = 0;
1799
1800 switch (mono_graph_options) {
1801 case MONO_GRAPH_DTREE:
1802 part = 1;
1803 opt |= MONO_OPT_LOOP;
1804 break;
1805 case MONO_GRAPH_CFG_CODE:
1806 part = 1;
1807 break;
1808 case MONO_GRAPH_CFG_SSA:
1809 part = 2;
1810 break;
1811 case MONO_GRAPH_CFG_OPTCODE:
1812 part = 3;
1813 break;
1814 default:
1815 break;
1816 }
1817
1818 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
1819 (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) {
1820 MonoMethod *nm;
1821 nm = mono_marshal_get_native_wrapper (method, TRUE, FALSE);
1822 cfg = mini_method_compile (nm, opt, mono_get_root_domain (), FALSE, FALSE, part);
1823 }
1824 else
1825 cfg = mini_method_compile (method, opt, mono_get_root_domain (), FALSE, FALSE, part);
1826 if ((mono_graph_options & MONO_GRAPH_CFG_SSA) && !(cfg->comp_done & MONO_COMP_SSA)) {
1827 g_warning ("no SSA info available (use -O=deadce)");
1828 return 1;
1829 }
1830 mono_draw_graph (cfg, mono_graph_options);
1831 mono_destroy_compile (cfg);
1832
1833 } else if (action == DO_BENCH) {
1834 if (mini_stats_fd) {
1835 const char *n;
1836 double no_opt_time = 0.0;
1837 GTimer *timer = g_timer_new ();
1838 fprintf (mini_stats_fd, "$stattitle = \'Compilations times for %s\';\n",
1839 mono_method_full_name (method, TRUE));
1840 fprintf (mini_stats_fd, "@data = (\n");
1841 fprintf (mini_stats_fd, "[");
1842 for (i = 0; i < G_N_ELEMENTS (opt_sets); i++) {
1843 opt = opt_sets [i];
1844 n = opt_descr (opt);
1845 if (!n [0])
1846 n = "none";
1847 fprintf (mini_stats_fd, "\"%s\",", n);
1848 }
1849 fprintf (mini_stats_fd, "],\n[");
1850
1851 for (i = 0; i < G_N_ELEMENTS (opt_sets); i++) {
1852 int j;
1853 double elapsed;
1854 opt = opt_sets [i];
1855 g_timer_start (timer);
1856 for (j = 0; j < count; ++j) {
1857 cfg = mini_method_compile (method, opt, mono_get_root_domain (), FALSE, FALSE, 0);
1858 mono_destroy_compile (cfg);
1859 }
1860 g_timer_stop (timer);
1861 elapsed = g_timer_elapsed (timer, NULL);
1862 if (!opt)
1863 no_opt_time = elapsed;
1864 fprintf (mini_stats_fd, "%f, ", elapsed);
1865 }
1866 fprintf (mini_stats_fd, "]");
1867 if (no_opt_time > 0.0) {
1868 fprintf (mini_stats_fd, ", \n[");
1869 for (i = 0; i < G_N_ELEMENTS (opt_sets); i++)
1870 fprintf (mini_stats_fd, "%f,", no_opt_time);
1871 fprintf (mini_stats_fd, "]");
1872 }
1873 fprintf (mini_stats_fd, ");\n");
1874 } else {
1875 for (i = 0; i < count; ++i) {
1876 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
1877 (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
1878 method = mono_marshal_get_native_wrapper (method, TRUE, FALSE);
1879
1880 cfg = mini_method_compile (method, opt, mono_get_root_domain (), FALSE, FALSE, 0);
1881 mono_destroy_compile (cfg);
1882 }
1883 }
1884 } else {
1885 cfg = mini_method_compile (method, opt, mono_get_root_domain (), FALSE, FALSE, 0);
1886 mono_destroy_compile (cfg);
1887 }
1888
1889 mini_cleanup (domain);
1890 return 0;
1891 }
1892
1893 MonoDomain *
1894 mono_jit_init (const char *file)
1895 {
1896 return mini_init (file, NULL);
1897 }
1898
1899 /**
1900 * mono_jit_init_version:
1901 * @domain_name: the name of the root domain
1902 * @runtime_version: the version of the runtime to load
1903 *
1904 * Use this version when you want to force a particular runtime
1905 * version to be used. By default Mono will pick the runtime that is
1906 * referenced by the initial assembly (specified in @file), this
1907 * routine allows programmers to specify the actual runtime to be used
1908 * as the initial runtime is inherited by all future assemblies loaded
1909 * (since Mono does not support having more than one mscorlib runtime
1910 * loaded at once).
1911 *
1912 * The @runtime_version can be one of these strings: "v1.1.4322" for
1913 * the 1.1 runtime or "v2.0.50727" for the 2.0 runtime.
1914 *
1915 * Returns: the MonoDomain representing the domain where the assembly
1916 * was loaded.
1917 */
1918 MonoDomain *
1919 mono_jit_init_version (const char *domain_name, const char *runtime_version)
1920 {
1921 return mini_init (domain_name, runtime_version);
1922 }
1923
1924 void
1925 mono_jit_cleanup (MonoDomain *domain)
1926 {
1927 mini_cleanup (domain);
1928 }
1929
1930 void
1931 mono_jit_set_aot_only (gboolean val)
1932 {
1933 mono_aot_only = val;
1934 }
1935
1936 /**
1937 * mono_jit_set_trace_options:
1938 * @options: string representing the trace options
1939 *
1940 * Set the options of the tracing engine. This function can be called before initializing
1941 * the mono runtime. See the --trace mono(1) manpage for the options format.
1942 *
1943 * Returns: #TRUE if the options where parsed and set correctly, #FALSE otherwise.
1944 */
1945 gboolean
1946 mono_jit_set_trace_options (const char* options)
1947 {
1948 MonoTraceSpec *trace_opt = mono_trace_parse_options (options);
1949 if (trace_opt == NULL)
1950 return FALSE;
1951 mono_jit_trace_calls = trace_opt;
1952 return TRUE;
1953 }
1954
1955 /**
1956 * mono_set_signal_chaining:
1957 *
1958 * Enable/disable signal chaining. This should be called before mono_jit_init ().
1959 * If signal chaining is enabled, the runtime saves the original signal handlers before
1960 * installing its own handlers, and calls the original ones in the following cases:
1961 * - a SIGSEGV/SIGABRT signal received while executing native (i.e. not JITted) code.
1962 * - SIGPROF
1963 * - SIGFPE
1964 * - SIGQUIT
1965 * - SIGUSR2
1966 * Signal chaining only works on POSIX platforms.
1967 */
1968 void
1969 mono_set_signal_chaining (gboolean chain_signals)
1970 {
1971 mono_do_signal_chaining = chain_signals;
1972 }
Mirror of the official Mono project git repository