bi->start, bi->end, block_he->diff.cycles);
        }
 
-       free_srcline(start_line);
-       free_srcline(end_line);
+       zfree_srcline(&start_line);
+       zfree_srcline(&end_line);
 
        return scnprintf(hpp->buf, hpp->size, "%*s", width, buf);
 }
 
 
 static void annotation_line__exit(struct annotation_line *al)
 {
-       free_srcline(al->path);
+       zfree_srcline(&al->path);
        zfree(&al->line);
 }
 
 
                          bi->start, bi->end);
        }
 
-       free_srcline(start_line);
-       free_srcline(end_line);
+       zfree_srcline(&start_line);
+       zfree_srcline(&end_line);
 
        return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, buf);
 }
 
        if (he->branch_info) {
                map__zput(he->branch_info->from.ms.map);
                map__zput(he->branch_info->to.ms.map);
-               free_srcline(he->branch_info->srcline_from);
-               free_srcline(he->branch_info->srcline_to);
+               zfree_srcline(&he->branch_info->srcline_from);
+               zfree_srcline(&he->branch_info->srcline_to);
                zfree(&he->branch_info);
        }
 
 
        zfree(&he->res_samples);
        zfree(&he->stat_acc);
-       free_srcline(he->srcline);
+       zfree_srcline(&he->srcline);
        if (he->srcfile && he->srcfile[0])
                zfree(&he->srcfile);
        free_callchain(he->callchain);
 
                char *srcline = map__srcline(map, addr, NULL);
                if (strncmp(srcline, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)
                        ret = fprintf(fp, "%s%s", prefix, srcline);
-               free_srcline(srcline);
+               zfree_srcline(&srcline);
        }
        return ret;
 }
 
        return NULL;
 }
 
-void free_srcline(char *srcline)
+void zfree_srcline(char **srcline)
 {
-       if (srcline && strcmp(srcline, SRCLINE_UNKNOWN) != 0)
-               free(srcline);
+       if (*srcline == NULL)
+               return;
+
+       if (strcmp(*srcline, SRCLINE_UNKNOWN))
+               free(*srcline);
+
+       *srcline = NULL;
 }
 
 char *get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
                pos = rb_entry(next, struct srcline_node, rb_node);
                next = rb_next(&pos->rb_node);
                rb_erase_cached(&pos->rb_node, tree);
-               free_srcline(pos->srcline);
+               zfree_srcline(&pos->srcline);
                zfree(&pos);
        }
 }
 
        list_for_each_entry_safe(ilist, tmp, &node->val, list) {
                list_del_init(&ilist->list);
-               free_srcline(ilist->srcline);
+               zfree_srcline(&ilist->srcline);
                /* only the inlined symbols are owned by the list */
                if (ilist->symbol && ilist->symbol->inlined)
                        symbol__delete(ilist->symbol);
 
 char *__get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
                  bool show_sym, bool show_addr, bool unwind_inlines,
                  u64 ip);
-void free_srcline(char *srcline);
+void zfree_srcline(char **srcline);
 char *get_srcline_split(struct dso *dso, u64 addr, unsigned *line);
 
 /* insert the srcline into the DSO, which will take ownership */