?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix on-demand initialization race conditions [mini] (#18161)
[mono-project.git] / mono / mini / aot-compiler.c
blob5ed944fc21dd42bfa1bca24f1f7e060c251dd68a
1 /**
2 * \file
3 * mono Ahead of Time compiler
4 *
5 * Author:
6 * Dietmar Maurer (dietmar@ximian.com)
7 * Zoltan Varga (vargaz@gmail.com)
8 * Johan Lorensson (lateralusx.github@gmail.com)
9 *
10 * (C) 2002 Ximian, Inc.
11 * Copyright 2003-2011 Novell, Inc
12 * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
13 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
14 */
15
16 #include "config.h"
17 #include <sys/types.h>
18 #ifdef HAVE_UNISTD_H
19 #include <unistd.h>
20 #endif
21 #ifdef HAVE_STDINT_H
22 #include <stdint.h>
23 #endif
24 #include <fcntl.h>
25 #include <ctype.h>
26 #include <string.h>
27 #ifndef HOST_WIN32
28 #include <sys/time.h>
29 #else
30 #include <winsock2.h>
31 #include <windows.h>
32 #endif
33
34 #include <errno.h>
35 #include <sys/stat.h>
36
37 #include <mono/metadata/abi-details.h>
38 #include <mono/metadata/tabledefs.h>
39 #include <mono/metadata/class.h>
40 #include <mono/metadata/object.h>
41 #include <mono/metadata/tokentype.h>
42 #include <mono/metadata/appdomain.h>
43 #include <mono/metadata/debug-helpers.h>
44 #include <mono/metadata/assembly.h>
45 #include <mono/metadata/metadata-internals.h>
46 #include <mono/metadata/reflection-internals.h>
47 #include <mono/metadata/marshal.h>
48 #include <mono/metadata/gc-internals.h>
49 #include <mono/metadata/mempool-internals.h>
50 #include <mono/metadata/mono-endian.h>
51 #include <mono/metadata/threads-types.h>
52 #include <mono/metadata/custom-attrs-internals.h>
53 #include <mono/utils/mono-logger-internals.h>
54 #include <mono/utils/mono-compiler.h>
55 #include <mono/utils/mono-time.h>
56 #include <mono/utils/mono-mmap.h>
57 #include <mono/utils/mono-rand.h>
58 #include <mono/utils/json.h>
59 #include <mono/utils/mono-threads-coop.h>
60 #include <mono/profiler/aot.h>
61 #include <mono/utils/w32api.h>
62
63 #include "aot-compiler.h"
64 #include "aot-runtime.h"
65 #include "seq-points.h"
66 #include "image-writer.h"
67 #include "dwarfwriter.h"
68 #include "mini-gc.h"
69 #include "mini-llvm.h"
70 #include "mini-runtime.h"
71
72 static MonoMethod*
73 try_get_method_nofail (MonoClass *klass, const char *method_name, int param_count, int flags)
74 {
75 MonoMethod *result;
76 ERROR_DECL (error);
77 result = mono_class_get_method_from_name_checked (klass, method_name, param_count, flags, error);
78 mono_error_assert_ok (error);
79 return result;
80 }
81
82 // FIXME Consolidate the multiple functions named get_method_nofail.
83 static MonoMethod*
84 get_method_nofail (MonoClass *klass, const char *method_name, int param_count, int flags)
85 {
86 MonoMethod *result = try_get_method_nofail (klass, method_name, param_count, flags);
87 g_assertf (result, "Expected to find method %s in klass %s", method_name, m_class_get_name (klass));
88 return result;
89 }
90
91 #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT)
92
93 // Use MSVC toolchain, Clang for MSVC using MSVC codegen and linker, when compiling for AMD64
94 // targeting WIN32 platforms running AOT compiler on WIN32 platform with VS installation.
95 #if defined(TARGET_AMD64) && defined(TARGET_WIN32) && defined(HOST_WIN32) && defined(_MSC_VER)
96 #define TARGET_X86_64_WIN32_MSVC
97 #endif
98
99 #if defined(TARGET_X86_64_WIN32_MSVC)
100 #define TARGET_WIN32_MSVC
101 #endif
102
103 // Emit native unwind info on Windows platforms (different from DWARF). Emitted unwind info
104 // works when using the MSVC toolchain using Clang for MSVC codegen and linker. Only supported when
105 // compiling for AMD64 (Windows x64 platforms).
106 #if defined(TARGET_WIN32_MSVC) && defined(MONO_ARCH_HAVE_UNWIND_TABLE)
107 #define EMIT_WIN32_UNWIND_INFO
108 #endif
109
110 #if defined(TARGET_ANDROID) || defined(__linux__)
111 #define RODATA_REL_SECT ".data.rel.ro"
112 #else
113 #define RODATA_REL_SECT ".text"
114 #endif
115
116 #if defined(__linux__)
117 #define RODATA_SECT ".rodata"
118 #elif defined(TARGET_MACH)
119 #define RODATA_SECT ".section __TEXT, __const"
120 #elif defined(TARGET_WIN32_MSVC)
121 #define RODATA_SECT ".rdata"
122 #else
123 #define RODATA_SECT ".text"
124 #endif
125
126 #define TV_DECLARE(name) gint64 name
127 #define TV_GETTIME(tv) tv = mono_100ns_ticks ()
128 #define TV_ELAPSED(start,end) (((end) - (start)) / 10)
129
130 #define ROUND_DOWN(VALUE,SIZE) ((VALUE) & ~((SIZE) - 1))
131
132 typedef struct {
133 char *name;
134 MonoImage *image;
135 } ImageProfileData;
136
137 typedef struct ClassProfileData ClassProfileData;
138
139 typedef struct {
140 int argc;
141 ClassProfileData **argv;
142 MonoGenericInst *inst;
143 } GInstProfileData;
144
145 struct ClassProfileData {
146 ImageProfileData *image;
147 char *ns, *name;
148 GInstProfileData *inst;
149 MonoClass *klass;
150 };
151
152 typedef struct {
153 ClassProfileData *klass;
154 int id;
155 char *name;
156 int param_count;
157 char *signature;
158 GInstProfileData *inst;
159 MonoMethod *method;
160 } MethodProfileData;
161
162 typedef struct {
163 GHashTable *images, *classes, *ginsts, *methods;
164 } ProfileData;
165
166 /* predefined values for static readonly fields without needed to run the .cctor */
167 typedef struct _ReadOnlyValue ReadOnlyValue;
168 struct _ReadOnlyValue {
169 ReadOnlyValue *next;
170 char *name;
171 int type; /* to be used later for typechecking to prevent user errors */
172 union {
173 guint8 i1;
174 guint16 i2;
175 guint32 i4;
176 guint64 i8;
177 gpointer ptr;
178 } value;
179 };
180 static ReadOnlyValue *readonly_values;
181
182 typedef struct MonoAotOptions {
183 char *outfile;
184 char *llvm_outfile;
185 char *data_outfile;
186 GList *profile_files;
187 gboolean save_temps;
188 gboolean write_symbols;
189 gboolean metadata_only;
190 gboolean bind_to_runtime_version;
191 MonoAotMode mode;
192 gboolean interp;
193 gboolean no_dlsym;
194 gboolean static_link;
195 gboolean asm_only;
196 gboolean asm_writer;
197 gboolean nodebug;
198 gboolean dwarf_debug;
199 gboolean soft_debug;
200 gboolean log_generics;
201 gboolean log_instances;
202 gboolean gen_msym_dir;
203 char *gen_msym_dir_path;
204 gboolean direct_pinvoke;
205 gboolean direct_icalls;
206 gboolean no_direct_calls;
207 gboolean use_trampolines_page;
208 gboolean no_instances;
209 // We are collecting inflated methods and emitting non-inflated
210 gboolean dedup;
211 // The name of the assembly for which the AOT module is going to have all deduped methods moved to.
212 // When set, we are emitting inflated methods only
213 char *dedup_include;
214 gboolean gnu_asm;
215 gboolean try_llvm;
216 gboolean llvm;
217 gboolean llvm_only;
218 gboolean llvm_disable_self_init;
219 int nthreads;
220 int ntrampolines;
221 int nrgctx_trampolines;
222 int nimt_trampolines;
223 int ngsharedvt_arg_trampolines;
224 int nftnptr_arg_trampolines;
225 int nrgctx_fetch_trampolines;
226 int nunbox_arbitrary_trampolines;
227 gboolean print_skipped_methods;
228 gboolean stats;
229 gboolean verbose;
230 gboolean deterministic;
231 char *tool_prefix;
232 char *ld_flags;
233 char *mtriple;
234 char *llvm_path;
235 char *temp_path;
236 char *instances_logfile_path;
237 char *logfile;
238 char *llvm_opts;
239 char *llvm_llc;
240 char *llvm_cpu_attr;
241 gboolean use_current_cpu;
242 gboolean dump_json;
243 gboolean profile_only;
244 gboolean no_opt;
245 char *clangxx;
246 char *depfile;
247 } MonoAotOptions;
248
249 typedef enum {
250 METHOD_CAT_NORMAL,
251 METHOD_CAT_GSHAREDVT,
252 METHOD_CAT_INST,
253 METHOD_CAT_WRAPPER,
254 METHOD_CAT_NUM
255 } MethodCategory;
256
257 typedef struct MonoAotStats {
258 int ccount, mcount, lmfcount, abscount, gcount, ocount, genericcount;
259 gint64 code_size, method_info_size, ex_info_size, unwind_info_size, got_size, class_info_size, got_info_size, plt_size, blob_size;
260 int methods_without_got_slots, direct_calls, all_calls, llvm_count;
261 int got_slots, offsets_size;
262 int method_categories [METHOD_CAT_NUM];
263 int got_slot_types [MONO_PATCH_INFO_NUM];
264 int got_slot_info_sizes [MONO_PATCH_INFO_NUM];
265 int jit_time, gen_time, link_time;
266 int method_ref_count, method_ref_size;
267 int class_ref_count, class_ref_size;
268 int ginst_count, ginst_size;
269 } MonoAotStats;
270
271 typedef struct GotInfo {
272 GHashTable *patch_to_got_offset;
273 GHashTable **patch_to_got_offset_by_type;
274 GPtrArray *got_patches;
275 } GotInfo;
276
277 #ifdef EMIT_WIN32_UNWIND_INFO
278 typedef struct _UnwindInfoSectionCacheItem {
279 char *xdata_section_label;
280 PUNWIND_INFO unwind_info;
281 gboolean xdata_section_emitted;
282 } UnwindInfoSectionCacheItem;
283 #endif
284
285 typedef struct MonoAotCompile {
286 MonoImage *image;
287 GPtrArray *methods;
288 GHashTable *method_indexes;
289 GHashTable *method_depth;
290 MonoCompile **cfgs;
291 int cfgs_size;
292 GHashTable **patch_to_plt_entry;
293 GHashTable *plt_offset_to_entry;
294 //GHashTable *patch_to_got_offset;
295 //GHashTable **patch_to_got_offset_by_type;
296 //GPtrArray *got_patches;
297 GotInfo got_info, llvm_got_info;
298 GHashTable *image_hash;
299 GHashTable *method_to_cfg;
300 GHashTable *token_info_hash;
301 GHashTable *method_to_pinvoke_import;
302 GHashTable *method_to_external_icall_symbol_name;
303 GPtrArray *extra_methods;
304 GPtrArray *image_table;
305 GPtrArray *globals;
306 GPtrArray *method_order;
307 GHashTable *dedup_stats;
308 GHashTable *dedup_cache;
309 gboolean dedup_cache_changed;
310 GHashTable *export_names;
311 /* Maps MonoClass* -> blob offset */
312 GHashTable *klass_blob_hash;
313 /* Maps MonoMethod* -> blob offset */
314 GHashTable *method_blob_hash;
315 /* Maps MonoGenericInst* -> blob offset */
316 GHashTable *ginst_blob_hash;
317 GHashTable *gsharedvt_in_signatures;
318 GHashTable *gsharedvt_out_signatures;
319 guint32 *plt_got_info_offsets;
320 guint32 got_offset, llvm_got_offset, plt_offset, plt_got_offset_base, nshared_got_entries;
321 /* Number of GOT entries reserved for trampolines */
322 guint32 num_trampoline_got_entries;
323 guint32 tramp_page_size;
324
325 guint32 table_offsets [MONO_AOT_TABLE_NUM];
326 guint32 num_trampolines [MONO_AOT_TRAMP_NUM];
327 guint32 trampoline_got_offset_base [MONO_AOT_TRAMP_NUM];
328 guint32 trampoline_size [MONO_AOT_TRAMP_NUM];
329 guint32 tramp_page_code_offsets [MONO_AOT_TRAMP_NUM];
330
331 MonoAotOptions aot_opts;
332 guint32 nmethods;
333 int call_table_entry_size;
334 guint32 nextra_methods;
335 guint32 opts;
336 guint32 simd_opts;
337 MonoMemPool *mempool;
338 MonoAotStats stats;
339 int method_index;
340 char *static_linking_symbol;
341 mono_mutex_t mutex;
342 gboolean gas_line_numbers;
343 /* Whenever to emit an object file directly from llc */
344 gboolean llvm_owriter;
345 gboolean llvm_owriter_supported;
346 MonoImageWriter *w;
347 MonoDwarfWriter *dwarf;
348 FILE *fp;
349 char *tmpbasename;
350 char *tmpfname;
351 char *temp_dir_to_delete;
352 char *llvm_sfile;
353 char *llvm_ofile;
354 GSList *cie_program;
355 GHashTable *unwind_info_offsets;
356 GPtrArray *unwind_ops;
357 guint32 unwind_info_offset;
358 char *global_prefix;
359 char *got_symbol;
360 char *llvm_got_symbol;
361 char *plt_symbol;
362 char *llvm_eh_frame_symbol;
363 GHashTable *method_label_hash;
364 const char *temp_prefix;
365 const char *user_symbol_prefix;
366 const char *llvm_label_prefix;
367 const char *inst_directive;
368 int align_pad_value;
369 guint32 label_generator;
370 gboolean llvm;
371 gboolean has_jitted_code;
372 gboolean is_full_aot;
373 gboolean dedup_collect_only;
374 MonoAotFileFlags flags;
375 MonoDynamicStream blob;
376 gboolean blob_closed;
377 GHashTable *typespec_classes;
378 GString *llc_args;
379 GString *as_args;
380 char *assembly_name_sym;
381 GHashTable *plt_entry_debug_sym_cache;
382 gboolean thumb_mixed, need_no_dead_strip, need_pt_gnu_stack;
383 GHashTable *ginst_hash;
384 GHashTable *dwarf_ln_filenames;
385 gboolean global_symbols;
386 int objc_selector_index, objc_selector_index_2;
387 GPtrArray *objc_selectors;
388 GHashTable *objc_selector_to_index;
389 GList *profile_data;
390 GHashTable *profile_methods;
391 #ifdef EMIT_WIN32_UNWIND_INFO
392 GList *unwind_info_section_cache;
393 #endif
394 FILE *logfile;
395 FILE *instances_logfile;
396 FILE *data_outfile;
397 int datafile_offset;
398 int gc_name_offset;
399 // In this mode, we are emitting dedupable methods that we encounter
400 gboolean dedup_emit_mode;
401 } MonoAotCompile;
402
403 typedef struct {
404 int plt_offset;
405 char *symbol, *llvm_symbol, *debug_sym;
406 MonoJumpInfo *ji;
407 gboolean jit_used, llvm_used;
408 } MonoPltEntry;
409
410 #define mono_acfg_lock(acfg) mono_os_mutex_lock (&((acfg)->mutex))
411 #define mono_acfg_unlock(acfg) mono_os_mutex_unlock (&((acfg)->mutex))
412
413 /* This points to the current acfg in LLVM mode */
414 static MonoAotCompile *llvm_acfg;
415 static MonoAotCompile *current_acfg;
416
417 /* Cache of decoded method external icall symbol names. */
418 /* Owned by acfg, but kept in this static as well since it is */
419 /* accessed by code paths not having access to acfg. */
420 static GHashTable *method_to_external_icall_symbol_name;
421
422 // This, instead of an array of pointers, to optimize away a pointer and a relocation per string.
423 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
424 #define MSGSTRFIELD1(line) str##line
425 static const struct msgstr_t {
426 #define PATCH_INFO(a,b) char MSGSTRFIELD(__LINE__) [sizeof (b)];
427 #include "patch-info.h"
428 #undef PATCH_INFO
429 } opstr = {
430 #define PATCH_INFO(a,b) b,
431 #include "patch-info.h"
432 #undef PATCH_INFO
433 };
434 static const gint16 opidx [] = {
435 #define PATCH_INFO(a,b) offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
436 #include "patch-info.h"
437 #undef PATCH_INFO
438 };
439
440 static G_GNUC_UNUSED const char*
441 get_patch_name (int info)
442 {
443 return (const char*)&opstr + opidx [info];
444 }
445
446 static int
447 emit_aot_image (MonoAotCompile *acfg);
448
449 static void
450 mono_flush_method_cache (MonoAotCompile *acfg);
451
452 static void
453 mono_read_method_cache (MonoAotCompile *acfg);
454
455 static guint32
456 get_unwind_info_offset (MonoAotCompile *acfg, guint8 *encoded, guint32 encoded_len);
457
458 static char*
459 get_plt_entry_debug_sym (MonoAotCompile *acfg, MonoJumpInfo *ji, GHashTable *cache);
460
461 static void
462 add_gsharedvt_wrappers (MonoAotCompile *acfg, MonoMethodSignature *sig, gboolean gsharedvt_in, gboolean gsharedvt_out, gboolean interp_in);
463
464 static void
465 add_profile_instances (MonoAotCompile *acfg, ProfileData *data);
466
467 static gboolean
468 ignore_cfg (MonoCompile *cfg)
469 {
470 return !cfg || cfg->skip;
471 }
472
473 static void
474 aot_printf (MonoAotCompile *acfg, const gchar *format, ...)
475 {
476 FILE *output;
477 va_list args;
478
479 if (acfg->logfile)
480 output = acfg->logfile;
481 else
482 output = stdout;
483
484 va_start (args, format);
485 vfprintf (output, format, args);
486 va_end (args);
487 }
488
489 static void
490 aot_printerrf (MonoAotCompile *acfg, const gchar *format, ...)
491 {
492 FILE *output;
493 va_list args;
494
495 if (acfg->logfile)
496 output = acfg->logfile;
497 else
498 output = stderr;
499
500 va_start (args, format);
501 vfprintf (output, format, args);
502 va_end (args);
503 }
504
505 static void
506 report_loader_error (MonoAotCompile *acfg, MonoError *error, gboolean fatal, const char *format, ...)
507 {
508 FILE *output;
509 va_list args;
510
511 if (is_ok (error))
512 return;
513
514 if (acfg->logfile)
515 output = acfg->logfile;
516 else
517 output = stderr;
518
519 va_start (args, format);
520 vfprintf (output, format, args);
521 va_end (args);
522 mono_error_cleanup (error);
523
524 if (acfg->is_full_aot && fatal) {
525 fprintf (output, "FullAOT cannot continue if there are loader errors.\n");
526 exit (1);
527 }
528 }
529
530 /* Wrappers around the image writer functions */
531
532 #define MAX_SYMBOL_SIZE 256
533
534 static const char *
535 mangle_symbol (const char * symbol, char * mangled_symbol, gsize length)
536 {
537 gsize needed_size = length;
538
539 g_assert (NULL != symbol);
540 g_assert (NULL != mangled_symbol);
541 g_assert (0 != length);
542
543 #if defined(TARGET_WIN32) && defined(TARGET_X86)
544 if (symbol && '_' != symbol [0]) {
545 needed_size = g_snprintf (mangled_symbol, length, "_%s", symbol);
546 } else {
547 needed_size = g_snprintf (mangled_symbol, length, "%s", symbol);
548 }
549 #else
550 needed_size = g_snprintf (mangled_symbol, length, "%s", symbol);
551 #endif
552
553 g_assert (0 <= needed_size && needed_size < length);
554 return mangled_symbol;
555 }
556
557 static char *
558 mangle_symbol_alloc (const char * symbol)
559 {
560 g_assert (NULL != symbol);
561
562 #if defined(TARGET_WIN32) && defined(TARGET_X86)
563 if (symbol && '_' != symbol [0]) {
564 return g_strdup_printf ("_%s", symbol);
565 }
566 else {
567 return g_strdup_printf ("%s", symbol);
568 }
569 #else
570 return g_strdup_printf ("%s", symbol);
571 #endif
572 }
573
574 static void
575 emit_section_change (MonoAotCompile *acfg, const char *section_name, int subsection_index)
576 {
577 mono_img_writer_emit_section_change (acfg->w, section_name, subsection_index);
578 }
579
580 #if defined(TARGET_WIN32) && defined(TARGET_X86)
581
582 static void
583 emit_local_symbol (MonoAotCompile *acfg, const char *name, const char *end_label, gboolean func)
584 {
585 const char * mangled_symbol_name = name;
586 char * mangled_symbol_name_alloc = NULL;
587
588 if (TRUE == func) {
589 mangled_symbol_name_alloc = mangle_symbol_alloc (name);
590 mangled_symbol_name = mangled_symbol_name_alloc;
591 }
592
593 if (name != mangled_symbol_name && 0 != g_strcasecmp (name, mangled_symbol_name)) {
594 mono_img_writer_emit_label (acfg->w, mangled_symbol_name);
595 }
596 mono_img_writer_emit_local_symbol (acfg->w, mangled_symbol_name, end_label, func);
597
598 if (NULL != mangled_symbol_name_alloc) {
599 g_free (mangled_symbol_name_alloc);
600 }
601 }
602
603 #else
604
605 static void
606 emit_local_symbol (MonoAotCompile *acfg, const char *name, const char *end_label, gboolean func)
607 {
608 mono_img_writer_emit_local_symbol (acfg->w, name, end_label, func);
609 }
610
611 #endif
612
613 static void
614 emit_label (MonoAotCompile *acfg, const char *name)
615 {
616 mono_img_writer_emit_label (acfg->w, name);
617 }
618
619 static void
620 emit_bytes (MonoAotCompile *acfg, const guint8* buf, int size)
621 {
622 mono_img_writer_emit_bytes (acfg->w, buf, size);
623 }
624
625 static void
626 emit_string (MonoAotCompile *acfg, const char *value)
627 {
628 mono_img_writer_emit_string (acfg->w, value);
629 }
630
631 static void
632 emit_line (MonoAotCompile *acfg)
633 {
634 mono_img_writer_emit_line (acfg->w);
635 }
636
637 static void
638 emit_alignment (MonoAotCompile *acfg, int size)
639 {
640 mono_img_writer_emit_alignment (acfg->w, size);
641 }
642
643 static void
644 emit_alignment_code (MonoAotCompile *acfg, int size)
645 {
646 if (acfg->align_pad_value)
647 mono_img_writer_emit_alignment_fill (acfg->w, size, acfg->align_pad_value);
648 else
649 mono_img_writer_emit_alignment (acfg->w, size);
650 }
651
652 static void
653 emit_padding (MonoAotCompile *acfg, int size)
654 {
655 int i;
656 guint8 buf [16];
657
658 if (acfg->align_pad_value) {
659 for (i = 0; i < 16; ++i)
660 buf [i] = acfg->align_pad_value;
661 } else {
662 memset (buf, 0, sizeof (buf));
663 }
664
665 for (i = 0; i < size; i += 16) {
666 if (size - i < 16)
667 emit_bytes (acfg, buf, size - i);
668 else
669 emit_bytes (acfg, buf, 16);
670 }
671 }
672
673 static void
674 emit_pointer (MonoAotCompile *acfg, const char *target)
675 {
676 mono_img_writer_emit_pointer (acfg->w, target);
677 }
678
679 static void
680 emit_pointer_2 (MonoAotCompile *acfg, const char *prefix, const char *target)
681 {
682 if (prefix [0] != '\0') {
683 char *s = g_strdup_printf ("%s%s", prefix, target);
684 mono_img_writer_emit_pointer (acfg->w, s);
685 g_free (s);
686 } else {
687 mono_img_writer_emit_pointer (acfg->w, target);
688 }
689 }
690
691 static void
692 emit_int16 (MonoAotCompile *acfg, int value)
693 {
694 mono_img_writer_emit_int16 (acfg->w, value);
695 }
696
697 static void
698 emit_int32 (MonoAotCompile *acfg, int value)
699 {
700 mono_img_writer_emit_int32 (acfg->w, value);
701 }
702
703 static void
704 emit_symbol_diff (MonoAotCompile *acfg, const char *end, const char* start, int offset)
705 {
706 mono_img_writer_emit_symbol_diff (acfg->w, end, start, offset);
707 }
708
709 static void
710 emit_zero_bytes (MonoAotCompile *acfg, int num)
711 {
712 mono_img_writer_emit_zero_bytes (acfg->w, num);
713 }
714
715 static void
716 emit_byte (MonoAotCompile *acfg, guint8 val)
717 {
718 mono_img_writer_emit_byte (acfg->w, val);
719 }
720
721 #if defined(TARGET_WIN32) && defined(TARGET_X86)
722
723 static G_GNUC_UNUSED void
724 emit_global_inner (MonoAotCompile *acfg, const char *name, gboolean func)
725 {
726 const char * mangled_symbol_name = name;
727 char * mangled_symbol_name_alloc = NULL;
728
729 mangled_symbol_name_alloc = mangle_symbol_alloc (name);
730 mangled_symbol_name = mangled_symbol_name_alloc;
731
732 if (0 != g_strcasecmp (name, mangled_symbol_name)) {
733 mono_img_writer_emit_label (acfg->w, mangled_symbol_name);
734 }
735 mono_img_writer_emit_global (acfg->w, mangled_symbol_name, func);
736
737 if (NULL != mangled_symbol_name_alloc) {
738 g_free (mangled_symbol_name_alloc);
739 }
740 }
741
742 #else
743
744 static G_GNUC_UNUSED void
745 emit_global_inner (MonoAotCompile *acfg, const char *name, gboolean func)
746 {
747 mono_img_writer_emit_global (acfg->w, name, func);
748 }
749
750 #endif
751
752 static gboolean
753 link_shared_library (MonoAotCompile *acfg)
754 {
755 return !acfg->aot_opts.static_link && !acfg->aot_opts.asm_only;
756 }
757
758 static gboolean
759 add_to_global_symbol_table (MonoAotCompile *acfg)
760 {
761 #ifdef TARGET_WIN32_MSVC
762 return acfg->aot_opts.no_dlsym || link_shared_library (acfg);
763 #else
764 return acfg->aot_opts.no_dlsym;
765 #endif
766 }
767
768 static void
769 emit_global (MonoAotCompile *acfg, const char *name, gboolean func)
770 {
771 if (add_to_global_symbol_table (acfg))
772 g_ptr_array_add (acfg->globals, g_strdup (name));
773
774 if (acfg->aot_opts.no_dlsym) {
775 mono_img_writer_emit_local_symbol (acfg->w, name, NULL, func);
776 } else {
777 emit_global_inner (acfg, name, func);
778 }
779 }
780
781 static void
782 emit_symbol_size (MonoAotCompile *acfg, const char *name, const char *end_label)
783 {
784 mono_img_writer_emit_symbol_size (acfg->w, name, end_label);
785 }
786
787 /* Emit a symbol which is referenced by the MonoAotFileInfo structure */
788 static void
789 emit_info_symbol (MonoAotCompile *acfg, const char *name, gboolean func)
790 {
791 char symbol [MAX_SYMBOL_SIZE];
792
793 if (acfg->llvm) {
794 emit_label (acfg, name);
795 /* LLVM generated code references this */
796 sprintf (symbol, "%s%s%s", acfg->user_symbol_prefix, acfg->global_prefix, name);
797 emit_label (acfg, symbol);
798
799 #ifndef TARGET_WIN32_MSVC
800 emit_global_inner (acfg, symbol, FALSE);
801 #else
802 emit_global_inner (acfg, symbol, func);
803 #endif
804 } else {
805 emit_label (acfg, name);
806 }
807 }
808
809 static void
810 emit_string_symbol (MonoAotCompile *acfg, const char *name, const char *value)
811 {
812 if (acfg->llvm) {
813 mono_llvm_emit_aot_data (name, (guint8*)value, strlen (value) + 1);
814 return;
815 }
816
817 mono_img_writer_emit_section_change (acfg->w, RODATA_SECT, 1);
818 #ifdef TARGET_MACH
819 /* On apple, all symbols need to be aligned to avoid warnings from ld */
820 emit_alignment (acfg, 4);
821 #endif
822 mono_img_writer_emit_label (acfg->w, name);
823 mono_img_writer_emit_string (acfg->w, value);
824 }
825
826 static G_GNUC_UNUSED void
827 emit_uleb128 (MonoAotCompile *acfg, guint32 value)
828 {
829 do {
830 guint8 b = value & 0x7f;
831 value >>= 7;
832 if (value != 0) /* more bytes to come */
833 b |= 0x80;
834 emit_byte (acfg, b);
835 } while (value);
836 }
837
838 static G_GNUC_UNUSED void
839 emit_sleb128 (MonoAotCompile *acfg, gint64 value)
840 {
841 gboolean more = 1;
842 gboolean negative = (value < 0);
843 guint32 size = 64;
844 guint8 byte;
845
846 while (more) {
847 byte = value & 0x7f;
848 value >>= 7;
849 /* the following is unnecessary if the
850 * implementation of >>= uses an arithmetic rather
851 * than logical shift for a signed left operand
852 */
853 if (negative)
854 /* sign extend */
855 value |= - ((gint64)1 <<(size - 7));
856 /* sign bit of byte is second high order bit (0x40) */
857 if ((value == 0 && !(byte & 0x40)) ||
858 (value == -1 && (byte & 0x40)))
859 more = 0;
860 else
861 byte |= 0x80;
862 emit_byte (acfg, byte);
863 }
864 }
865
866 static G_GNUC_UNUSED void
867 encode_uleb128 (guint32 value, guint8 *buf, guint8 **endbuf)
868 {
869 guint8 *p = buf;
870
871 do {
872 guint8 b = value & 0x7f;
873 value >>= 7;
874 if (value != 0) /* more bytes to come */
875 b |= 0x80;
876 *p ++ = b;
877 } while (value);
878
879 *endbuf = p;
880 }
881
882 static G_GNUC_UNUSED void
883 encode_sleb128 (gint32 value, guint8 *buf, guint8 **endbuf)
884 {
885 gboolean more = 1;
886 gboolean negative = (value < 0);
887 guint32 size = 32;
888 guint8 byte;
889 guint8 *p = buf;
890
891 while (more) {
892 byte = value & 0x7f;
893 value >>= 7;
894 /* the following is unnecessary if the
895 * implementation of >>= uses an arithmetic rather
896 * than logical shift for a signed left operand
897 */
898 if (negative)
899 /* sign extend */
900 value |= - (1 <<(size - 7));
901 /* sign bit of byte is second high order bit (0x40) */
902 if ((value == 0 && !(byte & 0x40)) ||
903 (value == -1 && (byte & 0x40)))
904 more = 0;
905 else
906 byte |= 0x80;
907 *p ++= byte;
908 }
909
910 *endbuf = p;
911 }
912
913 static void
914 encode_int (gint32 val, guint8 *buf, guint8 **endbuf)
915 {
916 // FIXME: Big-endian
917 buf [0] = (val >> 0) & 0xff;
918 buf [1] = (val >> 8) & 0xff;
919 buf [2] = (val >> 16) & 0xff;
920 buf [3] = (val >> 24) & 0xff;
921
922 *endbuf = buf + 4;
923 }
924
925 static void
926 encode_int16 (guint16 val, guint8 *buf, guint8 **endbuf)
927 {
928 buf [0] = (val >> 0) & 0xff;
929 buf [1] = (val >> 8) & 0xff;
930
931 *endbuf = buf + 2;
932 }
933
934 static void
935 encode_string (const char *s, guint8 *buf, guint8 **endbuf)
936 {
937 int len = strlen (s);
938
939 memcpy (buf, s, len + 1);
940 *endbuf = buf + len + 1;
941 }
942
943 static void
944 emit_unset_mode (MonoAotCompile *acfg)
945 {
946 mono_img_writer_emit_unset_mode (acfg->w);
947 }
948
949 static G_GNUC_UNUSED void
950 emit_set_thumb_mode (MonoAotCompile *acfg)
951 {
952 emit_unset_mode (acfg);
953 fprintf (acfg->fp, ".code 16\n");
954 }
955
956 static G_GNUC_UNUSED void
957 emit_set_arm_mode (MonoAotCompile *acfg)
958 {
959 emit_unset_mode (acfg);
960 fprintf (acfg->fp, ".code 32\n");
961 }
962
963 static void
964 emit_code_bytes (MonoAotCompile *acfg, const guint8* buf, int size)
965 {
966 #ifdef TARGET_ARM64
967 int i;
968
969 g_assert (size % 4 == 0);
970 emit_unset_mode (acfg);
971 for (i = 0; i < size; i += 4)
972 fprintf (acfg->fp, "%s 0x%x\n", acfg->inst_directive, *(guint32*)(buf + i));
973 #else
974 emit_bytes (acfg, buf, size);
975 #endif
976 }
977
978 /* ARCHITECTURE SPECIFIC CODE */
979
980 #if defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_ARM) || defined(TARGET_POWERPC) || defined(TARGET_ARM64) || defined (TARGET_RISCV)
981 #define EMIT_DWARF_INFO 1
982 #endif
983
984 #ifdef TARGET_WIN32_MSVC
985 #undef EMIT_DWARF_INFO
986 #define EMIT_WIN32_CODEVIEW_INFO
987 #endif
988
989 #ifdef EMIT_WIN32_UNWIND_INFO
990 static UnwindInfoSectionCacheItem *
991 get_cached_unwind_info_section_item_win32 (MonoAotCompile *acfg, const char *function_start, const char *function_end, GSList *unwind_ops);
992
993 static void
994 free_unwind_info_section_cache_win32 (MonoAotCompile *acfg);
995
996 static void
997 emit_unwind_info_data_win32 (MonoAotCompile *acfg, PUNWIND_INFO unwind_info);
998
999 static void
1000 emit_unwind_info_sections_win32 (MonoAotCompile *acfg, const char *function_start, const char *function_end, GSList *unwind_ops);
1001 #endif
1002
1003 static void
1004 arch_free_unwind_info_section_cache (MonoAotCompile *acfg)
1005 {
1006 #ifdef EMIT_WIN32_UNWIND_INFO
1007 free_unwind_info_section_cache_win32 (acfg);
1008 #endif
1009 }
1010
1011 static void
1012 arch_emit_unwind_info_sections (MonoAotCompile *acfg, const char *function_start, const char *function_end, GSList *unwind_ops)
1013 {
1014 #ifdef EMIT_WIN32_UNWIND_INFO
1015 gboolean own_unwind_ops = FALSE;
1016 if (!unwind_ops) {
1017 unwind_ops = mono_unwind_get_cie_program ();
1018 own_unwind_ops = TRUE;
1019 }
1020
1021 emit_unwind_info_sections_win32 (acfg, function_start, function_end, unwind_ops);
1022
1023 if (own_unwind_ops)
1024 mono_free_unwind_info (unwind_ops);
1025 #endif
1026 }
1027
1028 #if defined(TARGET_ARM)
1029 #define AOT_FUNC_ALIGNMENT 4
1030 #else
1031 #define AOT_FUNC_ALIGNMENT 16
1032 #endif
1033
1034 #if defined(TARGET_POWERPC64) && !defined(MONO_ARCH_ILP32)
1035 #define PPC_LD_OP "ld"
1036 #define PPC_LDX_OP "ldx"
1037 #else
1038 #define PPC_LD_OP "lwz"
1039 #define PPC_LDX_OP "lwzx"
1040 #endif
1041
1042 #ifdef TARGET_X86_64_WIN32_MSVC
1043 #define AOT_TARGET_STR "AMD64 (WIN32) (MSVC codegen)"
1044 #elif TARGET_AMD64
1045 #define AOT_TARGET_STR "AMD64"
1046 #endif
1047
1048 #ifdef TARGET_ARM
1049 #ifdef TARGET_MACH
1050 #define AOT_TARGET_STR "ARM (MACH)"
1051 #else
1052 #define AOT_TARGET_STR "ARM (!MACH)"
1053 #endif
1054 #endif
1055
1056 #ifdef TARGET_ARM64
1057 #ifdef TARGET_MACH
1058 #define AOT_TARGET_STR "ARM64 (MACH)"
1059 #else
1060 #define AOT_TARGET_STR "ARM64 (!MACH)"
1061 #endif
1062 #endif
1063
1064 #ifdef TARGET_POWERPC64
1065 #ifdef MONO_ARCH_ILP32
1066 #define AOT_TARGET_STR "POWERPC64 (mono ilp32)"
1067 #else
1068 #define AOT_TARGET_STR "POWERPC64 (!mono ilp32)"
1069 #endif
1070 #else
1071 #ifdef TARGET_POWERPC
1072 #ifdef MONO_ARCH_ILP32
1073 #define AOT_TARGET_STR "POWERPC (mono ilp32)"
1074 #else
1075 #define AOT_TARGET_STR "POWERPC (!mono ilp32)"
1076 #endif
1077 #endif
1078 #endif
1079
1080 #ifdef TARGET_RISCV32
1081 #define AOT_TARGET_STR "RISCV32"
1082 #endif
1083
1084 #ifdef TARGET_RISCV64
1085 #define AOT_TARGET_STR "RISCV64"
1086 #endif
1087
1088 #ifdef TARGET_X86
1089 #ifdef TARGET_WIN32
1090 #define AOT_TARGET_STR "X86 (WIN32)"
1091 #else
1092 #define AOT_TARGET_STR "X86"
1093 #endif
1094 #endif
1095
1096 #ifndef AOT_TARGET_STR
1097 #define AOT_TARGET_STR ""
1098 #endif
1099
1100 static void
1101 arch_init (MonoAotCompile *acfg)
1102 {
1103 acfg->llc_args = g_string_new ("");
1104 acfg->as_args = g_string_new ("");
1105 acfg->llvm_owriter_supported = TRUE;
1106
1107 /*
1108 * The prefix LLVM likes to put in front of symbol names on darwin.
1109 * The mach-os specs require this for globals, but LLVM puts them in front of all
1110 * symbols. We need to handle this, since we need to refer to LLVM generated
1111 * symbols.
1112 */
1113 acfg->llvm_label_prefix = "";
1114 acfg->user_symbol_prefix = "";
1115
1116 #if TARGET_X86 || TARGET_AMD64
1117 const gboolean has_custom_args = !!acfg->aot_opts.llvm_llc || acfg->aot_opts.use_current_cpu;
1118 #endif
1119
1120 #if defined(TARGET_X86)
1121 g_string_append_printf (acfg->llc_args, " -march=x86 %s", has_custom_args ? "" : "-mcpu=generic");
1122 #endif
1123
1124 #if defined(TARGET_AMD64)
1125 g_string_append_printf (acfg->llc_args, " -march=x86-64 %s", has_custom_args ? "" : "-mcpu=generic");
1126 /* NOP */
1127 acfg->align_pad_value = 0x90;
1128 #endif
1129 g_string_append (acfg->llc_args, " -enable-implicit-null-checks -disable-fault-maps");
1130
1131 if (mono_use_fast_math) {
1132 // same parameters are passed to opt and LLVM JIT
1133 g_string_append (acfg->llc_args, " -fp-contract=fast -enable-no-infs-fp-math -enable-no-nans-fp-math -enable-no-signed-zeros-fp-math -enable-no-trapping-fp-math -enable-unsafe-fp-math");
1134 }
1135
1136 #ifdef TARGET_ARM
1137 if (acfg->aot_opts.mtriple && strstr (acfg->aot_opts.mtriple, "darwin")) {
1138 g_string_append (acfg->llc_args, "-mattr=+v6");
1139 } else {
1140 if (!acfg->aot_opts.mtriple) {
1141 g_string_append (acfg->llc_args, " -march=arm");
1142 } else {
1143 /* arch will be defined via mtriple, e.g. armv7s-ios or thumb. */
1144
1145 if (strstr (acfg->aot_opts.mtriple, "ios")) {
1146 g_string_append (acfg->llc_args, " -mattr=+v7");
1147 g_string_append (acfg->llc_args, " -exception-model=dwarf -disable-fp-elim");
1148 }
1149 }
1150
1151 #if defined(ARM_FPU_VFP_HARD)
1152 g_string_append (acfg->llc_args, " -mattr=+vfp2,-neon,+d16 -float-abi=hard");
1153 g_string_append (acfg->as_args, " -mfpu=vfp3");
1154 #elif defined(ARM_FPU_VFP)
1155 g_string_append (acfg->llc_args, " -mattr=+vfp2,-neon,+d16");
1156 g_string_append (acfg->as_args, " -mfpu=vfp3");
1157 #else
1158 g_string_append (acfg->llc_args, " -mattr=+soft-float");
1159 #endif
1160 }
1161 if (acfg->aot_opts.mtriple && strstr (acfg->aot_opts.mtriple, "thumb"))
1162 acfg->thumb_mixed = TRUE;
1163
1164 if (acfg->aot_opts.mtriple)
1165 mono_arch_set_target (acfg->aot_opts.mtriple);
1166 #endif
1167
1168 #ifdef TARGET_ARM64
1169 g_string_append (acfg->llc_args, " -march=aarch64");
1170 acfg->inst_directive = ".inst";
1171 if (acfg->aot_opts.mtriple)
1172 mono_arch_set_target (acfg->aot_opts.mtriple);
1173 #endif
1174
1175 #ifdef TARGET_MACH
1176 acfg->user_symbol_prefix = "_";
1177 acfg->llvm_label_prefix = "_";
1178 acfg->inst_directive = ".word";
1179 acfg->need_no_dead_strip = TRUE;
1180 acfg->aot_opts.gnu_asm = TRUE;
1181 #endif
1182
1183 #if defined(__linux__) && !defined(TARGET_ARM)
1184 acfg->need_pt_gnu_stack = TRUE;
1185 #endif
1186
1187 #ifdef TARGET_RISCV
1188 if (acfg->aot_opts.mtriple)
1189 mono_arch_set_target (acfg->aot_opts.mtriple);
1190
1191 #ifdef TARGET_RISCV64
1192
1193 g_string_append (acfg->as_args, " -march=rv64i ");
1194 #ifdef RISCV_FPABI_DOUBLE
1195 g_string_append (acfg->as_args, " -mabi=lp64d");
1196 #else
1197 g_string_append (acfg->as_args, " -mabi=lp64");
1198 #endif
1199
1200 #else
1201
1202 g_string_append (acfg->as_args, " -march=rv32i ");
1203 #ifdef RISCV_FPABI_DOUBLE
1204 g_string_append (acfg->as_args, " -mabi=ilp32d ");
1205 #else
1206 g_string_append (acfg->as_args, " -mabi=ilp32 ");
1207 #endif
1208
1209 #endif
1210
1211 #endif
1212
1213 #ifdef MONOTOUCH
1214 acfg->global_symbols = TRUE;
1215 #endif
1216
1217 #ifdef TARGET_ANDROID
1218 acfg->llvm_owriter_supported = FALSE;
1219 #endif
1220 }
1221
1222 #ifdef TARGET_ARM64
1223
1224
1225 /* Load the contents of GOT_SLOT into dreg, clobbering ip0 */
1226 /* Must emit 12 bytes of instructions */
1227 static void
1228 arm64_emit_load_got_slot (MonoAotCompile *acfg, int dreg, int got_slot)
1229 {
1230 int offset;
1231
1232 g_assert (acfg->fp);
1233 emit_unset_mode (acfg);
1234 /* r16==ip0 */
1235 offset = (int)(got_slot * TARGET_SIZEOF_VOID_P);
1236 #ifdef TARGET_MACH
1237 /* clang's integrated assembler */
1238 fprintf (acfg->fp, "adrp x16, %s@PAGE+%d\n", acfg->got_symbol, offset & 0xfffff000);
1239 #ifdef MONO_ARCH_ILP32
1240 fprintf (acfg->fp, "add x16, x16, %s@PAGEOFF+%d\n", acfg->got_symbol, offset & 0xfff);
1241 fprintf (acfg->fp, "ldr w%d, [x16, #%d]\n", dreg, 0);
1242 #else
1243 fprintf (acfg->fp, "add x16, x16, %s@PAGEOFF\n", acfg->got_symbol);
1244 fprintf (acfg->fp, "ldr x%d, [x16, #%d]\n", dreg, offset & 0xfff);
1245 #endif
1246 #else
1247 /* Linux GAS */
1248 fprintf (acfg->fp, "adrp x16, %s+%d\n", acfg->got_symbol, offset & 0xfffff000);
1249 fprintf (acfg->fp, "add x16, x16, :lo12:%s\n", acfg->got_symbol);
1250 fprintf (acfg->fp, "ldr x%d, [x16, %d]\n", dreg, offset & 0xfff);
1251 #endif
1252 }
1253
1254 static void
1255 arm64_emit_objc_selector_ref (MonoAotCompile *acfg, guint8 *code, int index, int *code_size)
1256 {
1257 int reg;
1258
1259 g_assert (acfg->fp);
1260 emit_unset_mode (acfg);
1261
1262 /* ldr rt, target */
1263 reg = arm_get_ldr_lit_reg (code);
1264
1265 fprintf (acfg->fp, "adrp x%d, L_OBJC_SELECTOR_REFERENCES_%d@PAGE\n", reg, index);
1266 fprintf (acfg->fp, "add x%d, x%d, L_OBJC_SELECTOR_REFERENCES_%d@PAGEOFF\n", reg, reg, index);
1267 fprintf (acfg->fp, "ldr x%d, [x%d]\n", reg, reg);
1268
1269 *code_size = 12;
1270 }
1271
1272 static void
1273 arm64_emit_direct_call (MonoAotCompile *acfg, const char *target, gboolean external, gboolean thumb, MonoJumpInfo *ji, int *call_size)
1274 {
1275 g_assert (acfg->fp);
1276 emit_unset_mode (acfg);
1277 if (ji && ji->relocation == MONO_R_ARM64_B) {
1278 fprintf (acfg->fp, "b %s\n", target);
1279 } else {
1280 if (ji)
1281 g_assert (ji->relocation == MONO_R_ARM64_BL);
1282 fprintf (acfg->fp, "bl %s\n", target);
1283 }
1284 *call_size = 4;
1285 }
1286
1287 static void
1288 arm64_emit_got_access (MonoAotCompile *acfg, guint8 *code, int got_slot, int *code_size)
1289 {
1290 int reg;
1291
1292 /* ldr rt, target */
1293 reg = arm_get_ldr_lit_reg (code);
1294 arm64_emit_load_got_slot (acfg, reg, got_slot);
1295 *code_size = 12;
1296 }
1297
1298 static void
1299 arm64_emit_plt_entry (MonoAotCompile *acfg, const char *got_symbol, int offset, int info_offset)
1300 {
1301 arm64_emit_load_got_slot (acfg, ARMREG_R16, offset / sizeof (target_mgreg_t));
1302 fprintf (acfg->fp, "br x16\n");
1303 /* Used by mono_aot_get_plt_info_offset () */
1304 fprintf (acfg->fp, "%s %d\n", acfg->inst_directive, info_offset);
1305 }
1306
1307 static void
1308 arm64_emit_tramp_page_common_code (MonoAotCompile *acfg, int pagesize, int arg_reg, int *size)
1309 {
1310 guint8 buf [256];
1311 guint8 *code;
1312 int imm;
1313
1314 /* The common code */
1315 code = buf;
1316 imm = pagesize;
1317 /* The trampoline address is in IP0 */
1318 arm_movzx (code, ARMREG_IP1, imm & 0xffff, 0);
1319 arm_movkx (code, ARMREG_IP1, (imm >> 16) & 0xffff, 16);
1320 /* Compute the data slot address */
1321 arm_subx (code, ARMREG_IP0, ARMREG_IP0, ARMREG_IP1);
1322 /* Trampoline argument */
1323 arm_ldrp (code, arg_reg, ARMREG_IP0, 0);
1324 /* Address */
1325 arm_ldrp (code, ARMREG_IP0, ARMREG_IP0, TARGET_SIZEOF_VOID_P);
1326 arm_brx (code, ARMREG_IP0);
1327
1328 /* Emit it */
1329 emit_code_bytes (acfg, buf, code - buf);
1330
1331 *size = code - buf;
1332 }
1333
1334 static void
1335 arm64_emit_tramp_page_specific_code (MonoAotCompile *acfg, int pagesize, int common_tramp_size, int specific_tramp_size)
1336 {
1337 guint8 buf [256];
1338 guint8 *code;
1339 int i, count;
1340
1341 count = (pagesize - common_tramp_size) / specific_tramp_size;
1342 for (i = 0; i < count; ++i) {
1343 code = buf;
1344 arm_adrx (code, ARMREG_IP0, code);
1345 /* Branch to the generic code */
1346 arm_b (code, code - 4 - (i * specific_tramp_size) - common_tramp_size);
1347 #ifndef MONO_ARCH_ILP32
1348 /* This has to be 2 pointers long */
1349 arm_nop (code);
1350 arm_nop (code);
1351 #endif
1352 g_assert (code - buf == specific_tramp_size);
1353 emit_code_bytes (acfg, buf, code - buf);
1354 }
1355 }
1356
1357 static void
1358 arm64_emit_specific_trampoline_pages (MonoAotCompile *acfg)
1359 {
1360 guint8 buf [128];
1361 guint8 *code;
1362 guint8 *labels [16];
1363 int common_tramp_size;
1364 int specific_tramp_size = 2 * TARGET_SIZEOF_VOID_P;
1365 int imm, pagesize;
1366 char symbol [128];
1367
1368 if (!acfg->aot_opts.use_trampolines_page)
1369 return;
1370
1371 #ifdef TARGET_MACH
1372 /* Have to match the target pagesize */
1373 pagesize = 16384;
1374 #else
1375 pagesize = mono_pagesize ();
1376 #endif
1377 acfg->tramp_page_size = pagesize;
1378
1379 /* The specific trampolines */
1380 sprintf (symbol, "%sspecific_trampolines_page", acfg->user_symbol_prefix);
1381 emit_alignment (acfg, pagesize);
1382 emit_global (acfg, symbol, TRUE);
1383 emit_label (acfg, symbol);
1384
1385 /* The common code */
1386 arm64_emit_tramp_page_common_code (acfg, pagesize, ARMREG_IP1, &common_tramp_size);
1387 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_SPECIFIC] = common_tramp_size;
1388
1389 arm64_emit_tramp_page_specific_code (acfg, pagesize, common_tramp_size, specific_tramp_size);
1390
1391 /* The rgctx trampolines */
1392 /* These are the same as the specific trampolines, but they load the argument into MONO_ARCH_RGCTX_REG */
1393 sprintf (symbol, "%srgctx_trampolines_page", acfg->user_symbol_prefix);
1394 emit_alignment (acfg, pagesize);
1395 emit_global (acfg, symbol, TRUE);
1396 emit_label (acfg, symbol);
1397
1398 /* The common code */
1399 arm64_emit_tramp_page_common_code (acfg, pagesize, MONO_ARCH_RGCTX_REG, &common_tramp_size);
1400 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_STATIC_RGCTX] = common_tramp_size;
1401
1402 arm64_emit_tramp_page_specific_code (acfg, pagesize, common_tramp_size, specific_tramp_size);
1403
1404 /* The gsharedvt arg trampolines */
1405 /* These are the same as the specific trampolines */
1406 sprintf (symbol, "%sgsharedvt_arg_trampolines_page", acfg->user_symbol_prefix);
1407 emit_alignment (acfg, pagesize);
1408 emit_global (acfg, symbol, TRUE);
1409 emit_label (acfg, symbol);
1410
1411 arm64_emit_tramp_page_common_code (acfg, pagesize, ARMREG_IP1, &common_tramp_size);
1412 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_GSHAREDVT_ARG] = common_tramp_size;
1413
1414 arm64_emit_tramp_page_specific_code (acfg, pagesize, common_tramp_size, specific_tramp_size);
1415
1416 /* Unbox arbitrary trampolines */
1417 sprintf (symbol, "%sunbox_arbitrary_trampolines_page", acfg->user_symbol_prefix);
1418 emit_alignment (acfg, pagesize);
1419 emit_global (acfg, symbol, TRUE);
1420 emit_label (acfg, symbol);
1421
1422 code = buf;
1423 imm = pagesize;
1424
1425 /* Unbox this arg */
1426 arm_addx_imm (code, ARMREG_R0, ARMREG_R0, MONO_ABI_SIZEOF (MonoObject));
1427
1428 /* The trampoline address is in IP0 */
1429 arm_movzx (code, ARMREG_IP1, imm & 0xffff, 0);
1430 arm_movkx (code, ARMREG_IP1, (imm >> 16) & 0xffff, 16);
1431 /* Compute the data slot address */
1432 arm_subx (code, ARMREG_IP0, ARMREG_IP0, ARMREG_IP1);
1433 /* Address */
1434 arm_ldrp (code, ARMREG_IP0, ARMREG_IP0, 0);
1435 arm_brx (code, ARMREG_IP0);
1436
1437 /* Emit it */
1438 emit_code_bytes (acfg, buf, code - buf);
1439
1440 common_tramp_size = code - buf;
1441 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_UNBOX_ARBITRARY] = common_tramp_size;
1442
1443 arm64_emit_tramp_page_specific_code (acfg, pagesize, common_tramp_size, specific_tramp_size);
1444
1445 /* The IMT trampolines */
1446 sprintf (symbol, "%simt_trampolines_page", acfg->user_symbol_prefix);
1447 emit_alignment (acfg, pagesize);
1448 emit_global (acfg, symbol, TRUE);
1449 emit_label (acfg, symbol);
1450
1451 code = buf;
1452 imm = pagesize;
1453 /* The trampoline address is in IP0 */
1454 arm_movzx (code, ARMREG_IP1, imm & 0xffff, 0);
1455 arm_movkx (code, ARMREG_IP1, (imm >> 16) & 0xffff, 16);
1456 /* Compute the data slot address */
1457 arm_subx (code, ARMREG_IP0, ARMREG_IP0, ARMREG_IP1);
1458 /* Trampoline argument */
1459 arm_ldrp (code, ARMREG_IP1, ARMREG_IP0, 0);
1460
1461 /* Same as arch_emit_imt_trampoline () */
1462 labels [0] = code;
1463 arm_ldrp (code, ARMREG_IP0, ARMREG_IP1, 0);
1464 arm_cmpp (code, ARMREG_IP0, MONO_ARCH_RGCTX_REG);
1465 labels [1] = code;
1466 arm_bcc (code, ARMCOND_EQ, 0);
1467
1468 /* End-of-loop check */
1469 labels [2] = code;
1470 arm_cbzx (code, ARMREG_IP0, 0);
1471
1472 /* Loop footer */
1473 arm_addx_imm (code, ARMREG_IP1, ARMREG_IP1, 2 * TARGET_SIZEOF_VOID_P);
1474 arm_b (code, labels [0]);
1475
1476 /* Match */
1477 mono_arm_patch (labels [1], code, MONO_R_ARM64_BCC);
1478 /* Load vtable slot addr */
1479 arm_ldrp (code, ARMREG_IP0, ARMREG_IP1, TARGET_SIZEOF_VOID_P);
1480 /* Load vtable slot */
1481 arm_ldrp (code, ARMREG_IP0, ARMREG_IP0, 0);
1482 arm_brx (code, ARMREG_IP0);
1483
1484 /* No match */
1485 mono_arm_patch (labels [2], code, MONO_R_ARM64_CBZ);
1486 /* Load fail addr */
1487 arm_ldrp (code, ARMREG_IP0, ARMREG_IP1, TARGET_SIZEOF_VOID_P);
1488 arm_brx (code, ARMREG_IP0);
1489
1490 emit_code_bytes (acfg, buf, code - buf);
1491
1492 common_tramp_size = code - buf;
1493 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_IMT] = common_tramp_size;
1494
1495 arm64_emit_tramp_page_specific_code (acfg, pagesize, common_tramp_size, specific_tramp_size);
1496 }
1497
1498 static void
1499 arm64_emit_specific_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
1500 {
1501 /* Load argument from second GOT slot */
1502 arm64_emit_load_got_slot (acfg, ARMREG_R17, offset + 1);
1503 /* Load generic trampoline address from first GOT slot */
1504 arm64_emit_load_got_slot (acfg, ARMREG_R16, offset);
1505 fprintf (acfg->fp, "br x16\n");
1506 *tramp_size = 7 * 4;
1507 }
1508
1509 static void
1510 arm64_emit_unbox_trampoline (MonoAotCompile *acfg, MonoCompile *cfg, MonoMethod *method, const char *call_target)
1511 {
1512 emit_unset_mode (acfg);
1513 fprintf (acfg->fp, "add x0, x0, %d\n", (int)(MONO_ABI_SIZEOF (MonoObject)));
1514 fprintf (acfg->fp, "b %s\n", call_target);
1515 }
1516
1517 static void
1518 arm64_emit_static_rgctx_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
1519 {
1520 /* Similar to the specific trampolines, but use the rgctx reg instead of ip1 */
1521
1522 /* Load argument from first GOT slot */
1523 arm64_emit_load_got_slot (acfg, MONO_ARCH_RGCTX_REG, offset);
1524 /* Load generic trampoline address from second GOT slot */
1525 arm64_emit_load_got_slot (acfg, ARMREG_R16, offset + 1);
1526 fprintf (acfg->fp, "br x16\n");
1527 *tramp_size = 7 * 4;
1528 }
1529
1530 static void
1531 arm64_emit_imt_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
1532 {
1533 guint8 buf [128];
1534 guint8 *code, *labels [16];
1535
1536 /* Load parameter from GOT slot into ip1 */
1537 arm64_emit_load_got_slot (acfg, ARMREG_R17, offset);
1538
1539 code = buf;
1540 labels [0] = code;
1541 arm_ldrp (code, ARMREG_IP0, ARMREG_IP1, 0);
1542 arm_cmpp (code, ARMREG_IP0, MONO_ARCH_RGCTX_REG);
1543 labels [1] = code;
1544 arm_bcc (code, ARMCOND_EQ, 0);
1545
1546 /* End-of-loop check */
1547 labels [2] = code;
1548 arm_cbzx (code, ARMREG_IP0, 0);
1549
1550 /* Loop footer */
1551 arm_addx_imm (code, ARMREG_IP1, ARMREG_IP1, 2 * 8);
1552 arm_b (code, labels [0]);
1553
1554 /* Match */
1555 mono_arm_patch (labels [1], code, MONO_R_ARM64_BCC);
1556 /* Load vtable slot addr */
1557 arm_ldrp (code, ARMREG_IP0, ARMREG_IP1, TARGET_SIZEOF_VOID_P);
1558 /* Load vtable slot */
1559 arm_ldrp (code, ARMREG_IP0, ARMREG_IP0, 0);
1560 arm_brx (code, ARMREG_IP0);
1561
1562 /* No match */
1563 mono_arm_patch (labels [2], code, MONO_R_ARM64_CBZ);
1564 /* Load fail addr */
1565 arm_ldrp (code, ARMREG_IP0, ARMREG_IP1, TARGET_SIZEOF_VOID_P);
1566 arm_brx (code, ARMREG_IP0);
1567
1568 emit_code_bytes (acfg, buf, code - buf);
1569
1570 *tramp_size = code - buf + (3 * 4);
1571 }
1572
1573 static void
1574 arm64_emit_gsharedvt_arg_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
1575 {
1576 /* Similar to the specific trampolines, but the address is in the second slot */
1577 /* Load argument from first GOT slot */
1578 arm64_emit_load_got_slot (acfg, ARMREG_R17, offset);
1579 /* Load generic trampoline address from second GOT slot */
1580 arm64_emit_load_got_slot (acfg, ARMREG_R16, offset + 1);
1581 fprintf (acfg->fp, "br x16\n");
1582 *tramp_size = 7 * 4;
1583 }
1584
1585
1586 #endif
1587
1588 #ifdef MONO_ARCH_AOT_SUPPORTED
1589 /*
1590 * arch_emit_direct_call:
1591 *
1592 * Emit a direct call to the symbol TARGET. CALL_SIZE is set to the size of the
1593 * calling code.
1594 */
1595 static void
1596 arch_emit_direct_call (MonoAotCompile *acfg, const char *target, gboolean external, gboolean thumb, MonoJumpInfo *ji, int *call_size)
1597 {
1598 #if defined(TARGET_X86) || defined(TARGET_AMD64)
1599 /* Need to make sure this is exactly 5 bytes long */
1600 emit_unset_mode (acfg);
1601 fprintf (acfg->fp, "call %s\n", target);
1602 *call_size = 5;
1603 #elif defined(TARGET_ARM)
1604 emit_unset_mode (acfg);
1605 if (thumb)
1606 fprintf (acfg->fp, "blx %s\n", target);
1607 else
1608 fprintf (acfg->fp, "bl %s\n", target);
1609 *call_size = 4;
1610 #elif defined(TARGET_ARM64)
1611 arm64_emit_direct_call (acfg, target, external, thumb, ji, call_size);
1612 #elif defined(TARGET_POWERPC)
1613 emit_unset_mode (acfg);
1614 fprintf (acfg->fp, "bl %s\n", target);
1615 *call_size = 4;
1616 #else
1617 g_assert_not_reached ();
1618 #endif
1619 }
1620
1621 static void
1622 arch_emit_label_address (MonoAotCompile *acfg, const char *target, gboolean external_call, gboolean thumb, MonoJumpInfo *ji, int *call_size)
1623 {
1624 #if defined(TARGET_ARM) && defined(TARGET_ANDROID)
1625 /* binutils ld does not support branch islands on arm32 */
1626 if (!thumb) {
1627 emit_unset_mode (acfg);
1628 fprintf (acfg->fp, "ldr pc,=%s\n", target);
1629 fprintf (acfg->fp, ".ltorg\n");
1630 *call_size = 8;
1631 } else
1632 #endif
1633 arch_emit_direct_call (acfg, target, external_call, thumb, ji, call_size);
1634 }
1635 #endif
1636
1637 /*
1638 * PPC32 design:
1639 * - we use an approach similar to the x86 abi: reserve a register (r30) to hold
1640 * the GOT pointer.
1641 * - The full-aot trampolines need access to the GOT of mscorlib, so we store
1642 * in in the 2. slot of every GOT, and require every method to place the GOT
1643 * address in r30, even when it doesn't access the GOT otherwise. This way,
1644 * the trampolines can compute the mscorlib GOT address by loading 4(r30).
1645 */
1646
1647 /*
1648 * PPC64 design:
1649 * PPC64 uses function descriptors which greatly complicate all code, since
1650 * these are used very inconsistently in the runtime. Some functions like
1651 * mono_compile_method () return ftn descriptors, while others like the
1652 * trampoline creation functions do not.
1653 * We assume that all GOT slots contain function descriptors, and create
1654 * descriptors in aot-runtime.c when needed.
1655 * The ppc64 abi uses r2 to hold the address of the TOC/GOT, which is loaded
1656 * from function descriptors, we could do the same, but it would require
1657 * rewriting all the ppc/aot code to handle function descriptors properly.
1658 * So instead, we use the same approach as on PPC32.
1659 * This is a horrible mess, but fixing it would probably lead to an even bigger
1660 * one.
1661 */
1662
1663 /*
1664 * X86 design:
1665 * - similar to the PPC32 design, we reserve EBX to hold the GOT pointer.
1666 */
1667
1668 #ifdef MONO_ARCH_AOT_SUPPORTED
1669 /*
1670 * arch_emit_got_offset:
1671 *
1672 * The memory pointed to by CODE should hold native code for computing the GOT
1673 * address (OP_LOAD_GOTADDR). Emit this code while patching it with the offset
1674 * between code and the GOT. CODE_SIZE is set to the number of bytes emitted.
1675 */
1676 static void
1677 arch_emit_got_offset (MonoAotCompile *acfg, guint8 *code, int *code_size)
1678 {
1679 #if defined(TARGET_POWERPC64)
1680 emit_unset_mode (acfg);
1681 /*
1682 * The ppc32 code doesn't seem to work on ppc64, the assembler complains about
1683 * unsupported relocations. So we store the got address into the .Lgot_addr
1684 * symbol which is in the text segment, compute its address, and load it.
1685 */
1686 fprintf (acfg->fp, ".L%d:\n", acfg->label_generator);
1687 fprintf (acfg->fp, "lis 0, (.Lgot_addr + 4 - .L%d)@h\n", acfg->label_generator);
1688 fprintf (acfg->fp, "ori 0, 0, (.Lgot_addr + 4 - .L%d)@l\n", acfg->label_generator);
1689 fprintf (acfg->fp, "add 30, 30, 0\n");
1690 fprintf (acfg->fp, "%s 30, 0(30)\n", PPC_LD_OP);
1691 acfg->label_generator ++;
1692 *code_size = 16;
1693 #elif defined(TARGET_POWERPC)
1694 emit_unset_mode (acfg);
1695 fprintf (acfg->fp, ".L%d:\n", acfg->label_generator);
1696 fprintf (acfg->fp, "lis 0, (%s + 4 - .L%d)@h\n", acfg->got_symbol, acfg->label_generator);
1697 fprintf (acfg->fp, "ori 0, 0, (%s + 4 - .L%d)@l\n", acfg->got_symbol, acfg->label_generator);
1698 acfg->label_generator ++;
1699 *code_size = 8;
1700 #else
1701 guint32 offset = mono_arch_get_patch_offset (code);
1702 emit_bytes (acfg, code, offset);
1703 emit_symbol_diff (acfg, acfg->got_symbol, ".", offset);
1704
1705 *code_size = offset + 4;
1706 #endif
1707 }
1708
1709 /*
1710 * arch_emit_got_access:
1711 *
1712 * The memory pointed to by CODE should hold native code for loading a GOT
1713 * slot (OP_AOTCONST/OP_GOT_ENTRY). Emit this code while patching it so it accesses the
1714 * GOT slot GOT_SLOT. CODE_SIZE is set to the number of bytes emitted.
1715 */
1716 static void
1717 arch_emit_got_access (MonoAotCompile *acfg, const char *got_symbol, guint8 *code, int got_slot, int *code_size)
1718 {
1719 #ifdef TARGET_AMD64
1720 /* mov reg, got+offset(%rip) */
1721 if (acfg->llvm) {
1722 /* The GOT symbol is in the LLVM module, the clang assembler has problems emitting symbol diffs for it */
1723 int dreg;
1724 int rex_r;
1725
1726 /* Decode reg, see amd64_mov_reg_membase () */
1727 rex_r = code [0] & AMD64_REX_R;
1728 g_assert (code [0] == 0x49 + rex_r);
1729 g_assert (code [1] == 0x8b);
1730 dreg = ((code [2] >> 3) & 0x7) + (rex_r ? 8 : 0);
1731
1732 emit_unset_mode (acfg);
1733 fprintf (acfg->fp, "mov %s+%d(%%rip), %s\n", got_symbol, (unsigned int) ((got_slot * sizeof (target_mgreg_t))), mono_arch_regname (dreg));
1734 *code_size = 7;
1735 } else {
1736 emit_bytes (acfg, code, mono_arch_get_patch_offset (code));
1737 emit_symbol_diff (acfg, got_symbol, ".", (unsigned int) ((got_slot * sizeof (target_mgreg_t)) - 4));
1738 *code_size = mono_arch_get_patch_offset (code) + 4;
1739 }
1740 #elif defined(TARGET_X86)
1741 emit_bytes (acfg, code, mono_arch_get_patch_offset (code));
1742 emit_int32 (acfg, (unsigned int) ((got_slot * sizeof (target_mgreg_t))));
1743 *code_size = mono_arch_get_patch_offset (code) + 4;
1744 #elif defined(TARGET_ARM)
1745 emit_bytes (acfg, code, mono_arch_get_patch_offset (code));
1746 emit_symbol_diff (acfg, got_symbol, ".", (unsigned int) ((got_slot * sizeof (target_mgreg_t))) - 12);
1747 *code_size = mono_arch_get_patch_offset (code) + 4;
1748 #elif defined(TARGET_ARM64)
1749 emit_bytes (acfg, code, mono_arch_get_patch_offset (code));
1750 arm64_emit_got_access (acfg, code, got_slot, code_size);
1751 #elif defined(TARGET_POWERPC)
1752 {
1753 guint8 buf [32];
1754
1755 emit_bytes (acfg, code, mono_arch_get_patch_offset (code));
1756 code = buf;
1757 ppc_load32 (code, ppc_r0, got_slot * sizeof (target_mgreg_t));
1758 g_assert (code - buf == 8);
1759 emit_bytes (acfg, buf, code - buf);
1760 *code_size = code - buf;
1761 }
1762 #else
1763 g_assert_not_reached ();
1764 #endif
1765 }
1766
1767 #endif
1768
1769 #ifdef MONO_ARCH_AOT_SUPPORTED
1770 /*
1771 * arch_emit_objc_selector_ref:
1772 *
1773 * Emit the implementation of OP_OBJC_GET_SELECTOR, which itself implements @selector(foo:) in objective-c.
1774 */
1775 static void
1776 arch_emit_objc_selector_ref (MonoAotCompile *acfg, guint8 *code, int index, int *code_size)
1777 {
1778 #if defined(TARGET_ARM)
1779 char symbol1 [MAX_SYMBOL_SIZE];
1780 char symbol2 [MAX_SYMBOL_SIZE];
1781 int lindex = acfg->objc_selector_index_2 ++;
1782
1783 /* Emit ldr.imm/b */
1784 emit_bytes (acfg, code, 8);
1785
1786 sprintf (symbol1, "L_OBJC_SELECTOR_%d", lindex);
1787 sprintf (symbol2, "L_OBJC_SELECTOR_REFERENCES_%d", index);
1788
1789 emit_label (acfg, symbol1);
1790 mono_img_writer_emit_unset_mode (acfg->w);
1791 fprintf (acfg->fp, ".long %s-(%s+12)", symbol2, symbol1);
1792
1793 *code_size = 12;
1794 #elif defined(TARGET_ARM64)
1795 arm64_emit_objc_selector_ref (acfg, code, index, code_size);
1796 #else
1797 g_assert_not_reached ();
1798 #endif
1799 }
1800 #endif
1801
1802 /*
1803 * arch_emit_plt_entry:
1804 *
1805 * Emit code for the PLT entry.
1806 * The plt entry should look like this:
1807 * <indirect jump to GOT_SYMBOL + OFFSET>
1808 * <INFO_OFFSET embedded into the instruction stream>
1809 */
1810 static void
1811 arch_emit_plt_entry (MonoAotCompile *acfg, const char *got_symbol, int offset, int info_offset)
1812 {
1813 #if defined(TARGET_X86)
1814 /* jmp *<offset>(%ebx) */
1815 emit_byte (acfg, 0xff);
1816 emit_byte (acfg, 0xa3);
1817 emit_int32 (acfg, offset);
1818 /* Used by mono_aot_get_plt_info_offset */
1819 emit_int32 (acfg, info_offset);
1820 #elif defined(TARGET_AMD64)
1821 emit_unset_mode (acfg);
1822 fprintf (acfg->fp, "jmp *%s+%d(%%rip)\n", got_symbol, offset);
1823 /* Used by mono_aot_get_plt_info_offset */
1824 emit_int32 (acfg, info_offset);
1825 acfg->stats.plt_size += 10;
1826 #elif defined(TARGET_ARM)
1827 guint8 buf [256];
1828 guint8 *code;
1829
1830 code = buf;
1831 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0);
1832 ARM_LDR_REG_REG (code, ARMREG_PC, ARMREG_PC, ARMREG_IP);
1833 emit_bytes (acfg, buf, code - buf);
1834 emit_symbol_diff (acfg, got_symbol, ".", offset - 4);
1835 /* Used by mono_aot_get_plt_info_offset */
1836 emit_int32 (acfg, info_offset);
1837 #elif defined(TARGET_ARM64)
1838 arm64_emit_plt_entry (acfg, got_symbol, offset, info_offset);
1839 #elif defined(TARGET_POWERPC)
1840 /* The GOT address is guaranteed to be in r30 by OP_LOAD_GOTADDR */
1841 emit_unset_mode (acfg);
1842 fprintf (acfg->fp, "lis 11, %d@h\n", offset);
1843 fprintf (acfg->fp, "ori 11, 11, %d@l\n", offset);
1844 fprintf (acfg->fp, "add 11, 11, 30\n");
1845 fprintf (acfg->fp, "%s 11, 0(11)\n", PPC_LD_OP);
1846 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
1847 fprintf (acfg->fp, "%s 2, %d(11)\n", PPC_LD_OP, (int)sizeof (target_mgreg_t));
1848 fprintf (acfg->fp, "%s 11, 0(11)\n", PPC_LD_OP);
1849 #endif
1850 fprintf (acfg->fp, "mtctr 11\n");
1851 fprintf (acfg->fp, "bctr\n");
1852 emit_int32 (acfg, info_offset);
1853 #else
1854 g_assert_not_reached ();
1855 #endif
1856 }
1857
1858 /*
1859 * arch_emit_llvm_plt_entry:
1860 *
1861 * Same as arch_emit_plt_entry, but handles calls from LLVM generated code.
1862 * This is only needed on arm to handle thumb interop.
1863 */
1864 static void
1865 arch_emit_llvm_plt_entry (MonoAotCompile *acfg, const char *got_symbol, int offset, int info_offset)
1866 {
1867 #if defined(TARGET_ARM)
1868 /* LLVM calls the PLT entries using bl, so these have to be thumb2 */
1869 /* The caller already transitioned to thumb */
1870 /* The code below should be 12 bytes long */
1871 /* clang has trouble encoding these instructions, so emit the binary */
1872 #if 0
1873 fprintf (acfg->fp, "ldr ip, [pc, #8]\n");
1874 /* thumb can't encode ld pc, [pc, ip] */
1875 fprintf (acfg->fp, "add ip, pc, ip\n");
1876 fprintf (acfg->fp, "ldr ip, [ip, #0]\n");
1877 fprintf (acfg->fp, "bx ip\n");
1878 #endif
1879 emit_set_thumb_mode (acfg);
1880 fprintf (acfg->fp, ".4byte 0xc008f8df\n");
1881 fprintf (acfg->fp, ".2byte 0x44fc\n");
1882 fprintf (acfg->fp, ".4byte 0xc000f8dc\n");
1883 fprintf (acfg->fp, ".2byte 0x4760\n");
1884 emit_symbol_diff (acfg, got_symbol, ".", offset + 4);
1885 emit_int32 (acfg, info_offset);
1886 emit_unset_mode (acfg);
1887 emit_set_arm_mode (acfg);
1888 #else
1889 g_assert_not_reached ();
1890 #endif
1891 }
1892
1893 /* Save unwind_info in the module and emit the offset to the information at symbol */
1894 static void save_unwind_info (MonoAotCompile *acfg, char *symbol, GSList *unwind_ops)
1895 {
1896 guint32 uw_offset, encoded_len;
1897 guint8 *encoded;
1898
1899 emit_section_change (acfg, RODATA_SECT, 0);
1900 emit_global (acfg, symbol, FALSE);
1901 emit_label (acfg, symbol);
1902
1903 encoded = mono_unwind_ops_encode (unwind_ops, &encoded_len);
1904 uw_offset = get_unwind_info_offset (acfg, encoded, encoded_len);
1905 g_free (encoded);
1906 emit_int32 (acfg, uw_offset);
1907 }
1908
1909 /*
1910 * arch_emit_specific_trampoline_pages:
1911 *
1912 * Emits a page full of trampolines: each trampoline uses its own address to
1913 * lookup both the generic trampoline code and the data argument.
1914 * This page can be remapped in process multiple times so we can get an
1915 * unlimited number of trampolines.
1916 * Specifically this implementation uses the following trick: two memory pages
1917 * are allocated, with the first containing the data and the second containing the trampolines.
1918 * To reduce trampoline size, each trampoline jumps at the start of the page where a common
1919 * implementation does all the lifting.
1920 * Note that the ARM single trampoline size is 8 bytes, exactly like the data that needs to be stored
1921 * on the arm 32 bit system.
1922 */
1923 static void
1924 arch_emit_specific_trampoline_pages (MonoAotCompile *acfg)
1925 {
1926 #if defined(TARGET_ARM)
1927 guint8 buf [128];
1928 guint8 *code;
1929 guint8 *loop_start, *loop_branch_back, *loop_end_check, *imt_found_check;
1930 int i;
1931 int pagesize = MONO_AOT_TRAMP_PAGE_SIZE;
1932 GSList *unwind_ops = NULL;
1933 #define COMMON_TRAMP_SIZE 16
1934 int count = (pagesize - COMMON_TRAMP_SIZE) / 8;
1935 int imm8, rot_amount;
1936 char symbol [128];
1937
1938 if (!acfg->aot_opts.use_trampolines_page)
1939 return;
1940
1941 acfg->tramp_page_size = pagesize;
1942
1943 sprintf (symbol, "%sspecific_trampolines_page", acfg->user_symbol_prefix);
1944 emit_alignment (acfg, pagesize);
1945 emit_global (acfg, symbol, TRUE);
1946 emit_label (acfg, symbol);
1947
1948 /* emit the generic code first, the trampoline address + 8 is in the lr register */
1949 code = buf;
1950 imm8 = mono_arm_is_rotated_imm8 (pagesize, &rot_amount);
1951 ARM_SUB_REG_IMM (code, ARMREG_LR, ARMREG_LR, imm8, rot_amount);
1952 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_LR, -8);
1953 ARM_LDR_IMM (code, ARMREG_PC, ARMREG_LR, -4);
1954 ARM_NOP (code);
1955 g_assert (code - buf == COMMON_TRAMP_SIZE);
1956
1957 /* Emit it */
1958 emit_bytes (acfg, buf, code - buf);
1959
1960 for (i = 0; i < count; ++i) {
1961 code = buf;
1962 ARM_PUSH (code, 0x5fff);
1963 ARM_BL (code, 0);
1964 arm_patch (code - 4, code - COMMON_TRAMP_SIZE - 8 * (i + 1));
1965 g_assert (code - buf == 8);
1966 emit_bytes (acfg, buf, code - buf);
1967 }
1968
1969 /* now the rgctx trampolines: each specific trampolines puts in the ip register
1970 * the instruction pointer address, so the generic trampoline at the start of the page
1971 * subtracts 4096 to get to the data page and loads the values
1972 * We again fit the generic trampiline in 16 bytes.
1973 */
1974 sprintf (symbol, "%srgctx_trampolines_page", acfg->user_symbol_prefix);
1975 emit_global (acfg, symbol, TRUE);
1976 emit_label (acfg, symbol);
1977 code = buf;
1978 imm8 = mono_arm_is_rotated_imm8 (pagesize, &rot_amount);
1979 ARM_SUB_REG_IMM (code, ARMREG_IP, ARMREG_IP, imm8, rot_amount);
1980 ARM_LDR_IMM (code, MONO_ARCH_RGCTX_REG, ARMREG_IP, -8);
1981 ARM_LDR_IMM (code, ARMREG_PC, ARMREG_IP, -4);
1982 ARM_NOP (code);
1983 g_assert (code - buf == COMMON_TRAMP_SIZE);
1984
1985 /* Emit it */
1986 emit_bytes (acfg, buf, code - buf);
1987
1988 for (i = 0; i < count; ++i) {
1989 code = buf;
1990 ARM_MOV_REG_REG (code, ARMREG_IP, ARMREG_PC);
1991 ARM_B (code, 0);
1992 arm_patch (code - 4, code - COMMON_TRAMP_SIZE - 8 * (i + 1));
1993 g_assert (code - buf == 8);
1994 emit_bytes (acfg, buf, code - buf);
1995 }
1996
1997 /*
1998 * gsharedvt arg trampolines: see arch_emit_gsharedvt_arg_trampoline ()
1999 */
2000 sprintf (symbol, "%sgsharedvt_arg_trampolines_page", acfg->user_symbol_prefix);
2001 emit_global (acfg, symbol, TRUE);
2002 emit_label (acfg, symbol);
2003 code = buf;
2004 ARM_PUSH (code, (1 << ARMREG_R0) | (1 << ARMREG_R1) | (1 << ARMREG_R2) | (1 << ARMREG_R3));
2005 imm8 = mono_arm_is_rotated_imm8 (pagesize, &rot_amount);
2006 ARM_SUB_REG_IMM (code, ARMREG_IP, ARMREG_IP, imm8, rot_amount);
2007 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_IP, -8);
2008 ARM_LDR_IMM (code, ARMREG_PC, ARMREG_IP, -4);
2009 g_assert (code - buf == COMMON_TRAMP_SIZE);
2010 /* Emit it */
2011 emit_bytes (acfg, buf, code - buf);
2012
2013 for (i = 0; i < count; ++i) {
2014 code = buf;
2015 ARM_MOV_REG_REG (code, ARMREG_IP, ARMREG_PC);
2016 ARM_B (code, 0);
2017 arm_patch (code - 4, code - COMMON_TRAMP_SIZE - 8 * (i + 1));
2018 g_assert (code - buf == 8);
2019 emit_bytes (acfg, buf, code - buf);
2020 }
2021
2022 /* now the unbox arbitrary trampolines: each specific trampolines puts in the ip register
2023 * the instruction pointer address, so the generic trampoline at the start of the page
2024 * subtracts 4096 to get to the data page and loads the target addr.
2025 * We again fit the generic trampoline in 16 bytes.
2026 */
2027 sprintf (symbol, "%sunbox_arbitrary_trampolines_page", acfg->user_symbol_prefix);
2028 emit_global (acfg, symbol, TRUE);
2029 emit_label (acfg, symbol);
2030 code = buf;
2031
2032 ARM_ADD_REG_IMM8 (code, ARMREG_R0, ARMREG_R0, MONO_ABI_SIZEOF (MonoObject));
2033 imm8 = mono_arm_is_rotated_imm8 (pagesize, &rot_amount);
2034 ARM_SUB_REG_IMM (code, ARMREG_IP, ARMREG_IP, imm8, rot_amount);
2035 ARM_LDR_IMM (code, ARMREG_PC, ARMREG_IP, -4);
2036 ARM_NOP (code);
2037 g_assert (code - buf == COMMON_TRAMP_SIZE);
2038
2039 /* Emit it */
2040 emit_bytes (acfg, buf, code - buf);
2041
2042 for (i = 0; i < count; ++i) {
2043 code = buf;
2044 ARM_MOV_REG_REG (code, ARMREG_IP, ARMREG_PC);
2045 ARM_B (code, 0);
2046 arm_patch (code - 4, code - COMMON_TRAMP_SIZE - 8 * (i + 1));
2047 g_assert (code - buf == 8);
2048 emit_bytes (acfg, buf, code - buf);
2049 }
2050
2051 /* now the imt trampolines: each specific trampolines puts in the ip register
2052 * the instruction pointer address, so the generic trampoline at the start of the page
2053 * subtracts 4096 to get to the data page and loads the values
2054 */
2055 #define IMT_TRAMP_SIZE 72
2056 sprintf (symbol, "%simt_trampolines_page", acfg->user_symbol_prefix);
2057 emit_global (acfg, symbol, TRUE);
2058 emit_label (acfg, symbol);
2059 code = buf;
2060 /* Need at least two free registers, plus a slot for storing the pc */
2061 ARM_PUSH (code, (1 << ARMREG_R0)|(1 << ARMREG_R1)|(1 << ARMREG_R2));
2062
2063 imm8 = mono_arm_is_rotated_imm8 (pagesize, &rot_amount);
2064 ARM_SUB_REG_IMM (code, ARMREG_IP, ARMREG_IP, imm8, rot_amount);
2065 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_IP, -8);
2066
2067 /* The IMT method is in v5, r0 has the imt array address */
2068
2069 loop_start = code;
2070 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_R0, 0);
2071 ARM_CMP_REG_REG (code, ARMREG_R1, ARMREG_V5);
2072 imt_found_check = code;
2073 ARM_B_COND (code, ARMCOND_EQ, 0);
2074
2075 /* End-of-loop check */
2076 ARM_CMP_REG_IMM (code, ARMREG_R1, 0, 0);
2077 loop_end_check = code;
2078 ARM_B_COND (code, ARMCOND_EQ, 0);
2079
2080 /* Loop footer */
2081 ARM_ADD_REG_IMM8 (code, ARMREG_R0, ARMREG_R0, sizeof (target_mgreg_t) * 2);
2082 loop_branch_back = code;
2083 ARM_B (code, 0);
2084 arm_patch (loop_branch_back, loop_start);
2085
2086 /* Match */
2087 arm_patch (imt_found_check, code);
2088 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_R0, 4);
2089 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_R0, 0);
2090 /* Save it to the third stack slot */
2091 ARM_STR_IMM (code, ARMREG_R0, ARMREG_SP, 8);
2092 /* Restore the registers and branch */
2093 ARM_POP (code, (1 << ARMREG_R0)|(1 << ARMREG_R1)|(1 << ARMREG_PC));
2094
2095 /* No match */
2096 arm_patch (loop_end_check, code);
2097 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_R0, 4);
2098 ARM_STR_IMM (code, ARMREG_R0, ARMREG_SP, 8);
2099 ARM_POP (code, (1 << ARMREG_R0)|(1 << ARMREG_R1)|(1 << ARMREG_PC));
2100 ARM_NOP (code);
2101
2102 /* Emit it */
2103 g_assert (code - buf == IMT_TRAMP_SIZE);
2104 emit_bytes (acfg, buf, code - buf);
2105
2106 for (i = 0; i < count; ++i) {
2107 code = buf;
2108 ARM_MOV_REG_REG (code, ARMREG_IP, ARMREG_PC);
2109 ARM_B (code, 0);
2110 arm_patch (code - 4, code - IMT_TRAMP_SIZE - 8 * (i + 1));
2111 g_assert (code - buf == 8);
2112 emit_bytes (acfg, buf, code - buf);
2113 }
2114
2115 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_SPECIFIC] = 16;
2116 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_STATIC_RGCTX] = 16;
2117 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_IMT] = 72;
2118 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_GSHAREDVT_ARG] = 16;
2119 acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_UNBOX_ARBITRARY] = 16;
2120
2121 /* Unwind info for specifc trampolines */
2122 sprintf (symbol, "%sspecific_trampolines_page_gen_p", acfg->user_symbol_prefix);
2123 /* We unwind to the original caller, from the stack, since lr is clobbered */
2124 mono_add_unwind_op_def_cfa (unwind_ops, 0, 0, ARMREG_SP, 14 * sizeof (target_mgreg_t));
2125 mono_add_unwind_op_offset (unwind_ops, 0, 0, ARMREG_LR, -4);
2126 save_unwind_info (acfg, symbol, unwind_ops);
2127 mono_free_unwind_info (unwind_ops);
2128
2129 sprintf (symbol, "%sspecific_trampolines_page_sp_p", acfg->user_symbol_prefix);
2130 mono_add_unwind_op_def_cfa (unwind_ops, 0, 0, ARMREG_SP, 0);
2131 mono_add_unwind_op_def_cfa_offset (unwind_ops, 4, 0, 14 * sizeof (target_mgreg_t));
2132 save_unwind_info (acfg, symbol, unwind_ops);
2133 mono_free_unwind_info (unwind_ops);
2134
2135 /* Unwind info for rgctx trampolines */
2136 sprintf (symbol, "%srgctx_trampolines_page_gen_p", acfg->user_symbol_prefix);
2137 mono_add_unwind_op_def_cfa (unwind_ops, 0, 0, ARMREG_SP, 0);
2138 save_unwind_info (acfg, symbol, unwind_ops);
2139
2140 sprintf (symbol, "%srgctx_trampolines_page_sp_p", acfg->user_symbol_prefix);
2141 save_unwind_info (acfg, symbol, unwind_ops);
2142 mono_free_unwind_info (unwind_ops);
2143
2144 /* Unwind info for gsharedvt trampolines */
2145 sprintf (symbol, "%sgsharedvt_trampolines_page_gen_p", acfg->user_symbol_prefix);
2146 mono_add_unwind_op_def_cfa (unwind_ops, 0, 0, ARMREG_SP, 0);
2147 mono_add_unwind_op_def_cfa_offset (unwind_ops, 4, 0, 4 * sizeof (target_mgreg_t));
2148 save_unwind_info (acfg, symbol, unwind_ops);
2149 mono_free_unwind_info (unwind_ops);
2150
2151 sprintf (symbol, "%sgsharedvt_trampolines_page_sp_p", acfg->user_symbol_prefix);
2152 mono_add_unwind_op_def_cfa (unwind_ops, 0, 0, ARMREG_SP, 0);
2153 save_unwind_info (acfg, symbol, unwind_ops);
2154 mono_free_unwind_info (unwind_ops);
2155
2156 /* Unwind info for unbox arbitrary trampolines */
2157 sprintf (symbol, "%sunbox_arbitrary_trampolines_page_gen_p", acfg->user_symbol_prefix);
2158 mono_add_unwind_op_def_cfa (unwind_ops, 0, 0, ARMREG_SP, 0);
2159 save_unwind_info (acfg, symbol, unwind_ops);
2160
2161 sprintf (symbol, "%sunbox_arbitrary_trampolines_page_sp_p", acfg->user_symbol_prefix);
2162 save_unwind_info (acfg, symbol, unwind_ops);
2163 mono_free_unwind_info (unwind_ops);
2164
2165 /* Unwind info for imt trampolines */
2166 sprintf (symbol, "%simt_trampolines_page_gen_p", acfg->user_symbol_prefix);
2167 mono_add_unwind_op_def_cfa (unwind_ops, 0, 0, ARMREG_SP, 0);
2168 mono_add_unwind_op_def_cfa_offset (unwind_ops, 4, 0, 3 * sizeof (target_mgreg_t));
2169 save_unwind_info (acfg, symbol, unwind_ops);
2170 mono_free_unwind_info (unwind_ops);
2171
2172 sprintf (symbol, "%simt_trampolines_page_sp_p", acfg->user_symbol_prefix);
2173 mono_add_unwind_op_def_cfa (unwind_ops, 0, 0, ARMREG_SP, 0);
2174 save_unwind_info (acfg, symbol, unwind_ops);
2175 mono_free_unwind_info (unwind_ops);
2176 #elif defined(TARGET_ARM64)
2177 arm64_emit_specific_trampoline_pages (acfg);
2178 #endif
2179 }
2180
2181 /*
2182 * arch_emit_specific_trampoline:
2183 *
2184 * Emit code for a specific trampoline. OFFSET is the offset of the first of
2185 * two GOT slots which contain the generic trampoline address and the trampoline
2186 * argument. TRAMP_SIZE is set to the size of the emitted trampoline.
2187 */
2188 static void
2189 arch_emit_specific_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
2190 {
2191 /*
2192 * The trampolines created here are variations of the specific
2193 * trampolines created in mono_arch_create_specific_trampoline (). The
2194 * differences are:
2195 * - the generic trampoline address is taken from a got slot.
2196 * - the offset of the got slot where the trampoline argument is stored
2197 * is embedded in the instruction stream, and the generic trampoline
2198 * can load the argument by loading the offset, adding it to the
2199 * address of the trampoline to get the address of the got slot, and
2200 * loading the argument from there.
2201 * - all the trampolines should be of the same length.
2202 */
2203 #if defined(TARGET_AMD64)
2204 /* This should be exactly 8 bytes long */
2205 *tramp_size = 8;
2206 /* call *<offset>(%rip) */
2207 if (acfg->llvm) {
2208 emit_unset_mode (acfg);
2209 fprintf (acfg->fp, "call *%s+%d(%%rip)\n", acfg->got_symbol, (int)(offset * sizeof (target_mgreg_t)));
2210 emit_zero_bytes (acfg, 2);
2211 } else {
2212 emit_byte (acfg, '\x41');
2213 emit_byte (acfg, '\xff');
2214 emit_byte (acfg, '\x15');
2215 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) - 4);
2216 emit_zero_bytes (acfg, 1);
2217 }
2218 #elif defined(TARGET_ARM)
2219 guint8 buf [128];
2220 guint8 *code;
2221
2222 /* This should be exactly 20 bytes long */
2223 *tramp_size = 20;
2224 code = buf;
2225 ARM_PUSH (code, 0x5fff);
2226 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 4);
2227 /* Load the value from the GOT */
2228 ARM_LDR_REG_REG (code, ARMREG_R1, ARMREG_PC, ARMREG_R1);
2229 /* Branch to it */
2230 ARM_BLX_REG (code, ARMREG_R1);
2231
2232 g_assert (code - buf == 16);
2233
2234 /* Emit it */
2235 emit_bytes (acfg, buf, code - buf);
2236 /*
2237 * Only one offset is needed, since the second one would be equal to the
2238 * first one.
2239 */
2240 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) - 4 + 4);
2241 //emit_symbol_diff (acfg, acfg->got_symbol, ".", ((offset + 1) * sizeof (target_mgreg_t)) - 4 + 8);
2242 #elif defined(TARGET_ARM64)
2243 arm64_emit_specific_trampoline (acfg, offset, tramp_size);
2244 #elif defined(TARGET_POWERPC)
2245 guint8 buf [128];
2246 guint8 *code;
2247
2248 *tramp_size = 4;
2249 code = buf;
2250
2251 /*
2252 * PPC has no ip relative addressing, so we need to compute the address
2253 * of the mscorlib got. That is slow and complex, so instead, we store it
2254 * in the second got slot of every aot image. The caller already computed
2255 * the address of its got and placed it into r30.
2256 */
2257 emit_unset_mode (acfg);
2258 /* Load mscorlib got address */
2259 fprintf (acfg->fp, "%s 0, %d(30)\n", PPC_LD_OP, (int)sizeof (target_mgreg_t));
2260 /* Load generic trampoline address */
2261 fprintf (acfg->fp, "lis 11, %d@h\n", (int)(offset * sizeof (target_mgreg_t)));
2262 fprintf (acfg->fp, "ori 11, 11, %d@l\n", (int)(offset * sizeof (target_mgreg_t)));
2263 fprintf (acfg->fp, "%s 11, 11, 0\n", PPC_LDX_OP);
2264 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
2265 fprintf (acfg->fp, "%s 11, 0(11)\n", PPC_LD_OP);
2266 #endif
2267 fprintf (acfg->fp, "mtctr 11\n");
2268 /* Load trampoline argument */
2269 /* On ppc, we pass it normally to the generic trampoline */
2270 fprintf (acfg->fp, "lis 11, %d@h\n", (int)((offset + 1) * sizeof (target_mgreg_t)));
2271 fprintf (acfg->fp, "ori 11, 11, %d@l\n", (int)((offset + 1) * sizeof (target_mgreg_t)));
2272 fprintf (acfg->fp, "%s 0, 11, 0\n", PPC_LDX_OP);
2273 /* Branch to generic trampoline */
2274 fprintf (acfg->fp, "bctr\n");
2275
2276 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
2277 *tramp_size = 10 * 4;
2278 #else
2279 *tramp_size = 9 * 4;
2280 #endif
2281 #elif defined(TARGET_X86)
2282 guint8 buf [128];
2283 guint8 *code;
2284
2285 /* Similar to the PPC code above */
2286
2287 /* FIXME: Could this clobber the register needed by get_vcall_slot () ? */
2288
2289 code = buf;
2290 /* Load mscorlib got address */
2291 x86_mov_reg_membase (code, X86_ECX, MONO_ARCH_GOT_REG, sizeof (target_mgreg_t), 4);
2292 /* Push trampoline argument */
2293 x86_push_membase (code, X86_ECX, (offset + 1) * sizeof (target_mgreg_t));
2294 /* Load generic trampoline address */
2295 x86_mov_reg_membase (code, X86_ECX, X86_ECX, offset * sizeof (target_mgreg_t), 4);
2296 /* Branch to generic trampoline */
2297 x86_jump_reg (code, X86_ECX);
2298
2299 emit_bytes (acfg, buf, code - buf);
2300
2301 *tramp_size = 17;
2302 g_assert (code - buf == *tramp_size);
2303 #else
2304 g_assert_not_reached ();
2305 #endif
2306 }
2307
2308 /*
2309 * arch_emit_unbox_trampoline:
2310 *
2311 * Emit code for the unbox trampoline for METHOD used in the full-aot case.
2312 * CALL_TARGET is the symbol pointing to the native code of METHOD.
2313 *
2314 * See mono_aot_get_unbox_trampoline.
2315 */
2316 static void
2317 arch_emit_unbox_trampoline (MonoAotCompile *acfg, MonoCompile *cfg, MonoMethod *method, const char *call_target)
2318 {
2319 #if defined(TARGET_AMD64)
2320 guint8 buf [32];
2321 guint8 *code;
2322 int this_reg;
2323
2324 this_reg = mono_arch_get_this_arg_reg (NULL);
2325 code = buf;
2326 amd64_alu_reg_imm (code, X86_ADD, this_reg, MONO_ABI_SIZEOF (MonoObject));
2327
2328 emit_bytes (acfg, buf, code - buf);
2329 /* jump <method> */
2330 if (acfg->llvm) {
2331 emit_unset_mode (acfg);
2332 fprintf (acfg->fp, "jmp %s\n", call_target);
2333 } else {
2334 emit_byte (acfg, '\xe9');
2335 emit_symbol_diff (acfg, call_target, ".", -4);
2336 }
2337 #elif defined(TARGET_X86)
2338 guint8 buf [32];
2339 guint8 *code;
2340 int this_pos = 4;
2341
2342 code = buf;
2343
2344 x86_alu_membase_imm (code, X86_ADD, X86_ESP, this_pos, MONO_ABI_SIZEOF (MonoObject));
2345
2346 emit_bytes (acfg, buf, code - buf);
2347
2348 /* jump <method> */
2349 emit_byte (acfg, '\xe9');
2350 emit_symbol_diff (acfg, call_target, ".", -4);
2351 #elif defined(TARGET_ARM)
2352 guint8 buf [128];
2353 guint8 *code;
2354
2355 if (acfg->thumb_mixed && cfg->compile_llvm) {
2356 fprintf (acfg->fp, "add r0, r0, #%d\n", (int)MONO_ABI_SIZEOF (MonoObject));
2357 fprintf (acfg->fp, "b %s\n", call_target);
2358 fprintf (acfg->fp, ".arm\n");
2359 fprintf (acfg->fp, ".align 2\n");
2360 return;
2361 }
2362
2363 code = buf;
2364
2365 ARM_ADD_REG_IMM8 (code, ARMREG_R0, ARMREG_R0, MONO_ABI_SIZEOF (MonoObject));
2366
2367 emit_bytes (acfg, buf, code - buf);
2368 /* jump to method */
2369 if (acfg->thumb_mixed && cfg->compile_llvm)
2370 fprintf (acfg->fp, "\n\tbx %s\n", call_target);
2371 else
2372 fprintf (acfg->fp, "\n\tb %s\n", call_target);
2373 #elif defined(TARGET_ARM64)
2374 arm64_emit_unbox_trampoline (acfg, cfg, method, call_target);
2375 #elif defined(TARGET_POWERPC)
2376 int this_pos = 3;
2377
2378 fprintf (acfg->fp, "\n\taddi %d, %d, %d\n", this_pos, this_pos, (int)MONO_ABI_SIZEOF (MonoObject));
2379 fprintf (acfg->fp, "\n\tb %s\n", call_target);
2380 #else
2381 g_assert_not_reached ();
2382 #endif
2383 }
2384
2385 /*
2386 * arch_emit_static_rgctx_trampoline:
2387 *
2388 * Emit code for a static rgctx trampoline. OFFSET is the offset of the first of
2389 * two GOT slots which contain the rgctx argument, and the method to jump to.
2390 * TRAMP_SIZE is set to the size of the emitted trampoline.
2391 * These kinds of trampolines cannot be enumerated statically, since there could
2392 * be one trampoline per method instantiation, so we emit the same code for all
2393 * trampolines, and parameterize them using two GOT slots.
2394 */
2395 static void
2396 arch_emit_static_rgctx_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
2397 {
2398 #if defined(TARGET_AMD64)
2399 /* This should be exactly 13 bytes long */
2400 *tramp_size = 13;
2401
2402 if (acfg->llvm) {
2403 emit_unset_mode (acfg);
2404 fprintf (acfg->fp, "mov %s+%d(%%rip), %%r10\n", acfg->got_symbol, (int)(offset * sizeof (target_mgreg_t)));
2405 fprintf (acfg->fp, "jmp *%s+%d(%%rip)\n", acfg->got_symbol, (int)((offset + 1) * sizeof (target_mgreg_t)));
2406 } else {
2407 /* mov <OFFSET>(%rip), %r10 */
2408 emit_byte (acfg, '\x4d');
2409 emit_byte (acfg, '\x8b');
2410 emit_byte (acfg, '\x15');
2411 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) - 4);
2412
2413 /* jmp *<offset>(%rip) */
2414 emit_byte (acfg, '\xff');
2415 emit_byte (acfg, '\x25');
2416 emit_symbol_diff (acfg, acfg->got_symbol, ".", ((offset + 1) * sizeof (target_mgreg_t)) - 4);
2417 }
2418 #elif defined(TARGET_ARM)
2419 guint8 buf [128];
2420 guint8 *code;
2421
2422 /* This should be exactly 24 bytes long */
2423 *tramp_size = 24;
2424 code = buf;
2425 /* Load rgctx value */
2426 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 8);
2427 ARM_LDR_REG_REG (code, MONO_ARCH_RGCTX_REG, ARMREG_PC, ARMREG_IP);
2428 /* Load branch addr + branch */
2429 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 4);
2430 ARM_LDR_REG_REG (code, ARMREG_PC, ARMREG_PC, ARMREG_IP);
2431
2432 g_assert (code - buf == 16);
2433
2434 /* Emit it */
2435 emit_bytes (acfg, buf, code - buf);
2436 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) - 4 + 8);
2437 emit_symbol_diff (acfg, acfg->got_symbol, ".", ((offset + 1) * sizeof (target_mgreg_t)) - 4 + 4);
2438 #elif defined(TARGET_ARM64)
2439 arm64_emit_static_rgctx_trampoline (acfg, offset, tramp_size);
2440 #elif defined(TARGET_POWERPC)
2441 guint8 buf [128];
2442 guint8 *code;
2443
2444 *tramp_size = 4;
2445 code = buf;
2446
2447 /*
2448 * PPC has no ip relative addressing, so we need to compute the address
2449 * of the mscorlib got. That is slow and complex, so instead, we store it
2450 * in the second got slot of every aot image. The caller already computed
2451 * the address of its got and placed it into r30.
2452 */
2453 emit_unset_mode (acfg);
2454 /* Load mscorlib got address */
2455 fprintf (acfg->fp, "%s 0, %d(30)\n", PPC_LD_OP, (int)sizeof (target_mgreg_t));
2456 /* Load rgctx */
2457 fprintf (acfg->fp, "lis 11, %d@h\n", (int)(offset * sizeof (target_mgreg_t)));
2458 fprintf (acfg->fp, "ori 11, 11, %d@l\n", (int)(offset * sizeof (target_mgreg_t)));
2459 fprintf (acfg->fp, "%s %d, 11, 0\n", PPC_LDX_OP, MONO_ARCH_RGCTX_REG);
2460 /* Load target address */
2461 fprintf (acfg->fp, "lis 11, %d@h\n", (int)((offset + 1) * sizeof (target_mgreg_t)));
2462 fprintf (acfg->fp, "ori 11, 11, %d@l\n", (int)((offset + 1) * sizeof (target_mgreg_t)));
2463 fprintf (acfg->fp, "%s 11, 11, 0\n", PPC_LDX_OP);
2464 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
2465 fprintf (acfg->fp, "%s 2, %d(11)\n", PPC_LD_OP, (int)sizeof (target_mgreg_t));
2466 fprintf (acfg->fp, "%s 11, 0(11)\n", PPC_LD_OP);
2467 #endif
2468 fprintf (acfg->fp, "mtctr 11\n");
2469 /* Branch to the target address */
2470 fprintf (acfg->fp, "bctr\n");
2471
2472 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
2473 *tramp_size = 11 * 4;
2474 #else
2475 *tramp_size = 9 * 4;
2476 #endif
2477
2478 #elif defined(TARGET_X86)
2479 guint8 buf [128];
2480 guint8 *code;
2481
2482 /* Similar to the PPC code above */
2483
2484 g_assert (MONO_ARCH_RGCTX_REG != X86_ECX);
2485
2486 code = buf;
2487 /* Load mscorlib got address */
2488 x86_mov_reg_membase (code, X86_ECX, MONO_ARCH_GOT_REG, sizeof (target_mgreg_t), 4);
2489 /* Load arg */
2490 x86_mov_reg_membase (code, MONO_ARCH_RGCTX_REG, X86_ECX, offset * sizeof (target_mgreg_t), 4);
2491 /* Branch to the target address */
2492 x86_jump_membase (code, X86_ECX, (offset + 1) * sizeof (target_mgreg_t));
2493
2494 emit_bytes (acfg, buf, code - buf);
2495
2496 *tramp_size = 15;
2497 g_assert (code - buf == *tramp_size);
2498 #else
2499 g_assert_not_reached ();
2500 #endif
2501 }
2502
2503 /*
2504 * arch_emit_imt_trampoline:
2505 *
2506 * Emit an IMT trampoline usable in full-aot mode. The trampoline uses 1 got slot which
2507 * points to an array of pointer pairs. The pairs of the form [key, ptr], where
2508 * key is the IMT key, and ptr holds the address of a memory location holding
2509 * the address to branch to if the IMT arg matches the key. The array is
2510 * terminated by a pair whose key is NULL, and whose ptr is the address of the
2511 * fail_tramp.
2512 * TRAMP_SIZE is set to the size of the emitted trampoline.
2513 */
2514 static void
2515 arch_emit_imt_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
2516 {
2517 #if defined(TARGET_AMD64)
2518 guint8 *buf, *code;
2519 guint8 *labels [16];
2520 guint8 mov_buf[3];
2521 guint8 *mov_buf_ptr = mov_buf;
2522
2523 const int kSizeOfMove = 7;
2524
2525 code = buf = (guint8 *)g_malloc (256);
2526
2527 /* FIXME: Optimize this, i.e. use binary search etc. */
2528 /* Maybe move the body into a separate function (slower, but much smaller) */
2529
2530 /* MONO_ARCH_IMT_SCRATCH_REG is a free register */
2531
2532 if (acfg->llvm) {
2533 emit_unset_mode (acfg);
2534 fprintf (acfg->fp, "mov %s+%d(%%rip), %s\n", acfg->got_symbol, (int)(offset * sizeof (target_mgreg_t)), mono_arch_regname (MONO_ARCH_IMT_SCRATCH_REG));
2535 }
2536
2537 labels [0] = code;
2538 amd64_alu_membase_imm (code, X86_CMP, MONO_ARCH_IMT_SCRATCH_REG, 0, 0);
2539 labels [1] = code;
2540 amd64_branch8 (code, X86_CC_Z, 0, FALSE);
2541
2542 /* Check key */
2543 amd64_alu_membase_reg_size (code, X86_CMP, MONO_ARCH_IMT_SCRATCH_REG, 0, MONO_ARCH_IMT_REG, sizeof (target_mgreg_t));
2544 labels [2] = code;
2545 amd64_branch8 (code, X86_CC_Z, 0, FALSE);
2546
2547 /* Loop footer */
2548 amd64_alu_reg_imm (code, X86_ADD, MONO_ARCH_IMT_SCRATCH_REG, 2 * sizeof (target_mgreg_t));
2549 amd64_jump_code (code, labels [0]);
2550
2551 /* Match */
2552 mono_amd64_patch (labels [2], code);
2553 amd64_mov_reg_membase (code, MONO_ARCH_IMT_SCRATCH_REG, MONO_ARCH_IMT_SCRATCH_REG, sizeof (target_mgreg_t), sizeof (target_mgreg_t));
2554 amd64_jump_membase (code, MONO_ARCH_IMT_SCRATCH_REG, 0);
2555
2556 /* No match */
2557 mono_amd64_patch (labels [1], code);
2558 /* Load fail tramp */
2559 amd64_alu_reg_imm (code, X86_ADD, MONO_ARCH_IMT_SCRATCH_REG, sizeof (target_mgreg_t));
2560 /* Check if there is a fail tramp */
2561 amd64_alu_membase_imm (code, X86_CMP, MONO_ARCH_IMT_SCRATCH_REG, 0, 0);
2562 labels [3] = code;
2563 amd64_branch8 (code, X86_CC_Z, 0, FALSE);
2564 /* Jump to fail tramp */
2565 amd64_jump_membase (code, MONO_ARCH_IMT_SCRATCH_REG, 0);
2566
2567 /* Fail */
2568 mono_amd64_patch (labels [3], code);
2569 x86_breakpoint (code);
2570
2571 if (!acfg->llvm) {
2572 /* mov <OFFSET>(%rip), MONO_ARCH_IMT_SCRATCH_REG */
2573 amd64_emit_rex (mov_buf_ptr, sizeof(gpointer), MONO_ARCH_IMT_SCRATCH_REG, 0, AMD64_RIP);
2574 *(mov_buf_ptr)++ = (unsigned char)0x8b; /* mov opcode */
2575 x86_address_byte (mov_buf_ptr, 0, MONO_ARCH_IMT_SCRATCH_REG & 0x7, 5);
2576 emit_bytes (acfg, mov_buf, mov_buf_ptr - mov_buf);
2577 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) - 4);
2578 }
2579 emit_bytes (acfg, buf, code - buf);
2580
2581 *tramp_size = code - buf + kSizeOfMove;
2582
2583 g_free (buf);
2584
2585 #elif defined(TARGET_X86)
2586 guint8 *buf, *code;
2587 guint8 *labels [16];
2588
2589 code = buf = g_malloc (256);
2590
2591 /* Allocate a temporary stack slot */
2592 x86_push_reg (code, X86_EAX);
2593 /* Save EAX */
2594 x86_push_reg (code, X86_EAX);
2595
2596 /* Load mscorlib got address */
2597 x86_mov_reg_membase (code, X86_EAX, MONO_ARCH_GOT_REG, sizeof (target_mgreg_t), 4);
2598 /* Load arg */
2599 x86_mov_reg_membase (code, X86_EAX, X86_EAX, offset * sizeof (target_mgreg_t), 4);
2600
2601 labels [0] = code;
2602 x86_alu_membase_imm (code, X86_CMP, X86_EAX, 0, 0);
2603 labels [1] = code;
2604 x86_branch8 (code, X86_CC_Z, FALSE, 0);
2605
2606 /* Check key */
2607 x86_alu_membase_reg (code, X86_CMP, X86_EAX, 0, MONO_ARCH_IMT_REG);
2608 labels [2] = code;
2609 x86_branch8 (code, X86_CC_Z, FALSE, 0);
2610
2611 /* Loop footer */
2612 x86_alu_reg_imm (code, X86_ADD, X86_EAX, 2 * sizeof (target_mgreg_t));
2613 x86_jump_code (code, labels [0]);
2614
2615 /* Match */
2616 mono_x86_patch (labels [2], code);
2617 x86_mov_reg_membase (code, X86_EAX, X86_EAX, sizeof (target_mgreg_t), 4);
2618 x86_mov_reg_membase (code, X86_EAX, X86_EAX, 0, 4);
2619 /* Save the target address to the temporary stack location */
2620 x86_mov_membase_reg (code, X86_ESP, 4, X86_EAX, 4);
2621 /* Restore EAX */
2622 x86_pop_reg (code, X86_EAX);
2623 /* Jump to the target address */
2624 x86_ret (code);
2625
2626 /* No match */
2627 mono_x86_patch (labels [1], code);
2628 /* Load fail tramp */
2629 x86_mov_reg_membase (code, X86_EAX, X86_EAX, sizeof (target_mgreg_t), 4);
2630 x86_alu_membase_imm (code, X86_CMP, X86_EAX, 0, 0);
2631 labels [3] = code;
2632 x86_branch8 (code, X86_CC_Z, FALSE, 0);
2633 /* Jump to fail tramp */
2634 x86_mov_membase_reg (code, X86_ESP, 4, X86_EAX, 4);
2635 x86_pop_reg (code, X86_EAX);
2636 x86_ret (code);
2637
2638 /* Fail */
2639 mono_x86_patch (labels [3], code);
2640 x86_breakpoint (code);
2641
2642 emit_bytes (acfg, buf, code - buf);
2643
2644 *tramp_size = code - buf;
2645
2646 g_free (buf);
2647
2648 #elif defined(TARGET_ARM)
2649 guint8 buf [128];
2650 guint8 *code, *code2, *labels [16];
2651
2652 code = buf;
2653
2654 /* The IMT method is in v5 */
2655
2656 /* Need at least two free registers, plus a slot for storing the pc */
2657 ARM_PUSH (code, (1 << ARMREG_R0)|(1 << ARMREG_R1)|(1 << ARMREG_R2));
2658 labels [0] = code;
2659 /* Load the parameter from the GOT */
2660 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_PC, 0);
2661 ARM_LDR_REG_REG (code, ARMREG_R0, ARMREG_PC, ARMREG_R0);
2662
2663 labels [1] = code;
2664 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_R0, 0);
2665 ARM_CMP_REG_REG (code, ARMREG_R1, ARMREG_V5);
2666 labels [2] = code;
2667 ARM_B_COND (code, ARMCOND_EQ, 0);
2668
2669 /* End-of-loop check */
2670 ARM_CMP_REG_IMM (code, ARMREG_R1, 0, 0);
2671 labels [3] = code;
2672 ARM_B_COND (code, ARMCOND_EQ, 0);
2673
2674 /* Loop footer */
2675 ARM_ADD_REG_IMM8 (code, ARMREG_R0, ARMREG_R0, sizeof (target_mgreg_t) * 2);
2676 labels [4] = code;
2677 ARM_B (code, 0);
2678 arm_patch (labels [4], labels [1]);
2679
2680 /* Match */
2681 arm_patch (labels [2], code);
2682 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_R0, 4);
2683 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_R0, 0);
2684 /* Save it to the third stack slot */
2685 ARM_STR_IMM (code, ARMREG_R0, ARMREG_SP, 8);
2686 /* Restore the registers and branch */
2687 ARM_POP (code, (1 << ARMREG_R0)|(1 << ARMREG_R1)|(1 << ARMREG_PC));
2688
2689 /* No match */
2690 arm_patch (labels [3], code);
2691 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_R0, 4);
2692 ARM_STR_IMM (code, ARMREG_R0, ARMREG_SP, 8);
2693 ARM_POP (code, (1 << ARMREG_R0)|(1 << ARMREG_R1)|(1 << ARMREG_PC));
2694
2695 /* Fixup offset */
2696 code2 = labels [0];
2697 ARM_LDR_IMM (code2, ARMREG_R0, ARMREG_PC, (code - (labels [0] + 8)));
2698
2699 emit_bytes (acfg, buf, code - buf);
2700 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) + (code - (labels [0] + 8)) - 4);
2701
2702 *tramp_size = code - buf + 4;
2703 #elif defined(TARGET_ARM64)
2704 arm64_emit_imt_trampoline (acfg, offset, tramp_size);
2705 #elif defined(TARGET_POWERPC)
2706 guint8 buf [128];
2707 guint8 *code, *labels [16];
2708
2709 code = buf;
2710
2711 /* Load the mscorlib got address */
2712 ppc_ldptr (code, ppc_r12, sizeof (target_mgreg_t), ppc_r30);
2713 /* Load the parameter from the GOT */
2714 ppc_load (code, ppc_r0, offset * sizeof (target_mgreg_t));
2715 ppc_ldptr_indexed (code, ppc_r12, ppc_r12, ppc_r0);
2716
2717 /* Load and check key */
2718 labels [1] = code;
2719 ppc_ldptr (code, ppc_r0, 0, ppc_r12);
2720 ppc_cmp (code, 0, sizeof (target_mgreg_t) == 8 ? 1 : 0, ppc_r0, MONO_ARCH_IMT_REG);
2721 labels [2] = code;
2722 ppc_bc (code, PPC_BR_TRUE, PPC_BR_EQ, 0);
2723
2724 /* End-of-loop check */
2725 ppc_cmpi (code, 0, sizeof (target_mgreg_t) == 8 ? 1 : 0, ppc_r0, 0);
2726 labels [3] = code;
2727 ppc_bc (code, PPC_BR_TRUE, PPC_BR_EQ, 0);
2728
2729 /* Loop footer */
2730 ppc_addi (code, ppc_r12, ppc_r12, 2 * sizeof (target_mgreg_t));
2731 labels [4] = code;
2732 ppc_b (code, 0);
2733 mono_ppc_patch (labels [4], labels [1]);
2734
2735 /* Match */
2736 mono_ppc_patch (labels [2], code);
2737 ppc_ldptr (code, ppc_r12, sizeof (target_mgreg_t), ppc_r12);
2738 /* r12 now contains the value of the vtable slot */
2739 /* this is not a function descriptor on ppc64 */
2740 ppc_ldptr (code, ppc_r12, 0, ppc_r12);
2741 ppc_mtctr (code, ppc_r12);
2742 ppc_bcctr (code, PPC_BR_ALWAYS, 0);
2743
2744 /* Fail */
2745 mono_ppc_patch (labels [3], code);
2746 /* FIXME: */
2747 ppc_break (code);
2748
2749 *tramp_size = code - buf;
2750
2751 emit_bytes (acfg, buf, code - buf);
2752 #else
2753 g_assert_not_reached ();
2754 #endif
2755 }
2756
2757
2758 #if defined (TARGET_AMD64)
2759
2760 static void
2761 amd64_emit_load_got_slot (MonoAotCompile *acfg, int dreg, int got_slot)
2762 {
2763
2764 g_assert (acfg->fp);
2765 emit_unset_mode (acfg);
2766
2767 fprintf (acfg->fp, "mov %s+%d(%%rip), %s\n", acfg->got_symbol, (unsigned int) ((got_slot * sizeof (target_mgreg_t))), mono_arch_regname (dreg));
2768 }
2769
2770 #endif
2771
2772
2773 /*
2774 * arch_emit_gsharedvt_arg_trampoline:
2775 *
2776 * Emit code for a gsharedvt arg trampoline. OFFSET is the offset of the first of
2777 * two GOT slots which contain the argument, and the code to jump to.
2778 * TRAMP_SIZE is set to the size of the emitted trampoline.
2779 * These kinds of trampolines cannot be enumerated statically, since there could
2780 * be one trampoline per method instantiation, so we emit the same code for all
2781 * trampolines, and parameterize them using two GOT slots.
2782 */
2783 static void
2784 arch_emit_gsharedvt_arg_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
2785 {
2786 #if defined(TARGET_X86)
2787 guint8 buf [128];
2788 guint8 *code;
2789
2790 /* Similar to the PPC code above */
2791
2792 g_assert (MONO_ARCH_RGCTX_REG != X86_ECX);
2793
2794 code = buf;
2795 /* Load mscorlib got address */
2796 x86_mov_reg_membase (code, X86_ECX, MONO_ARCH_GOT_REG, sizeof (target_mgreg_t), 4);
2797 /* Load arg */
2798 x86_mov_reg_membase (code, X86_EAX, X86_ECX, offset * sizeof (target_mgreg_t), 4);
2799 /* Branch to the target address */
2800 x86_jump_membase (code, X86_ECX, (offset + 1) * sizeof (target_mgreg_t));
2801
2802 emit_bytes (acfg, buf, code - buf);
2803
2804 *tramp_size = 15;
2805 g_assert (code - buf == *tramp_size);
2806 #elif defined(TARGET_ARM)
2807 guint8 buf [128];
2808 guint8 *code;
2809
2810 /* The same as mono_arch_get_gsharedvt_arg_trampoline (), but for AOT */
2811 /* Similar to arch_emit_specific_trampoline () */
2812 *tramp_size = 24;
2813 code = buf;
2814 ARM_PUSH (code, (1 << ARMREG_R0) | (1 << ARMREG_R1) | (1 << ARMREG_R2) | (1 << ARMREG_R3));
2815 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 8);
2816 /* Load the arg value from the GOT */
2817 ARM_LDR_REG_REG (code, ARMREG_R0, ARMREG_PC, ARMREG_R1);
2818 /* Load the addr from the GOT */
2819 ARM_LDR_REG_REG (code, ARMREG_R1, ARMREG_PC, ARMREG_R1);
2820 /* Branch to it */
2821 ARM_BX (code, ARMREG_R1);
2822
2823 g_assert (code - buf == 20);
2824
2825 /* Emit it */
2826 emit_bytes (acfg, buf, code - buf);
2827 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) + 4);
2828 #elif defined(TARGET_ARM64)
2829 arm64_emit_gsharedvt_arg_trampoline (acfg, offset, tramp_size);
2830 #elif defined (TARGET_AMD64)
2831
2832 amd64_emit_load_got_slot (acfg, AMD64_RAX, offset);
2833 amd64_emit_load_got_slot (acfg, MONO_ARCH_IMT_SCRATCH_REG, offset + 1);
2834 g_assert (AMD64_R11 == MONO_ARCH_IMT_SCRATCH_REG);
2835 fprintf (acfg->fp, "jmp *%%r11\n");
2836
2837 *tramp_size = 0x11;
2838 #else
2839 g_assert_not_reached ();
2840 #endif
2841 }
2842
2843 static void
2844 arch_emit_ftnptr_arg_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
2845 {
2846 #if defined(TARGET_ARM)
2847 guint8 buf [128];
2848 guint8 *code;
2849
2850 *tramp_size = 32;
2851 code = buf;
2852
2853 /* Load target address and push it on stack */
2854 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 16);
2855 ARM_LDR_REG_REG (code, ARMREG_IP, ARMREG_PC, ARMREG_IP);
2856 ARM_PUSH (code, 1 << ARMREG_IP);
2857 /* Load argument in ARMREG_IP */
2858 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 8);
2859 ARM_LDR_REG_REG (code, ARMREG_IP, ARMREG_PC, ARMREG_IP);
2860 /* Branch */
2861 ARM_POP (code, 1 << ARMREG_PC);
2862
2863 g_assert (code - buf == 24);
2864
2865 /* Emit it */
2866 emit_bytes (acfg, buf, code - buf);
2867 emit_symbol_diff (acfg, acfg->got_symbol, ".", ((offset + 1) * sizeof (target_mgreg_t)) + 12); // offset from ldr pc to addr
2868 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) + 4); // offset from ldr pc to arg
2869 #else
2870 g_assert_not_reached ();
2871 #endif
2872 }
2873
2874 static void
2875 arch_emit_unbox_arbitrary_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size)
2876 {
2877 #if defined(TARGET_ARM64)
2878 emit_unset_mode (acfg);
2879 fprintf (acfg->fp, "add x0, x0, %d\n", (int)(MONO_ABI_SIZEOF (MonoObject)));
2880 arm64_emit_load_got_slot (acfg, ARMREG_R17, offset);
2881 fprintf (acfg->fp, "br x17\n");
2882 *tramp_size = 5 * 4;
2883 #elif defined (TARGET_AMD64)
2884 guint8 buf [32];
2885 guint8 *code;
2886 int this_reg;
2887
2888 this_reg = mono_arch_get_this_arg_reg (NULL);
2889 code = buf;
2890 amd64_alu_reg_imm (code, X86_ADD, this_reg, MONO_ABI_SIZEOF (MonoObject));
2891 emit_bytes (acfg, buf, code - buf);
2892
2893 amd64_emit_load_got_slot (acfg, AMD64_RAX, offset);
2894 fprintf (acfg->fp, "jmp *%%rax\n");
2895
2896 *tramp_size = 13;
2897 #elif defined (TARGET_ARM)
2898 guint8 buf [32];
2899 guint8 *code, *label;
2900
2901 code = buf;
2902 /* Unbox */
2903 ARM_ADD_REG_IMM8 (code, ARMREG_R0, ARMREG_R0, MONO_ABI_SIZEOF (MonoObject));
2904
2905 label = code;
2906 /* Calculate GOT slot */
2907 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0);
2908 /* Load target addr into PC*/
2909 ARM_LDR_REG_REG (code, ARMREG_PC, ARMREG_PC, ARMREG_IP);
2910
2911 g_assert (code - buf == 12);
2912
2913 /* Emit it */
2914 emit_bytes (acfg, buf, code - buf);
2915 emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) + (code - (label + 8)) - 4);
2916 *tramp_size = 4 * 4;
2917 #else
2918 g_error ("NOT IMPLEMENTED: needed for AOT<>interp mixed mode transition");
2919 #endif
2920 }
2921
2922 /* END OF ARCH SPECIFIC CODE */
2923
2924 static guint32
2925 mono_get_field_token (MonoClassField *field)
2926 {
2927 MonoClass *klass = field->parent;
2928 int i;
2929
2930 int fcount = mono_class_get_field_count (klass);
2931 MonoClassField *klass_fields = m_class_get_fields (klass);
2932 for (i = 0; i < fcount; ++i) {
2933 if (field == &klass_fields [i])
2934 return MONO_TOKEN_FIELD_DEF | (mono_class_get_first_field_idx (klass) + 1 + i);
2935 }
2936
2937 g_assert_not_reached ();
2938 return 0;
2939 }
2940
2941 static void
2942 encode_value (gint32 value, guint8 *buf, guint8 **endbuf)
2943 {
2944 guint8 *p = buf;
2945
2946 //printf ("ENCODE: %d 0x%x.\n", value, value);
2947
2948 /*
2949 * Same encoding as the one used in the metadata, extended to handle values
2950 * greater than 0x1fffffff.
2951 */
2952 if ((value >= 0) && (value <= 127))
2953 *p++ = value;
2954 else if ((value >= 0) && (value <= 16383)) {
2955 p [0] = 0x80 | (value >> 8);
2956 p [1] = value & 0xff;
2957 p += 2;
2958 } else if ((value >= 0) && (value <= 0x1fffffff)) {
2959 p [0] = (value >> 24) | 0xc0;
2960 p [1] = (value >> 16) & 0xff;
2961 p [2] = (value >> 8) & 0xff;
2962 p [3] = value & 0xff;
2963 p += 4;
2964 }
2965 else {
2966 p [0] = 0xff;
2967 p [1] = (value >> 24) & 0xff;
2968 p [2] = (value >> 16) & 0xff;
2969 p [3] = (value >> 8) & 0xff;
2970 p [4] = value & 0xff;
2971 p += 5;
2972 }
2973 if (endbuf)
2974 *endbuf = p;
2975 }
2976
2977 static void
2978 stream_init (MonoDynamicStream *sh)
2979 {
2980 sh->index = 0;
2981 sh->alloc_size = 4096;
2982 sh->data = (char *)g_malloc (4096);
2983
2984 /* So offsets are > 0 */
2985 sh->data [0] = 0;
2986 sh->index ++;
2987 }
2988
2989 static void
2990 make_room_in_stream (MonoDynamicStream *stream, int size)
2991 {
2992 if (size <= stream->alloc_size)
2993 return;
2994
2995 while (stream->alloc_size <= size) {
2996 if (stream->alloc_size < 4096)
2997 stream->alloc_size = 4096;
2998 else
2999 stream->alloc_size *= 2;
3000 }
3001
3002 stream->data = (char *)g_realloc (stream->data, stream->alloc_size);
3003 }
3004
3005 static guint32
3006 add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
3007 {
3008 guint32 idx;
3009
3010 make_room_in_stream (stream, stream->index + len);
3011 memcpy (stream->data + stream->index, data, len);
3012 idx = stream->index;
3013 stream->index += len;
3014 return idx;
3015 }
3016
3017 /*
3018 * add_to_blob:
3019 *
3020 * Add data to the binary blob inside the aot image. Returns the offset inside the
3021 * blob where the data was stored.
3022 */
3023 static guint32
3024 add_to_blob (MonoAotCompile *acfg, const guint8 *data, guint32 data_len)
3025 {
3026 g_assert (!acfg->blob_closed);
3027
3028 if (acfg->blob.alloc_size == 0)
3029 stream_init (&acfg->blob);
3030
3031 acfg->stats.blob_size += data_len;
3032
3033 return add_stream_data (&acfg->blob, (char*)data, data_len);
3034 }
3035
3036 static guint32
3037 add_to_blob_aligned (MonoAotCompile *acfg, const guint8 *data, guint32 data_len, guint32 align)
3038 {
3039 char buf [4] = {0};
3040 guint32 count;
3041
3042 if (acfg->blob.alloc_size == 0)
3043 stream_init (&acfg->blob);
3044
3045 count = acfg->blob.index % align;
3046
3047 /* we assume the stream data will be aligned */
3048 if (count)
3049 add_stream_data (&acfg->blob, buf, 4 - count);
3050
3051 return add_stream_data (&acfg->blob, (char*)data, data_len);
3052 }
3053
3054 /* Emit a table of data into the aot image */
3055 static void
3056 emit_aot_data (MonoAotCompile *acfg, MonoAotFileTable table, const char *symbol, guint8 *data, int size)
3057 {
3058 if (acfg->data_outfile) {
3059 acfg->table_offsets [(int)table] = acfg->datafile_offset;
3060 fwrite (data,1, size, acfg->data_outfile);
3061 acfg->datafile_offset += size;
3062 // align the data to 8 bytes. Put zeros in the file (so that every build results in consistent output).
3063 int align = 8 - size % 8;
3064 acfg->datafile_offset += align;
3065 guint8 align_buf [16];
3066 memset (&align_buf, 0, sizeof (align_buf));
3067 fwrite (align_buf, align, 1, acfg->data_outfile);
3068 } else if (acfg->llvm) {
3069 mono_llvm_emit_aot_data (symbol, data, size);
3070 } else {
3071 emit_section_change (acfg, RODATA_SECT, 0);
3072 emit_alignment (acfg, 8);
3073 emit_label (acfg, symbol);
3074 emit_bytes (acfg, data, size);
3075 }
3076 }
3077
3078 /*
3079 * emit_offset_table:
3080 *
3081 * Emit a table of increasing offsets in a compact form using differential encoding.
3082 * There is an index entry for each GROUP_SIZE number of entries. The greater the
3083 * group size, the more compact the table becomes, but the slower it becomes to compute
3084 * a given entry. Returns the size of the table.
3085 */
3086 static guint32
3087 emit_offset_table (MonoAotCompile *acfg, const char *symbol, MonoAotFileTable table, int noffsets, int group_size, gint32 *offsets)
3088 {
3089 gint32 current_offset;
3090 int i, buf_size, ngroups, index_entry_size;
3091 guint8 *p, *buf;
3092 guint8 *data_p, *data_buf;
3093 guint32 *index_offsets;
3094
3095 ngroups = (noffsets + (group_size - 1)) / group_size;
3096
3097 index_offsets = g_new0 (guint32, ngroups);
3098
3099 buf_size = noffsets * 4;
3100 p = buf = (guint8 *)g_malloc0 (buf_size);
3101
3102 current_offset = 0;
3103 for (i = 0; i < noffsets; ++i) {
3104 //printf ("D: %d -> %d\n", i, offsets [i]);
3105 if ((i % group_size) == 0) {
3106 index_offsets [i / group_size] = p - buf;
3107 /* Emit the full value for these entries */
3108 encode_value (offsets [i], p, &p);
3109 } else {
3110 /* The offsets are allowed to be non-increasing */
3111 //g_assert (offsets [i] >= current_offset);
3112 encode_value (offsets [i] - current_offset, p, &p);
3113 }
3114 current_offset = offsets [i];
3115 }
3116 data_buf = buf;
3117 data_p = p;
3118
3119 if (ngroups && index_offsets [ngroups - 1] < 65000)
3120 index_entry_size = 2;
3121 else
3122 index_entry_size = 4;
3123
3124 buf_size = (data_p - data_buf) + (ngroups * 4) + 16;
3125 p = buf = (guint8 *)g_malloc0 (buf_size);
3126
3127 /* Emit the header */
3128 encode_int (noffsets, p, &p);
3129 encode_int (group_size, p, &p);
3130 encode_int (ngroups, p, &p);
3131 encode_int (index_entry_size, p, &p);
3132
3133 /* Emit the index */
3134 for (i = 0; i < ngroups; ++i) {
3135 if (index_entry_size == 2)
3136 encode_int16 (index_offsets [i], p, &p);
3137 else
3138 encode_int (index_offsets [i], p, &p);
3139 }
3140 /* Emit the data */
3141 memcpy (p, data_buf, data_p - data_buf);
3142 p += data_p - data_buf;
3143
3144 g_assert (p - buf <= buf_size);
3145
3146 emit_aot_data (acfg, table, symbol, buf, p - buf);
3147
3148 g_free (buf);
3149 g_free (data_buf);
3150
3151 return (int)(p - buf);
3152 }
3153
3154 static guint32
3155 get_image_index (MonoAotCompile *cfg, MonoImage *image)
3156 {
3157 guint32 index;
3158
3159 index = GPOINTER_TO_UINT (g_hash_table_lookup (cfg->image_hash, image));
3160 if (index)
3161 return index - 1;
3162 else {
3163 index = g_hash_table_size (cfg->image_hash);
3164 g_hash_table_insert (cfg->image_hash, image, GUINT_TO_POINTER (index + 1));
3165 g_ptr_array_add (cfg->image_table, image);
3166 return index;
3167 }
3168 }
3169
3170 static guint32
3171 find_typespec_for_class (MonoAotCompile *acfg, MonoClass *klass)
3172 {
3173 int i;
3174 int len = acfg->image->tables [MONO_TABLE_TYPESPEC].rows;
3175
3176 /* FIXME: Search referenced images as well */
3177 if (!acfg->typespec_classes) {
3178 acfg->typespec_classes = g_hash_table_new (NULL, NULL);
3179 for (i = 0; i < len; i++) {
3180 ERROR_DECL (error);
3181 int typespec = MONO_TOKEN_TYPE_SPEC | (i + 1);
3182 MonoClass *klass_key = mono_class_get_and_inflate_typespec_checked (acfg->image, typespec, NULL, error);
3183 if (!is_ok (error)) {
3184 mono_error_cleanup (error);
3185 continue;
3186 }
3187 g_hash_table_insert (acfg->typespec_classes, klass_key, GINT_TO_POINTER (typespec));
3188 }
3189 }
3190 return GPOINTER_TO_INT (g_hash_table_lookup (acfg->typespec_classes, klass));
3191 }
3192
3193 static void
3194 encode_method_ref (MonoAotCompile *acfg, MonoMethod *method, guint8 *buf, guint8 **endbuf);
3195
3196 static void
3197 encode_klass_ref (MonoAotCompile *acfg, MonoClass *klass, guint8 *buf, guint8 **endbuf);
3198
3199 static void
3200 encode_ginst (MonoAotCompile *acfg, MonoGenericInst *inst, guint8 *buf, guint8 **endbuf);
3201
3202 static void
3203 encode_type (MonoAotCompile *acfg, MonoType *t, guint8 *buf, guint8 **endbuf);
3204
3205 static guint32
3206 get_shared_ginst_ref (MonoAotCompile *acfg, MonoGenericInst *ginst);
3207
3208 static void
3209 encode_klass_ref_inner (MonoAotCompile *acfg, MonoClass *klass, guint8 *buf, guint8 **endbuf)
3210 {
3211 guint8 *p = buf;
3212
3213 /*
3214 * The encoding begins with one of the MONO_AOT_TYPEREF values, followed by additional
3215 * information.
3216 */
3217
3218 if (mono_class_is_ginst (klass)) {
3219 guint32 token;
3220 g_assert (m_class_get_type_token (klass));
3221
3222 /* Find a typespec for a class if possible */
3223 token = find_typespec_for_class (acfg, klass);
3224 if (token) {
3225 encode_value (MONO_AOT_TYPEREF_TYPESPEC_TOKEN, p, &p);
3226 encode_value (token, p, &p);
3227 } else {
3228 MonoClass *gclass = mono_class_get_generic_class (klass)->container_class;
3229 MonoGenericInst *inst = mono_class_get_generic_class (klass)->context.class_inst;
3230 static int count = 0;
3231 guint8 *p1 = p;
3232
3233 encode_value (MONO_AOT_TYPEREF_GINST, p, &p);
3234 encode_klass_ref (acfg, gclass, p, &p);
3235 guint32 offset = get_shared_ginst_ref (acfg, inst);
3236 encode_value (offset, p, &p);
3237
3238 count += p - p1;
3239 }
3240 } else if (m_class_get_type_token (klass)) {
3241 int iindex = get_image_index (acfg, m_class_get_image (klass));
3242
3243 g_assert (mono_metadata_token_code (m_class_get_type_token (klass)) == MONO_TOKEN_TYPE_DEF);
3244 if (iindex == 0) {
3245 encode_value (MONO_AOT_TYPEREF_TYPEDEF_INDEX, p, &p);
3246 encode_value (m_class_get_type_token (klass) - MONO_TOKEN_TYPE_DEF, p, &p);
3247 } else {
3248 encode_value (MONO_AOT_TYPEREF_TYPEDEF_INDEX_IMAGE, p, &p);
3249 encode_value (m_class_get_type_token (klass) - MONO_TOKEN_TYPE_DEF, p, &p);
3250 encode_value (get_image_index (acfg, m_class_get_image (klass)), p, &p);
3251 }
3252 } else if ((m_class_get_byval_arg (klass)->type == MONO_TYPE_VAR) || (m_class_get_byval_arg (klass)->type == MONO_TYPE_MVAR)) {
3253 MonoGenericContainer *container = mono_type_get_generic_param_owner (m_class_get_byval_arg (klass));
3254 MonoGenericParam *par = m_class_get_byval_arg (klass)->data.generic_param;
3255
3256 encode_value (MONO_AOT_TYPEREF_VAR, p, &p);
3257
3258 encode_value (par->gshared_constraint ? 1 : 0, p, &p);
3259 if (par->gshared_constraint) {
3260 MonoGSharedGenericParam *gpar = (MonoGSharedGenericParam*)par;
3261 encode_type (acfg, par->gshared_constraint, p, &p);
3262 encode_klass_ref (acfg, mono_class_create_generic_parameter (gpar->parent), p, &p);
3263 } else {
3264 encode_value (m_class_get_byval_arg (klass)->type, p, &p);
3265 encode_value (mono_type_get_generic_param_num (m_class_get_byval_arg (klass)), p, &p);
3266
3267 encode_value (container->is_anonymous ? 0 : 1, p, &p);
3268
3269 if (!container->is_anonymous) {
3270 encode_value (container->is_method, p, &p);
3271 if (container->is_method)
3272 encode_method_ref (acfg, container->owner.method, p, &p);
3273 else
3274 encode_klass_ref (acfg, container->owner.klass, p, &p);
3275 }
3276 }
3277 } else if (m_class_get_byval_arg (klass)->type == MONO_TYPE_PTR) {
3278 encode_value (MONO_AOT_TYPEREF_PTR, p, &p);
3279 encode_type (acfg, m_class_get_byval_arg (klass), p, &p);
3280 } else {
3281 /* Array class */
3282 g_assert (m_class_get_rank (klass) > 0);
3283 encode_value (MONO_AOT_TYPEREF_ARRAY, p, &p);
3284 encode_value (m_class_get_rank (klass), p, &p);
3285 encode_klass_ref (acfg, m_class_get_element_class (klass), p, &p);
3286 }
3287
3288 acfg->stats.class_ref_count++;
3289 acfg->stats.class_ref_size += p - buf;
3290
3291 *endbuf = p;
3292 }
3293
3294 static guint32
3295 get_shared_klass_ref (MonoAotCompile *acfg, MonoClass *klass)
3296 {
3297 guint offset = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->klass_blob_hash, klass));
3298 guint8 *buf2, *p;
3299
3300 if (!offset) {
3301 buf2 = (guint8 *)g_malloc (1024);
3302 p = buf2;
3303
3304 encode_klass_ref_inner (acfg, klass, p, &p);
3305 g_assert (p - buf2 < 1024);
3306
3307 offset = add_to_blob (acfg, buf2, p - buf2);
3308 g_free (buf2);
3309
3310 g_hash_table_insert (acfg->klass_blob_hash, klass, GUINT_TO_POINTER (offset + 1));
3311 } else {
3312 offset --;
3313 }
3314
3315 return offset;
3316 }
3317
3318 /*
3319 * encode_klass_ref:
3320 *
3321 * Encode a reference to KLASS. We use our home-grown encoding instead of the
3322 * standard metadata encoding.
3323 */
3324 static void
3325 encode_klass_ref (MonoAotCompile *acfg, MonoClass *klass, guint8 *buf, guint8 **endbuf)
3326 {
3327 gboolean shared = FALSE;
3328
3329 /*
3330 * The encoding of generic instances is large so emit them only once.
3331 */
3332 if (mono_class_is_ginst (klass)) {
3333 guint32 token;
3334 g_assert (m_class_get_type_token (klass));
3335
3336 /* Find a typespec for a class if possible */
3337 token = find_typespec_for_class (acfg, klass);
3338 if (!token)
3339 shared = TRUE;
3340 } else if ((m_class_get_byval_arg (klass)->type == MONO_TYPE_VAR) || (m_class_get_byval_arg (klass)->type == MONO_TYPE_MVAR)) {
3341 shared = TRUE;
3342 }
3343
3344 if (shared) {
3345 guint8 *p;
3346 guint32 offset = get_shared_klass_ref (acfg, klass);
3347
3348 p = buf;
3349 encode_value (MONO_AOT_TYPEREF_BLOB_INDEX, p, &p);
3350 encode_value (offset, p, &p);
3351 *endbuf = p;
3352 return;
3353 }
3354
3355 encode_klass_ref_inner (acfg, klass, buf, endbuf);
3356 }
3357
3358 static void
3359 encode_field_info (MonoAotCompile *cfg, MonoClassField *field, guint8 *buf, guint8 **endbuf)
3360 {
3361 guint32 token = mono_get_field_token (field);
3362 guint8 *p = buf;
3363
3364 encode_klass_ref (cfg, field->parent, p, &p);
3365 g_assert (mono_metadata_token_code (token) == MONO_TOKEN_FIELD_DEF);
3366 encode_value (token - MONO_TOKEN_FIELD_DEF, p, &p);
3367 *endbuf = p;
3368 }
3369
3370 static void
3371 encode_ginst (MonoAotCompile *acfg, MonoGenericInst *inst, guint8 *buf, guint8 **endbuf)
3372 {
3373 guint8 *p = buf;
3374 int i;
3375
3376 encode_value (inst->type_argc, p, &p);
3377 for (i = 0; i < inst->type_argc; ++i)
3378 encode_klass_ref (acfg, mono_class_from_mono_type_internal (inst->type_argv [i]), p, &p);
3379
3380 acfg->stats.ginst_count++;
3381 acfg->stats.ginst_size += p - buf;
3382
3383 *endbuf = p;
3384 }
3385
3386 static guint32
3387 get_shared_ginst_ref (MonoAotCompile *acfg, MonoGenericInst *ginst)
3388 {
3389 guint32 offset = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->ginst_blob_hash, ginst));
3390 if (!offset) {
3391 guint8 *buf2, *p2;
3392
3393 buf2 = (guint8 *)g_malloc (1024);
3394 p2 = buf2;
3395
3396 encode_ginst (acfg, ginst, p2, &p2);
3397 g_assert (p2 - buf2 < 1024);
3398
3399 offset = add_to_blob (acfg, buf2, p2 - buf2);
3400 g_free (buf2);
3401
3402 g_hash_table_insert (acfg->ginst_blob_hash, ginst, GUINT_TO_POINTER (offset + 1));
3403 } else {
3404 offset --;
3405 }
3406 return offset;
3407 }
3408
3409 static void
3410 encode_generic_context (MonoAotCompile *acfg, MonoGenericContext *context, guint8 *buf, guint8 **endbuf)
3411 {
3412 guint8 *p = buf;
3413 MonoGenericInst *inst;
3414 guint32 flags = (context->class_inst ? 1 : 0) | (context->method_inst ? 2 : 0);
3415
3416 g_assert (flags);
3417
3418 encode_value (flags, p, &p);
3419 inst = context->class_inst;
3420 if (inst) {
3421 guint32 offset = get_shared_ginst_ref (acfg, inst);
3422 encode_value (offset, p, &p);
3423 }
3424 inst = context->method_inst;
3425 if (inst) {
3426 guint32 offset = get_shared_ginst_ref (acfg, inst);
3427 encode_value (offset, p, &p);
3428 }
3429 *endbuf = p;
3430 }
3431
3432 static void
3433 encode_type (MonoAotCompile *acfg, MonoType *t, guint8 *buf, guint8 **endbuf)
3434 {
3435 guint8 *p = buf;
3436
3437 if (t->has_cmods) {
3438 int count = mono_type_custom_modifier_count (t);
3439
3440 *p = MONO_TYPE_CMOD_REQD;
3441 ++p;
3442
3443 encode_value (count, p, &p);
3444 for (int i = 0; i < count; ++i) {
3445 ERROR_DECL (error);
3446 gboolean required;
3447 MonoType *cmod_type = mono_type_get_custom_modifier (t, i, &required, error);
3448 mono_error_assert_ok (error);
3449 encode_value (required, p, &p);
3450 encode_type (acfg, cmod_type, p, &p);
3451 }
3452 }
3453
3454 /* t->attrs can be ignored */
3455 //g_assert (t->attrs == 0);
3456
3457 if (t->pinned) {
3458 *p = MONO_TYPE_PINNED;
3459 ++p;
3460 }
3461 if (t->byref) {
3462 *p = MONO_TYPE_BYREF;
3463 ++p;
3464 }
3465
3466 *p = t->type;
3467 p ++;
3468
3469 switch (t->type) {
3470 case MONO_TYPE_VOID:
3471 case MONO_TYPE_BOOLEAN:
3472 case MONO_TYPE_CHAR:
3473 case MONO_TYPE_I1:
3474 case MONO_TYPE_U1:
3475 case MONO_TYPE_I2:
3476 case MONO_TYPE_U2:
3477 case MONO_TYPE_I4:
3478 case MONO_TYPE_U4:
3479 case MONO_TYPE_I8:
3480 case MONO_TYPE_U8:
3481 case MONO_TYPE_R4:
3482 case MONO_TYPE_R8:
3483 case MONO_TYPE_I:
3484 case MONO_TYPE_U:
3485 case MONO_TYPE_STRING:
3486 case MONO_TYPE_OBJECT:
3487 case MONO_TYPE_TYPEDBYREF:
3488 break;
3489 case MONO_TYPE_VALUETYPE:
3490 case MONO_TYPE_CLASS:
3491 encode_klass_ref (acfg, mono_class_from_mono_type_internal (t), p, &p);
3492 break;
3493 case MONO_TYPE_SZARRAY:
3494 encode_klass_ref (acfg, t->data.klass, p, &p);
3495 break;
3496 case MONO_TYPE_PTR:
3497 encode_type (acfg, t->data.type, p, &p);
3498 break;
3499 case MONO_TYPE_GENERICINST: {
3500 MonoClass *gclass = t->data.generic_class->container_class;
3501 MonoGenericInst *inst = t->data.generic_class->context.class_inst;
3502
3503 encode_klass_ref (acfg, gclass, p, &p);
3504 encode_ginst (acfg, inst, p, &p);
3505 break;
3506 }
3507 case MONO_TYPE_ARRAY: {
3508 MonoArrayType *array = t->data.array;
3509 int i;
3510
3511 encode_klass_ref (acfg, array->eklass, p, &p);
3512 encode_value (array->rank, p, &p);
3513 encode_value (array->numsizes, p, &p);
3514 for (i = 0; i < array->numsizes; ++i)
3515 encode_value (array->sizes [i], p, &p);
3516 encode_value (array->numlobounds, p, &p);
3517 for (i = 0; i < array->numlobounds; ++i)
3518 encode_value (array->lobounds [i], p, &p);
3519 break;
3520 }
3521 case MONO_TYPE_VAR:
3522 case MONO_TYPE_MVAR:
3523 encode_klass_ref (acfg, mono_class_from_mono_type_internal (t), p, &p);
3524 break;
3525 default:
3526 g_assert_not_reached ();
3527 }
3528
3529 *endbuf = p;
3530 }
3531
3532 static void
3533 encode_signature (MonoAotCompile *acfg, MonoMethodSignature *sig, guint8 *buf, guint8 **endbuf)
3534 {
3535 guint8 *p = buf;
3536 guint32 flags = 0;
3537 int i;
3538
3539 /* Similar to the metadata encoding */
3540 if (sig->generic_param_count)
3541 flags |= 0x10;
3542 if (sig->hasthis)
3543 flags |= 0x20;
3544 if (sig->explicit_this)
3545 flags |= 0x40;
3546 flags |= (sig->call_convention & 0x0F);
3547
3548 *p = flags;
3549 ++p;
3550 if (sig->generic_param_count)
3551 encode_value (sig->generic_param_count, p, &p);
3552 encode_value (sig->param_count, p, &p);
3553
3554 encode_type (acfg, sig->ret, p, &p);
3555 for (i = 0; i < sig->param_count; ++i) {
3556 if (sig->sentinelpos == i) {
3557 *p = MONO_TYPE_SENTINEL;
3558 ++p;
3559 }
3560 encode_type (acfg, sig->params [i], p, &p);
3561 }
3562
3563 *endbuf = p;
3564 }
3565
3566 #define MAX_IMAGE_INDEX 250
3567
3568 static void
3569 encode_method_ref (MonoAotCompile *acfg, MonoMethod *method, guint8 *buf, guint8 **endbuf)
3570 {
3571 guint32 image_index = get_image_index (acfg, m_class_get_image (method->klass));
3572 guint32 token = method->token;
3573 MonoJumpInfoToken *ji;
3574 guint8 *p = buf;
3575
3576 /*
3577 * The encoding for most methods is as follows:
3578 * - image index encoded as a leb128
3579 * - token index encoded as a leb128
3580 * Values of image index >= MONO_AOT_METHODREF_MIN are used to mark additional
3581 * types of method encodings.
3582 */
3583
3584 /* Mark methods which can't use aot trampolines because they need the further
3585 * processing in mono_magic_trampoline () which requires a MonoMethod*.
3586 */
3587 if ((method->is_generic && (method->flags & METHOD_ATTRIBUTE_VIRTUAL)) ||
3588 (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED))
3589 encode_value ((MONO_AOT_METHODREF_NO_AOT_TRAMPOLINE << 24), p, &p);
3590
3591 if (method->wrapper_type) {
3592 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
3593
3594 encode_value ((MONO_AOT_METHODREF_WRAPPER << 24), p, &p);
3595
3596 encode_value (method->wrapper_type, p, &p);
3597
3598 switch (method->wrapper_type) {
3599 case MONO_WRAPPER_REMOTING_INVOKE:
3600 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK:
3601 case MONO_WRAPPER_XDOMAIN_INVOKE: {
3602 MonoMethod *m;
3603
3604 m = mono_marshal_method_from_wrapper (method);
3605 g_assert (m);
3606 encode_method_ref (acfg, m, p, &p);
3607 break;
3608 }
3609 case MONO_WRAPPER_PROXY_ISINST:
3610 case MONO_WRAPPER_LDFLD:
3611 case MONO_WRAPPER_LDFLDA:
3612 case MONO_WRAPPER_STFLD: {
3613 g_assert (info);
3614 encode_klass_ref (acfg, info->d.proxy.klass, p, &p);
3615 break;
3616 }
3617 case MONO_WRAPPER_ALLOC: {
3618 /* The GC name is saved once in MonoAotFileInfo */
3619 g_assert (info->d.alloc.alloc_type != -1);
3620 encode_value (info->d.alloc.alloc_type, p, &p);
3621 break;
3622 }
3623 case MONO_WRAPPER_WRITE_BARRIER: {
3624 g_assert (info);
3625 break;
3626 }
3627 case MONO_WRAPPER_STELEMREF: {
3628 g_assert (info);
3629 encode_value (info->subtype, p, &p);
3630 if (info->subtype == WRAPPER_SUBTYPE_VIRTUAL_STELEMREF)
3631 encode_value (info->d.virtual_stelemref.kind, p, &p);
3632 break;
3633 }
3634 case MONO_WRAPPER_OTHER: {
3635 g_assert (info);
3636 encode_value (info->subtype, p, &p);
3637 if (info->subtype == WRAPPER_SUBTYPE_PTR_TO_STRUCTURE ||
3638 info->subtype == WRAPPER_SUBTYPE_STRUCTURE_TO_PTR)
3639 encode_klass_ref (acfg, method->klass, p, &p);
3640 else if (info->subtype == WRAPPER_SUBTYPE_SYNCHRONIZED_INNER)
3641 encode_method_ref (acfg, info->d.synchronized_inner.method, p, &p);
3642 else if (info->subtype == WRAPPER_SUBTYPE_ARRAY_ACCESSOR)
3643 encode_method_ref (acfg, info->d.array_accessor.method, p, &p);
3644 else if (info->subtype == WRAPPER_SUBTYPE_INTERP_IN)
3645 encode_signature (acfg, info->d.interp_in.sig, p, &p);
3646 else if (info->subtype == WRAPPER_SUBTYPE_GSHAREDVT_IN_SIG)
3647 encode_signature (acfg, info->d.gsharedvt.sig, p, &p);
3648 else if (info->subtype == WRAPPER_SUBTYPE_GSHAREDVT_OUT_SIG)
3649 encode_signature (acfg, info->d.gsharedvt.sig, p, &p);
3650 else if (info->subtype == WRAPPER_SUBTYPE_INTERP_LMF)
3651 encode_value (info->d.icall.jit_icall_id, p, &p);
3652 else if (info->subtype == WRAPPER_SUBTYPE_AOT_INIT)
3653 encode_value (info->d.aot_init.subtype, p, &p);
3654 else if (info->subtype == WRAPPER_SUBTYPE_LLVM_FUNC)
3655 encode_value (info->d.llvm_func.subtype, p, &p);
3656 break;
3657 }
3658 case MONO_WRAPPER_MANAGED_TO_NATIVE: {
3659 g_assert (info);
3660 encode_value (info->subtype, p, &p);
3661 if (info->subtype == WRAPPER_SUBTYPE_ICALL_WRAPPER) {
3662 encode_value (info->d.icall.jit_icall_id, p, &p);
3663 } else if (info->subtype == WRAPPER_SUBTYPE_NATIVE_FUNC_AOT) {
3664 encode_method_ref (acfg, info->d.managed_to_native.method, p, &p);
3665 } else {
3666 g_assert (info->subtype == WRAPPER_SUBTYPE_NONE || info->subtype == WRAPPER_SUBTYPE_PINVOKE);
3667 encode_method_ref (acfg, info->d.managed_to_native.method, p, &p);
3668 }
3669 break;
3670 }
3671 case MONO_WRAPPER_SYNCHRONIZED: {
3672 MonoMethod *m;
3673
3674 m = mono_marshal_method_from_wrapper (method);
3675 g_assert (m);
3676 g_assert (m != method);
3677 encode_method_ref (acfg, m, p, &p);
3678 break;
3679 }
3680 case MONO_WRAPPER_MANAGED_TO_MANAGED: {
3681 g_assert (info);
3682 encode_value (info->subtype, p, &p);
3683
3684 if (info->subtype == WRAPPER_SUBTYPE_ELEMENT_ADDR) {
3685 encode_value (info->d.element_addr.rank, p, &p);
3686 encode_value (info->d.element_addr.elem_size, p, &p);
3687 } else if (info->subtype == WRAPPER_SUBTYPE_STRING_CTOR) {
3688 encode_method_ref (acfg, info->d.string_ctor.method, p, &p);
3689 } else {
3690 g_assert_not_reached ();
3691 }
3692 break;
3693 }
3694 case MONO_WRAPPER_CASTCLASS: {
3695 g_assert (info);
3696 encode_value (info->subtype, p, &p);
3697 break;
3698 }
3699 case MONO_WRAPPER_RUNTIME_INVOKE: {
3700 g_assert (info);
3701 encode_value (info->subtype, p, &p);
3702 if (info->subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_DIRECT || info->subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_VIRTUAL)
3703 encode_method_ref (acfg, info->d.runtime_invoke.method, p, &p);
3704 else if (info->subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_NORMAL)
3705 encode_signature (acfg, info->d.runtime_invoke.sig, p, &p);
3706 break;
3707 }
3708 case MONO_WRAPPER_DELEGATE_INVOKE:
3709 case MONO_WRAPPER_DELEGATE_BEGIN_INVOKE:
3710 case MONO_WRAPPER_DELEGATE_END_INVOKE: {
3711 if (method->is_inflated) {
3712 /* These wrappers are identified by their class */
3713 encode_value (1, p, &p);
3714 encode_klass_ref (acfg, method->klass, p, &p);
3715 } else {
3716 MonoMethodSignature *sig = mono_method_signature_internal (method);
3717 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
3718
3719 encode_value (0, p, &p);
3720 if (method->wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE)
3721 encode_value (info ? info->subtype : 0, p, &p);
3722 encode_signature (acfg, sig, p, &p);
3723 }
3724 break;
3725 }
3726 case MONO_WRAPPER_NATIVE_TO_MANAGED: {
3727 g_assert (info);
3728 encode_method_ref (acfg, info->d.native_to_managed.method, p, &p);
3729 encode_klass_ref (acfg, info->d.native_to_managed.klass, p, &p);
3730 break;
3731 }
3732 default:
3733 g_assert_not_reached ();
3734 }
3735 } else if (mono_method_signature_internal (method)->is_inflated) {
3736 /*
3737 * This is a generic method, find the original token which referenced it and
3738 * encode that.
3739 * Obtain the token from information recorded by the JIT.
3740 */
3741 ji = (MonoJumpInfoToken *)g_hash_table_lookup (acfg->token_info_hash, method);
3742 if (ji) {
3743 image_index = get_image_index (acfg, ji->image);
3744 g_assert (image_index < MAX_IMAGE_INDEX);
3745 token = ji->token;
3746
3747 encode_value ((MONO_AOT_METHODREF_METHODSPEC << 24), p, &p);
3748 encode_value (image_index, p, &p);
3749 encode_value (token, p, &p);
3750 } else if (g_hash_table_lookup (acfg->method_blob_hash, method)) {
3751 /* Already emitted as part of an rgctx fetch */
3752 guint32 offset = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->method_blob_hash, method));
3753 offset --;
3754
3755 encode_value ((MONO_AOT_METHODREF_BLOB_INDEX << 24), p, &p);
3756 encode_value (offset, p, &p);
3757 } else {
3758 MonoMethod *declaring;
3759 MonoGenericContext *context = mono_method_get_context (method);
3760
3761 g_assert (method->is_inflated);
3762 declaring = ((MonoMethodInflated*)method)->declaring;
3763
3764 /*
3765 * This might be a non-generic method of a generic instance, which
3766 * doesn't have a token since the reference is generated by the JIT
3767 * like Nullable:Box/Unbox, or by generic sharing.
3768 */
3769 encode_value ((MONO_AOT_METHODREF_GINST << 24), p, &p);
3770 /* Encode the klass */
3771 encode_klass_ref (acfg, method->klass, p, &p);
3772 /* Encode the method */
3773 image_index = get_image_index (acfg, m_class_get_image (method->klass));
3774 g_assert (image_index < MAX_IMAGE_INDEX);
3775 g_assert (declaring->token);
3776 token = declaring->token;
3777 g_assert (mono_metadata_token_table (token) == MONO_TABLE_METHOD);
3778 encode_value (image_index, p, &p);
3779 encode_value (mono_metadata_token_index (token), p, &p);
3780 encode_generic_context (acfg, context, p, &p);
3781 }
3782 } else if (token == 0) {
3783 /* This might be a method of a constructed type like int[,].Set */
3784 /* Obtain the token from information recorded by the JIT */
3785 ji = (MonoJumpInfoToken *)g_hash_table_lookup (acfg->token_info_hash, method);
3786 if (ji) {
3787 image_index = get_image_index (acfg, ji->image);
3788 g_assert (image_index < MAX_IMAGE_INDEX);
3789 token = ji->token;
3790
3791 encode_value ((MONO_AOT_METHODREF_METHODSPEC << 24), p, &p);
3792 encode_value (image_index, p, &p);
3793 encode_value (token, p, &p);
3794 } else {
3795 /* Array methods */
3796 g_assert (m_class_get_rank (method->klass));
3797
3798 /* Encode directly */
3799 encode_value ((MONO_AOT_METHODREF_ARRAY << 24), p, &p);
3800 encode_klass_ref (acfg, method->klass, p, &p);
3801 if (!strcmp (method->name, ".ctor") && mono_method_signature_internal (method)->param_count == m_class_get_rank (method->klass))
3802 encode_value (0, p, &p);
3803 else if (!strcmp (method->name, ".ctor") && mono_method_signature_internal (method)->param_count == m_class_get_rank (method->klass) * 2)
3804 encode_value (1, p, &p);
3805 else if (!strcmp (method->name, "Get"))
3806 encode_value (2, p, &p);
3807 else if (!strcmp (method->name, "Address"))
3808 encode_value (3, p, &p);
3809 else if (!strcmp (method->name, "Set"))
3810 encode_value (4, p, &p);
3811 else
3812 g_assert_not_reached ();
3813 }
3814 } else {
3815 g_assert (mono_metadata_token_table (token) == MONO_TABLE_METHOD);
3816
3817 if (image_index >= MONO_AOT_METHODREF_MIN) {
3818 encode_value ((MONO_AOT_METHODREF_LARGE_IMAGE_INDEX << 24), p, &p);
3819 encode_value (image_index, p, &p);
3820 encode_value (mono_metadata_token_index (token), p, &p);
3821 } else {
3822 encode_value ((image_index << 24) | mono_metadata_token_index (token), p, &p);
3823 }
3824 }
3825
3826 acfg->stats.method_ref_count++;
3827 acfg->stats.method_ref_size += p - buf;
3828
3829 *endbuf = p;
3830 }
3831
3832 static guint32
3833 get_shared_method_ref (MonoAotCompile *acfg, MonoMethod *method)
3834 {
3835 guint32 offset = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->method_blob_hash, method));
3836 if (!offset) {
3837 guint8 *buf2, *p2;
3838
3839 buf2 = (guint8 *)g_malloc (1024);
3840 p2 = buf2;
3841
3842 encode_method_ref (acfg, method, p2, &p2);
3843 g_assert (p2 - buf2 < 1024);
3844
3845 offset = add_to_blob (acfg, buf2, p2 - buf2);
3846 g_free (buf2);
3847
3848 g_hash_table_insert (acfg->method_blob_hash, method, GUINT_TO_POINTER (offset + 1));
3849 } else {
3850 offset --;
3851 }
3852 return offset;
3853 }
3854
3855 static gint
3856 compare_patches (gconstpointer a, gconstpointer b)
3857 {
3858 int i, j;
3859
3860 i = (*(MonoJumpInfo**)a)->ip.i;
3861 j = (*(MonoJumpInfo**)b)->ip.i;
3862
3863 if (i < j)
3864 return -1;
3865 else
3866 if (i > j)
3867 return 1;
3868 else
3869 return 0;
3870 }
3871
3872 static G_GNUC_UNUSED char*
3873 patch_to_string (MonoJumpInfo *patch_info)
3874 {
3875 GString *str;
3876
3877 str = g_string_new ("");
3878
3879 g_string_append_printf (str, "%s(", get_patch_name (patch_info->type));
3880
3881 switch (patch_info->type) {
3882 case MONO_PATCH_INFO_VTABLE:
3883 mono_type_get_desc (str, m_class_get_byval_arg (patch_info->data.klass), TRUE);
3884 break;
3885 default:
3886 break;
3887 }
3888 g_string_append_printf (str, ")");
3889 return g_string_free (str, FALSE);
3890 }
3891
3892 /*
3893 * is_plt_patch:
3894 *
3895 * Return whenever PATCH_INFO refers to a direct call, and thus requires a
3896 * PLT entry.
3897 */
3898 static gboolean
3899 is_plt_patch (MonoJumpInfo *patch_info)
3900 {
3901 switch (patch_info->type) {
3902 case MONO_PATCH_INFO_METHOD:
3903 case MONO_PATCH_INFO_JIT_ICALL_ID:
3904 case MONO_PATCH_INFO_JIT_ICALL_ADDR:
3905 case MONO_PATCH_INFO_ICALL_ADDR_CALL:
3906 case MONO_PATCH_INFO_RGCTX_FETCH:
3907 case MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR:
3908 return TRUE;
3909 case MONO_PATCH_INFO_JIT_ICALL_ADDR_NOCALL:
3910 default:
3911 return FALSE;
3912 }
3913 }
3914
3915 /*
3916 * get_plt_symbol:
3917 *
3918 * Return the symbol identifying the plt entry PLT_OFFSET.
3919 */
3920 static char*
3921 get_plt_symbol (MonoAotCompile *acfg, int plt_offset, MonoJumpInfo *patch_info)
3922 {
3923 #ifdef TARGET_MACH
3924 /*
3925 * The Apple linker reorganizes object files, so it doesn't like branches to local
3926 * labels, since those have no relocations.
3927 */
3928 return g_strdup_printf ("%sp_%d", acfg->llvm_label_prefix, plt_offset);
3929 #else
3930 return g_strdup_printf ("%sp_%d", acfg->temp_prefix, plt_offset);
3931 #endif
3932 }
3933
3934 /*
3935 * get_plt_entry:
3936 *
3937 * Return a PLT entry which belongs to the method identified by PATCH_INFO.
3938 */
3939 static MonoPltEntry*
3940 get_plt_entry (MonoAotCompile *acfg, MonoJumpInfo *patch_info)
3941 {
3942 MonoPltEntry *res;
3943 gboolean synchronized = FALSE;
3944 static int synchronized_symbol_idx;
3945
3946 if (!is_plt_patch (patch_info))
3947 return NULL;
3948
3949 if (!acfg->patch_to_plt_entry [patch_info->type])
3950 acfg->patch_to_plt_entry [patch_info->type] = g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
3951 res = (MonoPltEntry *)g_hash_table_lookup (acfg->patch_to_plt_entry [patch_info->type], patch_info);
3952
3953 if (!acfg->llvm && patch_info->type == MONO_PATCH_INFO_METHOD && (patch_info->data.method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)) {
3954 /*
3955 * Allocate a separate PLT slot for each such patch, since some plt
3956 * entries will refer to the method itself, and some will refer to the
3957 * wrapper.
3958 */
3959 res = NULL;
3960 synchronized = TRUE;
3961 }
3962
3963 if (!res) {
3964 MonoJumpInfo *new_ji;
3965
3966 new_ji = mono_patch_info_dup_mp (acfg->mempool, patch_info);
3967
3968 res = (MonoPltEntry *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoPltEntry));
3969 res->plt_offset = acfg->plt_offset;
3970 res->ji = new_ji;
3971 res->symbol = get_plt_symbol (acfg, res->plt_offset, patch_info);
3972 if (acfg->aot_opts.write_symbols)
3973 res->debug_sym = get_plt_entry_debug_sym (acfg, res->ji, acfg->plt_entry_debug_sym_cache);
3974 if (synchronized) {
3975 /* Avoid duplicate symbols because we don't cache */
3976 res->symbol = g_strdup_printf ("%s_%d", res->symbol, synchronized_symbol_idx);
3977 if (res->debug_sym)
3978 res->debug_sym = g_strdup_printf ("%s_%d", res->debug_sym, synchronized_symbol_idx);
3979 synchronized_symbol_idx ++;
3980 }
3981
3982 if (res->debug_sym)
3983 res->llvm_symbol = g_strdup_printf ("%s_%s_llvm", res->symbol, res->debug_sym);
3984 else
3985 res->llvm_symbol = g_strdup_printf ("%s_llvm", res->symbol);
3986 if (strstr (res->llvm_symbol, acfg->temp_prefix) == res->llvm_symbol) {
3987 /* The llvm symbol shouldn't be temporary, since the llvm generated object file references it */
3988 char *tmp = res->llvm_symbol;
3989 res->llvm_symbol = g_strdup (res->llvm_symbol + strlen (acfg->temp_prefix));
3990 g_free (tmp);
3991 }
3992
3993 g_hash_table_insert (acfg->patch_to_plt_entry [new_ji->type], new_ji, res);
3994
3995 g_hash_table_insert (acfg->plt_offset_to_entry, GUINT_TO_POINTER (res->plt_offset), res);
3996
3997 //g_assert (mono_patch_info_equal (patch_info, new_ji));
3998 //mono_print_ji (patch_info); printf ("\n");
3999 //g_hash_table_print_stats (acfg->patch_to_plt_entry);
4000
4001 acfg->plt_offset ++;
4002 }
4003
4004 return res;
4005 }
4006
4007 static guint32
4008 lookup_got_offset (MonoAotCompile *acfg, gboolean llvm, MonoJumpInfo *ji)
4009 {
4010 guint32 got_offset;
4011 GotInfo *info = llvm ? &acfg->llvm_got_info : &acfg->got_info;
4012
4013 got_offset = GPOINTER_TO_UINT (g_hash_table_lookup (info->patch_to_got_offset_by_type [ji->type], ji));
4014 if (got_offset)
4015 return got_offset - 1;
4016 g_assert_not_reached ();
4017 }
4018
4019 /**
4020 * get_got_offset:
4021 *
4022 * Returns the offset of the GOT slot where the runtime object resulting from resolving
4023 * JI could be found if it exists, otherwise allocates a new one.
4024 */
4025 static guint32
4026 get_got_offset (MonoAotCompile *acfg, gboolean llvm, MonoJumpInfo *ji)
4027 {
4028 guint32 got_offset;
4029 GotInfo *info = llvm ? &acfg->llvm_got_info : &acfg->got_info;
4030
4031 got_offset = GPOINTER_TO_UINT (g_hash_table_lookup (info->patch_to_got_offset_by_type [ji->type], ji));
4032 if (got_offset)
4033 return got_offset - 1;
4034
4035 if (llvm) {
4036 got_offset = acfg->llvm_got_offset;
4037 acfg->llvm_got_offset ++;
4038 } else {
4039 got_offset = acfg->got_offset;
4040 acfg->got_offset ++;
4041 }
4042
4043 acfg->stats.got_slots ++;
4044 acfg->stats.got_slot_types [ji->type] ++;
4045
4046 g_hash_table_insert (info->patch_to_got_offset, ji, GUINT_TO_POINTER (got_offset + 1));
4047 g_hash_table_insert (info->patch_to_got_offset_by_type [ji->type], ji, GUINT_TO_POINTER (got_offset + 1));
4048 g_ptr_array_add (info->got_patches, ji);
4049
4050 return got_offset;
4051 }
4052
4053 /* Add a method to the list of methods which need to be emitted */
4054 static void
4055 add_method_with_index (MonoAotCompile *acfg, MonoMethod *method, int index, gboolean extra)
4056 {
4057 g_assert (method);
4058 if (!g_hash_table_lookup (acfg->method_indexes, method)) {
4059 g_ptr_array_add (acfg->methods, method);
4060 g_hash_table_insert (acfg->method_indexes, method, GUINT_TO_POINTER (index + 1));
4061 acfg->nmethods = acfg->methods->len + 1;
4062 }
4063
4064 if (method->wrapper_type || extra) {
4065 int token = mono_metadata_token_index (method->token) - 1;
4066 if (token < 0)
4067 acfg->nextra_methods++;
4068 g_ptr_array_add (acfg->extra_methods, method);
4069 }
4070 }
4071
4072 static gboolean
4073 prefer_gsharedvt_method (MonoAotCompile *acfg, MonoMethod *method)
4074 {
4075 /* One instantiation with valuetypes is generated for each async method */
4076 if (m_class_get_image (method->klass) == mono_defaults.corlib && (!strcmp (m_class_get_name (method->klass), "AsyncMethodBuilderCore") || !strcmp (m_class_get_name (method->klass), "AsyncVoidMethodBuilder")))
4077 return TRUE;
4078 else
4079 return FALSE;
4080 }
4081
4082 static guint32
4083 get_method_index (MonoAotCompile *acfg, MonoMethod *method)
4084 {
4085 int index = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->method_indexes, method));
4086
4087 g_assert (index);
4088
4089 return index - 1;
4090 }
4091
4092 static int
4093 add_method_full (MonoAotCompile *acfg, MonoMethod *method, gboolean extra, int depth)
4094 {
4095 int index;
4096
4097 index = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->method_indexes, method));
4098 if (index)
4099 return index - 1;
4100
4101 index = acfg->method_index;
4102 add_method_with_index (acfg, method, index, extra);
4103
4104 g_ptr_array_add (acfg->method_order, GUINT_TO_POINTER (index));
4105
4106 g_hash_table_insert (acfg->method_depth, method, GUINT_TO_POINTER (depth));
4107
4108 acfg->method_index ++;
4109
4110 return index;
4111 }
4112
4113 static int
4114 add_method (MonoAotCompile *acfg, MonoMethod *method)
4115 {
4116 return add_method_full (acfg, method, FALSE, 0);
4117 }
4118
4119 static void
4120 mono_dedup_cache_method (MonoAotCompile *acfg, MonoMethod *method)
4121 {
4122 g_assert (acfg->dedup_stats);
4123
4124 char *name = mono_aot_get_mangled_method_name (method);
4125 g_assert (name);
4126
4127 // For stats
4128 char *stats_name = g_strdup (name);
4129
4130 g_assert (acfg->dedup_cache);
4131
4132 if (!g_hash_table_lookup (acfg->dedup_cache, name)) {
4133 // This AOTCompile owns this method
4134 // We do this to decide whether to write it to disk
4135 // during a dedup run (first phase, where we skip).
4136 //
4137 // If never changed, then maybe can avoid a recompile
4138 // of the cache.
4139 //
4140 // Files not read in during last phase.
4141 acfg->dedup_cache_changed = TRUE;
4142
4143 // owns name
4144 g_hash_table_insert (acfg->dedup_cache, name, method);
4145 } else {
4146 // owns name
4147 g_free (name);
4148 }
4149
4150 guint count = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->dedup_stats, stats_name));
4151 count++;
4152 g_hash_table_insert (acfg->dedup_stats, stats_name, GUINT_TO_POINTER (count));
4153 }
4154
4155 static void
4156 add_extra_method_with_depth (MonoAotCompile *acfg, MonoMethod *method, int depth)
4157 {
4158 ERROR_DECL (error);
4159
4160 if (mono_method_is_generic_sharable_full (method, TRUE, TRUE, FALSE)) {
4161 method = mini_get_shared_method_full (method, SHARE_MODE_NONE, error);
4162 if (!is_ok (error)) {
4163 /* vtype constraint */
4164 mono_error_cleanup (error);
4165 return;
4166 }
4167 } else if ((acfg->opts & MONO_OPT_GSHAREDVT) && prefer_gsharedvt_method (acfg, method) && mono_method_is_generic_sharable_full (method, FALSE, FALSE, TRUE)) {
4168 /* Use the gsharedvt version */
4169 method = mini_get_shared_method_full (method, SHARE_MODE_GSHAREDVT, error);
4170 mono_error_assert_ok (error);
4171 }
4172
4173 if ((acfg->aot_opts.dedup || acfg->aot_opts.dedup_include) && mono_aot_can_dedup (method)) {
4174 mono_dedup_cache_method (acfg, method);
4175
4176 if (!acfg->dedup_emit_mode)
4177 return;
4178 }
4179
4180 if (acfg->aot_opts.log_generics)
4181 aot_printf (acfg, "%*sAdding method %s.\n", depth, "", mono_method_get_full_name (method));
4182
4183 add_method_full (acfg, method, TRUE, depth);
4184 }
4185
4186 static void
4187 add_extra_method (MonoAotCompile *acfg, MonoMethod *method)
4188 {
4189 add_extra_method_with_depth (acfg, method, 0);
4190 }
4191
4192 static void
4193 add_jit_icall_wrapper (MonoAotCompile *acfg, MonoJitICallInfo *callinfo)
4194 {
4195 if (!callinfo->sig)
4196 return;
4197
4198 g_assert (callinfo->name && callinfo->func);
4199
4200 add_method (acfg, mono_marshal_get_icall_wrapper (callinfo, TRUE));
4201 }
4202
4203 #if ENABLE_LLVM
4204
4205 static void
4206 add_lazy_init_wrappers (MonoAotCompile *acfg)
4207 {
4208 add_method (acfg, mono_marshal_get_aot_init_wrapper (AOT_INIT_METHOD));
4209 add_method (acfg, mono_marshal_get_aot_init_wrapper (AOT_INIT_METHOD_GSHARED_MRGCTX));
4210 add_method (acfg, mono_marshal_get_aot_init_wrapper (AOT_INIT_METHOD_GSHARED_VTABLE));
4211 add_method (acfg, mono_marshal_get_aot_init_wrapper (AOT_INIT_METHOD_GSHARED_THIS));
4212 }
4213
4214 #endif
4215
4216 static MonoMethod*
4217 get_runtime_invoke_sig (MonoMethodSignature *sig)
4218 {
4219 MonoMethodBuilder *mb;
4220 MonoMethod *m;
4221
4222 mb = mono_mb_new (mono_defaults.object_class, "FOO", MONO_WRAPPER_NONE);
4223 m = mono_mb_create_method (mb, sig, 16);
4224 MonoMethod *invoke = mono_marshal_get_runtime_invoke (m, FALSE);
4225 mono_mb_free (mb);
4226 return invoke;
4227 }
4228
4229 static MonoMethod*
4230 get_runtime_invoke (MonoAotCompile *acfg, MonoMethod *method, gboolean virtual_)
4231 {
4232 return mono_marshal_get_runtime_invoke (method, virtual_);
4233 }
4234
4235 static gboolean
4236 can_marshal_struct (MonoClass *klass)
4237 {
4238 MonoClassField *field;
4239 gboolean can_marshal = TRUE;
4240 gpointer iter = NULL;
4241 MonoMarshalType *info;
4242 int i;
4243
4244 if (mono_class_is_auto_layout (klass))
4245 return FALSE;
4246
4247 info = mono_marshal_load_type_info (klass);
4248
4249 /* Only allow a few field types to avoid asserts in the marshalling code */
4250 while ((field = mono_class_get_fields_internal (klass, &iter))) {
4251 if ((field->type->attrs & FIELD_ATTRIBUTE_STATIC))
4252 continue;
4253
4254 switch (field->type->type) {
4255 case MONO_TYPE_I4:
4256 case MONO_TYPE_U4:
4257 case MONO_TYPE_I1:
4258 case MONO_TYPE_U1:
4259 case MONO_TYPE_BOOLEAN:
4260 case MONO_TYPE_I2:
4261 case MONO_TYPE_U2:
4262 case MONO_TYPE_CHAR:
4263 case MONO_TYPE_I8:
4264 case MONO_TYPE_U8:
4265 case MONO_TYPE_I:
4266 case MONO_TYPE_U:
4267 case MONO_TYPE_PTR:
4268 case MONO_TYPE_R4:
4269 case MONO_TYPE_R8:
4270 case MONO_TYPE_STRING:
4271 break;
4272 case MONO_TYPE_VALUETYPE:
4273 if (!m_class_is_enumtype (mono_class_from_mono_type_internal (field->type)) && !can_marshal_struct (mono_class_from_mono_type_internal (field->type)))
4274 can_marshal = FALSE;
4275 break;
4276 case MONO_TYPE_SZARRAY: {
4277 gboolean has_mspec = FALSE;
4278
4279 if (info) {
4280 for (i = 0; i < info->num_fields; ++i) {
4281 if (info->fields [i].field == field && info->fields [i].mspec)
4282 has_mspec = TRUE;
4283 }
4284 }
4285 if (!has_mspec)
4286 can_marshal = FALSE;
4287 break;
4288 }
4289 default:
4290 can_marshal = FALSE;
4291 break;
4292 }
4293 }
4294
4295 /* Special cases */
4296 /* Its hard to compute whenever these can be marshalled or not */
4297 if (!strcmp (m_class_get_name_space (klass), "System.Net.NetworkInformation.MacOsStructs") && strcmp (m_class_get_name (klass), "sockaddr_dl"))
4298 return TRUE;
4299
4300 return can_marshal;
4301 }
4302
4303 static void
4304 create_gsharedvt_inst (MonoAotCompile *acfg, MonoMethod *method, MonoGenericContext *ctx)
4305 {
4306 /* Create a vtype instantiation */
4307 MonoGenericContext shared_context;
4308 MonoType **args;
4309 MonoGenericInst *inst;
4310 MonoGenericContainer *container;
4311 MonoClass **constraints;
4312 int i;
4313
4314 memset (ctx, 0, sizeof (MonoGenericContext));
4315
4316 if (mono_class_is_gtd (method->klass)) {
4317 shared_context = mono_class_get_generic_container (method->klass)->context;
4318 inst = shared_context.class_inst;
4319
4320 args = g_new0 (MonoType*, inst->type_argc);
4321 for (i = 0; i < inst->type_argc; ++i) {
4322 args [i] = mono_get_int_type ();
4323 }
4324 ctx->class_inst = mono_metadata_get_generic_inst (inst->type_argc, args);
4325 }
4326 if (method->is_generic) {
4327 container = mono_method_get_generic_container (method);
4328 g_assert (!container->is_anonymous && container->is_method);
4329 shared_context = container->context;
4330 inst = shared_context.method_inst;
4331
4332 args = g_new0 (MonoType*, inst->type_argc);
4333 for (i = 0; i < container->type_argc; ++i) {
4334 MonoGenericParamInfo *info = mono_generic_param_info (&container->type_params [i]);
4335 gboolean ref_only = FALSE;
4336
4337 if (info && info->constraints) {
4338 constraints = info->constraints;
4339
4340 while (*constraints) {
4341 MonoClass *cklass = *constraints;
4342 if (!(cklass == mono_defaults.object_class || (m_class_get_image (cklass) == mono_defaults.corlib && !strcmp (m_class_get_name (cklass), "ValueType"))))
4343 /* Inflaring the method with our vtype would not be valid */
4344 ref_only = TRUE;
4345 constraints ++;
4346 }
4347 }
4348
4349 if (ref_only)
4350 args [i] = mono_get_object_type ();
4351 else
4352 args [i] = mono_get_int_type ();
4353 }
4354 ctx->method_inst = mono_metadata_get_generic_inst (inst->type_argc, args);
4355 }
4356 }
4357
4358 static void
4359 add_gc_wrappers (MonoAotCompile *acfg)
4360 {
4361 MonoMethod *m;
4362 /* Managed Allocators */
4363 int nallocators = mono_gc_get_managed_allocator_types ();
4364 for (int i = 0; i < nallocators; ++i) {
4365 if ((m = mono_gc_get_managed_allocator_by_type (i, MANAGED_ALLOCATOR_REGULAR)))
4366 add_method (acfg, m);
4367 if ((m = mono_gc_get_managed_allocator_by_type (i, MANAGED_ALLOCATOR_SLOW_PATH)))
4368 add_method (acfg, m);
4369 if ((m = mono_gc_get_managed_allocator_by_type (i, MANAGED_ALLOCATOR_PROFILER)))
4370 add_method (acfg, m);
4371 }
4372
4373 /* write barriers */
4374 if (mono_gc_is_moving ()) {
4375 add_method (acfg, mono_gc_get_specific_write_barrier (FALSE));
4376 add_method (acfg, mono_gc_get_specific_write_barrier (TRUE));
4377 }
4378 }
4379
4380 static gboolean
4381 contains_disable_reflection_attribute (MonoCustomAttrInfo *cattr)
4382 {
4383 for (int i = 0; i < cattr->num_attrs; ++i) {
4384 MonoCustomAttrEntry *attr = &cattr->attrs [i];
4385
4386 if (!attr->ctor)
4387 return FALSE;
4388
4389 if (strcmp (m_class_get_name_space (attr->ctor->klass), "System.Runtime.CompilerServices"))
4390 return FALSE;
4391
4392 if (strcmp (m_class_get_name (attr->ctor->klass), "DisablePrivateReflectionAttribute"))
4393 return FALSE;
4394 }
4395
4396 return TRUE;
4397 }
4398
4399 gboolean
4400 mono_aot_can_specialize (MonoMethod *method)
4401 {
4402 if (!method)
4403 return FALSE;
4404
4405 if (method->wrapper_type != MONO_WRAPPER_NONE)
4406 return FALSE;
4407
4408 // If it's not private, we can't specialize
4409 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE)
4410 return FALSE;
4411
4412 // If it has the attribute disabling the specialization, we can't specialize
4413 //
4414 // Set by linker, indicates that the method can be found through reflection
4415 // and that call-site specialization shouldn't be done.
4416 //
4417 // Important that this attribute is used for *nothing else*
4418 //
4419 // If future authors make use of it (to disable more optimizations),
4420 // change this place to use a new attribute.
4421 ERROR_DECL (cattr_error);
4422 MonoCustomAttrInfo *cattr = mono_custom_attrs_from_class_checked (method->klass, cattr_error);
4423
4424 if (!is_ok (cattr_error)) {
4425 mono_error_cleanup (cattr_error);
4426 goto cleanup_false;
4427 } else if (cattr && contains_disable_reflection_attribute (cattr)) {
4428 goto cleanup_true;
4429 }
4430
4431 cattr = mono_custom_attrs_from_method_checked (method, cattr_error);
4432
4433 if (!is_ok (cattr_error)) {
4434 mono_error_cleanup (cattr_error);
4435 goto cleanup_false;
4436 } else if (cattr && contains_disable_reflection_attribute (cattr)) {
4437 goto cleanup_true;
4438 } else {
4439 goto cleanup_false;
4440 }
4441
4442 cleanup_false:
4443 if (cattr)
4444 mono_custom_attrs_free (cattr);
4445 return FALSE;
4446
4447 cleanup_true:
4448 if (cattr)
4449 mono_custom_attrs_free (cattr);
4450 return TRUE;
4451 }
4452
4453 static gboolean
4454 always_aot (MonoMethod *method)
4455 {
4456 /*
4457 * Calls to these methods do not go through the normal call processing code so
4458 * calling code cannot enter the interpreter. So always aot them even in profile guided aot mode.
4459 */
4460 if (method->klass == mono_get_string_class () && (strstr (method->name, "memcpy") || strstr (method->name, "bzero")))
4461 return TRUE;
4462 if (method->string_ctor)
4463 return TRUE;
4464 return FALSE;
4465 }
4466
4467 gboolean
4468 mono_aot_can_enter_interp (MonoMethod *method)
4469 {
4470 MonoAotCompile *acfg = current_acfg;
4471
4472 g_assert (acfg);
4473 if (always_aot (method))
4474 return FALSE;
4475 if (acfg->aot_opts.profile_only && !g_hash_table_lookup (acfg->profile_methods, method))
4476 return TRUE;
4477 return FALSE;
4478 }
4479
4480 static void
4481 add_wrappers (MonoAotCompile *acfg)
4482 {
4483 MonoMethod *method, *m;
4484 int i, j;
4485 MonoMethodSignature *sig, *csig;
4486 guint32 token;
4487
4488 /*
4489 * FIXME: Instead of AOTing all the wrappers, it might be better to redesign them
4490 * so there is only one wrapper of a given type, or inlining their contents into their
4491 * callers.
4492 */
4493 for (i = 0; i < acfg->image->tables [MONO_TABLE_METHOD].rows; ++i) {
4494 ERROR_DECL (error);
4495 MonoMethod *method;
4496 guint32 token = MONO_TOKEN_METHOD_DEF | (i + 1);
4497 gboolean skip = FALSE;
4498
4499 method = mono_get_method_checked (acfg->image, token, NULL, NULL, error);
4500 report_loader_error (acfg, error, TRUE, "Failed to load method token 0x%x due to %s\n", i, mono_error_get_message (error));
4501
4502 if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
4503 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
4504 (method->flags & METHOD_ATTRIBUTE_ABSTRACT))
4505 skip = TRUE;
4506
4507 /* Skip methods which can not be handled by get_runtime_invoke () */
4508 sig = mono_method_signature_internal (method);
4509 if (!sig)
4510 continue;
4511 if ((sig->ret->type == MONO_TYPE_PTR) ||
4512 (sig->ret->type == MONO_TYPE_TYPEDBYREF))
4513 skip = TRUE;
4514 if (mono_class_is_open_constructed_type (sig->ret))
4515 skip = TRUE;
4516
4517 for (j = 0; j < sig->param_count; j++) {
4518 if (sig->params [j]->type == MONO_TYPE_TYPEDBYREF)
4519 skip = TRUE;
4520 if (mono_class_is_open_constructed_type (sig->params [j]))
4521 skip = TRUE;
4522 }
4523
4524 #ifdef MONO_ARCH_DYN_CALL_SUPPORTED
4525 if (!mono_class_is_contextbound (method->klass)) {
4526 MonoDynCallInfo *info = mono_arch_dyn_call_prepare (sig);
4527 gboolean has_nullable = FALSE;
4528
4529 for (j = 0; j < sig->param_count; j++) {
4530 if (sig->params [j]->type == MONO_TYPE_GENERICINST && mono_class_is_nullable (mono_class_from_mono_type_internal (sig->params [j])))
4531 has_nullable = TRUE;
4532 }
4533
4534 if (info && !has_nullable && !acfg->aot_opts.llvm_only) {
4535 /* Supported by the dynamic runtime-invoke wrapper */
4536 skip = TRUE;
4537 }
4538 if (info)
4539 mono_arch_dyn_call_free (info);
4540 }
4541 #endif
4542
4543 if (acfg->aot_opts.llvm_only)
4544 /* Supported by the gsharedvt based runtime-invoke wrapper */
4545 skip = TRUE;
4546
4547 if (!skip) {
4548 //printf ("%s\n", mono_method_full_name (method, TRUE));
4549 add_method (acfg, get_runtime_invoke (acfg, method, FALSE));
4550 }
4551 }
4552
4553 if (mono_is_corlib_image (acfg->image->assembly->image)) {
4554 /* Runtime invoke wrappers */
4555
4556 MonoType *void_type = mono_get_void_type ();
4557 MonoType *string_type = m_class_get_byval_arg (mono_defaults.string_class);
4558
4559 /* void runtime-invoke () [.cctor] */
4560 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
4561 csig->ret = void_type;
4562 add_method (acfg, get_runtime_invoke_sig (csig));
4563
4564 /* void runtime-invoke () [Finalize] */
4565 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
4566 csig->hasthis = 1;
4567 csig->ret = void_type;
4568 add_method (acfg, get_runtime_invoke_sig (csig));
4569
4570 /* void runtime-invoke (string) [exception ctor] */
4571 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
4572 csig->hasthis = 1;
4573 csig->ret = void_type;
4574 csig->params [0] = string_type;
4575 add_method (acfg, get_runtime_invoke_sig (csig));
4576
4577 /* void runtime-invoke (string, string) [exception ctor] */
4578 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
4579 csig->hasthis = 1;
4580 csig->ret = void_type;
4581 csig->params [0] = string_type;
4582 csig->params [1] = string_type;
4583 add_method (acfg, get_runtime_invoke_sig (csig));
4584
4585 /* string runtime-invoke () [Exception.ToString ()] */
4586 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 0);
4587 csig->hasthis = 1;
4588 csig->ret = string_type;
4589 add_method (acfg, get_runtime_invoke_sig (csig));
4590
4591 /* void runtime-invoke (string, Exception) [exception ctor] */
4592 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
4593 csig->hasthis = 1;
4594 csig->ret = void_type;
4595 csig->params [0] = string_type;
4596 csig->params [1] = m_class_get_byval_arg (mono_defaults.exception_class);
4597 add_method (acfg, get_runtime_invoke_sig (csig));
4598
4599 /* Assembly runtime-invoke (string, Assembly, bool) [DoAssemblyResolve] */
4600 csig = mono_metadata_signature_alloc (mono_defaults.corlib, 3);
4601 csig->hasthis = 1;
4602 csig->ret = m_class_get_byval_arg (mono_class_load_from_name (mono_defaults.corlib, "System.Reflection", "Assembly"));
4603 csig->params [0] = string_type;
4604 csig->params [1] = m_class_get_byval_arg (mono_class_load_from_name (mono_defaults.corlib, "System.Reflection", "Assembly"));
4605 csig->params [2] = m_class_get_byval_arg (mono_defaults.boolean_class);
4606 add_method (acfg, get_runtime_invoke_sig (csig));
4607
4608 /* runtime-invoke used by finalizers */
4609 add_method (acfg, get_runtime_invoke (acfg, get_method_nofail (mono_defaults.object_class, "Finalize", 0, 0), TRUE));
4610
4611 /* This is used by mono_runtime_capture_context () */
4612 method = mono_get_context_capture_method ();
4613 if (method)
4614 add_method (acfg, get_runtime_invoke (acfg, method, FALSE));
4615
4616 #ifdef MONO_ARCH_DYN_CALL_SUPPORTED
4617 if (!acfg->aot_opts.llvm_only)
4618 add_method (acfg, mono_marshal_get_runtime_invoke_dynamic ());
4619 #endif
4620
4621 /* These are used by mono_jit_runtime_invoke () to calls gsharedvt out wrappers */
4622 if (acfg->aot_opts.llvm_only) {
4623 int variants;
4624
4625 /* Create simplified signatures which match the signature used by the gsharedvt out wrappers */
4626 for (variants = 0; variants < 4; ++variants) {
4627 for (i = 0; i < 40; ++i) {
4628 sig = mini_get_gsharedvt_out_sig_wrapper_signature ((variants & 1) > 0, (variants & 2) > 0, i);
4629 add_extra_method (acfg, mono_marshal_get_runtime_invoke_for_sig (sig));
4630
4631 g_free (sig);
4632 }
4633 }
4634 }
4635
4636 /* stelemref */
4637 add_method (acfg, mono_marshal_get_stelemref ());
4638
4639 add_gc_wrappers (acfg);
4640
4641 /* Stelemref wrappers */
4642 {
4643 MonoMethod **wrappers;
4644 int nwrappers;
4645
4646 wrappers = mono_marshal_get_virtual_stelemref_wrappers (&nwrappers);
4647 for (i = 0; i < nwrappers; ++i)
4648 add_method (acfg, wrappers [i]);
4649 g_free (wrappers);
4650 }
4651
4652 /* castclass_with_check wrapper */
4653 add_method (acfg, mono_marshal_get_castclass_with_cache ());
4654 /* isinst_with_check wrapper */
4655 add_method (acfg, mono_marshal_get_isinst_with_cache ());
4656
4657 /* JIT icall wrappers */
4658 /* FIXME: locking - this is "safe" as full-AOT threads don't mutate the icall data */
4659 for (int i = 0; i < MONO_JIT_ICALL_count; ++i)
4660 add_jit_icall_wrapper (acfg, mono_find_jit_icall_info ((MonoJitICallId)i));
4661 }
4662
4663 /*
4664 * remoting-invoke-with-check wrappers are very frequent, so avoid emitting them,
4665 * we use the original method instead at runtime.
4666 * Since full-aot doesn't support remoting, this is not a problem.
4667 */
4668 #if 0
4669 /* remoting-invoke wrappers */
4670 for (i = 0; i < acfg->image->tables [MONO_TABLE_METHOD].rows; ++i) {
4671 ERROR_DECL (error);
4672 MonoMethodSignature *sig;
4673
4674 token = MONO_TOKEN_METHOD_DEF | (i + 1);
4675 method = mono_get_method_checked (acfg->image, token, NULL, NULL, error);
4676 g_assert (is_ok (error)); /* FIXME don't swallow the error */
4677
4678 sig = mono_method_signature_internal (method);
4679
4680 if (sig->hasthis && (method->klass->marshalbyref || method->klass == mono_defaults.object_class)) {
4681 m = mono_marshal_get_remoting_invoke_with_check (method);
4682
4683 add_method (acfg, m);
4684 }
4685 }
4686 #endif
4687
4688 /* delegate-invoke wrappers */
4689 for (i = 0; i < acfg->image->tables [MONO_TABLE_TYPEDEF].rows; ++i) {
4690 ERROR_DECL (error);
4691 MonoClass *klass;
4692
4693 token = MONO_TOKEN_TYPE_DEF | (i + 1);
4694 klass = mono_class_get_checked (acfg->image, token, error);
4695
4696 if (!klass) {
4697 mono_error_cleanup (error);
4698 continue;
4699 }
4700
4701 if (!m_class_is_delegate (klass) || klass == mono_defaults.delegate_class || klass == mono_defaults.multicastdelegate_class)
4702 continue;
4703
4704 if (!mono_class_is_gtd (klass)) {
4705 method = mono_get_delegate_invoke_internal (klass);
4706
4707 m = mono_marshal_get_delegate_invoke (method, NULL);
4708
4709 add_method (acfg, m);
4710
4711 method = try_get_method_nofail (klass, "BeginInvoke", -1, 0);
4712 if (method)
4713 add_method (acfg, mono_marshal_get_delegate_begin_invoke (method));
4714
4715 method = try_get_method_nofail (klass, "EndInvoke", -1, 0);
4716 if (method)
4717 add_method (acfg, mono_marshal_get_delegate_end_invoke (method));
4718
4719 MonoCustomAttrInfo *cattr;
4720 cattr = mono_custom_attrs_from_class_checked (klass, error);
4721 if (!is_ok (error)) {
4722 mono_error_cleanup (error);
4723 g_assert (!cattr);
4724 continue;
4725 }
4726
4727 if (cattr) {
4728 int j;
4729
4730 for (j = 0; j < cattr->num_attrs; ++j)
4731 if (cattr->attrs [j].ctor && (!strcmp (m_class_get_name (cattr->attrs [j].ctor->klass), "MonoNativeFunctionWrapperAttribute") || !strcmp (m_class_get_name (cattr->attrs [j].ctor->klass), "UnmanagedFunctionPointerAttribute")))
4732 break;
4733 if (j < cattr->num_attrs) {
4734 MonoMethod *invoke;
4735 MonoMethod *wrapper;
4736 MonoMethod *del_invoke;
4737
4738 /* Add wrappers needed by mono_ftnptr_to_delegate () */
4739 invoke = mono_get_delegate_invoke_internal (klass);
4740 wrapper = mono_marshal_get_native_func_wrapper_aot (klass);
4741 del_invoke = mono_marshal_get_delegate_invoke_internal (invoke, FALSE, TRUE, wrapper);
4742 add_method (acfg, wrapper);
4743 add_method (acfg, del_invoke);
4744 }
4745 mono_custom_attrs_free (cattr);
4746 }
4747 } else if ((acfg->opts & MONO_OPT_GSHAREDVT) && mono_class_is_gtd (klass)) {
4748 ERROR_DECL (error);
4749 MonoGenericContext ctx;
4750 MonoMethod *inst, *gshared;
4751
4752 /*
4753 * Emit gsharedvt versions of the generic delegate-invoke wrappers
4754 */
4755 /* Invoke */
4756 method = mono_get_delegate_invoke_internal (klass);
4757 create_gsharedvt_inst (acfg, method, &ctx);
4758
4759 inst = mono_class_inflate_generic_method_checked (method, &ctx, error);
4760 g_assert (is_ok (error)); /* FIXME don't swallow the error */
4761
4762 m = mono_marshal_get_delegate_invoke (inst, NULL);
4763 g_assert (m->is_inflated);
4764
4765 gshared = mini_get_shared_method_full (m, SHARE_MODE_GSHAREDVT, error);
4766 mono_error_assert_ok (error);
4767
4768 add_extra_method (acfg, gshared);
4769
4770 /* begin-invoke */
4771 method = mono_get_delegate_begin_invoke_internal (klass);
4772 if (method) {
4773 create_gsharedvt_inst (acfg, method, &ctx);
4774
4775 inst = mono_class_inflate_generic_method_checked (method, &ctx, error);
4776 g_assert (is_ok (error)); /* FIXME don't swallow the error */
4777
4778 m = mono_marshal_get_delegate_begin_invoke (inst);
4779 g_assert (m->is_inflated);
4780
4781 gshared = mini_get_shared_method_full (m, SHARE_MODE_GSHAREDVT, error);
4782 mono_error_assert_ok (error);
4783
4784 add_extra_method (acfg, gshared);
4785 }
4786
4787 /* end-invoke */
4788 method = mono_get_delegate_end_invoke_internal (klass);
4789 if (method) {
4790 create_gsharedvt_inst (acfg, method, &ctx);
4791
4792 inst = mono_class_inflate_generic_method_checked (method, &ctx, error);
4793 g_assert (is_ok (error)); /* FIXME don't swallow the error */
4794
4795 m = mono_marshal_get_delegate_end_invoke (inst);
4796 g_assert (m->is_inflated);
4797
4798 gshared = mini_get_shared_method_full (m, SHARE_MODE_GSHAREDVT, error);
4799 mono_error_assert_ok (error);
4800
4801 add_extra_method (acfg, gshared);
4802 }
4803 }
4804 }
4805
4806 /* array access wrappers */
4807 for (i = 0; i < acfg->image->tables [MONO_TABLE_TYPESPEC].rows; ++i) {
4808 ERROR_DECL (error);
4809 MonoClass *klass;
4810
4811 token = MONO_TOKEN_TYPE_SPEC | (i + 1);
4812 klass = mono_class_get_checked (acfg->image, token, error);
4813
4814 if (!klass) {
4815 mono_error_cleanup (error);
4816 continue;
4817 }
4818
4819 if (m_class_get_rank (klass) && MONO_TYPE_IS_PRIMITIVE (m_class_get_byval_arg (m_class_get_element_class (klass)))) {
4820 MonoMethod *m, *wrapper;
4821
4822 /* Add runtime-invoke wrappers too */
4823
4824 m = get_method_nofail (klass, "Get", -1, 0);
4825 g_assert (m);
4826 wrapper = mono_marshal_get_array_accessor_wrapper (m);
4827 add_extra_method (acfg, wrapper);
4828 if (!acfg->aot_opts.llvm_only)
4829 add_extra_method (acfg, get_runtime_invoke (acfg, wrapper, FALSE));
4830
4831 m = get_method_nofail (klass, "Set", -1, 0);
4832 g_assert (m);
4833 wrapper = mono_marshal_get_array_accessor_wrapper (m);
4834 add_extra_method (acfg, wrapper);
4835 if (!acfg->aot_opts.llvm_only)
4836 add_extra_method (acfg, get_runtime_invoke (acfg, wrapper, FALSE));
4837 }
4838 }
4839
4840 /* Synchronized wrappers */
4841 for (i = 0; i < acfg->image->tables [MONO_TABLE_METHOD].rows; ++i) {
4842 ERROR_DECL (error);
4843 token = MONO_TOKEN_METHOD_DEF | (i + 1);
4844 method = mono_get_method_checked (acfg->image, token, NULL, NULL, error);
4845 report_loader_error (acfg, error, TRUE, "Failed to load method token 0x%x due to %s\n", i, mono_error_get_message (error));
4846
4847 if (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) {
4848 if (method->is_generic) {
4849 // FIXME:
4850 } else if ((acfg->opts & MONO_OPT_GSHAREDVT) && mono_class_is_gtd (method->klass)) {
4851 ERROR_DECL (error);
4852 MonoGenericContext ctx;
4853 MonoMethod *inst, *gshared, *m;
4854
4855 /*
4856 * Create a generic wrapper for a generic instance, and AOT that.
4857 */
4858 create_gsharedvt_inst (acfg, method, &ctx);
4859 inst = mono_class_inflate_generic_method_checked (method, &ctx, error);
4860 g_assert (is_ok (error)); /* FIXME don't swallow the error */
4861 m = mono_marshal_get_synchronized_wrapper (inst);
4862 g_assert (m->is_inflated);
4863 gshared = mini_get_shared_method_full (m, SHARE_MODE_GSHAREDVT, error);
4864 mono_error_assert_ok (error);
4865
4866 add_method (acfg, gshared);
4867 } else {
4868 add_method (acfg, mono_marshal_get_synchronized_wrapper (method));
4869 }
4870 }
4871 }
4872
4873 /* pinvoke wrappers */
4874 for (i = 0; i < acfg->image->tables [MONO_TABLE_METHOD].rows; ++i) {
4875 ERROR_DECL (error);
4876 MonoMethod *method;
4877 guint32 token = MONO_TOKEN_METHOD_DEF | (i + 1);
4878
4879 method = mono_get_method_checked (acfg->image, token, NULL, NULL, error);
4880 report_loader_error (acfg, error, TRUE, "Failed to load method token 0x%x due to %s\n", i, mono_error_get_message (error));
4881
4882 if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
4883 (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)) {
4884 add_method (acfg, mono_marshal_get_native_wrapper (method, TRUE, TRUE));
4885 }
4886
4887 if (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
4888 if (acfg->aot_opts.llvm_only) {
4889 /* The wrappers have a different signature (hasthis is not set) so need to add this too */
4890 add_gsharedvt_wrappers (acfg, mono_method_signature_internal (method), FALSE, TRUE, FALSE);
4891 }
4892 }
4893 }
4894
4895 /* native-to-managed wrappers */
4896 for (i = 0; i < acfg->image->tables [MONO_TABLE_METHOD].rows; ++i) {
4897 ERROR_DECL (error);
4898 MonoMethod *method;
4899 guint32 token = MONO_TOKEN_METHOD_DEF | (i + 1);
4900 MonoCustomAttrInfo *cattr;
4901 int j;
4902
4903 method = mono_get_method_checked (acfg->image, token, NULL, NULL, error);
4904 report_loader_error (acfg, error, TRUE, "Failed to load method token 0x%x due to %s\n", i, mono_error_get_message (error));
4905
4906 /*
4907 * Only generate native-to-managed wrappers for methods which have an
4908 * attribute named MonoPInvokeCallbackAttribute. We search for the attribute by
4909 * name to avoid defining a new assembly to contain it.
4910 */
4911 cattr = mono_custom_attrs_from_method_checked (method, error);
4912 if (!is_ok (error)) {
4913 char *name = mono_method_get_full_name (method);
4914 report_loader_error (acfg, error, TRUE, "Failed to load custom attributes from method %s due to %s\n", name, mono_error_get_message (error));
4915 g_free (name);
4916 }
4917
4918 if (cattr) {
4919 for (j = 0; j < cattr->num_attrs; ++j)
4920 if (cattr->attrs [j].ctor && !strcmp (m_class_get_name (cattr->attrs [j].ctor->klass), "MonoPInvokeCallbackAttribute"))
4921 break;
4922 if (j < cattr->num_attrs) {
4923 MonoCustomAttrEntry *e = &cattr->attrs [j];
4924 MonoMethodSignature *sig = mono_method_signature_internal (e->ctor);
4925 const char *p = (const char*)e->data;
4926 const char *named;
4927 int slen, num_named, named_type;
4928 char *n;
4929 MonoType *t;
4930 MonoClass *klass;
4931 char *export_name = NULL;
4932 MonoMethod *wrapper;
4933
4934 /* this cannot be enforced by the C# compiler so we must give the user some warning before aborting */
4935 if (!(method->flags & METHOD_ATTRIBUTE_STATIC)) {
4936 g_warning ("AOT restriction: Method '%s' must be static since it is decorated with [MonoPInvokeCallback]. See https://docs.microsoft.com/xamarin/ios/internals/limitations#reverse-callbacks",
4937 mono_method_full_name (method, TRUE));
4938 exit (1);
4939 }
4940
4941 g_assert (sig->param_count == 1);
4942 g_assert (sig->params [0]->type == MONO_TYPE_CLASS && !strcmp (m_class_get_name (mono_class_from_mono_type_internal (sig->params [0])), "Type"));
4943
4944 /*
4945 * Decode the cattr manually since we can't create objects
4946 * during aot compilation.
4947 */
4948
4949 /* Skip prolog */
4950 p += 2;
4951
4952 /* From load_cattr_value () in reflection.c */
4953 slen = mono_metadata_decode_value (p, &p);
4954 n = (char *)g_memdup (p, slen + 1);
4955 n [slen] = 0;
4956 t = mono_reflection_type_from_name_checked (n, mono_domain_ambient_alc (mono_domain_get ()), acfg->image, error);
4957 g_assert (t);
4958 mono_error_assert_ok (error);
4959 g_free (n);
4960
4961 klass = mono_class_from_mono_type_internal (t);
4962 g_assert (m_class_get_parent (klass) == mono_defaults.multicastdelegate_class);
4963
4964 p += slen;
4965
4966 num_named = read16 (p);
4967 p += 2;
4968
4969 g_assert (num_named < 2);
4970 if (num_named == 1) {
4971 int name_len;
4972 char *name;
4973
4974 /* parse ExportSymbol attribute */
4975 named = p;
4976 named_type = *named;
4977 named += 1;
4978 /* data_type = *named; */
4979 named += 1;
4980
4981 name_len = mono_metadata_decode_blob_size (named, &named);
4982 name = (char *)g_malloc (name_len + 1);
4983 memcpy (name, named, name_len);
4984 name [name_len] = 0;
4985 named += name_len;
4986
4987 g_assert (named_type == 0x54);
4988 g_assert (!strcmp (name, "ExportSymbol"));
4989
4990 /* load_cattr_value (), string case */
4991 MONO_DISABLE_WARNING (4310) // cast truncates constant value
4992 g_assert (*named != (char)0xFF);
4993 MONO_RESTORE_WARNING
4994 slen = mono_metadata_decode_value (named, &named);
4995 export_name = (char *)g_malloc (slen + 1);
4996 memcpy (export_name, named, slen);
4997 export_name [slen] = 0;
4998 named += slen;
4999 }
5000
5001 wrapper = mono_marshal_get_managed_wrapper (method, klass, 0, error);
5002 mono_error_assert_ok (error);
5003
5004 add_method (acfg, wrapper);
5005 if (export_name)
5006 g_hash_table_insert (acfg->export_names, wrapper, export_name);
5007 }
5008 g_free (cattr);
5009 }
5010
5011 if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
5012 (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)) {
5013 add_method (acfg, mono_marshal_get_native_wrapper (method, TRUE, TRUE));
5014 }
5015 }
5016
5017 /* StructureToPtr/PtrToStructure wrappers */
5018 for (i = 0; i < acfg->image->tables [MONO_TABLE_TYPEDEF].rows; ++i) {
5019 ERROR_DECL (error);
5020 MonoClass *klass;
5021
5022 token = MONO_TOKEN_TYPE_DEF | (i + 1);
5023 klass = mono_class_get_checked (acfg->image, token, error);
5024
5025 if (!klass) {
5026 mono_error_cleanup (error);
5027 continue;
5028 }
5029
5030 if (m_class_is_valuetype (klass) && !mono_class_is_gtd (klass) && can_marshal_struct (klass) &&
5031 !(m_class_get_nested_in (klass) && strstr (m_class_get_name (m_class_get_nested_in (klass)), "<PrivateImplementationDetails>") == m_class_get_name (m_class_get_nested_in (klass)))) {
5032 add_method (acfg, mono_marshal_get_struct_to_ptr (klass));
5033 add_method (acfg, mono_marshal_get_ptr_to_struct (klass));
5034 }
5035 }
5036 }
5037
5038 static gboolean
5039 has_type_vars (MonoClass *klass)
5040 {
5041 if ((m_class_get_byval_arg (klass)->type == MONO_TYPE_VAR) || (m_class_get_byval_arg (klass)->type == MONO_TYPE_MVAR))
5042 return TRUE;
5043 if (m_class_get_rank (klass))
5044 return has_type_vars (m_class_get_element_class (klass));
5045 if (mono_class_is_ginst (klass)) {
5046 MonoGenericContext *context = &mono_class_get_generic_class (klass)->context;
5047 if (context->class_inst) {
5048 int i;
5049
5050 for (i = 0; i < context->class_inst->type_argc; ++i)
5051 if (has_type_vars (mono_class_from_mono_type_internal (context->class_inst->type_argv [i])))
5052 return TRUE;
5053 }
5054 }
5055 if (mono_class_is_gtd (klass))
5056 return TRUE;
5057 return FALSE;
5058 }
5059
5060 static gboolean
5061 is_vt_inst (MonoGenericInst *inst)
5062 {
5063 int i;
5064
5065 for (i = 0; i < inst->type_argc; ++i) {
5066 MonoType *t = inst->type_argv [i];
5067 if (MONO_TYPE_ISSTRUCT (t) || t->type == MONO_TYPE_VALUETYPE)
5068 return TRUE;
5069 }
5070 return FALSE;
5071 }
5072
5073 static gboolean
5074 method_has_type_vars (MonoMethod *method)
5075 {
5076 if (has_type_vars (method->klass))
5077 return TRUE;
5078
5079 if (method->is_inflated) {
5080 MonoGenericContext *context = mono_method_get_context (method);
5081 if (context->method_inst) {
5082 int i;
5083
5084 for (i = 0; i < context->method_inst->type_argc; ++i)
5085 if (has_type_vars (mono_class_from_mono_type_internal (context->method_inst->type_argv [i])))
5086 return TRUE;
5087 }
5088 }
5089 return FALSE;
5090 }
5091
5092 static
5093 gboolean mono_aot_mode_is_full (MonoAotOptions *opts)
5094 {
5095 return opts->mode == MONO_AOT_MODE_FULL;
5096 }
5097
5098 static
5099 gboolean mono_aot_mode_is_interp (MonoAotOptions *opts)
5100 {
5101 return opts->interp;
5102 }
5103
5104 static
5105 gboolean mono_aot_mode_is_hybrid (MonoAotOptions *opts)
5106 {
5107 return opts->mode == MONO_AOT_MODE_HYBRID;
5108 }
5109
5110 static void add_generic_class_with_depth (MonoAotCompile *acfg, MonoClass *klass, int depth, const char *ref);
5111
5112 static void
5113 add_generic_class (MonoAotCompile *acfg, MonoClass *klass, gboolean force, const char *ref)
5114 {
5115 /* This might lead to a huge code blowup so only do it if neccesary */
5116 if (!mono_aot_mode_is_full (&acfg->aot_opts) && !mono_aot_mode_is_hybrid (&acfg->aot_opts) && !force)
5117 return;
5118
5119 add_generic_class_with_depth (acfg, klass, 0, ref);
5120 }
5121
5122 static gboolean
5123 check_type_depth (MonoType *t, int depth)
5124 {
5125 int i;
5126
5127 if (depth > 8)
5128 return TRUE;
5129
5130 switch (t->type) {
5131 case MONO_TYPE_GENERICINST: {
5132 MonoGenericClass *gklass = t->data.generic_class;
5133 MonoGenericInst *ginst = gklass->context.class_inst;
5134
5135 if (ginst) {
5136 for (i = 0; i < ginst->type_argc; ++i) {
5137 if (check_type_depth (ginst->type_argv [i], depth + 1))
5138 return TRUE;
5139 }
5140 }
5141 break;
5142 }
5143 default:
5144 break;
5145 }
5146
5147 return FALSE;
5148 }
5149
5150 static void
5151 add_types_from_method_header (MonoAotCompile *acfg, MonoMethod *method);
5152
5153 /*
5154 * add_generic_class:
5155 *
5156 * Add all methods of a generic class.
5157 */
5158 static void
5159 add_generic_class_with_depth (MonoAotCompile *acfg, MonoClass *klass, int depth, const char *ref)
5160 {
5161 MonoMethod *method;
5162 MonoClassField *field;
5163 gpointer iter;
5164 gboolean use_gsharedvt = FALSE;
5165
5166 if (!acfg->ginst_hash)
5167 acfg->ginst_hash = g_hash_table_new (NULL, NULL);
5168
5169 mono_class_init_internal (klass);
5170
5171 if (mono_class_is_ginst (klass) && mono_class_get_generic_class (klass)->context.class_inst->is_open)
5172 return;
5173
5174 if (has_type_vars (klass))
5175 return;
5176
5177 if (!mono_class_is_ginst (klass) && !m_class_get_rank (klass))
5178 return;
5179
5180 if (mono_class_has_failure (klass))
5181 return;
5182
5183 if (!acfg->ginst_hash)
5184 acfg->ginst_hash = g_hash_table_new (NULL, NULL);
5185
5186 if (g_hash_table_lookup (acfg->ginst_hash, klass))
5187 return;
5188
5189 if (check_type_depth (m_class_get_byval_arg (klass), 0))
5190 return;
5191
5192 if (acfg->aot_opts.log_generics) {
5193 char *s = mono_type_full_name (m_class_get_byval_arg (klass));
5194 aot_printf (acfg, "%*sAdding generic instance %s [%s].\n", depth, "", s, ref);
5195 g_free (s);
5196 }
5197
5198 g_hash_table_insert (acfg->ginst_hash, klass, klass);
5199
5200 /*
5201 * Use gsharedvt for generic collections with vtype arguments to avoid code blowup.
5202 * Enable this only for some classes since gsharedvt might not support all methods.
5203 */
5204 if ((acfg->opts & MONO_OPT_GSHAREDVT) && m_class_get_image (klass) == mono_defaults.corlib && mono_class_is_ginst (klass) && mono_class_get_generic_class (klass)->context.class_inst && is_vt_inst (mono_class_get_generic_class (klass)->context.class_inst) &&
5205 (!strcmp (m_class_get_name (klass), "Dictionary`2") || !strcmp (m_class_get_name (klass), "List`1") || !strcmp (m_class_get_name (klass), "ReadOnlyCollection`1")))
5206 use_gsharedvt = TRUE;
5207
5208 iter = NULL;
5209 while ((method = mono_class_get_methods (klass, &iter))) {
5210 if ((acfg->opts & MONO_OPT_GSHAREDVT) && method->is_inflated && mono_method_get_context (method)->method_inst) {
5211 /*
5212 * This is partial sharing, and we can't handle it yet
5213 */
5214 continue;
5215 }
5216
5217 if (mono_method_is_generic_sharable_full (method, FALSE, FALSE, use_gsharedvt)) {
5218 /* Already added */
5219 add_types_from_method_header (acfg, method);
5220 continue;
5221 }
5222
5223 if (method->is_generic)
5224 /* FIXME: */
5225 continue;
5226
5227 /*
5228 * FIXME: Instances which are referenced by these methods are not added,
5229 * for example Array.Resize<int> for List<int>.Add ().
5230 */
5231 add_extra_method_with_depth (acfg, method, depth + 1);
5232 }
5233
5234 iter = NULL;
5235 while ((field = mono_class_get_fields_internal (klass, &iter))) {
5236 if (field->type->type == MONO_TYPE_GENERICINST)
5237 add_generic_class_with_depth (acfg, mono_class_from_mono_type_internal (field->type), depth + 1, "field");
5238 }
5239
5240 if (m_class_is_delegate (klass)) {
5241 method = mono_get_delegate_invoke_internal (klass);
5242
5243 method = mono_marshal_get_delegate_invoke (method, NULL);
5244
5245 if (acfg->aot_opts.log_generics)
5246 aot_printf (acfg, "%*sAdding method %s.\n", depth, "", mono_method_get_full_name (method));
5247
5248 add_method (acfg, method);
5249 }
5250
5251 /* Add superclasses */
5252 if (m_class_get_parent (klass))
5253 add_generic_class_with_depth (acfg, m_class_get_parent (klass), depth, "parent");
5254
5255 const char *klass_name = m_class_get_name (klass);
5256 const char *klass_name_space = m_class_get_name_space (klass);
5257 const gboolean in_corlib = m_class_get_image (klass) == mono_defaults.corlib;
5258 /*
5259 * For ICollection<T>, add instances of the helper methods
5260 * in Array, since a T[] could be cast to ICollection<T>.
5261 */
5262 if (in_corlib && !strcmp (klass_name_space, "System.Collections.Generic") &&
5263 (!strcmp(klass_name, "ICollection`1") || !strcmp (klass_name, "IEnumerable`1") || !strcmp (klass_name, "IList`1") || !strcmp (klass_name, "IEnumerator`1") || !strcmp (klass_name, "IReadOnlyList`1"))) {
5264 MonoClass *tclass = mono_class_from_mono_type_internal (mono_class_get_generic_class (klass)->context.class_inst->type_argv [0]);
5265 MonoClass *array_class = mono_class_create_bounded_array (tclass, 1, FALSE);
5266 gpointer iter;
5267 char *name_prefix;
5268
5269 if (!strcmp (klass_name, "IEnumerator`1"))
5270 name_prefix = g_strdup_printf ("%s.%s", klass_name_space, "IEnumerable`1");
5271 else
5272 name_prefix = g_strdup_printf ("%s.%s", klass_name_space, klass_name);
5273
5274 #ifndef ENABLE_NETCORE
5275 /* Add the T[]/InternalEnumerator class */
5276 if (!strcmp (klass_name, "IEnumerable`1") || !strcmp (klass_name, "IEnumerator`1")) {
5277 ERROR_DECL (error);
5278 MonoClass *nclass;
5279
5280 iter = NULL;
5281 while ((nclass = mono_class_get_nested_types (m_class_get_parent (array_class), &iter))) {
5282 if (!strcmp (m_class_get_name (nclass), "InternalEnumerator`1"))
5283 break;
5284 }
5285 g_assert (nclass);
5286 nclass = mono_class_inflate_generic_class_checked (nclass, mono_generic_class_get_context (mono_class_get_generic_class (klass)), error);
5287 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5288 add_generic_class (acfg, nclass, FALSE, "ICollection<T>");
5289 }
5290 #endif
5291
5292 iter = NULL;
5293 while ((method = mono_class_get_methods (array_class, &iter))) {
5294 if (!strncmp (method->name, name_prefix, strlen (name_prefix))) {
5295 MonoMethod *m = mono_aot_get_array_helper_from_wrapper (method);
5296
5297 if (m->is_inflated && !mono_method_is_generic_sharable_full (m, FALSE, FALSE, FALSE))
5298 add_extra_method_with_depth (acfg, m, depth);
5299 }
5300 }
5301
5302 g_free (name_prefix);
5303 }
5304
5305 /* Add an instance of GenericComparer<T> which is created dynamically by Comparer<T> */
5306 if (in_corlib && !strcmp (klass_name_space, "System.Collections.Generic") && !strcmp (klass_name, "Comparer`1")) {
5307 ERROR_DECL (error);
5308 MonoClass *tclass = mono_class_from_mono_type_internal (mono_class_get_generic_class (klass)->context.class_inst->type_argv [0]);
5309 MonoClass *icomparable, *gcomparer, *icomparable_inst;
5310 MonoGenericContext ctx;
5311 MonoType *args [16];
5312
5313 memset (&ctx, 0, sizeof (ctx));
5314
5315 icomparable = mono_class_load_from_name (mono_defaults.corlib, "System", "IComparable`1");
5316
5317 args [0] = m_class_get_byval_arg (tclass);
5318 ctx.class_inst = mono_metadata_get_generic_inst (1, args);
5319
5320 icomparable_inst = mono_class_inflate_generic_class_checked (icomparable, &ctx, error);
5321 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5322
5323 if (mono_class_is_assignable_from_internal (icomparable_inst, tclass)) {
5324 MonoClass *gcomparer_inst;
5325 gcomparer = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "GenericComparer`1");
5326 gcomparer_inst = mono_class_inflate_generic_class_checked (gcomparer, &ctx, error);
5327 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5328
5329 add_generic_class (acfg, gcomparer_inst, FALSE, "Comparer<T>");
5330 }
5331 }
5332
5333 /* Add an instance of GenericEqualityComparer<T> which is created dynamically by EqualityComparer<T> */
5334 if (in_corlib && !strcmp (klass_name_space, "System.Collections.Generic") && !strcmp (klass_name, "EqualityComparer`1")) {
5335 ERROR_DECL (error);
5336 MonoClass *tclass = mono_class_from_mono_type_internal (mono_class_get_generic_class (klass)->context.class_inst->type_argv [0]);
5337 MonoClass *iface, *gcomparer, *iface_inst;
5338 MonoGenericContext ctx;
5339 MonoType *args [16];
5340
5341 memset (&ctx, 0, sizeof (ctx));
5342
5343 iface = mono_class_load_from_name (mono_defaults.corlib, "System", "IEquatable`1");
5344 g_assert (iface);
5345 args [0] = m_class_get_byval_arg (tclass);
5346 ctx.class_inst = mono_metadata_get_generic_inst (1, args);
5347
5348 iface_inst = mono_class_inflate_generic_class_checked (iface, &ctx, error);
5349 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5350
5351 if (mono_class_is_assignable_from_internal (iface_inst, tclass)) {
5352 MonoClass *gcomparer_inst;
5353 ERROR_DECL (error);
5354
5355 gcomparer = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "GenericEqualityComparer`1");
5356 gcomparer_inst = mono_class_inflate_generic_class_checked (gcomparer, &ctx, error);
5357 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5358 add_generic_class (acfg, gcomparer_inst, FALSE, "EqualityComparer<T>");
5359 }
5360 }
5361
5362 /* Add an instance of EnumComparer<T> which is created dynamically by EqualityComparer<T> for enums */
5363 if (in_corlib && !strcmp (klass_name_space, "System.Collections.Generic") && !strcmp (klass_name, "EqualityComparer`1")) {
5364 MonoClass *enum_comparer;
5365 MonoClass *tclass = mono_class_from_mono_type_internal (mono_class_get_generic_class (klass)->context.class_inst->type_argv [0]);
5366 MonoGenericContext ctx;
5367 MonoType *args [16];
5368
5369 if (m_class_is_enumtype (tclass)) {
5370 MonoClass *enum_comparer_inst;
5371 ERROR_DECL (error);
5372
5373 memset (&ctx, 0, sizeof (ctx));
5374 args [0] = m_class_get_byval_arg (tclass);
5375 ctx.class_inst = mono_metadata_get_generic_inst (1, args);
5376
5377 enum_comparer = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "EnumEqualityComparer`1");
5378 enum_comparer_inst = mono_class_inflate_generic_class_checked (enum_comparer, &ctx, error);
5379 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5380 add_generic_class (acfg, enum_comparer_inst, FALSE, "EqualityComparer<T>");
5381 }
5382 }
5383
5384 /* Add an instance of ObjectComparer<T> which is created dynamically by Comparer<T> for enums */
5385 if (in_corlib && !strcmp (klass_name_space, "System.Collections.Generic") && !strcmp (klass_name, "Comparer`1")) {
5386 MonoClass *comparer;
5387 MonoClass *tclass = mono_class_from_mono_type_internal (mono_class_get_generic_class (klass)->context.class_inst->type_argv [0]);
5388 MonoGenericContext ctx;
5389 MonoType *args [16];
5390
5391 if (m_class_is_enumtype (tclass)) {
5392 MonoClass *comparer_inst;
5393 ERROR_DECL (error);
5394
5395 memset (&ctx, 0, sizeof (ctx));
5396 args [0] = m_class_get_byval_arg (tclass);
5397 ctx.class_inst = mono_metadata_get_generic_inst (1, args);
5398
5399 comparer = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "ObjectComparer`1");
5400 comparer_inst = mono_class_inflate_generic_class_checked (comparer, &ctx, error);
5401 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5402 add_generic_class (acfg, comparer_inst, FALSE, "Comparer<T>");
5403 }
5404 }
5405 }
5406
5407 static void
5408 add_instances_of (MonoAotCompile *acfg, MonoClass *klass, MonoType **insts, int ninsts, gboolean force)
5409 {
5410 int i;
5411 MonoGenericContext ctx;
5412 MonoType *args [16];
5413
5414 if (acfg->aot_opts.no_instances)
5415 return;
5416
5417 memset (&ctx, 0, sizeof (ctx));
5418
5419 for (i = 0; i < ninsts; ++i) {
5420 ERROR_DECL (error);
5421 MonoClass *generic_inst;
5422 args [0] = insts [i];
5423 ctx.class_inst = mono_metadata_get_generic_inst (1, args);
5424 generic_inst = mono_class_inflate_generic_class_checked (klass, &ctx, error);
5425 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5426 add_generic_class (acfg, generic_inst, force, "");
5427 }
5428 }
5429
5430 static void
5431 add_types_from_method_header (MonoAotCompile *acfg, MonoMethod *method)
5432 {
5433 ERROR_DECL (error);
5434 MonoMethodHeader *header;
5435 MonoMethodSignature *sig;
5436 int j, depth;
5437
5438 depth = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->method_depth, method));
5439
5440 sig = mono_method_signature_internal (method);
5441
5442 if (sig) {
5443 for (j = 0; j < sig->param_count; ++j)
5444 if (sig->params [j]->type == MONO_TYPE_GENERICINST)
5445 add_generic_class_with_depth (acfg, mono_class_from_mono_type_internal (sig->params [j]), depth + 1, "arg");
5446 }
5447
5448 header = mono_method_get_header_checked (method, error);
5449
5450 if (header) {
5451 for (j = 0; j < header->num_locals; ++j)
5452 if (header->locals [j]->type == MONO_TYPE_GENERICINST)
5453 add_generic_class_with_depth (acfg, mono_class_from_mono_type_internal (header->locals [j]), depth + 1, "local");
5454 mono_metadata_free_mh (header);
5455 } else {
5456 mono_error_cleanup (error); /* FIXME report the error */
5457 }
5458
5459 }
5460
5461 /*
5462 * add_generic_instances:
5463 *
5464 * Add instances referenced by the METHODSPEC/TYPESPEC table.
5465 */
5466 static void
5467 add_generic_instances (MonoAotCompile *acfg)
5468 {
5469 int i;
5470 guint32 token;
5471 MonoMethod *method;
5472 MonoGenericContext *context;
5473
5474 if (acfg->aot_opts.no_instances)
5475 return;
5476
5477 for (i = 0; i < acfg->image->tables [MONO_TABLE_METHODSPEC].rows; ++i) {
5478 ERROR_DECL (error);
5479 token = MONO_TOKEN_METHOD_SPEC | (i + 1);
5480 method = mono_get_method_checked (acfg->image, token, NULL, NULL, error);
5481
5482 if (!method) {
5483 aot_printerrf (acfg, "Failed to load methodspec 0x%x due to %s.\n", token, mono_error_get_message (error));
5484 aot_printerrf (acfg, "Run with MONO_LOG_LEVEL=debug for more information.\n");
5485 mono_error_cleanup (error);
5486 continue;
5487 }
5488
5489 if (m_class_get_image (method->klass) != acfg->image)
5490 continue;
5491
5492 context = mono_method_get_context (method);
5493
5494 if (context && ((context->class_inst && context->class_inst->is_open)))
5495 continue;
5496
5497 /*
5498 * For open methods, create an instantiation which can be passed to the JIT.
5499 * FIXME: Handle class_inst as well.
5500 */
5501 if (context && context->method_inst && context->method_inst->is_open) {
5502 ERROR_DECL (error);
5503 MonoGenericContext shared_context;
5504 MonoGenericInst *inst;
5505 MonoType **type_argv;
5506 int i;
5507 MonoMethod *declaring_method;
5508 gboolean supported = TRUE;
5509
5510 /* Check that the context doesn't contain open constructed types */
5511 if (context->class_inst) {
5512 inst = context->class_inst;
5513 for (i = 0; i < inst->type_argc; ++i) {
5514 if (MONO_TYPE_IS_REFERENCE (inst->type_argv [i]) || inst->type_argv [i]->type == MONO_TYPE_VAR || inst->type_argv [i]->type == MONO_TYPE_MVAR)
5515 continue;
5516 if (mono_class_is_open_constructed_type (inst->type_argv [i]))
5517 supported = FALSE;
5518 }
5519 }
5520 if (context->method_inst) {
5521 inst = context->method_inst;
5522 for (i = 0; i < inst->type_argc; ++i) {
5523 if (MONO_TYPE_IS_REFERENCE (inst->type_argv [i]) || inst->type_argv [i]->type == MONO_TYPE_VAR || inst->type_argv [i]->type == MONO_TYPE_MVAR)
5524 continue;
5525 if (mono_class_is_open_constructed_type (inst->type_argv [i]))
5526 supported = FALSE;
5527 }
5528 }
5529
5530 if (!supported)
5531 continue;
5532
5533 memset (&shared_context, 0, sizeof (MonoGenericContext));
5534
5535 inst = context->class_inst;
5536 if (inst) {
5537 type_argv = g_new0 (MonoType*, inst->type_argc);
5538 for (i = 0; i < inst->type_argc; ++i) {
5539 if (MONO_TYPE_IS_REFERENCE (inst->type_argv [i]) || inst->type_argv [i]->type == MONO_TYPE_VAR || inst->type_argv [i]->type == MONO_TYPE_MVAR)
5540 type_argv [i] = mono_get_object_type ();
5541 else
5542 type_argv [i] = inst->type_argv [i];
5543 }
5544
5545 shared_context.class_inst = mono_metadata_get_generic_inst (inst->type_argc, type_argv);
5546 g_free (type_argv);
5547 }
5548
5549 inst = context->method_inst;
5550 if (inst) {
5551 type_argv = g_new0 (MonoType*, inst->type_argc);
5552 for (i = 0; i < inst->type_argc; ++i) {
5553 if (MONO_TYPE_IS_REFERENCE (inst->type_argv [i]) || inst->type_argv [i]->type == MONO_TYPE_VAR || inst->type_argv [i]->type == MONO_TYPE_MVAR)
5554 type_argv [i] = mono_get_object_type ();
5555 else
5556 type_argv [i] = inst->type_argv [i];
5557 }
5558
5559 shared_context.method_inst = mono_metadata_get_generic_inst (inst->type_argc, type_argv);
5560 g_free (type_argv);
5561 }
5562
5563 if (method->is_generic || mono_class_is_gtd (method->klass))
5564 declaring_method = method;
5565 else
5566 declaring_method = mono_method_get_declaring_generic_method (method);
5567
5568 method = mono_class_inflate_generic_method_checked (declaring_method, &shared_context, error);
5569 g_assert (is_ok (error)); /* FIXME don't swallow the error */
5570 }
5571
5572 /*
5573 * If the method is fully sharable, it was already added in place of its
5574 * generic definition.
5575 */
5576 if (mono_method_is_generic_sharable_full (method, FALSE, FALSE, FALSE))
5577 continue;
5578
5579 /*
5580 * FIXME: Partially shared methods are not shared here, so we end up with
5581 * many identical methods.
5582 */
5583 add_extra_method (acfg, method);
5584 }
5585
5586 for (i = 0; i < acfg->image->tables [MONO_TABLE_TYPESPEC].rows; ++i) {
5587 ERROR_DECL (error);
5588 MonoClass *klass;
5589
5590 token = MONO_TOKEN_TYPE_SPEC | (i + 1);
5591
5592 klass = mono_class_get_checked (acfg->image, token, error);
5593 if (!klass || m_class_get_rank (klass)) {
5594 mono_error_cleanup (error);
5595 continue;
5596 }
5597
5598 add_generic_class (acfg, klass, FALSE, "typespec");
5599 }
5600
5601 /* Add types of args/locals */
5602 for (i = 0; i < acfg->methods->len; ++i) {
5603 method = (MonoMethod *)g_ptr_array_index (acfg->methods, i);
5604 add_types_from_method_header (acfg, method);
5605 }
5606
5607 if (acfg->image == mono_defaults.corlib) {
5608 MonoClass *klass;
5609 MonoType *insts [256];
5610 int ninsts = 0;
5611
5612 MonoType *byte_type = m_class_get_byval_arg (mono_defaults.byte_class);
5613 MonoType *sbyte_type = m_class_get_byval_arg (mono_defaults.sbyte_class);
5614 MonoType *int16_type = m_class_get_byval_arg (mono_defaults.int16_class);
5615 MonoType *uint16_type = m_class_get_byval_arg (mono_defaults.uint16_class);
5616 MonoType *int32_type = mono_get_int32_type ();
5617 MonoType *uint32_type = m_class_get_byval_arg (mono_defaults.uint32_class);
5618 MonoType *int64_type = m_class_get_byval_arg (mono_defaults.int64_class);
5619 MonoType *uint64_type = m_class_get_byval_arg (mono_defaults.uint64_class);
5620 MonoType *object_type = mono_get_object_type ();
5621
5622 insts [ninsts ++] = byte_type;
5623 insts [ninsts ++] = sbyte_type;
5624 insts [ninsts ++] = int16_type;
5625 insts [ninsts ++] = uint16_type;
5626 insts [ninsts ++] = int32_type;
5627 insts [ninsts ++] = uint32_type;
5628 insts [ninsts ++] = int64_type;
5629 insts [ninsts ++] = uint64_type;
5630 insts [ninsts ++] = m_class_get_byval_arg (mono_defaults.single_class);
5631 insts [ninsts ++] = m_class_get_byval_arg (mono_defaults.double_class);
5632 insts [ninsts ++] = m_class_get_byval_arg (mono_defaults.char_class);
5633 insts [ninsts ++] = m_class_get_byval_arg (mono_defaults.boolean_class);
5634
5635 /* Add GenericComparer<T> instances for primitive types for Enum.ToString () */
5636 klass = mono_class_try_load_from_name (acfg->image, "System.Collections.Generic", "GenericComparer`1");
5637 if (klass)
5638 add_instances_of (acfg, klass, insts, ninsts, TRUE);
5639 klass = mono_class_try_load_from_name (acfg->image, "System.Collections.Generic", "GenericEqualityComparer`1");
5640 if (klass)
5641 add_instances_of (acfg, klass, insts, ninsts, TRUE);
5642
5643 /* Add instances of EnumEqualityComparer which are created by EqualityComparer<T> for enums */
5644 {
5645 MonoClass *enum_comparer;
5646 MonoType *insts [16];
5647 int ninsts;
5648
5649 ninsts = 0;
5650 insts [ninsts ++] = int32_type;
5651 insts [ninsts ++] = uint32_type;
5652 insts [ninsts ++] = uint16_type;
5653 insts [ninsts ++] = byte_type;
5654 enum_comparer = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "EnumEqualityComparer`1");
5655 add_instances_of (acfg, enum_comparer, insts, ninsts, FALSE);
5656
5657 #ifndef ENABLE_NETCORE
5658 ninsts = 0;
5659 insts [ninsts ++] = int16_type;
5660 enum_comparer = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "ShortEnumEqualityComparer`1");
5661 add_instances_of (acfg, enum_comparer, insts, ninsts, FALSE);
5662
5663 ninsts = 0;
5664 insts [ninsts ++] = sbyte_type;
5665 enum_comparer = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "SByteEnumEqualityComparer`1");
5666 add_instances_of (acfg, enum_comparer, insts, ninsts, FALSE);
5667
5668 enum_comparer = mono_class_load_from_name (mono_defaults.corlib, "System.Collections.Generic", "LongEnumEqualityComparer`1");
5669 ninsts = 0;
5670 insts [ninsts ++] = int64_type;
5671 insts [ninsts ++] = uint64_type;
5672 add_instances_of (acfg, enum_comparer, insts, ninsts, FALSE);
5673 #endif
5674 }
5675
5676 /* Add instances of the array generic interfaces for primitive types */
5677 /* This will add instances of the InternalArray_ helper methods in Array too */
5678 klass = mono_class_try_load_from_name (acfg->image, "System.Collections.Generic", "ICollection`1");
5679 if (klass)
5680 add_instances_of (acfg, klass, insts, ninsts, TRUE);
5681
5682 klass = mono_class_try_load_from_name (acfg->image, "System.Collections.Generic", "IList`1");
5683 if (klass)
5684 add_instances_of (acfg, klass, insts, ninsts, TRUE);
5685
5686 klass = mono_class_try_load_from_name (acfg->image, "System.Collections.Generic", "IEnumerable`1");
5687 if (klass)
5688 add_instances_of (acfg, klass, insts, ninsts, TRUE);
5689
5690 /*
5691 * Add a managed-to-native wrapper of Array.GetGenericValue_icall<object>, which is
5692 * used for all instances of GetGenericValue_icall by the AOT runtime.
5693 */
5694 {
5695 ERROR_DECL (error);
5696 MonoGenericContext ctx;
5697 MonoMethod *get_method;
5698 MonoClass *array_klass = m_class_get_parent (mono_class_create_array (mono_defaults.object_class, 1));
5699
5700 get_method = mono_class_get_method_from_name_checked (array_klass, "GetGenericValue_icall", 3, 0, error);
5701 mono_error_assert_ok (error);
5702
5703 if (get_method) {
5704 memset (&ctx, 0, sizeof (ctx));
5705 MonoType *args [ ] = { object_type };
5706 ctx.method_inst = mono_metadata_get_generic_inst (1, args);
5707 add_extra_method (acfg, mono_marshal_get_native_wrapper (mono_class_inflate_generic_method_checked (get_method, &ctx, error), TRUE, TRUE));
5708 mono_error_assert_ok (error); /* FIXME don't swallow the error */
5709 }
5710 }
5711
5712 /* object[] accessor wrappers. */
5713 for (i = 1; i < 4; ++i) {
5714 MonoClass *obj_array_class = mono_class_create_array (mono_defaults.object_class, i);
5715 MonoMethod *m;
5716
5717 m = get_method_nofail (obj_array_class, "Get", i, 0);
5718 g_assert (m);
5719
5720 m = mono_marshal_get_array_accessor_wrapper (m);
5721 add_extra_method (acfg, m);
5722
5723 m = get_method_nofail (obj_array_class, "Address", i, 0);
5724 g_assert (m);
5725
5726 m = mono_marshal_get_array_accessor_wrapper (m);
5727 add_extra_method (acfg, m);
5728
5729 m = get_method_nofail (obj_array_class, "Set", i + 1, 0);
5730 g_assert (m);
5731
5732 m = mono_marshal_get_array_accessor_wrapper (m);
5733 add_extra_method (acfg, m);
5734 }
5735 }
5736 }
5737
5738 static char *
5739 decode_direct_icall_symbol_name_attribute (MonoMethod *method)
5740 {
5741 ERROR_DECL (error);
5742
5743 int j = 0;
5744 char *symbol_name = NULL;
5745
5746 MonoCustomAttrInfo *cattr = mono_custom_attrs_from_method_checked (method, error);
5747 if (is_ok(error) && cattr) {
5748 for (j = 0; j < cattr->num_attrs; j++)
5749 if (cattr->attrs [j].ctor && !strcmp (m_class_get_name (cattr->attrs [j].ctor->klass), "MonoDirectICallSymbolNameAttribute"))
5750 break;
5751
5752 if (j < cattr->num_attrs) {
5753 MonoCustomAttrEntry *e = &cattr->attrs [j];
5754 MonoMethodSignature *sig = mono_method_signature_internal (e->ctor);
5755 if (e->data && sig && sig->param_count == 1 && sig->params [0]->type == MONO_TYPE_STRING) {
5756 /*
5757 * Decode the cattr manually since we can't create objects
5758 * during aot compilation.
5759 */
5760
5761 /* Skip prolog */
5762 const char *p = ((const char*)e->data) + 2;
5763 int slen = mono_metadata_decode_value (p, &p);
5764
5765 symbol_name = (char *)g_memdup (p, slen + 1);
5766 if (symbol_name)
5767 symbol_name [slen] = 0;
5768 }
5769 }
5770 }
5771
5772 return symbol_name;
5773 }
5774 static const char*
5775 lookup_external_icall_symbol_name_aot (MonoMethod *method)
5776 {
5777 g_assert (method_to_external_icall_symbol_name);
5778
5779 gpointer key, value;
5780 if (g_hash_table_lookup_extended (method_to_external_icall_symbol_name, method, &key, &value))
5781 return (const char*)value;
5782
5783 char *symbol_name = decode_direct_icall_symbol_name_attribute (method);
5784 g_hash_table_insert (method_to_external_icall_symbol_name, method, symbol_name);
5785
5786 return symbol_name;
5787 }
5788
5789 static const char*
5790 lookup_icall_symbol_name_aot (MonoMethod *method)
5791 {
5792 const char * symbol_name = mono_lookup_icall_symbol (method);
5793 if (!symbol_name)
5794 symbol_name = lookup_external_icall_symbol_name_aot (method);
5795
5796 return symbol_name;
5797 }
5798
5799 gboolean
5800 mono_aot_direct_icalls_enabled_for_method (MonoCompile *cfg, MonoMethod *method)
5801 {
5802 gboolean enable_icall = FALSE;
5803 if (cfg->compile_aot)
5804 enable_icall = lookup_external_icall_symbol_name_aot (method) ? TRUE : FALSE;
5805 else
5806 enable_icall = FALSE;
5807
5808 return enable_icall;
5809 }
5810
5811 /*
5812 * is_direct_callable:
5813 *
5814 * Return whenever the method identified by JI is directly callable without
5815 * going through the PLT.
5816 */
5817 static gboolean
5818 is_direct_callable (MonoAotCompile *acfg, MonoMethod *method, MonoJumpInfo *patch_info)
5819 {
5820 if ((patch_info->type == MONO_PATCH_INFO_METHOD) && (m_class_get_image (patch_info->data.method->klass) == acfg->image)) {
5821 MonoCompile *callee_cfg = (MonoCompile *)g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
5822 if (callee_cfg) {
5823 gboolean direct_callable = TRUE;
5824
5825 if (direct_callable && (acfg->aot_opts.dedup || acfg->aot_opts.dedup_include) && mono_aot_can_dedup (patch_info->data.method))
5826 direct_callable = FALSE;
5827
5828 if (direct_callable && (!acfg->llvm || acfg->aot_opts.llvm_disable_self_init) && !(!callee_cfg->has_got_slots && mono_class_is_before_field_init (callee_cfg->method->klass)))
5829 direct_callable = FALSE;
5830
5831 if (direct_callable && !strcmp (callee_cfg->method->name, ".cctor"))
5832 direct_callable = FALSE;
5833
5834 //
5835 // FIXME: Support inflated methods, it asserts in mini_llvm_init_gshared_method_this () because the method is not in
5836 // amodule->extra_methods.
5837 //
5838 if (direct_callable && callee_cfg->method->is_inflated)
5839 direct_callable = FALSE;
5840
5841 if (direct_callable && (callee_cfg->method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) && (!method || method->wrapper_type != MONO_WRAPPER_SYNCHRONIZED))
5842 // FIXME: Maybe call the wrapper directly ?
5843 direct_callable = FALSE;
5844
5845 if (direct_callable && (acfg->aot_opts.soft_debug || acfg->aot_opts.no_direct_calls)) {
5846 /* Disable this so all calls go through load_method (), see the
5847 * mini_get_debug_options ()->load_aot_jit_info_eagerly = TRUE; line in
5848 * mono_debugger_agent_init ().
5849 */
5850 direct_callable = FALSE;
5851 }
5852
5853 if (direct_callable && (callee_cfg->method->wrapper_type == MONO_WRAPPER_ALLOC))
5854 /* sgen does some initialization when the allocator method is created */
5855 direct_callable = FALSE;
5856 if (direct_callable && (callee_cfg->method->wrapper_type == MONO_WRAPPER_WRITE_BARRIER))
5857 /* we don't know at compile time whether sgen is concurrent or not */
5858 direct_callable = FALSE;
5859
5860 if (direct_callable)
5861 return TRUE;
5862 }
5863 } else if ((patch_info->type == MONO_PATCH_INFO_ICALL_ADDR_CALL && patch_info->data.method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) {
5864 if (acfg->aot_opts.direct_pinvoke)
5865 return TRUE;
5866 } else if (patch_info->type == MONO_PATCH_INFO_ICALL_ADDR_CALL) {
5867 if (acfg->aot_opts.direct_icalls)
5868 return TRUE;
5869 return FALSE;
5870 }
5871
5872 return FALSE;
5873 }
5874
5875 #ifdef MONO_ARCH_AOT_SUPPORTED
5876 static const char *
5877 get_pinvoke_import (MonoAotCompile *acfg, MonoMethod *method)
5878 {
5879 MonoImage *image = m_class_get_image (method->klass);
5880 MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *) method;
5881 MonoTableInfo *tables = image->tables;
5882 MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
5883 MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
5884 guint32 im_cols [MONO_IMPLMAP_SIZE];
5885 char *import;
5886
5887 import = (char *)g_hash_table_lookup (acfg->method_to_pinvoke_import, method);
5888 if (import != NULL)
5889 return import;
5890
5891 if (!piinfo->implmap_idx || piinfo->implmap_idx > im->rows)
5892 return NULL;
5893
5894 mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
5895
5896 if (!im_cols [MONO_IMPLMAP_SCOPE] || im_cols [MONO_IMPLMAP_SCOPE] > mr->rows)
5897 return NULL;
5898
5899 import = g_strdup_printf ("%s", mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]));
5900
5901 g_hash_table_insert (acfg->method_to_pinvoke_import, method, import);
5902
5903 return import;
5904 }
5905 #else
5906 static const char *
5907 get_pinvoke_import (MonoAotCompile *acfg, MonoMethod *method)
5908 {
5909 return NULL;
5910 }
5911 #endif
5912
5913 static gint
5914 compare_lne (MonoDebugLineNumberEntry *a, MonoDebugLineNumberEntry *b)
5915 {
5916 if (a->native_offset == b->native_offset)
5917 return a->il_offset - b->il_offset;
5918 else
5919 return a->native_offset - b->native_offset;
5920 }
5921
5922 /*
5923 * compute_line_numbers:
5924 *
5925 * Returns a sparse array of size CODE_SIZE containing MonoDebugSourceLocation* entries for the native offsets which have a corresponding line number
5926 * entry.
5927 */
5928 static MonoDebugSourceLocation**
5929 compute_line_numbers (MonoMethod *method, int code_size, MonoDebugMethodJitInfo *debug_info)
5930 {
5931 MonoDebugMethodInfo *minfo;
5932 MonoDebugLineNumberEntry *ln_array;
5933 MonoDebugSourceLocation *loc;
5934 int i, prev_line, prev_il_offset;
5935 int *native_to_il_offset = NULL;
5936 MonoDebugSourceLocation **res;
5937 gboolean first;
5938
5939 minfo = mono_debug_lookup_method (method);
5940 if (!minfo)
5941 return NULL;
5942 // FIXME: This seems to happen when two methods have the same cfg->method_to_register
5943 if (debug_info->code_size != code_size)
5944 return NULL;
5945
5946 g_assert (code_size);
5947
5948 /* Compute the native->IL offset mapping */
5949
5950 ln_array = g_new0 (MonoDebugLineNumberEntry, debug_info->num_line_numbers);
5951 memcpy (ln_array, debug_info->line_numbers, debug_info->num_line_numbers * sizeof (MonoDebugLineNumberEntry));
5952
5953 mono_qsort (ln_array, debug_info->num_line_numbers, sizeof (MonoDebugLineNumberEntry), (int (*)(const void *, const void *))compare_lne);
5954
5955 native_to_il_offset = g_new0 (int, code_size + 1);
5956
5957 for (i = 0; i < debug_info->num_line_numbers; ++i) {
5958 int j;
5959 MonoDebugLineNumberEntry *lne = &ln_array [i];
5960
5961 if (i == 0) {
5962 for (j = 0; j < lne->native_offset; ++j)
5963 native_to_il_offset [j] = -1;
5964 }
5965
5966 if (i < debug_info->num_line_numbers - 1) {
5967 MonoDebugLineNumberEntry *lne_next = &ln_array [i + 1];
5968
5969 for (j = lne->native_offset; j < lne_next->native_offset; ++j)
5970 native_to_il_offset [j] = lne->il_offset;
5971 } else {
5972 for (j = lne->native_offset; j < code_size; ++j)
5973 native_to_il_offset [j] = lne->il_offset;
5974 }
5975 }
5976 g_free (ln_array);
5977
5978 /* Compute the native->line number mapping */
5979 res = g_new0 (MonoDebugSourceLocation*, code_size);
5980 prev_il_offset = -1;
5981 prev_line = -1;
5982 first = TRUE;
5983 for (i = 0; i < code_size; ++i) {
5984 int il_offset = native_to_il_offset [i];
5985
5986 if (il_offset == -1 || il_offset == prev_il_offset)
5987 continue;
5988 prev_il_offset = il_offset;
5989 loc = mono_debug_method_lookup_location (minfo, il_offset);
5990 if (!(loc && loc->source_file))
5991 continue;
5992 if (loc->row == prev_line) {
5993 mono_debug_free_source_location (loc);
5994 continue;
5995 }
5996 prev_line = loc->row;
5997 //printf ("D: %s:%d il=%x native=%x\n", loc->source_file, loc->row, il_offset, i);
5998 if (first)
5999 /* This will cover the prolog too */
6000 res [0] = loc;
6001 else
6002 res [i] = loc;
6003 first = FALSE;
6004 }
6005 return res;
6006 }
6007
6008 static int
6009 get_file_index (MonoAotCompile *acfg, const char *source_file)
6010 {
6011 int findex;
6012
6013 // FIXME: Free these
6014 if (!acfg->dwarf_ln_filenames)
6015 acfg->dwarf_ln_filenames = g_hash_table_new (g_str_hash, g_str_equal);
6016 findex = GPOINTER_TO_INT (g_hash_table_lookup (acfg->dwarf_ln_filenames, source_file));
6017 if (!findex) {
6018 findex = g_hash_table_size (acfg->dwarf_ln_filenames) + 1;
6019 g_hash_table_insert (acfg->dwarf_ln_filenames, g_strdup (source_file), GINT_TO_POINTER (findex));
6020 emit_unset_mode (acfg);
6021 fprintf (acfg->fp, ".file %d \"%s\"\n", findex, mono_dwarf_escape_path (source_file));
6022 }
6023 return findex;
6024 }
6025
6026 #ifdef TARGET_ARM64
6027 #define INST_LEN 4
6028 #else
6029 #define INST_LEN 1
6030 #endif
6031
6032 /*
6033 * emit_and_reloc_code:
6034 *
6035 * Emit the native code in CODE, handling relocations along the way. If GOT_ONLY
6036 * is true, calls are made through the GOT too. This is used for emitting trampolines
6037 * in full-aot mode, since calls made from trampolines couldn't go through the PLT,
6038 * since trampolines are needed to make PLT work.
6039 */
6040 static void
6041 emit_and_reloc_code (MonoAotCompile *acfg, MonoMethod *method, guint8 *code, guint32 code_len, MonoJumpInfo *relocs, gboolean got_only, MonoDebugMethodJitInfo *debug_info)
6042 {
6043 int i, pindex, start_index;
6044 GPtrArray *patches;
6045 MonoJumpInfo *patch_info;
6046 MonoDebugSourceLocation **locs = NULL;
6047 gboolean skip, prologue_end = FALSE;
6048 #ifdef MONO_ARCH_AOT_SUPPORTED
6049 gboolean direct_call, external_call;
6050 guint32 got_slot;
6051 const char *direct_call_target = 0;
6052 const char *direct_pinvoke;
6053 #endif
6054
6055 if (acfg->gas_line_numbers && method && debug_info) {
6056 locs = compute_line_numbers (method, code_len, debug_info);
6057 if (!locs) {
6058 int findex = get_file_index (acfg, "<unknown>");
6059 emit_unset_mode (acfg);
6060 fprintf (acfg->fp, ".loc %d %d 0\n", findex, 1);
6061 }
6062 }
6063
6064 /* Collect and sort relocations */
6065 patches = g_ptr_array_new ();
6066 for (patch_info = relocs; patch_info; patch_info = patch_info->next)
6067 g_ptr_array_add (patches, patch_info);
6068 g_ptr_array_sort (patches, compare_patches);
6069
6070 start_index = 0;
6071 for (i = 0; i < code_len; i += INST_LEN) {
6072 patch_info = NULL;
6073 for (pindex = start_index; pindex < patches->len; ++pindex) {
6074 patch_info = (MonoJumpInfo *)g_ptr_array_index (patches, pindex);
6075 if (patch_info->ip.i >= i)
6076 break;
6077 }
6078
6079 if (locs && locs [i]) {
6080 MonoDebugSourceLocation *loc = locs [i];
6081 int findex;
6082 const char *options;
6083
6084 findex = get_file_index (acfg, loc->source_file);
6085 emit_unset_mode (acfg);
6086 if (!prologue_end)
6087 options = " prologue_end";
6088 else
6089 options = "";
6090 prologue_end = TRUE;
6091 fprintf (acfg->fp, ".loc %d %d 0%s\n", findex, loc->row, options);
6092 mono_debug_free_source_location (loc);
6093 }
6094
6095 skip = FALSE;
6096 #ifdef MONO_ARCH_AOT_SUPPORTED
6097 if (patch_info && (patch_info->ip.i == i) && (pindex < patches->len)) {
6098 start_index = pindex;
6099
6100 switch (patch_info->type) {
6101 case MONO_PATCH_INFO_NONE:
6102 break;
6103 case MONO_PATCH_INFO_GOT_OFFSET: {
6104 int code_size;
6105
6106 arch_emit_got_offset (acfg, code + i, &code_size);
6107 i += code_size - INST_LEN;
6108 skip = TRUE;
6109 patch_info->type = MONO_PATCH_INFO_NONE;
6110 break;
6111 }
6112 case MONO_PATCH_INFO_OBJC_SELECTOR_REF: {
6113 int code_size, index;
6114 char *selector = (char *)patch_info->data.target;
6115
6116 if (!acfg->objc_selector_to_index)
6117 acfg->objc_selector_to_index = g_hash_table_new (g_str_hash, g_str_equal);
6118 if (!acfg->objc_selectors)
6119 acfg->objc_selectors = g_ptr_array_new ();
6120 index = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->objc_selector_to_index, selector));
6121 if (index)
6122 index --;
6123 else {
6124 index = acfg->objc_selector_index;
6125 g_ptr_array_add (acfg->objc_selectors, (void*)patch_info->data.target);
6126 g_hash_table_insert (acfg->objc_selector_to_index, selector, GUINT_TO_POINTER (index + 1));
6127 acfg->objc_selector_index ++;
6128 }
6129
6130 arch_emit_objc_selector_ref (acfg, code + i, index, &code_size);
6131 i += code_size - INST_LEN;
6132 skip = TRUE;
6133 patch_info->type = MONO_PATCH_INFO_NONE;
6134 break;
6135 }
6136 default: {
6137 /*
6138 * If this patch is a call, try emitting a direct call instead of
6139 * through a PLT entry. This is possible if the called method is in
6140 * the same assembly and requires no initialization.
6141 */
6142 direct_call = FALSE;
6143 external_call = FALSE;
6144 if ((patch_info->type == MONO_PATCH_INFO_METHOD) && (m_class_get_image (patch_info->data.method->klass) == acfg->image)) {
6145 if (!got_only && is_direct_callable (acfg, method, patch_info)) {
6146 MonoCompile *callee_cfg = (MonoCompile *)g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
6147
6148 // Don't compile inflated methods if we're doing dedup
6149 if (acfg->aot_opts.dedup && !mono_aot_can_dedup (patch_info->data.method)) {
6150 char *name = mono_aot_get_mangled_method_name (patch_info->data.method);
6151 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_AOT, "DIRECT CALL: %s by %s", name, method ? mono_method_full_name (method, TRUE) : "");
6152 g_free (name);
6153
6154 direct_call = TRUE;
6155 direct_call_target = callee_cfg->asm_symbol;
6156 patch_info->type = MONO_PATCH_INFO_NONE;
6157 acfg->stats.direct_calls ++;
6158 }
6159 }
6160
6161 acfg->stats.all_calls ++;
6162 } else if (patch_info->type == MONO_PATCH_INFO_ICALL_ADDR_CALL) {
6163 if (!got_only && is_direct_callable (acfg, method, patch_info)) {
6164 if (!(patch_info->data.method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
6165 direct_pinvoke = lookup_icall_symbol_name_aot (patch_info->data.method);
6166 else
6167 direct_pinvoke = get_pinvoke_import (acfg, patch_info->data.method);
6168 if (direct_pinvoke) {
6169 direct_call = TRUE;
6170 g_assert (strlen (direct_pinvoke) < 1000);
6171 direct_call_target = g_strdup_printf ("%s%s", acfg->user_symbol_prefix, direct_pinvoke);
6172 }
6173 }
6174 } else if (patch_info->type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
6175 const char *sym = mono_find_jit_icall_info (patch_info->data.jit_icall_id)->c_symbol;
6176 if (!got_only && sym && acfg->aot_opts.direct_icalls) {
6177 /* Call to a C function implementing a jit icall */
6178 direct_call = TRUE;
6179 external_call = TRUE;
6180 g_assert (strlen (sym) < 1000);
6181 direct_call_target = g_strdup_printf ("%s%s", acfg->user_symbol_prefix, sym);
6182 }
6183 } else if (patch_info->type == MONO_PATCH_INFO_JIT_ICALL_ID) {
6184 MonoJitICallInfo * const info = mono_find_jit_icall_info (patch_info->data.jit_icall_id);
6185 const char * const sym = info->c_symbol;
6186 if (!got_only && sym && acfg->aot_opts.direct_icalls && info->func == info->wrapper) {
6187 /* Call to a jit icall without a wrapper */
6188 direct_call = TRUE;
6189 external_call = TRUE;
6190 g_assert (strlen (sym) < 1000);
6191 direct_call_target = g_strdup_printf ("%s%s", acfg->user_symbol_prefix, sym);
6192 }
6193 }
6194 if (direct_call) {
6195 patch_info->type = MONO_PATCH_INFO_NONE;
6196 acfg->stats.direct_calls ++;
6197 }
6198
6199 if (!got_only && !direct_call) {
6200 MonoPltEntry *plt_entry = get_plt_entry (acfg, patch_info);
6201 if (plt_entry) {
6202 /* This patch has a PLT entry, so we must emit a call to the PLT entry */
6203 direct_call = TRUE;
6204 direct_call_target = plt_entry->symbol;
6205
6206 /* Nullify the patch */
6207 patch_info->type = MONO_PATCH_INFO_NONE;
6208 plt_entry->jit_used = TRUE;
6209 }
6210 }
6211
6212 if (direct_call) {
6213 int call_size;
6214
6215 arch_emit_direct_call (acfg, direct_call_target, external_call, FALSE, patch_info, &call_size);
6216 i += call_size - INST_LEN;
6217 } else {
6218 int code_size;
6219
6220 got_slot = get_got_offset (acfg, FALSE, patch_info);
6221
6222 arch_emit_got_access (acfg, acfg->got_symbol, code + i, got_slot, &code_size);
6223 i += code_size - INST_LEN;
6224 }
6225 skip = TRUE;
6226 }
6227 }
6228 }
6229 #endif /* MONO_ARCH_AOT_SUPPORTED */
6230
6231 if (!skip) {
6232 /* Find next patch */
6233 patch_info = NULL;
6234 for (pindex = start_index; pindex < patches->len; ++pindex) {
6235 patch_info = (MonoJumpInfo *)g_ptr_array_index (patches, pindex);
6236 if (patch_info->ip.i >= i)
6237 break;
6238 }
6239
6240 /* Try to emit multiple bytes at once */
6241 if (pindex < patches->len && patch_info->ip.i > i) {
6242 int limit;
6243
6244 for (limit = i + INST_LEN; limit < patch_info->ip.i; limit += INST_LEN) {
6245 if (locs && locs [limit])
6246 break;
6247 }
6248
6249 emit_code_bytes (acfg, code + i, limit - i);
6250 i = limit - INST_LEN;
6251 } else {
6252 emit_code_bytes (acfg, code + i, INST_LEN);
6253 }
6254 }
6255 }
6256
6257 g_ptr_array_free (patches, TRUE);
6258 g_free (locs);
6259 }
6260
6261 /*
6262 * sanitize_symbol:
6263 *
6264 * Return a modified version of S which only includes characters permissible in symbols.
6265 */
6266 static char*
6267 sanitize_symbol (MonoAotCompile *acfg, char *s)
6268 {
6269 gboolean process = FALSE;
6270 int i, len;
6271 GString *gs;
6272 char *res;
6273
6274 if (!s)
6275 return s;
6276
6277 len = strlen (s);
6278 for (i = 0; i < len; ++i)
6279 if (!(s [i] <= 0x7f && (isalnum (s [i]) || s [i] == '_')))
6280 process = TRUE;
6281 if (!process)
6282 return s;
6283
6284 gs = g_string_sized_new (len);
6285 for (i = 0; i < len; ++i) {
6286 guint8 c = s [i];
6287 if (c <= 0x7f && (isalnum (c) || c == '_')) {
6288 g_string_append_c (gs, c);
6289 } else if (c > 0x7f) {
6290 /* multi-byte utf8 */
6291 g_string_append_printf (gs, "_0x%x", c);
6292 i ++;
6293 c = s [i];
6294 while (c >> 6 == 0x2) {
6295 g_string_append_printf (gs, "%x", c);
6296 i ++;
6297 c = s [i];
6298 }
6299 g_string_append_printf (gs, "_");
6300 i --;
6301 } else {
6302 g_string_append_c (gs, '_');
6303 }
6304 }
6305
6306 res = mono_mempool_strdup (acfg->mempool, gs->str);
6307 g_string_free (gs, TRUE);
6308 return res;
6309 }
6310
6311 static char*
6312 get_debug_sym (MonoMethod *method, const char *prefix, GHashTable *cache)
6313 {
6314 char *name1, *name2, *cached;
6315 int i, j, len, count;
6316 MonoMethod *cached_method;
6317
6318 name1 = mono_method_full_name (method, TRUE);
6319
6320 #ifdef TARGET_MACH
6321 // This is so that we don't accidentally create a local symbol (which starts with 'L')
6322 if ((!prefix || !*prefix) && name1 [0] == 'L')
6323 prefix = "_";
6324 #endif
6325
6326 #if defined(TARGET_WIN32) && defined(TARGET_X86)
6327 char adjustedPrefix [MAX_SYMBOL_SIZE];
6328 prefix = mangle_symbol (prefix, adjustedPrefix, G_N_ELEMENTS (adjustedPrefix));
6329 #endif
6330
6331 len = strlen (name1);
6332 name2 = (char *) g_malloc (strlen (prefix) + len + 16);
6333 memcpy (name2, prefix, strlen (prefix));
6334 j = strlen (prefix);
6335 for (i = 0; i < len; ++i) {
6336 if (i == 0 && name1 [0] >= '0' && name1 [0] <= '9') {
6337 name2 [j ++] = '_';
6338 } else if (isalnum (name1 [i])) {
6339 name2 [j ++] = name1 [i];
6340 } else if (name1 [i] == ' ' && name1 [i + 1] == '(' && name1 [i + 2] == ')') {
6341 i += 2;
6342 } else if (name1 [i] == ',' && name1 [i + 1] == ' ') {
6343 name2 [j ++] = '_';
6344 i++;
6345 } else if (name1 [i] == '(' || name1 [i] == ')' || name1 [i] == '>') {
6346 } else
6347 name2 [j ++] = '_';
6348 }
6349 name2 [j] = '\0';
6350
6351 g_free (name1);
6352
6353 count = 0;
6354 while (TRUE) {
6355 cached_method = (MonoMethod *)g_hash_table_lookup (cache, name2);
6356 if (!(cached_method && cached_method != method))
6357 break;
6358 sprintf (name2 + j, "_%d", count);
6359 count ++;
6360 }
6361
6362 cached = g_strdup (name2);
6363 g_hash_table_insert (cache, cached, method);
6364
6365 return name2;
6366 }
6367
6368 static void
6369 emit_method_code (MonoAotCompile *acfg, MonoCompile *cfg)
6370 {
6371 MonoMethod *method;
6372 int method_index;
6373 guint8 *code;
6374 char *debug_sym = NULL;
6375 char *symbol = NULL;
6376 int func_alignment = AOT_FUNC_ALIGNMENT;
6377 char *export_name;
6378
6379 g_assert (!ignore_cfg (cfg));
6380
6381 method = cfg->orig_method;
6382 code = cfg->native_code;
6383
6384 method_index = get_method_index (acfg, method);
6385 symbol = g_strdup_printf ("%sme_%x", acfg->temp_prefix, method_index);
6386
6387 /* Make the labels local */
6388 emit_section_change (acfg, ".text", 0);
6389 emit_alignment_code (acfg, func_alignment);
6390
6391 if (acfg->global_symbols && acfg->need_no_dead_strip)
6392 fprintf (acfg->fp, " .no_dead_strip %s\n", cfg->asm_symbol);
6393
6394 emit_label (acfg, cfg->asm_symbol);
6395
6396 if (acfg->aot_opts.write_symbols && !acfg->global_symbols && !acfg->llvm) {
6397 /*
6398 * Write a C style symbol for every method, this has two uses:
6399 * - it works on platforms where the dwarf debugging info is not
6400 * yet supported.
6401 * - it allows the setting of breakpoints of aot-ed methods.
6402 */
6403
6404 // Comment out to force dedup to link these symbols and forbid compiling
6405 // in duplicated code. This is an "assert when linking if broken" trick.
6406 /*if (mono_aot_can_dedup (method) && (acfg->aot_opts.dedup || acfg->aot_opts.dedup_include))*/
6407 /*debug_sym = mono_aot_get_mangled_method_name (method);*/
6408 /*else*/
6409 debug_sym = get_debug_sym (method, "", acfg->method_label_hash);
6410
6411 cfg->asm_debug_symbol = g_strdup (debug_sym);
6412
6413 if (acfg->need_no_dead_strip)
6414 fprintf (acfg->fp, " .no_dead_strip %s\n", debug_sym);
6415
6416 // Comment out to force dedup to link these symbols and forbid compiling
6417 // in duplicated code. This is an "assert when linking if broken" trick.
6418 /*if (mono_aot_can_dedup (method) && (acfg->aot_opts.dedup || acfg->aot_opts.dedup_include))*/
6419 /*emit_global_inner (acfg, debug_sym, TRUE);*/
6420 /*else*/
6421 emit_local_symbol (acfg, debug_sym, symbol, TRUE);
6422
6423 emit_label (acfg, debug_sym);
6424 }
6425
6426 export_name = (char *)g_hash_table_lookup (acfg->export_names, method);
6427 if (export_name) {
6428 /* Emit a global symbol for the method */
6429 emit_global_inner (acfg, export_name, TRUE);
6430 emit_label (acfg, export_name);
6431 }
6432
6433 if (cfg->verbose_level > 0 && !ignore_cfg (cfg))
6434 g_print ("Method %s emitted as %s\n", mono_method_get_full_name (method), cfg->asm_symbol);
6435
6436 acfg->stats.code_size += cfg->code_len;
6437
6438 acfg->cfgs [method_index]->got_offset = acfg->got_offset;
6439
6440 emit_and_reloc_code (acfg, method, code, cfg->code_len, cfg->patch_info, FALSE, mono_debug_find_method (cfg->jit_info->d.method, mono_domain_get ()));
6441
6442 emit_line (acfg);
6443
6444 if (acfg->aot_opts.write_symbols) {
6445 if (debug_sym)
6446 emit_symbol_size (acfg, debug_sym, ".");
6447 else
6448 emit_symbol_size (acfg, cfg->asm_symbol, ".");
6449 g_free (debug_sym);
6450 }
6451
6452 emit_label (acfg, symbol);
6453
6454 arch_emit_unwind_info_sections (acfg, cfg->asm_symbol, symbol, cfg->unwind_ops);
6455
6456 g_free (symbol);
6457 }
6458
6459 /**
6460 * encode_patch:
6461 *
6462 * Encode PATCH_INFO into its disk representation.
6463 */
6464 static void
6465 encode_patch (MonoAotCompile *acfg, MonoJumpInfo *patch_info, guint8 *buf, guint8 **endbuf)
6466 {
6467 guint8 *p = buf;
6468
6469 switch (patch_info->type) {
6470 case MONO_PATCH_INFO_NONE:
6471 break;
6472 case MONO_PATCH_INFO_IMAGE:
6473 encode_value (get_image_index (acfg, patch_info->data.image), p, &p);
6474 break;
6475 case MONO_PATCH_INFO_MSCORLIB_GOT_ADDR:
6476 case MONO_PATCH_INFO_GC_CARD_TABLE_ADDR:
6477 case MONO_PATCH_INFO_GC_NURSERY_START:
6478 case MONO_PATCH_INFO_GC_NURSERY_BITS:
6479 break;
6480 case MONO_PATCH_INFO_SWITCH: {
6481 gpointer *table = (gpointer *)patch_info->data.table->table;
6482 int k;
6483
6484 encode_value (patch_info->data.table->table_size, p, &p);
6485 for (k = 0; k < patch_info->data.table->table_size; k++)
6486 encode_value ((int)(gssize)table [k], p, &p);
6487 break;
6488 }
6489 case MONO_PATCH_INFO_METHODCONST:
6490 case MONO_PATCH_INFO_METHOD:
6491 case MONO_PATCH_INFO_METHOD_JUMP:
6492 case MONO_PATCH_INFO_METHOD_FTNDESC:
6493 case MONO_PATCH_INFO_ICALL_ADDR:
6494 case MONO_PATCH_INFO_ICALL_ADDR_CALL:
6495 case MONO_PATCH_INFO_METHOD_RGCTX:
6496 case MONO_PATCH_INFO_METHOD_CODE_SLOT:
6497 encode_method_ref (acfg, patch_info->data.method, p, &p);
6498 break;
6499 case MONO_PATCH_INFO_AOT_JIT_INFO:
6500 case MONO_PATCH_INFO_CASTCLASS_CACHE:
6501 encode_value (patch_info->data.index, p, &p);
6502 break;
6503 case MONO_PATCH_INFO_JIT_ICALL_ID:
6504 case MONO_PATCH_INFO_JIT_ICALL_ADDR:
6505 case MONO_PATCH_INFO_JIT_ICALL_ADDR_NOCALL:
6506 encode_value (patch_info->data.jit_icall_id, p, &p);
6507 break;
6508 case MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR:
6509 encode_value (patch_info->data.uindex, p, &p);
6510 break;
6511 case MONO_PATCH_INFO_LDSTR_LIT: {
6512 guint32 len = strlen (patch_info->data.name);
6513 encode_value (len, p, &p);
6514 memcpy (p, patch_info->data.name, len + 1);
6515 p += len + 1;
6516 break;
6517 }
6518 case MONO_PATCH_INFO_LDSTR: {
6519 guint32 image_index = get_image_index (acfg, patch_info->data.token->image);
6520 guint32 token = patch_info->data.token->token;
6521 g_assert (mono_metadata_token_code (token) == MONO_TOKEN_STRING);
6522 encode_value (image_index, p, &p);
6523 encode_value (patch_info->data.token->token - MONO_TOKEN_STRING, p, &p);
6524 break;
6525 }
6526 case MONO_PATCH_INFO_RVA:
6527 case MONO_PATCH_INFO_DECLSEC:
6528 case MONO_PATCH_INFO_LDTOKEN:
6529 case MONO_PATCH_INFO_TYPE_FROM_HANDLE:
6530 encode_value (get_image_index (acfg, patch_info->data.token->image), p, &p);
6531 encode_value (patch_info->data.token->token, p, &p);
6532 encode_value (patch_info->data.token->has_context, p, &p);
6533 if (patch_info->data.token->has_context)
6534 encode_generic_context (acfg, &patch_info->data.token->context, p, &p);
6535 break;
6536 case MONO_PATCH_INFO_EXC_NAME: {
6537 MonoClass *ex_class;
6538
6539 ex_class =
6540 mono_class_load_from_name (m_class_get_image (mono_defaults.exception_class),
6541 "System", (const char *)patch_info->data.target);
6542 encode_klass_ref (acfg, ex_class, p, &p);
6543 break;
6544 }
6545 case MONO_PATCH_INFO_R4:
6546 encode_value (*((guint32 *)patch_info->data.target), p, &p);
6547 break;
6548 case MONO_PATCH_INFO_R8:
6549 encode_value (((guint32 *)patch_info->data.target) [MINI_LS_WORD_IDX], p, &p);
6550 encode_value (((guint32 *)patch_info->data.target) [MINI_MS_WORD_IDX], p, &p);
6551 break;
6552 case MONO_PATCH_INFO_VTABLE:
6553 case MONO_PATCH_INFO_CLASS:
6554 case MONO_PATCH_INFO_IID:
6555 case MONO_PATCH_INFO_ADJUSTED_IID:
6556 encode_klass_ref (acfg, patch_info->data.klass, p, &p);
6557 break;
6558 case MONO_PATCH_INFO_DELEGATE_TRAMPOLINE:
6559 encode_klass_ref (acfg, patch_info->data.del_tramp->klass, p, &p);
6560 if (patch_info->data.del_tramp->method) {
6561 encode_value (1, p, &p);
6562 encode_method_ref (acfg, patch_info->data.del_tramp->method, p, &p);
6563 } else {
6564 encode_value (0, p, &p);
6565 }
6566 encode_value (patch_info->data.del_tramp->is_virtual, p, &p);
6567 break;
6568 case MONO_PATCH_INFO_FIELD:
6569 case MONO_PATCH_INFO_SFLDA:
6570 encode_field_info (acfg, patch_info->data.field, p, &p);
6571 break;
6572 case MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG:
6573 break;
6574 case MONO_PATCH_INFO_PROFILER_ALLOCATION_COUNT:
6575 case MONO_PATCH_INFO_PROFILER_CLAUSE_COUNT:
6576 break;
6577 case MONO_PATCH_INFO_RGCTX_FETCH:
6578 case MONO_PATCH_INFO_RGCTX_SLOT_INDEX: {
6579 MonoJumpInfoRgctxEntry *entry = patch_info->data.rgctx_entry;
6580 guint32 offset;
6581
6582 /*
6583 * entry->d.klass/method has a lenghtly encoding and multiple rgctx_fetch entries
6584 * reference the same klass/method, so encode it only once.
6585 * For patches which refer to got entries, this sharing is done by get_got_offset, but
6586 * these are not got entries.
6587 */
6588 if (entry->in_mrgctx) {
6589 offset = get_shared_method_ref (acfg, entry->d.method);
6590 } else {
6591 offset = get_shared_klass_ref (acfg, entry->d.klass);
6592 }
6593
6594 encode_value (offset, p, &p);
6595 g_assert ((int)entry->info_type < 256);
6596 g_assert (entry->data->type < 256);
6597 encode_value ((entry->in_mrgctx ? 1 : 0) | (entry->info_type << 1) | (entry->data->type << 9), p, &p);
6598 encode_patch (acfg, entry->data, p, &p);
6599 break;
6600 }
6601 case MONO_PATCH_INFO_SEQ_POINT_INFO:
6602 case MONO_PATCH_INFO_AOT_MODULE:
6603 break;
6604 case MONO_PATCH_INFO_SIGNATURE:
6605 case MONO_PATCH_INFO_GSHAREDVT_IN_WRAPPER:
6606 encode_signature (acfg, (MonoMethodSignature*)patch_info->data.target, p, &p);
6607 break;
6608 case MONO_PATCH_INFO_GSHAREDVT_CALL:
6609 encode_signature (acfg, (MonoMethodSignature*)patch_info->data.gsharedvt->sig, p, &p);
6610 encode_method_ref (acfg, patch_info->data.gsharedvt->method, p, &p);
6611 break;
6612 case MONO_PATCH_INFO_GSHAREDVT_METHOD: {
6613 MonoGSharedVtMethodInfo *info = patch_info->data.gsharedvt_method;
6614 int i;
6615
6616 encode_method_ref (acfg, info->method, p, &p);
6617 encode_value (info->num_entries, p, &p);
6618 for (i = 0; i < info->num_entries; ++i) {
6619 MonoRuntimeGenericContextInfoTemplate *template_ = &info->entries [i];
6620
6621 encode_value (template_->info_type, p, &p);
6622 switch (mini_rgctx_info_type_to_patch_info_type (template_->info_type)) {
6623 case MONO_PATCH_INFO_CLASS:
6624 encode_klass_ref (acfg, mono_class_from_mono_type_internal ((MonoType *)template_->data), p, &p);
6625 break;
6626 case MONO_PATCH_INFO_FIELD:
6627 encode_field_info (acfg, (MonoClassField *)template_->data, p, &p);
6628 break;
6629 default:
6630 g_assert_not_reached ();
6631 break;
6632 }
6633 }
6634 break;
6635 }
6636 case MONO_PATCH_INFO_VIRT_METHOD:
6637 encode_klass_ref (acfg, patch_info->data.virt_method->klass, p, &p);
6638 encode_method_ref (acfg, patch_info->data.virt_method->method, p, &p);
6639 break;
6640 case MONO_PATCH_INFO_GC_SAFE_POINT_FLAG:
6641 break;
6642 default:
6643 g_error ("unable to handle jump info %d", patch_info->type);
6644 }
6645
6646 *endbuf = p;
6647 }
6648
6649 static void
6650 encode_patch_list (MonoAotCompile *acfg, GPtrArray *patches, int n_patches, gboolean llvm, guint8 *buf, guint8 **endbuf)
6651 {
6652 guint8 *p = buf;
6653 guint32 pindex, offset;
6654 MonoJumpInfo *patch_info;
6655
6656 encode_value (n_patches, p, &p);
6657
6658 for (pindex = 0; pindex < patches->len; ++pindex) {
6659 patch_info = (MonoJumpInfo *)g_ptr_array_index (patches, pindex);
6660
6661 if (patch_info->type == MONO_PATCH_INFO_NONE || patch_info->type == MONO_PATCH_INFO_BB)
6662 /* Nothing to do */
6663 continue;
6664 /* This shouldn't allocate a new offset */
6665 offset = lookup_got_offset (acfg, llvm, patch_info);
6666 encode_value (offset, p, &p);
6667 }
6668
6669 *endbuf = p;
6670 }
6671
6672 static void
6673 emit_method_info (MonoAotCompile *acfg, MonoCompile *cfg)
6674 {
6675 MonoMethod *method;
6676 int pindex, buf_size, n_patches;
6677 GPtrArray *patches;
6678 MonoJumpInfo *patch_info;
6679 guint8 *p, *buf;
6680 guint32 offset;
6681 gboolean needs_ctx = FALSE;
6682
6683 method = cfg->orig_method;
6684
6685 (void)get_method_index (acfg, method);
6686
6687 /* Sort relocations */
6688 patches = g_ptr_array_new ();
6689 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next)
6690 g_ptr_array_add (patches, patch_info);
6691 if (!acfg->aot_opts.llvm_only)
6692 g_ptr_array_sort (patches, compare_patches);
6693
6694 /**********************/
6695 /* Encode method info */
6696 /**********************/
6697
6698 g_assert (!(cfg->opt & MONO_OPT_SHARED));
6699
6700 guint32 *got_offsets = g_new0 (guint32, patches->len);
6701
6702 n_patches = 0;
6703 for (pindex = 0; pindex < patches->len; ++pindex) {
6704 patch_info = (MonoJumpInfo *)g_ptr_array_index (patches, pindex);
6705
6706 if ((patch_info->type == MONO_PATCH_INFO_GOT_OFFSET) ||
6707 (patch_info->type == MONO_PATCH_INFO_NONE)) {
6708 patch_info->type = MONO_PATCH_INFO_NONE;
6709 /* Nothing to do */
6710 continue;
6711 }
6712
6713 if ((patch_info->type == MONO_PATCH_INFO_IMAGE) && (patch_info->data.image == acfg->image)) {
6714 /* Stored in a GOT slot initialized at module load time */
6715 patch_info->type = MONO_PATCH_INFO_NONE;
6716 continue;
6717 }
6718
6719 if (patch_info->type == MONO_PATCH_INFO_GC_CARD_TABLE_ADDR ||
6720 patch_info->type == MONO_PATCH_INFO_GC_NURSERY_START ||
6721 patch_info->type == MONO_PATCH_INFO_GC_NURSERY_BITS ||
6722 patch_info->type == MONO_PATCH_INFO_AOT_MODULE) {
6723 /* Stored in a GOT slot initialized at module load time */
6724 patch_info->type = MONO_PATCH_INFO_NONE;
6725 continue;
6726 }
6727
6728 if (is_plt_patch (patch_info) && !(cfg->compile_llvm && acfg->aot_opts.llvm_only)) {
6729 /* Calls are made through the PLT */
6730 patch_info->type = MONO_PATCH_INFO_NONE;
6731 continue;
6732 }
6733
6734 if (acfg->aot_opts.llvm_only && patch_info->type == MONO_PATCH_INFO_METHOD)
6735 needs_ctx = TRUE;
6736
6737 /* This shouldn't allocate a new offset */
6738 offset = lookup_got_offset (acfg, cfg->compile_llvm, patch_info);
6739 if (offset >= acfg->nshared_got_entries)
6740 got_offsets [n_patches ++] = offset;
6741 }
6742
6743 if (n_patches)
6744 g_assert (cfg->has_got_slots);
6745
6746 buf_size = (patches->len < 1000) ? 40960 : 40960 + (patches->len * 64);
6747 p = buf = (guint8 *)g_malloc (buf_size);
6748
6749 MonoGenericContext *ctx = mono_method_get_context (cfg->method);
6750
6751 guint8 flags = 0;
6752 if (mono_class_get_cctor (method->klass))
6753 flags |= MONO_AOT_METHOD_FLAG_HAS_CCTOR;
6754 if (mini_jit_info_is_gsharedvt (cfg->jit_info) && mini_is_gsharedvt_variable_signature (mono_method_signature_internal (jinfo_get_method (cfg->jit_info))))
6755 flags |= MONO_AOT_METHOD_FLAG_GSHAREDVT_VARIABLE;
6756 if (n_patches)
6757 flags |= MONO_AOT_METHOD_FLAG_HAS_PATCHES;
6758 if (needs_ctx && ctx)
6759 flags |= MONO_AOT_METHOD_FLAG_HAS_CTX;
6760 encode_value (flags, p, &p);
6761 if (flags & MONO_AOT_METHOD_FLAG_HAS_CCTOR)
6762 encode_klass_ref (acfg, method->klass, p, &p);
6763 if (needs_ctx && ctx)
6764 encode_generic_context (acfg, ctx, p, &p);
6765
6766 if (n_patches) {
6767 encode_value (n_patches, p, &p);
6768 for (int i = 0; i < n_patches; ++i)
6769 encode_value (got_offsets [i], p, &p);
6770 }
6771
6772 g_ptr_array_free (patches, TRUE);
6773 g_free (got_offsets);
6774
6775 acfg->stats.method_info_size += p - buf;
6776
6777 g_assert (p - buf < buf_size);
6778
6779 cfg->method_info_offset = add_to_blob (acfg, buf, p - buf);
6780 g_free (buf);
6781 }
6782
6783 static guint32
6784 get_unwind_info_offset (MonoAotCompile *acfg, guint8 *encoded, guint32 encoded_len)
6785 {
6786 guint32 cache_index;
6787 guint32 offset;
6788
6789 /* Reuse the unwind module to canonize and store unwind info entries */
6790 cache_index = mono_cache_unwind_info (encoded, encoded_len);
6791
6792 /* Use +/- 1 to distinguish 0s from missing entries */
6793 offset = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->unwind_info_offsets, GUINT_TO_POINTER (cache_index + 1)));
6794 if (offset)
6795 return offset - 1;
6796 else {
6797 guint8 buf [16];
6798 guint8 *p;
6799
6800 /*
6801 * It would be easier to use assembler symbols, but the caller needs an
6802 * offset now.
6803 */
6804 offset = acfg->unwind_info_offset;
6805 g_hash_table_insert (acfg->unwind_info_offsets, GUINT_TO_POINTER (cache_index + 1), GUINT_TO_POINTER (offset + 1));
6806 g_ptr_array_add (acfg->unwind_ops, GUINT_TO_POINTER (cache_index));
6807
6808 p = buf;
6809 encode_value (encoded_len, p, &p);
6810
6811 acfg->unwind_info_offset += encoded_len + (p - buf);
6812 return offset;
6813 }
6814 }
6815
6816 static void
6817 emit_exception_debug_info (MonoAotCompile *acfg, MonoCompile *cfg, gboolean store_seq_points)
6818 {
6819 int i, k, buf_size;
6820 guint32 debug_info_size, seq_points_size;
6821 guint8 *code;
6822 MonoMethodHeader *header;
6823 guint8 *p, *buf, *debug_info;
6824 MonoJitInfo *jinfo = cfg->jit_info;
6825 guint32 flags;
6826 gboolean use_unwind_ops = FALSE;
6827 MonoSeqPointInfo *seq_points;
6828
6829 code = cfg->native_code;
6830 header = cfg->header;
6831
6832 if (!acfg->aot_opts.nodebug) {
6833 mono_debug_serialize_debug_info (cfg, &debug_info, &debug_info_size);
6834 } else {
6835 debug_info = NULL;
6836 debug_info_size = 0;
6837 }
6838
6839 seq_points = cfg->seq_point_info;
6840 seq_points_size = (store_seq_points)? mono_seq_point_info_get_write_size (seq_points) : 0;
6841
6842 buf_size = header->num_clauses * 256 + debug_info_size + 2048 + seq_points_size + cfg->gc_map_size;
6843 if (jinfo->has_try_block_holes) {
6844 MonoTryBlockHoleTableJitInfo *table = mono_jit_info_get_try_block_hole_table_info (jinfo);
6845 buf_size += table->num_holes * 16;
6846 }
6847
6848 p = buf = (guint8 *)g_malloc (buf_size);
6849
6850 use_unwind_ops = cfg->unwind_ops != NULL;
6851
6852 flags = (jinfo->has_generic_jit_info ? 1 : 0) | (use_unwind_ops ? 2 : 0) | (header->num_clauses ? 4 : 0) | (seq_points_size ? 8 : 0) | (cfg->compile_llvm ? 16 : 0) | (jinfo->has_try_block_holes ? 32 : 0) | (cfg->gc_map ? 64 : 0) | (jinfo->has_arch_eh_info ? 128 : 0);
6853
6854 encode_value (flags, p, &p);
6855
6856 if (use_unwind_ops) {
6857 guint32 encoded_len;
6858 guint8 *encoded;
6859 guint32 unwind_desc;
6860
6861 encoded = mono_unwind_ops_encode (cfg->unwind_ops, &encoded_len);
6862
6863 unwind_desc = get_unwind_info_offset (acfg, encoded, encoded_len);
6864 encode_value (unwind_desc, p, &p);
6865
6866 g_free (encoded);
6867 } else {
6868 encode_value (jinfo->unwind_info, p, &p);
6869 }
6870
6871 /*Encode the number of holes before the number of clauses to make decoding easier*/
6872 if (jinfo->has_try_block_holes) {
6873 MonoTryBlockHoleTableJitInfo *table = mono_jit_info_get_try_block_hole_table_info (jinfo);
6874 encode_value (table->num_holes, p, &p);
6875 }
6876
6877 if (jinfo->has_arch_eh_info) {
6878 /*
6879 * In AOT mode, the code length is calculated from the address of the previous method,
6880 * which could include alignment padding, so calculating the start of the epilog as
6881 * code_len - epilog_size is correct any more. Save the real code len as a workaround.
6882 */
6883 encode_value (jinfo->code_size, p, &p);
6884 }
6885
6886 /* Exception table */
6887 if (cfg->compile_llvm) {
6888 /*
6889 * When using LLVM, we can't emit some data, like pc offsets, this reg/offset etc.,
6890 * since the information is only available to llc. Instead, we let llc save the data
6891 * into the LSDA, and read it from there at runtime.
6892 */
6893 /* The assembly might be CIL stripped so emit the data ourselves */
6894 if (header->num_clauses)
6895 encode_value (header->num_clauses, p, &p);
6896
6897 for (k = 0; k < header->num_clauses; ++k) {
6898 MonoExceptionClause *clause;
6899
6900 clause = &header->clauses [k];
6901
6902 encode_value (clause->flags, p, &p);
6903 if (!(clause->flags == MONO_EXCEPTION_CLAUSE_FILTER || clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY)) {
6904 if (clause->data.catch_class) {
6905 guint8 *buf2, *p2;
6906 int len;
6907
6908 buf2 = (guint8 *)g_malloc (4096);
6909 p2 = buf2;
6910 encode_klass_ref (acfg, clause->data.catch_class, p2, &p2);
6911 len = p2 - buf2;
6912 g_assert (len < 4096);
6913 encode_value (len, p, &p);
6914 memcpy (p, buf2, len);
6915 p += p2 - buf2;
6916 g_free (buf2);
6917 } else {
6918 encode_value (0, p, &p);
6919 }
6920 }
6921
6922 /* Emit the IL ranges too, since they might not be available at runtime */
6923 encode_value (clause->try_offset, p, &p);
6924 encode_value (clause->try_len, p, &p);
6925 encode_value (clause->handler_offset, p, &p);
6926 encode_value (clause->handler_len, p, &p);
6927
6928 /* Emit a list of nesting clauses */
6929 for (i = 0; i < header->num_clauses; ++i) {
6930 gint32 cindex1 = k;
6931 MonoExceptionClause *clause1 = &header->clauses [cindex1];
6932 gint32 cindex2 = i;
6933 MonoExceptionClause *clause2 = &header->clauses [cindex2];
6934
6935 if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset)
6936 encode_value (i, p, &p);
6937 }
6938 encode_value (-1, p, &p);
6939 }
6940 } else {
6941 if (jinfo->num_clauses)
6942 encode_value (jinfo->num_clauses, p, &p);
6943
6944 for (k = 0; k < jinfo->num_clauses; ++k) {
6945 MonoJitExceptionInfo *ei = &jinfo->clauses [k];
6946
6947 encode_value (ei->flags, p, &p);
6948 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
6949 /* Not used for catch clauses */
6950 if (ei->flags != MONO_EXCEPTION_CLAUSE_NONE)
6951 encode_value (ei->exvar_offset, p, &p);
6952 #else
6953 encode_value (ei->exvar_offset, p, &p);
6954 #endif
6955
6956 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER || ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY)
6957 encode_value ((gint)((guint8*)ei->data.filter - code), p, &p);
6958 else {
6959 if (ei->data.catch_class) {
6960 guint8 *buf2, *p2;
6961 int len;
6962
6963 buf2 = (guint8 *)g_malloc (4096);
6964 p2 = buf2;
6965 encode_klass_ref (acfg, ei->data.catch_class, p2, &p2);
6966 len = p2 - buf2;
6967 g_assert (len < 4096);
6968 encode_value (len, p, &p);
6969 memcpy (p, buf2, len);
6970 p += p2 - buf2;
6971 g_free (buf2);
6972 } else {
6973 encode_value (0, p, &p);
6974 }
6975 }
6976
6977 encode_value ((gint)((guint8*)ei->try_start - code), p, &p);
6978 encode_value ((gint)((guint8*)ei->try_end - code), p, &p);
6979 encode_value ((gint)((guint8*)ei->handler_start - code), p, &p);
6980 }
6981 }
6982
6983 if (jinfo->has_try_block_holes) {
6984 MonoTryBlockHoleTableJitInfo *table = mono_jit_info_get_try_block_hole_table_info (jinfo);
6985 for (i = 0; i < table->num_holes; ++i) {
6986 MonoTryBlockHoleJitInfo *hole = &table->holes [i];
6987 encode_value (hole->clause, p, &p);
6988 encode_value (hole->length, p, &p);
6989 encode_value (hole->offset, p, &p);
6990 }
6991 }
6992
6993 if (jinfo->has_arch_eh_info) {
6994 MonoArchEHJitInfo *eh_info;
6995
6996 eh_info = mono_jit_info_get_arch_eh_info (jinfo);
6997 encode_value (eh_info->stack_size, p, &p);
6998 encode_value (eh_info->epilog_size, p, &p);
6999 }
7000
7001 if (jinfo->has_generic_jit_info) {
7002 MonoGenericJitInfo *gi = mono_jit_info_get_generic_jit_info (jinfo);
7003 MonoGenericSharingContext* gsctx = gi->generic_sharing_context;
7004 guint8 *buf2, *p2;
7005 int len;
7006
7007 encode_value (gi->nlocs, p, &p);
7008 if (gi->nlocs) {
7009 for (i = 0; i < gi->nlocs; ++i) {
7010 MonoDwarfLocListEntry *entry = &gi->locations [i];
7011
7012 encode_value (entry->is_reg ? 1 : 0, p, &p);
7013 encode_value (entry->reg, p, &p);
7014 if (!entry->is_reg)
7015 encode_value (entry->offset, p, &p);
7016 if (i == 0)
7017 g_assert (entry->from == 0);
7018 else
7019 encode_value (entry->from, p, &p);
7020 encode_value (entry->to, p, &p);
7021 }
7022 } else {
7023 if (!cfg->compile_llvm) {
7024 encode_value (gi->has_this ? 1 : 0, p, &p);
7025 encode_value (gi->this_reg, p, &p);
7026 encode_value (gi->this_offset, p, &p);
7027 }
7028 }
7029
7030 /*
7031 * Need to encode jinfo->method too, since it is not equal to 'method'
7032 * when using generic sharing.
7033 */
7034 buf2 = (guint8 *)g_malloc (4096);
7035 p2 = buf2;
7036 encode_method_ref (acfg, jinfo->d.method, p2, &p2);
7037 len = p2 - buf2;
7038 g_assert (len < 4096);
7039 encode_value (len, p, &p);
7040 memcpy (p, buf2, len);
7041 p += p2 - buf2;
7042 g_free (buf2);
7043
7044 if (gsctx && gsctx->is_gsharedvt) {
7045 encode_value (1, p, &p);
7046 } else {
7047 encode_value (0, p, &p);
7048 }
7049 }
7050
7051 if (seq_points_size)
7052 p += mono_seq_point_info_write (seq_points, p);
7053
7054 g_assert (debug_info_size < buf_size);
7055
7056 encode_value (debug_info_size, p, &p);
7057 if (debug_info_size) {
7058 memcpy (p, debug_info, debug_info_size);
7059 p += debug_info_size;
7060 g_free (debug_info);
7061 }
7062
7063 /* GC Map */
7064 if (cfg->gc_map) {
7065 encode_value (cfg->gc_map_size, p, &p);
7066 /* The GC map requires 4 bytes of alignment */
7067 while ((gsize)p % 4)
7068 p ++;
7069 memcpy (p, cfg->gc_map, cfg->gc_map_size);
7070 p += cfg->gc_map_size;
7071 }
7072
7073 acfg->stats.ex_info_size += p - buf;
7074
7075 g_assert (p - buf < buf_size);
7076
7077 /* Emit info */
7078 /* The GC Map requires 4 byte alignment */
7079 cfg->ex_info_offset = add_to_blob_aligned (acfg, buf, p - buf, cfg->gc_map ? 4 : 1);
7080 g_free (buf);
7081 }
7082
7083 static guint32
7084 emit_klass_info (MonoAotCompile *acfg, guint32 token)
7085 {
7086 ERROR_DECL (error);
7087 MonoClass *klass = mono_class_get_checked (acfg->image, token, error);
7088 guint8 *p, *buf;
7089 int i, buf_size, res;
7090 gboolean no_special_static, cant_encode;
7091 gpointer iter = NULL;
7092
7093 if (!klass) {
7094 mono_error_cleanup (error);
7095
7096 buf_size = 16;
7097
7098 p = buf = (guint8 *)g_malloc (buf_size);
7099
7100 /* Mark as unusable */
7101 encode_value (-1, p, &p);
7102
7103 res = add_to_blob (acfg, buf, p - buf);
7104 g_free (buf);
7105
7106 return res;
7107 }
7108
7109 buf_size = 10240 + (m_class_get_vtable_size (klass) * 16);
7110 p = buf = (guint8 *)g_malloc (buf_size);
7111
7112 g_assert (klass);
7113
7114 mono_class_init_internal (klass);
7115
7116 mono_class_get_nested_types (klass, &iter);
7117 g_assert (m_class_is_nested_classes_inited (klass));
7118
7119 mono_class_setup_vtable (klass);
7120
7121 /*
7122 * Emit all the information which is required for creating vtables so
7123 * the runtime does not need to create the MonoMethod structures which
7124 * take up a lot of space.
7125 */
7126
7127 no_special_static = !mono_class_has_special_static_fields (klass);
7128
7129 /* Check whenever we have enough info to encode the vtable */
7130 cant_encode = FALSE;
7131 MonoMethod **klass_vtable = m_class_get_vtable (klass);
7132 for (i = 0; i < m_class_get_vtable_size (klass); ++i) {
7133 MonoMethod *cm = klass_vtable [i];
7134
7135 if (cm && mono_method_signature_internal (cm)->is_inflated && !g_hash_table_lookup (acfg->token_info_hash, cm))
7136 cant_encode = TRUE;
7137 }
7138
7139 mono_class_has_finalizer (klass);
7140 if (mono_class_has_failure (klass))
7141 cant_encode = TRUE;
7142
7143 if (mono_class_is_gtd (klass) || cant_encode) {
7144 encode_value (-1, p, &p);
7145 } else {
7146 gboolean has_nested = mono_class_get_nested_classes_property (klass) != NULL;
7147 encode_value (m_class_get_vtable_size (klass), p, &p);
7148 encode_value ((m_class_has_weak_fields (klass) << 9) | (mono_class_is_gtd (klass) ? (1 << 8) : 0) | (no_special_static << 7) | (m_class_has_static_refs (klass) << 6) | (m_class_has_references (klass) << 5) | ((m_class_is_blittable (klass) << 4) | (has_nested ? 1 : 0) << 3) | (m_class_has_cctor (klass) << 2) | (m_class_has_finalize (klass) << 1) | m_class_is_ghcimpl (klass), p, &p);
7149 if (m_class_has_cctor (klass))
7150 encode_method_ref (acfg, mono_class_get_cctor (klass), p, &p);
7151 if (m_class_has_finalize (klass))
7152 encode_method_ref (acfg, mono_class_get_finalizer (klass), p, &p);
7153
7154 encode_value (m_class_get_instance_size (klass), p, &p);
7155 encode_value (mono_class_data_size (klass), p, &p);
7156 encode_value (m_class_get_packing_size (klass), p, &p);
7157 encode_value (m_class_get_min_align (klass), p, &p);
7158
7159 for (i = 0; i < m_class_get_vtable_size (klass); ++i) {
7160 MonoMethod *cm = klass_vtable [i];
7161
7162 if (cm)
7163 encode_method_ref (acfg, cm, p, &p);
7164 else
7165 encode_value (0, p, &p);
7166 }
7167 }
7168
7169 acfg->stats.class_info_size += p - buf;
7170
7171 g_assert (p - buf < buf_size);
7172 res = add_to_blob (acfg, buf, p - buf);
7173 g_free (buf);
7174
7175 return res;
7176 }
7177
7178 static char*
7179 get_plt_entry_debug_sym (MonoAotCompile *acfg, MonoJumpInfo *ji, GHashTable *cache)
7180 {
7181 char *debug_sym = NULL;
7182 char *prefix;
7183
7184 if (acfg->llvm && llvm_acfg->aot_opts.static_link) {
7185 /* Need to add a prefix to create unique symbols */
7186 prefix = g_strdup_printf ("plt_%s_", acfg->assembly_name_sym);
7187 } else {
7188 #if defined(TARGET_WIN32) && defined(TARGET_X86)
7189 prefix = mangle_symbol_alloc ("plt_");
7190 #else
7191 prefix = g_strdup ("plt_");
7192 #endif
7193 }
7194
7195 switch (ji->type) {
7196 case MONO_PATCH_INFO_METHOD:
7197 debug_sym = get_debug_sym (ji->data.method, prefix, cache);
7198 break;
7199 case MONO_PATCH_INFO_JIT_ICALL_ID:
7200 debug_sym = g_strdup_printf ("%s_jit_icall_%s", prefix, mono_find_jit_icall_info (ji->data.jit_icall_id)->name);
7201 break;
7202 case MONO_PATCH_INFO_RGCTX_FETCH:
7203 debug_sym = g_strdup_printf ("%s_rgctx_fetch_%d", prefix, acfg->label_generator ++);
7204 break;
7205 case MONO_PATCH_INFO_ICALL_ADDR:
7206 case MONO_PATCH_INFO_ICALL_ADDR_CALL: {
7207 char *s = get_debug_sym (ji->data.method, "", cache);
7208
7209 debug_sym = g_strdup_printf ("%s_icall_native_%s", prefix, s);
7210 g_free (s);
7211 break;
7212 }
7213 case MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR:
7214 debug_sym = g_strdup_printf ("%s_jit_icall_native_specific_trampoline_lazy_fetch_%lu", prefix, (gulong)ji->data.uindex);
7215 break;
7216 case MONO_PATCH_INFO_JIT_ICALL_ADDR:
7217 debug_sym = g_strdup_printf ("%s_jit_icall_native_%s", prefix, mono_find_jit_icall_info (ji->data.jit_icall_id)->name);
7218 break;
7219 default:
7220 break;
7221 }
7222
7223 g_free (prefix);
7224
7225 return sanitize_symbol (acfg, debug_sym);
7226 }
7227
7228 /*
7229 * Calls made from AOTed code are routed through a table of jumps similar to the
7230 * ELF PLT (Program Linkage Table). Initially the PLT entries jump to code which transfers
7231 * control to the AOT runtime through a trampoline.
7232 */
7233 static void
7234 emit_plt (MonoAotCompile *acfg)
7235 {
7236 int i;
7237
7238 if (acfg->aot_opts.llvm_only) {
7239 g_assert (acfg->plt_offset == 1);
7240 return;
7241 }
7242
7243 emit_line (acfg);
7244
7245 emit_section_change (acfg, ".text", 0);
7246 emit_alignment_code (acfg, 16);
7247 emit_info_symbol (acfg, "plt", TRUE);
7248 emit_label (acfg, acfg->plt_symbol);
7249
7250 for (i = 0; i < acfg->plt_offset; ++i) {
7251 char *debug_sym = NULL;
7252 MonoPltEntry *plt_entry = NULL;
7253
7254 if (i == 0)
7255 /*
7256 * The first plt entry is unused.
7257 */
7258 continue;
7259
7260 plt_entry = (MonoPltEntry *)g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
7261
7262 debug_sym = plt_entry->debug_sym;
7263
7264 if (acfg->thumb_mixed && !plt_entry->jit_used)
7265 /* Emit only a thumb version */
7266 continue;
7267
7268 /* Skip plt entries not actually called */
7269 if (!plt_entry->jit_used && !plt_entry->llvm_used)
7270 continue;
7271
7272 if (acfg->llvm && !acfg->thumb_mixed) {
7273 emit_label (acfg, plt_entry->llvm_symbol);
7274 if (acfg->llvm) {
7275 emit_global_inner (acfg, plt_entry->llvm_symbol, TRUE);
7276 #if defined(TARGET_MACH)
7277 fprintf (acfg->fp, ".private_extern %s\n", plt_entry->llvm_symbol);
7278 #endif
7279 }
7280 }
7281
7282 if (debug_sym) {
7283 if (acfg->need_no_dead_strip) {
7284 emit_unset_mode (acfg);
7285 fprintf (acfg->fp, " .no_dead_strip %s\n", debug_sym);
7286 }
7287 emit_local_symbol (acfg, debug_sym, NULL, TRUE);
7288 emit_label (acfg, debug_sym);
7289 }
7290
7291 emit_label (acfg, plt_entry->symbol);
7292
7293 arch_emit_plt_entry (acfg, acfg->got_symbol, (acfg->plt_got_offset_base + i) * sizeof (target_mgreg_t), acfg->plt_got_info_offsets [i]);
7294
7295 if (debug_sym)
7296 emit_symbol_size (acfg, debug_sym, ".");
7297 }
7298
7299 if (acfg->thumb_mixed) {
7300 /* Make sure the ARM symbols don't alias the thumb ones */
7301 emit_zero_bytes (acfg, 16);
7302
7303 /*
7304 * Emit a separate set of PLT entries using thumb2 which is called by LLVM generated
7305 * code.
7306 */
7307 for (i = 0; i < acfg->plt_offset; ++i) {
7308 char *debug_sym = NULL;
7309 MonoPltEntry *plt_entry = NULL;
7310
7311 if (i == 0)
7312 continue;
7313
7314 plt_entry = (MonoPltEntry *)g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
7315
7316 /* Skip plt entries not actually called by LLVM code */
7317 if (!plt_entry->llvm_used)
7318 continue;
7319
7320 if (acfg->aot_opts.write_symbols) {
7321 if (plt_entry->debug_sym)
7322 debug_sym = g_strdup_printf ("%s_thumb", plt_entry->debug_sym);
7323 }
7324
7325 if (debug_sym) {
7326 #if defined(TARGET_MACH)
7327 fprintf (acfg->fp, " .thumb_func %s\n", debug_sym);
7328 fprintf (acfg->fp, " .no_dead_strip %s\n", debug_sym);
7329 #endif
7330 emit_local_symbol (acfg, debug_sym, NULL, TRUE);
7331 emit_label (acfg, debug_sym);
7332 }
7333 fprintf (acfg->fp, "\n.thumb_func\n");
7334
7335 emit_label (acfg, plt_entry->llvm_symbol);
7336
7337 if (acfg->llvm)
7338 emit_global_inner (acfg, plt_entry->llvm_symbol, TRUE);
7339
7340 arch_emit_llvm_plt_entry (acfg, acfg->got_symbol, (acfg->plt_got_offset_base + i) * sizeof (target_mgreg_t), acfg->plt_got_info_offsets [i]);
7341
7342 if (debug_sym) {
7343 emit_symbol_size (acfg, debug_sym, ".");
7344 g_free (debug_sym);
7345 }
7346 }
7347 }
7348
7349 emit_symbol_size (acfg, acfg->plt_symbol, ".");
7350
7351 emit_info_symbol (acfg, "plt_end", TRUE);
7352
7353 arch_emit_unwind_info_sections (acfg, "plt", "plt_end", NULL);
7354 }
7355
7356 /*
7357 * emit_trampoline_full:
7358 *
7359 * If EMIT_TINFO is TRUE, emit additional information which can be used to create a MonoJitInfo for this trampoline by
7360 * create_jit_info_for_trampoline ().
7361 */
7362 static G_GNUC_UNUSED void
7363 emit_trampoline_full (MonoAotCompile *acfg, MonoTrampInfo *info, gboolean emit_tinfo)
7364 {
7365 char start_symbol [MAX_SYMBOL_SIZE];
7366 char end_symbol [MAX_SYMBOL_SIZE];
7367 char symbol [MAX_SYMBOL_SIZE];
7368 guint32 buf_size, info_offset;
7369 MonoJumpInfo *patch_info;
7370 guint8 *buf, *p;
7371 GPtrArray *patches;
7372 char *name;
7373 guint8 *code;
7374 guint32 code_size;
7375 MonoJumpInfo *ji;
7376 GSList *unwind_ops;
7377
7378 g_assert (info);
7379
7380 name = info->name;
7381 code = info->code;
7382 code_size = info->code_size;
7383 ji = info->ji;
7384 unwind_ops = info->unwind_ops;
7385
7386 /* Emit code */
7387
7388 sprintf (start_symbol, "%s%s", acfg->user_symbol_prefix, name);
7389
7390 emit_section_change (acfg, ".text", 0);
7391 emit_global (acfg, start_symbol, TRUE);
7392 emit_alignment_code (acfg, AOT_FUNC_ALIGNMENT);
7393 emit_label (acfg, start_symbol);
7394
7395 sprintf (symbol, "%snamed_%s", acfg->temp_prefix, name);
7396 emit_label (acfg, symbol);
7397
7398 /*
7399 * The code should access everything through the GOT, so we pass
7400 * TRUE here.
7401 */
7402 emit_and_reloc_code (acfg, NULL, code, code_size, ji, TRUE, NULL);
7403
7404 emit_symbol_size (acfg, start_symbol, ".");
7405
7406 if (emit_tinfo) {
7407 sprintf (end_symbol, "%snamede_%s", acfg->temp_prefix, name);
7408 emit_label (acfg, end_symbol);
7409 }
7410
7411 /* Emit info */
7412
7413 /* Sort relocations */
7414 patches = g_ptr_array_new ();
7415 for (patch_info = ji; patch_info; patch_info = patch_info->next)
7416 if (patch_info->type != MONO_PATCH_INFO_NONE)
7417 g_ptr_array_add (patches, patch_info);
7418 g_ptr_array_sort (patches, compare_patches);
7419
7420 buf_size = patches->len * 128 + 128;
7421 buf = (guint8 *)g_malloc (buf_size);
7422 p = buf;
7423
7424 encode_patch_list (acfg, patches, patches->len, FALSE, p, &p);
7425 g_assert (p - buf < buf_size);
7426 g_ptr_array_free (patches, TRUE);
7427
7428 sprintf (symbol, "%s%s_p", acfg->user_symbol_prefix, name);
7429
7430 info_offset = add_to_blob (acfg, buf, p - buf);
7431
7432 emit_section_change (acfg, RODATA_SECT, 0);
7433 emit_global (acfg, symbol, FALSE);
7434 emit_label (acfg, symbol);
7435
7436 emit_int32 (acfg, info_offset);
7437
7438 if (emit_tinfo) {
7439 guint8 *encoded;
7440 guint32 encoded_len;
7441 guint32 uw_offset;
7442
7443 /*
7444 * Emit additional information which can be used to reconstruct a partial MonoTrampInfo.
7445 */
7446 encoded = mono_unwind_ops_encode (info->unwind_ops, &encoded_len);
7447 uw_offset = get_unwind_info_offset (acfg, encoded, encoded_len);
7448 g_free (encoded);
7449
7450 emit_symbol_diff (acfg, end_symbol, start_symbol, 0);
7451 emit_int32 (acfg, uw_offset);
7452 }
7453
7454 /* Emit debug info */
7455 if (unwind_ops) {
7456 char symbol2 [MAX_SYMBOL_SIZE];
7457
7458 sprintf (symbol, "%s", name);
7459 sprintf (symbol2, "%snamed_%s", acfg->temp_prefix, name);
7460
7461 arch_emit_unwind_info_sections (acfg, start_symbol, end_symbol, unwind_ops);
7462
7463 if (acfg->dwarf)
7464 mono_dwarf_writer_emit_trampoline (acfg->dwarf, symbol, symbol2, NULL, NULL, code_size, unwind_ops);
7465 }
7466
7467 g_free (buf);
7468 }
7469
7470 static G_GNUC_UNUSED void
7471 emit_trampoline (MonoAotCompile *acfg, MonoTrampInfo *info)
7472 {
7473 emit_trampoline_full (acfg, info, TRUE);
7474 }
7475
7476 static void
7477 emit_trampolines (MonoAotCompile *acfg)
7478 {
7479 char symbol [MAX_SYMBOL_SIZE];
7480 char end_symbol [MAX_SYMBOL_SIZE];
7481 int i, tramp_got_offset;
7482 int ntype;
7483 #ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
7484 int tramp_type;
7485 #endif
7486
7487 if (!mono_aot_mode_is_full (&acfg->aot_opts) && !mono_aot_mode_is_interp (&acfg->aot_opts))
7488 return;
7489 if (acfg->aot_opts.llvm_only)
7490 return;
7491
7492 g_assert (acfg->image->assembly);
7493
7494 /* Currently, we emit most trampolines into the mscorlib AOT image. */
7495 if (mono_is_corlib_image(acfg->image->assembly->image)) {
7496 #ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
7497 MonoTrampInfo *info;
7498
7499 /*
7500 * Emit the generic trampolines.
7501 *
7502 * We could save some code by treating the generic trampolines as a wrapper
7503 * method, but that approach has its own complexities, so we choose the simpler
7504 * method.
7505 */
7506 for (tramp_type = 0; tramp_type < MONO_TRAMPOLINE_NUM; ++tramp_type) {
7507 /* we overload the boolean here to indicate the slightly different trampoline needed, see mono_arch_create_generic_trampoline() */
7508 #ifdef DISABLE_REMOTING
7509 if (tramp_type == MONO_TRAMPOLINE_GENERIC_VIRTUAL_REMOTING)
7510 continue;
7511 #endif
7512 mono_arch_create_generic_trampoline ((MonoTrampolineType)tramp_type, &info, acfg->aot_opts.use_trampolines_page? 2: TRUE);
7513 emit_trampoline (acfg, info);
7514 mono_tramp_info_free (info);
7515 }
7516
7517 /* Emit the exception related code pieces */
7518 mono_arch_get_restore_context (&info, TRUE);
7519 emit_trampoline (acfg, info);
7520 mono_tramp_info_free (info);
7521
7522 mono_arch_get_call_filter (&info, TRUE);
7523 emit_trampoline (acfg, info);
7524 mono_tramp_info_free (info);
7525
7526 mono_arch_get_throw_exception (&info, TRUE);
7527 emit_trampoline (acfg, info);
7528 mono_tramp_info_free (info);
7529
7530 mono_arch_get_rethrow_exception (&info, TRUE);
7531 emit_trampoline (acfg, info);
7532 mono_tramp_info_free (info);
7533
7534 mono_arch_get_rethrow_preserve_exception (&info, TRUE);
7535 emit_trampoline (acfg, info);
7536 mono_tramp_info_free (info);
7537
7538 mono_arch_get_throw_corlib_exception (&info, TRUE);
7539 emit_trampoline (acfg, info);
7540 mono_tramp_info_free (info);
7541
7542 #ifdef MONO_ARCH_HAVE_SDB_TRAMPOLINES
7543 mono_arch_create_sdb_trampoline (TRUE, &info, TRUE);
7544 emit_trampoline (acfg, info);
7545 mono_tramp_info_free (info);
7546
7547 mono_arch_create_sdb_trampoline (FALSE, &info, TRUE);
7548 emit_trampoline (acfg, info);
7549 mono_tramp_info_free (info);
7550 #endif
7551
7552 #ifdef MONO_ARCH_GSHAREDVT_SUPPORTED
7553 mono_arch_get_gsharedvt_trampoline (&info, TRUE);
7554 if (info) {
7555 emit_trampoline_full (acfg, info, TRUE);
7556
7557 /* Create a separate out trampoline for more information in stack traces */
7558 info->name = g_strdup ("gsharedvt_out_trampoline");
7559 emit_trampoline_full (acfg, info, TRUE);
7560 mono_tramp_info_free (info);
7561 }
7562 #endif
7563
7564 #if defined(MONO_ARCH_HAVE_GET_TRAMPOLINES)
7565 {
7566 GSList *l = mono_arch_get_trampolines (TRUE);
7567
7568 while (l) {
7569 MonoTrampInfo *info = (MonoTrampInfo *)l->data;
7570
7571 emit_trampoline (acfg, info);
7572 l = l->next;
7573 }
7574 }
7575 #endif
7576
7577 for (i = 0; i < acfg->aot_opts.nrgctx_fetch_trampolines; ++i) {
7578 int offset;
7579
7580 offset = MONO_RGCTX_SLOT_MAKE_RGCTX (i);
7581 mono_arch_create_rgctx_lazy_fetch_trampoline (offset, &info, TRUE);
7582 emit_trampoline (acfg, info);
7583 mono_tramp_info_free (info);
7584
7585 offset = MONO_RGCTX_SLOT_MAKE_MRGCTX (i);
7586 mono_arch_create_rgctx_lazy_fetch_trampoline (offset, &info, TRUE);
7587 emit_trampoline (acfg, info);
7588 mono_tramp_info_free (info);
7589 }
7590
7591 #ifdef MONO_ARCH_HAVE_GENERAL_RGCTX_LAZY_FETCH_TRAMPOLINE
7592 mono_arch_create_general_rgctx_lazy_fetch_trampoline (&info, TRUE);
7593 emit_trampoline (acfg, info);
7594 mono_tramp_info_free (info);
7595 #endif
7596
7597 {
7598 GSList *l;
7599
7600 /* delegate_invoke_impl trampolines */
7601 l = mono_arch_get_delegate_invoke_impls ();
7602 while (l) {
7603 MonoTrampInfo *info = (MonoTrampInfo *)l->data;
7604
7605 emit_trampoline (acfg, info);
7606 l = l->next;
7607 }
7608 }
7609
7610 if (mono_aot_mode_is_interp (&acfg->aot_opts) && mono_is_corlib_image (acfg->image->assembly->image)) {
7611 mono_arch_get_interp_to_native_trampoline (&info);
7612 emit_trampoline (acfg, info);
7613
7614 #ifdef MONO_ARCH_HAVE_INTERP_ENTRY_TRAMPOLINE
7615 mono_arch_get_native_to_interp_trampoline (&info);
7616 emit_trampoline (acfg, info);
7617 #endif
7618 }
7619
7620 #endif /* #ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES */
7621
7622 /* Emit trampolines which are numerous */
7623
7624 /*
7625 * These include the following:
7626 * - specific trampolines
7627 * - static rgctx invoke trampolines
7628 * - imt trampolines
7629 * These trampolines have the same code, they are parameterized by GOT
7630 * slots.
7631 * They are defined in this file, in the arch_... routines instead of
7632 * in tramp-<ARCH>.c, since it is easier to do it this way.
7633 */
7634
7635 /*
7636 * When running in aot-only mode, we can't create specific trampolines at
7637 * runtime, so we create a few, and save them in the AOT file.
7638 * Normal trampolines embed their argument as a literal inside the
7639 * trampoline code, we can't do that here, so instead we embed an offset
7640 * which needs to be added to the trampoline address to get the address of
7641 * the GOT slot which contains the argument value.
7642 * The generated trampolines jump to the generic trampolines using another
7643 * GOT slot, which will be setup by the AOT loader to point to the
7644 * generic trampoline code of the given type.
7645 */
7646
7647 /*
7648 * FIXME: Maybe we should use more specific trampolines (i.e. one class init for
7649 * each class).
7650 */
7651
7652 emit_section_change (acfg, ".text", 0);
7653
7654 tramp_got_offset = acfg->got_offset;
7655
7656 for (ntype = 0; ntype < MONO_AOT_TRAMP_NUM; ++ntype) {
7657 switch (ntype) {
7658 case MONO_AOT_TRAMP_SPECIFIC:
7659 sprintf (symbol, "specific_trampolines");
7660 break;
7661 case MONO_AOT_TRAMP_STATIC_RGCTX:
7662 sprintf (symbol, "static_rgctx_trampolines");
7663 break;
7664 case MONO_AOT_TRAMP_IMT:
7665 sprintf (symbol, "imt_trampolines");
7666 break;
7667 case MONO_AOT_TRAMP_GSHAREDVT_ARG:
7668 sprintf (symbol, "gsharedvt_arg_trampolines");
7669 break;
7670 case MONO_AOT_TRAMP_FTNPTR_ARG:
7671 sprintf (symbol, "ftnptr_arg_trampolines");
7672 break;
7673 case MONO_AOT_TRAMP_UNBOX_ARBITRARY:
7674 sprintf (symbol, "unbox_arbitrary_trampolines");
7675 break;
7676 default:
7677 g_assert_not_reached ();
7678 }
7679
7680 sprintf (end_symbol, "%s_e", symbol);
7681
7682 if (acfg->aot_opts.write_symbols)
7683 emit_local_symbol (acfg, symbol, end_symbol, TRUE);
7684
7685 emit_alignment_code (acfg, AOT_FUNC_ALIGNMENT);
7686 emit_info_symbol (acfg, symbol, TRUE);
7687
7688 acfg->trampoline_got_offset_base [ntype] = tramp_got_offset;
7689
7690 for (i = 0; i < acfg->num_trampolines [ntype]; ++i) {
7691 int tramp_size = 0;
7692
7693 switch (ntype) {
7694 case MONO_AOT_TRAMP_SPECIFIC:
7695 arch_emit_specific_trampoline (acfg, tramp_got_offset, &tramp_size);
7696 tramp_got_offset += 2;
7697 break;
7698 case MONO_AOT_TRAMP_STATIC_RGCTX:
7699 arch_emit_static_rgctx_trampoline (acfg, tramp_got_offset, &tramp_size);
7700 tramp_got_offset += 2;
7701 break;
7702 case MONO_AOT_TRAMP_IMT:
7703 arch_emit_imt_trampoline (acfg, tramp_got_offset, &tramp_size);
7704 tramp_got_offset += 1;
7705 break;
7706 case MONO_AOT_TRAMP_GSHAREDVT_ARG:
7707 arch_emit_gsharedvt_arg_trampoline (acfg, tramp_got_offset, &tramp_size);
7708 tramp_got_offset += 2;
7709 break;
7710 case MONO_AOT_TRAMP_FTNPTR_ARG:
7711 arch_emit_ftnptr_arg_trampoline (acfg, tramp_got_offset, &tramp_size);
7712 tramp_got_offset += 2;
7713 break;
7714 case MONO_AOT_TRAMP_UNBOX_ARBITRARY:
7715 arch_emit_unbox_arbitrary_trampoline (acfg, tramp_got_offset, &tramp_size);
7716 tramp_got_offset += 1;
7717 break;
7718 default:
7719 g_assert_not_reached ();
7720 }
7721 if (!acfg->trampoline_size [ntype]) {
7722 g_assert (tramp_size);
7723 acfg->trampoline_size [ntype] = tramp_size;
7724 }
7725 }
7726
7727 emit_label (acfg, end_symbol);
7728 emit_int32 (acfg, 0);
7729 }
7730
7731 arch_emit_specific_trampoline_pages (acfg);
7732
7733 /* Reserve some entries at the end of the GOT for our use */
7734 acfg->num_trampoline_got_entries = tramp_got_offset - acfg->got_offset;
7735 }
7736
7737 acfg->got_offset += acfg->num_trampoline_got_entries;
7738 }
7739
7740 static gboolean
7741 str_begins_with (const char *str1, const char *str2)
7742 {
7743 int len = strlen (str2);
7744 return strncmp (str1, str2, len) == 0;
7745 }
7746
7747 void*
7748 mono_aot_readonly_field_override (MonoClassField *field)
7749 {
7750 ReadOnlyValue *rdv;
7751 for (rdv = readonly_values; rdv; rdv = rdv->next) {
7752 char *p = rdv->name;
7753 int len;
7754 len = strlen (m_class_get_name_space (field->parent));
7755 if (strncmp (p, m_class_get_name_space (field->parent), len))
7756 continue;
7757 p += len;
7758 if (*p++ != '.')
7759 continue;
7760 len = strlen (m_class_get_name (field->parent));
7761 if (strncmp (p, m_class_get_name (field->parent), len))
7762 continue;
7763 p += len;
7764 if (*p++ != '.')
7765 continue;
7766 if (strcmp (p, field->name))
7767 continue;
7768 switch (rdv->type) {
7769 case MONO_TYPE_I1:
7770 return &rdv->value.i1;
7771 case MONO_TYPE_I2:
7772 return &rdv->value.i2;
7773 case MONO_TYPE_I4:
7774 return &rdv->value.i4;
7775 default:
7776 break;
7777 }
7778 }
7779 return NULL;
7780 }
7781
7782 static void
7783 add_readonly_value (MonoAotOptions *opts, const char *val)
7784 {
7785 ReadOnlyValue *rdv;
7786 const char *fval;
7787 const char *tval;
7788 /* the format of val is:
7789 * namespace.typename.fieldname=type/value
7790 * type can be i1 for uint8/int8/boolean, i2 for uint16/int16/char, i4 for uint32/int32
7791 */
7792 fval = strrchr (val, '/');
7793 if (!fval) {
7794 fprintf (stderr, "AOT : invalid format for readonly field '%s', missing /.\n", val);
7795 exit (1);
7796 }
7797 tval = strrchr (val, '=');
7798 if (!tval) {
7799 fprintf (stderr, "AOT : invalid format for readonly field '%s', missing =.\n", val);
7800 exit (1);
7801 }
7802 rdv = g_new0 (ReadOnlyValue, 1);
7803 rdv->name = (char *)g_malloc0 (tval - val + 1);
7804 memcpy (rdv->name, val, tval - val);
7805 tval++;
7806 fval++;
7807 if (strncmp (tval, "i1", 2) == 0) {
7808 rdv->value.i1 = atoi (fval);
7809 rdv->type = MONO_TYPE_I1;
7810 } else if (strncmp (tval, "i2", 2) == 0) {
7811 rdv->value.i2 = atoi (fval);
7812 rdv->type = MONO_TYPE_I2;
7813 } else if (strncmp (tval, "i4", 2) == 0) {
7814 rdv->value.i4 = atoi (fval);
7815 rdv->type = MONO_TYPE_I4;
7816 } else {
7817 fprintf (stderr, "AOT : unsupported type for readonly field '%s'.\n", tval);
7818 exit (1);
7819 }
7820 rdv->next = readonly_values;
7821 readonly_values = rdv;
7822 }
7823
7824 static gchar *
7825 clean_path (gchar * path)
7826 {
7827 if (!path)
7828 return NULL;
7829
7830 if (g_str_has_suffix (path, G_DIR_SEPARATOR_S))
7831 return path;
7832
7833 gchar *clean = g_strconcat (path, G_DIR_SEPARATOR_S, (const char*)NULL);
7834 g_free (path);
7835
7836 return clean;
7837 }
7838
7839 static const gchar *
7840 wrap_path (const gchar * path)
7841 {
7842 int len;
7843 if (!path)
7844 return NULL;
7845
7846 // If the string contains no spaces, just return the original string.
7847 if (strstr (path, " ") == NULL)
7848 return path;
7849
7850 // If the string is already wrapped in quotes, return it.
7851 len = strlen (path);
7852 if (len >= 2 && path[0] == '\"' && path[len-1] == '\"')
7853 return path;
7854
7855 // If the string contains spaces, then wrap it in quotes.
7856 gchar *clean = g_strdup_printf ("\"%s\"", path);
7857
7858 return clean;
7859 }
7860
7861 // Duplicate a char range and add it to a ptrarray, but only if it is nonempty
7862 static void
7863 ptr_array_add_range_if_nonempty(GPtrArray *args, gchar const *start, gchar const *end)
7864 {
7865 ptrdiff_t len = end-start;
7866 if (len > 0)
7867 g_ptr_array_add (args, g_strndup (start, len));
7868 }
7869
7870 static GPtrArray *
7871 mono_aot_split_options (const char *aot_options)
7872 {
7873 enum MonoAotOptionState {
7874 MONO_AOT_OPTION_STATE_DEFAULT,
7875 MONO_AOT_OPTION_STATE_STRING,
7876 MONO_AOT_OPTION_STATE_ESCAPE,
7877 };
7878
7879 GPtrArray *args = g_ptr_array_new ();
7880 enum MonoAotOptionState state = MONO_AOT_OPTION_STATE_DEFAULT;
7881 gchar const *opt_start = aot_options;
7882 gboolean end_of_string = FALSE;
7883 gchar cur;
7884
7885 g_return_val_if_fail (aot_options != NULL, NULL);
7886
7887 while ((cur = *aot_options) != '\0') {
7888 if (state == MONO_AOT_OPTION_STATE_ESCAPE)
7889 goto next;
7890
7891 switch (cur) {
7892 case '"':
7893 // If we find a quote, then if we're in the default case then
7894 // it means we've found the start of a string, if not then it
7895 // means we've found the end of the string and should switch
7896 // back to the default case.
7897 switch (state) {
7898 case MONO_AOT_OPTION_STATE_DEFAULT:
7899 state = MONO_AOT_OPTION_STATE_STRING;
7900 break;
7901 case MONO_AOT_OPTION_STATE_STRING:
7902 state = MONO_AOT_OPTION_STATE_DEFAULT;
7903 break;
7904 case MONO_AOT_OPTION_STATE_ESCAPE:
7905 g_assert_not_reached ();
7906 break;
7907 }
7908 break;
7909 case '\\':
7910 // If we've found an escaping operator, then this means we
7911 // should not process the next character if inside a string.
7912 if (state == MONO_AOT_OPTION_STATE_STRING)
7913 state = MONO_AOT_OPTION_STATE_ESCAPE;
7914 break;
7915 case ',':
7916 // If we're in the default state then this means we've found
7917 // an option, store it for later processing.
7918 if (state == MONO_AOT_OPTION_STATE_DEFAULT)
7919 goto new_opt;
7920 break;
7921 }
7922
7923 next:
7924 aot_options++;
7925 restart:
7926 // If the next character is end of string, then process the last option.
7927 if (*(aot_options) == '\0') {
7928 end_of_string = TRUE;
7929 goto new_opt;
7930 }
7931 continue;
7932
7933 new_opt:
7934 ptr_array_add_range_if_nonempty (args, opt_start, aot_options);
7935 opt_start = ++aot_options;
7936 if (end_of_string)
7937 break;
7938 goto restart; // Check for null and continue loop
7939 }
7940
7941 return args;
7942 }
7943
7944 static gboolean
7945 parse_cpu_features (const gchar *attr)
7946 {
7947 if (!attr || strlen (attr) < 2) {
7948 fprintf (stderr, "Invalid attribute");
7949 return FALSE;
7950 }
7951
7952 //+foo - enable foo
7953 //foo - enable foo
7954 //-foo - disable foo
7955 gboolean enabled = TRUE;
7956 if (attr [0] == '-')
7957 enabled = FALSE;
7958 int prefix = (attr [0] == '-' || attr [0] == '+') ? 1 : 0;
7959 MonoCPUFeatures feature = (MonoCPUFeatures) 0;
7960
7961 #if defined(TARGET_X86) || defined(TARGET_AMD64)
7962 // e.g.:
7963 // `mattr=+sse3` = +sse,+sse2,+pclmul,+aes,+sse3
7964 // `mattr=-sse3` = -sse3,-ssse3,-sse4.1,-sse4.2,-popcnt,-avx,-avx2,-fma
7965 if (!strcmp (attr + prefix, "sse"))
7966 feature = MONO_CPU_X86_SSE_COMBINED;
7967 else if (!strcmp (attr + prefix, "sse2"))
7968 feature = MONO_CPU_X86_SSE2_COMBINED;
7969 else if (!strcmp (attr + prefix, "sse3"))
7970 feature = MONO_CPU_X86_SSE3_COMBINED;
7971 else if (!strcmp (attr + prefix, "ssse3"))
7972 feature = MONO_CPU_X86_SSSE3_COMBINED;
7973 else if (!strcmp (attr + prefix, "sse4.1"))
7974 feature = MONO_CPU_X86_SSE41_COMBINED;
7975 else if (!strcmp (attr + prefix, "sse4.2"))
7976 feature = MONO_CPU_X86_SSE42_COMBINED;
7977 else if (!strcmp (attr + prefix, "avx"))
7978 feature = MONO_CPU_X86_AVX_COMBINED;
7979 else if (!strcmp (attr + prefix, "avx2"))
7980 feature = MONO_CPU_X86_AVX2_COMBINED;
7981 else if (!strcmp (attr + prefix, "pclmul"))
7982 feature = MONO_CPU_X86_PCLMUL_COMBINED;
7983 else if (!strcmp (attr + prefix, "aes"))
7984 feature = MONO_CPU_X86_AES_COMBINED;
7985 else if (!strcmp (attr + prefix, "popcnt"))
7986 feature = MONO_CPU_X86_POPCNT_COMBINED;
7987 else if (!strcmp (attr + prefix, "fma"))
7988 feature = MONO_CPU_X86_FMA_COMBINED;
7989 // these are independent
7990 else if (!strcmp (attr + prefix, "lzcnt")) // technically, it'a a part of BMI but only on Intel
7991 feature = MONO_CPU_X86_LZCNT;
7992 else if (!strcmp (attr + prefix, "bmi")) // NOTE: it's not "bmi1"
7993 feature = MONO_CPU_X86_BMI1;
7994 else if (!strcmp (attr + prefix, "bmi2"))
7995 feature = MONO_CPU_X86_BMI2; // BMI2 doesn't imply BMI1
7996 else {
7997 // we don't have a flag for it but it's probably recognized by opt/llc so let's don't fire an error here
7998 // printf ("Unknown cpu feature: %s\n", attr);
7999 }
8000
8001 // if we disable a feature from the SSE-AVX tree we also need to disable all dependencies
8002 if (!enabled && (feature & MONO_CPU_X86_FULL_SSEAVX_COMBINED))
8003 feature = (MonoCPUFeatures) (MONO_CPU_X86_FULL_SSEAVX_COMBINED & ~feature);
8004
8005 #elif defined(TARGET_ARM64)
8006 // TODO: neon, sha1, sha2, asimd, etc...
8007 #elif defined(TARGET_WASM)
8008 if (!strcmp (attr + prefix, "simd"))
8009 feature = MONO_CPU_WASM_SIMD;
8010 #endif
8011
8012 if (enabled)
8013 mono_cpu_features_enabled = (MonoCPUFeatures) (mono_cpu_features_enabled | feature);
8014 else
8015 mono_cpu_features_disabled = (MonoCPUFeatures) (mono_cpu_features_disabled | feature);
8016
8017 return TRUE;
8018 }
8019
8020 static void
8021 mono_aot_parse_options (const char *aot_options, MonoAotOptions *opts)
8022 {
8023 GPtrArray* args;
8024
8025 args = mono_aot_split_options (aot_options ? aot_options : "");
8026 for (int i = 0; i < args->len; ++i) {
8027 const char *arg = (const char *)g_ptr_array_index (args, i);
8028
8029 if (str_begins_with (arg, "outfile=")) {
8030 opts->outfile = g_strdup (arg + strlen ("outfile="));
8031 } else if (str_begins_with (arg, "llvm-outfile=")) {
8032 opts->llvm_outfile = g_strdup (arg + strlen ("llvm-outfile="));
8033 } else if (str_begins_with (arg, "temp-path=")) {
8034 opts->temp_path = clean_path (g_strdup (arg + strlen ("temp-path=")));
8035 } else if (str_begins_with (arg, "save-temps")) {
8036 opts->save_temps = TRUE;
8037 } else if (str_begins_with (arg, "keep-temps")) {
8038 opts->save_temps = TRUE;
8039 } else if (str_begins_with (arg, "write-symbols")) {
8040 opts->write_symbols = TRUE;
8041 } else if (str_begins_with (arg, "no-write-symbols")) {
8042 opts->write_symbols = FALSE;
8043 // Intentionally undocumented -- one-off experiment
8044 } else if (str_begins_with (arg, "metadata-only")) {
8045 opts->metadata_only = TRUE;
8046 } else if (str_begins_with (arg, "bind-to-runtime-version")) {
8047 opts->bind_to_runtime_version = TRUE;
8048 } else if (str_begins_with (arg, "full")) {
8049 opts->mode = MONO_AOT_MODE_FULL;
8050 } else if (str_begins_with (arg, "hybrid")) {
8051 opts->mode = MONO_AOT_MODE_HYBRID;
8052 } else if (str_begins_with (arg, "interp")) {
8053 opts->interp = TRUE;
8054 } else if (str_begins_with (arg, "threads=")) {
8055 opts->nthreads = atoi (arg + strlen ("threads="));
8056 } else if (str_begins_with (arg, "static")) {
8057 opts->static_link = TRUE;
8058 opts->no_dlsym = TRUE;
8059 } else if (str_begins_with (arg, "asmonly")) {
8060 opts->asm_only = TRUE;
8061 } else if (str_begins_with (arg, "asmwriter")) {
8062 opts->asm_writer = TRUE;
8063 } else if (str_begins_with (arg, "nodebug")) {
8064 opts->nodebug = TRUE;
8065 } else if (str_begins_with (arg, "dwarfdebug")) {
8066 opts->dwarf_debug = TRUE;
8067 // Intentionally undocumented -- No one remembers what this does. It appears to be ARM-only
8068 } else if (str_begins_with (arg, "nopagetrampolines")) {
8069 opts->use_trampolines_page = FALSE;
8070 } else if (str_begins_with (arg, "ntrampolines=")) {
8071 opts->ntrampolines = atoi (arg + strlen ("ntrampolines="));
8072 } else if (str_begins_with (arg, "nrgctx-trampolines=")) {
8073 opts->nrgctx_trampolines = atoi (arg + strlen ("nrgctx-trampolines="));
8074 } else if (str_begins_with (arg, "nrgctx-fetch-trampolines=")) {
8075 opts->nrgctx_fetch_trampolines = atoi (arg + strlen ("nrgctx-fetch-trampolines="));
8076 } else if (str_begins_with (arg, "nimt-trampolines=")) {
8077 opts->nimt_trampolines = atoi (arg + strlen ("nimt-trampolines="));
8078 } else if (str_begins_with (arg, "ngsharedvt-trampolines=")) {
8079 opts->ngsharedvt_arg_trampolines = atoi (arg + strlen ("ngsharedvt-trampolines="));
8080 } else if (str_begins_with (arg, "nftnptr-arg-trampolines=")) {
8081 opts->nftnptr_arg_trampolines = atoi (arg + strlen ("nftnptr-arg-trampolines="));
8082 } else if (str_begins_with (arg, "nunbox-arbitrary-trampolines=")) {
8083 opts->nunbox_arbitrary_trampolines = atoi (arg + strlen ("unbox-arbitrary-trampolines="));
8084 } else if (str_begins_with (arg, "tool-prefix=")) {
8085 opts->tool_prefix = g_strdup (arg + strlen ("tool-prefix="));
8086 } else if (str_begins_with (arg, "ld-flags=")) {
8087 opts->ld_flags = g_strdup (arg + strlen ("ld-flags="));
8088 } else if (str_begins_with (arg, "soft-debug")) {
8089 opts->soft_debug = TRUE;
8090 // Intentionally undocumented x2-- deprecated
8091 } else if (str_begins_with (arg, "gen-seq-points-file=")) {
8092 fprintf (stderr, "Mono Warning: aot option gen-seq-points-file= is deprecated.\n");
8093 } else if (str_begins_with (arg, "gen-seq-points-file")) {
8094 fprintf (stderr, "Mono Warning: aot option gen-seq-points-file is deprecated.\n");
8095 } else if (str_begins_with (arg, "msym-dir=")) {
8096 mini_debug_options.no_seq_points_compact_data = FALSE;
8097 opts->gen_msym_dir = TRUE;
8098 opts->gen_msym_dir_path = g_strdup (arg + strlen ("msym_dir="));
8099 } else if (str_begins_with (arg, "direct-pinvoke")) {
8100 opts->direct_pinvoke = TRUE;
8101 } else if (str_begins_with (arg, "direct-icalls")) {
8102 opts->direct_icalls = TRUE;
8103 } else if (str_begins_with (arg, "no-direct-calls")) {
8104 opts->no_direct_calls = TRUE;
8105 } else if (str_begins_with (arg, "print-skipped")) {
8106 opts->print_skipped_methods = TRUE;
8107 } else if (str_begins_with (arg, "stats")) {
8108 opts->stats = TRUE;
8109 // Intentionally undocumented-- has no known function other than to debug the compiler
8110 } else if (str_begins_with (arg, "no-instances")) {
8111 opts->no_instances = TRUE;
8112 // Intentionally undocumented x4-- Used for internal debugging of compiler
8113 } else if (str_begins_with (arg, "log-generics")) {
8114 opts->log_generics = TRUE;
8115 } else if (str_begins_with (arg, "log-instances=")) {
8116 opts->log_instances = TRUE;
8117 opts->instances_logfile_path = g_strdup (arg + strlen ("log-instances="));
8118 } else if (str_begins_with (arg, "log-instances")) {
8119 opts->log_instances = TRUE;
8120 } else if (str_begins_with (arg, "internal-logfile=")) {
8121 opts->logfile = g_strdup (arg + strlen ("internal-logfile="));
8122 } else if (str_begins_with (arg, "dedup-skip")) {
8123 opts->dedup = TRUE;
8124 } else if (str_begins_with (arg, "dedup-include=")) {
8125 opts->dedup_include = g_strdup (arg + strlen ("dedup-include="));
8126 } else if (str_begins_with (arg, "mtriple=")) {
8127 opts->mtriple = g_strdup (arg + strlen ("mtriple="));
8128 } else if (str_begins_with (arg, "llvm-path=")) {
8129 opts->llvm_path = clean_path (g_strdup (arg + strlen ("llvm-path=")));
8130 } else if (!strcmp (arg, "try-llvm")) {
8131 // If we can load LLVM, use it
8132 // Note: if you call this function from anywhere but mono_compile_assembly,
8133 // this will only set the try_llvm attribute and not do the probing / set the
8134 // attribute.
8135 opts->try_llvm = TRUE;
8136 } else if (!strcmp (arg, "llvm")) {
8137 opts->llvm = TRUE;
8138 } else if (str_begins_with (arg, "readonly-value=")) {
8139 add_readonly_value (opts, arg + strlen ("readonly-value="));
8140 } else if (str_begins_with (arg, "info")) {
8141 printf ("AOT target setup: %s.\n", AOT_TARGET_STR);
8142 exit (0);
8143 // Intentionally undocumented: Used for precise stack maps, which are not available yet
8144 } else if (str_begins_with (arg, "gc-maps")) {
8145 mini_gc_enable_gc_maps_for_aot ();
8146 // Intentionally undocumented: Used for internal debugging
8147 } else if (str_begins_with (arg, "dump")) {
8148 opts->dump_json = TRUE;
8149 } else if (str_begins_with (arg, "llvmonly")) {
8150 opts->mode = MONO_AOT_MODE_FULL;
8151 opts->llvm = TRUE;
8152 opts->llvm_only = TRUE;
8153 } else if (str_begins_with (arg, "data-outfile=")) {
8154 opts->data_outfile = g_strdup (arg + strlen ("data-outfile="));
8155 } else if (str_begins_with (arg, "profile=")) {
8156 opts->profile_files = g_list_append (opts->profile_files, g_strdup (arg + strlen ("profile=")));
8157 } else if (!strcmp (arg, "profile-only")) {
8158 opts->profile_only = TRUE;
8159 } else if (!strcmp (arg, "verbose")) {
8160 opts->verbose = TRUE;
8161 } else if (str_begins_with (arg, "llvmopts=")){
8162 if (opts->llvm_opts) {
8163 char *s = g_strdup_printf ("%s %s", opts->llvm_opts, arg + strlen ("llvmopts="));
8164 g_free (opts->llvm_opts);
8165 opts->llvm_opts = s;
8166 } else {
8167 opts->llvm_opts = g_strdup (arg + strlen ("llvmopts="));
8168 }
8169 } else if (str_begins_with (arg, "llvmllc=")){
8170 opts->llvm_llc = g_strdup (arg + strlen ("llvmllc="));
8171 } else if (!strcmp (arg, "deterministic")) {
8172 opts->deterministic = TRUE;
8173 } else if (!strcmp (arg, "no-opt")) {
8174 opts->no_opt = TRUE;
8175 } else if (str_begins_with (arg, "clangxx=")) {
8176 opts->clangxx = g_strdup (arg + strlen ("clangxx="));
8177 } else if (str_begins_with (arg, "mcpu=")) {
8178 if (!strcmp(arg, "mcpu=native")) {
8179 opts->use_current_cpu = TRUE;
8180 } else if (!strcmp(arg, "mcpu=generic")) {
8181 opts->use_current_cpu = FALSE;
8182 } else {
8183 printf ("mcpu can only be 'native' or 'generic' (default).\n");
8184 exit (0);
8185 }
8186 } else if (str_begins_with (arg, "mattr=")) {
8187 gchar* attr = g_strdup (arg + strlen ("mattr="));
8188 if (!parse_cpu_features (attr))
8189 exit (0);
8190 // mattr can be declared more than once, e.g.
8191 // `mattr=avx2,mattr=lzcnt,mattr=bmi2`
8192 if (!opts->llvm_cpu_attr)
8193 opts->llvm_cpu_attr = attr;
8194 else {
8195 char* old_attrs = opts->llvm_cpu_attr;
8196 opts->llvm_cpu_attr = g_strdup_printf ("%s,%s", opts->llvm_cpu_attr, attr);
8197 g_free (old_attrs);
8198 }
8199 } else if (str_begins_with (arg, "depfile=")) {
8200 opts->depfile = g_strdup (arg + strlen ("depfile="));
8201 } else if (str_begins_with (arg, "help") || str_begins_with (arg, "?")) {
8202 printf ("Supported options for --aot:\n");
8203 printf (" asmonly\n");
8204 printf (" bind-to-runtime-version\n");
8205 printf (" bitcode\n");
8206 printf (" data-outfile=\n");
8207 printf (" direct-icalls\n");
8208 printf (" direct-pinvoke\n");
8209 printf (" dwarfdebug\n");
8210 printf (" full\n");
8211 printf (" hybrid\n");
8212 printf (" info\n");
8213 printf (" keep-temps\n");
8214 printf (" llvm\n");
8215 printf (" llvmonly\n");
8216 printf (" llvm-outfile=\n");
8217 printf (" llvm-path=\n");
8218 printf (" msym-dir=\n");
8219 printf (" mtriple\n");
8220 printf (" nimt-trampolines=\n");
8221 printf (" nodebug\n");
8222 printf (" no-direct-calls\n");
8223 printf (" no-write-symbols\n");
8224 printf (" nrgctx-trampolines=\n");
8225 printf (" nrgctx-fetch-trampolines=\n");
8226 printf (" ngsharedvt-trampolines=\n");
8227 printf (" nftnptr-arg-trampolines=\n");
8228 printf (" nunbox-arbitrary-trampolines=\n");
8229 printf (" ntrampolines=\n");
8230 printf (" outfile=\n");
8231 printf (" profile=\n");
8232 printf (" profile-only\n");
8233 printf (" print-skipped-methods\n");
8234 printf (" readonly-value=\n");
8235 printf (" save-temps\n");
8236 printf (" soft-debug\n");
8237 printf (" static\n");
8238 printf (" stats\n");
8239 printf (" temp-path=\n");
8240 printf (" tool-prefix=\n");
8241 printf (" threads=\n");
8242 printf (" write-symbols\n");
8243 printf (" verbose\n");
8244 printf (" no-opt\n");
8245 printf (" llvmopts=\n");
8246 printf (" llvmllc=\n");
8247 printf (" clangxx=\n");
8248 printf (" depfile=\n");
8249 printf (" mcpu=\n");
8250 printf (" mattr=\n");
8251 printf (" help/?\n");
8252 exit (0);
8253 } else {
8254 fprintf (stderr, "AOT : Unknown argument '%s'.\n", arg);
8255 exit (1);
8256 }
8257
8258 g_free ((gpointer) arg);
8259 }
8260
8261 if (opts->use_trampolines_page) {
8262 opts->ntrampolines = 0;
8263 opts->nrgctx_trampolines = 0;
8264 opts->nimt_trampolines = 0;
8265 opts->ngsharedvt_arg_trampolines = 0;
8266 opts->nftnptr_arg_trampolines = 0;
8267 opts->nunbox_arbitrary_trampolines = 0;
8268 }
8269
8270 g_ptr_array_free (args, /*free_seg=*/TRUE);
8271 }
8272
8273 static void
8274 add_token_info_hash (gpointer key, gpointer value, gpointer user_data)
8275 {
8276 MonoMethod *method = (MonoMethod*)key;
8277 MonoJumpInfoToken *ji = (MonoJumpInfoToken*)value;
8278 MonoAotCompile *acfg = (MonoAotCompile *)user_data;
8279 MonoJumpInfoToken *new_ji;
8280
8281 new_ji = (MonoJumpInfoToken *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfoToken));
8282 new_ji->image = ji->image;
8283 new_ji->token = ji->token;
8284 g_hash_table_insert (acfg->token_info_hash, method, new_ji);
8285 }
8286
8287 static gboolean
8288 can_encode_class (MonoAotCompile *acfg, MonoClass *klass)
8289 {
8290 if (m_class_get_type_token (klass))
8291 return TRUE;
8292 if ((m_class_get_byval_arg (klass)->type == MONO_TYPE_VAR) || (m_class_get_byval_arg (klass)->type == MONO_TYPE_MVAR) || (m_class_get_byval_arg (klass)->type == MONO_TYPE_PTR))
8293 return TRUE;
8294 if (m_class_get_rank (klass))
8295 return can_encode_class (acfg, m_class_get_element_class (klass));
8296 return FALSE;
8297 }
8298
8299 static gboolean
8300 can_encode_method (MonoAotCompile *acfg, MonoMethod *method)
8301 {
8302 if (method->wrapper_type) {
8303 switch (method->wrapper_type) {
8304 case MONO_WRAPPER_NONE:
8305 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK:
8306 case MONO_WRAPPER_XDOMAIN_INVOKE:
8307 case MONO_WRAPPER_STFLD:
8308 case MONO_WRAPPER_LDFLD:
8309 case MONO_WRAPPER_LDFLDA:
8310 case MONO_WRAPPER_STELEMREF:
8311 case MONO_WRAPPER_PROXY_ISINST:
8312 case MONO_WRAPPER_ALLOC:
8313 case MONO_WRAPPER_REMOTING_INVOKE:
8314 case MONO_WRAPPER_OTHER:
8315 case MONO_WRAPPER_WRITE_BARRIER:
8316 case MONO_WRAPPER_DELEGATE_INVOKE:
8317 case MONO_WRAPPER_DELEGATE_BEGIN_INVOKE:
8318 case MONO_WRAPPER_DELEGATE_END_INVOKE:
8319 case MONO_WRAPPER_SYNCHRONIZED:
8320 case MONO_WRAPPER_MANAGED_TO_NATIVE:
8321 break;
8322 case MONO_WRAPPER_MANAGED_TO_MANAGED:
8323 case MONO_WRAPPER_CASTCLASS: {
8324 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
8325
8326 if (info)
8327 return TRUE;
8328 else
8329 return FALSE;
8330 break;
8331 }
8332 default:
8333 //printf ("Skip (wrapper call): %d -> %s\n", patch_info->type, mono_method_full_name (patch_info->data.method, TRUE));
8334 return FALSE;
8335 }
8336 } else {
8337 if (!method->token) {
8338 /* The method is part of a constructed type like Int[,].Set (). */
8339 if (!g_hash_table_lookup (acfg->token_info_hash, method)) {
8340 if (m_class_get_rank (method->klass))
8341 return TRUE;
8342 return FALSE;
8343 }
8344 }
8345 }
8346 return TRUE;
8347 }
8348
8349 static gboolean
8350 can_encode_patch (MonoAotCompile *acfg, MonoJumpInfo *patch_info)
8351 {
8352 switch (patch_info->type) {
8353 case MONO_PATCH_INFO_METHOD:
8354 case MONO_PATCH_INFO_METHOD_FTNDESC:
8355 case MONO_PATCH_INFO_METHODCONST:
8356 case MONO_PATCH_INFO_METHOD_CODE_SLOT: {
8357 MonoMethod *method = patch_info->data.method;
8358
8359 return can_encode_method (acfg, method);
8360 }
8361 case MONO_PATCH_INFO_VTABLE:
8362 case MONO_PATCH_INFO_CLASS:
8363 case MONO_PATCH_INFO_IID:
8364 case MONO_PATCH_INFO_ADJUSTED_IID:
8365 if (!can_encode_class (acfg, patch_info->data.klass)) {
8366 //printf ("Skip: %s\n", mono_type_full_name (m_class_get_byval_arg (patch_info->data.klass)));
8367 return FALSE;
8368 }
8369 break;
8370 case MONO_PATCH_INFO_DELEGATE_TRAMPOLINE: {
8371 if (!can_encode_class (acfg, patch_info->data.del_tramp->klass)) {
8372 //printf ("Skip: %s\n", mono_type_full_name (m_class_get_byval_arg (patch_info->data.klass)));
8373 return FALSE;
8374 }
8375 break;
8376 }
8377 case MONO_PATCH_INFO_RGCTX_FETCH:
8378 case MONO_PATCH_INFO_RGCTX_SLOT_INDEX: {
8379 MonoJumpInfoRgctxEntry *entry = patch_info->data.rgctx_entry;
8380
8381 if (entry->in_mrgctx) {
8382 if (!can_encode_method (acfg, entry->d.method))
8383 return FALSE;
8384 } else {
8385 if (!can_encode_class (acfg, entry->d.klass))
8386 return FALSE;
8387 }
8388 if (!can_encode_patch (acfg, entry->data))
8389 return FALSE;
8390 break;
8391 }
8392 default:
8393 break;
8394 }
8395
8396 return TRUE;
8397 }
8398
8399 static gboolean
8400 is_concrete_type (MonoType *t)
8401 {
8402 MonoClass *klass;
8403 int i;
8404
8405 if (t->type == MONO_TYPE_VAR || t->type == MONO_TYPE_MVAR)
8406 return FALSE;
8407 if (t->type == MONO_TYPE_GENERICINST) {
8408 MonoGenericContext *orig_ctx;
8409 MonoGenericInst *inst;
8410 MonoType *arg;
8411
8412 if (!MONO_TYPE_ISSTRUCT (t))
8413 return TRUE;
8414 klass = mono_class_from_mono_type_internal (t);
8415 orig_ctx = &mono_class_get_generic_class (klass)->context;
8416
8417 inst = orig_ctx->class_inst;
8418 if (inst) {
8419 for (i = 0; i < inst->type_argc; ++i) {
8420 arg = mini_get_underlying_type (inst->type_argv [i]);
8421 if (!is_concrete_type (arg))
8422 return FALSE;
8423 }
8424 }
8425 inst = orig_ctx->method_inst;
8426 if (inst) {
8427 for (i = 0; i < inst->type_argc; ++i) {
8428 arg = mini_get_underlying_type (inst->type_argv [i]);
8429 if (!is_concrete_type (arg))
8430 return FALSE;
8431 }
8432 }
8433 }
8434 return TRUE;
8435 }
8436
8437 static MonoMethodSignature*
8438 get_concrete_sig (MonoMethodSignature *sig)
8439 {
8440 gboolean concrete = TRUE;
8441
8442 if (!sig->has_type_parameters)
8443 return sig;
8444
8445 /* For signatures created during generic sharing, convert them to a concrete signature if possible */
8446 MonoMethodSignature *copy = mono_metadata_signature_dup (sig);
8447 int i;
8448
8449 //printf ("%s\n", mono_signature_full_name (sig));
8450
8451 if (sig->ret->byref)
8452 copy->ret = m_class_get_this_arg (mono_defaults.int_class);
8453 else
8454 copy->ret = mini_get_underlying_type (sig->ret);
8455 if (!is_concrete_type (copy->ret))
8456 concrete = FALSE;
8457 for (i = 0; i < sig->param_count; ++i) {
8458 if (sig->params [i]->byref) {
8459 MonoType *t = m_class_get_byval_arg (mono_class_from_mono_type_internal (sig->params [i]));
8460 t = mini_get_underlying_type (t);
8461 copy->params [i] = m_class_get_this_arg (mono_class_from_mono_type_internal (t));
8462 } else {
8463 copy->params [i] = mini_get_underlying_type (sig->params [i]);
8464 }
8465 if (!is_concrete_type (copy->params [i]))
8466 concrete = FALSE;
8467 }
8468 copy->has_type_parameters = 0;
8469 if (!concrete)
8470 return NULL;
8471 return copy;
8472 }
8473
8474 /* LOCKING: Assumes the loader lock is held */
8475 static void
8476 add_gsharedvt_wrappers (MonoAotCompile *acfg, MonoMethodSignature *sig, gboolean gsharedvt_in, gboolean gsharedvt_out, gboolean interp_in)
8477 {
8478 MonoMethod *wrapper;
8479 gboolean add_in = gsharedvt_in;
8480 gboolean add_out = gsharedvt_out;
8481
8482 if (gsharedvt_in && g_hash_table_lookup (acfg->gsharedvt_in_signatures, sig))
8483 add_in = FALSE;
8484 if (gsharedvt_out && g_hash_table_lookup (acfg->gsharedvt_out_signatures, sig))
8485 add_out = FALSE;
8486
8487 if (!add_in && !add_out)
8488 return;
8489
8490 if (mini_is_gsharedvt_variable_signature (sig))
8491 return;
8492
8493 if (add_in)
8494 g_hash_table_insert (acfg->gsharedvt_in_signatures, sig, sig);
8495 if (add_out)
8496 g_hash_table_insert (acfg->gsharedvt_out_signatures, sig, sig);
8497
8498 sig = get_concrete_sig (sig);
8499 if (!sig)
8500 return;
8501 //printf ("%s\n", mono_signature_full_name (sig));
8502
8503 if (gsharedvt_in) {
8504 wrapper = mini_get_gsharedvt_in_sig_wrapper (sig);
8505 add_extra_method (acfg, wrapper);
8506 }
8507 if (gsharedvt_out) {
8508 wrapper = mini_get_gsharedvt_out_sig_wrapper (sig);
8509 add_extra_method (acfg, wrapper);
8510 }
8511
8512 #ifndef MONO_ARCH_HAVE_INTERP_ENTRY_TRAMPOLINE
8513 if (interp_in) {
8514 wrapper = mini_get_interp_in_wrapper (sig);
8515 add_extra_method (acfg, wrapper);
8516 //printf ("X: %s\n", mono_method_full_name (wrapper, 1));
8517 }
8518 #endif
8519 }
8520
8521 /*
8522 * compile_method:
8523 *
8524 * AOT compile a given method.
8525 * This function might be called by multiple threads, so it must be thread-safe.
8526 */
8527 static void
8528 compile_method (MonoAotCompile *acfg, MonoMethod *method)
8529 {
8530 MonoCompile *cfg;
8531 MonoJumpInfo *patch_info;
8532 gboolean skip;
8533 int index, depth;
8534 MonoMethod *wrapped;
8535 gint64 jit_time_start;
8536 JitFlags flags;
8537
8538 if (acfg->aot_opts.metadata_only)
8539 return;
8540
8541 mono_acfg_lock (acfg);
8542 index = get_method_index (acfg, method);
8543 mono_acfg_unlock (acfg);
8544
8545 /* fixme: maybe we can also precompile wrapper methods */
8546 if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
8547 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
8548 (method->flags & METHOD_ATTRIBUTE_ABSTRACT)) {
8549 //printf ("Skip (impossible): %s\n", mono_method_full_name (method, TRUE));
8550 return;
8551 }
8552
8553 if (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)
8554 return;
8555
8556 wrapped = mono_marshal_method_from_wrapper (method);
8557 if (wrapped && (wrapped->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && wrapped->is_generic)
8558 // FIXME: The wrapper should be generic too, but it is not
8559 return;
8560
8561 if (method->wrapper_type == MONO_WRAPPER_COMINTEROP)
8562 return;
8563
8564 if (acfg->aot_opts.profile_only && !g_hash_table_lookup (acfg->profile_methods, method)) {
8565 if (acfg->aot_opts.llvm_only) {
8566 gboolean keep = FALSE;
8567 if (method->wrapper_type) {
8568 /* Keep most wrappers */
8569 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
8570 switch (info->subtype) {
8571 case WRAPPER_SUBTYPE_PTR_TO_STRUCTURE:
8572 case WRAPPER_SUBTYPE_STRUCTURE_TO_PTR:
8573 break;
8574 default:
8575 keep = TRUE;
8576 break;
8577 }
8578 }
8579 if (always_aot (method))
8580 keep = TRUE;
8581 if (!keep)
8582 return;
8583 } else {
8584 if (!method->is_inflated)
8585 return;
8586 }
8587 }
8588
8589 mono_atomic_inc_i32 (&acfg->stats.mcount);
8590
8591 #if 0
8592 if (method->is_generic || mono_class_is_gtd (method->klass)) {
8593 mono_atomic_inc_i32 (&acfg->stats.genericcount);
8594 return;
8595 }
8596 #endif
8597
8598 //acfg->aot_opts.print_skipped_methods = TRUE;
8599
8600 /*
8601 * Since these methods are the only ones which are compiled with
8602 * AOT support, and they are not used by runtime startup/shutdown code,
8603 * the runtime will not see AOT methods during AOT compilation,so it
8604 * does not need to support them by creating a fake GOT etc.
8605 */
8606 flags = JIT_FLAG_AOT;
8607 if (mono_aot_mode_is_full (&acfg->aot_opts))
8608 flags = (JitFlags)(flags | JIT_FLAG_FULL_AOT);
8609 if (acfg->llvm)
8610 flags = (JitFlags)(flags | JIT_FLAG_LLVM);
8611 if (acfg->aot_opts.llvm_only)
8612 flags = (JitFlags)(flags | JIT_FLAG_LLVM_ONLY | JIT_FLAG_EXPLICIT_NULL_CHECKS);
8613 if (acfg->aot_opts.no_direct_calls)
8614 flags = (JitFlags)(flags | JIT_FLAG_NO_DIRECT_ICALLS);
8615 if (acfg->aot_opts.direct_pinvoke)
8616 flags = (JitFlags)(flags | JIT_FLAG_DIRECT_PINVOKE);
8617 if (acfg->aot_opts.interp)
8618 flags = (JitFlags)(flags | JIT_FLAG_INTERP);
8619 if (acfg->aot_opts.use_current_cpu)
8620 flags = (JitFlags)(flags | JIT_FLAG_USE_CURRENT_CPU);
8621
8622 jit_time_start = mono_time_track_start ();
8623 cfg = mini_method_compile (method, acfg->opts, mono_get_root_domain (), flags, 0, index);
8624 mono_time_track_end (&mono_jit_stats.jit_time, jit_time_start);
8625
8626 if (cfg->exception_type == MONO_EXCEPTION_GENERIC_SHARING_FAILED) {
8627 if (acfg->aot_opts.print_skipped_methods)
8628 printf ("Skip (gshared failure): %s (%s)\n", mono_method_get_full_name (method), cfg->exception_message);
8629 mono_atomic_inc_i32 (&acfg->stats.genericcount);
8630 return;
8631 }
8632 if (cfg->exception_type != MONO_EXCEPTION_NONE) {
8633 /* Some instances cannot be JITted due to constraints etc. */
8634 if (!method->is_inflated)
8635 report_loader_error (acfg, cfg->error, FALSE, "Unable to compile method '%s' due to: '%s'.\n", mono_method_get_full_name (method), mono_error_get_message (cfg->error));
8636 /* Let the exception happen at runtime */
8637 return;
8638 }
8639
8640 if (cfg->disable_aot) {
8641 if (acfg->aot_opts.print_skipped_methods)
8642 printf ("Skip (disabled): %s\n", mono_method_get_full_name (method));
8643 mono_atomic_inc_i32 (&acfg->stats.ocount);
8644 return;
8645 }
8646 cfg->method_index = index;
8647
8648 /* Nullify patches which need no aot processing */
8649 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
8650 switch (patch_info->type) {
8651 case MONO_PATCH_INFO_LABEL:
8652 case MONO_PATCH_INFO_BB:
8653 patch_info->type = MONO_PATCH_INFO_NONE;
8654 break;
8655 default:
8656 break;
8657 }
8658 }
8659
8660 /* Collect method->token associations from the cfg */
8661 mono_acfg_lock (acfg);
8662 g_hash_table_foreach (cfg->token_info_hash, add_token_info_hash, acfg);
8663 mono_acfg_unlock (acfg);
8664 g_hash_table_destroy (cfg->token_info_hash);
8665 cfg->token_info_hash = NULL;
8666
8667 /*
8668 * Check for absolute addresses.
8669 */
8670 skip = FALSE;
8671 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
8672 switch (patch_info->type) {
8673 case MONO_PATCH_INFO_ABS:
8674 /* unable to handle this */
8675 skip = TRUE;
8676 break;
8677 default:
8678 break;
8679 }
8680 }
8681
8682 if (skip) {
8683 if (acfg->aot_opts.print_skipped_methods)
8684 printf ("Skip (abs call): %s\n", mono_method_get_full_name (method));
8685 mono_atomic_inc_i32 (&acfg->stats.abscount);
8686 return;
8687 }
8688
8689 /* Lock for the rest of the code */
8690 mono_acfg_lock (acfg);
8691
8692 if (cfg->gsharedvt)
8693 acfg->stats.method_categories [METHOD_CAT_GSHAREDVT] ++;
8694 else if (cfg->gshared)
8695 acfg->stats.method_categories [METHOD_CAT_INST] ++;
8696 else if (cfg->method->wrapper_type)
8697 acfg->stats.method_categories [METHOD_CAT_WRAPPER] ++;
8698 else
8699 acfg->stats.method_categories [METHOD_CAT_NORMAL] ++;
8700
8701 /*
8702 * Check for methods/klasses we can't encode.
8703 */
8704 skip = FALSE;
8705 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
8706 if (!can_encode_patch (acfg, patch_info))
8707 skip = TRUE;
8708 }
8709
8710 if (skip) {
8711 if (acfg->aot_opts.print_skipped_methods)
8712 printf ("Skip (patches): %s\n", mono_method_get_full_name (method));
8713 acfg->stats.ocount++;
8714 mono_acfg_unlock (acfg);
8715 return;
8716 }
8717
8718 if (!cfg->compile_llvm)
8719 acfg->has_jitted_code = TRUE;
8720
8721 if (method->is_inflated && acfg->aot_opts.log_instances) {
8722 if (acfg->instances_logfile)
8723 fprintf (acfg->instances_logfile, "%s ### %d\n", mono_method_get_full_name (method), cfg->code_size);
8724 else
8725 printf ("%s ### %d\n", mono_method_get_full_name (method), cfg->code_size);
8726 }
8727
8728 /* Adds generic instances referenced by this method */
8729 /*
8730 * The depth is used to avoid infinite loops when generic virtual recursion is
8731 * encountered.
8732 */
8733 depth = GPOINTER_TO_UINT (g_hash_table_lookup (acfg->method_depth, method));
8734 if (!acfg->aot_opts.no_instances && depth < 32 && (mono_aot_mode_is_full (&acfg->aot_opts) || mono_aot_mode_is_hybrid (&acfg->aot_opts))) {
8735 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
8736 switch (patch_info->type) {
8737 case MONO_PATCH_INFO_RGCTX_FETCH:
8738 case MONO_PATCH_INFO_RGCTX_SLOT_INDEX:
8739 case MONO_PATCH_INFO_METHOD:
8740 case MONO_PATCH_INFO_METHOD_FTNDESC:
8741 case MONO_PATCH_INFO_METHOD_RGCTX: {
8742 MonoMethod *m = NULL;
8743
8744 if (patch_info->type == MONO_PATCH_INFO_RGCTX_FETCH || patch_info->type == MONO_PATCH_INFO_RGCTX_SLOT_INDEX) {
8745 MonoJumpInfoRgctxEntry *e = patch_info->data.rgctx_entry;
8746
8747 if (e->info_type == MONO_RGCTX_INFO_GENERIC_METHOD_CODE || e->info_type == MONO_RGCTX_INFO_METHOD_FTNDESC)
8748 m = e->data->data.method;
8749 } else {
8750 m = patch_info->data.method;
8751 }
8752
8753 if (!m)
8754 break;
8755 if (m->is_inflated && (mono_aot_mode_is_full (&acfg->aot_opts) || mono_aot_mode_is_hybrid (&acfg->aot_opts))) {
8756 if (!(mono_class_generic_sharing_enabled (m->klass) &&
8757 mono_method_is_generic_sharable_full (m, FALSE, FALSE, FALSE)) &&
8758 (!method_has_type_vars (m) || mono_method_is_generic_sharable_full (m, TRUE, TRUE, FALSE))) {
8759 if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
8760 if (mono_aot_mode_is_full (&acfg->aot_opts) && !method_has_type_vars (m))
8761 add_extra_method_with_depth (acfg, mono_marshal_get_native_wrapper (m, TRUE, TRUE), depth + 1);
8762 } else {
8763 add_extra_method_with_depth (acfg, m, depth + 1);
8764 add_types_from_method_header (acfg, m);
8765 }
8766 }
8767 add_generic_class_with_depth (acfg, m->klass, depth + 5, "method");
8768 }
8769 if (m->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
8770 WrapperInfo *info = mono_marshal_get_wrapper_info (m);
8771
8772 if (info && info->subtype == WRAPPER_SUBTYPE_ELEMENT_ADDR)
8773 add_extra_method_with_depth (acfg, m, depth + 1);
8774 }
8775 break;
8776 }
8777 case MONO_PATCH_INFO_VTABLE: {
8778 MonoClass *klass = patch_info->data.klass;
8779
8780 if (mono_class_is_ginst (klass) && !mini_class_is_generic_sharable (klass))
8781 add_generic_class_with_depth (acfg, klass, depth + 5, "vtable");
8782 break;
8783 }
8784 case MONO_PATCH_INFO_SFLDA: {
8785 MonoClass *klass = patch_info->data.field->parent;
8786
8787 /* The .cctor needs to run at runtime. */
8788 if (mono_class_is_ginst (klass) && !mono_generic_context_is_sharable_full (&mono_class_get_generic_class (klass)->context, FALSE, FALSE) && mono_class_get_cctor (klass))
8789 add_extra_method_with_depth (acfg, mono_class_get_cctor (klass), depth + 1);
8790 break;
8791 }
8792 default:
8793 break;
8794 }
8795 }
8796 }
8797
8798 /* Determine whenever the method has GOT slots */
8799 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
8800 switch (patch_info->type) {
8801 case MONO_PATCH_INFO_GOT_OFFSET:
8802 case MONO_PATCH_INFO_NONE:
8803 case MONO_PATCH_INFO_GC_CARD_TABLE_ADDR:
8804 case MONO_PATCH_INFO_GC_NURSERY_START:
8805 case MONO_PATCH_INFO_GC_NURSERY_BITS:
8806 break;
8807 case MONO_PATCH_INFO_IMAGE:
8808 /* The assembly is stored in GOT slot 0 */
8809 if (patch_info->data.image != acfg->image)
8810 cfg->has_got_slots = TRUE;
8811 break;
8812 default:
8813 if (!is_plt_patch (patch_info) || (cfg->compile_llvm && acfg->aot_opts.llvm_only))
8814 cfg->has_got_slots = TRUE;
8815 break;
8816 }
8817 }
8818
8819 if (!cfg->has_got_slots)
8820 mono_atomic_inc_i32 (&acfg->stats.methods_without_got_slots);
8821
8822 /* Add gsharedvt wrappers for signatures used by the method */
8823 if (acfg->aot_opts.llvm_only) {
8824 GSList *l;
8825
8826 if (!cfg->method->wrapper_type || cfg->method->wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE)
8827 /* These only need out wrappers */
8828 add_gsharedvt_wrappers (acfg, mono_method_signature_internal (cfg->method), FALSE, TRUE, FALSE);
8829
8830 for (l = cfg->signatures; l; l = l->next) {
8831 MonoMethodSignature *sig = mono_metadata_signature_dup ((MonoMethodSignature*)l->data);
8832
8833 /* These only need in wrappers */
8834 add_gsharedvt_wrappers (acfg, sig, TRUE, FALSE, FALSE);
8835 }
8836
8837 for (l = cfg->interp_in_signatures; l; l = l->next) {
8838 MonoMethodSignature *sig = mono_metadata_signature_dup ((MonoMethodSignature*)l->data);
8839
8840 add_gsharedvt_wrappers (acfg, sig, TRUE, FALSE, FALSE);
8841 }
8842 } else if (mono_aot_mode_is_full (&acfg->aot_opts) && mono_aot_mode_is_interp (&acfg->aot_opts)) {
8843 /* The interpreter uses these wrappers to call aot-ed code */
8844 if (!cfg->method->wrapper_type || cfg->method->wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE)
8845 add_gsharedvt_wrappers (acfg, mono_method_signature_internal (cfg->method), FALSE, TRUE, TRUE);
8846 }
8847
8848 if (cfg->llvm_only)
8849 acfg->stats.llvm_count ++;
8850
8851 /*
8852 * FIXME: Instead of this mess, allocate the patches from the aot mempool.
8853 */
8854 /* Make a copy of the patch info which is in the mempool */
8855 {
8856 MonoJumpInfo *patches = NULL, *patches_end = NULL;
8857
8858 for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
8859 MonoJumpInfo *new_patch_info = mono_patch_info_dup_mp (acfg->mempool, patch_info);
8860
8861 if (!patches)
8862 patches = new_patch_info;
8863 else
8864 patches_end->next = new_patch_info;
8865 patches_end = new_patch_info;
8866 }
8867 cfg->patch_info = patches;
8868 }
8869 /* Make a copy of the unwind info */
8870 {
8871 GSList *l, *unwind_ops;
8872 MonoUnwindOp *op;
8873
8874 unwind_ops = NULL;
8875 for (l = cfg->unwind_ops; l; l = l->next) {
8876 op = (MonoUnwindOp *)mono_mempool_alloc (acfg->mempool, sizeof (MonoUnwindOp));
8877 memcpy (op, l->data, sizeof (MonoUnwindOp));
8878 unwind_ops = g_slist_prepend_mempool (acfg->mempool, unwind_ops, op);
8879 }
8880 cfg->unwind_ops = g_slist_reverse (unwind_ops);
8881 }
8882 /* Make a copy of the argument/local info */
8883 {
8884 ERROR_DECL (error);
8885 MonoInst **args, **locals;
8886 MonoMethodSignature *sig;
8887 MonoMethodHeader *header;
8888 int i;
8889
8890 sig = mono_method_signature_internal (method);
8891 args = (MonoInst **)mono_mempool_alloc (acfg->mempool, sizeof (MonoInst*) * (sig->param_count + sig->hasthis));
8892 for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
8893 args [i] = (MonoInst *)mono_mempool_alloc (acfg->mempool, sizeof (MonoInst));
8894 memcpy (args [i], cfg->args [i], sizeof (MonoInst));
8895 }
8896 cfg->args = args;
8897
8898 header = mono_method_get_header_checked (method, error);
8899 mono_error_assert_ok (error); /* FIXME don't swallow the error */
8900 locals = (MonoInst **)mono_mempool_alloc (acfg->mempool, sizeof (MonoInst*) * header->num_locals);
8901 for (i = 0; i < header->num_locals; ++i) {
8902 locals [i] = (MonoInst *)mono_mempool_alloc (acfg->mempool, sizeof (MonoInst));
8903 memcpy (locals [i], cfg->locals [i], sizeof (MonoInst));
8904 }
8905 mono_metadata_free_mh (header);
8906 cfg->locals = locals;
8907 }
8908
8909 /* Free some fields used by cfg to conserve memory */
8910 mono_empty_compile (cfg);
8911
8912 //printf ("Compile: %s\n", mono_method_full_name (method, TRUE));
8913
8914 while (index >= acfg->cfgs_size) {
8915 MonoCompile **new_cfgs;
8916 int new_size;
8917
8918 new_size = acfg->cfgs_size * 2;
8919 new_cfgs = g_new0 (MonoCompile*, new_size);
8920 memcpy (new_cfgs, acfg->cfgs, sizeof (MonoCompile*) * acfg->cfgs_size);
8921 g_free (acfg->cfgs);
8922 acfg->cfgs = new_cfgs;
8923 acfg->cfgs_size = new_size;
8924 }
8925 acfg->cfgs [index] = cfg;
8926
8927 g_hash_table_insert (acfg->method_to_cfg, cfg->orig_method, cfg);
8928
8929 /* Update global stats while holding a lock. */
8930 mono_update_jit_stats (cfg);
8931
8932 /*
8933 if (cfg->orig_method->wrapper_type)
8934 g_ptr_array_add (acfg->extra_methods, cfg->orig_method);
8935 */
8936
8937 mono_acfg_unlock (acfg);
8938
8939 mono_atomic_inc_i32 (&acfg->stats.ccount);
8940 }
8941
8942 static mono_thread_start_return_t WINAPI
8943 compile_thread_main (gpointer user_data)
8944 {
8945 MonoAotCompile *acfg = ((MonoAotCompile **)user_data) [0];
8946 GPtrArray *methods = ((GPtrArray **)user_data) [1];
8947 int i;
8948
8949 mono_thread_set_name_constant_ignore_error (mono_thread_internal_current (), "AOT compiler", MonoSetThreadNameFlag_Permanent);
8950
8951 for (i = 0; i < methods->len; ++i)
8952 compile_method (acfg, (MonoMethod *)g_ptr_array_index (methods, i));
8953
8954 return 0;
8955 }
8956
8957 /* Used by the LLVM backend */
8958 guint32
8959 mono_aot_get_got_offset (MonoJumpInfo *ji)
8960 {
8961 return get_got_offset (llvm_acfg, TRUE, ji);
8962 }
8963
8964 /*
8965 * mono_aot_is_shared_got_offset:
8966 *
8967 * Return whenever OFFSET refers to a GOT slot which is preinitialized
8968 * when the AOT image is loaded.
8969 */
8970 gboolean
8971 mono_aot_is_shared_got_offset (int offset)
8972 {
8973 return offset < llvm_acfg->nshared_got_entries;
8974 }
8975
8976 char*
8977 mono_aot_get_method_name (MonoCompile *cfg)
8978 {
8979 MonoMethod *method = cfg->orig_method;
8980
8981 /* Use the mangled name if possible */
8982 if (method->wrapper_type == MONO_WRAPPER_OTHER) {
8983 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
8984 if (info->subtype == WRAPPER_SUBTYPE_GSHAREDVT_IN_SIG || info->subtype == WRAPPER_SUBTYPE_GSHAREDVT_OUT_SIG)
8985 return mono_aot_get_mangled_method_name (method);
8986 }
8987
8988 if (llvm_acfg->aot_opts.static_link)
8989 /* Include the assembly name too to avoid duplicate symbol errors */
8990 return g_strdup_printf ("%s_%s", llvm_acfg->assembly_name_sym, get_debug_sym (cfg->orig_method, "", llvm_acfg->method_label_hash));
8991 else
8992 return get_debug_sym (cfg->orig_method, "", llvm_acfg->method_label_hash);
8993 }
8994
8995 static gboolean
8996 append_mangled_type (GString *s, MonoType *t)
8997 {
8998 if (t->byref)
8999 g_string_append_printf (s, "b");
9000 switch (t->type) {
9001 case MONO_TYPE_VOID:
9002 g_string_append_printf (s, "void");
9003 break;
9004 case MONO_TYPE_BOOLEAN:
9005 g_string_append_printf (s, "bool");
9006 break;
9007 case MONO_TYPE_CHAR:
9008 g_string_append_printf (s, "char");
9009 break;
9010 case MONO_TYPE_I1:
9011 g_string_append_printf (s, "i1");
9012 break;
9013 case MONO_TYPE_U1:
9014 g_string_append_printf (s, "u1");
9015 break;
9016 case MONO_TYPE_I2:
9017 g_string_append_printf (s, "i2");
9018 break;
9019 case MONO_TYPE_U2:
9020 g_string_append_printf (s, "u2");
9021 break;
9022 case MONO_TYPE_I4:
9023 g_string_append_printf (s, "i4");
9024 break;
9025 case MONO_TYPE_U4:
9026 g_string_append_printf (s, "u4");
9027 break;
9028 case MONO_TYPE_I8:
9029 g_string_append_printf (s, "i8");
9030 break;
9031 case MONO_TYPE_U8:
9032 g_string_append_printf (s, "u8");
9033 break;
9034 case MONO_TYPE_I:
9035 g_string_append_printf (s, "ii");
9036 break;
9037 case MONO_TYPE_U:
9038 g_string_append_printf (s, "ui");
9039 break;
9040 case MONO_TYPE_R4:
9041 g_string_append_printf (s, "fl");
9042 break;
9043 case MONO_TYPE_R8:
9044 g_string_append_printf (s, "do");
9045 break;
9046 case MONO_TYPE_OBJECT:
9047 g_string_append_printf (s, "obj");
9048 break;
9049 default: {
9050 char *fullname = mono_type_full_name (t);
9051 char *name = fullname;
9052 GString *temp;
9053 char *temps;
9054 gboolean is_system = FALSE;
9055 int i, len;
9056
9057 len = strlen ("System.");
9058 if (strncmp (fullname, "System.", len) == 0) {
9059 name = fullname + len;
9060 is_system = TRUE;
9061 }
9062 /*
9063 * Have to create a mangled name which is:
9064 * - a valid symbol
9065 * - unique
9066 */
9067 temp = g_string_new ("");
9068 len = strlen (name);
9069 for (i = 0; i < len; ++i) {
9070 char c = name [i];
9071 if (isalnum (c)) {
9072 g_string_append_c (temp, c);
9073 } else if (c == '_') {
9074 g_string_append_c (temp, '_');
9075 g_string_append_c (temp, '_');
9076 } else {
9077 g_string_append_c (temp, '_');
9078 if (c == '.')
9079 g_string_append_c (temp, 'd');
9080 else
9081 g_string_append_printf (temp, "%x", (int)c);
9082 }
9083 }
9084 temps = g_string_free (temp, FALSE);
9085 /* Include the length to avoid different length type names aliasing each other */
9086 g_string_append_printf (s, "cl%s%x_%s_", is_system ? "s" : "", (int)strlen (temps), temps);
9087 g_free (temps);
9088 g_free (fullname);
9089 }
9090 }
9091 if (t->attrs)
9092 g_string_append_printf (s, "_attrs_%d", t->attrs);
9093 return TRUE;
9094 }
9095
9096 static gboolean
9097 append_mangled_signature (GString *s, MonoMethodSignature *sig)
9098 {
9099 int i;
9100 gboolean supported;
9101
9102 if (sig->pinvoke)
9103 g_string_append_printf (s, "pinvoke_");
9104 supported = append_mangled_type (s, sig->ret);
9105 if (!supported)
9106 return FALSE;
9107 g_string_append_printf (s, "_");
9108 if (sig->hasthis)
9109 g_string_append_printf (s, "this_");
9110 for (i = 0; i < sig->param_count; ++i) {
9111 supported = append_mangled_type (s, sig->params [i]);
9112 if (!supported)
9113 return FALSE;
9114 }
9115
9116 return TRUE;
9117 }
9118
9119 static void
9120 append_mangled_wrapper_type (GString *s, guint32 wrapper_type)
9121 {
9122 const char *label;
9123
9124 switch (wrapper_type) {
9125 case MONO_WRAPPER_REMOTING_INVOKE:
9126 label = "remoting_invoke";
9127 break;
9128 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK:
9129 label = "remoting_invoke_check";
9130 break;
9131 case MONO_WRAPPER_XDOMAIN_INVOKE:
9132 label = "remoting_invoke_xdomain";
9133 break;
9134 case MONO_WRAPPER_PROXY_ISINST:
9135 label = "proxy_isinst";
9136 break;
9137 case MONO_WRAPPER_LDFLD:
9138 label = "ldfld";
9139 break;
9140 case MONO_WRAPPER_LDFLDA:
9141 label = "ldflda";
9142 break;
9143 case MONO_WRAPPER_STFLD:
9144 label = "stfld";
9145 break;
9146 case MONO_WRAPPER_ALLOC:
9147 label = "alloc";
9148 break;
9149 case MONO_WRAPPER_WRITE_BARRIER:
9150 label = "write_barrier";
9151 break;
9152 case MONO_WRAPPER_STELEMREF:
9153 label = "stelemref";
9154 break;
9155 case MONO_WRAPPER_OTHER:
9156 label = "unknown";
9157 break;
9158 case MONO_WRAPPER_MANAGED_TO_NATIVE:
9159 label = "man2native";
9160 break;
9161 case MONO_WRAPPER_SYNCHRONIZED:
9162 label = "synch";
9163 break;
9164 case MONO_WRAPPER_MANAGED_TO_MANAGED:
9165 label = "man2man";
9166 break;
9167 case MONO_WRAPPER_CASTCLASS:
9168 label = "castclass";
9169 break;
9170 case MONO_WRAPPER_RUNTIME_INVOKE:
9171 label = "run_invoke";
9172 break;
9173 case MONO_WRAPPER_DELEGATE_INVOKE:
9174 label = "del_inv";
9175 break;
9176 case MONO_WRAPPER_DELEGATE_BEGIN_INVOKE:
9177 label = "del_beg_inv";
9178 break;
9179 case MONO_WRAPPER_DELEGATE_END_INVOKE:
9180 label = "del_end_inv";
9181 break;
9182 case MONO_WRAPPER_NATIVE_TO_MANAGED:
9183 label = "native2man";
9184 break;
9185 default:
9186 g_assert_not_reached ();
9187 }
9188
9189 g_string_append_printf (s, "%s_", label);
9190 }
9191
9192 static void
9193 append_mangled_wrapper_subtype (GString *s, WrapperSubtype subtype)
9194 {
9195 const char *label;
9196
9197 switch (subtype)
9198 {
9199 case WRAPPER_SUBTYPE_NONE:
9200 return;
9201 case WRAPPER_SUBTYPE_ELEMENT_ADDR:
9202 label = "elem_addr";
9203 break;
9204 case WRAPPER_SUBTYPE_STRING_CTOR:
9205 label = "str_ctor";
9206 break;
9207 case WRAPPER_SUBTYPE_VIRTUAL_STELEMREF:
9208 label = "virt_stelem";
9209 break;
9210 case WRAPPER_SUBTYPE_FAST_MONITOR_ENTER:
9211 label = "fast_mon_enter";
9212 break;
9213 case WRAPPER_SUBTYPE_FAST_MONITOR_ENTER_V4:
9214 label = "fast_mon_enter_4";
9215 break;
9216 case WRAPPER_SUBTYPE_FAST_MONITOR_EXIT:
9217 label = "fast_monitor_exit";
9218 break;
9219 case WRAPPER_SUBTYPE_PTR_TO_STRUCTURE:
9220 label = "ptr2struct";
9221 break;
9222 case WRAPPER_SUBTYPE_STRUCTURE_TO_PTR:
9223 label = "struct2ptr";
9224 break;
9225 case WRAPPER_SUBTYPE_CASTCLASS_WITH_CACHE:
9226 label = "castclass_w_cache";
9227 break;
9228 case WRAPPER_SUBTYPE_ISINST_WITH_CACHE:
9229 label = "isinst_w_cache";
9230 break;
9231 case WRAPPER_SUBTYPE_RUNTIME_INVOKE_NORMAL:
9232 label = "run_inv_norm";
9233 break;
9234 case WRAPPER_SUBTYPE_RUNTIME_INVOKE_DYNAMIC:
9235 label = "run_inv_dyn";
9236 break;
9237 case WRAPPER_SUBTYPE_RUNTIME_INVOKE_DIRECT:
9238 label = "run_inv_dir";
9239 break;
9240 case WRAPPER_SUBTYPE_RUNTIME_INVOKE_VIRTUAL:
9241 label = "run_inv_vir";
9242 break;
9243 case WRAPPER_SUBTYPE_ICALL_WRAPPER:
9244 label = "icall";
9245 break;
9246 case WRAPPER_SUBTYPE_NATIVE_FUNC_AOT:
9247 label = "native_func_aot";
9248 break;
9249 case WRAPPER_SUBTYPE_PINVOKE:
9250 label = "pinvoke";
9251 break;
9252 case WRAPPER_SUBTYPE_SYNCHRONIZED_INNER:
9253 label = "synch_inner";
9254 break;
9255 case WRAPPER_SUBTYPE_GSHAREDVT_IN:
9256 label = "gshared_in";
9257 break;
9258 case WRAPPER_SUBTYPE_GSHAREDVT_OUT:
9259 label = "gshared_out";
9260 break;
9261 case WRAPPER_SUBTYPE_ARRAY_ACCESSOR:
9262 label = "array_acc";
9263 break;
9264 case WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER:
9265 label = "generic_arry_help";
9266 break;
9267 case WRAPPER_SUBTYPE_DELEGATE_INVOKE_VIRTUAL:
9268 label = "del_inv_virt";
9269 break;
9270 case WRAPPER_SUBTYPE_DELEGATE_INVOKE_BOUND:
9271 label = "del_inv_bound";
9272 break;
9273 case WRAPPER_SUBTYPE_INTERP_IN:
9274 label = "interp_in";
9275 break;
9276 case WRAPPER_SUBTYPE_INTERP_LMF:
9277 label = "interp_lmf";
9278 break;
9279 case WRAPPER_SUBTYPE_GSHAREDVT_IN_SIG:
9280 label = "gsharedvt_in_sig";
9281 break;
9282 case WRAPPER_SUBTYPE_GSHAREDVT_OUT_SIG:
9283 label = "gsharedvt_out_sig";
9284 break;
9285 case WRAPPER_SUBTYPE_AOT_INIT:
9286 label = "aot_init";
9287 break;
9288 default:
9289 g_assert_not_reached ();
9290 }
9291
9292 g_string_append_printf (s, "%s_", label);
9293 }
9294
9295 static char *
9296 sanitize_mangled_string (const char *input)
9297 {
9298 GString *s = g_string_new ("");
9299
9300 for (int i=0; input [i] != '\0'; i++) {
9301 char c = input [i];
9302 switch (c) {
9303 case '.':
9304 g_string_append (s, "_dot_");
9305 break;
9306 case ' ':
9307 g_string_append (s, "_");
9308 break;
9309 case '`':
9310 g_string_append (s, "_bt_");
9311 break;
9312 case '<':
9313 g_string_append (s, "_le_");
9314 break;
9315 case '>':
9316 g_string_append (s, "_gt_");
9317 break;
9318 case '/':
9319 g_string_append (s, "_sl_");
9320 break;
9321 case '[':
9322 g_string_append (s, "_lbrack_");
9323 break;
9324 case ']':
9325 g_string_append (s, "_rbrack_");
9326 break;
9327 case '(':
9328 g_string_append (s, "_lparen_");
9329 break;
9330 case '-':
9331 g_string_append (s, "_dash_");
9332 break;
9333 case ')':
9334 g_string_append (s, "_rparen_");
9335 break;
9336 case ',':
9337 g_string_append (s, "_comma_");
9338 break;
9339 case ':':
9340 g_string_append (s, "_colon_");
9341 break;
9342 default:
9343 g_string_append_c (s, c);
9344 }
9345 }
9346
9347 return g_string_free (s, FALSE);
9348 }
9349
9350 static gboolean
9351 append_mangled_klass (GString *s, MonoClass *klass)
9352 {
9353 char *klass_desc = mono_class_full_name (klass);
9354 g_string_append_printf (s, "_%s_%s_", m_class_get_name_space (klass), klass_desc);
9355 g_free (klass_desc);
9356
9357 // Success
9358 return TRUE;
9359 }
9360
9361 static gboolean
9362 append_mangled_method (GString *s, MonoMethod *method);
9363
9364 static gboolean
9365 append_mangled_wrapper (GString *s, MonoMethod *method)
9366 {
9367 gboolean success = TRUE;
9368 gboolean append_sig = TRUE;
9369 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
9370 g_string_append_printf (s, "wrapper_");
9371 /* Most wrappers are in mscorlib */
9372 if (m_class_get_image (method->klass) != mono_get_corlib ())
9373 g_string_append_printf (s, "%s_", m_class_get_image (method->klass)->assembly->aname.name);
9374
9375 if (method->wrapper_type != MONO_WRAPPER_OTHER && method->wrapper_type != MONO_WRAPPER_MANAGED_TO_NATIVE)
9376 append_mangled_wrapper_type (s, method->wrapper_type);
9377
9378 switch (method->wrapper_type) {
9379 case MONO_WRAPPER_REMOTING_INVOKE:
9380 case MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK:
9381 case MONO_WRAPPER_XDOMAIN_INVOKE: {
9382 MonoMethod *m = mono_marshal_method_from_wrapper (method);
9383 g_assert (m);
9384 success = success && append_mangled_method (s, m);
9385 break;
9386 }
9387 case MONO_WRAPPER_PROXY_ISINST:
9388 case MONO_WRAPPER_LDFLD:
9389 case MONO_WRAPPER_LDFLDA:
9390 case MONO_WRAPPER_STFLD: {
9391 g_assert (info);
9392 success = success && append_mangled_klass (s, info->d.proxy.klass);
9393 break;
9394 }
9395 case MONO_WRAPPER_ALLOC: {
9396 /* The GC name is saved once in MonoAotFileInfo */
9397 g_assert (info->d.alloc.alloc_type != -1);
9398 g_string_append_printf (s, "%d_", info->d.alloc.alloc_type);
9399 // SlowAlloc, etc
9400 g_string_append_printf (s, "%s_", method->name);
9401 break;
9402 }
9403 case MONO_WRAPPER_WRITE_BARRIER: {
9404 g_string_append_printf (s, "%s_", method->name);
9405 break;
9406 }
9407 case MONO_WRAPPER_STELEMREF: {
9408 append_mangled_wrapper_subtype (s, info->subtype);
9409 if (info->subtype == WRAPPER_SUBTYPE_VIRTUAL_STELEMREF)
9410 g_string_append_printf (s, "%d", info->d.virtual_stelemref.kind);
9411 break;
9412 }
9413 case MONO_WRAPPER_OTHER: {
9414 append_mangled_wrapper_subtype (s, info->subtype);
9415 if (info->subtype == WRAPPER_SUBTYPE_PTR_TO_STRUCTURE ||
9416 info->subtype == WRAPPER_SUBTYPE_STRUCTURE_TO_PTR)
9417 success = success && append_mangled_klass (s, method->klass);
9418 else if (info->subtype == WRAPPER_SUBTYPE_SYNCHRONIZED_INNER)
9419 success = success && append_mangled_method (s, info->d.synchronized_inner.method);
9420 else if (info->subtype == WRAPPER_SUBTYPE_ARRAY_ACCESSOR)
9421 success = success && append_mangled_method (s, info->d.array_accessor.method);
9422 else if (info->subtype == WRAPPER_SUBTYPE_INTERP_IN)
9423 append_mangled_signature (s, info->d.interp_in.sig);
9424 else if (info->subtype == WRAPPER_SUBTYPE_GSHAREDVT_IN_SIG) {
9425 append_mangled_signature (s, info->d.gsharedvt.sig);
9426 append_sig = FALSE;
9427 } else if (info->subtype == WRAPPER_SUBTYPE_GSHAREDVT_OUT_SIG) {
9428 append_mangled_signature (s, info->d.gsharedvt.sig);
9429 append_sig = FALSE;
9430 } else if (info->subtype == WRAPPER_SUBTYPE_INTERP_LMF)
9431 g_string_append_printf (s, "%s", method->name);
9432 else if (info->subtype == WRAPPER_SUBTYPE_AOT_INIT) {
9433 g_string_append_printf (s, "%s_%d_", m_class_get_image (method->klass)->assembly->aname.name, info->d.aot_init.subtype);
9434 append_sig = FALSE;
9435 }
9436 break;
9437 }
9438 case MONO_WRAPPER_MANAGED_TO_NATIVE: {
9439 append_mangled_wrapper_subtype (s, info->subtype);
9440 if (info->subtype == WRAPPER_SUBTYPE_ICALL_WRAPPER) {
9441 const char *name = method->name;
9442 const char *prefix = "__icall_wrapper_";
9443 if (strstr (name, prefix) == name)
9444 name += strlen (prefix);
9445 g_string_append_printf (s, "%s", name);
9446 append_sig = FALSE;
9447 } else if (info->subtype == WRAPPER_SUBTYPE_NATIVE_FUNC_AOT) {
9448 success = success && append_mangled_method (s, info->d.managed_to_native.method);
9449 } else {
9450 g_assert (info->subtype == WRAPPER_SUBTYPE_NONE || info->subtype == WRAPPER_SUBTYPE_PINVOKE);
9451 success = success && append_mangled_method (s, info->d.managed_to_native.method);
9452 }
9453 break;
9454 }
9455 case MONO_WRAPPER_SYNCHRONIZED: {
9456 MonoMethod *m;
9457
9458 m = mono_marshal_method_from_wrapper (method);
9459 g_assert (m);
9460 g_assert (m != method);
9461 success = success && append_mangled_method (s, m);
9462 break;
9463 }
9464 case MONO_WRAPPER_MANAGED_TO_MANAGED: {
9465 append_mangled_wrapper_subtype (s, info->subtype);
9466
9467 if (info->subtype == WRAPPER_SUBTYPE_ELEMENT_ADDR) {
9468 g_string_append_printf (s, "%d_", info->d.element_addr.rank);
9469 g_string_append_printf (s, "%d_", info->d.element_addr.elem_size);
9470 } else if (info->subtype == WRAPPER_SUBTYPE_STRING_CTOR) {
9471 success = success && append_mangled_method (s, info->d.string_ctor.method);
9472 } else if (info->subtype == WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER) {
9473 success = success && append_mangled_method (s, info->d.generic_array_helper.method);
9474 } else {
9475 success = FALSE;
9476 }
9477 break;
9478 }
9479 case MONO_WRAPPER_CASTCLASS: {
9480 append_mangled_wrapper_subtype (s, info->subtype);
9481 break;
9482 }
9483 case MONO_WRAPPER_RUNTIME_INVOKE: {
9484 append_mangled_wrapper_subtype (s, info->subtype);
9485 if (info->subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_DIRECT || info->subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_VIRTUAL)
9486 success = success && append_mangled_method (s, info->d.runtime_invoke.method);
9487 else if (info->subtype == WRAPPER_SUBTYPE_RUNTIME_INVOKE_NORMAL)
9488 success = success && append_mangled_signature (s, info->d.runtime_invoke.sig);
9489 break;
9490 }
9491 case MONO_WRAPPER_DELEGATE_INVOKE:
9492 case MONO_WRAPPER_DELEGATE_BEGIN_INVOKE:
9493 case MONO_WRAPPER_DELEGATE_END_INVOKE: {
9494 if (method->is_inflated) {
9495 /* These wrappers are identified by their class */
9496 g_string_append_printf (s, "i_");
9497 success = success && append_mangled_klass (s, method->klass);
9498 } else {
9499 WrapperInfo *info = mono_marshal_get_wrapper_info (method);
9500
9501 g_string_append_printf (s, "u_");
9502 if (method->wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE)
9503 append_mangled_wrapper_subtype (s, info->subtype);
9504 g_string_append_printf (s, "u_sigstart");
9505 }
9506 break;
9507 }
9508 case MONO_WRAPPER_NATIVE_TO_MANAGED: {
9509 g_assert (info);
9510 success = success && append_mangled_method (s, info->d.native_to_managed.method);
9511 success = success && append_mangled_klass (s, method->klass);
9512 break;
9513 }
9514 default:
9515 g_assert_not_reached ();
9516 }
9517 if (success && append_sig)
9518 success = append_mangled_signature (s, mono_method_signature_internal (method));
9519 return success;
9520 }
9521
9522 static void
9523 append_mangled_ginst (GString *str, MonoGenericInst *ginst)
9524 {
9525 int i;
9526
9527 for (i = 0; i < ginst->type_argc; ++i) {
9528 if (i > 0)
9529 g_string_append (str, ", ");
9530 MonoType *type = ginst->type_argv [i];
9531 switch (type->type) {
9532 case MONO_TYPE_VAR:
9533 case MONO_TYPE_MVAR: {
9534 MonoType *constraint = NULL;
9535 if (type->data.generic_param)
9536 constraint = type->data.generic_param->gshared_constraint;
9537 if (constraint) {
9538 g_assert (constraint->type != MONO_TYPE_VAR && constraint->type != MONO_TYPE_MVAR);
9539 g_string_append (str, "gshared:");
9540 mono_type_get_desc (str, constraint, TRUE);
9541 break;
9542 }
9543 // Else falls through to common case
9544 }
9545 default:
9546 mono_type_get_desc (str, type, TRUE);
9547 }
9548 }
9549 }
9550
9551 static void
9552 append_mangled_context (GString *str, MonoGenericContext *context)
9553 {
9554 GString *res = g_string_new ("");
9555
9556 g_string_append_printf (res, "gens_");
9557 g_string_append (res, "00");
9558
9559 gboolean good = context->class_inst && context->class_inst->type_argc > 0;
9560 good = good || (context->method_inst && context->method_inst->type_argc > 0);
9561 g_assert (good);
9562
9563 if (context->class_inst)
9564 append_mangled_ginst (res, context->class_inst);
9565 if (context->method_inst) {
9566 if (context->class_inst)
9567 g_string_append (res, "11");
9568 append_mangled_ginst (res, context->method_inst);
9569 }
9570 g_string_append_printf (str, "gens_%s", res->str);
9571 g_free (res);
9572 }
9573
9574 static gboolean
9575 append_mangled_method (GString *s, MonoMethod *method)
9576 {
9577 if (method->wrapper_type)
9578 return append_mangled_wrapper (s, method);
9579
9580 if (method->is_inflated) {
9581 g_string_append_printf (s, "inflated_");
9582 MonoMethodInflated *imethod = (MonoMethodInflated*) method;
9583 g_assert (imethod->context.class_inst != NULL || imethod->context.method_inst != NULL);
9584
9585 append_mangled_context (s, &imethod->context);
9586 g_string_append_printf (s, "_declared_by_%s_", m_class_get_image (imethod->declaring->klass)->assembly->aname.name);
9587 append_mangled_method (s, imethod->declaring);
9588 } else if (method->is_generic) {
9589 g_string_append_printf (s, "%s_", m_class_get_image (method->klass)->assembly->aname.name);
9590
9591 g_string_append_printf (s, "generic_");
9592 append_mangled_klass (s, method->klass);
9593 g_string_append_printf (s, "_%s_", method->name);
9594
9595 MonoGenericContainer *container = mono_method_get_generic_container (method);
9596 g_string_append_printf (s, "_");
9597 append_mangled_context (s, &container->context);
9598
9599 return append_mangled_signature (s, mono_method_signature_internal (method));
9600 } else {
9601 g_string_append_printf (s, "%s", m_class_get_image (method->klass)->assembly->aname.name);
9602 append_mangled_klass (s, method->klass);
9603 g_string_append_printf (s, "_%s_", method->name);
9604 if (!append_mangled_signature (s, mono_method_signature_internal (method))) {
9605 g_string_free (s, TRUE);
9606 return FALSE;
9607 }
9608 }
9609
9610 return TRUE;
9611 }
9612
9613 /*
9614 * mono_aot_get_mangled_method_name:
9615 *
9616 * Return a unique mangled name for METHOD, or NULL.
9617 */
9618 char*
9619 mono_aot_get_mangled_method_name (MonoMethod *method)
9620 {
9621 // FIXME: use static cache (mempool?)
9622 // We call this a *lot*
9623
9624 GString *s = g_string_new ("aot_");
9625 if (!append_mangled_method (s, method)) {
9626 g_string_free (s, TRUE);
9627 return NULL;
9628 } else {
9629 char *out = g_string_free (s, FALSE);
9630 // Scrub method and class names
9631 char *cleaned = sanitize_mangled_string (out);
9632 g_free (out);
9633 return cleaned;
9634 }
9635 }
9636
9637 gboolean
9638 mono_aot_is_direct_callable (MonoJumpInfo *patch_info)
9639 {
9640 return is_direct_callable (llvm_acfg, NULL, patch_info);
9641 }
9642
9643 void
9644 mono_aot_mark_unused_llvm_plt_entry (MonoJumpInfo *patch_info)
9645 {
9646 MonoPltEntry *plt_entry;
9647
9648 plt_entry = get_plt_entry (llvm_acfg, patch_info);
9649 plt_entry->llvm_used = FALSE;
9650 }
9651
9652 char*
9653 mono_aot_get_direct_call_symbol (MonoJumpInfoType type, gconstpointer data)
9654 {
9655 const char *sym = NULL;
9656
9657 if (llvm_acfg->aot_opts.direct_icalls) {
9658 if (type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
9659 /* Call to a C function implementing a jit icall */
9660 sym = mono_find_jit_icall_info ((MonoJitICallId)(gsize)data)->c_symbol;
9661 } else if (type == MONO_PATCH_INFO_ICALL_ADDR_CALL) {
9662 MonoMethod *method = (MonoMethod *)data;
9663 if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
9664 sym = lookup_icall_symbol_name_aot (method);
9665 else if (llvm_acfg->aot_opts.direct_pinvoke)
9666 sym = get_pinvoke_import (llvm_acfg, method);
9667 } else if (type == MONO_PATCH_INFO_JIT_ICALL_ID) {
9668 MonoJitICallInfo const * const info = mono_find_jit_icall_info ((MonoJitICallId)(gsize)data);
9669 char const * const name = info->c_symbol;
9670 if (name && info->func == info->wrapper)
9671 sym = name;
9672 }
9673 if (sym)
9674 return g_strdup (sym);
9675 }
9676 return NULL;
9677 }
9678
9679 char*
9680 mono_aot_get_plt_symbol (MonoJumpInfoType type, gconstpointer data)
9681 {
9682 MonoJumpInfo *ji = (MonoJumpInfo *)mono_mempool_alloc (llvm_acfg->mempool, sizeof (MonoJumpInfo));
9683 MonoPltEntry *plt_entry;
9684 const char *sym = NULL;
9685
9686 ji->type = type;
9687 ji->data.target = data;
9688
9689 if (!can_encode_patch (llvm_acfg, ji))
9690 return NULL;
9691
9692 if (llvm_acfg->aot_opts.direct_icalls) {
9693 if (type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
9694 /* Call to a C function implementing a jit icall */
9695 sym = mono_find_jit_icall_info ((MonoJitICallId)(gsize)data)->c_symbol;
9696 } else if (type == MONO_PATCH_INFO_ICALL_ADDR_CALL) {
9697 MonoMethod *method = (MonoMethod *)data;
9698 if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
9699 sym = lookup_icall_symbol_name_aot (method);
9700 }
9701 if (sym)
9702 return g_strdup (sym);
9703 }
9704
9705 plt_entry = get_plt_entry (llvm_acfg, ji);
9706 plt_entry->llvm_used = TRUE;
9707
9708 #if defined(TARGET_MACH)
9709 return g_strdup (plt_entry->llvm_symbol + strlen (llvm_acfg->llvm_label_prefix));
9710 #else
9711 return g_strdup (plt_entry->llvm_symbol);
9712 #endif
9713 }
9714
9715 int
9716 mono_aot_get_method_index (MonoMethod *method)
9717 {
9718 g_assert (llvm_acfg);
9719 return get_method_index (llvm_acfg, method);
9720 }
9721
9722 MonoJumpInfo*
9723 mono_aot_patch_info_dup (MonoJumpInfo* ji)
9724 {
9725 MonoJumpInfo *res;
9726
9727 mono_acfg_lock (llvm_acfg);
9728 res = mono_patch_info_dup_mp (llvm_acfg->mempool, ji);
9729 mono_acfg_unlock (llvm_acfg);
9730
9731 return res;
9732 }
9733
9734 static int
9735 execute_system (const char * command)
9736 {
9737 int status = 0;
9738
9739 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) && defined(HOST_WIN32)
9740 // We need an extra set of quotes around the whole command to properly handle commands
9741 // with spaces since internally the command is called through "cmd /c.
9742 char * quoted_command = g_strdup_printf ("\"%s\"", command);
9743
9744 int size = MultiByteToWideChar (CP_UTF8, 0 , quoted_command , -1, NULL , 0);
9745 wchar_t* wstr = g_malloc (sizeof (wchar_t) * size);
9746 MultiByteToWideChar (CP_UTF8, 0, quoted_command, -1, wstr , size);
9747 status = _wsystem (wstr);
9748 g_free (wstr);
9749
9750 g_free (quoted_command);
9751 #elif defined (HAVE_SYSTEM)
9752 status = system (command);
9753 #else
9754 g_assert_not_reached ();
9755 #endif
9756
9757 return status;
9758 }
9759
9760 #ifdef ENABLE_LLVM
9761
9762 /*
9763 * emit_llvm_file:
9764 *
9765 * Emit the LLVM code into an LLVM bytecode file, and compile it using the LLVM
9766 * tools.
9767 */
9768 static gboolean
9769 emit_llvm_file (MonoAotCompile *acfg)
9770 {
9771 char *command, *opts, *tempbc, *optbc, *output_fname;
9772
9773 if (acfg->aot_opts.llvm_only && acfg->aot_opts.asm_only) {
9774 if (acfg->aot_opts.no_opt)
9775 tempbc = g_strdup (acfg->aot_opts.llvm_outfile);
9776 else
9777 tempbc = g_strdup_printf ("%s.bc", acfg->tmpbasename);
9778 optbc = g_strdup (acfg->aot_opts.llvm_outfile);
9779 } else {
9780 tempbc = g_strdup_printf ("%s.bc", acfg->tmpbasename);
9781 optbc = g_strdup_printf ("%s.opt.bc", acfg->tmpbasename);
9782 }
9783
9784 mono_llvm_emit_aot_module (tempbc, g_path_get_basename (acfg->image->name));
9785
9786 if (acfg->aot_opts.no_opt)
9787 return TRUE;
9788 /*
9789 * FIXME: Experiment with adding optimizations, the -std-compile-opts set takes
9790 * a lot of time, and doesn't seem to save much space.
9791 * The following optimizations cannot be enabled:
9792 * - 'tailcallelim'
9793 * - 'jump-threading' changes our blockaddress references to int constants.
9794 * - 'basiccg' fails because it contains:
9795 * if (CS && !isa<IntrinsicInst>(II)) {
9796 * and isa<IntrinsicInst> is false for invokes to intrinsics (iltests.exe).
9797 * - 'prune-eh' and 'functionattrs' depend on 'basiccg'.
9798 * The opt list below was produced by taking the output of:
9799 * llvm-as < /dev/null | opt -O2 -disable-output -debug-pass=Arguments
9800 * then removing tailcallelim + the global opts.
9801 * strip-dead-prototypes deletes unused intrinsics definitions.
9802 */
9803 /* The dse pass is disabled because of #13734 and #17616 */
9804 /*
9805 * The dse bug is in DeadStoreElimination.cpp:isOverwrite ():
9806 * // If we have no DataLayout information around, then the size of the store
9807 * // is inferrable from the pointee type. If they are the same type, then
9808 * // we know that the store is safe.
9809 * if (AA.getDataLayout() == 0 &&
9810 * Later.Ptr->getType() == Earlier.Ptr->getType()) {
9811 * return OverwriteComplete;
9812 * Here, if 'Earlier' refers to a memset, and Later has no size info, it mistakenly thinks the memset is redundant.
9813 */
9814 if (acfg->aot_opts.llvm_only) {
9815 // FIXME: This doesn't work yet
9816 opts = g_strdup ("");
9817 } else {
9818 opts = g_strdup ("-disable-tail-calls -place-safepoints -spp-all-backedges");
9819 }
9820
9821 if (acfg->aot_opts.llvm_opts) {
9822 opts = g_strdup_printf ("%s %s", acfg->aot_opts.llvm_opts, opts);
9823 } else if (!acfg->aot_opts.llvm_only) {
9824 opts = g_strdup_printf ("-O2 %s", opts);
9825 }
9826
9827 if (acfg->aot_opts.use_current_cpu) {
9828 opts = g_strdup_printf ("%s -mcpu=native", opts);
9829 }
9830
9831 if (acfg->aot_opts.llvm_cpu_attr) {
9832 opts = g_strdup_printf ("%s -mattr=%s", opts, acfg->aot_opts.llvm_cpu_attr);
9833 }
9834
9835 if (mono_use_fast_math) {
9836 // same parameters are passed to llc and LLVM JIT
9837 opts = g_strdup_printf ("%s -fp-contract=fast -enable-no-infs-fp-math -enable-no-nans-fp-math -enable-no-signed-zeros-fp-math -enable-no-trapping-fp-math -enable-unsafe-fp-math", opts);
9838 }
9839
9840 command = g_strdup_printf ("\"%sopt\" -f %s -o \"%s\" \"%s\"", acfg->aot_opts.llvm_path, opts, optbc, tempbc);
9841 aot_printf (acfg, "Executing opt: %s\n", command);
9842 if (execute_system (command) != 0)
9843 return FALSE;
9844 g_free (opts);
9845
9846 if (acfg->aot_opts.llvm_only && acfg->aot_opts.asm_only)
9847 /* Nothing else to do */
9848 return TRUE;
9849
9850 if (acfg->aot_opts.llvm_only) {
9851 /* Use the stock clang from xcode */
9852 // FIXME: arch
9853 command = g_strdup_printf ("%s -fexceptions -fpic -O2 -fno-optimize-sibling-calls -Wno-override-module -c -o \"%s\" \"%s.opt.bc\"", acfg->aot_opts.clangxx, acfg->llvm_ofile, acfg->tmpbasename);
9854
9855 aot_printf (acfg, "Executing clang: %s\n", command);
9856 if (execute_system (command) != 0)
9857 return FALSE;
9858 return TRUE;
9859 }
9860
9861 if (!acfg->llc_args)
9862 acfg->llc_args = g_string_new ("");
9863
9864 /* Verbose asm slows down llc greatly */
9865 g_string_append (acfg->llc_args, " -asm-verbose=false");
9866
9867 if (acfg->aot_opts.mtriple)
9868 g_string_append_printf (acfg->llc_args, " -mtriple=%s", acfg->aot_opts.mtriple);
9869
9870 #if defined(TARGET_X86_64_WIN32_MSVC)
9871 if (!acfg->aot_opts.mtriple)
9872 g_string_append_printf (acfg->llc_args, " -mtriple=%s", "x86_64-pc-windows-msvc");
9873 #endif
9874
9875 g_string_append (acfg->llc_args, " -disable-gnu-eh-frame -enable-mono-eh-frame");
9876
9877 g_string_append_printf (acfg->llc_args, " -mono-eh-frame-symbol=%s%s", acfg->user_symbol_prefix, acfg->llvm_eh_frame_symbol);
9878
9879 g_string_append_printf (acfg->llc_args, " -disable-tail-calls");
9880
9881 #if defined(TARGET_AMD64) || defined(TARGET_X86)
9882 /* This generates stack adjustments in the middle of functions breaking unwind info */
9883 g_string_append_printf (acfg->llc_args, " -no-x86-call-frame-opt");
9884 #endif
9885
9886 #if ( defined(TARGET_MACH) && defined(TARGET_ARM) ) || defined(TARGET_ORBIS) || defined(TARGET_X86_64_WIN32_MSVC)
9887 g_string_append_printf (acfg->llc_args, " -relocation-model=pic");
9888 #else
9889 if (llvm_acfg->aot_opts.static_link)
9890 g_string_append_printf (acfg->llc_args, " -relocation-model=static");
9891 else
9892 g_string_append_printf (acfg->llc_args, " -relocation-model=pic");
9893 #endif
9894
9895 if (acfg->llvm_owriter) {
9896 /* Emit an object file directly */
9897 output_fname = g_strdup_printf ("%s", acfg->llvm_ofile);
9898 g_string_append_printf (acfg->llc_args, " -filetype=obj");
9899 } else {
9900 output_fname = g_strdup_printf ("%s", acfg->llvm_sfile);
9901 }
9902
9903 if (acfg->aot_opts.llvm_llc) {
9904 g_string_append_printf (acfg->llc_args, " %s", acfg->aot_opts.llvm_llc);
9905 }
9906
9907 if (acfg->aot_opts.use_current_cpu) {
9908 g_string_append (acfg->llc_args, " -mcpu=native");
9909 }
9910
9911 if (acfg->aot_opts.llvm_cpu_attr) {
9912 g_string_append_printf (acfg->llc_args, " -mattr=%s", acfg->aot_opts.llvm_cpu_attr);
9913 }
9914
9915 command = g_strdup_printf ("\"%sllc\" %s -o \"%s\" \"%s.opt.bc\"", acfg->aot_opts.llvm_path, acfg->llc_args->str, output_fname, acfg->tmpbasename);
9916 g_free (output_fname);
9917
9918 aot_printf (acfg, "Executing llc: %s\n", command);
9919
9920 if (execute_system (command) != 0)
9921 return FALSE;
9922 return TRUE;
9923 }
9924 #endif
9925
9926 /* Set the skip flag for methods which do not need to be emitted because of dedup */
9927 static void
9928 dedup_skip_methods (MonoAotCompile *acfg)
9929 {
9930 int oindex, i;
9931
9932 if (acfg->aot_opts.llvm_only)
9933 return;
9934
9935 for (oindex = 0; oindex < acfg->method_order->len; ++oindex) {
9936 MonoCompile *cfg;
9937 MonoMethod *method;
9938
9939 i = GPOINTER_TO_UINT (g_ptr_array_index (acfg->method_order, oindex));
9940
9941 cfg = acfg->cfgs [i];
9942
9943 if (!cfg)
9944 continue;
9945
9946 method = cfg->orig_method;
9947
9948 gboolean dedup_collect = acfg->aot_opts.dedup || (acfg->aot_opts.dedup_include && !acfg->dedup_emit_mode);
9949 gboolean dedupable = mono_aot_can_dedup (method);
9950
9951 // cfg->skip is vital for LLVM to work, can't just continue in this loop
9952 if (dedupable && strcmp (method->name, "wbarrier_conc") && dedup_collect) {
9953 mono_dedup_cache_method (acfg, method);
9954
9955 // Don't compile inflated methods if we're in first phase of
9956 // dedup
9957 //
9958 // In second phase, we emit methods that
9959 // are dedupable. We also emit later methods
9960 // which are referenced by them and added later.
9961 // For this reason, when in the dedup_include mode,
9962 // we never set skip.
9963 if (acfg->aot_opts.dedup)
9964 cfg->skip = TRUE;
9965 }
9966
9967 // Don't compile anything in this mode
9968 if (acfg->aot_opts.dedup_include && !acfg->dedup_emit_mode)
9969 cfg->skip = TRUE;
9970
9971 // Compile everything in this mode
9972 if (acfg->aot_opts.dedup_include && acfg->dedup_emit_mode)
9973 cfg->skip = FALSE;
9974
9975 /*if (dedup_collect) {*/
9976 /*char *name = mono_aot_get_mangled_method_name (method);*/
9977
9978 /*if (ignore_cfg (cfg))*/
9979 /*aot_printf (acfg, "Dedup Skipping %s\n", acfg->image->name, name);*/
9980 /*else*/
9981 /*aot_printf (acfg, "Dedup Keeping %s\n", acfg->image->name, name);*/
9982
9983 /*g_free (name);*/
9984 /*}*/
9985 }
9986 }
9987
9988 static void
9989 emit_code (MonoAotCompile *acfg)
9990 {
9991 int oindex, i, prev_index;
9992 gboolean saved_unbox_info = FALSE; // See mono_aot_get_unbox_trampoline.
9993 char symbol [MAX_SYMBOL_SIZE];
9994
9995 if (acfg->aot_opts.llvm_only)
9996 return;
9997
9998 #if defined(TARGET_POWERPC64)
9999 sprintf (symbol, ".Lgot_addr");
10000 emit_section_change (acfg, ".text", 0);
10001 emit_alignment (acfg, 8);
10002 emit_label (acfg, symbol);
10003 emit_pointer (acfg, acfg->got_symbol);
10004 #endif
10005
10006 /*
10007 * This global symbol is used to compute the address of each method using the
10008 * code_offsets array. It is also used to compute the memory ranges occupied by
10009 * AOT code, so it must be equal to the address of the first emitted method.
10010 */
10011 emit_section_change (acfg, ".text", 0);
10012 emit_alignment_code (acfg, 8);
10013 emit_info_symbol (acfg, "jit_code_start", TRUE);
10014
10015 /*
10016 * Emit some padding so the local symbol for the first method doesn't have the
10017 * same address as 'methods'.
10018 */
10019 emit_padding (acfg, 16);
10020
10021 for (oindex = 0; oindex < acfg->method_order->len; ++oindex) {
10022 MonoCompile *cfg;
10023 MonoMethod *method;
10024
10025 i = GPOINTER_TO_UINT (g_ptr_array_index (acfg->method_order, oindex));
10026
10027 cfg = acfg->cfgs [i];
10028
10029 if (!cfg)
10030 continue;
10031
10032 method = cfg->orig_method;
10033
10034 if (ignore_cfg (cfg))
10035 continue;
10036
10037 /* Emit unbox trampoline */
10038 if (mono_aot_mode_is_full (&acfg->aot_opts) && m_class_is_valuetype (cfg->orig_method->klass)) {
10039 sprintf (symbol, "ut_%d", get_method_index (acfg, method));
10040
10041 emit_section_change (acfg, ".text", 0);
10042
10043 if (acfg->thumb_mixed && cfg->compile_llvm) {
10044 emit_set_thumb_mode (acfg);
10045 fprintf (acfg->fp, "\n.thumb_func\n");
10046 }
10047
10048 emit_label (acfg, symbol);
10049
10050 arch_emit_unbox_trampoline (acfg, cfg, cfg->orig_method, cfg->asm_symbol);
10051
10052 if (acfg->thumb_mixed && cfg->compile_llvm)
10053 emit_set_arm_mode (acfg);
10054
10055 if (!saved_unbox_info) {
10056 char user_symbol [128];
10057 GSList *unwind_ops;
10058 sprintf (user_symbol, "%sunbox_trampoline_p", acfg->user_symbol_prefix);
10059
10060 emit_label (acfg, "ut_end");
10061
10062 unwind_ops = mono_unwind_get_cie_program ();
10063 save_unwind_info (acfg, user_symbol, unwind_ops);
10064 mono_free_unwind_info (unwind_ops);
10065
10066 /* Save the unbox trampoline size */
10067 #ifdef TARGET_AMD64
10068 // LLVM unbox trampolines vary in size, 6 or 9 bytes,
10069 // due to the last instruction being 2 or 5 bytes.
10070 // There is no need to describe interior bytes of instructions
10071 // however, so state the size as if the last instruction is size 1.
10072 emit_int32 (acfg, 5);
10073 #else
10074 emit_symbol_diff (acfg, "ut_end", symbol, 0);
10075 #endif
10076 saved_unbox_info = TRUE;
10077 }
10078 }
10079
10080 if (cfg->compile_llvm) {
10081 acfg->stats.llvm_count ++;
10082 } else {
10083 emit_method_code (acfg, cfg);
10084 }
10085 }
10086
10087 emit_section_change (acfg, ".text", 0);
10088 emit_alignment_code (acfg, 8);
10089 emit_info_symbol (acfg, "jit_code_end", TRUE);
10090
10091 /* To distinguish it from the next symbol */
10092 emit_padding (acfg, 4);
10093
10094 /*
10095 * Add .no_dead_strip directives for all LLVM methods to prevent the OSX linker
10096 * from optimizing them away, since it doesn't see that code_offsets references them.
10097 * JITted methods don't need this since they are referenced using assembler local
10098 * symbols.
10099 * FIXME: This is why write-symbols doesn't work on OSX ?
10100 */
10101 if (acfg->llvm && acfg->need_no_dead_strip) {
10102 fprintf (acfg->fp, "\n");
10103 for (i = 0; i < acfg->nmethods; ++i) {
10104 if (acfg->cfgs [i] && acfg->cfgs [i]->compile_llvm)
10105 fprintf (acfg->fp, ".no_dead_strip %s\n", acfg->cfgs [i]->asm_symbol);
10106 }
10107 }
10108
10109 /*
10110 * To work around linker issues, we emit a table of branches, and disassemble them at runtime.
10111 * This is PIE code, and the linker can update it if needed.
10112 */
10113 #if defined(TARGET_ANDROID) || defined(__linux__)
10114 gboolean is_func = FALSE;
10115 #else
10116 gboolean is_func = TRUE;
10117 #endif
10118
10119 sprintf (symbol, "method_addresses");
10120 emit_section_change (acfg, RODATA_REL_SECT, !!is_func);
10121 emit_alignment_code (acfg, 8);
10122 emit_info_symbol (acfg, symbol, is_func);
10123 if (acfg->aot_opts.write_symbols)
10124 emit_local_symbol (acfg, symbol, "method_addresses_end", is_func);
10125 emit_unset_mode (acfg);
10126 if (acfg->need_no_dead_strip)
10127 fprintf (acfg->fp, " .no_dead_strip %s\n", symbol);
10128
10129 for (i = 0; i < acfg->nmethods; ++i) {
10130 #ifdef MONO_ARCH_AOT_SUPPORTED
10131 if (!ignore_cfg (acfg->cfgs [i])) {
10132 arch_emit_label_address (acfg, acfg->cfgs [i]->asm_symbol, FALSE, acfg->thumb_mixed && acfg->cfgs [i]->compile_llvm, NULL, &acfg->call_table_entry_size);
10133 } else {
10134 arch_emit_label_address (acfg, symbol, FALSE, FALSE, NULL, &acfg->call_table_entry_size);
10135 }
10136 #endif
10137 }
10138
10139 sprintf (symbol, "method_addresses_end");
10140 emit_label (acfg, symbol);
10141 emit_line (acfg);
10142
10143 /* Emit a sorted table mapping methods to the index of their unbox trampolines */
10144 sprintf (symbol, "unbox_trampolines");
10145 emit_section_change (acfg, RODATA_SECT, 0);
10146 emit_alignment (acfg, 8);
10147 emit_info_symbol (acfg, symbol, FALSE);
10148
10149 prev_index = -1;
10150 for (i = 0; i < acfg->nmethods; ++i) {
10151 MonoCompile *cfg;
10152 MonoMethod *method;
10153 int index;
10154
10155 cfg = acfg->cfgs [i];
10156 if (ignore_cfg (cfg))
10157 continue;
10158
10159 method = cfg->orig_method;
10160
10161 if (mono_aot_mode_is_full (&acfg->aot_opts) && m_class_is_valuetype (cfg->orig_method->klass)) {
10162 index = get_method_index (acfg, method);
10163
10164 emit_int32 (acfg, index);
10165 /* Make sure the table is sorted by index */
10166 g_assert (index > prev_index);
10167 prev_index = index;
10168 }
10169 }
10170 sprintf (symbol, "unbox_trampolines_end");
10171 emit_info_symbol (acfg, symbol, FALSE);
10172 emit_int32 (acfg, 0);
10173
10174 /* Emit a separate table with the trampoline addresses/offsets */
10175 sprintf (symbol, "unbox_trampoline_addresses");
10176 emit_section_change (acfg, ".text", 0);
10177 emit_alignment_code (acfg, 8);
10178 emit_info_symbol (acfg, symbol, TRUE);
10179
10180 for (i = 0; i < acfg->nmethods; ++i) {
10181 MonoCompile *cfg;
10182 MonoMethod *method;
10183
10184 cfg = acfg->cfgs [i];
10185 if (ignore_cfg (cfg))
10186 continue;
10187
10188 method = cfg->orig_method;
10189 (void)method;
10190
10191 if (mono_aot_mode_is_full (&acfg->aot_opts) && m_class_is_valuetype (cfg->orig_method->klass)) {
10192 #ifdef MONO_ARCH_AOT_SUPPORTED
10193 int call_size;
10194
10195 const int index = get_method_index (acfg, method);
10196 sprintf (symbol, "ut_%d", index);
10197
10198 arch_emit_direct_call (acfg, symbol, FALSE, acfg->thumb_mixed && cfg->compile_llvm, NULL, &call_size);
10199 #endif
10200 }
10201 }
10202 emit_int32 (acfg, 0);
10203 }
10204
10205 static void
10206 emit_info (MonoAotCompile *acfg)
10207 {
10208 int oindex, i;
10209 gint32 *offsets;
10210
10211 offsets = g_new0 (gint32, acfg->nmethods);
10212
10213 for (oindex = 0; oindex < acfg->method_order->len; ++oindex) {
10214 i = GPOINTER_TO_UINT (g_ptr_array_index (acfg->method_order, oindex));
10215
10216 if (acfg->cfgs [i]) {
10217 emit_method_info (acfg, acfg->cfgs [i]);
10218 offsets [i] = acfg->cfgs [i]->method_info_offset;
10219 } else {
10220 offsets [i] = 0;
10221 }
10222 }
10223
10224 acfg->stats.offsets_size += emit_offset_table (acfg, "method_info_offsets", MONO_AOT_TABLE_METHOD_INFO_OFFSETS, acfg->nmethods, 10, offsets);
10225
10226 g_free (offsets);
10227 }
10228
10229 #endif /* #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */
10230
10231 #define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
10232 #define mix(a,b,c) { \
10233 a -= c; a ^= rot(c, 4); c += b; \
10234 b -= a; b ^= rot(a, 6); a += c; \
10235 c -= b; c ^= rot(b, 8); b += a; \
10236 a -= c; a ^= rot(c,16); c += b; \
10237 b -= a; b ^= rot(a,19); a += c; \
10238 c -= b; c ^= rot(b, 4); b += a; \
10239 }
10240 #define mono_final(a,b,c) { \
10241 c ^= b; c -= rot(b,14); \
10242 a ^= c; a -= rot(c,11); \
10243 b ^= a; b -= rot(a,25); \
10244 c ^= b; c -= rot(b,16); \
10245 a ^= c; a -= rot(c,4); \
10246 b ^= a; b -= rot(a,14); \
10247 c ^= b; c -= rot(b,24); \
10248 }
10249
10250 static guint
10251 mono_aot_type_hash (MonoType *t1)
10252 {
10253 guint hash = t1->type;
10254
10255 hash |= t1->byref << 6; /* do not collide with t1->type values */
10256 switch (t1->type) {
10257 case MONO_TYPE_VALUETYPE:
10258 case MONO_TYPE_CLASS:
10259 case MONO_TYPE_SZARRAY:
10260 /* check if the distribution is good enough */
10261 return ((hash << 5) - hash) ^ mono_metadata_str_hash (m_class_get_name (t1->data.klass));
10262 case MONO_TYPE_PTR:
10263 return ((hash << 5) - hash) ^ mono_metadata_type_hash (t1->data.type);
10264 case MONO_TYPE_ARRAY:
10265 return ((hash << 5) - hash) ^ mono_metadata_type_hash (m_class_get_byval_arg (t1->data.array->eklass));
10266 case MONO_TYPE_GENERICINST:
10267 return ((hash << 5) - hash) ^ 0;
10268 default:
10269 return hash;
10270 }
10271 }
10272
10273 /*
10274 * mono_aot_method_hash:
10275 *
10276 * Return a hash code for methods which only depends on metadata.
10277 */
10278 guint32
10279 mono_aot_method_hash (MonoMethod *method)
10280 {
10281 MonoMethodSignature *sig;
10282 MonoClass *klass;
10283 int i, hindex;
10284 int hashes_count;
10285 guint32 *hashes_start, *hashes;
10286 guint32 a, b, c;
10287 MonoGenericInst *class_ginst = NULL;
10288 MonoGenericInst *ginst = NULL;
10289
10290 /* Similar to the hash in mono_method_get_imt_slot () */
10291
10292 sig = mono_method_signature_internal (method);
10293
10294 if (mono_class_is_ginst (method->klass))
10295 class_ginst = mono_class_get_generic_class (method->klass)->context.class_inst;
10296 if (method->is_inflated)
10297 ginst = ((MonoMethodInflated*)method)->context.method_inst;
10298
10299 hashes_count = sig->param_count + 5 + (class_ginst ? class_ginst->type_argc : 0) + (ginst ? ginst->type_argc : 0);
10300 hashes_start = (guint32 *)g_malloc0 (hashes_count * sizeof (guint32));
10301 hashes = hashes_start;
10302
10303 /* Some wrappers are assigned to random classes */
10304 if (!method->wrapper_type || method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)
10305 klass = method->klass;
10306 else
10307 klass = mono_defaults.object_class;
10308
10309 if (!method->wrapper_type) {
10310 char *full_name;
10311
10312 if (mono_class_is_ginst (klass))
10313 full_name = mono_type_full_name (m_class_get_byval_arg (mono_class_get_generic_class (klass)->container_class));
10314 else
10315 full_name = mono_type_full_name (m_class_get_byval_arg (klass));
10316
10317 hashes [0] = mono_metadata_str_hash (full_name);
10318 hashes [1] = 0;
10319 g_free (full_name);
10320 } else {
10321 hashes [0] = mono_metadata_str_hash (m_class_get_name (klass));
10322 hashes [1] = mono_metadata_str_hash (m_class_get_name_space (klass));
10323 }
10324 if (method->wrapper_type == MONO_WRAPPER_STFLD || method->wrapper_type == MONO_WRAPPER_LDFLD || method->wrapper_type == MONO_WRAPPER_LDFLDA)
10325 /* The method name includes a stringified pointer */
10326 hashes [2] = 0;
10327 else
10328 hashes [2] = mono_metadata_str_hash (method->name);
10329 hashes [3] = method->wrapper_type;
10330 hashes [4] = mono_aot_type_hash (sig->ret);
10331 hindex = 5;
10332 for (i = 0; i < sig->param_count; i++) {
10333 hashes [hindex ++] = mono_aot_type_hash (sig->params [i]);
10334 }
10335 if (class_ginst) {
10336 for (i = 0; i < class_ginst->type_argc; ++i)
10337 hashes [hindex ++] = mono_aot_type_hash (class_ginst->type_argv [i]);
10338 }
10339 if (ginst) {
10340 for (i = 0; i < ginst->type_argc; ++i)
10341 hashes [hindex ++] = mono_aot_type_hash (ginst->type_argv [i]);
10342 }
10343 g_assert (hindex == hashes_count);
10344
10345 /* Setup internal state */
10346 a = b = c = 0xdeadbeef + (((guint32)hashes_count)<<2);
10347
10348 /* Handle most of the hashes */
10349 while (hashes_count > 3) {
10350 a += hashes [0];
10351 b += hashes [1];
10352 c += hashes [2];
10353 mix (a,b,c);
10354 hashes_count -= 3;
10355 hashes += 3;
10356 }
10357
10358 /* Handle the last 3 hashes (all the case statements fall through) */
10359 switch (hashes_count) {
10360 case 3 : c += hashes [2];
10361 case 2 : b += hashes [1];
10362 case 1 : a += hashes [0];
10363 mono_final (a,b,c);
10364 case 0: /* nothing left to add */
10365 break;
10366 }
10367
10368 g_free (hashes_start);
10369
10370 return c;
10371 }
10372 #undef rot
10373 #undef mix
10374 #undef mono_final
10375
10376 /*
10377 * mono_aot_get_array_helper_from_wrapper;
10378 *
10379 * Get the helper method in Array called by an array wrapper method.
10380 */
10381 MonoMethod*
10382 mono_aot_get_array_helper_from_wrapper (MonoMethod *method)
10383 {
10384 MonoMethod *m;
10385 const char *prefix;
10386 MonoGenericContext ctx;
10387 MonoType *args [16];
10388 char *mname, *iname, *s, *s2, *helper_name = NULL;
10389
10390 prefix = "System.Collections.Generic";
10391 s = g_strdup_printf ("%s", method->name + strlen (prefix) + 1);
10392 s2 = strstr (s, "`1.");
10393 g_assert (s2);
10394 s2 [0] = '\0';
10395 iname = s;
10396 mname = s2 + 3;
10397
10398 //printf ("X: %s %s\n", iname, mname);
10399
10400 if (!strcmp (iname, "IList"))
10401 helper_name = g_strdup_printf ("InternalArray__%s", mname);
10402 else
10403 helper_name = g_strdup_printf ("InternalArray__%s_%s", iname, mname);
10404 m = get_method_nofail (mono_defaults.array_class, helper_name, mono_method_signature_internal (method)->param_count, 0);
10405 g_assert (m);
10406 g_free (helper_name);
10407 g_free (s);
10408
10409 if (m->is_generic) {
10410 ERROR_DECL (error);
10411 memset (&ctx, 0, sizeof (ctx));
10412 args [0] = m_class_get_byval_arg (m_class_get_element_class (method->klass));
10413 ctx.method_inst = mono_metadata_get_generic_inst (1, args);
10414 m = mono_class_inflate_generic_method_checked (m, &ctx, error);
10415 g_assert (is_ok (error)); /* FIXME don't swallow the error */
10416 }
10417
10418 return m;
10419 }
10420
10421 #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT)
10422
10423 typedef struct HashEntry {
10424 guint32 key, value, index;
10425 struct HashEntry *next;
10426 } HashEntry;
10427
10428 /*
10429 * emit_extra_methods:
10430 *
10431 * Emit methods which are not in the METHOD table, like wrappers.
10432 */
10433 static void
10434 emit_extra_methods (MonoAotCompile *acfg)
10435 {
10436 int i, table_size, buf_size;
10437 guint8 *p, *buf;
10438 guint32 *info_offsets;
10439 guint32 hash;
10440 GPtrArray *table;
10441 HashEntry *entry, *new_entry;
10442 int nmethods, max_chain_length;
10443 int *chain_lengths;
10444
10445 info_offsets = g_new0 (guint32, acfg->extra_methods->len);
10446
10447 /* Emit method info */
10448 nmethods = 0;
10449 for (i = 0; i < acfg->extra_methods->len; ++i) {
10450 MonoMethod *method = (MonoMethod *)g_ptr_array_index (acfg->extra_methods, i);
10451 MonoCompile *cfg = (MonoCompile *)g_hash_table_lookup (acfg->method_to_cfg, method);
10452
10453 if (ignore_cfg (cfg))
10454 continue;
10455
10456 buf_size = 10240;
10457 p = buf = (guint8 *)g_malloc (buf_size);
10458
10459 nmethods ++;
10460
10461 method = cfg->method_to_register;
10462
10463 encode_method_ref (acfg, method, p, &p);
10464
10465 g_assert ((p - buf) < buf_size);
10466
10467 info_offsets [i] = add_to_blob (acfg, buf, p - buf);
10468 g_free (buf);
10469 }
10470
10471 /*
10472 * Construct a chained hash table for mapping indexes in extra_method_info to
10473 * method indexes.
10474 */
10475 table_size = g_spaced_primes_closest ((int)(nmethods * 1.5));
10476 table = g_ptr_array_sized_new (table_size);
10477 for (i = 0; i < table_size; ++i)
10478 g_ptr_array_add (table, NULL);
10479 chain_lengths = g_new0 (int, table_size);
10480 max_chain_length = 0;
10481 for (i = 0; i < acfg->extra_methods->len; ++i) {
10482 MonoMethod *method = (MonoMethod *)g_ptr_array_index (acfg->extra_methods, i);
10483 MonoCompile *cfg = (MonoCompile *)g_hash_table_lookup (acfg->method_to_cfg, method);
10484 guint32 key, value;
10485
10486 if (ignore_cfg (cfg))
10487 continue;
10488
10489 key = info_offsets [i];
10490 value = get_method_index (acfg, method);
10491
10492 hash = mono_aot_method_hash (method) % table_size;
10493 //printf ("X: %s %x\n", mono_method_get_full_name (method), mono_aot_method_hash (method));
10494
10495 chain_lengths [hash] ++;
10496 max_chain_length = MAX (max_chain_length, chain_lengths [hash]);
10497
10498 new_entry = (HashEntry *)mono_mempool_alloc0 (acfg->mempool, sizeof (HashEntry));
10499 new_entry->key = key;
10500 new_entry->value = value;
10501
10502 entry = (HashEntry *)g_ptr_array_index (table, hash);
10503 if (entry == NULL) {
10504 new_entry->index = hash;
10505 g_ptr_array_index (table, hash) = new_entry;
10506 } else {
10507 while (entry->next)
10508 entry = entry->next;
10509
10510 entry->next = new_entry;
10511 new_entry->index = table->len;
10512 g_ptr_array_add (table, new_entry);
10513 }
10514 }
10515 g_free (chain_lengths);
10516
10517 //printf ("MAX: %d\n", max_chain_length);
10518
10519 buf_size = table->len * 12 + 4;
10520 p = buf = (guint8 *)g_malloc (buf_size);
10521 encode_int (table_size, p, &p);
10522
10523 for (i = 0; i < table->len; ++i) {
10524 HashEntry *entry = (HashEntry *)g_ptr_array_index (table, i);
10525
10526 if (entry == NULL) {
10527 encode_int (0, p, &p);
10528 encode_int (0, p, &p);
10529 encode_int (0, p, &p);
10530 } else {
10531 //g_assert (entry->key > 0);
10532 encode_int (entry->key, p, &p);
10533 encode_int (entry->value, p, &p);
10534 if (entry->next)
10535 encode_int (entry->next->index, p, &p);
10536 else
10537 encode_int (0, p, &p);
10538 }
10539 }
10540 g_assert (p - buf <= buf_size);
10541
10542 /* Emit the table */
10543 emit_aot_data (acfg, MONO_AOT_TABLE_EXTRA_METHOD_TABLE, "extra_method_table", buf, p - buf);
10544
10545 g_free (buf);
10546
10547 /*
10548 * Emit a table reverse mapping method indexes to their index in extra_method_info.
10549 * This is used by mono_aot_find_jit_info ().
10550 */
10551 buf_size = acfg->extra_methods->len * 8 + 4;
10552 p = buf = (guint8 *)g_malloc (buf_size);
10553 encode_int (acfg->extra_methods->len, p, &p);
10554 for (i = 0; i < acfg->extra_methods->len; ++i) {
10555 MonoMethod *method = (MonoMethod *)g_ptr_array_index (acfg->extra_methods, i);
10556
10557 encode_int (get_method_index (acfg, method), p, &p);
10558 encode_int (info_offsets [i], p, &p);
10559 }
10560 emit_aot_data (acfg, MONO_AOT_TABLE_EXTRA_METHOD_INFO_OFFSETS, "extra_method_info_offsets", buf, p - buf);
10561
10562 g_free (buf);
10563 g_free (info_offsets);
10564 g_ptr_array_free (table, TRUE);
10565 }
10566
10567 static void
10568 generate_aotid (guint8* aotid)
10569 {
10570 gpointer rand_handle;
10571 ERROR_DECL (error);
10572
10573 mono_rand_open ();
10574 rand_handle = mono_rand_init (NULL, 0);
10575
10576 mono_rand_try_get_bytes (&rand_handle, aotid, 16, error);
10577 mono_error_assert_ok (error);
10578
10579 mono_rand_close (rand_handle);
10580 }
10581
10582 static void
10583 emit_exception_info (MonoAotCompile *acfg)
10584 {
10585 int i;
10586 gint32 *offsets;
10587 SeqPointData sp_data;
10588 gboolean seq_points_to_file = FALSE;
10589
10590 offsets = g_new0 (gint32, acfg->nmethods);
10591 for (i = 0; i < acfg->nmethods; ++i) {
10592 if (acfg->cfgs [i]) {
10593 MonoCompile *cfg = acfg->cfgs [i];
10594
10595 // By design aot-runtime decode_exception_debug_info is not able to load sequence point debug data from a file.
10596 // As it is not possible to load debug data from a file its is also not possible to store it in a file.
10597 gboolean method_seq_points_to_file = acfg->aot_opts.gen_msym_dir &&
10598 cfg->gen_seq_points && !cfg->gen_sdb_seq_points;
10599 gboolean method_seq_points_to_binary = cfg->gen_seq_points && !method_seq_points_to_file;
10600
10601 emit_exception_debug_info (acfg, cfg, method_seq_points_to_binary);
10602 offsets [i] = cfg->ex_info_offset;
10603
10604 if (method_seq_points_to_file) {
10605 if (!seq_points_to_file) {
10606 mono_seq_point_data_init (&sp_data, acfg->nmethods);
10607 seq_points_to_file = TRUE;
10608 }
10609 mono_seq_point_data_add (&sp_data, cfg->method->token, cfg->method_index, cfg->seq_point_info);
10610 }
10611 } else {
10612 offsets [i] = 0;
10613 }
10614 }
10615
10616 if (seq_points_to_file) {
10617 char *aotid = mono_guid_to_string_minimal (acfg->image->aotid);
10618 char *dir = g_build_filename (acfg->aot_opts.gen_msym_dir_path, aotid, (const char*)NULL);
10619 char *image_basename = g_path_get_basename (acfg->image->name);
10620 char *aot_file = g_strdup_printf("%s%s", image_basename, SEQ_POINT_AOT_EXT);
10621 char *aot_file_path = g_build_filename (dir, aot_file, (const char*)NULL);
10622
10623 if (g_ensure_directory_exists (aot_file_path) == FALSE) {
10624 fprintf (stderr, "AOT : failed to create msym directory: %s\n", aot_file_path);
10625 exit (1);
10626 }
10627
10628 mono_seq_point_data_write (&sp_data, aot_file_path);
10629 mono_seq_point_data_free (&sp_data);
10630
10631 g_free (aotid);
10632 g_free (dir);
10633 g_free (image_basename);
10634 g_free (aot_file);
10635 g_free (aot_file_path);
10636 }
10637
10638 acfg->stats.offsets_size += emit_offset_table (acfg, "ex_info_offsets", MONO_AOT_TABLE_EX_INFO_OFFSETS, acfg->nmethods, 10, offsets);
10639 g_free (offsets);
10640 }
10641
10642 static void
10643 emit_unwind_info (MonoAotCompile *acfg)
10644 {
10645 int i;
10646 char symbol [128];
10647
10648 if (acfg->aot_opts.llvm_only) {
10649 g_assert (acfg->unwind_ops->len == 0);
10650 return;
10651 }
10652
10653 /*
10654 * The unwind info contains a lot of duplicates so we emit each unique
10655 * entry once, and only store the offset from the start of the table in the
10656 * exception info.
10657 */
10658
10659 sprintf (symbol, "unwind_info");
10660 emit_section_change (acfg, RODATA_SECT, 1);
10661 emit_alignment (acfg, 8);
10662 emit_info_symbol (acfg, symbol, TRUE);
10663
10664 for (i = 0; i < acfg->unwind_ops->len; ++i) {
10665 guint32 index = GPOINTER_TO_UINT (g_ptr_array_index (acfg->unwind_ops, i));
10666 guint8 *unwind_info;
10667 guint32 unwind_info_len;
10668 guint8 buf [16];
10669 guint8 *p;
10670
10671 unwind_info = mono_get_cached_unwind_info (index, &unwind_info_len);
10672
10673 p = buf;
10674 encode_value (unwind_info_len, p, &p);
10675 emit_bytes (acfg, buf, p - buf);
10676 emit_bytes (acfg, unwind_info, unwind_info_len);
10677
10678 acfg->stats.unwind_info_size += (p - buf) + unwind_info_len;
10679 }
10680 }
10681
10682 static void
10683 emit_class_info (MonoAotCompile *acfg)
10684 {
10685 int i;
10686 gint32 *offsets;
10687
10688 offsets = g_new0 (gint32, acfg->image->tables [MONO_TABLE_TYPEDEF].rows);
10689 for (i = 0; i < acfg->image->tables [MONO_TABLE_TYPEDEF].rows; ++i)
10690 offsets [i] = emit_klass_info (acfg, MONO_TOKEN_TYPE_DEF | (i + 1));
10691
10692 acfg->stats.offsets_size += emit_offset_table (acfg, "class_info_offsets", MONO_AOT_TABLE_CLASS_INFO_OFFSETS, acfg->image->tables [MONO_TABLE_TYPEDEF].rows, 10, offsets);
10693 g_free (offsets);
10694 }
10695
10696 typedef struct ClassNameTableEntry {
10697 guint32 token, index;
10698 struct ClassNameTableEntry *next;
10699 } ClassNameTableEntry;
10700
10701 static void
10702 emit_class_name_table (MonoAotCompile *acfg)
10703 {
10704 int i, table_size, buf_size;
10705 guint32 token, hash;
10706 MonoClass *klass;
10707 GPtrArray *table;
10708 char *full_name;
10709 guint8 *buf, *p;
10710 ClassNameTableEntry *entry, *new_entry;
10711
10712 /*
10713 * Construct a chained hash table for mapping class names to typedef tokens.
10714 */
10715 table_size = g_spaced_primes_closest ((int)(acfg->image->tables [MONO_TABLE_TYPEDEF].rows * 1.5));
10716 table = g_ptr_array_sized_new (table_size);
10717 for (i = 0; i < table_size; ++i)
10718 g_ptr_array_add (table, NULL);
10719 for (i = 0; i < acfg->image->tables [MONO_TABLE_TYPEDEF].rows; ++i) {
10720 ERROR_DECL (error);
10721 token = MONO_TOKEN_TYPE_DEF | (i + 1);
10722 klass = mono_class_get_checked (acfg->image, token, error);
10723 if (!klass) {
10724 mono_error_cleanup (error);
10725 continue;
10726 }
10727 full_name = mono_type_get_name_full (m_class_get_byval_arg (klass), MONO_TYPE_NAME_FORMAT_FULL_NAME);
10728 hash = mono_metadata_str_hash (full_name) % table_size;
10729 g_free (full_name);
10730
10731 /* FIXME: Allocate from the mempool */
10732 new_entry = g_new0 (ClassNameTableEntry, 1);
10733 new_entry->token = token;
10734
10735 entry = (ClassNameTableEntry *)g_ptr_array_index (table, hash);
10736 if (entry == NULL) {
10737 new_entry->index = hash;
10738 g_ptr_array_index (table, hash) = new_entry;
10739 } else {
10740 while (entry->next)
10741 entry = entry->next;
10742
10743 entry->next = new_entry;
10744 new_entry->index = table->len;
10745 g_ptr_array_add (table, new_entry);
10746 }
10747 }
10748
10749 /* Emit the table */
10750 buf_size = table->len * 4 + 4;
10751 p = buf = (guint8 *)g_malloc0 (buf_size);
10752
10753 /* FIXME: Optimize memory usage */
10754 g_assert (table_size < 65000);
10755 encode_int16 (table_size, p, &p);
10756 g_assert (table->len < 65000);
10757 for (i = 0; i < table->len; ++i) {
10758 ClassNameTableEntry *entry = (ClassNameTableEntry *)g_ptr_array_index (table, i);
10759
10760 if (entry == NULL) {
10761 encode_int16 (0, p, &p);
10762 encode_int16 (0, p, &p);
10763 } else {
10764 encode_int16 (mono_metadata_token_index (entry->token), p, &p);
10765 if (entry->next)
10766 encode_int16 (entry->next->index, p, &p);
10767 else
10768 encode_int16 (0, p, &p);
10769 }
10770 g_free (entry);
10771 }
10772 g_assert (p - buf <= buf_size);
10773 g_ptr_array_free (table, TRUE);
10774
10775 emit_aot_data (acfg, MONO_AOT_TABLE_CLASS_NAME, "class_name_table", buf, p - buf);
10776
10777 g_free (buf);
10778 }
10779
10780 static void
10781 emit_image_table (MonoAotCompile *acfg)
10782 {
10783 int i, buf_size;
10784 guint8 *buf, *p;
10785
10786 /*
10787 * The image table is small but referenced in a lot of places.
10788 * So we emit it at once, and reference its elements by an index.
10789 */
10790 buf_size = acfg->image_table->len * 28 + 4;
10791 for (i = 0; i < acfg->image_table->len; i++) {
10792 MonoImage *image = (MonoImage*)g_ptr_array_index (acfg->image_table, i);
10793 MonoAssemblyName *aname = &image->assembly->aname;
10794
10795 buf_size += strlen (image->assembly_name) + strlen (image->guid) + (aname->culture ? strlen (aname->culture) : 1) + strlen ((char*)aname->public_key_token) + 4;
10796 }
10797
10798 buf = p = (guint8 *)g_malloc0 (buf_size);
10799 encode_int (acfg->image_table->len, p, &p);
10800 for (i = 0; i < acfg->image_table->len; i++) {
10801 MonoImage *image = (MonoImage*)g_ptr_array_index (acfg->image_table, i);
10802 MonoAssemblyName *aname = &image->assembly->aname;
10803
10804 /* FIXME: Support multi-module assemblies */
10805 g_assert (image->assembly->image == image);
10806
10807 encode_string (image->assembly_name, p, &p);
10808 encode_string (image->guid, p, &p);
10809 encode_string (aname->culture ? aname->culture : "", p, &p);
10810 encode_string ((const char*)aname->public_key_token, p, &p);
10811
10812 while (GPOINTER_TO_UINT (p) % 8 != 0)
10813 p ++;
10814
10815 encode_int (aname->flags, p, &p);
10816 encode_int (aname->major, p, &p);
10817 encode_int (aname->minor, p, &p);
10818 encode_int (aname->build, p, &p);
10819 encode_int (aname->revision, p, &p);
10820 }
10821 g_assert (p - buf <= buf_size);
10822
10823 emit_aot_data (acfg, MONO_AOT_TABLE_IMAGE_TABLE, "image_table", buf, p - buf);
10824
10825 g_free (buf);
10826 }
10827
10828 static void
10829 emit_weak_field_indexes (MonoAotCompile *acfg)
10830 {
10831 GHashTable *indexes;
10832 GHashTableIter iter;
10833 gpointer key, value;
10834 int buf_size;
10835 guint8 *buf, *p;
10836
10837 /* Emit a table of weak field indexes, since computing these at runtime is expensive */
10838 mono_assembly_init_weak_fields (acfg->image);
10839 indexes = acfg->image->weak_field_indexes;
10840 g_assert (indexes);
10841
10842 buf_size = (g_hash_table_size (indexes) + 1) * 4;
10843 buf = p = (guint8 *)g_malloc0 (buf_size);
10844
10845 encode_int (g_hash_table_size (indexes), p, &p);
10846 g_hash_table_iter_init (&iter, indexes);
10847 while (g_hash_table_iter_next (&iter, &key, &value)) {
10848 guint32 index = GPOINTER_TO_UINT (key);
10849 encode_int (index, p, &p);
10850 }
10851 g_assert (p - buf <= buf_size);
10852
10853 emit_aot_data (acfg, MONO_AOT_TABLE_WEAK_FIELD_INDEXES, "weak_field_indexes", buf, p - buf);
10854
10855 g_free (buf);
10856 }
10857
10858 static void
10859 emit_got_info (MonoAotCompile *acfg, gboolean llvm)
10860 {
10861 int i, first_plt_got_patch = 0, buf_size;
10862 guint8 *p, *buf;
10863 guint32 *got_info_offsets;
10864 GotInfo *info = llvm ? &acfg->llvm_got_info : &acfg->got_info;
10865
10866 /* Add the patches needed by the PLT to the GOT */
10867 if (!llvm) {
10868 acfg->plt_got_offset_base = acfg->got_offset;
10869 first_plt_got_patch = info->got_patches->len;
10870 for (i = 1; i < acfg->plt_offset; ++i) {
10871 MonoPltEntry *plt_entry = (MonoPltEntry *)g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
10872
10873 g_ptr_array_add (info->got_patches, plt_entry->ji);
10874
10875 acfg->stats.got_slot_types [plt_entry->ji->type] ++;
10876 }
10877
10878 acfg->got_offset += acfg->plt_offset;
10879 }
10880
10881 /**
10882 * FIXME:
10883 * - optimize offsets table.
10884 * - reduce number of exported symbols.
10885 * - emit info for a klass only once.
10886 * - determine when a method uses a GOT slot which is guaranteed to be already
10887 * initialized.
10888 * - clean up and document the code.
10889 * - use String.Empty in class libs.
10890 */
10891
10892 /* Encode info required to decode shared GOT entries */
10893 buf_size = info->got_patches->len * 128;
10894 p = buf = (guint8 *)mono_mempool_alloc (acfg->mempool, buf_size);
10895 got_info_offsets = (guint32 *)mono_mempool_alloc (acfg->mempool, info->got_patches->len * sizeof (guint32));
10896 if (!llvm) {
10897 acfg->plt_got_info_offsets = (guint32 *)mono_mempool_alloc (acfg->mempool, acfg->plt_offset * sizeof (guint32));
10898 /* Unused */
10899 if (acfg->plt_offset)
10900 acfg->plt_got_info_offsets [0] = 0;
10901 }
10902 for (i = 0; i < info->got_patches->len; ++i) {
10903 MonoJumpInfo *ji = (MonoJumpInfo *)g_ptr_array_index (info->got_patches, i);
10904 guint8 *p2;
10905
10906 p = buf;
10907
10908 encode_value (ji->type, p, &p);
10909 p2 = p;
10910 encode_patch (acfg, ji, p, &p);
10911 acfg->stats.got_slot_info_sizes [ji->type] += p - p2;
10912 g_assert (p - buf <= buf_size);
10913 got_info_offsets [i] = add_to_blob (acfg, buf, p - buf);
10914
10915 if (!llvm && i >= first_plt_got_patch)
10916 acfg->plt_got_info_offsets [i - first_plt_got_patch + 1] = got_info_offsets [i];
10917 acfg->stats.got_info_size += p - buf;
10918 }
10919
10920 /* Emit got_info_offsets table */
10921
10922 /* No need to emit offsets for the got plt entries, the plt embeds them directly */
10923 acfg->stats.offsets_size += emit_offset_table (acfg, llvm ? "llvm_got_info_offsets" : "got_info_offsets", llvm ? MONO_AOT_TABLE_LLVM_GOT_INFO_OFFSETS : MONO_AOT_TABLE_GOT_INFO_OFFSETS, llvm ? acfg->llvm_got_offset : first_plt_got_patch, 10, (gint32*)got_info_offsets);
10924 }
10925
10926 static void
10927 emit_got (MonoAotCompile *acfg)
10928 {
10929 char symbol [MAX_SYMBOL_SIZE];
10930
10931 if (acfg->aot_opts.llvm_only)
10932 return;
10933
10934 /* Don't make GOT global so accesses to it don't need relocations */
10935 sprintf (symbol, "%s", acfg->got_symbol);
10936
10937 #ifdef TARGET_MACH
10938 emit_unset_mode (acfg);
10939 fprintf (acfg->fp, ".section __DATA, __bss\n");
10940 emit_alignment (acfg, 8);
10941 if (acfg->llvm)
10942 emit_info_symbol (acfg, "jit_got", FALSE);
10943 fprintf (acfg->fp, ".lcomm %s, %d\n", acfg->got_symbol, (int)(acfg->got_offset * sizeof (target_mgreg_t)));
10944 #else
10945 emit_section_change (acfg, ".bss", 0);
10946 emit_alignment (acfg, 8);
10947 if (acfg->aot_opts.write_symbols)
10948 emit_local_symbol (acfg, symbol, "got_end", FALSE);
10949 emit_label (acfg, symbol);
10950 if (acfg->llvm)
10951 emit_info_symbol (acfg, "jit_got", FALSE);
10952 if (acfg->got_offset > 0)
10953 emit_zero_bytes (acfg, (int)(acfg->got_offset * sizeof (target_mgreg_t)));
10954 #endif
10955
10956 sprintf (symbol, "got_end");
10957 emit_label (acfg, symbol);
10958 }
10959
10960 typedef struct GlobalsTableEntry {
10961 guint32 value, index;
10962 struct GlobalsTableEntry *next;
10963 } GlobalsTableEntry;
10964
10965 #ifdef TARGET_WIN32_MSVC
10966 #define DLL_ENTRY_POINT "DllMain"
10967
10968 static void
10969 emit_library_info (MonoAotCompile *acfg)
10970 {
10971 // Only include for shared libraries linked directly from generated object.
10972 if (link_shared_library (acfg)) {
10973 char *name = NULL;
10974 char symbol [MAX_SYMBOL_SIZE];
10975
10976 // Ask linker to export all global symbols.
10977 emit_section_change (acfg, ".drectve", 0);
10978 for (guint i = 0; i < acfg->globals->len; ++i) {
10979 name = (char *)g_ptr_array_index (acfg->globals, i);
10980 g_assert (name != NULL);
10981 sprintf_s (symbol, MAX_SYMBOL_SIZE, " /EXPORT:%s", name);
10982 emit_string (acfg, symbol);
10983 }
10984
10985 // Emit DLLMain function, needed by MSVC linker for DLL's.
10986 // NOTE, DllMain should not go into exports above.
10987 emit_section_change (acfg, ".text", 0);
10988 emit_global (acfg, DLL_ENTRY_POINT, TRUE);
10989 emit_label (acfg, DLL_ENTRY_POINT);
10990
10991 // Simple implementation of DLLMain, just returning TRUE.
10992 // For more information about DLLMain: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682583(v=vs.85).aspx
10993 fprintf (acfg->fp, "movl $1, %%eax\n");
10994 fprintf (acfg->fp, "ret\n");
10995
10996 // Inform linker about our dll entry function.
10997 emit_section_change (acfg, ".drectve", 0);
10998 emit_string (acfg, "/ENTRY:" DLL_ENTRY_POINT);
10999 return;
11000 }
11001 }
11002
11003 #else
11004
11005 static void
11006 emit_library_info (MonoAotCompile *acfg)
11007 {
11008 return;
11009 }
11010 #endif
11011
11012 static void
11013 emit_globals (MonoAotCompile *acfg)
11014 {
11015 int i, table_size;
11016 guint32 hash;
11017 GPtrArray *table;
11018 char symbol [1024];
11019 GlobalsTableEntry *entry, *new_entry;
11020
11021 if (!acfg->aot_opts.static_link)
11022 return;
11023
11024 if (acfg->aot_opts.llvm_only) {
11025 g_assert (acfg->globals->len == 0);
11026 return;
11027 }
11028
11029 /*
11030 * When static linking, we emit a table containing our globals.
11031 */
11032
11033 /*
11034 * Construct a chained hash table for mapping global names to their index in
11035 * the globals table.
11036 */
11037 table_size = g_spaced_primes_closest ((int)(acfg->globals->len * 1.5));
11038 table = g_ptr_array_sized_new (table_size);
11039 for (i = 0; i < table_size; ++i)
11040 g_ptr_array_add (table, NULL);
11041 for (i = 0; i < acfg->globals->len; ++i) {
11042 char *name = (char *)g_ptr_array_index (acfg->globals, i);
11043
11044 hash = mono_metadata_str_hash (name) % table_size;
11045
11046 /* FIXME: Allocate from the mempool */
11047 new_entry = g_new0 (GlobalsTableEntry, 1);
11048 new_entry->value = i;
11049
11050 entry = (GlobalsTableEntry *)g_ptr_array_index (table, hash);
11051 if (entry == NULL) {
11052 new_entry->index = hash;
11053 g_ptr_array_index (table, hash) = new_entry;
11054 } else {
11055 while (entry->next)
11056 entry = entry->next;
11057
11058 entry->next = new_entry;
11059 new_entry->index = table->len;
11060 g_ptr_array_add (table, new_entry);
11061 }
11062 }
11063
11064 /* Emit the table */
11065 sprintf (symbol, ".Lglobals_hash");
11066 emit_section_change (acfg, RODATA_SECT, 0);
11067 emit_alignment (acfg, 8);
11068 emit_label (acfg, symbol);
11069
11070 /* FIXME: Optimize memory usage */
11071 g_assert (table_size < 65000);
11072 emit_int16 (acfg, table_size);
11073 for (i = 0; i < table->len; ++i) {
11074 GlobalsTableEntry *entry = (GlobalsTableEntry *)g_ptr_array_index (table, i);
11075
11076 if (entry == NULL) {
11077 emit_int16 (acfg, 0);
11078 emit_int16 (acfg, 0);
11079 } else {
11080 emit_int16 (acfg, entry->value + 1);
11081 if (entry->next)
11082 emit_int16 (acfg, entry->next->index);
11083 else
11084 emit_int16 (acfg, 0);
11085 }
11086 }
11087
11088 /* Emit the names */
11089 for (i = 0; i < acfg->globals->len; ++i) {
11090 char *name = (char *)g_ptr_array_index (acfg->globals, i);
11091
11092 sprintf (symbol, "name_%d", i);
11093 emit_section_change (acfg, RODATA_SECT, 1);
11094 #ifdef TARGET_MACH
11095 emit_alignment (acfg, 4);
11096 #endif
11097 emit_label (acfg, symbol);
11098 emit_string (acfg, name);
11099 }
11100
11101 /* Emit the globals table */
11102 sprintf (symbol, "globals");
11103 emit_section_change (acfg, ".data", 0);
11104 /* This is not a global, since it is accessed by the init function */
11105 emit_alignment (acfg, 8);
11106 emit_info_symbol (acfg, symbol, FALSE);
11107
11108 sprintf (symbol, "%sglobals_hash", acfg->temp_prefix);
11109 emit_pointer (acfg, symbol);
11110
11111 for (i = 0; i < acfg->globals->len; ++i) {
11112 char *name = (char *)g_ptr_array_index (acfg->globals, i);
11113
11114 sprintf (symbol, "name_%d", i);
11115 emit_pointer (acfg, symbol);
11116
11117 g_assert (strlen (name) < sizeof (symbol));
11118 sprintf (symbol, "%s", name);
11119 emit_pointer (acfg, symbol);
11120 }
11121 /* Null terminate the table */
11122 emit_int32 (acfg, 0);
11123 emit_int32 (acfg, 0);
11124 }
11125
11126 static void
11127 emit_mem_end (MonoAotCompile *acfg)
11128 {
11129 char symbol [128];
11130
11131 if (acfg->aot_opts.llvm_only)
11132 return;
11133
11134 sprintf (symbol, "mem_end");
11135 emit_section_change (acfg, ".text", 1);
11136 emit_alignment_code (acfg, 8);
11137 emit_label (acfg, symbol);
11138 }
11139
11140 static void
11141 init_aot_file_info (MonoAotCompile *acfg, MonoAotFileInfo *info)
11142 {
11143 int i;
11144
11145 info->version = MONO_AOT_FILE_VERSION;
11146 info->plt_got_offset_base = acfg->plt_got_offset_base;
11147 info->got_size = acfg->got_offset * sizeof (target_mgreg_t);
11148 info->plt_size = acfg->plt_offset;
11149 info->nmethods = acfg->nmethods;
11150 info->call_table_entry_size = acfg->call_table_entry_size;
11151 info->nextra_methods = acfg->nextra_methods;
11152 info->flags = acfg->flags;
11153 info->opts = acfg->opts;
11154 info->simd_opts = acfg->simd_opts;
11155 info->gc_name_index = acfg->gc_name_offset;
11156 info->datafile_size = acfg->datafile_offset;
11157 for (i = 0; i < MONO_AOT_TABLE_NUM; ++i)
11158 info->table_offsets [i] = acfg->table_offsets [i];
11159 for (i = 0; i < MONO_AOT_TRAMP_NUM; ++i)
11160 info->num_trampolines [i] = acfg->num_trampolines [i];
11161 for (i = 0; i < MONO_AOT_TRAMP_NUM; ++i)
11162 info->trampoline_got_offset_base [i] = acfg->trampoline_got_offset_base [i];
11163 for (i = 0; i < MONO_AOT_TRAMP_NUM; ++i)
11164 info->trampoline_size [i] = acfg->trampoline_size [i];
11165 info->num_rgctx_fetch_trampolines = acfg->aot_opts.nrgctx_fetch_trampolines;
11166
11167 int card_table_shift_bits = 0;
11168 target_mgreg_t card_table_mask = 0;
11169
11170 mono_gc_get_target_card_table (&card_table_shift_bits, &card_table_mask);
11171
11172 /*
11173 * Sanity checking variables used to make sure the host and target
11174 * environment matches when cross compiling.
11175 */
11176 info->double_align = MONO_ABI_ALIGNOF (double);
11177 info->long_align = MONO_ABI_ALIGNOF (gint64);
11178 info->generic_tramp_num = MONO_TRAMPOLINE_NUM;
11179 info->card_table_shift_bits = card_table_shift_bits;
11180 info->card_table_mask = card_table_mask;
11181
11182 info->tramp_page_size = acfg->tramp_page_size;
11183 info->nshared_got_entries = acfg->nshared_got_entries;
11184 for (i = 0; i < MONO_AOT_TRAMP_NUM; ++i)
11185 info->tramp_page_code_offsets [i] = acfg->tramp_page_code_offsets [i];
11186
11187 memcpy(&info->aotid, acfg->image->aotid, 16);
11188 }
11189
11190 static void
11191 emit_aot_file_info (MonoAotCompile *acfg, MonoAotFileInfo *info)
11192 {
11193 char symbol [MAX_SYMBOL_SIZE];
11194 int i, sindex;
11195 const char **symbols;
11196
11197 symbols = g_new0 (const char *, MONO_AOT_FILE_INFO_NUM_SYMBOLS);
11198 sindex = 0;
11199 symbols [sindex ++] = acfg->got_symbol;
11200 if (acfg->llvm) {
11201 symbols [sindex ++] = g_strdup_printf ("%s%s", acfg->user_symbol_prefix, acfg->llvm_got_symbol);
11202 symbols [sindex ++] = acfg->llvm_eh_frame_symbol;
11203 } else {
11204 symbols [sindex ++] = NULL;
11205 symbols [sindex ++] = NULL;
11206 }
11207 /* llvm_get_method */
11208 symbols [sindex ++] = NULL;
11209 /* llvm_get_unbox_tramp */
11210 symbols [sindex ++] = NULL;
11211 if (!acfg->aot_opts.llvm_only) {
11212 symbols [sindex ++] = "jit_code_start";
11213 symbols [sindex ++] = "jit_code_end";
11214 symbols [sindex ++] = "method_addresses";
11215 } else {
11216 symbols [sindex ++] = NULL;
11217 symbols [sindex ++] = NULL;
11218 symbols [sindex ++] = NULL;
11219 }
11220 symbols [sindex ++] = NULL;
11221 symbols [sindex ++] = NULL;
11222
11223 if (acfg->data_outfile) {
11224 for (i = 0; i < MONO_AOT_TABLE_NUM; ++i)
11225 symbols [sindex ++] = NULL;
11226 } else {
11227 symbols [sindex ++] = "blob";
11228 symbols [sindex ++] = "class_name_table";
11229 symbols [sindex ++] = "class_info_offsets";
11230 symbols [sindex ++] = "method_info_offsets";
11231 symbols [sindex ++] = "ex_info_offsets";
11232 symbols [sindex ++] = "extra_method_info_offsets";
11233 symbols [sindex ++] = "extra_method_table";
11234 symbols [sindex ++] = "got_info_offsets";
11235 if (acfg->llvm)
11236 symbols [sindex ++] = "llvm_got_info_offsets";
11237 else
11238 symbols [sindex ++] = NULL;
11239 symbols [sindex ++] = "image_table";
11240 symbols [sindex ++] = "weak_field_indexes";
11241 }
11242
11243 symbols [sindex ++] = "mem_end";
11244 symbols [sindex ++] = "assembly_guid";
11245 symbols [sindex ++] = "runtime_version";
11246 if (acfg->num_trampoline_got_entries) {
11247 symbols [sindex ++] = "specific_trampolines";
11248 symbols [sindex ++] = "static_rgctx_trampolines";
11249 symbols [sindex ++] = "imt_trampolines";
11250 symbols [sindex ++] = "gsharedvt_arg_trampolines";
11251 symbols [sindex ++] = "ftnptr_arg_trampolines";
11252 symbols [sindex ++] = "unbox_arbitrary_trampolines";
11253 } else {
11254 symbols [sindex ++] = NULL;
11255 symbols [sindex ++] = NULL;
11256 symbols [sindex ++] = NULL;
11257 symbols [sindex ++] = NULL;
11258 symbols [sindex ++] = NULL;
11259 symbols [sindex ++] = NULL;
11260 }
11261 if (acfg->aot_opts.static_link) {
11262 symbols [sindex ++] = "globals";
11263 } else {
11264 symbols [sindex ++] = NULL;
11265 }
11266 symbols [sindex ++] = "assembly_name";
11267 symbols [sindex ++] = "plt";
11268 symbols [sindex ++] = "plt_end";
11269 symbols [sindex ++] = "unwind_info";
11270 if (!acfg->aot_opts.llvm_only) {
11271 symbols [sindex ++] = "unbox_trampolines";
11272 symbols [sindex ++] = "unbox_trampolines_end";
11273 symbols [sindex ++] = "unbox_trampoline_addresses";
11274 } else {
11275 symbols [sindex ++] = NULL;
11276 symbols [sindex ++] = NULL;
11277 symbols [sindex ++] = NULL;
11278 }
11279
11280 g_assert (sindex == MONO_AOT_FILE_INFO_NUM_SYMBOLS);
11281
11282 sprintf (symbol, "%smono_aot_file_info", acfg->user_symbol_prefix);
11283 emit_section_change (acfg, ".data", 0);
11284 emit_alignment (acfg, 8);
11285 emit_label (acfg, symbol);
11286 if (!acfg->aot_opts.static_link)
11287 emit_global (acfg, symbol, FALSE);
11288
11289 /* The data emitted here must match MonoAotFileInfo. */
11290
11291 emit_int32 (acfg, info->version);
11292 emit_int32 (acfg, info->dummy);
11293
11294 /*
11295 * We emit pointers to our data structures instead of emitting global symbols which
11296 * point to them, to reduce the number of globals, and because using globals leads to
11297 * various problems (i.e. arm/thumb).
11298 */
11299 for (i = 0; i < MONO_AOT_FILE_INFO_NUM_SYMBOLS; ++i)
11300 emit_pointer (acfg, symbols [i]);
11301
11302 emit_int32 (acfg, info->plt_got_offset_base);
11303 emit_int32 (acfg, info->got_size);
11304 emit_int32 (acfg, info->plt_size);
11305 emit_int32 (acfg, info->nmethods);
11306 emit_int32 (acfg, info->nextra_methods);
11307 emit_int32 (acfg, info->flags);
11308 emit_int32 (acfg, info->opts);
11309 emit_int32 (acfg, info->simd_opts);
11310 emit_int32 (acfg, info->gc_name_index);
11311 emit_int32 (acfg, info->num_rgctx_fetch_trampolines);
11312 emit_int32 (acfg, info->double_align);
11313 emit_int32 (acfg, info->long_align);
11314 emit_int32 (acfg, info->generic_tramp_num);
11315 emit_int32 (acfg, info->card_table_shift_bits);
11316 emit_int32 (acfg, info->card_table_mask);
11317 emit_int32 (acfg, info->tramp_page_size);
11318 emit_int32 (acfg, info->call_table_entry_size);
11319 emit_int32 (acfg, info->nshared_got_entries);
11320 emit_int32 (acfg, info->datafile_size);
11321 emit_int32 (acfg, 0);
11322 emit_int32 (acfg, 0);
11323
11324 for (i = 0; i < MONO_AOT_TABLE_NUM; ++i)
11325 emit_int32 (acfg, info->table_offsets [i]);
11326 for (i = 0; i < MONO_AOT_TRAMP_NUM; ++i)
11327 emit_int32 (acfg, info->num_trampolines [i]);
11328 for (i = 0; i < MONO_AOT_TRAMP_NUM; ++i)
11329 emit_int32 (acfg, info->trampoline_got_offset_base [i]);
11330 for (i = 0; i < MONO_AOT_TRAMP_NUM; ++i)
11331 emit_int32 (acfg, info->trampoline_size [i]);
11332 for (i = 0; i < MONO_AOT_TRAMP_NUM; ++i)
11333 emit_int32 (acfg, info->tramp_page_code_offsets [i]);
11334
11335 emit_bytes (acfg, info->aotid, 16);
11336
11337 if (acfg->aot_opts.static_link) {
11338 emit_global_inner (acfg, acfg->static_linking_symbol, FALSE);
11339 emit_alignment (acfg, sizeof (target_mgreg_t));
11340 emit_label (acfg, acfg->static_linking_symbol);
11341 emit_pointer_2 (acfg, acfg->user_symbol_prefix, "mono_aot_file_info");
11342 }
11343 }
11344
11345 /*
11346 * Emit a structure containing all the information not stored elsewhere.
11347 */
11348 static void
11349 emit_file_info (MonoAotCompile *acfg)
11350 {
11351 char *build_info;
11352 MonoAotFileInfo *info;
11353
11354 if (acfg->aot_opts.bind_to_runtime_version) {
11355 build_info = mono_get_runtime_build_info ();
11356 emit_string_symbol (acfg, "runtime_version", build_info);
11357 g_free (build_info);
11358 } else {
11359 emit_string_symbol (acfg, "runtime_version", "");
11360 }
11361
11362 emit_string_symbol (acfg, "assembly_guid" , acfg->image->guid);
11363
11364 /* Emit a string holding the assembly name */
11365 emit_string_symbol (acfg, "assembly_name", acfg->image->assembly->aname.name);
11366
11367 info = g_new0 (MonoAotFileInfo, 1);
11368 init_aot_file_info (acfg, info);
11369
11370 if (acfg->aot_opts.static_link) {
11371 char symbol [MAX_SYMBOL_SIZE];
11372 char *p;
11373
11374 /*
11375 * Emit a global symbol which can be passed by an embedding app to
11376 * mono_aot_register_module (). The symbol points to a pointer to the the file info
11377 * structure.
11378 */
11379 sprintf (symbol, "%smono_aot_module_%s_info", acfg->user_symbol_prefix, acfg->image->assembly->aname.name);
11380
11381 /* Get rid of characters which cannot occur in symbols */
11382 p = symbol;
11383 for (p = symbol; *p; ++p) {
11384 if (!(isalnum (*p) || *p == '_'))
11385 *p = '_';
11386 }
11387 acfg->static_linking_symbol = g_strdup (symbol);
11388 }
11389
11390 if (acfg->llvm)
11391 mono_llvm_emit_aot_file_info (info, acfg->has_jitted_code);
11392 else
11393 emit_aot_file_info (acfg, info);
11394 }
11395
11396 static void
11397 emit_blob (MonoAotCompile *acfg)
11398 {
11399 acfg->blob_closed = TRUE;
11400
11401 emit_aot_data (acfg, MONO_AOT_TABLE_BLOB, "blob", (guint8*)acfg->blob.data, acfg->blob.index);
11402 }
11403
11404 static void
11405 emit_objc_selectors (MonoAotCompile *acfg)
11406 {
11407 int i;
11408 char symbol [128];
11409
11410 if (!acfg->objc_selectors || acfg->objc_selectors->len == 0)
11411 return;
11412
11413 /*
11414 * From
11415 * cat > foo.m << EOF
11416 * void *ret ()
11417 * {
11418 * return @selector(print:);
11419 * }
11420 * EOF
11421 */
11422
11423 mono_img_writer_emit_unset_mode (acfg->w);
11424 g_assert (acfg->fp);
11425 fprintf (acfg->fp, ".section __DATA,__objc_selrefs,literal_pointers,no_dead_strip\n");
11426 fprintf (acfg->fp, ".align 3\n");
11427 for (i = 0; i < acfg->objc_selectors->len; ++i) {
11428 sprintf (symbol, "L_OBJC_SELECTOR_REFERENCES_%d", i);
11429 emit_label (acfg, symbol);
11430 sprintf (symbol, "L_OBJC_METH_VAR_NAME_%d", i);
11431 emit_pointer (acfg, symbol);
11432
11433 }
11434 fprintf (acfg->fp, ".section __TEXT,__cstring,cstring_literals\n");
11435 for (i = 0; i < acfg->objc_selectors->len; ++i) {
11436 fprintf (acfg->fp, "L_OBJC_METH_VAR_NAME_%d:\n", i);
11437 fprintf (acfg->fp, ".asciz \"%s\"\n", (char*)g_ptr_array_index (acfg->objc_selectors, i));
11438 }
11439
11440 fprintf (acfg->fp, ".section __DATA,__objc_imageinfo,regular,no_dead_strip\n");
11441 fprintf (acfg->fp, ".align 3\n");
11442 fprintf (acfg->fp, "L_OBJC_IMAGE_INFO:\n");
11443 fprintf (acfg->fp, ".long 0\n");
11444 fprintf (acfg->fp, ".long 16\n");
11445 }
11446
11447 static void
11448 emit_dwarf_info (MonoAotCompile *acfg)
11449 {
11450 #ifdef EMIT_DWARF_INFO
11451 int i;
11452 char symbol2 [128];
11453
11454 /* DIEs for methods */
11455 for (i = 0; i < acfg->nmethods; ++i) {
11456 MonoCompile *cfg = acfg->cfgs [i];
11457
11458 if (ignore_cfg (cfg))
11459 continue;
11460
11461 // FIXME: LLVM doesn't define .Lme_...
11462 if (cfg->compile_llvm)
11463 continue;
11464
11465 sprintf (symbol2, "%sme_%x", acfg->temp_prefix, i);
11466
11467 mono_dwarf_writer_emit_method (acfg->dwarf, cfg, cfg->method, cfg->asm_symbol, symbol2, cfg->asm_debug_symbol, (guint8 *)cfg->jit_info->code_start, cfg->jit_info->code_size, cfg->args, cfg->locals, cfg->unwind_ops, mono_debug_find_method (cfg->jit_info->d.method, mono_domain_get ()));
11468 }
11469 #endif
11470 }
11471
11472 #ifdef EMIT_WIN32_CODEVIEW_INFO
11473 typedef struct _CodeViewSubSectionData
11474 {
11475 gchar *start_section;
11476 gchar *end_section;
11477 gchar *start_section_record;
11478 gchar *end_section_record;
11479 int section_type;
11480 int section_record_type;
11481 int section_id;
11482 } CodeViewSubsectionData;
11483
11484 typedef struct _CodeViewCompilerVersion
11485 {
11486 gint major;
11487 gint minor;
11488 gint revision;
11489 gint patch;
11490 } CodeViewCompilerVersion;
11491
11492 #define CODEVIEW_SUBSECTION_SYMBOL_TYPE 0xF1
11493 #define CODEVIEW_SUBSECTION_RECORD_COMPILER_TYPE 0x113c
11494 #define CODEVIEW_SUBSECTION_RECORD_FUNCTION_START_TYPE 0x1147
11495 #define CODEVIEW_SUBSECTION_RECORD_FUNCTION_END_TYPE 0x114F
11496 #define CODEVIEW_CSHARP_LANGUAGE_TYPE 0x0A
11497 #define CODEVIEW_CPU_TYPE 0x0
11498 #define CODEVIEW_MAGIC_HEADER 0x4
11499
11500 static void
11501 codeview_clear_subsection_data (CodeViewSubsectionData *section_data)
11502 {
11503 g_free (section_data->start_section);
11504 g_free (section_data->end_section);
11505 g_free (section_data->start_section_record);
11506 g_free (section_data->end_section_record);
11507
11508 memset (section_data, 0, sizeof (CodeViewSubsectionData));
11509 }
11510
11511 static void
11512 codeview_parse_compiler_version (gchar *version, CodeViewCompilerVersion *data)
11513 {
11514 gint values[4] = { 0 };
11515 gint *value = values;
11516
11517 while (*version && (value < values + G_N_ELEMENTS (values))) {
11518 if (isdigit (*version)) {
11519 *value *= 10;
11520 *value += *version - '0';
11521 }
11522 else if (*version == '.') {
11523 value++;
11524 }
11525
11526 version++;
11527 }
11528
11529 data->major = values[0];
11530 data->minor = values[1];
11531 data->revision = values[2];
11532 data->patch = values[3];
11533 }
11534
11535 static void
11536 emit_codeview_start_subsection (MonoAotCompile *acfg, int section_id, int section_type, int section_record_type, CodeViewSubsectionData *section_data)
11537 {
11538 // Starting a new subsection, clear old data.
11539 codeview_clear_subsection_data (section_data);
11540
11541 // Keep subsection data.
11542 section_data->section_id = section_id;
11543 section_data->section_type = section_type;
11544 section_data->section_record_type = section_record_type;
11545
11546 // Allocate all labels used in subsection.
11547 section_data->start_section = g_strdup_printf ("%scvs_%d", acfg->temp_prefix, section_data->section_id);
11548 section_data->end_section = g_strdup_printf ("%scvse_%d", acfg->temp_prefix, section_data->section_id);
11549 section_data->start_section_record = g_strdup_printf ("%scvsr_%d", acfg->temp_prefix, section_data->section_id);
11550 section_data->end_section_record = g_strdup_printf ("%scvsre_%d", acfg->temp_prefix, section_data->section_id);
11551
11552 // Subsection type, function symbol.
11553 emit_int32 (acfg, section_data->section_type);
11554
11555 // Subsection size.
11556 emit_symbol_diff (acfg, section_data->end_section, section_data->start_section, 0);
11557 emit_label (acfg, section_data->start_section);
11558
11559 // Subsection record size.
11560 fprintf (acfg->fp, "\t.word %s - %s\n", section_data->end_section_record, section_data->start_section_record);
11561 emit_label (acfg, section_data->start_section_record);
11562
11563 // Subsection record type.
11564 emit_int16 (acfg, section_record_type);
11565 }
11566
11567 static void
11568 emit_codeview_end_subsection (MonoAotCompile *acfg, CodeViewSubsectionData *section_data, int *section_id)
11569 {
11570 g_assert (section_data->start_section);
11571 g_assert (section_data->end_section);
11572 g_assert (section_data->start_section_record);
11573 g_assert (section_data->end_section_record);
11574
11575 emit_label (acfg, section_data->end_section_record);
11576
11577 if (section_data->section_record_type == CODEVIEW_SUBSECTION_RECORD_FUNCTION_START_TYPE) {
11578 // Emit record length.
11579 emit_int16 (acfg, 2);
11580
11581 // Emit specific record type end.
11582 emit_int16 (acfg, CODEVIEW_SUBSECTION_RECORD_FUNCTION_END_TYPE);
11583 }
11584
11585 emit_label (acfg, section_data->end_section);
11586
11587 // Next subsection needs to be 4 byte aligned.
11588 emit_alignment (acfg, 4);
11589
11590 *section_id = section_data->section_id + 1;
11591 codeview_clear_subsection_data (section_data);
11592 }
11593
11594 inline static void
11595 emit_codeview_start_symbol_subsection (MonoAotCompile *acfg, int section_id, int section_record_type, CodeViewSubsectionData *section_data)
11596 {
11597 emit_codeview_start_subsection (acfg, section_id, CODEVIEW_SUBSECTION_SYMBOL_TYPE, section_record_type, section_data);
11598 }
11599
11600 inline static void
11601 emit_codeview_end_symbol_subsection (MonoAotCompile *acfg, CodeViewSubsectionData *section_data, int *section_id)
11602 {
11603 emit_codeview_end_subsection (acfg, section_data, section_id);
11604 }
11605
11606 static void
11607 emit_codeview_compiler_info (MonoAotCompile *acfg, int *section_id)
11608 {
11609 CodeViewSubsectionData section_data = { 0 };
11610 CodeViewCompilerVersion compiler_version = { 0 };
11611
11612 // Start new compiler record subsection.
11613 emit_codeview_start_symbol_subsection (acfg, *section_id, CODEVIEW_SUBSECTION_RECORD_COMPILER_TYPE, &section_data);
11614
11615 emit_int32 (acfg, CODEVIEW_CSHARP_LANGUAGE_TYPE);
11616 emit_int16 (acfg, CODEVIEW_CPU_TYPE);
11617
11618 // Get compiler version information.
11619 codeview_parse_compiler_version (VERSION, &compiler_version);
11620
11621 // Compiler frontend version, 4 digits.
11622 emit_int16 (acfg, compiler_version.major);
11623 emit_int16 (acfg, compiler_version.minor);
11624 emit_int16 (acfg, compiler_version.revision);
11625 emit_int16 (acfg, compiler_version.patch);
11626
11627 // Compiler backend version, 4 digits (currently same as frontend).
11628 emit_int16 (acfg, compiler_version.major);
11629 emit_int16 (acfg, compiler_version.minor);
11630 emit_int16 (acfg, compiler_version.revision);
11631 emit_int16 (acfg, compiler_version.patch);
11632
11633 // Compiler string.
11634 emit_string (acfg, "Mono AOT compiler");
11635
11636 // Done with section.
11637 emit_codeview_end_symbol_subsection (acfg, &section_data, section_id);
11638 }
11639
11640 static void
11641 emit_codeview_function_info (MonoAotCompile *acfg, MonoMethod *method, int *section_id, gchar *symbol, gchar *symbol_start, gchar *symbol_end)
11642 {
11643 CodeViewSubsectionData section_data = { 0 };
11644 gchar *full_method_name = NULL;
11645
11646 // Start new function record subsection.
11647 emit_codeview_start_symbol_subsection (acfg, *section_id, CODEVIEW_SUBSECTION_RECORD_FUNCTION_START_TYPE, &section_data);
11648
11649 // Emit 3 int 0 byte padding, currently not used.
11650 emit_zero_bytes (acfg, sizeof (int) * 3);
11651
11652 // Emit size of function.
11653 emit_symbol_diff (acfg, symbol_end, symbol_start, 0);
11654
11655 // Emit 3 int 0 byte padding, currently not used.
11656 emit_zero_bytes (acfg, sizeof (int) * 3);
11657
11658 // Emit reallocation info.
11659 fprintf (acfg->fp, "\t.secrel32 %s\n", symbol);
11660 fprintf (acfg->fp, "\t.secidx %s\n", symbol);
11661
11662 // Emit flag, currently not used.
11663 emit_zero_bytes (acfg, 1);
11664
11665 // Emit function name, exclude signature since it should be described by own metadata.
11666 full_method_name = mono_method_full_name (method, FALSE);
11667 emit_string (acfg, full_method_name ? full_method_name : "");
11668 g_free (full_method_name);
11669
11670 // Done with section.
11671 emit_codeview_end_symbol_subsection (acfg, &section_data, section_id);
11672 }
11673
11674 static void
11675 emit_codeview_info (MonoAotCompile *acfg)
11676 {
11677 int i;
11678 int section_id = 0;
11679 gchar symbol_buffer[MAX_SYMBOL_SIZE];
11680
11681 // Emit codeview debug info section
11682 emit_section_change (acfg, ".debug$S", 0);
11683
11684 // Emit magic header.
11685 emit_int32 (acfg, CODEVIEW_MAGIC_HEADER);
11686
11687 emit_codeview_compiler_info (acfg, &section_id);
11688
11689 for (i = 0; i < acfg->nmethods; ++i) {
11690 MonoCompile *cfg = acfg->cfgs[i];
11691
11692 if (!cfg || COMPILE_LLVM (cfg))
11693 continue;
11694
11695 int ret = g_snprintf (symbol_buffer, G_N_ELEMENTS (symbol_buffer), "%sme_%x", acfg->temp_prefix, i);
11696 if (ret > 0 && ret < G_N_ELEMENTS (symbol_buffer))
11697 emit_codeview_function_info (acfg, cfg->method, &section_id, cfg->asm_debug_symbol, cfg->asm_symbol, symbol_buffer);
11698 }
11699 }
11700 #else
11701 static void
11702 emit_codeview_info (MonoAotCompile *acfg)
11703 {
11704 }
11705 #endif /* EMIT_WIN32_CODEVIEW_INFO */
11706
11707 #ifdef EMIT_WIN32_UNWIND_INFO
11708 static UnwindInfoSectionCacheItem *
11709 get_cached_unwind_info_section_item_win32 (MonoAotCompile *acfg, const char *function_start, const char *function_end, GSList *unwind_ops)
11710 {
11711 UnwindInfoSectionCacheItem *item = NULL;
11712
11713 if (!acfg->unwind_info_section_cache)
11714 acfg->unwind_info_section_cache = g_list_alloc ();
11715
11716 PUNWIND_INFO unwind_info = mono_arch_unwindinfo_alloc_unwind_info (unwind_ops);
11717
11718 // Search for unwind info in cache.
11719 GList *list = acfg->unwind_info_section_cache;
11720 int list_size = 0;
11721 while (list && list->data) {
11722 item = (UnwindInfoSectionCacheItem*)list->data;
11723 if (!memcmp (unwind_info, item->unwind_info, sizeof (UNWIND_INFO))) {
11724 // Cache hit, return cached item.
11725 return item;
11726 }
11727 list = list->next;
11728 list_size++;
11729 }
11730
11731 // Add to cache.
11732 if (acfg->unwind_info_section_cache) {
11733 item = g_new0 (UnwindInfoSectionCacheItem, 1);
11734 if (item) {
11735 // Format .xdata section label for function, used to get unwind info address RVA.
11736 // Since the unwind info is similar for most functions, the symbol will be reused.
11737 item->xdata_section_label = g_strdup_printf ("%sunwind_%d", acfg->temp_prefix, list_size);
11738
11739 // Cache unwind info data, used when checking cache for matching unwind info. NOTE, cache takes
11740 //over ownership of unwind info.
11741 item->unwind_info = unwind_info;
11742
11743 // Needs to be emitted once.
11744 item->xdata_section_emitted = FALSE;
11745
11746 // Prepend to beginning of list to speed up inserts.
11747 acfg->unwind_info_section_cache = g_list_prepend (acfg->unwind_info_section_cache, (gpointer)item);
11748 }
11749 }
11750
11751 return item;
11752 }
11753
11754 static void
11755 free_unwind_info_section_cache_win32 (MonoAotCompile *acfg)
11756 {
11757 GList *list = acfg->unwind_info_section_cache;
11758
11759 while (list) {
11760 UnwindInfoSectionCacheItem *item = (UnwindInfoSectionCacheItem *)list->data;
11761 if (item) {
11762 g_free (item->xdata_section_label);
11763 mono_arch_unwindinfo_free_unwind_info (item->unwind_info);
11764
11765 g_free (item);
11766 list->data = NULL;
11767 }
11768
11769 list = list->next;
11770 }
11771
11772 g_list_free (acfg->unwind_info_section_cache);
11773 acfg->unwind_info_section_cache = NULL;
11774 }
11775
11776 static void
11777 emit_unwind_info_data_win32 (MonoAotCompile *acfg, PUNWIND_INFO unwind_info)
11778 {
11779 // Emit the unwind info struct.
11780 emit_bytes (acfg, (guint8*)unwind_info, sizeof (UNWIND_INFO) - (sizeof (UNWIND_CODE) * MONO_MAX_UNWIND_CODES));
11781
11782 // Emit all unwind codes encoded in unwind info struct.
11783 PUNWIND_CODE current_unwind_node = &unwind_info->UnwindCode[MONO_MAX_UNWIND_CODES - unwind_info->CountOfCodes];
11784 PUNWIND_CODE last_unwind_node = &unwind_info->UnwindCode[MONO_MAX_UNWIND_CODES];
11785
11786 while (current_unwind_node < last_unwind_node) {
11787 guint8 node_count = 0;
11788 switch (current_unwind_node->UnwindOp) {
11789 case UWOP_PUSH_NONVOL:
11790 case UWOP_ALLOC_SMALL:
11791 case UWOP_SET_FPREG:
11792 case UWOP_PUSH_MACHFRAME:
11793 node_count = 1;
11794 break;
11795 case UWOP_SAVE_NONVOL:
11796 case UWOP_SAVE_XMM128:
11797 node_count = 2;
11798 break;
11799 case UWOP_SAVE_NONVOL_FAR:
11800 case UWOP_SAVE_XMM128_FAR:
11801 node_count = 3;
11802 break;
11803 case UWOP_ALLOC_LARGE:
11804 if (current_unwind_node->OpInfo == 0)
11805 node_count = 2;
11806 else
11807 node_count = 3;
11808 break;
11809 default:
11810 g_assert (!"Unknown unwind opcode.");
11811 }
11812
11813 while (node_count > 0) {
11814 g_assert (current_unwind_node < last_unwind_node);
11815
11816 //Emit current node.
11817 emit_bytes (acfg, (guint8*)current_unwind_node, sizeof (UNWIND_CODE));
11818
11819 node_count--;
11820 current_unwind_node++;
11821 }
11822 }
11823 }
11824
11825 // Emit unwind info sections for each function. Unwind info on Windows x64 is emitted into two different sections.
11826 // .pdata includes the serialized DWORD aligned RVA's of function start, end and address of serialized
11827 // UNWIND_INFO struct emitted into .xdata, see https://msdn.microsoft.com/en-us/library/ft9x1kdx.aspx.
11828 // .xdata section includes DWORD aligned serialized version of UNWIND_INFO struct, https://msdn.microsoft.com/en-us/library/ddssxxy8.aspx.
11829 static void
11830 emit_unwind_info_sections_win32 (MonoAotCompile *acfg, const char *function_start, const char *function_end, GSList *unwind_ops)
11831 {
11832 char *pdata_section_label = NULL;
11833
11834 int temp_prefix_len = (acfg->temp_prefix != NULL) ? strlen (acfg->temp_prefix) : 0;
11835 if (strncmp (function_start, acfg->temp_prefix, temp_prefix_len)) {
11836 temp_prefix_len = 0;
11837 }
11838
11839 // Format .pdata section label for function.
11840 pdata_section_label = g_strdup_printf ("%spdata_%s", acfg->temp_prefix, function_start + temp_prefix_len);
11841
11842 UnwindInfoSectionCacheItem *cache_item = get_cached_unwind_info_section_item_win32 (acfg, function_start, function_end, unwind_ops);
11843 g_assert (cache_item && cache_item->xdata_section_label && cache_item->unwind_info);
11844
11845 // Emit .pdata section.
11846 emit_section_change (acfg, ".pdata", 0);
11847 emit_alignment (acfg, sizeof (DWORD));
11848 emit_label (acfg, pdata_section_label);
11849
11850 // Emit function start address RVA.
11851 fprintf (acfg->fp, "\t.long %s@IMGREL\n", function_start);
11852
11853 // Emit function end address RVA.
11854 fprintf (acfg->fp, "\t.long %s@IMGREL\n", function_end);
11855
11856 // Emit unwind info address RVA.
11857 fprintf (acfg->fp, "\t.long %s@IMGREL\n", cache_item->xdata_section_label);
11858
11859 if (!cache_item->xdata_section_emitted) {
11860 // Emit .xdata section.
11861 emit_section_change (acfg, ".xdata", 0);
11862 emit_alignment (acfg, sizeof (DWORD));
11863 emit_label (acfg, cache_item->xdata_section_label);
11864
11865 // Emit unwind info into .xdata section.
11866 emit_unwind_info_data_win32 (acfg, cache_item->unwind_info);
11867 cache_item->xdata_section_emitted = TRUE;
11868 }
11869
11870 g_free (pdata_section_label);
11871 }
11872 #endif
11873
11874 static gboolean
11875 should_emit_gsharedvt_method (MonoAotCompile *acfg, MonoMethod *method)
11876 {
11877 #ifdef TARGET_WASM
11878 if (acfg->image == mono_get_corlib () && !strcmp (m_class_get_name (method->klass), "Vector`1"))
11879 /* The SIMD fallback code in Vector<T> is very large, and not likely to be used */
11880 return FALSE;
11881 #endif
11882 if (acfg->image == mono_get_corlib () && !strcmp (m_class_get_name (method->klass), "Volatile"))
11883 /* Read<T>/Write<T> are not needed and cause JIT failures */
11884 return FALSE;
11885 return TRUE;
11886 }
11887
11888 static gboolean
11889 collect_methods (MonoAotCompile *acfg)
11890 {
11891 int mindex, i;
11892 MonoImage *image = acfg->image;
11893
11894 /* Collect methods */
11895 for (i = 0; i < image->tables [MONO_TABLE_METHOD].rows; ++i) {
11896 ERROR_DECL (error);
11897 MonoMethod *method;
11898 guint32 token = MONO_TOKEN_METHOD_DEF | (i + 1);
11899
11900 method = mono_get_method_checked (acfg->image, token, NULL, NULL, error);
11901
11902 if (!method) {
11903 aot_printerrf (acfg, "Failed to load method 0x%x from '%s' due to %s.\n", token, image->name, mono_error_get_message (error));
11904 aot_printerrf (acfg, "Run with MONO_LOG_LEVEL=debug for more information.\n");
11905 mono_error_cleanup (error);
11906 return FALSE;
11907 }
11908
11909 /* Load all methods eagerly to skip the slower lazy loading code */
11910 mono_class_setup_methods (method->klass);
11911
11912 if (mono_aot_mode_is_full (&acfg->aot_opts) && method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
11913 /* Compile the wrapper instead */
11914 /* We do this here instead of add_wrappers () because it is easy to do it here */
11915 MonoMethod *wrapper = mono_marshal_get_native_wrapper (method, TRUE, TRUE);
11916 method = wrapper;
11917 }
11918
11919 /* FIXME: Some mscorlib methods don't have debug info */
11920 /*
11921 if (acfg->aot_opts.soft_debug && !method->wrapper_type) {
11922 if (!((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
11923 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
11924 (method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
11925 (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))) {
11926 if (!mono_debug_lookup_method (method)) {
11927 fprintf (stderr, "Method %s has no debug info, probably the .mdb file for the assembly is missing.\n", mono_method_get_full_name (method));
11928 exit (1);
11929 }
11930 }
11931 }
11932 */
11933
11934 if (method->is_generic || mono_class_is_gtd (method->klass)) {
11935 /* Compile the ref shared version instead */
11936 method = mini_get_shared_method_full (method, SHARE_MODE_NONE, error);
11937 if (!method) {
11938 aot_printerrf (acfg, "Failed to load method 0x%x from '%s' due to %s.\n", token, image->name, mono_error_get_message (error));
11939 aot_printerrf (acfg, "Run with MONO_LOG_LEVEL=debug for more information.\n");
11940 mono_error_cleanup (error);
11941 return FALSE;
11942 }
11943 }
11944
11945 /* Since we add the normal methods first, their index will be equal to their zero based token index */
11946 add_method_with_index (acfg, method, i, FALSE);
11947 acfg->method_index ++;
11948 }
11949
11950 /* gsharedvt methods */
11951 for (mindex = 0; mindex < image->tables [MONO_TABLE_METHOD].rows; ++mindex) {
11952 ERROR_DECL (error);
11953 MonoMethod *method;
11954 guint32 token = MONO_TOKEN_METHOD_DEF | (mindex + 1);
11955
11956 if (!(acfg->opts & MONO_OPT_GSHAREDVT))
11957 continue;
11958
11959 method = mono_get_method_checked (acfg->image, token, NULL, NULL, error);
11960 report_loader_error (acfg, error, TRUE, "Failed to load method token 0x%x due to %s\n", i, mono_error_get_message (error));
11961
11962 if ((method->is_generic || mono_class_is_gtd (method->klass)) && should_emit_gsharedvt_method (acfg, method)) {
11963 MonoMethod *gshared;
11964
11965 gshared = mini_get_shared_method_full (method, SHARE_MODE_GSHAREDVT, error);
11966 mono_error_assert_ok (error);
11967
11968 add_extra_method (acfg, gshared);
11969 }
11970 }
11971
11972 if (mono_aot_mode_is_full (&acfg->aot_opts) || mono_aot_mode_is_hybrid (&acfg->aot_opts))
11973 add_generic_instances (acfg);
11974
11975 if (mono_aot_mode_is_full (&acfg->aot_opts))
11976 add_wrappers (acfg);
11977 return TRUE;
11978 }
11979
11980 static void
11981 compile_methods (MonoAotCompile *acfg)
11982 {
11983 int i, methods_len;
11984
11985 if (acfg->aot_opts.nthreads > 0) {
11986 GPtrArray *frag;
11987 int len, j;
11988 GPtrArray *threads;
11989 MonoThreadHandle *thread_handle;
11990 gpointer *user_data;
11991 MonoMethod **methods;
11992
11993 methods_len = acfg->methods->len;
11994
11995 len = acfg->methods->len / acfg->aot_opts.nthreads;
11996 g_assert (len > 0);
11997 /*
11998 * Partition the list of methods into fragments, and hand it to threads to
11999 * process.
12000 */
12001 threads = g_ptr_array_new ();
12002 /* Make a copy since acfg->methods is modified by compile_method () */
12003 methods = g_new0 (MonoMethod*, methods_len);
12004 //memcpy (methods, g_ptr_array_index (acfg->methods, 0), sizeof (MonoMethod*) * methods_len);
12005 for (i = 0; i < methods_len; ++i)
12006 methods [i] = (MonoMethod *)g_ptr_array_index (acfg->methods, i);
12007 i = 0;
12008 while (i < methods_len) {
12009 ERROR_DECL (error);
12010 MonoInternalThread *thread;
12011
12012 frag = g_ptr_array_new ();
12013 for (j = 0; j < len; ++j) {
12014 if (i < methods_len) {
12015 g_ptr_array_add (frag, methods [i]);
12016 i ++;
12017 }
12018 }
12019
12020 user_data = g_new0 (gpointer, 3);
12021 user_data [0] = acfg;
12022 user_data [1] = frag;
12023
12024 thread = mono_thread_create_internal (mono_domain_get (), (gpointer)compile_thread_main, user_data, MONO_THREAD_CREATE_FLAGS_NONE, error);
12025 mono_error_assert_ok (error);
12026
12027 thread_handle = mono_threads_open_thread_handle (thread->handle);
12028 g_ptr_array_add (threads, thread_handle);
12029 }
12030 g_free (methods);
12031
12032 for (i = 0; i < threads->len; ++i) {
12033 mono_thread_info_wait_one_handle ((MonoThreadHandle*)g_ptr_array_index (threads, i), MONO_INFINITE_WAIT, FALSE);
12034 mono_threads_close_thread_handle ((MonoThreadHandle*)g_ptr_array_index (threads, i));
12035 }
12036 } else {
12037 methods_len = 0;
12038 }
12039
12040 /* Compile methods added by compile_method () or all methods if nthreads == 0 */
12041 for (i = methods_len; i < acfg->methods->len; ++i) {
12042 /* This can add new methods to acfg->methods */
12043 compile_method (acfg, (MonoMethod *)g_ptr_array_index (acfg->methods, i));
12044 }
12045
12046 #ifdef ENABLE_LLVM
12047 if (acfg->llvm)
12048 mono_llvm_fixup_aot_module ();
12049 #endif
12050 }
12051
12052 static int
12053 compile_asm (MonoAotCompile *acfg)
12054 {
12055 char *command, *objfile;
12056 char *outfile_name, *tmp_outfile_name, *llvm_ofile;
12057 const char *tool_prefix = acfg->aot_opts.tool_prefix ? acfg->aot_opts.tool_prefix : "";
12058 char *ld_flags = acfg->aot_opts.ld_flags ? acfg->aot_opts.ld_flags : g_strdup("");
12059
12060 #ifdef TARGET_WIN32_MSVC
12061 #define AS_OPTIONS "--target=x86_64-pc-windows-msvc -c -x assembler"
12062 #elif defined(TARGET_AMD64) && !defined(TARGET_MACH)
12063 #define AS_OPTIONS "--64"
12064 #elif defined(TARGET_POWERPC64)
12065 #define AS_OPTIONS "-a64 -mppc64"
12066 #elif defined(sparc) && TARGET_SIZEOF_VOID_P == 8
12067 #define AS_OPTIONS "-xarch=v9"
12068 #elif defined(TARGET_X86) && defined(TARGET_MACH)
12069 #define AS_OPTIONS "-arch i386"
12070 #elif defined(TARGET_X86) && !defined(TARGET_MACH)
12071 #define AS_OPTIONS "--32"
12072 #else
12073 #define AS_OPTIONS ""
12074 #endif
12075
12076 #if defined(TARGET_OSX)
12077 #define AS_NAME "clang"
12078 #elif defined(TARGET_WIN32_MSVC)
12079 #define AS_NAME "clang.exe"
12080 #else
12081 #define AS_NAME "as"
12082 #endif
12083
12084 #ifdef TARGET_WIN32_MSVC
12085 #define AS_OBJECT_FILE_SUFFIX "obj"
12086 #else
12087 #define AS_OBJECT_FILE_SUFFIX "o"
12088 #endif
12089
12090 #if defined(sparc)
12091 #define LD_NAME "ld"
12092 #define LD_OPTIONS "-shared -G -Bsymbolic"
12093 #elif defined(__ppc__) && defined(TARGET_MACH)
12094 #define LD_NAME "gcc"
12095 #define LD_OPTIONS "-dynamiclib -Wl,-Bsymbolic"
12096 #elif defined(TARGET_AMD64) && defined(TARGET_MACH)
12097 #define LD_NAME "clang"
12098 #define LD_OPTIONS "--shared"
12099 #elif defined(TARGET_WIN32_MSVC)
12100 #define LD_NAME "link.exe"
12101 #define LD_OPTIONS "/DLL /MACHINE:X64 /NOLOGO /INCREMENTAL:NO"
12102 #define LD_DEBUG_OPTIONS LD_OPTIONS " /DEBUG"
12103 #elif defined(TARGET_WIN32) && !defined(TARGET_ANDROID)
12104 #define LD_NAME "gcc"
12105 #define LD_OPTIONS "-shared -Wl,-Bsymbolic"
12106 #elif defined(TARGET_X86) && defined(TARGET_MACH)
12107 #define LD_NAME "clang"
12108 #define LD_OPTIONS "-m32 -dynamiclib"
12109 #elif defined(TARGET_X86) && !defined(TARGET_MACH)
12110 #define LD_OPTIONS "-m elf_i386 -Bsymbolic"
12111 #elif defined(TARGET_ARM) && !defined(TARGET_ANDROID)
12112 #define LD_NAME "gcc"
12113 #define LD_OPTIONS "--shared -Wl,-Bsymbolic"
12114 #elif defined(TARGET_POWERPC64)
12115 #define LD_OPTIONS "-m elf64ppc -Bsymbolic"
12116 #endif
12117
12118 #ifndef LD_OPTIONS
12119 #define LD_OPTIONS "-Bsymbolic"
12120 #endif
12121
12122 if (acfg->aot_opts.asm_only) {
12123 aot_printf (acfg, "Output file: '%s'.\n", acfg->tmpfname);
12124 if (acfg->aot_opts.static_link)
12125 aot_printf (acfg, "Linking symbol: '%s'.\n", acfg->static_linking_symbol);
12126 if (acfg->llvm)
12127 aot_printf (acfg, "LLVM output file: '%s'.\n", acfg->llvm_sfile);
12128 return 0;
12129 }
12130
12131 if (acfg->aot_opts.static_link) {
12132 if (acfg->aot_opts.outfile)
12133 objfile = g_strdup_printf ("%s", acfg->aot_opts.outfile);
12134 else
12135 objfile = g_strdup_printf ("%s." AS_OBJECT_FILE_SUFFIX, acfg->image->name);
12136 } else {
12137 objfile = g_strdup_printf ("%s." AS_OBJECT_FILE_SUFFIX, acfg->tmpfname);
12138 }
12139
12140 #ifdef TARGET_OSX
12141 g_string_append (acfg->as_args, "-c -x assembler");
12142 #endif
12143
12144 command = g_strdup_printf ("\"%s%s\" %s %s -o %s %s", tool_prefix, AS_NAME, AS_OPTIONS,
12145 acfg->as_args ? acfg->as_args->str : "",
12146 wrap_path (objfile), wrap_path (acfg->tmpfname));
12147 aot_printf (acfg, "Executing the native assembler: %s\n", command);
12148 if (execute_system (command) != 0) {
12149 g_free (command);
12150 g_free (objfile);
12151 return 1;
12152 }
12153
12154 if (acfg->llvm && !acfg->llvm_owriter) {
12155 command = g_strdup_printf ("\"%s%s\" %s %s -o %s %s", tool_prefix, AS_NAME, AS_OPTIONS,
12156 acfg->as_args ? acfg->as_args->str : "",
12157 wrap_path (acfg->llvm_ofile), wrap_path (acfg->llvm_sfile));
12158 aot_printf (acfg, "Executing the native assembler: %s\n", command);
12159 if (execute_system (command) != 0) {
12160 g_free (command);
12161 g_free (objfile);
12162 return 1;
12163 }
12164 }
12165
12166 g_free (command);
12167
12168 if (acfg->aot_opts.static_link) {
12169 aot_printf (acfg, "Output file: '%s'.\n", objfile);
12170 aot_printf (acfg, "Linking symbol: '%s'.\n", acfg->static_linking_symbol);
12171 g_free (objfile);
12172 return 0;
12173 }
12174
12175 if (acfg->aot_opts.outfile)
12176 outfile_name = g_strdup_printf ("%s", acfg->aot_opts.outfile);
12177 else
12178 outfile_name = g_strdup_printf ("%s%s", acfg->image->name, MONO_SOLIB_EXT);
12179
12180 tmp_outfile_name = g_strdup_printf ("%s.tmp", outfile_name);
12181
12182 if (acfg->llvm) {
12183 llvm_ofile = g_strdup_printf ("\"%s\"", acfg->llvm_ofile);
12184 } else {
12185 llvm_ofile = g_strdup ("");
12186 }
12187
12188 /* replace the ; flags separators with spaces */
12189 g_strdelimit (ld_flags, ';', ' ');
12190
12191 if (acfg->aot_opts.llvm_only)
12192 ld_flags = g_strdup_printf ("%s %s", ld_flags, "-lstdc++");
12193
12194 #ifdef TARGET_WIN32_MSVC
12195 g_assert (tmp_outfile_name != NULL);
12196 g_assert (objfile != NULL);
12197 command = g_strdup_printf ("\"%s%s\" %s %s /OUT:%s %s %s", tool_prefix, LD_NAME,
12198 acfg->aot_opts.nodebug ? LD_OPTIONS : LD_DEBUG_OPTIONS, ld_flags, wrap_path (tmp_outfile_name), wrap_path (objfile), wrap_path (llvm_ofile));
12199 #elif defined(LD_NAME)
12200 command = g_strdup_printf ("%s%s %s -o %s %s %s %s", tool_prefix, LD_NAME, LD_OPTIONS,
12201 wrap_path (tmp_outfile_name), wrap_path (llvm_ofile),
12202 wrap_path (g_strdup_printf ("%s." AS_OBJECT_FILE_SUFFIX, acfg->tmpfname)), ld_flags);
12203 #else
12204 // Default (linux)
12205 if (acfg->aot_opts.tool_prefix) {
12206 /* Cross compiling */
12207 command = g_strdup_printf ("\"%sld\" %s -shared -o %s %s %s %s", tool_prefix, LD_OPTIONS,
12208 wrap_path (tmp_outfile_name), wrap_path (llvm_ofile),
12209 wrap_path (g_strdup_printf ("%s." AS_OBJECT_FILE_SUFFIX, acfg->tmpfname)), ld_flags);
12210 } else {
12211 char *args = g_strdup_printf ("%s -shared -o %s %s %s %s", LD_OPTIONS,
12212 wrap_path (tmp_outfile_name), wrap_path (llvm_ofile),
12213 wrap_path (g_strdup_printf ("%s." AS_OBJECT_FILE_SUFFIX, acfg->tmpfname)), ld_flags);
12214
12215 if (acfg->aot_opts.llvm_only) {
12216 command = g_strdup_printf ("%s %s", acfg->aot_opts.clangxx, args);
12217 } else {
12218 command = g_strdup_printf ("\"%sld\" %s", tool_prefix, args);
12219 }
12220 g_free (args);
12221 }
12222 #endif
12223 aot_printf (acfg, "Executing the native linker: %s\n", command);
12224 if (execute_system (command) != 0) {
12225 g_free (tmp_outfile_name);
12226 g_free (outfile_name);
12227 g_free (command);
12228 g_free (objfile);
12229 g_free (ld_flags);
12230 return 1;
12231 }
12232
12233 g_free (command);
12234
12235 /*com = g_strdup_printf ("strip --strip-unneeded %s%s", acfg->image->name, MONO_SOLIB_EXT);
12236 printf ("Stripping the binary: %s\n", com);
12237 execute_system (com);
12238 g_free (com);*/
12239
12240 #if defined(TARGET_ARM) && !defined(TARGET_MACH)
12241 /*
12242 * gas generates 'mapping symbols' each time code and data is mixed, which
12243 * happens a lot in emit_and_reloc_code (), so we need to get rid of them.
12244 */
12245 command = g_strdup_printf ("\"%sstrip\" --strip-symbol=\\$a --strip-symbol=\\$d %s", tool_prefix, wrap_path(tmp_outfile_name));
12246 aot_printf (acfg, "Stripping the binary: %s\n", command);
12247 if (execute_system (command) != 0) {
12248 g_free (tmp_outfile_name);
12249 g_free (outfile_name);
12250 g_free (command);
12251 g_free (objfile);
12252 return 1;
12253 }
12254 #endif
12255
12256 if (0 != rename (tmp_outfile_name, outfile_name)) {
12257 if (G_FILE_ERROR_EXIST == g_file_error_from_errno (errno)) {
12258 /* Since we are rebuilding the module we need to be able to replace any old copies. Remove old file and retry rename operation. */
12259 unlink (outfile_name);
12260 rename (tmp_outfile_name, outfile_name);
12261 }
12262 }
12263
12264 #if defined(TARGET_MACH)
12265 command = g_strdup_printf ("dsymutil \"%s\"", outfile_name);
12266 aot_printf (acfg, "Executing dsymutil: %s\n", command);
12267 if (execute_system (command) != 0) {
12268 return 1;
12269 }
12270 #endif
12271
12272 if (!acfg->aot_opts.save_temps)
12273 unlink (objfile);
12274
12275 g_free (tmp_outfile_name);
12276 g_free (outfile_name);
12277 g_free (objfile);
12278
12279 if (acfg->aot_opts.save_temps)
12280 aot_printf (acfg, "Retained input file.\n");
12281 else
12282 unlink (acfg->tmpfname);
12283
12284 return 0;
12285 }
12286
12287 static guint8
12288 profread_byte (FILE *infile)
12289 {
12290 guint8 i;
12291 int res;
12292
12293 res = fread (&i, 1, 1, infile);
12294 g_assert (res == 1);
12295 return i;
12296 }
12297
12298 static int
12299 profread_int (FILE *infile)
12300 {
12301 int i, res;
12302
12303 res = fread (&i, 4, 1, infile);
12304 g_assert (res == 1);
12305 return i;
12306 }
12307
12308 static char*
12309 profread_string (FILE *infile)
12310 {
12311 int len, res;
12312 char *pbuf;
12313
12314 len = profread_int (infile);
12315 pbuf = (char*)g_malloc (len + 1);
12316 res = fread (pbuf, 1, len, infile);
12317 g_assert (res == len);
12318 pbuf [len] = '\0';
12319 return pbuf;
12320 }
12321
12322 static void
12323 load_profile_file (MonoAotCompile *acfg, char *filename)
12324 {
12325 FILE *infile;
12326 char buf [1024];
12327 int res, len, version;
12328 char magic [32];
12329
12330 infile = fopen (filename, "rb");
12331 if (!infile) {
12332 fprintf (stderr, "Unable to open file '%s': %s.\n", filename, strerror (errno));
12333 exit (1);
12334 }
12335
12336 printf ("Using profile data file '%s'\n", filename);
12337
12338 sprintf (magic, AOT_PROFILER_MAGIC);
12339 len = strlen (magic);
12340 res = fread (buf, 1, len, infile);
12341 magic [len] = '\0';
12342 buf [len] = '\0';
12343 if ((res != len) || strcmp (buf, magic) != 0) {
12344 printf ("Profile file has wrong header: '%s'.\n", buf);
12345 fclose (infile);
12346 exit (1);
12347 }
12348 guint32 expected_version = (AOT_PROFILER_MAJOR_VERSION << 16) | AOT_PROFILER_MINOR_VERSION;
12349 version = profread_int (infile);
12350 if (version != expected_version) {
12351 printf ("Profile file has wrong version 0x%4x, expected 0x%4x.\n", version, expected_version);
12352 fclose (infile);
12353 exit (1);
12354 }
12355
12356 ProfileData *data = g_new0 (ProfileData, 1);
12357 data->images = g_hash_table_new (NULL, NULL);
12358 data->classes = g_hash_table_new (NULL, NULL);
12359 data->ginsts = g_hash_table_new (NULL, NULL);
12360 data->methods = g_hash_table_new (NULL, NULL);
12361
12362 while (TRUE) {
12363 int type = profread_byte (infile);
12364 int id = profread_int (infile);
12365
12366 if (type == AOTPROF_RECORD_NONE)
12367 break;
12368
12369 switch (type) {
12370 case AOTPROF_RECORD_IMAGE: {
12371 ImageProfileData *idata = g_new0 (ImageProfileData, 1);
12372 idata->name = profread_string (infile);
12373 char *mvid = profread_string (infile);
12374 g_free (mvid);
12375 g_hash_table_insert (data->images, GINT_TO_POINTER (id), idata);
12376 break;
12377 }
12378 case AOTPROF_RECORD_GINST: {
12379 int i;
12380 int len = profread_int (infile);
12381
12382 GInstProfileData *gdata = g_new0 (GInstProfileData, 1);
12383 gdata->argc = len;
12384 gdata->argv = g_new0 (ClassProfileData*, len);
12385
12386 for (i = 0; i < len; ++i) {
12387 int class_id = profread_int (infile);
12388
12389 gdata->argv [i] = (ClassProfileData*)g_hash_table_lookup (data->classes, GINT_TO_POINTER (class_id));
12390 g_assert (gdata->argv [i]);
12391 }
12392 g_hash_table_insert (data->ginsts, GINT_TO_POINTER (id), gdata);
12393 break;
12394 }
12395 case AOTPROF_RECORD_TYPE: {
12396 int type = profread_byte (infile);
12397
12398 switch (type) {
12399 case MONO_TYPE_CLASS: {
12400 int image_id = profread_int (infile);
12401 int ginst_id = profread_int (infile);
12402 char *class_name = profread_string (infile);
12403
12404 ImageProfileData *image = (ImageProfileData*)g_hash_table_lookup (data->images, GINT_TO_POINTER (image_id));
12405 g_assert (image);
12406
12407 char *p = strrchr (class_name, '.');
12408 g_assert (p);
12409 *p = '\0';
12410
12411 ClassProfileData *cdata = g_new0 (ClassProfileData, 1);
12412 cdata->image = image;
12413 cdata->ns = g_strdup (class_name);
12414 cdata->name = g_strdup (p + 1);
12415
12416 if (ginst_id != -1) {
12417 cdata->inst = (GInstProfileData*)g_hash_table_lookup (data->ginsts, GINT_TO_POINTER (ginst_id));
12418 g_assert (cdata->inst);
12419 }
12420 g_free (class_name);
12421
12422 g_hash_table_insert (data->classes, GINT_TO_POINTER (id), cdata);
12423 break;
12424 }
12425 #if 0
12426 case MONO_TYPE_SZARRAY: {
12427 int elem_id = profread_int (infile);
12428 // FIXME:
12429 break;
12430 }
12431 #endif
12432 default:
12433 g_assert_not_reached ();
12434 break;
12435 }
12436 break;
12437 }
12438 case AOTPROF_RECORD_METHOD: {
12439 int class_id = profread_int (infile);
12440 int ginst_id = profread_int (infile);
12441 int param_count = profread_int (infile);
12442 char *method_name = profread_string (infile);
12443 char *sig = profread_string (infile);
12444
12445 ClassProfileData *klass = (ClassProfileData*)g_hash_table_lookup (data->classes, GINT_TO_POINTER (class_id));
12446 g_assert (klass);
12447
12448 MethodProfileData *mdata = g_new0 (MethodProfileData, 1);
12449 mdata->id = id;
12450 mdata->klass = klass;
12451 mdata->name = method_name;
12452 mdata->signature = sig;
12453 mdata->param_count = param_count;
12454
12455 if (ginst_id != -1) {
12456 mdata->inst = (GInstProfileData*)g_hash_table_lookup (data->ginsts, GINT_TO_POINTER (ginst_id));
12457 g_assert (mdata->inst);
12458 }
12459 g_hash_table_insert (data->methods, GINT_TO_POINTER (id), mdata);
12460 break;
12461 }
12462 default:
12463 printf ("%d\n", type);
12464 g_assert_not_reached ();
12465 break;
12466 }
12467 }
12468
12469 fclose (infile);
12470 acfg->profile_data = g_list_append (acfg->profile_data, data);
12471 }
12472
12473 static void
12474 resolve_class (ClassProfileData *cdata);
12475
12476 static void
12477 resolve_ginst (GInstProfileData *inst_data)
12478 {
12479 int i;
12480
12481 if (inst_data->inst)
12482 return;
12483
12484 for (i = 0; i < inst_data->argc; ++i) {
12485 resolve_class (inst_data->argv [i]);
12486 if (!inst_data->argv [i]->klass)
12487 return;
12488 }
12489 MonoType **args = g_new0 (MonoType*, inst_data->argc);
12490 for (i = 0; i < inst_data->argc; ++i)
12491 args [i] = m_class_get_byval_arg (inst_data->argv [i]->klass);
12492
12493 inst_data->inst = mono_metadata_get_generic_inst (inst_data->argc, args);
12494 }
12495
12496 static void
12497 resolve_class (ClassProfileData *cdata)
12498 {
12499 ERROR_DECL (error);
12500 MonoClass *klass;
12501
12502 if (!cdata->image->image)
12503 return;
12504
12505 klass = mono_class_from_name_checked (cdata->image->image, cdata->ns, cdata->name, error);
12506 if (!klass) {
12507 //printf ("[%s] %s.%s\n", cdata->image->name, cdata->ns, cdata->name);
12508 return;
12509 }
12510 if (cdata->inst) {
12511 resolve_ginst (cdata->inst);
12512 if (!cdata->inst->inst)
12513 return;
12514 MonoGenericContext ctx;
12515
12516 memset (&ctx, 0, sizeof (ctx));
12517 ctx.class_inst = cdata->inst->inst;
12518 cdata->klass = mono_class_inflate_generic_class_checked (klass, &ctx, error);
12519 } else {
12520 cdata->klass = klass;
12521 }
12522 }
12523
12524 /*
12525 * Resolve the profile data to the corresponding loaded classes/methods etc. if possible.
12526 */
12527 static void
12528 resolve_profile_data (MonoAotCompile *acfg, ProfileData *data, MonoAssembly* current)
12529 {
12530 GHashTableIter iter;
12531 gpointer key, value;
12532 int i;
12533
12534 if (!data)
12535 return;
12536
12537 /* Images */
12538 GPtrArray *assemblies = mono_domain_get_assemblies (mono_get_root_domain (), FALSE);
12539 g_hash_table_iter_init (&iter, data->images);
12540 while (g_hash_table_iter_next (&iter, &key, &value)) {
12541 ImageProfileData *idata = (ImageProfileData*)value;
12542
12543 if (!strcmp (current->aname.name, idata->name)) {
12544 idata->image = current->image;
12545 break;
12546 }
12547
12548 for (i = 0; i < assemblies->len; ++i) {
12549 MonoAssembly *ass = (MonoAssembly*)g_ptr_array_index (assemblies, i);
12550
12551 if (!strcmp (ass->aname.name, idata->name)) {
12552 idata->image = ass->image;
12553 break;
12554 }
12555 }
12556 }
12557 g_ptr_array_free (assemblies, TRUE);
12558
12559 /* Classes */
12560 g_hash_table_iter_init (&iter, data->classes);
12561 while (g_hash_table_iter_next (&iter, &key, &value)) {
12562 ClassProfileData *cdata = (ClassProfileData*)value;
12563
12564 if (!cdata->image->image) {
12565 if (acfg->aot_opts.verbose)
12566 printf ("Unable to load class '%s.%s' because its image '%s' is not loaded.\n", cdata->ns, cdata->name, cdata->image->name);
12567 continue;
12568 }
12569
12570 resolve_class (cdata);
12571 /*
12572 if (cdata->klass)
12573 printf ("%s %s %s\n", cdata->ns, cdata->name, mono_class_full_name (cdata->klass));
12574 */
12575 }
12576
12577 /* Methods */
12578 g_hash_table_iter_init (&iter, data->methods);
12579 while (g_hash_table_iter_next (&iter, &key, &value)) {
12580 MethodProfileData *mdata = (MethodProfileData*)value;
12581 MonoClass *klass;
12582 MonoMethod *m;
12583 gpointer miter;
12584
12585 resolve_class (mdata->klass);
12586 klass = mdata->klass->klass;
12587 if (!klass) {
12588 if (acfg->aot_opts.verbose)
12589 printf ("Unable to load method '%s' because its class '%s.%s' is not loaded.\n", mdata->name, mdata->klass->ns, mdata->klass->name);
12590 continue;
12591 }
12592 miter = NULL;
12593 while ((m = mono_class_get_methods (klass, &miter))) {
12594 ERROR_DECL (error);
12595
12596 if (strcmp (m->name, mdata->name))
12597 continue;
12598 MonoMethodSignature *sig = mono_method_signature_internal (m);
12599 if (!sig)
12600 continue;
12601 if (sig->param_count != mdata->param_count)
12602 continue;
12603 if (mdata->inst) {
12604 resolve_ginst (mdata->inst);
12605 if (!mdata->inst->inst)
12606 continue;
12607 MonoGenericContext ctx;
12608
12609 memset (&ctx, 0, sizeof (ctx));
12610 ctx.method_inst = mdata->inst->inst;
12611
12612 m = mono_class_inflate_generic_method_checked (m, &ctx, error);
12613 if (!m)
12614 continue;
12615 sig = mono_method_signature_checked (m, error);
12616 if (!is_ok (error)) {
12617 mono_error_cleanup (error);
12618 continue;
12619 }
12620 }
12621 char *sig_str = mono_signature_full_name (sig);
12622 gboolean match = !strcmp (sig_str, mdata->signature);
12623 g_free (sig_str);
12624 if (!match)
12625
12626 continue;
12627 //printf ("%s\n", mono_method_full_name (m, 1));
12628 mdata->method = m;
12629 break;
12630 }
12631 if (!mdata->method) {
12632 if (acfg->aot_opts.verbose)
12633 printf ("Unable to load method '%s' from class '%s', not found.\n", mdata->name, mono_class_full_name (klass));
12634 }
12635 }
12636 }
12637
12638 static gboolean
12639 inst_references_image (MonoGenericInst *inst, MonoImage *image)
12640 {
12641 int i;
12642
12643 for (i = 0; i < inst->type_argc; ++i) {
12644 MonoClass *k = mono_class_from_mono_type_internal (inst->type_argv [i]);
12645 if (m_class_get_image (k) == image)
12646 return TRUE;
12647 if (mono_class_is_ginst (k)) {
12648 MonoGenericInst *kinst = mono_class_get_context (k)->class_inst;
12649 if (inst_references_image (kinst, image))
12650 return TRUE;
12651 }
12652 }
12653 return FALSE;
12654 }
12655
12656 static gboolean
12657 is_local_inst (MonoGenericInst *inst, MonoImage *image)
12658 {
12659 int i;
12660
12661 for (i = 0; i < inst->type_argc; ++i) {
12662 MonoClass *k = mono_class_from_mono_type_internal (inst->type_argv [i]);
12663 if (!MONO_TYPE_IS_PRIMITIVE (inst->type_argv [i]) && m_class_get_image (k) != image)
12664 return FALSE;
12665 }
12666 return TRUE;
12667 }
12668
12669 static void
12670 add_profile_instances (MonoAotCompile *acfg, ProfileData *data)
12671 {
12672 GHashTableIter iter;
12673 gpointer key, value;
12674 int count = 0;
12675
12676 if (!data)
12677 return;
12678
12679 if (acfg->aot_opts.profile_only) {
12680 /* Add methods referenced by the profile */
12681 g_hash_table_iter_init (&iter, data->methods);
12682 while (g_hash_table_iter_next (&iter, &key, &value)) {
12683 MethodProfileData *mdata = (MethodProfileData*)value;
12684 MonoMethod *m = mdata->method;
12685
12686 if (!m)
12687 continue;
12688 if (m->is_inflated)
12689 continue;
12690 add_extra_method (acfg, m);
12691 g_hash_table_insert (acfg->profile_methods, m, m);
12692 count ++;
12693 }
12694 }
12695
12696 /*
12697 * Add method instances 'related' to this assembly to the AOT image.
12698 */
12699 g_hash_table_iter_init (&iter, data->methods);
12700 while (g_hash_table_iter_next (&iter, &key, &value)) {
12701 MethodProfileData *mdata = (MethodProfileData*)value;
12702 MonoMethod *m = mdata->method;
12703 MonoGenericContext *ctx;
12704
12705 if (!m)
12706 continue;
12707 if (!m->is_inflated)
12708 continue;
12709
12710 ctx = mono_method_get_context (m);
12711 /* For simplicity, add instances which reference the assembly we are compiling */
12712 if (((ctx->class_inst && inst_references_image (ctx->class_inst, acfg->image)) ||
12713 (ctx->method_inst && inst_references_image (ctx->method_inst, acfg->image))) &&
12714 !mono_method_is_generic_sharable_full (m, FALSE, FALSE, FALSE)) {
12715 //printf ("%s\n", mono_method_full_name (m, TRUE));
12716 add_extra_method (acfg, m);
12717 count ++;
12718 } else if (m_class_get_image (m->klass) == acfg->image &&
12719 ((ctx->class_inst && is_local_inst (ctx->class_inst, acfg->image)) ||
12720 (ctx->method_inst && is_local_inst (ctx->method_inst, acfg->image))) &&
12721 !mono_method_is_generic_sharable_full (m, FALSE, FALSE, FALSE)) {
12722 /* Add instances where the gtd is in the assembly and its inflated with types from this assembly or corlib */
12723 //printf ("%s\n", mono_method_full_name (m, TRUE));
12724 add_extra_method (acfg, m);
12725 count ++;
12726 }
12727 /*
12728 * FIXME: We might skip some instances, for example:
12729 * Foo<Bar> won't be compiled when compiling Foo's assembly since it doesn't match the first case,
12730 * and it won't be compiled when compiling Bar's assembly if Foo's assembly is not loaded.
12731 */
12732 }
12733
12734 printf ("Added %d methods from profile.\n", count);
12735 }
12736
12737 static void
12738 init_got_info (GotInfo *info)
12739 {
12740 int i;
12741
12742 info->patch_to_got_offset = g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
12743 info->patch_to_got_offset_by_type = g_new0 (GHashTable*, MONO_PATCH_INFO_NUM);
12744 for (i = 0; i < MONO_PATCH_INFO_NUM; ++i)
12745 info->patch_to_got_offset_by_type [i] = g_hash_table_new (mono_patch_info_hash, mono_patch_info_equal);
12746 info->got_patches = g_ptr_array_new ();
12747 }
12748
12749 static MonoAotCompile*
12750 acfg_create (MonoAssembly *ass, guint32 opts)
12751 {
12752 MonoImage *image = ass->image;
12753 MonoAotCompile *acfg;
12754
12755 acfg = g_new0 (MonoAotCompile, 1);
12756 acfg->methods = g_ptr_array_new ();
12757 acfg->method_indexes = g_hash_table_new (NULL, NULL);
12758 acfg->method_depth = g_hash_table_new (NULL, NULL);
12759 acfg->plt_offset_to_entry = g_hash_table_new (NULL, NULL);
12760 acfg->patch_to_plt_entry = g_new0 (GHashTable*, MONO_PATCH_INFO_NUM);
12761 acfg->method_to_cfg = g_hash_table_new (NULL, NULL);
12762 acfg->token_info_hash = g_hash_table_new_full (NULL, NULL, NULL, NULL);
12763 acfg->method_to_pinvoke_import = g_hash_table_new_full (NULL, NULL, NULL, g_free);
12764 acfg->method_to_external_icall_symbol_name = g_hash_table_new_full (NULL, NULL, NULL, g_free);
12765 acfg->image_hash = g_hash_table_new (NULL, NULL);
12766 acfg->image_table = g_ptr_array_new ();
12767 acfg->globals = g_ptr_array_new ();
12768 acfg->image = image;
12769 acfg->opts = opts;
12770 /* TODO: Write out set of SIMD instructions used, rather than just those available */
12771 #ifndef MONO_CROSS_COMPILE
12772 acfg->simd_opts = mono_arch_cpu_enumerate_simd_versions ();
12773 #endif
12774 acfg->mempool = mono_mempool_new ();
12775 acfg->extra_methods = g_ptr_array_new ();
12776 acfg->unwind_info_offsets = g_hash_table_new (NULL, NULL);
12777 acfg->unwind_ops = g_ptr_array_new ();
12778 acfg->method_label_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
12779 acfg->method_order = g_ptr_array_new ();
12780 acfg->export_names = g_hash_table_new (NULL, NULL);
12781 acfg->klass_blob_hash = g_hash_table_new (NULL, NULL);
12782 acfg->method_blob_hash = g_hash_table_new (NULL, NULL);
12783 acfg->ginst_blob_hash = g_hash_table_new (mono_metadata_generic_inst_hash, mono_metadata_generic_inst_equal);
12784 acfg->plt_entry_debug_sym_cache = g_hash_table_new (g_str_hash, g_str_equal);
12785 acfg->gsharedvt_in_signatures = g_hash_table_new ((GHashFunc)mono_signature_hash, (GEqualFunc)mono_metadata_signature_equal);
12786 acfg->gsharedvt_out_signatures = g_hash_table_new ((GHashFunc)mono_signature_hash, (GEqualFunc)mono_metadata_signature_equal);
12787 acfg->profile_methods = g_hash_table_new (NULL, NULL);
12788 mono_os_mutex_init_recursive (&acfg->mutex);
12789
12790 init_got_info (&acfg->got_info);
12791 init_got_info (&acfg->llvm_got_info);
12792
12793 method_to_external_icall_symbol_name = acfg->method_to_external_icall_symbol_name;
12794 return acfg;
12795 }
12796
12797 static void
12798 got_info_free (GotInfo *info)
12799 {
12800 int i;
12801
12802 for (i = 0; i < MONO_PATCH_INFO_NUM; ++i)
12803 g_hash_table_destroy (info->patch_to_got_offset_by_type [i]);
12804 g_free (info->patch_to_got_offset_by_type);
12805 g_hash_table_destroy (info->patch_to_got_offset);
12806 g_ptr_array_free (info->got_patches, TRUE);
12807 }
12808
12809 static void
12810 acfg_free (MonoAotCompile *acfg)
12811 {
12812 int i;
12813
12814 mono_img_writer_destroy (acfg->w);
12815 for (i = 0; i < acfg->nmethods; ++i)
12816 if (acfg->cfgs [i])
12817 mono_destroy_compile (acfg->cfgs [i]);
12818
12819 g_free (acfg->cfgs);
12820
12821 g_free (acfg->static_linking_symbol);
12822 g_free (acfg->got_symbol);
12823 g_free (acfg->plt_symbol);
12824 g_ptr_array_free (acfg->methods, TRUE);
12825 g_ptr_array_free (acfg->image_table, TRUE);
12826 g_ptr_array_free (acfg->globals, TRUE);
12827 g_ptr_array_free (acfg->unwind_ops, TRUE);
12828 g_hash_table_destroy (acfg->method_indexes);
12829 g_hash_table_destroy (acfg->method_depth);
12830 g_hash_table_destroy (acfg->plt_offset_to_entry);
12831 for (i = 0; i < MONO_PATCH_INFO_NUM; ++i)
12832 g_hash_table_destroy (acfg->patch_to_plt_entry [i]);
12833 g_free (acfg->patch_to_plt_entry);
12834 g_hash_table_destroy (acfg->method_to_cfg);
12835 g_hash_table_destroy (acfg->token_info_hash);
12836 g_hash_table_destroy (acfg->method_to_pinvoke_import);
12837 g_hash_table_destroy (acfg->method_to_external_icall_symbol_name);
12838 g_hash_table_destroy (acfg->image_hash);
12839 g_hash_table_destroy (acfg->unwind_info_offsets);
12840 g_hash_table_destroy (acfg->method_label_hash);
12841 g_hash_table_destroy (acfg->typespec_classes);
12842 g_hash_table_destroy (acfg->export_names);
12843 g_hash_table_destroy (acfg->plt_entry_debug_sym_cache);
12844 g_hash_table_destroy (acfg->klass_blob_hash);
12845 g_hash_table_destroy (acfg->method_blob_hash);
12846 got_info_free (&acfg->got_info);
12847 got_info_free (&acfg->llvm_got_info);
12848 arch_free_unwind_info_section_cache (acfg);
12849 mono_mempool_destroy (acfg->mempool);
12850
12851 method_to_external_icall_symbol_name = NULL;
12852 g_free (acfg);
12853 }
12854
12855 #define WRAPPER(e,n) n,
12856 static const char* const
12857 wrapper_type_names [MONO_WRAPPER_NUM + 1] = {
12858 #include "mono/metadata/wrapper-types.h"
12859 NULL
12860 };
12861
12862 static G_GNUC_UNUSED const char*
12863 get_wrapper_type_name (int type)
12864 {
12865 return wrapper_type_names [type];
12866 }
12867
12868 //#define DUMP_PLT
12869 //#define DUMP_GOT
12870
12871 static void aot_dump (MonoAotCompile *acfg)
12872 {
12873 FILE *dumpfile;
12874 char * dumpname;
12875
12876 JsonWriter writer;
12877 mono_json_writer_init (&writer);
12878
12879 mono_json_writer_object_begin(&writer);
12880
12881 // Methods
12882 mono_json_writer_indent (&writer);
12883 mono_json_writer_object_key(&writer, "methods");
12884 mono_json_writer_array_begin (&writer);
12885
12886 int i;
12887 for (i = 0; i < acfg->nmethods; ++i) {
12888 MonoCompile *cfg;
12889 MonoMethod *method;
12890 MonoClass *klass;
12891
12892 cfg = acfg->cfgs [i];
12893 if (ignore_cfg (cfg))
12894 continue;
12895
12896 method = cfg->orig_method;
12897
12898 mono_json_writer_indent (&writer);
12899 mono_json_writer_object_begin(&writer);
12900
12901 mono_json_writer_indent (&writer);
12902 mono_json_writer_object_key(&writer, "name");
12903 mono_json_writer_printf (&writer, "\"%s\",\n", method->name);
12904
12905 mono_json_writer_indent (&writer);
12906 mono_json_writer_object_key(&writer, "signature");
12907 mono_json_writer_printf (&writer, "\"%s\",\n", mono_method_get_full_name (method));
12908
12909 mono_json_writer_indent (&writer);
12910 mono_json_writer_object_key(&writer, "code_size");
12911 mono_json_writer_printf (&writer, "\"%d\",\n", cfg->code_size);
12912
12913 klass = method->klass;
12914
12915 mono_json_writer_indent (&writer);
12916 mono_json_writer_object_key(&writer, "class");
12917 mono_json_writer_printf (&writer, "\"%s\",\n", m_class_get_name (klass));
12918
12919 mono_json_writer_indent (&writer);
12920 mono_json_writer_object_key(&writer, "namespace");
12921 mono_json_writer_printf (&writer, "\"%s\",\n", m_class_get_name_space (klass));
12922
12923 mono_json_writer_indent (&writer);
12924 mono_json_writer_object_key(&writer, "wrapper_type");
12925 mono_json_writer_printf (&writer, "\"%s\",\n", get_wrapper_type_name(method->wrapper_type));
12926
12927 mono_json_writer_indent_pop (&writer);
12928 mono_json_writer_indent (&writer);
12929 mono_json_writer_object_end (&writer);
12930 mono_json_writer_printf (&writer, ",\n");
12931 }
12932
12933 mono_json_writer_indent_pop (&writer);
12934 mono_json_writer_indent (&writer);
12935 mono_json_writer_array_end (&writer);
12936 mono_json_writer_printf (&writer, ",\n");
12937
12938 // PLT entries
12939 #ifdef DUMP_PLT
12940 mono_json_writer_indent_push (&writer);
12941 mono_json_writer_indent (&writer);
12942 mono_json_writer_object_key(&writer, "plt");
12943 mono_json_writer_array_begin (&writer);
12944
12945 for (i = 0; i < acfg->plt_offset; ++i) {
12946 MonoPltEntry *plt_entry = NULL;
12947 MonoJumpInfo *ji;
12948
12949 if (i == 0)
12950 /*
12951 * The first plt entry is unused.
12952 */
12953 continue;
12954
12955 plt_entry = g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
12956 ji = plt_entry->ji;
12957
12958 mono_json_writer_indent (&writer);
12959 mono_json_writer_printf (&writer, "{ ");
12960 mono_json_writer_object_key(&writer, "symbol");
12961 mono_json_writer_printf (&writer, "\"%s\" },\n", plt_entry->symbol);
12962 }
12963
12964 mono_json_writer_indent_pop (&writer);
12965 mono_json_writer_indent (&writer);
12966 mono_json_writer_array_end (&writer);
12967 mono_json_writer_printf (&writer, ",\n");
12968 #endif
12969
12970 // GOT entries
12971 #ifdef DUMP_GOT
12972 mono_json_writer_indent_push (&writer);
12973 mono_json_writer_indent (&writer);
12974 mono_json_writer_object_key(&writer, "got");
12975 mono_json_writer_array_begin (&writer);
12976
12977 mono_json_writer_indent_push (&writer);
12978 for (i = 0; i < acfg->got_info.got_patches->len; ++i) {
12979 MonoJumpInfo *ji = g_ptr_array_index (acfg->got_info.got_patches, i);
12980
12981 mono_json_writer_indent (&writer);
12982 mono_json_writer_printf (&writer, "{ ");
12983 mono_json_writer_object_key(&writer, "patch_name");
12984 mono_json_writer_printf (&writer, "\"%s\" },\n", get_patch_name (ji->type));
12985 }
12986
12987 mono_json_writer_indent_pop (&writer);
12988 mono_json_writer_indent (&writer);
12989 mono_json_writer_array_end (&writer);
12990 mono_json_writer_printf (&writer, ",\n");
12991 #endif
12992
12993 mono_json_writer_indent_pop (&writer);
12994 mono_json_writer_indent (&writer);
12995 mono_json_writer_object_end (&writer);
12996
12997 dumpname = g_strdup_printf ("%s.json", g_path_get_basename (acfg->image->name));
12998 dumpfile = fopen (dumpname, "w+");
12999 g_free (dumpname);
13000
13001 fprintf (dumpfile, "%s", writer.text->str);
13002 fclose (dumpfile);
13003
13004 mono_json_writer_destroy (&writer);
13005 }
13006
13007 static const MonoJitICallId preinited_jit_icalls [] = {
13008 MONO_JIT_ICALL_mini_llvm_init_method,
13009 MONO_JIT_ICALL_mini_llvm_init_gshared_method_this,
13010 MONO_JIT_ICALL_mini_llvm_init_gshared_method_mrgctx,
13011 MONO_JIT_ICALL_mini_llvm_init_gshared_method_vtable,
13012 MONO_JIT_ICALL_mini_llvmonly_throw_nullref_exception,
13013 MONO_JIT_ICALL_mono_llvm_throw_corlib_exception,
13014 MONO_JIT_ICALL_mono_threads_state_poll,
13015 MONO_JIT_ICALL_mini_llvmonly_init_vtable_slot,
13016 MONO_JIT_ICALL_mono_helper_ldstr_mscorlib,
13017 MONO_JIT_ICALL_mono_fill_method_rgctx,
13018 MONO_JIT_ICALL_mono_fill_class_rgctx
13019 };
13020
13021 static void
13022 add_preinit_slot (MonoAotCompile *acfg, MonoJumpInfo *ji)
13023 {
13024 if (!acfg->aot_opts.llvm_only)
13025 get_got_offset (acfg, FALSE, ji);
13026 get_got_offset (acfg, TRUE, ji);
13027 }
13028
13029 static void
13030 add_preinit_got_slots (MonoAotCompile *acfg)
13031 {
13032 MonoJumpInfo *ji;
13033 int i;
13034
13035 /*
13036 * Allocate the first few GOT entries to information which is needed frequently, or it is needed
13037 * during method initialization etc.
13038 */
13039
13040 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13041 ji->type = MONO_PATCH_INFO_IMAGE;
13042 ji->data.image = acfg->image;
13043 add_preinit_slot (acfg, ji);
13044
13045 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13046 ji->type = MONO_PATCH_INFO_MSCORLIB_GOT_ADDR;
13047 add_preinit_slot (acfg, ji);
13048
13049 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13050 ji->type = MONO_PATCH_INFO_GC_CARD_TABLE_ADDR;
13051 add_preinit_slot (acfg, ji);
13052
13053 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13054 ji->type = MONO_PATCH_INFO_GC_NURSERY_START;
13055 add_preinit_slot (acfg, ji);
13056
13057 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13058 ji->type = MONO_PATCH_INFO_AOT_MODULE;
13059 add_preinit_slot (acfg, ji);
13060
13061 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13062 ji->type = MONO_PATCH_INFO_GC_NURSERY_BITS;
13063 add_preinit_slot (acfg, ji);
13064
13065 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13066 ji->type = MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG;
13067 add_preinit_slot (acfg, ji);
13068
13069 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13070 ji->type = MONO_PATCH_INFO_GC_SAFE_POINT_FLAG;
13071 add_preinit_slot (acfg, ji);
13072
13073 if (!acfg->aot_opts.llvm_only) {
13074 for (i = 0; i < TLS_KEY_NUM; i++) {
13075 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13076 ji->type = MONO_PATCH_INFO_JIT_ICALL_ADDR_NOCALL;
13077 ji->data.jit_icall_id = mono_get_tls_key_to_jit_icall_id (i);
13078 add_preinit_slot (acfg, ji);
13079 }
13080 }
13081
13082 /* Called by native-to-managed wrappers on possibly unattached threads */
13083 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13084 ji->type = MONO_PATCH_INFO_JIT_ICALL_ADDR_NOCALL;
13085 ji->data.jit_icall_id = MONO_JIT_ICALL_mono_threads_attach_coop;
13086 add_preinit_slot (acfg, ji);
13087
13088 for (i = 0; i < G_N_ELEMENTS (preinited_jit_icalls); ++i) {
13089 ji = (MonoJumpInfo *)mono_mempool_alloc0 (acfg->mempool, sizeof (MonoJumpInfo));
13090 ji->type = MONO_PATCH_INFO_JIT_ICALL_ID;
13091 ji->data.jit_icall_id = preinited_jit_icalls [i];
13092 add_preinit_slot (acfg, ji);
13093 }
13094
13095 if (acfg->aot_opts.llvm_only)
13096 acfg->nshared_got_entries = acfg->llvm_got_offset;
13097 else
13098 acfg->nshared_got_entries = acfg->got_offset;
13099 g_assert (acfg->nshared_got_entries);
13100 }
13101
13102 static void
13103 mono_dedup_log_stats (MonoAotCompile *acfg)
13104 {
13105 GHashTableIter iter;
13106 g_assert (acfg->dedup_stats);
13107
13108 if (!acfg->dedup_emit_mode)
13109 return;
13110
13111 // If dedup_emit_mode, acfg is the dummy dedup module that consolidates
13112 // deduped modules
13113 g_hash_table_iter_init (&iter, acfg->method_to_cfg);
13114 MonoCompile *dcfg = NULL;
13115 MonoMethod *method = NULL;
13116
13117 size_t wrappers_size_saved = 0;
13118 size_t inflated_size_saved = 0;
13119 size_t copied_singles = 0;
13120 int wrappers_saved = 0;
13121 int instances_saved = 0;
13122 int copied = 0;
13123
13124 while (g_hash_table_iter_next (&iter, (gpointer *) &method, (gpointer *)&dcfg)) {
13125 gchar *dedup_name = mono_aot_get_mangled_method_name (method);
13126 guint count = GPOINTER_TO_UINT(g_hash_table_lookup (acfg->dedup_stats, dedup_name));
13127
13128 if (count == 0)
13129 continue;
13130
13131 if (acfg->dedup_emit_mode) {
13132 // Size *saved* is the size due to things not emitted.
13133 if (count < 2) {
13134 // Just moved, didn't save space / dedup
13135 copied ++;
13136 copied_singles += dcfg->code_len;
13137 } else if (method->wrapper_type != MONO_WRAPPER_NONE) {
13138 wrappers_saved ++;
13139 wrappers_size_saved += dcfg->code_len * (count - 1);
13140 } else {
13141 instances_saved ++;
13142 inflated_size_saved += dcfg->code_len * (count - 1);
13143 }
13144 }
13145 if (acfg->aot_opts.dedup) {
13146 if (method->wrapper_type != MONO_WRAPPER_NONE) {
13147 wrappers_saved ++;
13148 wrappers_size_saved += dcfg->code_len * count;
13149 } else {
13150 instances_saved ++;
13151 inflated_size_saved += dcfg->code_len * count;
13152 }
13153 }
13154 }
13155
13156 aot_printf (acfg, "Dedup Pass: Size Saved From Deduped Wrappers:\t%d methods, %zu bytes\n", wrappers_saved, wrappers_size_saved);
13157 aot_printf (acfg, "Dedup Pass: Size Saved From Inflated Methods:\t%d methods, %zu bytes\n", instances_saved, inflated_size_saved);
13158 if (acfg->dedup_emit_mode)
13159 aot_printf (acfg, "Dedup Pass: Size of Moved But Not Deduped (only 1 copy) Methods:\t%d methods, %zu bytes\n", copied, copied_singles);
13160
13161 g_hash_table_destroy (acfg->dedup_stats);
13162 acfg->dedup_stats = NULL;
13163 }
13164
13165 // Flush the cache to tell future calls what to skip
13166 static void
13167 mono_flush_method_cache (MonoAotCompile *acfg)
13168 {
13169 GHashTable *method_cache = acfg->dedup_cache;
13170 char *filename = g_strdup_printf ("%s.dedup", acfg->image->name);
13171 if (!acfg->dedup_cache_changed || !acfg->aot_opts.dedup) {
13172 g_free (filename);
13173 return;
13174 }
13175
13176 acfg->dedup_cache = NULL;
13177
13178 FILE *cache = fopen (filename, "w");
13179
13180 if (!cache)
13181 g_error ("Could not create cache at %s because of error: %s\n", filename, strerror (errno));
13182
13183 GHashTableIter iter;
13184 gchar *name = NULL;
13185 g_hash_table_iter_init (&iter, method_cache);
13186 gboolean cont = TRUE;
13187 while (cont && g_hash_table_iter_next (&iter, (gpointer *) &name, NULL)) {
13188 int res = fprintf (cache, "%s\n", name);
13189 cont = res >= 0;
13190 }
13191 // FIXME: don't assert if error when flushing
13192 g_assert (cont);
13193
13194 fclose (cache);
13195 g_free (filename);
13196
13197 // The keys are all in the imageset, nothing to free
13198 // Values are just pointers to memory owned elsewhere, or sentinels
13199 g_hash_table_destroy (method_cache);
13200 }
13201
13202 // Read in what has been emitted by previous invocations,
13203 // what can be skipped
13204 static void
13205 mono_read_method_cache (MonoAotCompile *acfg)
13206 {
13207 char *filename = g_strdup_printf ("%s.dedup", acfg->image->name);
13208 // Only do once, when dedup_cache is null
13209 if (acfg->dedup_cache)
13210 goto early_exit;
13211
13212 if (acfg->aot_opts.dedup_include || acfg->aot_opts.dedup)
13213 g_assert (acfg->dedup_stats);
13214
13215 // only in skip mode
13216 if (!acfg->aot_opts.dedup)
13217 goto early_exit;
13218
13219 g_assert (acfg->dedup_cache);
13220
13221 FILE *cache;
13222 cache = fopen (filename, "r");
13223 if (!cache)
13224 goto early_exit;
13225
13226 // Since we do pointer comparisons, and it can't be allocated at
13227 // the address 0x1 due to alignment, we use this as a sentinel
13228 gpointer other_acfg_sentinel;
13229 other_acfg_sentinel = GINT_TO_POINTER (0x1);
13230
13231 if (fseek (cache, 0L, SEEK_END))
13232 goto cleanup;
13233
13234 size_t fileLength;
13235 fileLength = ftell (cache);
13236 g_assert (fileLength > 0);
13237
13238 if (fseek (cache, 0L, SEEK_SET))
13239 goto cleanup;
13240
13241 // Avoid thousands of new malloc entries
13242 // FIXME: allocate into imageset, so we don't need to free.
13243 // put the other mangled names there too.
13244 char *bulk;
13245 bulk = g_malloc0 (fileLength * sizeof (char));
13246 size_t offset;
13247 offset = 0;
13248
13249 while (fgets (&bulk [offset], fileLength - offset, cache)) {
13250 // strip newline
13251 char *line = &bulk [offset];
13252 size_t len = strlen (line);
13253 if (len == 0)
13254 break;
13255
13256 if (len >= 0 && line [len] == '\n')
13257 line [len] = '\0';
13258 offset += strlen (line) + 1;
13259 g_assert (fileLength >= offset);
13260
13261 g_hash_table_insert (acfg->dedup_cache, line, other_acfg_sentinel);
13262 }
13263
13264 cleanup:
13265 fclose (cache);
13266
13267 early_exit:
13268 g_free (filename);
13269 return;
13270 }
13271
13272 typedef struct {
13273 GHashTable *cache;
13274 GHashTable *stats;
13275 gboolean emit_inflated_methods;
13276 MonoAssembly *inflated_assembly;
13277 } MonoAotState;
13278
13279 static MonoAotState *
13280 alloc_aot_state (void)
13281 {
13282 MonoAotState *state = g_malloc (sizeof (MonoAotState));
13283 // FIXME: Should this own the memory?
13284 state->cache = g_hash_table_new (g_str_hash, g_str_equal);
13285 state->stats = g_hash_table_new (g_str_hash, g_str_equal);
13286 // Start in "collect mode"
13287 state->emit_inflated_methods = FALSE;
13288 state->inflated_assembly = NULL;
13289 return state;
13290 }
13291
13292 static void
13293 free_aot_state (MonoAotState *astate)
13294 {
13295 g_hash_table_destroy (astate->cache);
13296 g_free (astate);
13297 }
13298
13299 static void
13300 mono_add_deferred_extra_methods (MonoAotCompile *acfg, MonoAotState *astate)
13301 {
13302 GHashTableIter iter;
13303 gchar *name = NULL;
13304 MonoMethod *method = NULL;
13305
13306 acfg->dedup_emit_mode = TRUE;
13307
13308 g_hash_table_iter_init (&iter, astate->cache);
13309 while (g_hash_table_iter_next (&iter, (gpointer *) &name, (gpointer *) &method)) {
13310 add_method_full (acfg, method, TRUE, 0);
13311 }
13312 return;
13313 }
13314
13315 static void
13316 mono_setup_dedup_state (MonoAotCompile *acfg, MonoAotState **global_aot_state, MonoAssembly *ass, MonoAotState **astate, gboolean *is_dedup_dummy)
13317 {
13318 if (!acfg->aot_opts.dedup_include && !acfg->aot_opts.dedup)
13319 return;
13320
13321 if (global_aot_state && *global_aot_state && acfg->aot_opts.dedup_include) {
13322 // Thread the state through when making the inflate pass
13323 *astate = *global_aot_state;
13324 }
13325
13326 if (!*astate) {
13327 *astate = alloc_aot_state ();
13328 *global_aot_state = *astate;
13329 }
13330
13331 acfg->dedup_cache = (*astate)->cache;
13332 acfg->dedup_stats = (*astate)->stats;
13333
13334 // fills out acfg->dedup_cache
13335 if (acfg->aot_opts.dedup)
13336 mono_read_method_cache (acfg);
13337
13338 if (!(*astate)->inflated_assembly && acfg->aot_opts.dedup_include) {
13339 gchar **asm_path = g_strsplit (ass->image->name, G_DIR_SEPARATOR_S, 0);
13340 gchar *asm_file = NULL;
13341
13342 // Get the last part of the path, the filename
13343 for (int i=0; asm_path [i] != NULL; i++)
13344 asm_file = asm_path [i];
13345
13346 if (!strcmp (acfg->aot_opts.dedup_include, asm_file)) {
13347 // Save
13348 *is_dedup_dummy = TRUE;
13349 (*astate)->inflated_assembly = ass;
13350 }
13351 g_strfreev (asm_path);
13352 } else if ((*astate)->inflated_assembly) {
13353 *is_dedup_dummy = (ass == (*astate)->inflated_assembly);
13354 }
13355 }
13356
13357 int
13358 mono_compile_deferred_assemblies (guint32 opts, const char *aot_options, gpointer **aot_state)
13359 {
13360 // create assembly, loop and add extra_methods
13361 // in add_generic_instances , rip out what's in that for loop
13362 // and apply that to this aot_state inside of mono_compile_assembly
13363 MonoAotState *astate;
13364 astate = *(MonoAotState **)aot_state;
13365 g_assert (astate);
13366
13367 // FIXME: allow suffixes?
13368 if (!astate->inflated_assembly) {
13369 const char* inflate = strstr (aot_options, "dedup-inflate");
13370 if (!inflate)
13371 return 0;
13372 else
13373 g_error ("Error: mono was not given an assembly with the provided inflate name\n");
13374 }
13375
13376 // Switch modes
13377 astate->emit_inflated_methods = TRUE;
13378
13379 int res = mono_compile_assembly (astate->inflated_assembly, opts, aot_options, aot_state);
13380
13381 *aot_state = NULL;
13382 free_aot_state (astate);
13383
13384 return res;
13385 }
13386
13387 #ifndef MONO_ARCH_HAVE_INTERP_ENTRY_TRAMPOLINE
13388 static MonoMethodSignature * const * const interp_in_static_sigs [] = {
13389 &mono_icall_sig_bool_ptr_int32_ptrref,
13390 &mono_icall_sig_bool_ptr_ptrref,
13391 &mono_icall_sig_int32_int32_ptrref,
13392 &mono_icall_sig_int32_int32_ptr_ptrref,
13393 &mono_icall_sig_int32_ptr_int32_ptr,
13394 &mono_icall_sig_int32_ptr_int32_ptrref,
13395 &mono_icall_sig_int32_ptr_ptrref,
13396 &mono_icall_sig_object_object_ptr_ptr_ptr,
13397 &mono_icall_sig_object,
13398 &mono_icall_sig_ptr_int32_ptrref,
13399 &mono_icall_sig_ptr_ptr_int32_ptr_ptr_ptrref,
13400 &mono_icall_sig_ptr_ptr_int32_ptr_ptrref,
13401 &mono_icall_sig_ptr_ptr_int32_ptrref,
13402 &mono_icall_sig_ptr_ptr_ptr_int32_ptrref,
13403 &mono_icall_sig_ptr_ptr_ptr_ptrref_ptrref,
13404 &mono_icall_sig_ptr_ptr_ptr_ptr_ptrref,
13405 &mono_icall_sig_ptr_ptr_ptr_ptrref,
13406 &mono_icall_sig_ptr_ptr_ptrref,
13407 &mono_icall_sig_ptr_ptr_uint32_ptrref,
13408 &mono_icall_sig_ptr_uint32_ptrref,
13409 &mono_icall_sig_void_object_ptr_ptr_ptr,
13410 &mono_icall_sig_void_ptr_ptr_int32_ptr_ptrref_ptr_ptrref,
13411 &mono_icall_sig_void_ptr_ptr_int32_ptr_ptrref,
13412 &mono_icall_sig_void_ptr_ptr_ptrref,
13413 &mono_icall_sig_void_ptr_ptrref,
13414 &mono_icall_sig_void_ptr,
13415 &mono_icall_sig_void_int32_ptrref,
13416 &mono_icall_sig_void_uint32_ptrref,
13417 &mono_icall_sig_void,
13418 };
13419 #else
13420 // Common signatures for which we use interp in wrappers even in fullaot + trampolines mode
13421 // for increased performance
13422 static MonoMethodSignature *const * const interp_in_static_common_sigs [] = {
13423 &mono_icall_sig_void,
13424 &mono_icall_sig_ptr,
13425 &mono_icall_sig_void_ptr,
13426 &mono_icall_sig_ptr_ptr,
13427 &mono_icall_sig_void_ptr_ptr,
13428 &mono_icall_sig_ptr_ptr_ptr,
13429 &mono_icall_sig_void_ptr_ptr_ptr,
13430 &mono_icall_sig_ptr_ptr_ptr_ptr,
13431 &mono_icall_sig_void_ptr_ptr_ptr_ptr,
13432 &mono_icall_sig_ptr_ptr_ptr_ptr_ptr,
13433 &mono_icall_sig_void_ptr_ptr_ptr_ptr_ptr,
13434 &mono_icall_sig_ptr_ptr_ptr_ptr_ptr_ptr,
13435 &mono_icall_sig_void_ptr_ptr_ptr_ptr_ptr_ptr,
13436 &mono_icall_sig_ptr_ptr_ptr_ptr_ptr_ptr_ptr,
13437 };
13438 #endif
13439
13440 static void
13441 add_interp_in_wrapper_for_sig (MonoAotCompile *acfg, MonoMethodSignature *sig)
13442 {
13443 MonoMethod *wrapper;
13444
13445 sig = mono_metadata_signature_dup_full (mono_get_corlib (), sig);
13446 sig->pinvoke = FALSE;
13447 wrapper = mini_get_interp_in_wrapper (sig);
13448 add_method (acfg, wrapper);
13449 }
13450
13451 int
13452 mono_compile_assembly (MonoAssembly *ass, guint32 opts, const char *aot_options, gpointer **global_aot_state)
13453 {
13454 MonoImage *image = ass->image;
13455 int res;
13456 MonoAotCompile *acfg;
13457 char *p;
13458 TV_DECLARE (atv);
13459 TV_DECLARE (btv);
13460
13461 acfg = acfg_create (ass, opts);
13462
13463 memset (&acfg->aot_opts, 0, sizeof (acfg->aot_opts));
13464 acfg->aot_opts.write_symbols = TRUE;
13465 acfg->aot_opts.ntrampolines = 4096;
13466 acfg->aot_opts.nrgctx_trampolines = 4096;
13467 acfg->aot_opts.nimt_trampolines = 512;
13468 acfg->aot_opts.nrgctx_fetch_trampolines = 128;
13469 acfg->aot_opts.ngsharedvt_arg_trampolines = 512;
13470 #ifdef MONO_ARCH_HAVE_FTNPTR_ARG_TRAMPOLINE
13471 acfg->aot_opts.nftnptr_arg_trampolines = 128;
13472 #endif
13473 acfg->aot_opts.nunbox_arbitrary_trampolines = 256;
13474 if (!acfg->aot_opts.llvm_path)
13475 acfg->aot_opts.llvm_path = g_strdup ("");
13476 acfg->aot_opts.temp_path = g_strdup ("");
13477 #ifdef MONOTOUCH
13478 acfg->aot_opts.use_trampolines_page = TRUE;
13479 #endif
13480 acfg->aot_opts.clangxx = g_strdup ("clang++");
13481
13482 mono_aot_parse_options (aot_options, &acfg->aot_opts);
13483
13484 // start dedup
13485 MonoAotState *astate = NULL;
13486 gboolean is_dedup_dummy = FALSE;
13487 mono_setup_dedup_state (acfg, (MonoAotState **) global_aot_state, ass, &astate, &is_dedup_dummy);
13488
13489 // Process later
13490 if (is_dedup_dummy && astate && !astate->emit_inflated_methods)
13491 return 0;
13492
13493 if (acfg->aot_opts.dedup_include && !is_dedup_dummy)
13494 acfg->dedup_collect_only = TRUE;
13495 // end dedup
13496
13497 if (acfg->aot_opts.logfile) {
13498 acfg->logfile = fopen (acfg->aot_opts.logfile, "a+");
13499 }
13500
13501 if (acfg->aot_opts.data_outfile) {
13502 acfg->data_outfile = fopen (acfg->aot_opts.data_outfile, "w+");
13503 if (!acfg->data_outfile) {
13504 aot_printerrf (acfg, "Unable to create file '%s': %s\n", acfg->aot_opts.data_outfile, strerror (errno));
13505 return 1;
13506 }
13507 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_SEPARATE_DATA);
13508 }
13509
13510 //acfg->aot_opts.print_skipped_methods = TRUE;
13511
13512 #if !defined(MONO_ARCH_GSHAREDVT_SUPPORTED)
13513 if (acfg->opts & MONO_OPT_GSHAREDVT) {
13514 aot_printerrf (acfg, "-O=gsharedvt not supported on this platform.\n");
13515 return 1;
13516 }
13517 if (acfg->aot_opts.llvm_only) {
13518 aot_printerrf (acfg, "--aot=llvmonly requires a runtime that supports gsharedvt.\n");
13519 return 1;
13520 }
13521 #else
13522 if (acfg->aot_opts.llvm_only || mono_aot_mode_is_full (&acfg->aot_opts) || mono_aot_mode_is_hybrid (&acfg->aot_opts))
13523 acfg->opts |= MONO_OPT_GSHAREDVT;
13524 #endif
13525
13526 #if !defined(ENABLE_LLVM)
13527 if (acfg->aot_opts.llvm_only) {
13528 aot_printerrf (acfg, "--aot=llvmonly requires a runtime compiled with llvm support.\n");
13529 return 1;
13530 }
13531 if (mono_use_llvm || acfg->aot_opts.llvm) {
13532 aot_printerrf (acfg, "--aot=llvm requires a runtime compiled with llvm support.\n");
13533 return 1;
13534 }
13535 #endif
13536
13537 if (acfg->opts & MONO_OPT_GSHAREDVT)
13538 mono_set_generic_sharing_vt_supported (TRUE);
13539
13540 if (!acfg->dedup_collect_only)
13541 aot_printf (acfg, "Mono Ahead of Time compiler - compiling assembly %s\n", image->name);
13542
13543 if (!acfg->aot_opts.deterministic)
13544 generate_aotid ((guint8*) &acfg->image->aotid);
13545
13546 char *aotid = mono_guid_to_string (acfg->image->aotid);
13547 if (!acfg->dedup_collect_only && !acfg->aot_opts.deterministic)
13548 aot_printf (acfg, "AOTID %s\n", aotid);
13549 g_free (aotid);
13550
13551 #ifndef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
13552 if (mono_aot_mode_is_full (&acfg->aot_opts)) {
13553 aot_printerrf (acfg, "--aot=full is not supported on this platform.\n");
13554 return 1;
13555 }
13556 #endif
13557
13558 if (acfg->aot_opts.direct_pinvoke && !acfg->aot_opts.static_link) {
13559 aot_printerrf (acfg, "The 'direct-pinvoke' AOT option also requires the 'static' AOT option.\n");
13560 return 1;
13561 }
13562
13563 if (acfg->aot_opts.static_link)
13564 acfg->aot_opts.asm_writer = TRUE;
13565
13566 if (acfg->aot_opts.soft_debug) {
13567 mini_debug_options.mdb_optimizations = TRUE;
13568 mini_debug_options.gen_sdb_seq_points = TRUE;
13569
13570 if (!mono_debug_enabled ()) {
13571 aot_printerrf (acfg, "The soft-debug AOT option requires the --debug option.\n");
13572 return 1;
13573 }
13574 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_DEBUG);
13575 }
13576
13577 if (acfg->aot_opts.try_llvm)
13578 acfg->aot_opts.llvm = mini_llvm_init ();
13579
13580 if (mono_use_llvm || acfg->aot_opts.llvm) {
13581 acfg->llvm = TRUE;
13582 acfg->aot_opts.asm_writer = TRUE;
13583 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_WITH_LLVM);
13584
13585 if (acfg->aot_opts.soft_debug) {
13586 aot_printerrf (acfg, "The 'soft-debug' option is not supported when compiling with LLVM.\n");
13587 return 1;
13588 }
13589
13590 mini_llvm_init ();
13591
13592 if (acfg->aot_opts.asm_only && !acfg->aot_opts.llvm_outfile) {
13593 aot_printerrf (acfg, "Compiling with LLVM and the asm-only option requires the llvm-outfile= option.\n");
13594 return 1;
13595 }
13596 }
13597
13598 if (mono_aot_mode_is_full (&acfg->aot_opts)) {
13599 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_FULL_AOT);
13600 acfg->is_full_aot = TRUE;
13601 }
13602
13603 if (mono_aot_mode_is_interp (&acfg->aot_opts)) {
13604 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_INTERP);
13605 acfg->is_full_aot = TRUE;
13606 }
13607
13608 if (mini_safepoints_enabled ())
13609 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_SAFEPOINTS);
13610
13611 // The methods in dedup-emit amodules must be available on runtime startup
13612 // Note: Only one such amodule can have this attribute
13613 if (astate && astate->emit_inflated_methods)
13614 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_EAGER_LOAD);
13615
13616
13617 if (acfg->aot_opts.instances_logfile_path) {
13618 acfg->instances_logfile = fopen (acfg->aot_opts.instances_logfile_path, "w");
13619 if (!acfg->instances_logfile) {
13620 aot_printerrf (acfg, "Unable to create logfile: '%s'.\n", acfg->aot_opts.instances_logfile_path);
13621 return 1;
13622 }
13623 }
13624
13625 if (acfg->aot_opts.profile_files) {
13626 GList *l;
13627
13628 for (l = acfg->aot_opts.profile_files; l; l = l->next) {
13629 load_profile_file (acfg, (char*)l->data);
13630 }
13631 }
13632
13633 if (!(mono_aot_mode_is_interp (&acfg->aot_opts) && !mono_aot_mode_is_full (&acfg->aot_opts))) {
13634 for (int method_index = 0; method_index < acfg->image->tables [MONO_TABLE_METHOD].rows; ++method_index)
13635 g_ptr_array_add (acfg->method_order,GUINT_TO_POINTER (method_index));
13636 }
13637
13638 acfg->num_trampolines [MONO_AOT_TRAMP_SPECIFIC] = mono_aot_mode_is_full (&acfg->aot_opts) ? acfg->aot_opts.ntrampolines : 0;
13639 #ifdef MONO_ARCH_GSHARED_SUPPORTED
13640 acfg->num_trampolines [MONO_AOT_TRAMP_STATIC_RGCTX] = mono_aot_mode_is_full (&acfg->aot_opts) ? acfg->aot_opts.nrgctx_trampolines : 0;
13641 #endif
13642 acfg->num_trampolines [MONO_AOT_TRAMP_IMT] = mono_aot_mode_is_full (&acfg->aot_opts) ? acfg->aot_opts.nimt_trampolines : 0;
13643 #ifdef MONO_ARCH_GSHAREDVT_SUPPORTED
13644 if (acfg->opts & MONO_OPT_GSHAREDVT)
13645 acfg->num_trampolines [MONO_AOT_TRAMP_GSHAREDVT_ARG] = mono_aot_mode_is_full (&acfg->aot_opts) ? acfg->aot_opts.ngsharedvt_arg_trampolines : 0;
13646 #endif
13647 #ifdef MONO_ARCH_HAVE_FTNPTR_ARG_TRAMPOLINE
13648 acfg->num_trampolines [MONO_AOT_TRAMP_FTNPTR_ARG] = mono_aot_mode_is_interp (&acfg->aot_opts) ? acfg->aot_opts.nftnptr_arg_trampolines : 0;
13649 #endif
13650 acfg->num_trampolines [MONO_AOT_TRAMP_UNBOX_ARBITRARY] = mono_aot_mode_is_interp (&acfg->aot_opts) && mono_aot_mode_is_full (&acfg->aot_opts) ? acfg->aot_opts.nunbox_arbitrary_trampolines : 0;
13651
13652 acfg->temp_prefix = mono_img_writer_get_temp_label_prefix (NULL);
13653
13654 arch_init (acfg);
13655
13656 if (mono_use_llvm || acfg->aot_opts.llvm) {
13657 /*
13658 * Emit all LLVM code into a separate assembly/object file and link with it
13659 * normally.
13660 */
13661 if (!acfg->aot_opts.asm_only && acfg->llvm_owriter_supported) {
13662 acfg->llvm_owriter = TRUE;
13663 } else if (acfg->aot_opts.llvm_outfile) {
13664 int len = strlen (acfg->aot_opts.llvm_outfile);
13665
13666 if (len >= 2 && acfg->aot_opts.llvm_outfile [len - 2] == '.' && acfg->aot_opts.llvm_outfile [len - 1] == 'o')
13667 acfg->llvm_owriter = TRUE;
13668 }
13669 }
13670
13671 if (acfg->llvm && acfg->thumb_mixed)
13672 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_LLVM_THUMB);
13673 if (acfg->aot_opts.llvm_only)
13674 acfg->flags = (MonoAotFileFlags)(acfg->flags | MONO_AOT_FILE_FLAG_LLVM_ONLY);
13675
13676 acfg->assembly_name_sym = g_strdup (acfg->image->assembly->aname.name);
13677 /* Get rid of characters which cannot occur in symbols */
13678 for (p = acfg->assembly_name_sym; *p; ++p) {
13679 if (!(isalnum (*p) || *p == '_'))
13680 *p = '_';
13681 }
13682
13683 acfg->global_prefix = g_strdup_printf ("mono_aot_%s", acfg->assembly_name_sym);
13684 acfg->plt_symbol = g_strdup_printf ("%s_plt", acfg->global_prefix);
13685 acfg->got_symbol = g_strdup_printf ("%s_got", acfg->global_prefix);
13686 if (acfg->llvm) {
13687 acfg->llvm_got_symbol = g_strdup_printf ("%s_llvm_got", acfg->global_prefix);
13688 acfg->llvm_eh_frame_symbol = g_strdup_printf ("%s_eh_frame", acfg->global_prefix);
13689 }
13690
13691 acfg->method_index = 1;
13692
13693 if (mono_aot_mode_is_full (&acfg->aot_opts) || mono_aot_mode_is_hybrid (&acfg->aot_opts))
13694 mono_set_partial_sharing_supported (TRUE);
13695
13696 if (!(mono_aot_mode_is_interp (&acfg->aot_opts) && !mono_aot_mode_is_full (&acfg->aot_opts))) {
13697 res = collect_methods (acfg);
13698 if (!res)
13699 return 1;
13700 }
13701
13702 // If we're emitting all of the inflated methods into a dummy
13703 // Assembly, then after extra_methods is set up, we're done
13704 // in this function.
13705 if (astate && astate->emit_inflated_methods)
13706 mono_add_deferred_extra_methods (acfg, astate);
13707
13708 {
13709 GList *l;
13710
13711 for (l = acfg->profile_data; l; l = l->next)
13712 resolve_profile_data (acfg, (ProfileData*)l->data, ass);
13713 for (l = acfg->profile_data; l; l = l->next)
13714 add_profile_instances (acfg, (ProfileData*)l->data);
13715 }
13716
13717 acfg->cfgs_size = acfg->methods->len + 32;
13718 acfg->cfgs = g_new0 (MonoCompile*, acfg->cfgs_size);
13719
13720 /* PLT offset 0 is reserved for the PLT trampoline */
13721 acfg->plt_offset = 1;
13722 add_preinit_got_slots (acfg);
13723
13724 current_acfg = acfg;
13725
13726 #ifdef ENABLE_LLVM
13727 if (acfg->llvm) {
13728 llvm_acfg = acfg;
13729 LLVMModuleFlags flags = (LLVMModuleFlags)0;
13730 #ifdef EMIT_DWARF_INFO
13731 flags = LLVM_MODULE_FLAG_DWARF;
13732 #endif
13733 #ifdef EMIT_WIN32_CODEVIEW_INFO
13734 flags = LLVM_MODULE_FLAG_CODEVIEW;
13735 #endif
13736 if (acfg->aot_opts.static_link)
13737 flags = (LLVMModuleFlags)(flags | LLVM_MODULE_FLAG_STATIC);
13738 if (acfg->aot_opts.llvm_only)
13739 flags = (LLVMModuleFlags)(flags | LLVM_MODULE_FLAG_LLVM_ONLY);
13740 if (acfg->aot_opts.interp)
13741 flags = (LLVMModuleFlags)(flags | LLVM_MODULE_FLAG_INTERP);
13742 mono_llvm_create_aot_module (acfg->image->assembly, acfg->global_prefix, acfg->nshared_got_entries, flags);
13743
13744 add_lazy_init_wrappers (acfg);
13745 add_method (acfg, mono_marshal_get_llvm_func_wrapper (LLVM_FUNC_WRAPPER_GC_POLL));
13746 }
13747 #endif
13748
13749 if (mono_aot_mode_is_interp (&acfg->aot_opts) && mono_is_corlib_image (acfg->image->assembly->image)) {
13750 MonoMethod *wrapper = mini_get_interp_lmf_wrapper ("mono_interp_to_native_trampoline", (gpointer) mono_interp_to_native_trampoline);
13751 add_method (acfg, wrapper);
13752
13753 wrapper = mini_get_interp_lmf_wrapper ("mono_interp_entry_from_trampoline", (gpointer) mono_interp_entry_from_trampoline);
13754 add_method (acfg, wrapper);
13755
13756 #ifndef MONO_ARCH_HAVE_INTERP_ENTRY_TRAMPOLINE
13757 for (int i = 0; i < G_N_ELEMENTS (interp_in_static_sigs); i++)
13758 add_interp_in_wrapper_for_sig (acfg, *interp_in_static_sigs [i]);
13759 #else
13760 for (int i = 0; i < G_N_ELEMENTS (interp_in_static_common_sigs); i++)
13761 add_interp_in_wrapper_for_sig (acfg, *interp_in_static_common_sigs [i]);
13762 #endif
13763
13764 /* required for mixed mode */
13765 if (strcmp (acfg->image->assembly->aname.name, "mscorlib") == 0) {
13766 add_gc_wrappers (acfg);
13767
13768 for (int i = 0; i < MONO_JIT_ICALL_count; ++i)
13769 add_jit_icall_wrapper (acfg, mono_find_jit_icall_info ((MonoJitICallId)i));
13770 }
13771 }
13772
13773 TV_GETTIME (atv);
13774
13775 compile_methods (acfg);
13776
13777 TV_GETTIME (btv);
13778
13779 acfg->stats.jit_time = TV_ELAPSED (atv, btv);
13780
13781 dedup_skip_methods (acfg);
13782
13783 if (acfg->aot_opts.dedup_include && !is_dedup_dummy)
13784 /* We only collected methods from this assembly */
13785 return 0;
13786
13787 current_acfg = NULL;
13788
13789 return emit_aot_image (acfg);
13790 }
13791
13792 static void
13793 print_stats (MonoAotCompile *acfg)
13794 {
13795 int i;
13796 gint64 all_sizes;
13797 char llvm_stats_msg [256];
13798
13799 if (acfg->llvm && !acfg->aot_opts.llvm_only)
13800 sprintf (llvm_stats_msg, ", LLVM: %d (%d%%)", acfg->stats.llvm_count, acfg->stats.mcount ? (acfg->stats.llvm_count * 100) / acfg->stats.mcount : 100);
13801 else
13802 strcpy (llvm_stats_msg, "");
13803
13804 all_sizes = acfg->stats.code_size + acfg->stats.method_info_size + acfg->stats.ex_info_size + acfg->stats.unwind_info_size + acfg->stats.class_info_size + acfg->stats.got_info_size + acfg->stats.offsets_size + acfg->stats.plt_size;
13805
13806 aot_printf (acfg, "Code: %d(%d%%) Info: %d(%d%%) Ex Info: %d(%d%%) Unwind Info: %d(%d%%) Class Info: %d(%d%%) PLT: %d(%d%%) GOT Info: %d(%d%%) Offsets: %d(%d%%) GOT: %d, BLOB: %d\n",
13807 (int)acfg->stats.code_size, (int)(acfg->stats.code_size * 100 / all_sizes),
13808 (int)acfg->stats.method_info_size, (int)(acfg->stats.method_info_size * 100 / all_sizes),
13809 (int)acfg->stats.ex_info_size, (int)(acfg->stats.ex_info_size * 100 / all_sizes),
13810 (int)acfg->stats.unwind_info_size, (int)(acfg->stats.unwind_info_size * 100 / all_sizes),
13811 (int)acfg->stats.class_info_size, (int)(acfg->stats.class_info_size * 100 / all_sizes),
13812 acfg->stats.plt_size ? (int)acfg->stats.plt_size : (int)acfg->plt_offset, acfg->stats.plt_size ? (int)(acfg->stats.plt_size * 100 / all_sizes) : 0,
13813 (int)acfg->stats.got_info_size, (int)(acfg->stats.got_info_size * 100 / all_sizes),
13814 (int)acfg->stats.offsets_size, (int)(acfg->stats.offsets_size * 100 / all_sizes),
13815 (int)(acfg->got_offset * sizeof (target_mgreg_t)),
13816 (int)acfg->stats.blob_size);
13817 aot_printf (acfg, "Compiled: %d/%d (%d%%)%s, No GOT slots: %d (%d%%), Direct calls: %d (%d%%)\n",
13818 acfg->stats.ccount, acfg->stats.mcount, acfg->stats.mcount ? (acfg->stats.ccount * 100) / acfg->stats.mcount : 100,
13819 llvm_stats_msg,
13820 acfg->stats.methods_without_got_slots, acfg->stats.mcount ? (acfg->stats.methods_without_got_slots * 100) / acfg->stats.mcount : 100,
13821 acfg->stats.direct_calls, acfg->stats.all_calls ? (acfg->stats.direct_calls * 100) / acfg->stats.all_calls : 100);
13822 if (acfg->stats.genericcount)
13823 aot_printf (acfg, "%d methods failed gsharing (%d%%)\n", acfg->stats.genericcount, acfg->stats.mcount ? (acfg->stats.genericcount * 100) / acfg->stats.mcount : 100);
13824 if (acfg->stats.abscount)
13825 aot_printf (acfg, "%d methods contain absolute addresses (%d%%)\n", acfg->stats.abscount, acfg->stats.mcount ? (acfg->stats.abscount * 100) / acfg->stats.mcount : 100);
13826 if (acfg->stats.lmfcount)
13827 aot_printf (acfg, "%d methods contain lmf pointers (%d%%)\n", acfg->stats.lmfcount, acfg->stats.mcount ? (acfg->stats.lmfcount * 100) / acfg->stats.mcount : 100);
13828 if (acfg->stats.ocount)
13829 aot_printf (acfg, "%d methods have other problems (%d%%)\n", acfg->stats.ocount, acfg->stats.mcount ? (acfg->stats.ocount * 100) / acfg->stats.mcount : 100);
13830
13831 aot_printf (acfg, "GOT slot distribution:\n");
13832 int nslots = 0;
13833 int size = 0;
13834 for (i = 0; i < MONO_PATCH_INFO_NUM; ++i) {
13835 nslots += acfg->stats.got_slot_types [i];
13836 size += acfg->stats.got_slot_info_sizes [i];
13837 if (acfg->stats.got_slot_types [i])
13838 aot_printf (acfg, "\t%s: %d (%d)\n", get_patch_name (i), acfg->stats.got_slot_types [i], acfg->stats.got_slot_info_sizes [i]);
13839 }
13840 aot_printf (acfg, "GOT SLOTS: %d, INFO SIZE: %d\n", nslots, size);
13841
13842 aot_printf (acfg, "\nEncoding stats:\n");
13843 aot_printf (acfg, "\tMethod ref: %d (%dk)\n", acfg->stats.method_ref_count, acfg->stats.method_ref_size / 1024);
13844 aot_printf (acfg, "\tClass ref: %d (%dk)\n", acfg->stats.class_ref_count, acfg->stats.class_ref_size / 1024);
13845 aot_printf (acfg, "\tGinst: %d (%dk)\n", acfg->stats.ginst_count, acfg->stats.ginst_size / 1024);
13846
13847 aot_printf (acfg, "\nMethod stats:\n");
13848 aot_printf (acfg, "\tNormal: %d\n", acfg->stats.method_categories [METHOD_CAT_NORMAL]);
13849 aot_printf (acfg, "\tInstance: %d\n", acfg->stats.method_categories [METHOD_CAT_INST]);
13850 aot_printf (acfg, "\tGSharedvt: %d\n", acfg->stats.method_categories [METHOD_CAT_GSHAREDVT]);
13851 aot_printf (acfg, "\tWrapper: %d\n", acfg->stats.method_categories [METHOD_CAT_WRAPPER]);
13852
13853 if (acfg->aot_opts.dedup || acfg->dedup_emit_mode)
13854 mono_dedup_log_stats (acfg);
13855 }
13856
13857 static void
13858 create_depfile (MonoAotCompile *acfg)
13859 {
13860 FILE *depfile;
13861
13862 // FIXME: Support other configurations
13863 g_assert (acfg->aot_opts.llvm_only && acfg->aot_opts.asm_only && acfg->aot_opts.llvm_outfile);
13864
13865 depfile = fopen (acfg->aot_opts.depfile, "w");
13866 g_assert (depfile);
13867
13868 int ntargets = 1;
13869 char **targets = g_new0 (char*, ntargets);
13870 targets [0] = acfg->aot_opts.llvm_outfile;
13871 for (int tindex = 0; tindex < ntargets; ++tindex) {
13872 fprintf (depfile, "%s: ", targets [tindex]);
13873 for (int i = 0; i < acfg->image_table->len; i++) {
13874 MonoImage *image = (MonoImage*)g_ptr_array_index (acfg->image_table, i);
13875 fprintf (depfile, " %s", image->filename);
13876 }
13877 fprintf (depfile, "\n");
13878 }
13879 g_free (targets);
13880 fclose (depfile);
13881 }
13882
13883 static int
13884 emit_aot_image (MonoAotCompile *acfg)
13885 {
13886 int i, res;
13887 TV_DECLARE (atv);
13888 TV_DECLARE (btv);
13889
13890 TV_GETTIME (atv);
13891
13892 #ifdef ENABLE_LLVM
13893 if (acfg->llvm) {
13894 if (acfg->aot_opts.asm_only) {
13895 if (acfg->aot_opts.outfile) {
13896 acfg->tmpfname = g_strdup_printf ("%s", acfg->aot_opts.outfile);
13897 acfg->tmpbasename = g_strdup (acfg->tmpfname);
13898 } else {
13899 acfg->tmpbasename = g_strdup_printf ("%s", acfg->image->name);
13900 acfg->tmpfname = g_strdup_printf ("%s.s", acfg->tmpbasename);
13901 }
13902 g_assert (acfg->aot_opts.llvm_outfile);
13903 acfg->llvm_sfile = g_strdup (acfg->aot_opts.llvm_outfile);
13904 if (acfg->llvm_owriter)
13905 acfg->llvm_ofile = g_strdup (acfg->aot_opts.llvm_outfile);
13906 else
13907 acfg->llvm_sfile = g_strdup (acfg->aot_opts.llvm_outfile);
13908 } else {
13909 gchar *temp_path;
13910 if (strcmp (acfg->aot_opts.temp_path, "") != 0) {
13911 temp_path = g_strdup (acfg->aot_opts.temp_path);
13912 } else {
13913 temp_path = g_mkdtemp (g_strdup ("mono_aot_XXXXXX"));
13914 g_assertf (temp_path, "mkdtemp failed, error = (%d) %s", errno, g_strerror (errno));
13915 acfg->temp_dir_to_delete = g_strdup (temp_path);
13916 }
13917
13918 acfg->tmpbasename = g_build_filename (temp_path, "temp", (const char*)NULL);
13919 acfg->tmpfname = g_strdup_printf ("%s.s", acfg->tmpbasename);
13920 acfg->llvm_sfile = g_strdup_printf ("%s-llvm.s", acfg->tmpbasename);
13921 acfg->llvm_ofile = g_strdup_printf ("%s-llvm." AS_OBJECT_FILE_SUFFIX, acfg->tmpbasename);
13922
13923 g_free (temp_path);
13924 }
13925 }
13926 #endif
13927
13928 if (acfg->aot_opts.asm_only && !acfg->aot_opts.llvm_only) {
13929 if (acfg->aot_opts.outfile)
13930 acfg->tmpfname = g_strdup_printf ("%s", acfg->aot_opts.outfile);
13931 else
13932 acfg->tmpfname = g_strdup_printf ("%s.s", acfg->image->name);
13933 acfg->fp = fopen (acfg->tmpfname, "w+");
13934 } else {
13935 if (strcmp (acfg->aot_opts.temp_path, "") == 0) {
13936 int i = g_file_open_tmp ("mono_aot_XXXXXX", &acfg->tmpfname, NULL);
13937 acfg->fp = fdopen (i, "w+");
13938 } else {
13939 acfg->tmpbasename = g_build_filename (acfg->aot_opts.temp_path, "temp", (const char*)NULL);
13940 acfg->tmpfname = g_strdup_printf ("%s.s", acfg->tmpbasename);
13941 acfg->fp = fopen (acfg->tmpfname, "w+");
13942 }
13943 }
13944 if (acfg->fp == 0 && !acfg->aot_opts.llvm_only) {
13945 aot_printerrf (acfg, "Unable to open file '%s': %s\n", acfg->tmpfname, strerror (errno));
13946 return 1;
13947 }
13948 if (acfg->fp)
13949 acfg->w = mono_img_writer_create (acfg->fp, FALSE);
13950
13951 /* Compute symbols for methods */
13952 for (i = 0; i < acfg->nmethods; ++i) {
13953 if (acfg->cfgs [i]) {
13954 MonoCompile *cfg = acfg->cfgs [i];
13955 int method_index = get_method_index (acfg, cfg->orig_method);
13956
13957 if (cfg->asm_symbol) {
13958 // Set by method emitter in backend
13959 if (acfg->llvm_label_prefix) {
13960 char *old_symbol = cfg->asm_symbol;
13961 cfg->asm_symbol = g_strdup_printf ("%s%s", acfg->llvm_label_prefix, cfg->asm_symbol);
13962 g_free (old_symbol);
13963 }
13964 } else if (COMPILE_LLVM (cfg)) {
13965 cfg->asm_symbol = g_strdup_printf ("%s%s", acfg->llvm_label_prefix, cfg->llvm_method_name);
13966 } else if (acfg->global_symbols || acfg->llvm) {
13967 cfg->asm_symbol = get_debug_sym (cfg->orig_method, "", acfg->method_label_hash);
13968 } else {
13969 cfg->asm_symbol = g_strdup_printf ("%s%sm_%x", acfg->temp_prefix, acfg->llvm_label_prefix, method_index);
13970 }
13971 cfg->asm_debug_symbol = cfg->asm_symbol;
13972 }
13973 }
13974
13975 if (acfg->aot_opts.dwarf_debug && acfg->aot_opts.gnu_asm) {
13976 /*
13977 * CLANG supports GAS .file/.loc directives, so emit line number information this way
13978 */
13979 acfg->gas_line_numbers = TRUE;
13980 }
13981
13982 #ifdef EMIT_DWARF_INFO
13983 if ((!acfg->aot_opts.nodebug || acfg->aot_opts.dwarf_debug) && acfg->has_jitted_code) {
13984 if (acfg->aot_opts.dwarf_debug && !mono_debug_enabled ()) {
13985 aot_printerrf (acfg, "The dwarf AOT option requires the --debug option.\n");
13986 return 1;
13987 }
13988 acfg->dwarf = mono_dwarf_writer_create (acfg->w, NULL, 0, !acfg->gas_line_numbers);
13989 }
13990 #endif /* EMIT_DWARF_INFO */
13991
13992 if (acfg->w)
13993 mono_img_writer_emit_start (acfg->w);
13994
13995 if (acfg->dwarf)
13996 mono_dwarf_writer_emit_base_info (acfg->dwarf, g_path_get_basename (acfg->image->name), mono_unwind_get_cie_program ());
13997
13998 if (acfg->aot_opts.dedup)
13999 mono_flush_method_cache (acfg);
14000
14001 emit_code (acfg);
14002
14003 emit_info (acfg);
14004
14005 emit_extra_methods (acfg);
14006
14007 emit_trampolines (acfg);
14008
14009 emit_class_name_table (acfg);
14010
14011 emit_got_info (acfg, FALSE);
14012 if (acfg->llvm)
14013 emit_got_info (acfg, TRUE);
14014
14015 emit_exception_info (acfg);
14016
14017 emit_unwind_info (acfg);
14018
14019 emit_class_info (acfg);
14020
14021 emit_plt (acfg);
14022
14023 emit_image_table (acfg);
14024
14025 emit_weak_field_indexes (acfg);
14026
14027 emit_got (acfg);
14028
14029 {
14030 /*
14031 * The managed allocators are GC specific, so can't use an AOT image created by one GC
14032 * in another.
14033 */
14034 const char *gc_name = mono_gc_get_gc_name ();
14035 acfg->gc_name_offset = add_to_blob (acfg, (guint8*)gc_name, strlen (gc_name) + 1);
14036 }
14037
14038 emit_blob (acfg);
14039
14040 emit_objc_selectors (acfg);
14041
14042 emit_globals (acfg);
14043
14044 emit_file_info (acfg);
14045
14046 if (acfg->dwarf) {
14047 emit_dwarf_info (acfg);
14048 mono_dwarf_writer_close (acfg->dwarf);
14049 } else {
14050 if (!acfg->aot_opts.nodebug)
14051 emit_codeview_info (acfg);
14052 }
14053
14054 emit_mem_end (acfg);
14055
14056 if (acfg->need_pt_gnu_stack) {
14057 /* This is required so the .so doesn't have an executable stack */
14058 /* The bin writer already emits this */
14059 fprintf (acfg->fp, "\n.section .note.GNU-stack,\"\",@progbits\n");
14060 }
14061
14062 if (acfg->aot_opts.data_outfile)
14063 fclose (acfg->data_outfile);
14064
14065 #ifdef ENABLE_LLVM
14066 if (acfg->llvm) {
14067 gboolean res;
14068
14069 res = emit_llvm_file (acfg);
14070 if (!res)
14071 return 1;
14072 }
14073 #endif
14074
14075 emit_library_info (acfg);
14076
14077 TV_GETTIME (btv);
14078
14079 acfg->stats.gen_time = TV_ELAPSED (atv, btv);
14080
14081 if (!acfg->aot_opts.stats)
14082 aot_printf (acfg, "Compiled: %d/%d\n", acfg->stats.ccount, acfg->stats.mcount);
14083
14084 TV_GETTIME (atv);
14085 if (acfg->w) {
14086 res = mono_img_writer_emit_writeout (acfg->w);
14087 if (res != 0) {
14088 acfg_free (acfg);
14089 return res;
14090 }
14091 res = compile_asm (acfg);
14092 if (res != 0) {
14093 acfg_free (acfg);
14094 return res;
14095 }
14096 }
14097 TV_GETTIME (btv);
14098 acfg->stats.link_time = TV_ELAPSED (atv, btv);
14099
14100 if (acfg->aot_opts.stats)
14101 print_stats (acfg);
14102
14103 aot_printf (acfg, "JIT time: %d ms, Generation time: %d ms, Assembly+Link time: %d ms.\n", acfg->stats.jit_time / 1000, acfg->stats.gen_time / 1000, acfg->stats.link_time / 1000);
14104
14105 if (acfg->aot_opts.depfile)
14106 create_depfile (acfg);
14107
14108 if (acfg->aot_opts.dump_json)
14109 aot_dump (acfg);
14110
14111 if (!acfg->aot_opts.save_temps && acfg->temp_dir_to_delete) {
14112 char *command = g_strdup_printf ("rm -r %s", acfg->temp_dir_to_delete);
14113 execute_system (command);
14114 g_free (command);
14115 }
14116
14117 acfg_free (acfg);
14118
14119 return 0;
14120 }
14121
14122 #else
14123
14124 /* AOT disabled */
14125
14126 void*
14127 mono_aot_readonly_field_override (MonoClassField *field)
14128 {
14129 return NULL;
14130 }
14131
14132 int
14133 mono_compile_assembly (MonoAssembly *ass, guint32 opts, const char *aot_options, gpointer **aot_state)
14134 {
14135 return 0;
14136 }
14137
14138 gboolean
14139 mono_aot_is_shared_got_offset (int offset)
14140 {
14141 return FALSE;
14142 }
14143
14144 int
14145 mono_compile_deferred_assemblies (guint32 opts, const char *aot_options, gpointer **aot_state)
14146 {
14147 g_assert_not_reached ();
14148 return 0;
14149 }
14150
14151 gboolean
14152 mono_aot_direct_icalls_enabled_for_method (MonoCompile *cfg, MonoMethod *method)
14153 {
14154 g_assert_not_reached ();
14155 return 0;
14156 }
14157
14158 gboolean
14159 mono_aot_can_enter_interp (MonoMethod *method)
14160 {
14161 return FALSE;
14162 }
14163
14164 #endif
Mirror of the official Mono project git repository