4 * (C) 2005 Michael Beck beck@ipd.info.uni-karlsruhe.de
6 #define WIN32_LEAN_AND_MEAN
14 /* ugly, but I must include array.h WITHOUT NDEBUG */
24 #include "irgraph_t.h"
29 #include "irextbb_t.h"
31 #include "compound_path_t.h"
41 #include "firmEvaluator.h"
43 /** get the address of a pointer */
44 #define ADD_ADR(p, off) ((void *)((char *)(p) + (off)))
47 static void debug(char *fmt, ...) {
52 vsprintf(buf, fmt, ap);
54 OutputDebugString(buf);
59 * return the size of a firm object
61 int get_firm_object_size(firm_kind kind) {
63 case k_entity: /* an entity */
64 return sizeof(ir_entity);
65 case k_type: /* a type */
66 return sizeof(ir_type);
67 case k_ir_graph: /* an ir graph */
68 return sizeof(ir_graph);
69 case k_ir_node: /* an ir node */
70 return sizeof(ir_node);
71 case k_ir_mode: /* an ir mode */
72 return sizeof(ir_mode);
73 case k_ir_op: /* an ir opcode */
75 case k_tarval: /* a tarval */
76 return sizeof(tarval);
77 case k_ir_loop: /* a loop */
78 return sizeof(ir_loop);
79 case k_ir_compound_graph_path: /* a compound graph path, see entity.h */
80 return sizeof(compound_graph_path);
81 case k_ir_extblk: /* an extended block */
82 return sizeof(ir_extblk);
83 case k_ir_prog: /* a program representation (irp) */
84 return sizeof(ir_prog);
88 } /* get_firm_object_size */
91 * returns the string length of a string in debuggee space
93 * @return string length or negative value on error
95 static int strlen_debuggee(DEBUGHELPER *pHelper, const void *address, size_t max)
99 const char *p = address;
101 for (i = 0; i < max; ++i) {
102 if (copy_from_debuggee(p + i, pHelper, &v, sizeof(v)) != S_OK)
109 } /* strlen_debuggee */
114 HRESULT format_ident(DEBUGHELPER *pHelper, const void *address, char *pResult, size_t max) {
115 set_entry *data = NULL;
119 if (copy_from_debuggee(address, pHelper, &id, sizeof(id)) != S_OK)
123 if (id.size < 1 || id.size > 256)
127 len = offsetof(set_entry, dptr) + slen;
131 if (copy_from_debuggee(address, pHelper, data, len) != S_OK)
134 _tcsncpy(pResult, (const char *)data->dptr, max);
141 static HRESULT format_tp_op(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
145 #define X(a) case tpo_##a: _tcsncpy(pResult, #a, max); return S_OK
146 #define Y(a, b) case tpo_##a: _tcsncpy(pResult, b, max); return S_OK
148 if (copy_from_debuggee(addr, pHelper, &op, sizeof(op)) != S_OK)
158 Y(enumeration, "enum");
160 Y(primitive, "prim");
171 * Checks whether a type is the global type
173 * @param type the address of the type in debuggee's space
175 static HRESULT is_global_type(DEBUGHELPER *pHelper, const void *type, int *flag) {
179 if (copy_from_debuggee(type, pHelper, &tp, sizeof(tp)) != S_OK)
182 *flag = tp.flags & tf_global_type;
184 } /* is_global_type */
189 static HRESULT format_entity(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top) {
195 if (copy_from_debuggee(addr, pHelper, &ent, sizeof(ent)) != S_OK) {
198 if (is_global_type(pHelper, ent.owner, &is_global) != S_OK)
203 _tcsncpy(pResult, "ENT: ", max);
206 if (copy_from_debuggee(ent.owner, pHelper, &owner, sizeof(owner)) != S_OK)
208 if (format_ident(pHelper, (void *)owner.name, name, sizeof(name)) != S_OK)
210 _tcsncat(pResult, name, max);
211 _tcsncat(pResult, "::", max);
214 if (format_ident(pHelper, (void *)ent.name, name, sizeof(name)) != S_OK)
216 _tcsncat(pResult, name, max);
220 _snprintf(name, sizeof(name), " [0x%lx]", ent.nr);
223 _snprintf(name, sizeof(name), " [0%lo]", ent.nr);
226 _snprintf(name, sizeof(name), " [%ld]", ent.nr);
228 _tcsncat(pResult, name, max);
231 } /* format_entity */
236 static HRESULT format_type(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top) {
240 if (copy_from_debuggee(addr, pHelper, &tp, sizeof(tp)) != S_OK)
245 if (format_tp_op(pHelper, tp.type_op, pResult, max) != S_OK)
248 _tcsncat(pResult, " ", max);
251 if (format_ident(pHelper, tp.name, name, sizeof(name)) != S_OK)
254 _tcsncat(pResult, name, max);
257 _snprintf(name, sizeof(name), " [0x%lx]", tp.nr);
260 _snprintf(name, sizeof(name), " [0%lo]", tp.nr);
263 _snprintf(name, sizeof(name), " [%ld]", tp.nr);
265 _tcsncat(pResult, name, max);
273 static HRESULT format_irg(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top) {
277 if (copy_from_debuggee(addr, pHelper, &irg, sizeof(irg)) != S_OK)
282 _tcsncpy(pResult, "IRG: ", max);
289 if (copy_from_debuggee(irg.ent, pHelper, &ent, sizeof(ent)) != S_OK)
291 if (is_global_type(pHelper, ent.owner, &is_global) != S_OK)
294 if (copy_from_debuggee(ent.owner, pHelper, &owner, sizeof(owner)) != S_OK)
296 if (format_ident(pHelper, (void *)owner.name, name, sizeof(name)) != S_OK)
298 _tcsncat(pResult, name, max);
299 _tcsncat(pResult, "::", max);
301 if (format_ident(pHelper, ent.name, name, sizeof(name)) != S_OK)
303 _tcsncat(pResult, name, max);
306 _tcsncat(pResult, "NULL", max);
310 _snprintf(name, sizeof(name), " [0x%lx, 0x%u nodes]", irg.graph_nr, irg.last_node_idx);
313 _snprintf(name, sizeof(name), " [0%lo, 0%o nodes]", irg.graph_nr, irg.last_node_idx);
316 _snprintf(name, sizeof(name), " [%ld, %u nodes]", irg.graph_nr, irg.last_node_idx);
318 _tcsncat(pResult, name, max);
325 HRESULT format_op(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max) {
328 if (copy_from_debuggee(addr, pHelper, &op, sizeof(op)) != S_OK)
330 if (format_ident(pHelper, op.name, pResult, max) != S_OK)
338 static HRESULT format_mode(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max) {
341 if (copy_from_debuggee(addr, pHelper, &mode, sizeof(mode)) != S_OK)
343 if (format_ident(pHelper, mode.name, pResult, max) != S_OK)
348 /** get a temporary string */
349 #define get_string(str) \
354 len = strlen_debuggee(pHelper, str, 256); \
357 s = alloca(len + 1); \
358 if (copy_from_debuggee(str, pHelper, s, (DWORD)len) != S_OK) \
368 static HRESULT format_tarval(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
374 tarval_mode_info modinfo;
377 static int initialized = 0;
380 /* from init_tarval_1() */
388 if (copy_from_debuggee(addr, pHelper, &tv, sizeof(tv)) != S_OK)
395 if (copy_from_debuggee(tv.mode, pHelper, &mode, sizeof(mode)) != S_OK)
400 if (mode_is_int(&mode)) {
403 modinfo.mode_output = TVO_HEX;
404 modinfo.mode_prefix = "0x";
405 modinfo.mode_suffix = "";
408 modinfo.mode_output = TVO_OCTAL;
409 modinfo.mode_prefix = "0";
410 modinfo.mode_suffix = "";
413 modinfo.mode_output = TVO_DECIMAL;
414 modinfo.mode_prefix = "";
415 modinfo.mode_suffix = "";
420 if (copy_from_debuggee(mode.tv_priv, pHelper, &modinfo, sizeof(modinfo)) != S_OK)
423 get_string(modinfo.mode_prefix);
424 get_string(modinfo.mode_suffix);
427 mode.tv_priv = &modinfo;
436 if (copy_from_debuggee(tv.value, pHelper, value, len) != S_OK)
441 tarval_snprintf(pResult, max, &tv);
444 /* might be a reserved tarval */
445 int resid = PTR_TO_INT(tv.value);
448 case resid_tarval_bad:
449 _tcsncat(pResult, "BAD", max);
451 case resid_tarval_undefined:
452 _tcsncat(pResult, "UNDEF", max);
454 case resid_tarval_b_false:
455 _tcsncat(pResult, "FALSE", max);
457 case resid_tarval_b_true:
458 _tcsncat(pResult, "TRUE", max);
462 tarval_snprintf(pResult, max, &tv);
466 } /* format_tarval */
471 static HRESULT format_node(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top) {
476 if (copy_from_debuggee(addr, pHelper, &n, sizeof(n)) != S_OK)
480 if (format_op(pHelper, n.op, pResult, max) != S_OK)
484 if (format_mode(pHelper, n.mode, name, sizeof(name)) != S_OK)
486 _tcsncat(pResult, name, max);
488 if (copy_from_debuggee(n.op, pHelper, &op, sizeof(op)) != S_OK)
491 /* show show node attributes */
494 if (format_tarval(pHelper, nBase, n.attr.con.tv, name, sizeof(name)) != S_OK) {
495 _tcsncat(pResult, "<???>", max);
498 _tcsncat(pResult, "<", max);
499 _tcsncat(pResult, name, max);
500 _tcsncat(pResult, ">", max);
504 _tcsncat(pResult, "<", max);
505 switch (n.attr.symc.kind) {
506 case symconst_type_tag:
507 _tcsncat(pResult, "TAG:", max);
508 if (format_type(pHelper, nBase, n.attr.symc.sym.type_p, name, sizeof(name), 0) != S_OK)
510 _tcsncat(pResult, name, max);
512 case symconst_type_size:
513 _tcsncat(pResult, "SIZE:", max);
514 if (format_type(pHelper, nBase, n.attr.symc.sym.type_p, name, sizeof(name), 0) != S_OK)
516 _tcsncat(pResult, name, max);
518 case symconst_type_align:
519 _tcsncat(pResult, "ALGN:", max);
520 if (format_type(pHelper, nBase, n.attr.symc.sym.type_p, name, sizeof(name), 0) != S_OK)
522 _tcsncat(pResult, name, max);
524 case symconst_addr_name:
525 _tcsncat(pResult, "NAME:", max);
526 if (format_ident(pHelper, n.attr.symc.sym.ident_p, name, sizeof(name)) != S_OK)
528 _tcsncat(pResult, name, max);
530 case symconst_addr_ent:
531 _tcsncat(pResult, "ENT:", max);
532 if (format_entity(pHelper, nBase, n.attr.symc.sym.entity_p, name, sizeof(name), 0) != S_OK)
534 _tcsncat(pResult, name, max);
537 _tcsncat(pResult, ">", max);
540 _tcsncat(pResult, "<", max);
541 if (format_entity(pHelper, nBase, n.attr.sel.entity, name, sizeof(name), 0) != S_OK)
543 _tcsncat(pResult, name, max);
544 _tcsncat(pResult, ">", max);
547 _tcsncat(pResult, "<", max);
548 if (format_type(pHelper, nBase, n.attr.cast.type, name, sizeof(name), 0) != S_OK)
550 _tcsncat(pResult, name, max);
551 _tcsncat(pResult, ">", max);
554 _tcsncat(pResult, "<", max);
555 if (format_type(pHelper, nBase, n.attr.alloc.type, name, sizeof(name), 0) != S_OK)
557 _tcsncat(pResult, name, max);
558 _snprintf(name, sizeof(name), ", %s", n.attr.alloc.where == stack_alloc ? "stack" : "heap");
559 _tcsncat(pResult, name, max);
560 _tcsncat(pResult, ">", max);
563 _tcsncat(pResult, "<", max);
564 if (format_type(pHelper, nBase, n.attr.free.type, name, sizeof(name), 0) != S_OK)
566 _tcsncat(pResult, name, max);
567 _snprintf(name, sizeof(name), ", %s", n.attr.free.where == stack_alloc ? "stack" : "heap");
568 _tcsncat(pResult, name, max);
569 _tcsncat(pResult, ">", max);
572 _tcsncat(pResult, "<", max);
573 if (format_type(pHelper, nBase, n.attr.copyb.type, name, sizeof(name), 0) != S_OK)
575 _tcsncat(pResult, name, max);
576 _tcsncat(pResult, ">", max);
582 _snprintf(name, sizeof(name), " [0x%lx:0x%x]", n.node_nr, n.node_idx);
585 _snprintf(name, sizeof(name), " [0%lo:0%o]", n.node_nr, n.node_idx);
588 _snprintf(name, sizeof(name), " [%ld:%u]", n.node_nr, n.node_idx);
590 _tcsncat(pResult, name, max);
598 static HRESULT format_loop(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
602 if (copy_from_debuggee(addr, pHelper, &loop, sizeof(loop)) != S_OK)
608 * Get an array descriptor
610 static HRESULT get_array_desc(DEBUGHELPER *pHelper, const void *address, ir_arr_descr *desc)
612 address = ARR_DESCR(address);
613 if (copy_from_debuggee(address, pHelper, desc, sizeof(*desc)) != S_OK)
617 } /* get_array_desc */
620 * format an extended block
622 static HRESULT format_extblk(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max){
625 ir_node *blks = NULL;
629 if (copy_from_debuggee(addr, pHelper, &extbb, sizeof(extbb)) != S_OK)
631 if (extbb.blks == NULL)
634 if (get_array_desc(pHelper, extbb.blks, &blocks) != S_OK)
637 len = ARR_LEN(&blocks.v.elts);
640 if (copy_from_debuggee(extbb.blks, pHelper, &blks, sizeof(blks)) != S_OK)
647 _snprintf(name, sizeof(name), "0x%x 0x%x blocks", blks->node_nr, len);
650 _snprintf(name, sizeof(name), "0%o 0%o blocks", blks->node_nr, len);
653 _snprintf(name, sizeof(name), "%d %d blocks", blks->node_nr, len);
655 _tcsncpy(pResult, name, max);
658 _tcsncpy(pResult, "<EMPTY>", max);
660 } /* format_extblk */
666 static HRESULT format_prog(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
669 ir_arr_descr graphs, types;
672 if (copy_from_debuggee(addr, pHelper, &irp, sizeof(irp)) != S_OK)
675 if (get_array_desc(pHelper, irp.graphs, &graphs) != S_OK)
678 irp.graphs = (ir_graph**)&graphs.v.elts;
682 if (get_array_desc(pHelper, irp.types, &types) != S_OK)
685 irp.types = (ir_type**)&types.v.elts;
690 _snprintf(name, sizeof(name), "0x%x graphs 0x%x types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
693 _snprintf(name, sizeof(name), "0%o graphs 0%o types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
696 _snprintf(name, sizeof(name), "%d graphs %d types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
698 _tcsncpy(pResult, name, max);
704 * Format an array descriptor
706 HRESULT format_arr_descr(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
711 if (copy_from_debuggee(addr, pHelper, &desc, sizeof(desc)) != S_OK)
714 switch (desc.magic) {
716 _tcsncpy(pResult, "DynArr ", max); break;
718 _tcsncpy(pResult, "AutoArr ", max); break;
720 _tcsncpy(pResult, "FlexArr ", max); break;
722 _tcsncpy(pResult, "UNKN ", max);
727 _snprintf(name, sizeof(name), "nelts 0x%x", desc.nelts);
730 _snprintf(name, sizeof(name), "nelts 0%o", desc.nelts);
733 _snprintf(name, sizeof(name), "nelts %d", desc.nelts);
735 _tcsncat(pResult, name, max);
738 } /* format_arr_descr */
741 * format a firm object
743 HRESULT FormatFirmObject(DEBUGHELPER *pHelper, int nBase, firm_kind kind, const void *addr, char *pResult, size_t max)
746 case k_entity: /* an entity */
747 return format_entity(pHelper, nBase, addr, pResult, max, 1);
748 case k_type: /* a type */
749 return format_type(pHelper, nBase, addr, pResult, max, 1);
750 case k_ir_graph: /* an ir graph */
751 return format_irg(pHelper, nBase, addr, pResult, max, 1);
752 case k_ir_node: /* an ir node */
753 return format_node(pHelper, nBase, addr, pResult, max, 1);
754 case k_ir_mode: /* an ir mode */
755 return format_mode(pHelper, addr, pResult, max);
756 case k_ir_op: /* an ir opcode */
757 return format_op(pHelper, addr, pResult, max);
758 case k_tarval: /* a tarval */
759 return format_tarval(pHelper, nBase, addr, pResult, max);
760 case k_ir_loop: /* a loop */
761 return format_loop(pHelper, addr, pResult, max);
762 case k_ir_compound_graph_path: /* a compound graph path, see entity.h */
764 case k_ir_extblk: /* an extended block */
765 return format_extblk(pHelper, nBase, addr, pResult, max);
766 case k_ir_prog: /* a program representation (irp) */
767 return format_prog(pHelper, nBase, addr, pResult, max);
771 } /* FormatFirmObject */
773 #define SEGMENT_SIZE_SHIFT 8
774 #define SEGMENT_SIZE (1 << SEGMENT_SIZE_SHIFT)
775 #define DIRECTORY_SIZE_SHIFT 8
776 #define DIRECTORY_SIZE (1 << DIRECTORY_SIZE_SHIFT)
777 #define MAX_LOAD_FACTOR 4
779 typedef struct pset_element {
780 struct pset_element *chain; /**< for chaining Elements */
782 } pset_Element, *pset_Segment;
784 /* not visible from outside */
786 unsigned p; /**< Next bucket to be split */
787 unsigned maxp; /**< upper bound on p during expansion */
788 unsigned nkey; /**< current # keys */
789 unsigned nseg; /**< current # segments */
790 pset_Segment *dir[DIRECTORY_SIZE];
791 int (*cmp)(); /**< function comparing entries */
792 unsigned iter_i, iter_j;
793 pset_Element *iter_tail; /**< non-NULL while iterating over elts */
794 pset_Element *free_list; /**< list of free Elements */
795 struct obstack obst; /**< obstack for allocation all data */
797 int naccess, ncollision, ndups;
801 const char *tag; /**< an optionally tag for distinguishing sets */
805 typedef struct set_element {
806 struct set_element *chain; /**< for chaining Elements */
808 } set_Element, *set_Segment;
810 /* not visible from outside */
812 unsigned p; /**< Next bucket to be split */
813 unsigned maxp; /**< upper bound on p during expansion */
814 unsigned nkey; /**< current # keys */
815 unsigned nseg; /**< current # segments */
816 set_Segment *dir[DIRECTORY_SIZE];
817 int (*cmp)(); /**< function comparing entries */
818 unsigned iter_i, iter_j;
819 set_Element *iter_tail; /**< non-NULL while iterating over elts */
820 struct obstack obst; /**< obstack for allocation all data */
822 int naccess, ncollision, ndups;
826 const char *tag; /**< an optionally tag for distinguishing sets */
831 * Find the longest chain of a pset
833 static HRESULT find_longest_pset_chain(DEBUGHELPER *pHelper, pset *set,
834 int *chains, int *lenght, size_t *size) {
836 pset_Segment *seg, *curr;
839 int len, nchains = 0, max_len = 0;
842 for (i = 0; i < set->nseg; ++i) {
845 dyns += sizeof(seg[j]) * SEGMENT_SIZE;
846 for (j = 0; j < SEGMENT_SIZE; ++j) {
847 if (copy_from_debuggee(&seg[j], pHelper, &curr, sizeof(curr)) != S_OK)
853 for (len = 0; address != NULL; address = elem.chain) {
854 if (copy_from_debuggee(address, pHelper, &elem, sizeof(elem)) != S_OK)
856 dyns += sizeof(pset_Element);
868 } /* find_longest_pset_chain */
871 * Find the longest chain of a set
873 static HRESULT find_longest_set_chain(DEBUGHELPER *pHelper, set *set,
874 int *chains, int *lenght, size_t *size) {
876 set_Segment *seg, *curr;
879 int len, nchains = 0, max_len = 0;
882 for (i = 0; i < set->nseg; ++i) {
885 dyns += sizeof(seg[j]) * SEGMENT_SIZE;
886 for (j = 0; j < SEGMENT_SIZE; ++j) {
887 if (copy_from_debuggee(&seg[j], pHelper, &curr, sizeof(curr)) != S_OK)
893 for (len = 0; address != NULL; address = elem.chain) {
894 if (copy_from_debuggee(address, pHelper, &elem, sizeof(elem)) != S_OK)
896 dyns += offsetof(set_Element, entry.dptr) + elem.entry.size;
908 } /* find_longest_set_chain */
913 HRESULT format_pset(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
917 int nchains, chain_len;
920 if (copy_from_debuggee(address, pHelper, &set, sizeof(set)) != S_OK)
923 if (find_longest_pset_chain(pHelper, &set, &nchains, &chain_len, &size) != S_OK)
928 _snprintf(name, sizeof(name), "nkey 0x%x nseg 0x%x nchain 0x%x maxlen 0x%x size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
931 _snprintf(name, sizeof(name), "nkey 0%o nseg 0%o nchain 0%o maxlen 0%o size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
934 _snprintf(name, sizeof(name), "nkey %u nseg %d nchain %d maxlen %d size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
936 _tcsncpy(pResult, name, max);
944 HRESULT format_set(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
948 int nchains, chain_len;
951 if (copy_from_debuggee(address, pHelper, &set, sizeof(set)) != S_OK)
954 if (find_longest_set_chain(pHelper, &set, &nchains, &chain_len, &size) != S_OK)
959 _snprintf(name, sizeof(name), "nkey 0x%x nseg 0x%x nchain 0x%x maxlen 0x%x size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
962 _snprintf(name, sizeof(name), "nkey 0%o nseg 0%o nchain 0%o maxlen 0%o size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
965 _snprintf(name, sizeof(name), "nkey %u nseg %d nchain %d maxlen %d size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
967 _tcsncpy(pResult, name, max);
973 unsigned magic; /**< debug magic, only available in DEBUG builds */
974 pdeq *l_end, *r_end; /**< left and right ends of the queue */
975 pdeq *l, *r; /**< left and right neighbor */
976 int n; /**< number of elements in the current chunk */
977 int p; /**< the read/write pointer */
978 const void *data[1]; /**< storage for elements */
981 /** Returns the length of a double ended pointer list. */
982 static int get_pdeq_len(DEBUGHELPER *pHelper, pdeq *dq)
991 if (copy_from_debuggee(q, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
1001 if (copy_from_debuggee(q, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
1007 } /* get_pdeq_len */
1012 HRESULT format_pdeq(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
1018 if (copy_from_debuggee(address, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
1021 len = get_pdeq_len(pHelper, &pdeq);
1027 _snprintf(name, sizeof(name), "pdeq 0x%x elem", len);
1030 _snprintf(name, sizeof(name), "pdeq 0%o elem", len);
1033 _snprintf(name, sizeof(name), "pdeq %d elem", len);
1035 _tcsncpy(pResult, name, max);
1040 /** show the first 2 units */
1041 static HRESULT fill_bits(DEBUGHELPER *pHelper, bitset_t *bs, char *pResult) {
1042 bitset_pos_t i, units = bs->units;
1043 int l = 0, o = 0, breaked = 0;
1046 for (i = 0; i < units; ++i) {
1049 if (copy_from_debuggee((void *)(BS_DATA(bs)[i]), pHelper, &data, sizeof(data)) != S_OK)
1052 for (j = 0; j < 32; ++j) {
1053 if (data & (1 << j)) {
1054 sprintf(pResult + l, "%d,", i * sizeof(data) * 8 + j);
1055 l += strlen(pResult + l);
1066 sprintf(pResult + l, "...");
1069 sprintf(pResult + l, "}");
1076 HRESULT format_bitset(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
1082 if (copy_from_debuggee(address, pHelper, &bs, sizeof(bs)) != S_OK)
1087 _snprintf(name, sizeof(name), "bitset{0x%x:", bs.size);
1090 _snprintf(name, sizeof(name), "bitset{0%o:", bs.size);
1093 _snprintf(name, sizeof(name), "bitset{%u:", bs.size);
1097 if (fill_bits(pHelper, &bs, &name[l]) != S_OK)
1101 _tcsncpy(pResult, name, max);
1104 } /* format_bitset */