tal: remove unused assigned var (scan-build warning)

[ccan] / ccan / tal / tal.c

diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c
index 5c0aec07990dcbafc44b5e7bf075ac8c68ba5641..df4020ea07e4997b6888d9418cf521fa74437e6a 100644 (file)
--- a/ccan/tal/tal.c
+++ b/ccan/tal/tal.c
@@ -3,6 +3,7 @@
 #include <ccan/compiler/compiler.h>
 #include <ccan/list/list.h>
 #include <ccan/take/take.h>
 #include <ccan/compiler/compiler.h>
 #include <ccan/list/list.h>
 #include <ccan/take/take.h>

+#include <ccan/alignof/alignof.h>

 #include <assert.h>
 #include <stdio.h>
 #include <stddef.h>
 #include <assert.h>
 #include <stdio.h>
 #include <stddef.h>


@@ -75,7 +76,6 @@ static void *(*allocfn)(size_t size) = malloc;
 static void *(*resizefn)(void *, size_t size) = realloc;
 static void (*freefn)(void *) = free;
 static void (*errorfn)(const char *msg) = (void *)abort;
 static void *(*resizefn)(void *, size_t size) = realloc;
 static void (*freefn)(void *) = free;
 static void (*errorfn)(const char *msg) = (void *)abort;

-static bool initialized = false;

 /* Count on non-destrutor notifiers; often stays zero. */
 static size_t notifiers = 0;
 
 /* Count on non-destrutor notifiers; often stays zero. */
 static size_t notifiers = 0;
 


@@ -100,23 +100,19 @@ static struct children *ignore_destroying_bit(struct children *parent_child)
 }
 
 /* This means valgrind can see leaks. */
 }
 
 /* This means valgrind can see leaks. */

-static void tal_cleanup(void)
+void tal_cleanup(void)

 {
        struct tal_hdr *i;
 
 {
        struct tal_hdr *i;
 

-       while ((i = list_top(&null_parent.c.children, struct tal_hdr, list)))
+       while ((i = list_top(&null_parent.c.children, struct tal_hdr, list))) {

                list_del(&i->list);
                list_del(&i->list);

+               memset(i, 0, sizeof(*i));
+       }

 
        /* Cleanup any taken pointers. */
        take_cleanup();
 }
 
 
        /* Cleanup any taken pointers. */
        take_cleanup();
 }
 

-/* For allocation failures inside ccan/take */
-static void take_alloc_failed(const void *p)
-{
-       tal_free(p);
-}
-

 /* We carefully start all real properties with a zero byte. */
 static bool is_literal(const struct prop_hdr *prop)
 {
 /* We carefully start all real properties with a zero byte. */
 static bool is_literal(const struct prop_hdr *prop)
 {


@@ -326,18 +322,6 @@ static struct name *add_name_property(struct tal_hdr *t, const char *name)
        return prop;
 }
 
        return prop;
 }
 

-static struct length *add_length_property(struct tal_hdr *t, size_t count)
-{
-       struct length *prop;
-
-       prop = allocate(sizeof(*prop));
-       if (prop) {
-               init_property(&prop->hdr, t, LENGTH);
-               prop->count = count;
-       }
-       return prop;
-}
-

 static struct children *add_child_property(struct tal_hdr *parent,
                                           struct tal_hdr *child)
 {
 static struct children *add_child_property(struct tal_hdr *parent,
                                           struct tal_hdr *child)
 {


@@ -355,11 +339,6 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child)
        struct children *children = find_property(parent, CHILDREN);
 
         if (!children) {
        struct children *children = find_property(parent, CHILDREN);
 
         if (!children) {

-               if (unlikely(!initialized)) {
-                       atexit(tal_cleanup);
-                       take_allocfail(take_alloc_failed);
-                       initialized = true;
-               }

                children = add_child_property(parent, child);
                if (!children)
                        return false;
                children = add_child_property(parent, child);
                if (!children)
                        return false;


@@ -397,7 +376,9 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig)
         /* Finally free our properties. */
         for (p = t->prop; p && !is_literal(p); p = next) {
                 next = p->next;
         /* Finally free our properties. */
         for (p = t->prop; p && !is_literal(p); p = next) {
                 next = p->next;

-               freefn(p);
+               /* LENGTH is appended, so don't free separately! */
+               if (p->type != LENGTH)
+                       freefn(p);

         }
         freefn(t);
 }
         }
         freefn(t);
 }


