+extern MonoMethodDesc *mono_break_at_bb_method;
+extern int mono_break_at_bb_bb_num;
+extern gboolean check_for_pending_exc;
+extern gboolean disable_vtypes_in_regs;
+extern gboolean mono_verify_all;
+
+#define INS_INFO(opcode) (&ins_info [((opcode) - OP_START - 1) * 3])
+
+extern const char ins_info[];
+
+#define MONO_BB_FOR_EACH_INS(bb, ins) for ((ins) = (bb)->code; (ins); (ins) = (ins)->next)
+
+#define MONO_BB_FOR_EACH_INS_SAFE(bb, n, ins) for ((ins) = (bb)->code, n = (ins) ? (ins)->next : NULL; (ins); (ins) = (n), (n) = (ins) ? (ins)->next : NULL)
+
+#define MONO_BB_FOR_EACH_INS_REVERSE_SAFE(bb, p, ins) for ((ins) = (bb)->last_ins, p = (ins) ? (ins)->prev : NULL; (ins); (ins) = (p), (p) = (ins) ? (ins)->prev : NULL)
+
+#define mono_bb_first_ins(bb) (bb)->code
+
+#if 0
+
+static inline void
+MONO_INST_LIST_ADD_TAIL (MonoInstList *new, MonoInstList *head)
+{
+ __MONO_INST_LIST_ADD (new, head->prev, head);
+}
+
+static inline void
+__MONO_INST_LIST_DEL (MonoInstList *prev, MonoInstList *next)
+{
+ next->prev = prev;
+ prev->next = next;
+}
+
+static inline void
+__MONO_INST_LIST_SPLICE (MonoInstList *list, MonoInstList *head)
+{
+ MonoInstList *first = list->next;
+ MonoInstList *last = list->prev;
+ MonoInstList *at = head->next;
+
+ first->prev = head;
+ head->next = first;
+
+ last->next = at;
+ at->prev = last;
+}
+
+static inline void
+MONO_INST_LIST_SPLICE (MonoInstList *list, MonoInstList *head)
+{
+ if (!MONO_INST_LIST_EMPTY (list))
+ __MONO_INST_LIST_SPLICE (list, head);
+}
+
+static inline void
+MONO_INST_LIST_SPLICE_TAIL (MonoInstList *list, MonoInstList *head)
+{
+ if (!MONO_INST_LIST_EMPTY (list))
+ __MONO_INST_LIST_SPLICE (list, head->prev);
+}
+
+static inline void
+MONO_INST_LIST_SPLICE_INIT (MonoInstList *list, MonoInstList *head)
+{
+ if (!MONO_INST_LIST_EMPTY (list)) {
+ __MONO_INST_LIST_SPLICE (list, head);
+ MONO_INST_LIST_INIT (list);
+ }
+}
+
+static inline void
+MONO_INST_LIST_SPLICE_TAIL_INIT (MonoInstList *list, MonoInstList *head)
+{
+ if (!MONO_INST_LIST_EMPTY (list)) {
+ __MONO_INST_LIST_SPLICE (list, head->prev);
+ MONO_INST_LIST_INIT (list);
+ }
+}
+
+/*#define mono_container_of(ptr, type, member) ({ \
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+ (type *)( (char *)__mptr - offsetof(type,member) );})
+
+#define MONO_INST_LIST_ENTRY(ptr, type, member) \
+ mono_container_of(ptr, type, member)*/
+
+#define MONO_INST_LIST_ENTRY(ptr, type, member) \
+ ((type *)(gpointer)(ptr))
+
+#define MONO_INST_LIST_FIRST_ENTRY(ptr, type, member) \
+ MONO_INST_LIST_ENTRY((ptr)->next, type, member)
+
+#define MONO_INST_LIST_LAST_ENTRY(ptr, type, member) \
+ MONO_INST_LIST_ENTRY((ptr)->prev, type, member)
+
+#define MONO_INST_LIST_FOR_EACH(pos, head) \
+ for (pos = (head)->next; pos != (head); pos = pos->next)
+
+#define MONO_INST_LIST_FOR_EACH_PREV(pos, head) \
+ for (pos = (head)->prev; pos != (head); pos = pos->prev)
+
+#define MONO_INST_LIST_FOR_EACH_SAFE(pos, n, head) \
+ for (pos = (head)->next, n = pos->next; pos != (head); \
+ pos = n, n = pos->next)
+
+#define MONO_INST_LIST_FOR_EACH_PREV_SAFE(pos, n, head) \
+ for (pos = (head)->prev, n = pos->prev; pos != (head); \
+ pos = n, n = pos->prev)
+
+#define MONO_INST_LIST_FOR_EACH_ENTRY(pos, head, member) \
+ for (pos = MONO_INST_LIST_ENTRY ((head)->next, MonoInst, member);\
+ &pos->member != (head);\
+ pos = MONO_INST_LIST_ENTRY (pos->member.next, MonoInst, member))
+
+#define MONO_INST_LIST_FOR_EACH_ENTRY_REVERSE(pos, head, member) \
+ for (pos = MONO_INST_LIST_ENTRY ((head)->prev, MonoInst, member);\
+ &pos->member != (head);\
+ pos = MONO_INST_LIST_ENTRY (pos->member.prev, MonoInst, member))
+
+#define MONO_INST_LIST_FOR_EACH_ENTRY_SAFE(pos, n, head, member) \
+ for (pos = MONO_INST_LIST_ENTRY ((head)->next, MonoInst, member),\
+ n = MONO_INST_LIST_ENTRY (pos->member.next, MonoInst, member);\
+ &pos->member != (head); \
+ pos = n, n = MONO_INST_LIST_ENTRY (n->member.next, MonoInst, member))
+
+#define MONO_BB_FOR_EACH_INS(bb, ins) MONO_INST_LIST_FOR_EACH_ENTRY ((ins), &((bb)->ins_list), node)
+
+#define MONO_BB_FOR_EACH_INS_SAFE(bb, next, ins) MONO_INST_LIST_FOR_EACH_ENTRY_SAFE ((ins), (next), &((bb)->ins_list), node)
+
+#define MONO_BB_FOR_EACH_INS_REVERSE(bb, ins) MONO_INST_LIST_FOR_EACH_ENTRY_REVERSE ((ins), &((bb)->ins_list), node)
+
+#endif