Lines Matching refs:cmp
100 ctf_merge_gettype(ctf_merge_types_t *cmp, ctf_id_t id)
102 if (cmp->cm_dedup == B_FALSE) {
103 VERIFY(cmp->cm_tmap[id].cmt_map != 0);
104 return (cmp->cm_tmap[id].cmt_map);
107 while (cmp->cm_tmap[id].cmt_missing == B_FALSE) {
108 VERIFY(cmp->cm_tmap[id].cmt_map != 0);
109 id = cmp->cm_tmap[id].cmt_map;
111 VERIFY(cmp->cm_tmap[id].cmt_map != 0);
112 return (cmp->cm_tmap[id].cmt_map);
119 ctf_merge_types_t *cmp = arg;
120 ctf_merge_tinfo_t *cmt = cmp->cm_tmap;
138 if (cmp->cm_unique == B_TRUE) {
159 } else if (ifp == cmp->cm_src) {
167 ctf_merge_add_number(ctf_merge_types_t *cmp, ctf_id_t id)
174 if (ctf_type_encoding(cmp->cm_src, id, &en) != 0)
177 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id);
178 name = ctf_strraw(cmp->cm_src, tp->ctt_name);
184 ret = ctf_add_encoded(cmp->cm_out, flags, name, &en,
185 ctf_type_kind(cmp->cm_src, id));
190 VERIFY(cmp->cm_tmap[id].cmt_map == 0);
191 cmp->cm_tmap[id].cmt_map = ret;
196 ctf_merge_add_array(ctf_merge_types_t *cmp, ctf_id_t id)
202 if (ctf_array_info(cmp->cm_src, id, &ar) == CTF_ERR)
205 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id);
211 if (cmp->cm_tmap[ar.ctr_contents].cmt_map == 0) {
212 ret = ctf_merge_add_type(cmp, ar.ctr_contents);
215 ASSERT(cmp->cm_tmap[ar.ctr_contents].cmt_map != 0);
217 ar.ctr_contents = ctf_merge_gettype(cmp, ar.ctr_contents);
219 if (cmp->cm_tmap[ar.ctr_index].cmt_map == 0) {
220 ret = ctf_merge_add_type(cmp, ar.ctr_index);
223 ASSERT(cmp->cm_tmap[ar.ctr_index].cmt_map != 0);
225 ar.ctr_index = ctf_merge_gettype(cmp, ar.ctr_index);
227 ret = ctf_add_array(cmp->cm_out, flags, &ar);
231 VERIFY(cmp->cm_tmap[id].cmt_map == 0);
232 cmp->cm_tmap[id].cmt_map = ret;
238 ctf_merge_add_reftype(ctf_merge_types_t *cmp, ctf_id_t id)
245 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id);
246 name = ctf_strraw(cmp->cm_src, tp->ctt_name);
252 reftype = ctf_type_reference(cmp->cm_src, id);
254 return (ctf_set_errno(cmp->cm_out, ctf_errno(cmp->cm_src)));
256 if (cmp->cm_tmap[reftype].cmt_map == 0) {
257 ret = ctf_merge_add_type(cmp, reftype);
260 ASSERT(cmp->cm_tmap[reftype].cmt_map != 0);
262 reftype = ctf_merge_gettype(cmp, reftype);
264 ret = ctf_add_reftype(cmp->cm_out, flags, name, reftype,
265 ctf_type_kind(cmp->cm_src, id));
269 VERIFY(cmp->cm_tmap[id].cmt_map == 0);
270 cmp->cm_tmap[id].cmt_map = ret;
275 ctf_merge_add_typedef(ctf_merge_types_t *cmp, ctf_id_t id)
282 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id);
283 name = ctf_strraw(cmp->cm_src, tp->ctt_name);
289 reftype = ctf_type_reference(cmp->cm_src, id);
291 return (ctf_set_errno(cmp->cm_out, ctf_errno(cmp->cm_src)));
293 if (cmp->cm_tmap[reftype].cmt_map == 0) {
294 ret = ctf_merge_add_type(cmp, reftype);
297 ASSERT(cmp->cm_tmap[reftype].cmt_map != 0);
299 reftype = ctf_merge_gettype(cmp, reftype);
301 ret = ctf_add_typedef(cmp->cm_out, flags, name, reftype);
305 VERIFY(cmp->cm_tmap[id].cmt_map == 0);
306 cmp->cm_tmap[id].cmt_map = ret;
325 ctf_merge_add_enum(ctf_merge_types_t *cmp, ctf_id_t id)
333 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id);
334 name = ctf_strraw(cmp->cm_src, tp->ctt_name);
340 enumid = ctf_add_enum(cmp->cm_out, flags, name);
344 cme.cme_fp = cmp->cm_out;
346 if (ctf_enum_iter(cmp->cm_src, id, ctf_merge_add_enumerator,
350 VERIFY(cmp->cm_tmap[id].cmt_map == 0);
351 cmp->cm_tmap[id].cmt_map = enumid;
356 ctf_merge_add_func(ctf_merge_types_t *cmp, ctf_id_t id)
363 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id);
369 if (ctf_func_info_by_id(cmp->cm_src, id, &ctc) == CTF_ERR)
370 return (ctf_set_errno(cmp->cm_out, ctf_errno(cmp->cm_src)));
374 return (ctf_set_errno(cmp->cm_out, ENOMEM));
375 if (ctf_func_args_by_id(cmp->cm_src, id, ctc.ctc_argc, argv) ==
378 return (ctf_set_errno(cmp->cm_out, ctf_errno(cmp->cm_src)));
381 if (cmp->cm_tmap[ctc.ctc_return].cmt_map == 0) {
382 ret = ctf_merge_add_type(cmp, ctc.ctc_return);
385 ASSERT(cmp->cm_tmap[ctc.ctc_return].cmt_map != 0);
387 ctc.ctc_return = ctf_merge_gettype(cmp, ctc.ctc_return);
390 if (cmp->cm_tmap[argv[i]].cmt_map == 0) {
391 ret = ctf_merge_add_type(cmp, argv[i]);
394 ASSERT(cmp->cm_tmap[argv[i]].cmt_map != 0);
396 argv[i] = ctf_merge_gettype(cmp, argv[i]);
399 ret = ctf_add_funcptr(cmp->cm_out, flags, &ctc, argv);
404 VERIFY(cmp->cm_tmap[id].cmt_map == 0);
405 cmp->cm_tmap[id].cmt_map = ret;
410 ctf_merge_add_forward(ctf_merge_types_t *cmp, ctf_id_t id)
416 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id);
417 name = ctf_strraw(cmp->cm_src, tp->ctt_name);
430 ret = ctf_add_forward(cmp->cm_out, flags, name, CTF_K_STRUCT);
434 VERIFY(cmp->cm_tmap[id].cmt_map == 0);
435 cmp->cm_tmap[id].cmt_map = ret;
463 ctf_merge_add_sou(ctf_merge_types_t *cmp, ctf_id_t id, boolean_t forward)
470 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id);
471 name = ctf_strraw(cmp->cm_src, tp->ctt_name);
476 kind = ctf_type_kind(cmp->cm_src, id);
479 suid = ctf_add_struct(cmp->cm_out, flags, name);
481 suid = ctf_add_union(cmp->cm_out, flags, name);
491 VERIFY(cmp->cm_tmap[id].cmt_map == 0);
492 cmp->cm_tmap[id].cmt_map = suid;
496 VERIFY(cmp->cm_tmap[id].cmt_map == suid);
498 cmp->cm_tmap[id].cmt_fixup = B_TRUE;
504 ctf_merge_add_type(ctf_merge_types_t *cmp, ctf_id_t id)
513 if (cmp->cm_tmap[id].cmt_map != 0)
516 kind = ctf_type_kind(cmp->cm_src, id);
520 ret = ctf_merge_add_number(cmp, id);
523 ret = ctf_merge_add_array(cmp, id);
529 ret = ctf_merge_add_reftype(cmp, id);
532 ret = ctf_merge_add_typedef(cmp, id);
535 ret = ctf_merge_add_enum(cmp, id);
538 ret = ctf_merge_add_func(cmp, id);
541 ret = ctf_merge_add_forward(cmp, id);
545 ret = ctf_merge_add_sou(cmp, id, B_FALSE);
561 ctf_merge_fixup_sou(ctf_merge_types_t *cmp, ctf_id_t id)
568 mapid = cmp->cm_tmap[id].cmt_map;
570 dtd = ctf_dtd_lookup(cmp->cm_out, mapid);
574 cms.cms_cm = cmp;
576 if (ctf_member_iter(cmp->cm_src, id, ctf_merge_add_member, &cms) != 0)
579 if ((size = ctf_type_size(cmp->cm_src, id)) == CTF_ERR)
581 if (ctf_set_size(cmp->cm_out, mapid, size) == CTF_ERR)
588 ctf_merge_fixup_type(ctf_merge_types_t *cmp, ctf_id_t id)
592 kind = ctf_type_kind(cmp->cm_src, id);
596 ret = ctf_merge_fixup_sou(cmp, id);
615 ctf_merge_fixup_dedup_map(ctf_merge_types_t *cmp)
619 for (i = 1; i < cmp->cm_src->ctf_typemax + 1; i++) {
626 if (cmp->cm_tmap[i].cmt_missing == B_TRUE) {
627 VERIFY(cmp->cm_tmap[i].cmt_map != 0);
632 while (cmp->cm_tmap[tid].cmt_missing == B_FALSE) {
633 VERIFY(cmp->cm_tmap[tid].cmt_map != 0);
634 tid = cmp->cm_tmap[tid].cmt_map;
636 VERIFY(cmp->cm_tmap[tid].cmt_map != 0);
637 cmp->cm_tmap[i].cmt_map = cmp->cm_tmap[tid].cmt_map;
660 ctf_merge_common(ctf_merge_types_t *cmp)
664 ctf_phase_dump(cmp->cm_src, "merge-common-src");
665 ctf_phase_dump(cmp->cm_out, "merge-common-dest");
668 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) {
669 if (cmp->cm_tmap[i].cmt_forward == B_TRUE) {
670 ret = ctf_merge_add_sou(cmp, i, B_TRUE);
678 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) {
679 if (cmp->cm_tmap[i].cmt_missing == B_TRUE) {
680 ret = ctf_merge_add_type(cmp, i);
688 ret = ctf_update(cmp->cm_out);
692 if (cmp->cm_dedup == B_TRUE) {
693 ctf_merge_fixup_dedup_map(cmp);
698 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) {
699 if (cmp->cm_tmap[i].cmt_fixup == B_TRUE) {
700 ret = ctf_merge_fixup_type(cmp, i);
706 if (cmp->cm_dedup == B_TRUE) {
707 ctf_merge_fixup_dedup_map(cmp);
720 ctf_merge_uniquify_types(ctf_merge_types_t *cmp)
724 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) {
725 if (cmp->cm_tmap[i].cmt_missing == B_FALSE)
727 ret = ctf_merge_add_type(cmp, i);
732 ret = ctf_update(cmp->cm_out);
736 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) {
737 if (cmp->cm_tmap[i].cmt_fixup == B_FALSE)
739 ret = ctf_merge_fixup_type(cmp, i);
748 ctf_merge_types_init(ctf_merge_types_t *cmp)
750 cmp->cm_tmap = ctf_alloc(sizeof (ctf_merge_tinfo_t) *
751 (cmp->cm_src->ctf_typemax + 1));
752 if (cmp->cm_tmap == NULL)
753 return (ctf_set_errno(cmp->cm_out, ENOMEM));
754 bzero(cmp->cm_tmap, sizeof (ctf_merge_tinfo_t) *
755 (cmp->cm_src->ctf_typemax + 1));
760 ctf_merge_types_fini(ctf_merge_types_t *cmp)
762 ctf_free(cmp->cm_tmap, sizeof (ctf_merge_tinfo_t) *
763 (cmp->cm_src->ctf_typemax + 1));
863 ctf_merge_fixup_nontypes(ctf_merge_types_t *cmp, ctf_merge_input_t *cmi)
872 VERIFY(cmp->cm_tmap[cmo->cmo_tid].cmt_map != 0);
873 cmo->cmo_tid = cmp->cm_tmap[cmo->cmo_tid].cmt_map;
880 VERIFY(cmp->cm_tmap[cmf->cmf_rtid].cmt_map != 0);
881 cmf->cmf_rtid = cmp->cm_tmap[cmf->cmf_rtid].cmt_map;
883 VERIFY(cmp->cm_tmap[cmf->cmf_args[i]].cmt_map !=
886 cmp->cm_tmap[cmf->cmf_args[i]].cmt_map;
1423 ctf_merge_types_t *cmp = arg;
1424 ctf_merge_tinfo_t *cmt = cmp->cm_tmap;
1458 ctf_merge_dedup(ctf_merge_t *cmp, ctf_file_t **outp)
1466 if (cmp == NULL || outp == NULL)
1469 ctf_dprintf("encountered %d inputs\n", cmp->cmh_ninputs);
1470 if (cmp->cmh_ninputs != 2)
1475 cmi = list_head(&cmp->cmh_inputs);
1477 cmc = list_next(&cmp->cmh_inputs, cmi);
1515 if (cmp->cmh_msyms == B_TRUE) {
1516 ret = ctf_merge_symbols(cmp, cm.cm_out);
1524 ret = ctf_merge_functions(cmp, cm.cm_out);
1545 ctf_merge_set_nthreads(ctf_merge_t *cmp, const uint_t nthrs)
1549 cmp->cmh_nthreads = nthrs;