4
* The contents of this file are subject to the terms of the
5
* Common Development and Distribution License (the "License").
6
* You may not use this file except in compliance with the License.
8
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9
* or http://www.opensolaris.org/os/licensing.
10
* See the License for the specific language governing permissions
11
* and limitations under the License.
13
* When distributing Covered Code, include this CDDL HEADER in each
14
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15
* If applicable, add the following below this CDDL HEADER, with the
16
* fields enclosed by brackets "[]" replaced with your own identifying
17
* information: Portions Copyright [yyyy] [name of copyright owner]
22
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23
* Use is subject to license terms.
26
#pragma ident "%Z%%M% %I% %E% SMI"
29
* This file contains routines that merge one tdata_t tree, called the child,
30
* into another, called the parent. Note that these names are used mainly for
31
* convenience and to represent the direction of the merge. They are not meant
32
* to imply any relationship between the tdata_t graphs prior to the merge.
34
* tdata_t structures contain two main elements - a hash of iidesc_t nodes, and
35
* a directed graph of tdesc_t nodes, pointed to by the iidesc_t nodes. Simply
36
* put, we merge the tdesc_t graphs, followed by the iidesc_t nodes, and then we
37
* clean up loose ends.
39
* The algorithm is as follows:
41
* 1. Mapping iidesc_t nodes
43
* For each child iidesc_t node, we first try to map its tdesc_t subgraph
44
* against the tdesc_t graph in the parent. For each node in the child subgraph
45
* that exists in the parent, a mapping between the two (between their type IDs)
46
* is established. For the child nodes that cannot be mapped onto existing
47
* parent nodes, a mapping is established between the child node ID and a
48
* newly-allocated ID that the node will use when it is re-created in the
49
* parent. These unmappable nodes are added to the md_tdtba (tdesc_t To Be
50
* Added) hash, which tracks nodes that need to be created in the parent.
52
* If all of the nodes in the subgraph for an iidesc_t in the child can be
53
* mapped to existing nodes in the parent, then we can try to map the child
54
* iidesc_t onto an iidesc_t in the parent. If we cannot find an equivalent
55
* iidesc_t, or if we were not able to completely map the tdesc_t subgraph(s),
56
* then we add this iidesc_t to the md_iitba (iidesc_t To Be Added) list. This
57
* list tracks iidesc_t nodes that are to be created in the parent.
59
* While visiting the tdesc_t nodes, we may discover a forward declaration (a
60
* FORWARD tdesc_t) in the parent that is resolved in the child. That is, there
61
* may be a structure or union definition in the child with the same name as the
62
* forward declaration in the parent. If we find such a node, we record an
63
* association in the md_fdida (Forward => Definition ID Association) list
64
* between the parent ID of the forward declaration and the ID that the
65
* definition will use when re-created in the parent.
67
* 2. Creating new tdesc_t nodes (the md_tdtba hash)
69
* We have now attempted to map all tdesc_t nodes from the child into the
70
* parent, and have, in md_tdtba, a hash of all tdesc_t nodes that need to be
71
* created (or, as we so wittily call it, conjured) in the parent. We iterate
72
* through this hash, creating the indicated tdesc_t nodes. For a given tdesc_t
73
* node, conjuring requires two steps - the copying of the common tdesc_t data
74
* (name, type, etc) from the child node, and the creation of links from the
75
* newly-created node to the parent equivalents of other tdesc_t nodes pointed
76
* to by node being conjured. Note that in some cases, the targets of these
77
* links will be on the md_tdtba hash themselves, and may not have been created
78
* yet. As such, we can't establish the links from these new nodes into the
79
* parent graph. We therefore conjure them with links to nodes in the *child*
80
* graph, and add pointers to the links to be created to the md_tdtbr (tdesc_t
81
* To Be Remapped) hash. For example, a POINTER tdesc_t that could not be
82
* resolved would have its &tdesc_t->t_tdesc added to md_tdtbr.
84
* 3. Creating new iidesc_t nodes (the md_iitba list)
86
* When we have completed step 2, all tdesc_t nodes have been created (or
87
* already existed) in the parent. Some of them may have incorrect links (the
88
* members of the md_tdtbr list), but they've all been created. As such, we can
89
* create all of the iidesc_t nodes, as we can attach the tdesc_t subgraph
90
* pointers correctly. We create each node, and attach the pointers to the
91
* appropriate parts of the parent tdesc_t graph.
93
* 4. Resolving newly-created tdesc_t node links (the md_tdtbr list)
95
* As in step 3, we rely on the fact that all of the tdesc_t nodes have been
96
* created. Each entry in the md_tdtbr list is a pointer to where a link into
97
* the parent will be established. As saved in the md_tdtbr list, these
98
* pointers point into the child tdesc_t subgraph. We can thus get the target
99
* type ID from the child, look at the ID mapping to determine the desired link
100
* target, and redirect the link accordingly.
102
* 5. Parent => child forward declaration resolution
104
* If entries were made in the md_fdida list in step 1, we have forward
105
* declarations in the parent that need to be resolved to their definitions
106
* re-created in step 2 from the child. Using the md_fdida list, we can locate
107
* the definition for the forward declaration, and we can redirect all inbound
108
* edges to the forward declaration node to the actual definition.
110
* A pox on the house of anyone who changes the algorithm without updating
119
#include "ctf_headers.h"
120
#include "ctftools.h"
124
#include "traverse.h"
126
typedef struct equiv_data equiv_data_t;
127
typedef struct merge_cb_data merge_cb_data_t;
130
* There are two traversals in this file, for equivalency and for tdesc_t
131
* re-creation, that do not fit into the tdtraverse() framework. We have our
132
* own traversal mechanism and ops vector here for those two cases.
134
typedef struct tdesc_ops {
136
int (*equiv)(tdesc_t *, tdesc_t *, equiv_data_t *);
137
tdesc_t *(*conjure)(tdesc_t *, int, merge_cb_data_t *);
139
extern tdesc_ops_t tdesc_ops[];
142
* The workhorse structure of tdata_t merging. Holds all lists of nodes to be
143
* processed during various phases of the merge algorithm.
145
struct merge_cb_data {
148
alist_t *md_ta; /* Type Association */
149
alist_t *md_fdida; /* Forward -> Definition ID Association */
150
list_t **md_iitba; /* iidesc_t nodes To Be Added to the parent */
151
hash_t *md_tdtba; /* tdesc_t nodes To Be Added to the parent */
152
list_t **md_tdtbr; /* tdesc_t nodes To Be Remapped */
154
}; /* merge_cb_data_t */
157
* When we first create a tdata_t from stabs data, we will have duplicate nodes.
158
* Normal merges, however, assume that the child tdata_t is already self-unique,
159
* and for speed reasons do not attempt to self-uniquify. If this flag is set,
160
* the merge algorithm will self-uniquify by avoiding the insertion of
161
* duplicates in the md_tdtdba list.
163
#define MCD_F_SELFUNIQUIFY 0x1
166
* When we merge the CTF data for the modules, we don't want it to contain any
167
* data that can be found in the reference module (usually genunix). If this
168
* flag is set, we're doing a merge between the fully merged tdata_t for this
169
* module and the tdata_t for the reference module, with the data unique to this
170
* module ending up in a third tdata_t. It is this third tdata_t that will end
171
* up in the .SUNW_ctf section for the module.
173
#define MCD_F_REFMERGE 0x2
176
* Mapping of child type IDs to parent type IDs
180
add_mapping(alist_t *ta, tid_t srcid, tid_t tgtid)
182
debug(3, "Adding mapping %u <%x> => %u <%x>\n", srcid, srcid, tgtid, tgtid);
184
assert(!alist_find(ta, (void *)(uintptr_t)srcid, NULL));
185
assert(srcid != 0 && tgtid != 0);
187
alist_add(ta, (void *)(uintptr_t)srcid, (void *)(uintptr_t)tgtid);
191
get_mapping(alist_t *ta, int srcid)
195
if (alist_find(ta, (void *)(uintptr_t)srcid, (void **)<gtid))
196
return ((uintptr_t)ltgtid);
202
* Determining equivalence of tdesc_t subgraphs
213
}; /* equiv_data_t */
215
static int equiv_node(tdesc_t *, tdesc_t *, equiv_data_t *);
219
equiv_intrinsic(tdesc_t *stdp, tdesc_t *ttdp, equiv_data_t *ed __unused)
221
intr_t *si = stdp->t_intr;
222
intr_t *ti = ttdp->t_intr;
224
if (si->intr_type != ti->intr_type ||
225
si->intr_signed != ti->intr_signed ||
226
si->intr_offset != ti->intr_offset ||
227
si->intr_nbits != ti->intr_nbits)
230
if (si->intr_type == INTR_INT &&
231
si->intr_iformat != ti->intr_iformat)
233
else if (si->intr_type == INTR_REAL &&
234
si->intr_fformat != ti->intr_fformat)
241
equiv_plain(tdesc_t *stdp, tdesc_t *ttdp, equiv_data_t *ed)
243
return (equiv_node(stdp->t_tdesc, ttdp->t_tdesc, ed));
247
equiv_function(tdesc_t *stdp, tdesc_t *ttdp, equiv_data_t *ed)
249
fndef_t *fn1 = stdp->t_fndef, *fn2 = ttdp->t_fndef;
252
if (fn1->fn_nargs != fn2->fn_nargs ||
253
fn1->fn_vargs != fn2->fn_vargs)
256
if (!equiv_node(fn1->fn_ret, fn2->fn_ret, ed))
259
for (i = 0; i < (int) fn1->fn_nargs; i++) {
260
if (!equiv_node(fn1->fn_args[i], fn2->fn_args[i], ed))
268
equiv_array(tdesc_t *stdp, tdesc_t *ttdp, equiv_data_t *ed)
270
ardef_t *ar1 = stdp->t_ardef, *ar2 = ttdp->t_ardef;
272
if (!equiv_node(ar1->ad_contents, ar2->ad_contents, ed) ||
273
!equiv_node(ar1->ad_idxtype, ar2->ad_idxtype, ed))
276
if (ar1->ad_nelems != ar2->ad_nelems)
283
equiv_su(tdesc_t *stdp, tdesc_t *ttdp, equiv_data_t *ed)
285
mlist_t *ml1 = stdp->t_members, *ml2 = ttdp->t_members;
286
mlist_t *olm1 = NULL;
289
if (ml1->ml_offset != ml2->ml_offset ||
290
strcmp(ml1->ml_name, ml2->ml_name) != 0)
294
* Don't do the recursive equivalency checking more than
297
if (olm1 == NULL || olm1->ml_type->t_id != ml1->ml_type->t_id) {
298
if (ml1->ml_size != ml2->ml_size ||
299
!equiv_node(ml1->ml_type, ml2->ml_type, ed))
316
equiv_enum(tdesc_t *stdp, tdesc_t *ttdp, equiv_data_t *ed __unused)
318
elist_t *el1 = stdp->t_emem;
319
elist_t *el2 = ttdp->t_emem;
322
if (el1->el_number != el2->el_number ||
323
strcmp(el1->el_name, el2->el_name) != 0)
338
equiv_assert(tdesc_t *stdp __unused, tdesc_t *ttdp __unused, equiv_data_t *ed __unused)
340
/* foul, evil, and very bad - this is a "shouldn't happen" */
347
fwd_equiv(tdesc_t *ctdp, tdesc_t *mtdp)
349
tdesc_t *defn = (ctdp->t_type == FORWARD ? mtdp : ctdp);
351
return (defn->t_type == STRUCT || defn->t_type == UNION);
355
equiv_node(tdesc_t *ctdp, tdesc_t *mtdp, equiv_data_t *ed)
357
int (*equiv)(tdesc_t *, tdesc_t *, equiv_data_t *);
360
if (ctdp->t_emark > ed->ed_clear_mark ||
361
mtdp->t_emark > ed->ed_clear_mark)
362
return (ctdp->t_emark == mtdp->t_emark);
365
* In normal (non-self-uniquify) mode, we don't want to do equivalency
366
* checking on a subgraph that has already been checked. If a mapping
367
* has already been established for a given child node, we can simply
368
* compare the mapping for the child node with the ID of the parent
369
* node. If we are in self-uniquify mode, then we're comparing two
370
* subgraphs within the child graph, and thus need to ignore any
371
* type mappings that have been created, as they are only valid into the
374
if ((mapping = get_mapping(ed->ed_ta, ctdp->t_id)) > 0 &&
375
mapping == mtdp->t_id && !ed->ed_selfuniquify)
378
if (!streq(ctdp->t_name, mtdp->t_name))
381
if (ctdp->t_type != mtdp->t_type) {
382
if (ctdp->t_type == FORWARD || mtdp->t_type == FORWARD)
383
return (fwd_equiv(ctdp, mtdp));
388
ctdp->t_emark = ed->ed_cur_mark;
389
mtdp->t_emark = ed->ed_cur_mark;
392
if ((equiv = tdesc_ops[ctdp->t_type].equiv) != NULL)
393
return (equiv(ctdp, mtdp, ed));
399
* We perform an equivalency check on two subgraphs by traversing through them
400
* in lockstep. If a given node is equivalent in both the parent and the child,
401
* we mark it in both subgraphs, using the t_emark field, with a monotonically
402
* increasing number. If, in the course of the traversal, we reach a node that
403
* we have visited and numbered during this equivalency check, we have a cycle.
404
* If the previously-visited nodes don't have the same emark, then the edges
405
* that brought us to these nodes are not equivalent, and so the check ends.
406
* If the emarks are the same, the edges are equivalent. We then backtrack and
407
* continue the traversal. If we have exhausted all edges in the subgraph, and
408
* have not found any inequivalent nodes, then the subgraphs are equivalent.
411
equiv_cb(void *bucket, void *arg)
413
equiv_data_t *ed = arg;
414
tdesc_t *mtdp = bucket;
415
tdesc_t *ctdp = ed->ed_node;
417
ed->ed_clear_mark = ed->ed_cur_mark + 1;
418
ed->ed_cur_mark = ed->ed_clear_mark + 1;
420
if (equiv_node(ctdp, mtdp, ed)) {
421
debug(3, "equiv_node matched %d <%x> %d <%x>\n",
422
ctdp->t_id, ctdp->t_id, mtdp->t_id, mtdp->t_id);
424
/* matched. stop looking */
433
map_td_tree_pre(tdesc_t *ctdp, tdesc_t **ctdpp __unused, void *private)
435
merge_cb_data_t *mcd = private;
437
if (get_mapping(mcd->md_ta, ctdp->t_id) > 0)
445
map_td_tree_post(tdesc_t *ctdp, tdesc_t **ctdpp __unused, void *private)
447
merge_cb_data_t *mcd = private;
450
ed.ed_ta = mcd->md_ta;
451
ed.ed_clear_mark = mcd->md_parent->td_curemark;
452
ed.ed_cur_mark = mcd->md_parent->td_curemark + 1;
454
ed.ed_selfuniquify = 0;
456
debug(3, "map_td_tree_post on %d <%x> %s\n", ctdp->t_id, ctdp->t_id,tdesc_name(ctdp));
458
if (hash_find_iter(mcd->md_parent->td_layouthash, ctdp,
459
equiv_cb, &ed) < 0) {
460
/* We found an equivalent node */
461
if (ed.ed_tgt->t_type == FORWARD && ctdp->t_type != FORWARD) {
462
int id = mcd->md_tgt->td_nextid++;
464
debug(3, "Creating new defn type %d <%x>\n", id, id);
465
add_mapping(mcd->md_ta, ctdp->t_id, id);
466
alist_add(mcd->md_fdida, (void *)(ulong_t)ed.ed_tgt,
467
(void *)(ulong_t)id);
468
hash_add(mcd->md_tdtba, ctdp);
470
add_mapping(mcd->md_ta, ctdp->t_id, ed.ed_tgt->t_id);
472
} else if (debug_level > 1 && hash_iter(mcd->md_parent->td_idhash,
473
equiv_cb, &ed) < 0) {
475
* We didn't find an equivalent node by looking through the
476
* layout hash, but we somehow found it by performing an
477
* exhaustive search through the entire graph. This usually
478
* means that the "name" hash function is broken.
480
aborterr("Second pass for %d (%s) == %d\n", ctdp->t_id,
481
tdesc_name(ctdp), ed.ed_tgt->t_id);
483
int id = mcd->md_tgt->td_nextid++;
485
debug(3, "Creating new type %d <%x>\n", id, id);
486
add_mapping(mcd->md_ta, ctdp->t_id, id);
487
hash_add(mcd->md_tdtba, ctdp);
490
mcd->md_parent->td_curemark = ed.ed_cur_mark + 1;
497
map_td_tree_self_post(tdesc_t *ctdp, tdesc_t **ctdpp __unused, void *private)
499
merge_cb_data_t *mcd = private;
502
ed.ed_ta = mcd->md_ta;
503
ed.ed_clear_mark = mcd->md_parent->td_curemark;
504
ed.ed_cur_mark = mcd->md_parent->td_curemark + 1;
506
ed.ed_selfuniquify = 1;
509
if (hash_find_iter(mcd->md_tdtba, ctdp, equiv_cb, &ed) < 0) {
510
debug(3, "Self check found %d <%x> in %d <%x>\n", ctdp->t_id,
511
ctdp->t_id, ed.ed_tgt->t_id, ed.ed_tgt->t_id);
512
add_mapping(mcd->md_ta, ctdp->t_id,
513
get_mapping(mcd->md_ta, ed.ed_tgt->t_id));
514
} else if (debug_level > 1 && hash_iter(mcd->md_tdtba,
515
equiv_cb, &ed) < 0) {
517
* We didn't find an equivalent node using the quick way (going
518
* through the hash normally), but we did find it by iterating
519
* through the entire hash. This usually means that the hash
520
* function is broken.
522
aborterr("Self-unique second pass for %d <%x> (%s) == %d <%x>\n",
523
ctdp->t_id, ctdp->t_id, tdesc_name(ctdp), ed.ed_tgt->t_id,
526
int id = mcd->md_tgt->td_nextid++;
528
debug(3, "Creating new type %d <%x>\n", id, id);
529
add_mapping(mcd->md_ta, ctdp->t_id, id);
530
hash_add(mcd->md_tdtba, ctdp);
533
mcd->md_parent->td_curemark = ed.ed_cur_mark + 1;
538
static tdtrav_cb_f map_pre[] = {
540
map_td_tree_pre, /* intrinsic */
541
map_td_tree_pre, /* pointer */
542
map_td_tree_pre, /* array */
543
map_td_tree_pre, /* function */
544
map_td_tree_pre, /* struct */
545
map_td_tree_pre, /* union */
546
map_td_tree_pre, /* enum */
547
map_td_tree_pre, /* forward */
548
map_td_tree_pre, /* typedef */
549
tdtrav_assert, /* typedef_unres */
550
map_td_tree_pre, /* volatile */
551
map_td_tree_pre, /* const */
552
map_td_tree_pre /* restrict */
555
static tdtrav_cb_f map_post[] = {
557
map_td_tree_post, /* intrinsic */
558
map_td_tree_post, /* pointer */
559
map_td_tree_post, /* array */
560
map_td_tree_post, /* function */
561
map_td_tree_post, /* struct */
562
map_td_tree_post, /* union */
563
map_td_tree_post, /* enum */
564
map_td_tree_post, /* forward */
565
map_td_tree_post, /* typedef */
566
tdtrav_assert, /* typedef_unres */
567
map_td_tree_post, /* volatile */
568
map_td_tree_post, /* const */
569
map_td_tree_post /* restrict */
572
static tdtrav_cb_f map_self_post[] = {
574
map_td_tree_self_post, /* intrinsic */
575
map_td_tree_self_post, /* pointer */
576
map_td_tree_self_post, /* array */
577
map_td_tree_self_post, /* function */
578
map_td_tree_self_post, /* struct */
579
map_td_tree_self_post, /* union */
580
map_td_tree_self_post, /* enum */
581
map_td_tree_self_post, /* forward */
582
map_td_tree_self_post, /* typedef */
583
tdtrav_assert, /* typedef_unres */
584
map_td_tree_self_post, /* volatile */
585
map_td_tree_self_post, /* const */
586
map_td_tree_self_post /* restrict */
590
* Determining equivalence of iidesc_t nodes
593
typedef struct iifind_data {
594
iidesc_t *iif_template;
601
* Check to see if this iidesc_t (node) - the current one on the list we're
602
* iterating through - matches the target one (iif->iif_template). Return -1
603
* if it matches, to stop the iteration.
606
iidesc_match(void *data, void *arg)
608
iidesc_t *node = data;
609
iifind_data_t *iif = arg;
612
if (node->ii_type != iif->iif_template->ii_type ||
613
!streq(node->ii_name, iif->iif_template->ii_name) ||
614
node->ii_dtype->t_id != iif->iif_newidx)
617
if ((node->ii_type == II_SVAR || node->ii_type == II_SFUN) &&
618
!streq(node->ii_owner, iif->iif_template->ii_owner))
621
if (node->ii_nargs != iif->iif_template->ii_nargs)
624
for (i = 0; i < node->ii_nargs; i++) {
625
if (get_mapping(iif->iif_ta,
626
iif->iif_template->ii_args[i]->t_id) !=
627
node->ii_args[i]->t_id)
631
if (iif->iif_refmerge) {
632
switch (iif->iif_template->ii_type) {
637
debug(3, "suppressing duping of %d %s from %s\n",
638
iif->iif_template->ii_type,
639
iif->iif_template->ii_name,
640
(iif->iif_template->ii_owner ?
641
iif->iif_template->ii_owner : "NULL"));
655
merge_type_cb(void *data, void *arg)
657
iidesc_t *sii = data;
658
merge_cb_data_t *mcd = arg;
662
post = (mcd->md_flags & MCD_F_SELFUNIQUIFY ? map_self_post : map_post);
664
/* Map the tdesc nodes */
665
(void) iitraverse(sii, &mcd->md_parent->td_curvgen, NULL, map_pre, post,
668
/* Map the iidesc nodes */
669
iif.iif_template = sii;
670
iif.iif_ta = mcd->md_ta;
671
iif.iif_newidx = get_mapping(mcd->md_ta, sii->ii_dtype->t_id);
672
iif.iif_refmerge = (mcd->md_flags & MCD_F_REFMERGE);
674
if (hash_match(mcd->md_parent->td_iihash, sii, iidesc_match,
676
/* successfully mapped */
679
debug(3, "tba %s (%d)\n", (sii->ii_name ? sii->ii_name : "(anon)"),
682
list_add(mcd->md_iitba, sii);
688
remap_node(tdesc_t **tgtp, tdesc_t *oldtgt, int selftid, tdesc_t *newself,
689
merge_cb_data_t *mcd)
693
int oldid = oldtgt->t_id;
695
if (oldid == selftid) {
700
if ((template.t_id = get_mapping(mcd->md_ta, oldid)) == 0)
701
aborterr("failed to get mapping for tid %d <%x>\n", oldid, oldid);
703
if (!hash_find(mcd->md_parent->td_idhash, (void *)&template,
704
(void *)&tgt) && (!(mcd->md_flags & MCD_F_REFMERGE) ||
705
!hash_find(mcd->md_tgt->td_idhash, (void *)&template,
707
debug(3, "Remap couldn't find %d <%x> (from %d <%x>)\n", template.t_id,
708
template.t_id, oldid, oldid);
710
list_add(mcd->md_tdtbr, tgtp);
719
conjure_template(tdesc_t *old, int newselfid)
721
tdesc_t *new = xcalloc(sizeof (tdesc_t));
723
new->t_name = old->t_name ? xstrdup(old->t_name) : NULL;
724
new->t_type = old->t_type;
725
new->t_size = old->t_size;
726
new->t_id = newselfid;
727
new->t_flags = old->t_flags;
734
conjure_intrinsic(tdesc_t *old, int newselfid, merge_cb_data_t *mcd __unused)
736
tdesc_t *new = conjure_template(old, newselfid);
738
new->t_intr = xmalloc(sizeof (intr_t));
739
bcopy(old->t_intr, new->t_intr, sizeof (intr_t));
745
conjure_plain(tdesc_t *old, int newselfid, merge_cb_data_t *mcd)
747
tdesc_t *new = conjure_template(old, newselfid);
749
(void) remap_node(&new->t_tdesc, old->t_tdesc, old->t_id, new, mcd);
755
conjure_function(tdesc_t *old, int newselfid, merge_cb_data_t *mcd)
757
tdesc_t *new = conjure_template(old, newselfid);
758
fndef_t *nfn = xmalloc(sizeof (fndef_t));
759
fndef_t *ofn = old->t_fndef;
762
(void) remap_node(&nfn->fn_ret, ofn->fn_ret, old->t_id, new, mcd);
764
nfn->fn_nargs = ofn->fn_nargs;
765
nfn->fn_vargs = ofn->fn_vargs;
767
if (nfn->fn_nargs > 0)
768
nfn->fn_args = xcalloc(sizeof (tdesc_t *) * ofn->fn_nargs);
770
for (i = 0; i < (int) ofn->fn_nargs; i++) {
771
(void) remap_node(&nfn->fn_args[i], ofn->fn_args[i], old->t_id,
781
conjure_array(tdesc_t *old, int newselfid, merge_cb_data_t *mcd)
783
tdesc_t *new = conjure_template(old, newselfid);
784
ardef_t *nar = xmalloc(sizeof (ardef_t));
785
ardef_t *oar = old->t_ardef;
787
(void) remap_node(&nar->ad_contents, oar->ad_contents, old->t_id, new,
789
(void) remap_node(&nar->ad_idxtype, oar->ad_idxtype, old->t_id, new,
792
nar->ad_nelems = oar->ad_nelems;
800
conjure_su(tdesc_t *old, int newselfid, merge_cb_data_t *mcd)
802
tdesc_t *new = conjure_template(old, newselfid);
803
mlist_t *omem, **nmemp;
805
for (omem = old->t_members, nmemp = &new->t_members;
806
omem; omem = omem->ml_next, nmemp = &((*nmemp)->ml_next)) {
807
*nmemp = xmalloc(sizeof (mlist_t));
808
(*nmemp)->ml_offset = omem->ml_offset;
809
(*nmemp)->ml_size = omem->ml_size;
810
(*nmemp)->ml_name = xstrdup(omem->ml_name ? omem->ml_name : "empty omem->ml_name");
811
(void) remap_node(&((*nmemp)->ml_type), omem->ml_type,
812
old->t_id, new, mcd);
821
conjure_enum(tdesc_t *old, int newselfid, merge_cb_data_t *mcd __unused)
823
tdesc_t *new = conjure_template(old, newselfid);
824
elist_t *oel, **nelp;
826
for (oel = old->t_emem, nelp = &new->t_emem;
827
oel; oel = oel->el_next, nelp = &((*nelp)->el_next)) {
828
*nelp = xmalloc(sizeof (elist_t));
829
(*nelp)->el_name = xstrdup(oel->el_name);
830
(*nelp)->el_number = oel->el_number;
839
conjure_forward(tdesc_t *old, int newselfid, merge_cb_data_t *mcd)
841
tdesc_t *new = conjure_template(old, newselfid);
843
list_add(&mcd->md_tgt->td_fwdlist, new);
850
conjure_assert(tdesc_t *old __unused, int newselfid __unused, merge_cb_data_t *mcd __unused)
857
conjure_iidesc(iidesc_t *old, merge_cb_data_t *mcd)
859
iidesc_t *new = iidesc_dup(old);
862
(void) remap_node(&new->ii_dtype, old->ii_dtype, -1, NULL, mcd);
863
for (i = 0; i < new->ii_nargs; i++) {
864
(void) remap_node(&new->ii_args[i], old->ii_args[i], -1, NULL,
872
fwd_redir(tdesc_t *fwd, tdesc_t **fwdp, void *private)
874
alist_t *map = private;
877
if (!alist_find(map, (void *)fwd, (void **)&defn))
880
debug(3, "Redirecting an edge to %s\n", tdesc_name(defn));
887
static tdtrav_cb_f fwd_redir_cbs[] = {
889
NULL, /* intrinsic */
896
fwd_redir, /* forward */
898
tdtrav_assert, /* typedef_unres */
904
typedef struct redir_mstr_data {
910
redir_mstr_fwd_cb(void *name, void *value, void *arg)
913
int defnid = (uintptr_t)value;
914
redir_mstr_data_t *rmd = arg;
918
template.t_id = defnid;
920
if (!hash_find(rmd->rmd_tgt->td_idhash, (void *)&template,
922
aborterr("Couldn't unforward %d (%s)\n", defnid,
926
debug(3, "Forward map: resolved %d to %s\n", defnid, tdesc_name(defn));
928
alist_add(rmd->rmd_map, (void *)fwd, (void *)defn);
934
redir_mstr_fwds(merge_cb_data_t *mcd)
936
redir_mstr_data_t rmd;
937
alist_t *map = alist_new(NULL, NULL);
939
rmd.rmd_tgt = mcd->md_tgt;
942
if (alist_iter(mcd->md_fdida, redir_mstr_fwd_cb, &rmd)) {
943
(void) iitraverse_hash(mcd->md_tgt->td_iihash,
944
&mcd->md_tgt->td_curvgen, fwd_redir_cbs, NULL, NULL, map);
951
add_iitba_cb(void *data, void *private)
953
merge_cb_data_t *mcd = private;
954
iidesc_t *tba = data;
959
newidx = get_mapping(mcd->md_ta, tba->ii_dtype->t_id);
960
assert(newidx != -1);
962
(void) list_remove(mcd->md_iitba, data, NULL, NULL);
964
iif.iif_template = tba;
965
iif.iif_ta = mcd->md_ta;
966
iif.iif_newidx = newidx;
967
iif.iif_refmerge = (mcd->md_flags & MCD_F_REFMERGE);
969
if (hash_match(mcd->md_parent->td_iihash, tba, iidesc_match,
971
debug(3, "iidesc_t %s already exists\n",
972
(tba->ii_name ? tba->ii_name : "(anon)"));
976
new = conjure_iidesc(tba, mcd);
977
hash_add(mcd->md_tgt->td_iihash, new);
983
add_tdesc(tdesc_t *oldtdp, int newid, merge_cb_data_t *mcd)
988
template.t_id = newid;
989
assert(hash_find(mcd->md_parent->td_idhash,
990
(void *)&template, NULL) == 0);
992
debug(3, "trying to conjure %d %s (%d, <%x>) as %d, <%x>\n",
993
oldtdp->t_type, tdesc_name(oldtdp), oldtdp->t_id,
994
oldtdp->t_id, newid, newid);
996
if ((newtdp = tdesc_ops[oldtdp->t_type].conjure(oldtdp, newid,
998
/* couldn't map everything */
1001
debug(3, "succeeded\n");
1003
hash_add(mcd->md_tgt->td_idhash, newtdp);
1004
hash_add(mcd->md_tgt->td_layouthash, newtdp);
1010
add_tdtba_cb(void *data, void *arg)
1012
tdesc_t *tdp = data;
1013
merge_cb_data_t *mcd = arg;
1017
newid = get_mapping(mcd->md_ta, tdp->t_id);
1018
assert(newid != -1);
1020
if ((rc = add_tdesc(tdp, newid, mcd)))
1021
hash_remove(mcd->md_tdtba, (void *)tdp);
1027
add_tdtbr_cb(void *data, void *arg)
1029
tdesc_t **tdpp = data;
1030
merge_cb_data_t *mcd = arg;
1032
debug(3, "Remapping %s (%d)\n", tdesc_name(*tdpp), (*tdpp)->t_id);
1034
if (!remap_node(tdpp, *tdpp, -1, NULL, mcd))
1037
(void) list_remove(mcd->md_tdtbr, (void *)tdpp, NULL, NULL);
1042
merge_types(hash_t *src, merge_cb_data_t *mcd)
1044
list_t *iitba = NULL;
1045
list_t *tdtbr = NULL;
1048
mcd->md_iitba = &iitba;
1049
mcd->md_tdtba = hash_new(TDATA_LAYOUT_HASH_SIZE, tdesc_layouthash,
1051
mcd->md_tdtbr = &tdtbr;
1053
(void) hash_iter(src, merge_type_cb, mcd);
1055
tdrc = hash_iter(mcd->md_tdtba, add_tdtba_cb, mcd);
1056
debug(3, "add_tdtba_cb added %d items\n", tdrc);
1058
iirc = list_iter(*mcd->md_iitba, add_iitba_cb, mcd);
1059
debug(3, "add_iitba_cb added %d items\n", iirc);
1061
assert(list_count(*mcd->md_iitba) == 0 &&
1062
hash_count(mcd->md_tdtba) == 0);
1064
tdrc = list_iter(*mcd->md_tdtbr, add_tdtbr_cb, mcd);
1065
debug(3, "add_tdtbr_cb added %d items\n", tdrc);
1067
if (list_count(*mcd->md_tdtbr) != 0)
1068
aborterr("Couldn't remap all nodes\n");
1071
* We now have an alist of master forwards and the ids of the new master
1072
* definitions for those forwards in mcd->md_fdida. By this point,
1073
* we're guaranteed that all of the master definitions referenced in
1074
* fdida have been added to the master tree. We now traverse through
1075
* the master tree, redirecting all edges inbound to forwards that have
1076
* definitions to those definitions.
1078
if (mcd->md_parent == mcd->md_tgt) {
1079
redir_mstr_fwds(mcd);
1084
merge_into_master(tdata_t *cur, tdata_t *mstr, tdata_t *tgt, int selfuniquify)
1086
merge_cb_data_t mcd;
1093
assert(cur->td_ref == 1 && mstr->td_ref == 1 &&
1094
(tgt == NULL || tgt->td_ref == 1));
1096
mcd.md_parent = mstr;
1097
mcd.md_tgt = (tgt ? tgt : mstr);
1098
mcd.md_ta = alist_new(NULL, NULL);
1099
mcd.md_fdida = alist_new(NULL, NULL);
1103
mcd.md_flags |= MCD_F_SELFUNIQUIFY;
1105
mcd.md_flags |= MCD_F_REFMERGE;
1107
mstr->td_curvgen = MAX(mstr->td_curvgen, cur->td_curvgen);
1108
mstr->td_curemark = MAX(mstr->td_curemark, cur->td_curemark);
1110
merge_types(cur->td_iihash, &mcd);
1112
if (debug_level >= 3) {
1113
debug(3, "Type association stats\n");
1114
alist_stats(mcd.md_ta, 0);
1115
debug(3, "Layout hash stats\n");
1116
hash_stats(mcd.md_tgt->td_layouthash, 1);
1119
alist_free(mcd.md_fdida);
1120
alist_free(mcd.md_ta);
1128
tdesc_ops_t tdesc_ops[] = {
1129
{ "ERROR! BAD tdesc TYPE", NULL, NULL },
1130
{ "intrinsic", equiv_intrinsic, conjure_intrinsic },
1131
{ "pointer", equiv_plain, conjure_plain },
1132
{ "array", equiv_array, conjure_array },
1133
{ "function", equiv_function, conjure_function },
1134
{ "struct", equiv_su, conjure_su },
1135
{ "union", equiv_su, conjure_su },
1136
{ "enum", equiv_enum, conjure_enum },
1137
{ "forward", NULL, conjure_forward },
1138
{ "typedef", equiv_plain, conjure_plain },
1139
{ "typedef_unres", equiv_assert, conjure_assert },
1140
{ "volatile", equiv_plain, conjure_plain },
1141
{ "const", equiv_plain, conjure_plain },
1142
{ "restrict", equiv_plain, conjure_plain }
added
removed
cddl/contrib/opensolaris/tools/ctf/cvt/merge.c
