int mdb_ctf_type_iter(const char *object, mdb_ctf_type_f *cb, void *data) { ctf_file_t *fp; mdb_tgt_t *t = mdb.m_target; int ret; type_iter_t ti; if (object == MDB_CTF_SYNTHETIC_ITER) fp = mdb.m_synth; else fp = mdb_tgt_name_to_ctf(t, object); if (fp == NULL) return (-1); ti.ti_cb = cb; ti.ti_arg = data; ti.ti_fp = fp; if ((ret = ctf_type_iter(fp, type_iter_cb, &ti)) == CTF_ERR) return (set_errno(ctf_to_errno(ctf_errno(fp)))); return (ret); }
/* * Check to see if there is ctf data in the given object. This is useful * so that we don't enter some loop where every call to lookup fails. */ int mdb_ctf_enabled_by_object(const char *object) { mdb_tgt_t *t = mdb.m_target; return (mdb_tgt_name_to_ctf(t, object) != NULL); }
int nm_symbol_iter(const char *object, uint_t which, uint_t type, mdb_tgt_sym_f *cb, nm_iter_info_t *niip) { mdb_tgt_t *t = mdb.m_target; if (object == MDB_TGT_OBJ_EVERY) { nm_object_iter_t noi; noi.noi_which = which; noi.noi_type = type; noi.noi_cb = cb; noi.noi_niip = niip; return (mdb_tgt_object_iter(t, nm_object_iter_cb, &noi)); } niip->nii_fp = mdb_tgt_name_to_ctf(t, object); return (mdb_tgt_symbol_iter(t, object, which, type, cb, niip)); }
/*ARGSUSED*/ static int obj_lookup(void *data, const mdb_map_t *mp, const char *name) { tnarg_t *tnp = data; ctf_file_t *fp; ctf_id_t id; if ((fp = mdb_tgt_name_to_ctf(tnp->tn_tgt, name)) != NULL && (id = ctf_lookup_by_name(fp, tnp->tn_name)) != CTF_ERR) { tnp->tn_fp = fp; tnp->tn_id = id; /* * We may have found a forward declaration. If we did, we'll * note the ID and file pointer, but we'll keep searching in * an attempt to find the real thing. If we found something * real (i.e. not a forward), we stop the iteration. */ return (ctf_type_kind(fp, id) == CTF_K_FORWARD ? 0 : -1); } return (0); }
/* * Convert a string type name with an optional leading object specifier into * the corresponding CTF file container and type ID. If an error occurs, we * print an appropriate message and return NULL. */ static ctf_file_t * name_to_type(mdb_tgt_t *t, const char *cname, ctf_id_t *idp) { const char *object = MDB_TGT_OBJ_EXEC; ctf_file_t *fp = NULL; ctf_id_t id; tnarg_t arg; char *p, *s; char buf[MDB_SYM_NAMLEN]; char *name = &buf[0]; (void) mdb_snprintf(buf, sizeof (buf), "%s", cname); if ((p = strrsplit(name, '`')) != NULL) { /* * We need to shuffle things around a little to support * type names of the form "struct module`name". */ if ((s = strsplit(name, ' ')) != NULL) { bcopy(cname + (s - name), name, (p - s) - 1); name[(p - s) - 1] = '\0'; bcopy(cname, name + (p - s), s - name); p = name + (p - s); } if (*name != '\0') object = name; name = p; } /* * Attempt to look up the name in the primary object file. If this * fails and the name was unscoped, search all remaining object files. * Finally, search the synthetic types. */ if (((fp = mdb_tgt_name_to_ctf(t, object)) == NULL || (id = ctf_lookup_by_name(fp, name)) == CTF_ERR || ctf_type_kind(fp, id) == CTF_K_FORWARD) && object == MDB_TGT_OBJ_EXEC) { arg.tn_tgt = t; arg.tn_name = name; arg.tn_fp = NULL; arg.tn_id = CTF_ERR; (void) mdb_tgt_object_iter(t, obj_lookup, &arg); if (arg.tn_id != CTF_ERR) { fp = arg.tn_fp; id = arg.tn_id; } else if (mdb.m_synth != NULL) { if ((id = ctf_lookup_by_name(mdb.m_synth, name)) != CTF_ERR) fp = mdb.m_synth; } } if (fp == NULL) return (NULL); /* errno is set for us */ if (id == CTF_ERR) { (void) set_errno(ctf_to_errno(ctf_errno(fp))); return (NULL); } *idp = id; return (fp); }