mono/mini/seq-points.c

   1 /*
   2  * seq-points.c: Sequence Points functions
   3  *
   4  * Authors:
   5  *   Marcos Henrich (marcos.henrich@xamarin.com)
   6  *
   7  * Copyright 2014 Xamarin, Inc (http://www.xamarin.com)
   8  */
   9
  10 #include "mini.h"
  11 #include "seq-points.h"
  12
  13 static void
  14 collect_pred_seq_points (MonoBasicBlock *bb, MonoInst *ins, GSList **next, int depth)
  15 {
  16         int i;
  17         MonoBasicBlock *in_bb;
  18         GSList *l;
  19
  20         for (i = 0; i < bb->in_count; ++i) {
  21                 in_bb = bb->in_bb [i];
  22
  23                 if (in_bb->last_seq_point) {
  24                         int src_index = in_bb->last_seq_point->backend.size;
  25                         int dst_index = ins->backend.size;
  26
  27                         /* bb->in_bb might contain duplicates */
  28                         for (l = next [src_index]; l; l = l->next)
  29                                 if (GPOINTER_TO_UINT (l->data) == dst_index)
  30                                         break;
  31                         if (!l)
  32                                 next [src_index] = g_slist_append (next [src_index], GUINT_TO_POINTER (dst_index));
  33                 } else {
  34                         /* Have to look at its predecessors */
  35                         if (depth < 5)
  36                                 collect_pred_seq_points (in_bb, ins, next, depth + 1);
  37                 }
  38         }
  39 }
  40
  41 void
  42 mono_save_seq_point_info (MonoCompile *cfg)
  43 {
  44         MonoBasicBlock *bb;
  45         GSList *bb_seq_points, *l;
  46         MonoInst *last;
  47         MonoDomain *domain = cfg->domain;
  48         int i, seq_info_size;
  49         GSList **next = NULL;
  50         SeqPoint* seq_points;
  51         GByteArray* array;
  52         gboolean has_debug_data = cfg->gen_sdb_seq_points;
  53
  54         if (!cfg->seq_points)
  55                 return;
  56
  57         seq_points = g_new0 (SeqPoint, cfg->seq_points->len);
  58
  59         for (i = 0; i < cfg->seq_points->len; ++i) {
  60                 SeqPoint *sp = &seq_points [i];
  61                 MonoInst *ins = g_ptr_array_index (cfg->seq_points, i);
  62
  63                 sp->il_offset = ins->inst_imm;
  64                 sp->native_offset = ins->inst_offset;
  65                 if (ins->flags & MONO_INST_NONEMPTY_STACK)
  66                         sp->flags |= MONO_SEQ_POINT_FLAG_NONEMPTY_STACK;
  67
  68                 /* Used below */
  69                 ins->backend.size = i;
  70         }
  71
  72         if (has_debug_data) {
  73                 /*
  74                  * For each sequence point, compute the list of sequence points immediately
  75                  * following it, this is needed to implement 'step over' in the debugger agent.
  76                  */
  77                 next = g_new0 (GSList*, cfg->seq_points->len);
  78                 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
  79                         bb_seq_points = g_slist_reverse (bb->seq_points);
  80                         last = NULL;
  81                         for (l = bb_seq_points; l; l = l->next) {
  82                                 MonoInst *ins = l->data;
  83
  84                                 if (ins->inst_imm == METHOD_ENTRY_IL_OFFSET || ins->inst_imm == METHOD_EXIT_IL_OFFSET)
  85                                 /* Used to implement method entry/exit events */
  86                                         continue;
  87                                 if (ins->inst_offset == SEQ_POINT_NATIVE_OFFSET_DEAD_CODE)
  88                                         continue;
  89
  90                                 if (last != NULL) {
  91                                         /* Link with the previous seq point in the same bb */
  92                                         next [last->backend.size] = g_slist_append (next [last->backend.size], GUINT_TO_POINTER (ins->backend.size));
  93                                 } else {
  94                                         /* Link with the last bb in the previous bblocks */
  95                                         collect_pred_seq_points (bb, ins, next, 0);
  96                                 }
  97
  98                                 last = ins;
  99                         }
 100
 101                         /* The second case handles endfinally opcodes which are in a separate bb by themselves */
 102                         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)) {
 103                                 MonoBasicBlock *bb2;
 104                                 MonoInst *endfinally_seq_point = NULL;
 105
 106                                 /*
 107                                  * The ENDFINALLY branches are not represented in the cfg, so link it with all seq points starting bbs.
 108                                  */
 109                                 l = g_slist_last (bb->seq_points);
 110                                 if (l) {
 111                                         endfinally_seq_point = l->data;
 112
 113                                         for (bb2 = cfg->bb_entry; bb2; bb2 = bb2->next_bb) {
 114                                                 GSList *l = g_slist_last (bb2->seq_points);
 115
 116                                                 if (l) {
 117                                                         MonoInst *ins = l->data;
 118
 119                                                         if (!(ins->inst_imm == METHOD_ENTRY_IL_OFFSET || ins->inst_imm == METHOD_EXIT_IL_OFFSET) && ins != endfinally_seq_point)
 120                                                                 next [endfinally_seq_point->backend.size] = g_slist_append (next [endfinally_seq_point->backend.size], GUINT_TO_POINTER (ins->backend.size));
 121                                                 }
 122                                         }
 123                                 }
 124                         }
 125                 }
 126
 127                 if (cfg->verbose_level > 2) {
 128                         printf ("\nSEQ POINT MAP: \n");
 129
 130                         for (i = 0; i < cfg->seq_points->len; ++i) {
 131                                 SeqPoint *sp = &seq_points [i];
 132                                 GSList *l;
 133
 134                                 if (!next [i])
 135                                         continue;
 136
 137                                 printf ("\tIL0x%x[0x%0x] ->", sp->il_offset, sp->native_offset);
 138                                 for (l = next [i]; l; l = l->next) {
 139                                         int next_index = GPOINTER_TO_UINT (l->data);
 140                                         printf (" IL0x%x", seq_points [next_index].il_offset);
 141                                 }
 142                                 printf ("\n");
 143                         }
 144                 }
 145         }
 146
 147         array = g_byte_array_new ();
 148
 149         { /* Add sequence points to seq_point_info */
 150                 SeqPoint zero_seq_point = {0};
 151                 SeqPoint* last_seq_point = &zero_seq_point;
 152
 153                 for (i = 0; i < cfg->seq_points->len; ++i) {
 154                         SeqPoint *sp = &seq_points [i];
 155                         GSList* next_list = NULL;
 156
 157                         if (has_debug_data)
 158                                 next_list = next[i];
 159
 160                         if (mono_seq_point_info_add_seq_point (array, sp, last_seq_point, next_list, has_debug_data))
 161                                 last_seq_point = sp;
 162
 163                         if (has_debug_data)
 164                                 g_slist_free (next [i]);
 165                 }
 166         }
 167
 168         if (has_debug_data)
 169                 g_free (next);
 170
 171         cfg->seq_point_info = mono_seq_point_info_new (array->len, TRUE, array->data, has_debug_data, &seq_info_size);
 172         mono_jit_stats.allocated_seq_points_size += seq_info_size;
 173
 174         g_byte_array_free (array, TRUE);
 175
 176         // FIXME: dynamic methods
 177         if (!cfg->compile_aot) {
 178                 mono_domain_lock (domain);
 179                 // FIXME: How can the lookup succeed ?
 180                 if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, cfg->method_to_register))
 181                         g_hash_table_insert (domain_jit_info (domain)->seq_points, cfg->method_to_register, cfg->seq_point_info);
 182                 mono_domain_unlock (domain);
 183         }
 184
 185         g_ptr_array_free (cfg->seq_points, TRUE);
 186         cfg->seq_points = NULL;
 187 }
 188
 189 MonoSeqPointInfo*
 190 mono_get_seq_points (MonoDomain *domain, MonoMethod *method)
 191 {
 192         MonoSeqPointInfo *seq_points;
 193
 194         mono_domain_lock (domain);
 195         seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, method);
 196         if (!seq_points && method->is_inflated) {
 197                 /* generic sharing + aot */
 198                 seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, mono_method_get_declaring_generic_method (method));
 199                 if (!seq_points)
 200                         seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, mini_get_shared_method (method));
 201         }
 202         mono_domain_unlock (domain);
 203
 204         return seq_points;
 205 }
 206
 207 /*
 208  * mono_find_next_seq_point_for_native_offset:
 209  *
 210  *   Find the first sequence point after NATIVE_OFFSET.
 211  */
 212 gboolean
 213 mono_find_next_seq_point_for_native_offset (MonoDomain *domain, MonoMethod *method, gint32 native_offset, MonoSeqPointInfo **info, SeqPoint* seq_point)
 214 {
 215         MonoSeqPointInfo *seq_points;
 216
 217         seq_points = mono_get_seq_points (domain, method);
 218         if (!seq_points) {
 219                 if (info)
 220                         *info = NULL;
 221                 return FALSE;
 222         }
 223         if (info)
 224                 *info = seq_points;
 225
 226         return mono_seq_point_find_next_by_native_offset (seq_points, native_offset, seq_point);
 227 }
 228
 229 /*
 230  * mono_find_prev_seq_point_for_native_offset:
 231  *
 232  *   Find the first sequence point before NATIVE_OFFSET.
 233  */
 234 gboolean
 235 mono_find_prev_seq_point_for_native_offset (MonoDomain *domain, MonoMethod *method, gint32 native_offset, MonoSeqPointInfo **info, SeqPoint* seq_point)
 236 {
 237         MonoSeqPointInfo *seq_points;
 238
 239         seq_points = mono_get_seq_points (domain, method);
 240         if (!seq_points) {
 241                 if (info)
 242                         *info = NULL;
 243                 return FALSE;
 244         }
 245         if (info)
 246                 *info = seq_points;
 247
 248         return mono_seq_point_find_prev_by_native_offset (seq_points, native_offset, seq_point);
 249 }
 250
 251 /*
 252  * mono_find_seq_point:
 253  *
 254  *   Find the sequence point corresponding to the IL offset IL_OFFSET, which
 255  * should be the location of a sequence point.
 256  */
 257 gboolean
 258 mono_find_seq_point (MonoDomain *domain, MonoMethod *method, gint32 il_offset, MonoSeqPointInfo **info, SeqPoint *seq_point)
 259 {
 260         MonoSeqPointInfo *seq_points;
 261
 262         seq_points = mono_get_seq_points (domain, method);
 263         if (!seq_points) {
 264                 if (info)
 265                         *info = NULL;
 266                 return FALSE;
 267         }
 268         if (info)
 269                 *info = seq_points;
 270
 271         return mono_seq_point_find_by_il_offset (seq_points, il_offset, seq_point);
 272 }
 273
 274 void
 275 mono_bb_deduplicate_op_il_seq_points (MonoCompile *cfg, MonoBasicBlock *bb)
 276 {
 277         MonoInst *ins, *n, *prev;
 278
 279         MONO_BB_FOR_EACH_INS_SAFE (bb, n, ins) {
 280                 if (ins->opcode != OP_IL_SEQ_POINT)
 281                         continue;
 282
 283                 prev = mono_inst_prev (ins, FILTER_NOP);
 284
 285                 if (!prev || ins == prev || prev->opcode != OP_IL_SEQ_POINT)
 286                         continue;
 287
 288                 MONO_REMOVE_INS (bb, prev);
 289         };
 290 }
 291
 292 void
 293 mono_image_get_aot_seq_point_path (MonoImage *image, char **str)
 294 {
 295         int size = strlen (image->name) + strlen (SEQ_POINT_AOT_EXT) + 1;
 296         *str = g_malloc (size);
 297         g_sprintf (*str, "%s%s", image->name, SEQ_POINT_AOT_EXT);
 298 }