@@ -424,14 +405,16 @@ void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label)
 
 static bool adjust_size(size_t *size, size_t count)
 {
 
 static bool adjust_size(size_t *size, size_t count)
 {

+       const size_t extra = sizeof(struct tal_hdr) + sizeof(struct length)*2;
+

        /* Multiplication wrap */
         if (count && unlikely(*size * count / *size != count))
                goto overflow;
 
         *size *= count;
 
        /* Multiplication wrap */
         if (count && unlikely(*size * count / *size != count))
                goto overflow;
 
         *size *= count;
 

-        /* Make sure we don't wrap adding header. */
-        if (*size + sizeof(struct tal_hdr) < sizeof(struct tal_hdr))
+        /* Make sure we don't wrap adding header/tailer. */
+        if (*size + extra < extra)

                goto overflow;
        return true;
 overflow:
                goto overflow;
        return true;
 overflow:


@@ -439,6 +422,17 @@ overflow:
        return false;
 }
 
        return false;
 }
 

+static size_t extra_for_length(size_t size)
+{
+       size_t extra;
+       const size_t align = ALIGNOF(struct length);
+
+       /* Round up size, and add tailer. */
+       extra = ((size + align-1) & ~(align-1)) - size;
+       extra += sizeof(struct length);
+       return extra;
+}
+

 void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
                     bool add_count, const char *label)
 {
 void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
                     bool add_count, const char *label)
 {


@@ -447,10 +441,18 @@ void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
        if (!adjust_size(&size, count))
                return NULL;
 
        if (!adjust_size(&size, count))
                return NULL;
 

+       if (add_count)
+               size += extra_for_length(size);
+

        ret = tal_alloc_(ctx, size, clear, label);
        ret = tal_alloc_(ctx, size, clear, label);

-       if (likely(ret) && add_count) {
-               if (unlikely(!add_length_property(to_tal_hdr(ret), count)))
-                       ret = tal_free(ret);
+       if (unlikely(!ret))
+               return ret;
+
+       if (add_count) {
+               struct length *lprop;
+               lprop = (struct length *)((char *)ret + size) - 1;
+               init_property(&lprop->hdr, to_tal_hdr(ret), LENGTH);
+               lprop->count = count;

        }
        return ret;
 }
        }
        return ret;
 }


@@ -628,31 +630,16 @@ tal_t *tal_first(const tal_t *root)
        return from_tal_hdr(c);
 }
 
        return from_tal_hdr(c);
 }
 

-tal_t *tal_next(const tal_t *root, const tal_t *prev)
+tal_t *tal_next(const tal_t *prev)

 {
 {

-        struct tal_hdr *c, *t = debug_tal(to_tal_hdr(prev)), *top;
+        struct tal_hdr *next, *prevhdr = debug_tal(to_tal_hdr(prev));
+       struct list_head *head;

 
 

-        /* Children? */
-       c = first_child(t);
-       if (c)
-               return from_tal_hdr(c);
-
-        top = to_tal_hdr_or_null(root);
-        do {
-               struct tal_hdr *next;
-               struct list_node *end;
-
-               end = &ignore_destroying_bit(t->parent_child)->children.n;
-
-               next = list_entry(t->list.next, struct tal_hdr, list);
-               if (&next->list != end)
-                       return from_tal_hdr(next);
-
-                /* OK, go back to parent. */
-                t = ignore_destroying_bit(t->parent_child)->parent;
-        } while (t != top);
-
-        return NULL;
+       head = &ignore_destroying_bit(prevhdr->parent_child)->children;
+       next = list_next(head, prevhdr, list);
+       if (!next)
+               return NULL;
+       return from_tal_hdr(next);

 }
 
 tal_t *tal_parent(const tal_t *ctx)
 }
 
 tal_t *tal_parent(const tal_t *ctx)


@@ -668,30 +655,60 @@ tal_t *tal_parent(const tal_t *ctx)
         return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
 }
 
         return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
 }
 

-bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
+bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)

 {
         struct tal_hdr *old_t, *t;
         struct children *child;
 {
         struct tal_hdr *old_t, *t;
         struct children *child;

-       struct length *len;
+       struct prop_hdr **lenp;
+       struct length len;
+       size_t extra = 0, elemsize = size;

 
         old_t = debug_tal(to_tal_hdr(*ctxp));
 
        if (!adjust_size(&size, count))
                return false;
 
 
         old_t = debug_tal(to_tal_hdr(*ctxp));
 
        if (!adjust_size(&size, count))
                return false;
 

-        t = resizefn(old_t, size + sizeof(struct tal_hdr));
+       lenp = find_property_ptr(old_t, LENGTH);
+       if (lenp) {
+               /* Copy here, in case we're shrinking! */
+               len = *(struct length *)*lenp;
+               extra = extra_for_length(size);
+       } else /* If we don't have an old length, we can't clear! */
+               assert(!clear);
+
+        t = resizefn(old_t, sizeof(struct tal_hdr) + size + extra);

        if (!t) {
                call_error("Reallocation failure");
                return false;
        }
 
        if (!t) {
                call_error("Reallocation failure");
                return false;
        }
 

+       /* Copy length to end. */
+       if (lenp) {
+               struct length *new_len;
+
+               /* Clear between old end and new end. */
+               if (clear && count > len.count) {
+                       char *old_end = (char *)(t + 1) + len.count * elemsize;
+                       memset(old_end, 0, elemsize * (count - len.count));
+               }
+
+               new_len = (struct length *)((char *)(t + 1) + size);
+               len.count = count;
+               *new_len = len;
+
+               /* Be careful replacing next ptr; could be old hdr. */
+               if (lenp == &old_t->prop)
+                       t->prop = &new_len->hdr;
+               else
+                       *lenp = &new_len->hdr;
+       }
+
+       update_bounds(t, sizeof(struct tal_hdr) + size + extra);
+

        /* If it didn't move, we're done! */
         if (t != old_t) {
        /* If it didn't move, we're done! */
         if (t != old_t) {

-               update_bounds(t, size + sizeof(struct tal_hdr));
-

                /* Fix up linked list pointers. */
                /* Fix up linked list pointers. */

-               if (list_entry(t->list.next, struct tal_hdr, list) != old_t)
-                       t->list.next->prev = t->list.prev->next = &t->list;
+               t->list.next->prev = t->list.prev->next = &t->list;

 
                /* Fix up child property's parent pointer. */
                child = find_property(t, CHILDREN);
 
                /* Fix up child property's parent pointer. */
                child = find_property(t, CHILDREN);


@@ -703,9 +720,6 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
                if (notifiers)
                        notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
        }
                if (notifiers)
                        notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
        }

-       len = find_property(t, LENGTH);
-       if (len)
-               len->count = count;

        if (notifiers)
                notify(t, TAL_NOTIFY_RESIZE, (void *)size);
 
        if (notifiers)
                notify(t, TAL_NOTIFY_RESIZE, (void *)size);
 


@@ -715,26 +729,26 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
 bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
 {
        struct length *l;
 bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
 {
        struct length *l;

+       size_t old_count;

        bool ret = false;
 
        l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);
        bool ret = false;
 
        l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);

+       old_count = l->count;

 
        /* Check for additive overflow */
 
        /* Check for additive overflow */

-       if (l->count + count < count) {
+       if (old_count + count < count) {

                call_error("dup size overflow");
                goto out;
        }
 
        /* Don't point src inside thing we're expanding! */
        assert(src < *ctxp
                call_error("dup size overflow");
                goto out;
        }
 
        /* Don't point src inside thing we're expanding! */
        assert(src < *ctxp

-              || (char *)src >= (char *)(*ctxp) + (size * l->count));
+              || (char *)src >= (char *)(*ctxp) + (size * old_count));

 
 

-       /* Note: updates l->count. */
-       if (!tal_resize_(ctxp, size, l->count + count))
+       if (!tal_resize_(ctxp, size, old_count + count, false))

                goto out;
 
                goto out;
 

-       memcpy((char *)*ctxp + size * (l->count - count),
-              src, count * size);
+       memcpy((char *)*ctxp + size * old_count, src, count * size);

        ret = true;
 
 out:
        ret = true;
 
 out:


@@ -767,7 +781,7 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
        if (taken(p)) {
                if (unlikely(!p))
                        return NULL;
        if (taken(p)) {
                if (unlikely(!p))
                        return NULL;

-               if (unlikely(!tal_resize_((void **)&p, size, n + extra)))
+               if (unlikely(!tal_resize_((void **)&p, size, n + extra, false)))

                        return tal_free(p);
                if (unlikely(!tal_steal(ctx, p)))
                        return tal_free(p);
                        return tal_free(p);
                if (unlikely(!tal_steal(ctx, p)))
                        return tal_free(p);


@@ -892,7 +906,6 @@ static bool check_node(struct children *parent_child,
                        if (name)
                                return check_err(t, errorstr,
                                                 "has extra literal");
                        if (name)
                                return check_err(t, errorstr,
                                                 "has extra literal");

-                       name = (struct name *)p;

                        break;
                }
                if (!in_bounds(p))
                        break;
                }
                if (!in_bounds(p))