3 * Sequence Points functions
6 * Marcos Henrich (marcos.henrich@xamarin.com)
8 * Copyright 2014 Xamarin, Inc (http://www.xamarin.com)
9 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
13 #include "seq-points.h"
16 insert_pred_seq_point (MonoInst *last_seq_ins, MonoInst *ins, GSList **next)
19 int src_index = last_seq_ins->backend.size;
20 int dst_index = ins->backend.size;
22 /* bb->in_bb might contain duplicates */
23 for (l = next [src_index]; l; l = l->next)
24 if (GPOINTER_TO_UINT (l->data) == dst_index)
27 next [src_index] = g_slist_append (next [src_index], GUINT_TO_POINTER (dst_index));
31 recursively_make_pred_seq_points (MonoCompile *cfg, MonoBasicBlock *bb)
33 const gpointer MONO_SEQ_SEEN_LOOP = GINT_TO_POINTER(-1);
35 GArray *predecessors = g_array_new (FALSE, TRUE, sizeof (gpointer));
36 GHashTable *seen = g_hash_table_new_full (g_direct_hash, NULL, NULL, NULL);
38 // Insert/remove sentinel into the memoize table to detect loops containing bb
39 bb->pred_seq_points = MONO_SEQ_SEEN_LOOP;
41 for (int i = 0; i < bb->in_count; ++i) {
42 MonoBasicBlock *in_bb = bb->in_bb [i];
44 // This bb has the last seq point, append it and continue
45 if (in_bb->last_seq_point != NULL) {
46 predecessors = g_array_append_val (predecessors, in_bb->last_seq_point);
50 // We've looped or handled this before, exit early.
51 // No last sequence points to find.
52 if (in_bb->pred_seq_points == MONO_SEQ_SEEN_LOOP)
55 // Take sequence points from incoming basic blocks
57 if (in_bb == cfg->bb_entry)
60 if (in_bb->pred_seq_points == NULL)
61 recursively_make_pred_seq_points (cfg, in_bb);
63 // Union sequence points with incoming bb's
64 for (int i=0; i < in_bb->num_pred_seq_points; i++) {
65 if (!g_hash_table_lookup (seen, in_bb->pred_seq_points [i])) {
66 g_array_append_val (predecessors, in_bb->pred_seq_points [i]);
67 g_hash_table_insert (seen, in_bb->pred_seq_points [i], (gpointer)&MONO_SEQ_SEEN_LOOP);
70 // predecessors = g_array_append_vals (predecessors, in_bb->pred_seq_points, in_bb->num_pred_seq_points);
73 g_hash_table_destroy (seen);
75 if (predecessors->len != 0) {
76 bb->pred_seq_points = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst *) * predecessors->len);
77 bb->num_pred_seq_points = predecessors->len;
79 for (int newer = 0; newer < bb->num_pred_seq_points; newer++) {
80 bb->pred_seq_points [newer] = g_array_index(predecessors, gpointer, newer);
84 g_array_free (predecessors, TRUE);
88 collect_pred_seq_points (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins, GSList **next)
90 // Doesn't have a last sequence point, must find from incoming basic blocks
91 if (bb->pred_seq_points == NULL && bb != cfg->bb_entry)
92 recursively_make_pred_seq_points (cfg, bb);
94 for (int i = 0; i < bb->num_pred_seq_points; i++)
95 insert_pred_seq_point (bb->pred_seq_points [i], ins, next);
101 mono_save_seq_point_info (MonoCompile *cfg)
104 GSList *bb_seq_points, *l;
106 MonoDomain *domain = cfg->domain;
107 int i, seq_info_size;
108 GSList **next = NULL;
109 SeqPoint* seq_points;
111 gboolean has_debug_data = cfg->gen_sdb_seq_points;
113 if (!cfg->seq_points)
116 seq_points = g_new0 (SeqPoint, cfg->seq_points->len);
118 for (i = 0; i < cfg->seq_points->len; ++i) {
119 SeqPoint *sp = &seq_points [i];
120 MonoInst *ins = (MonoInst *)g_ptr_array_index (cfg->seq_points, i);
122 sp->il_offset = ins->inst_imm;
123 sp->native_offset = ins->inst_offset;
124 if (ins->flags & MONO_INST_NONEMPTY_STACK)
125 sp->flags |= MONO_SEQ_POINT_FLAG_NONEMPTY_STACK;
128 ins->backend.size = i;
131 if (has_debug_data) {
133 * For each sequence point, compute the list of sequence points immediately
134 * following it, this is needed to implement 'step over' in the debugger agent.
136 next = g_new0 (GSList*, cfg->seq_points->len);
137 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
138 bb_seq_points = g_slist_reverse (bb->seq_points);
140 for (l = bb_seq_points; l; l = l->next) {
141 MonoInst *ins = (MonoInst *)l->data;
143 if (ins->inst_imm == METHOD_ENTRY_IL_OFFSET || ins->inst_imm == METHOD_EXIT_IL_OFFSET)
144 /* Used to implement method entry/exit events */
146 if (ins->inst_offset == SEQ_POINT_NATIVE_OFFSET_DEAD_CODE)
150 /* Link with the previous seq point in the same bb */
151 next [last->backend.size] = g_slist_append (next [last->backend.size], GUINT_TO_POINTER (ins->backend.size));
153 /* Link with the last bb in the previous bblocks */
154 collect_pred_seq_points (cfg, bb, ins, next);
160 /* The second case handles endfinally opcodes which are in a separate bb by themselves */
161 if ((bb->last_ins && bb->last_ins->opcode == OP_ENDFINALLY && bb->seq_points) || (bb->out_count == 1 && bb->out_bb [0]->code && bb->out_bb [0]->code->opcode == OP_ENDFINALLY)) {
163 MonoInst *endfinally_seq_point = NULL;
166 * The ENDFINALLY branches are not represented in the cfg, so link it with all seq points starting bbs.
168 l = g_slist_last (bb->seq_points);
170 endfinally_seq_point = (MonoInst *)l->data;
172 for (bb2 = bb->next_bb; bb2; bb2 = bb2->next_bb) {
173 GSList *l = g_slist_last (bb2->seq_points);
176 MonoInst *ins = (MonoInst *)l->data;
178 if (!(ins->inst_imm == METHOD_ENTRY_IL_OFFSET || ins->inst_imm == METHOD_EXIT_IL_OFFSET) && ins != endfinally_seq_point)
179 next [endfinally_seq_point->backend.size] = g_slist_append (next [endfinally_seq_point->backend.size], GUINT_TO_POINTER (ins->backend.size));
186 if (cfg->verbose_level > 2) {
187 printf ("\nSEQ POINT MAP: \n");
189 for (i = 0; i < cfg->seq_points->len; ++i) {
190 SeqPoint *sp = &seq_points [i];
196 printf ("\tIL0x%x[0x%0x] ->", sp->il_offset, sp->native_offset);
197 for (l = next [i]; l; l = l->next) {
198 int next_index = GPOINTER_TO_UINT (l->data);
199 printf (" IL0x%x", seq_points [next_index].il_offset);
206 array = g_byte_array_new ();
208 { /* Add sequence points to seq_point_info */
209 SeqPoint zero_seq_point = {0};
210 SeqPoint* last_seq_point = &zero_seq_point;
212 for (i = 0; i < cfg->seq_points->len; ++i) {
213 SeqPoint *sp = &seq_points [i];
214 GSList* next_list = NULL;
219 if (mono_seq_point_info_add_seq_point (array, sp, last_seq_point, next_list, has_debug_data))
223 g_slist_free (next [i]);
232 cfg->seq_point_info = mono_seq_point_info_new (array->len, TRUE, array->data, has_debug_data, &seq_info_size);
233 InterlockedAdd (&mono_jit_stats.allocated_seq_points_size, seq_info_size);
235 g_byte_array_free (array, TRUE);
237 // FIXME: dynamic methods
238 if (!cfg->compile_aot) {
239 mono_domain_lock (domain);
240 // FIXME: The lookup can fail if the method is JITted recursively though a type cctor
241 if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, cfg->method_to_register))
242 g_hash_table_insert (domain_jit_info (domain)->seq_points, cfg->method_to_register, cfg->seq_point_info);
244 mono_seq_point_info_free (cfg->seq_point_info);
245 mono_domain_unlock (domain);
248 g_ptr_array_free (cfg->seq_points, TRUE);
249 cfg->seq_points = NULL;
253 mono_get_seq_points (MonoDomain *domain, MonoMethod *method)
255 MonoSeqPointInfo *seq_points;
256 MonoMethod *declaring_generic_method = NULL, *shared_method = NULL;
258 if (method->is_inflated) {
259 declaring_generic_method = mono_method_get_declaring_generic_method (method);
260 shared_method = mini_get_shared_method (method);
264 seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, method);
265 if (!seq_points && method->is_inflated) {
266 /* generic sharing + aot */
267 seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, declaring_generic_method);
269 seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, shared_method);
271 mono_loader_unlock ();
277 * mono_find_next_seq_point_for_native_offset:
279 * Find the first sequence point after NATIVE_OFFSET.
282 mono_find_next_seq_point_for_native_offset (MonoDomain *domain, MonoMethod *method, gint32 native_offset, MonoSeqPointInfo **info, SeqPoint* seq_point)
284 MonoSeqPointInfo *seq_points;
286 seq_points = mono_get_seq_points (domain, method);
295 return mono_seq_point_find_next_by_native_offset (seq_points, native_offset, seq_point);
299 * mono_find_prev_seq_point_for_native_offset:
301 * Find the first sequence point before NATIVE_OFFSET.
304 mono_find_prev_seq_point_for_native_offset (MonoDomain *domain, MonoMethod *method, gint32 native_offset, MonoSeqPointInfo **info, SeqPoint* seq_point)
306 MonoSeqPointInfo *seq_points;
308 seq_points = mono_get_seq_points (domain, method);
317 return mono_seq_point_find_prev_by_native_offset (seq_points, native_offset, seq_point);
321 * mono_find_seq_point:
323 * Find the sequence point corresponding to the IL offset IL_OFFSET, which
324 * should be the location of a sequence point.
327 mono_find_seq_point (MonoDomain *domain, MonoMethod *method, gint32 il_offset, MonoSeqPointInfo **info, SeqPoint *seq_point)
329 MonoSeqPointInfo *seq_points;
331 seq_points = mono_get_seq_points (domain, method);
340 return mono_seq_point_find_by_il_offset (seq_points, il_offset, seq_point);
344 mono_bb_deduplicate_op_il_seq_points (MonoCompile *cfg, MonoBasicBlock *bb)
346 MonoInst *ins, *n, *prev;
348 MONO_BB_FOR_EACH_INS_SAFE (bb, n, ins) {
349 if (ins->opcode != OP_IL_SEQ_POINT)
352 prev = mono_inst_prev (ins, FILTER_NOP);
354 if (!prev || ins == prev || prev->opcode != OP_IL_SEQ_POINT)
357 MONO_REMOVE_INS (bb, prev);