From e429f8efbb935b71d95af855404acdcf561b8a4c Mon Sep 17 00:00:00 2001 From: Arnaldo Carvalho de Melo Date: Thu, 4 Jun 2009 14:56:44 -0300 Subject: [PATCH] dwarves: Add an rbtree for the functions in a cu That is used by cus__find_function_by_addr & cu__func_function_by_addr. First user is pfunct --addr, but this is really for pfunct --annotate, that will process a perf.data file generated by 'perf report', load the debugging info and regenerate the functions (pfunct -TVi like) that had hits, using libdisasm to show the assembly code, etc. Signed-off-by: Arnaldo Carvalho de Melo --- CMakeLists.txt | 4 +- MANIFEST | 2 + dwarves.c | 77 ++++++++- dwarves.h | 7 + pfunct.c | 43 +++-- rbtree.c | 383 +++++++++++++++++++++++++++++++++++++++++ rbtree.h | 171 ++++++++++++++++++ rpm/SPECS/dwarves.spec | 1 + 8 files changed, 671 insertions(+), 17 deletions(-) create mode 100644 rbtree.c create mode 100644 rbtree.h diff --git a/CMakeLists.txt b/CMakeLists.txt index a7d6b3b..fc07bf7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,7 +34,7 @@ _set_fancy(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}${CMAKE_INSTALL_PREFIX}/${__LI set(dwarves_LIB_SRCS dwarves.c dwarves_fprintf.c gobuffer strings ctf_encoder.c ctf_loader.c libctf.c dwarf_loader.c - dutil.c elf_symtab.c) + dutil.c elf_symtab.c rbtree.c) add_library(dwarves SHARED ${dwarves_LIB_SRCS}) set_target_properties(dwarves PROPERTIES VERSION 1.0.0 SOVERSION 1) target_link_libraries(dwarves ${DWARF_LIBRARIES} ${ZLIB_LIBRARIES}) @@ -91,7 +91,7 @@ install(TARGETS codiff ctracer dtagnames pahole pdwtags install(TARGETS dwarves LIBRARY DESTINATION ${LIB_INSTALL_DIR}) install(TARGETS dwarves dwarves_emit dwarves_reorganize LIBRARY DESTINATION ${LIB_INSTALL_DIR}) install(FILES dwarves.h dwarves_emit.h dwarves_reorganize.h - dutil.h gobuffer.h list.h strings.h + dutil.h gobuffer.h list.h rbtree.h strings.h DESTINATION ${CMAKE_INSTALL_PREFIX}/include/dwarves/) install(FILES man-pages/pahole.1 DESTINATION ${CMAKE_INSTALL_PREFIX}/share/man/man1/) install(PROGRAMS ostra/ostra-cg DESTINATION ${CMAKE_INSTALL_PREFIX}/bin) diff --git a/MANIFEST b/MANIFEST index ba102de..b6e40a4 100644 --- a/MANIFEST +++ b/MANIFEST @@ -28,6 +28,8 @@ pdwtags.c pfunct.c pglobal.c prefcnt.c +rbtree.c +rbtree.h syscse.c strings.c strings.h diff --git a/dwarves.c b/dwarves.c index b5614c5..500e77f 100644 --- a/dwarves.c +++ b/dwarves.c @@ -369,13 +369,36 @@ static void *ptr_table__entry(const struct ptr_table *self, uint32_t id) return id >= self->nr_entries ? NULL : self->entries[id]; } +static void cu__insert_function(struct cu *self, struct tag *tag) +{ + struct function *function = tag__function(tag); + struct rb_node **p = &self->functions.rb_node; + struct rb_node *parent = NULL; + struct function *f; + + while (*p != NULL) { + parent = *p; + f = rb_entry(parent, struct function, rb_node); + if (function->lexblock.low_pc < f->lexblock.low_pc) + p = &(*p)->rb_left; + else + p = &(*p)->rb_right; + } + rb_link_node(&function->rb_node, parent, p); + rb_insert_color(&function->rb_node, &self->functions); +} + int cu__table_add_tag(struct cu *self, struct tag *tag, long *id) { - struct ptr_table *pt = tag__is_tag_type(tag) ? - &self->types_table : - tag__is_function(tag) ? - &self->functions_table : - &self->tags_table; + struct ptr_table *pt = &self->tags_table; + + if (tag__is_tag_type(tag)) + pt = &self->types_table; + else if (tag__is_function(tag)) { + pt = &self->functions_table; + cu__insert_function(self, tag); + } + if (*id < 0) { *id = ptr_table__add(pt, tag); if (*id < 0) @@ -422,6 +445,8 @@ struct cu *cu__new(const char *name, uint8_t addr_size, if (ptr_table__add(&self->types_table, NULL) < 0) goto out_free_name; + self->functions = RB_ROOT; + self->dfops = NULL; INIT_LIST_HEAD(&self->tags); INIT_LIST_HEAD(&self->tool_list); @@ -688,6 +713,48 @@ struct tag *cus__find_struct_by_name(const struct cus *self, return NULL; } +struct function *cu__find_function_at_addr(const struct cu *self, + uint64_t addr) +{ + struct rb_node *n; + + if (self == NULL) + return NULL; + + n = self->functions.rb_node; + + while (n) { + struct function *f = rb_entry(n, struct function, rb_node); + + if (addr < f->lexblock.low_pc) + n = n->rb_left; + else if (addr >= f->lexblock.low_pc + f->lexblock.size) + n = n->rb_right; + else + return f; + } + + return NULL; + +} + +struct function *cus__find_function_at_addr(const struct cus *self, + uint64_t addr, struct cu **cu) +{ + struct cu *pos; + + list_for_each_entry(pos, &self->cus, node) { + struct function *f = cu__find_function_at_addr(pos, addr); + + if (f != NULL) { + if (cu != NULL) + *cu = pos; + return f; + } + } + return NULL; +} + struct cu *cus__find_cu_by_name(const struct cus *self, const char *name) { struct cu *pos; diff --git a/dwarves.h b/dwarves.h index f3487b2..922f874 100644 --- a/dwarves.h +++ b/dwarves.h @@ -17,6 +17,7 @@ #include "dutil.h" #include "list.h" +#include "rbtree.h" #include "strings.h" struct cu; @@ -86,6 +87,8 @@ struct cu *cus__find_cu_by_name(const struct cus *self, const char *name); struct tag *cus__find_struct_by_name(const struct cus *self, struct cu **cu, const char *name, const int include_decls, uint16_t *id); +struct function *cus__find_function_at_addr(const struct cus *self, + uint64_t addr, struct cu **cu); void cus__for_each_cu(struct cus *self, int (*iterator)(struct cu *cu, void *cookie), void *cookie, @@ -146,6 +149,7 @@ struct cu { struct ptr_table types_table; struct ptr_table functions_table; struct ptr_table tags_table; + struct rb_root functions; char *name; char *filename; void *priv; @@ -264,6 +268,8 @@ struct tag *cu__find_first_typedef_of_type(const struct cu *self, struct tag *cu__find_function_by_name(const struct cu *cu, const char *name); struct tag *cu__find_struct_by_sname(const struct cu *self, strings_t sname, const int include_decls, uint16_t *idp); +struct function *cu__find_function_at_addr(const struct cu *self, + uint64_t addr); struct tag *cu__function(const struct cu *self, const uint32_t id); struct tag *cu__tag(const struct cu *self, const uint32_t id); struct tag *cu__type(const struct cu *self, const uint16_t id); @@ -621,6 +627,7 @@ int ftype__has_parm_of_type(const struct ftype *self, const uint16_t target, struct function { struct ftype proto; struct lexblock lexblock; + struct rb_node rb_node; strings_t name; strings_t linkage_name; uint32_t cu_total_size_inline_expansions; diff --git a/pfunct.c b/pfunct.c index 52b6ada..d4810d4 100644 --- a/pfunct.c +++ b/pfunct.c @@ -32,6 +32,7 @@ static int show_cc_uninlined; static char *symtab_name; static bool expand_types; static struct type_emissions emissions; +static uint64_t addr; static struct conf_fprintf conf; @@ -340,7 +341,19 @@ static int function__emit_type_definitions(struct function *self, return 0; } -static int cu_function_iterator(struct cu*cu, void *cookie) +static void function__show(struct function *self, struct cu *cu) +{ + struct tag *tag = function__tag(self); + + if (expand_types) + function__emit_type_definitions(self, cu, stdout); + tag__fprintf(tag, cu, &conf, stdout); + putchar('\n'); + if (show_variables || show_inline_expansions) + function__fprintf_stats(tag, cu, &conf, stdout); +} + +static int cu_function_iterator(struct cu *cu, void *cookie) { struct function *function; uint32_t id; @@ -348,14 +361,7 @@ static int cu_function_iterator(struct cu*cu, void *cookie) cu__for_each_function(cu, id, function) { if (strcmp(function__name(function, cu), cookie) != 0) continue; - - if (expand_types) - function__emit_type_definitions(function, cu, stdout); - tag__fprintf(function__tag(function), cu, &conf, stdout); - putchar('\n'); - if (show_variables || show_inline_expansions) - function__fprintf_stats(function__tag(function), cu, - &conf, stdout); + function__show(function, cu); return 1; } return 0; @@ -449,6 +455,12 @@ ARGP_PROGRAM_VERSION_HOOK_DEF = dwarves_print_version; #define ARGP_no_parm_names 301 static const struct argp_option pfunct__options[] = { + { + .key = 'a', + .name = "addr", + .arg = "ADDR", + .doc = "show just the function that where ADDR is", + }, { .key = 'b', .name = "expand_types", @@ -572,6 +584,7 @@ static error_t pfunct__options_parser(int key, char *arg, if (state->child_inputs != NULL) state->child_inputs[0] = state->input; break; + case 'a': addr = strtoull(arg, NULL, 0); break; case 'b': expand_types = true; type_emissions__init(&emissions); break; case 'c': class_name = arg; break; @@ -640,7 +653,17 @@ int main(int argc, char *argv[]) cus__for_each_cu(cus, cu_unique_iterator, NULL, NULL); - if (show_total_inline_expansion_stats) + if (addr) { + struct cu *cu; + struct function *f = cus__find_function_at_addr(cus, addr, &cu); + + if (f == NULL) { + fprintf(stderr, "pfunct: No function found at %#llx!\n", + (unsigned long long)addr); + goto out_cus_delete; + } + function__show(f, cu); + } else if (show_total_inline_expansion_stats) print_total_inline_stats(); else if (class_name != NULL) cus__for_each_cu(cus, cu_class_iterator, class_name, NULL); diff --git a/rbtree.c b/rbtree.c new file mode 100644 index 0000000..2189f88 --- /dev/null +++ b/rbtree.c @@ -0,0 +1,383 @@ +/* + Red Black Trees + (C) 1999 Andrea Arcangeli + (C) 2002 David Woodhouse + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + linux/lib/rbtree.c +*/ + +#include "rbtree.h" + +static void __rb_rotate_left(struct rb_node *node, struct rb_root *root) +{ + struct rb_node *right = node->rb_right; + struct rb_node *parent = rb_parent(node); + + if ((node->rb_right = right->rb_left)) + rb_set_parent(right->rb_left, node); + right->rb_left = node; + + rb_set_parent(right, parent); + + if (parent) + { + if (node == parent->rb_left) + parent->rb_left = right; + else + parent->rb_right = right; + } + else + root->rb_node = right; + rb_set_parent(node, right); +} + +static void __rb_rotate_right(struct rb_node *node, struct rb_root *root) +{ + struct rb_node *left = node->rb_left; + struct rb_node *parent = rb_parent(node); + + if ((node->rb_left = left->rb_right)) + rb_set_parent(left->rb_right, node); + left->rb_right = node; + + rb_set_parent(left, parent); + + if (parent) + { + if (node == parent->rb_right) + parent->rb_right = left; + else + parent->rb_left = left; + } + else + root->rb_node = left; + rb_set_parent(node, left); +} + +void rb_insert_color(struct rb_node *node, struct rb_root *root) +{ + struct rb_node *parent, *gparent; + + while ((parent = rb_parent(node)) && rb_is_red(parent)) + { + gparent = rb_parent(parent); + + if (parent == gparent->rb_left) + { + { + register struct rb_node *uncle = gparent->rb_right; + if (uncle && rb_is_red(uncle)) + { + rb_set_black(uncle); + rb_set_black(parent); + rb_set_red(gparent); + node = gparent; + continue; + } + } + + if (parent->rb_right == node) + { + register struct rb_node *tmp; + __rb_rotate_left(parent, root); + tmp = parent; + parent = node; + node = tmp; + } + + rb_set_black(parent); + rb_set_red(gparent); + __rb_rotate_right(gparent, root); + } else { + { + register struct rb_node *uncle = gparent->rb_left; + if (uncle && rb_is_red(uncle)) + { + rb_set_black(uncle); + rb_set_black(parent); + rb_set_red(gparent); + node = gparent; + continue; + } + } + + if (parent->rb_left == node) + { + register struct rb_node *tmp; + __rb_rotate_right(parent, root); + tmp = parent; + parent = node; + node = tmp; + } + + rb_set_black(parent); + rb_set_red(gparent); + __rb_rotate_left(gparent, root); + } + } + + rb_set_black(root->rb_node); +} + +static void __rb_erase_color(struct rb_node *node, struct rb_node *parent, + struct rb_root *root) +{ + struct rb_node *other; + + while ((!node || rb_is_black(node)) && node != root->rb_node) + { + if (parent->rb_left == node) + { + other = parent->rb_right; + if (rb_is_red(other)) + { + rb_set_black(other); + rb_set_red(parent); + __rb_rotate_left(parent, root); + other = parent->rb_right; + } + if ((!other->rb_left || rb_is_black(other->rb_left)) && + (!other->rb_right || rb_is_black(other->rb_right))) + { + rb_set_red(other); + node = parent; + parent = rb_parent(node); + } + else + { + if (!other->rb_right || rb_is_black(other->rb_right)) + { + rb_set_black(other->rb_left); + rb_set_red(other); + __rb_rotate_right(other, root); + other = parent->rb_right; + } + rb_set_color(other, rb_color(parent)); + rb_set_black(parent); + rb_set_black(other->rb_right); + __rb_rotate_left(parent, root); + node = root->rb_node; + break; + } + } + else + { + other = parent->rb_left; + if (rb_is_red(other)) + { + rb_set_black(other); + rb_set_red(parent); + __rb_rotate_right(parent, root); + other = parent->rb_left; + } + if ((!other->rb_left || rb_is_black(other->rb_left)) && + (!other->rb_right || rb_is_black(other->rb_right))) + { + rb_set_red(other); + node = parent; + parent = rb_parent(node); + } + else + { + if (!other->rb_left || rb_is_black(other->rb_left)) + { + rb_set_black(other->rb_right); + rb_set_red(other); + __rb_rotate_left(other, root); + other = parent->rb_left; + } + rb_set_color(other, rb_color(parent)); + rb_set_black(parent); + rb_set_black(other->rb_left); + __rb_rotate_right(parent, root); + node = root->rb_node; + break; + } + } + } + if (node) + rb_set_black(node); +} + +void rb_erase(struct rb_node *node, struct rb_root *root) +{ + struct rb_node *child, *parent; + int color; + + if (!node->rb_left) + child = node->rb_right; + else if (!node->rb_right) + child = node->rb_left; + else + { + struct rb_node *old = node, *left; + + node = node->rb_right; + while ((left = node->rb_left) != NULL) + node = left; + child = node->rb_right; + parent = rb_parent(node); + color = rb_color(node); + + if (child) + rb_set_parent(child, parent); + if (parent == old) { + parent->rb_right = child; + parent = node; + } else + parent->rb_left = child; + + node->rb_parent_color = old->rb_parent_color; + node->rb_right = old->rb_right; + node->rb_left = old->rb_left; + + if (rb_parent(old)) + { + if (rb_parent(old)->rb_left == old) + rb_parent(old)->rb_left = node; + else + rb_parent(old)->rb_right = node; + } else + root->rb_node = node; + + rb_set_parent(old->rb_left, node); + if (old->rb_right) + rb_set_parent(old->rb_right, node); + goto color; + } + + parent = rb_parent(node); + color = rb_color(node); + + if (child) + rb_set_parent(child, parent); + if (parent) + { + if (parent->rb_left == node) + parent->rb_left = child; + else + parent->rb_right = child; + } + else + root->rb_node = child; + + color: + if (color == RB_BLACK) + __rb_erase_color(child, parent, root); +} + +/* + * This function returns the first node (in sort order) of the tree. + */ +struct rb_node *rb_first(const struct rb_root *root) +{ + struct rb_node *n; + + n = root->rb_node; + if (!n) + return NULL; + while (n->rb_left) + n = n->rb_left; + return n; +} + +struct rb_node *rb_last(const struct rb_root *root) +{ + struct rb_node *n; + + n = root->rb_node; + if (!n) + return NULL; + while (n->rb_right) + n = n->rb_right; + return n; +} + +struct rb_node *rb_next(const struct rb_node *node) +{ + struct rb_node *parent; + + if (rb_parent(node) == node) + return NULL; + + /* If we have a right-hand child, go down and then left as far + as we can. */ + if (node->rb_right) { + node = node->rb_right; + while (node->rb_left) + node=node->rb_left; + return (struct rb_node *)node; + } + + /* No right-hand children. Everything down and left is + smaller than us, so any 'next' node must be in the general + direction of our parent. Go up the tree; any time the + ancestor is a right-hand child of its parent, keep going + up. First time it's a left-hand child of its parent, said + parent is our 'next' node. */ + while ((parent = rb_parent(node)) && node == parent->rb_right) + node = parent; + + return parent; +} + +struct rb_node *rb_prev(const struct rb_node *node) +{ + struct rb_node *parent; + + if (rb_parent(node) == node) + return NULL; + + /* If we have a left-hand child, go down and then right as far + as we can. */ + if (node->rb_left) { + node = node->rb_left; + while (node->rb_right) + node=node->rb_right; + return (struct rb_node *)node; + } + + /* No left-hand children. Go up till we find an ancestor which + is a right-hand child of its parent */ + while ((parent = rb_parent(node)) && node == parent->rb_left) + node = parent; + + return parent; +} + +void rb_replace_node(struct rb_node *victim, struct rb_node *new, + struct rb_root *root) +{ + struct rb_node *parent = rb_parent(victim); + + /* Set the surrounding nodes to point to the replacement */ + if (parent) { + if (victim == parent->rb_left) + parent->rb_left = new; + else + parent->rb_right = new; + } else { + root->rb_node = new; + } + if (victim->rb_left) + rb_set_parent(victim->rb_left, new); + if (victim->rb_right) + rb_set_parent(victim->rb_right, new); + + /* Copy the pointers/colour from the victim to the replacement */ + *new = *victim; +} diff --git a/rbtree.h b/rbtree.h new file mode 100644 index 0000000..c9ab87a --- /dev/null +++ b/rbtree.h @@ -0,0 +1,171 @@ +/* + Red Black Trees + (C) 1999 Andrea Arcangeli + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + linux/include/linux/rbtree.h + + To use rbtrees you'll have to implement your own insert and search cores. + This will avoid us to use callbacks and to drop drammatically performances. + I know it's not the cleaner way, but in C (not in C++) to get + performances and genericity... + + Some example of insert and search follows here. The search is a plain + normal search over an ordered tree. The insert instead must be implemented + int two steps: as first thing the code must insert the element in + order as a red leaf in the tree, then the support library function + rb_insert_color() must be called. Such function will do the + not trivial work to rebalance the rbtree if necessary. + +----------------------------------------------------------------------- +static inline struct page * rb_search_page_cache(struct inode * inode, + unsigned long offset) +{ + struct rb_node * n = inode->i_rb_page_cache.rb_node; + struct page * page; + + while (n) + { + page = rb_entry(n, struct page, rb_page_cache); + + if (offset < page->offset) + n = n->rb_left; + else if (offset > page->offset) + n = n->rb_right; + else + return page; + } + return NULL; +} + +static inline struct page * __rb_insert_page_cache(struct inode * inode, + unsigned long offset, + struct rb_node * node) +{ + struct rb_node ** p = &inode->i_rb_page_cache.rb_node; + struct rb_node * parent = NULL; + struct page * page; + + while (*p) + { + parent = *p; + page = rb_entry(parent, struct page, rb_page_cache); + + if (offset < page->offset) + p = &(*p)->rb_left; + else if (offset > page->offset) + p = &(*p)->rb_right; + else + return page; + } + + rb_link_node(node, parent, p); + + return NULL; +} + +static inline struct page * rb_insert_page_cache(struct inode * inode, + unsigned long offset, + struct rb_node * node) +{ + struct page * ret; + if ((ret = __rb_insert_page_cache(inode, offset, node))) + goto out; + rb_insert_color(node, &inode->i_rb_page_cache); + out: + return ret; +} +----------------------------------------------------------------------- +*/ + +#ifndef _LINUX_RBTREE_H +#define _LINUX_RBTREE_H + +#include + +/** + * container_of - cast a member of a structure out to the containing structure + * @ptr: the pointer to the member. + * @type: the type of the container struct this is embedded in. + * @member: the name of the member within the struct. + * + */ +#define container_of(ptr, type, member) ({ \ + const typeof( ((type *)0)->member ) *__mptr = (ptr); \ + (type *)( (char *)__mptr - offsetof(type,member) );}) + +struct rb_node +{ + unsigned long rb_parent_color; +#define RB_RED 0 +#define RB_BLACK 1 + struct rb_node *rb_right; + struct rb_node *rb_left; +} __attribute__((aligned(sizeof(long)))); + /* The alignment might seem pointless, but allegedly CRIS needs it */ + +struct rb_root +{ + struct rb_node *rb_node; +}; + + +#define rb_parent(r) ((struct rb_node *)((r)->rb_parent_color & ~3)) +#define rb_color(r) ((r)->rb_parent_color & 1) +#define rb_is_red(r) (!rb_color(r)) +#define rb_is_black(r) rb_color(r) +#define rb_set_red(r) do { (r)->rb_parent_color &= ~1; } while (0) +#define rb_set_black(r) do { (r)->rb_parent_color |= 1; } while (0) + +static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p) +{ + rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p; +} +static inline void rb_set_color(struct rb_node *rb, int color) +{ + rb->rb_parent_color = (rb->rb_parent_color & ~1) | color; +} + +#define RB_ROOT (struct rb_root) { NULL, } +#define rb_entry(ptr, type, member) container_of(ptr, type, member) + +#define RB_EMPTY_ROOT(root) ((root)->rb_node == NULL) +#define RB_EMPTY_NODE(node) (rb_parent(node) == node) +#define RB_CLEAR_NODE(node) (rb_set_parent(node, node)) + +extern void rb_insert_color(struct rb_node *, struct rb_root *); +extern void rb_erase(struct rb_node *, struct rb_root *); + +/* Find logical next and previous nodes in a tree */ +extern struct rb_node *rb_next(const struct rb_node *); +extern struct rb_node *rb_prev(const struct rb_node *); +extern struct rb_node *rb_first(const struct rb_root *); +extern struct rb_node *rb_last(const struct rb_root *); + +/* Fast replacement of a single node without remove/rebalance/add/rebalance */ +extern void rb_replace_node(struct rb_node *victim, struct rb_node *new, + struct rb_root *root); + +static inline void rb_link_node(struct rb_node * node, struct rb_node * parent, + struct rb_node ** rb_link) +{ + node->rb_parent_color = (unsigned long )parent; + node->rb_left = node->rb_right = NULL; + + *rb_link = node; +} + +#endif /* _LINUX_RBTREE_H */ diff --git a/rpm/SPECS/dwarves.spec b/rpm/SPECS/dwarves.spec index eadd62d..4bebc0f 100644 --- a/rpm/SPECS/dwarves.spec +++ b/rpm/SPECS/dwarves.spec @@ -108,6 +108,7 @@ rm -rf %{buildroot} %{_includedir}/dwarves/dutil.h %{_includedir}/dwarves/gobuffer.h %{_includedir}/dwarves/list.h +%{_includedir}/dwarves/rbtree.h %{_includedir}/dwarves/strings.h %{_libdir}/%{libname}.so %{_libdir}/%{libname}_emit.so