#include "builtin.h"

#include "cache.h"

#include "repository.h"

#include "config.h"

#include "attr.h"

#include "object.h"

#include "blob.h"

#include "commit.h"

#include "tag.h"

#include "tree.h"

#include "delta.h"

#include "pack.h"

#include "pack-revindex.h"

#include "csum-file.h"

#include "tree-walk.h"

#include "diff.h"

#include "revision.h"

#include "list-objects.h"

#include "list-objects-filter.h"

#include "list-objects-filter-options.h"

#include "pack-objects.h"

#include "progress.h"

#include "refs.h"

#include "streaming.h"

#include "thread-utils.h"

#include "pack-bitmap.h"

#include "delta-islands.h"

#include "reachable.h"

#include "oid-array.h"

#include "strvec.h"

#include "list.h"

#include "packfile.h"

#include "object-store.h"

#include "dir.h"

#include "midx.h"

#include "trace2.h"

#include "shallow.h"

#include "promisor-remote.h"

static struct packing_data to_pack;

static inline struct object_entry *oe_delta(

const struct packing_data *pack,

const struct object_entry *e)

{

if (!e->delta_idx)

return NULL;

if (e->ext_base)

return &pack->ext_bases[e->delta_idx - 1];

else

return &pack->objects[e->delta_idx - 1];

}

static inline unsigned long oe_delta_size(struct packing_data *pack,

const struct object_entry *e)

{

if (e->delta_size_valid)

return e->delta_size_;

/*

return pack->delta_size[e - pack->objects];

}

unsigned long oe_get_size_slow(struct packing_data *pack,

const struct object_entry *e);

static inline unsigned long oe_size(struct packing_data *pack,

const struct object_entry *e)

{

if (e->size_valid)

return e->size_;

return oe_get_size_slow(pack, e);

}

static inline void oe_set_delta(struct packing_data *pack,

struct object_entry *e,

struct object_entry *delta)

{

if (delta)

e->delta_idx = (delta - pack->objects) + 1;

else

e->delta_idx = 0;

}

static inline struct object_entry *oe_delta_sibling(

const struct packing_data *pack,

const struct object_entry *e)

{

if (e->delta_sibling_idx)

return &pack->objects[e->delta_sibling_idx - 1];

return NULL;

}

static inline struct object_entry *oe_delta_child(

const struct packing_data *pack,

const struct object_entry *e)

{

if (e->delta_child_idx)

return &pack->objects[e->delta_child_idx - 1];

return NULL;

}

static inline void oe_set_delta_child(struct packing_data *pack,

struct object_entry *e,

struct object_entry *delta)

{

if (delta)

e->delta_child_idx = (delta - pack->objects) + 1;

else

e->delta_child_idx = 0;

}

static inline void oe_set_delta_sibling(struct packing_data *pack,

struct object_entry *e,

struct object_entry *delta)

{

if (delta)

e->delta_sibling_idx = (delta - pack->objects) + 1;

else

e->delta_sibling_idx = 0;

}

static inline void oe_set_size(struct packing_data *pack,

struct object_entry *e,

unsigned long size)

{

if (size < pack->oe_size_limit) {

e->size_ = size;

e->size_valid = 1;

} else {

e->size_valid = 0;

if (oe_get_size_slow(pack, e) != size)

BUG("'size' is supposed to be the object size!");

}

}

static inline void oe_set_delta_size(struct packing_data *pack,

struct object_entry *e,

unsigned long size)

{

if (size < pack->oe_delta_size_limit) {

e->delta_size_ = size;

e->delta_size_valid = 1;

} else {

packing_data_lock(pack);

if (!pack->delta_size)

ALLOC_ARRAY(pack->delta_size, pack->nr_alloc);

packing_data_unlock(pack);

pack->delta_size[e - pack->objects] = size;

e->delta_size_valid = 0;

}

}

#define IN_PACK(obj) oe_in_pack(&to_pack, obj)

#define SIZE(obj) oe_size(&to_pack, obj)

#define SET_SIZE(obj,size) oe_set_size(&to_pack, obj, size)

#define DELTA_SIZE(obj) oe_delta_size(&to_pack, obj)

#define DELTA(obj) oe_delta(&to_pack, obj)

#define DELTA_CHILD(obj) oe_delta_child(&to_pack, obj)

#define DELTA_SIBLING(obj) oe_delta_sibling(&to_pack, obj)

#define SET_DELTA(obj, val) oe_set_delta(&to_pack, obj, val)

#define SET_DELTA_EXT(obj, oid) oe_set_delta_ext(&to_pack, obj, oid)

#define SET_DELTA_SIZE(obj, val) oe_set_delta_size(&to_pack, obj, val)

#define SET_DELTA_CHILD(obj, val) oe_set_delta_child(&to_pack, obj, val)

#define SET_DELTA_SIBLING(obj, val) oe_set_delta_sibling(&to_pack, obj, val)

static const char *pack_usage[] = {

N_("git pack-objects --stdout [<options>...] [< <ref-list> | < <object-list>]"),

N_("git pack-objects [<options>...] <base-name> [< <ref-list> | < <object-list>]"),

NULL

};

static struct pack_idx_entry **written_list;

static uint32_t nr_result, nr_written, nr_seen;

static struct bitmap_index *bitmap_git;

static uint32_t write_layer;

static int non_empty;

static int reuse_delta = 1, reuse_object = 1;

static int keep_unreachable, unpack_unreachable, include_tag;

static timestamp_t unpack_unreachable_expiration;

static int pack_loose_unreachable;

static int local;

static int have_non_local_packs;

static int incremental;

static int ignore_packed_keep_on_disk;

static int ignore_packed_keep_in_core;

static int allow_ofs_delta;

static struct pack_idx_option pack_idx_opts;

static const char *base_name;

static int progress = 1;

static int window = 10;

static unsigned long pack_size_limit;

static int depth = 50;

static int delta_search_threads;

static int pack_to_stdout;

static int sparse;

static int thin;

static int num_preferred_base;

static struct progress *progress_state;

static struct packed_git *reuse_packfile;

static uint32_t reuse_packfile_objects;

static struct bitmap *reuse_packfile_bitmap;

static int use_bitmap_index_default = 1;

static int use_bitmap_index = -1;

static int allow_pack_reuse = 1;

static enum {

WRITE_BITMAP_FALSE = 0,

WRITE_BITMAP_QUIET,

WRITE_BITMAP_TRUE,

} write_bitmap_index;

static uint16_t write_bitmap_options = BITMAP_OPT_HASH_CACHE;

static int exclude_promisor_objects;

static int use_delta_islands;

static unsigned long delta_cache_size = 0;

static unsigned long max_delta_cache_size = DEFAULT_DELTA_CACHE_SIZE;

static unsigned long cache_max_small_delta_size = 1000;

static unsigned long window_memory_limit = 0;

static struct list_objects_filter_options filter_options;

static struct string_list uri_protocols = STRING_LIST_INIT_NODUP;

enum missing_action {

};

static enum missing_action arg_missing_action;

static show_object_fn fn_show_object;

struct configured_exclusion {

};

static struct oidmap configured_exclusions;

static struct oidset excluded_by_config;

static uint32_t written, written_delta;

static uint32_t reused, reused_delta;

static struct commit **indexed_commits;

static unsigned int indexed_commits_nr;

static unsigned int indexed_commits_alloc;

static void index_commit_for_bitmap(struct commit *commit)

{

if (indexed_commits_nr >= indexed_commits_alloc) {

indexed_commits_alloc = (indexed_commits_alloc + 32) * 2;

REALLOC_ARRAY(indexed_commits, indexed_commits_alloc);

}

indexed_commits[indexed_commits_nr++] = commit;

}

static void *get_delta(struct object_entry *entry)

{

unsigned long size, base_size, delta_size;

void *buf, *base_buf, *delta_buf;

enum object_type type;

buf = read_object_file(&entry->idx.oid, &type, &size);

if (!buf)

die(_("unable to read %s"), oid_to_hex(&entry->idx.oid));

base_buf = read_object_file(&DELTA(entry)->idx.oid, &type,

&base_size);

if (!base_buf)

die("unable to read %s",

oid_to_hex(&DELTA(entry)->idx.oid));

delta_buf = diff_delta(base_buf, base_size,

buf, size, &delta_size, 0);

/*

if (!delta_buf || delta_size != DELTA_SIZE(entry))

BUG("delta size changed");

free(buf);

free(base_buf);

return delta_buf;

}

static unsigned long do_compress(void **pptr, unsigned long size)

{

git_zstream stream;

void *in, *out;

unsigned long maxsize;

git_deflate_init(&stream, pack_compression_level);

maxsize = git_deflate_bound(&stream, size);

in = *pptr;

out = xmalloc(maxsize);

*pptr = out;

stream.next_in = in;

stream.avail_in = size;

stream.next_out = out;

stream.avail_out = maxsize;

while (git_deflate(&stream, Z_FINISH) == Z_OK)

; /* nothing */

git_deflate_end(&stream);

free(in);

return stream.total_out;

}

static unsigned long write_large_blob_data(struct git_istream *st, struct hashfile *f,

const struct object_id *oid)

{

git_zstream stream;

unsigned char ibuf[1024 * 16];

unsigned char obuf[1024 * 16];

unsigned long olen = 0;

git_deflate_init(&stream, pack_compression_level);

for (;;) {

ssize_t readlen;

int zret = Z_OK;

readlen = read_istream(st, ibuf, sizeof(ibuf));

if (readlen == -1)

die(_("unable to read %s"), oid_to_hex(oid));

stream.next_in = ibuf;

stream.avail_in = readlen;

while ((stream.avail_in || readlen == 0) &&

(zret == Z_OK || zret == Z_BUF_ERROR)) {

stream.next_out = obuf;

stream.avail_out = sizeof(obuf);

zret = git_deflate(&stream, readlen ? 0 : Z_FINISH);

hashwrite(f, obuf, stream.next_out - obuf);

olen += stream.next_out - obuf;

}

if (stream.avail_in)

die(_("deflate error (%d)"), zret);

if (readlen == 0) {

if (zret != Z_STREAM_END)

die(_("deflate error (%d)"), zret);

break;

}

}

git_deflate_end(&stream);

return olen;

}

static int check_pack_inflate(struct packed_git *p,

unsigned long expect)

{

git_zstream stream;

unsigned char fakebuf[4096], *in;

int st;

memset(&stream, 0, sizeof(stream));

git_inflate_init(&stream);

do {

in = use_pack(p, w_curs, offset, &stream.avail_in);

stream.next_in = in;

stream.next_out = fakebuf;

stream.avail_out = sizeof(fakebuf);

st = git_inflate(&stream, Z_FINISH);

offset += stream.next_in - in;

} while (st == Z_OK || st == Z_BUF_ERROR);

git_inflate_end(&stream);

return (st == Z_STREAM_END &&

stream.total_out == expect &&

stream.total_in == len) ? 0 : -1;

}

static void copy_pack_data(struct hashfile *f,

off_t len)

{

unsigned char *in;

unsigned long avail;

while (len) {

in = use_pack(p, w_curs, offset, &avail);

if (avail > len)

avail = (unsigned long)len;

hashwrite(f, in, avail);

offset += avail;

len -= avail;

}

}

static inline int oe_size_greater_than(struct packing_data *pack,

const struct object_entry *lhs,

unsigned long rhs)

{

if (lhs->size_valid)

return lhs->size_ > rhs;

if (rhs < pack->oe_size_limit) /* rhs < 2^x <= lhs ? */

return 1;

return oe_get_size_slow(pack, lhs) > rhs;

}

static unsigned long write_no_reuse_object(struct hashfile *f, struct object_entry *entry,

unsigned long limit, int usable_delta)

{

unsigned long size, datalen;

unsigned char header[MAX_PACK_OBJECT_HEADER],

dheader[MAX_PACK_OBJECT_HEADER];

unsigned hdrlen;

enum object_type type;

void *buf;

struct git_istream *st = NULL;

const unsigned hashsz = the_hash_algo->rawsz;

if (!usable_delta) {

if (oe_type(entry) == OBJ_BLOB &&

oe_size_greater_than(&to_pack, entry, big_file_threshold) &&

(st = open_istream(the_repository, &entry->idx.oid, &type,

&size, NULL)) != NULL)

buf = NULL;

else {

buf = read_object_file(&entry->idx.oid, &type, &size);

if (!buf)

die(_("unable to read %s"),

oid_to_hex(&entry->idx.oid));

}

/*

FREE_AND_NULL(entry->delta_data);

entry->z_delta_size = 0;

} else if (entry->delta_data) {

size = DELTA_SIZE(entry);

buf = entry->delta_data;

entry->delta_data = NULL;

type = (allow_ofs_delta && DELTA(entry)->idx.offset) ?

OBJ_OFS_DELTA : OBJ_REF_DELTA;

} else {

buf = get_delta(entry);

size = DELTA_SIZE(entry);

type = (allow_ofs_delta && DELTA(entry)->idx.offset) ?

OBJ_OFS_DELTA : OBJ_REF_DELTA;

}

if (st) /* large blob case, just assume we don't compress well */

datalen = size;

else if (entry->z_delta_size)

datalen = entry->z_delta_size;

else

datalen = do_compress(&buf, size);

/*

hdrlen = encode_in_pack_object_header(header, sizeof(header),

type, size);

if (type == OBJ_OFS_DELTA) {

/*

off_t ofs = entry->idx.offset - DELTA(entry)->idx.offset;

unsigned pos = sizeof(dheader) - 1;

dheader[pos] = ofs & 127;

while (ofs >>= 7)

dheader[--pos] = 128 | (--ofs & 127);

if (limit && hdrlen + sizeof(dheader) - pos + datalen + hashsz >= limit) {

if (st)

close_istream(st);

free(buf);

return 0;

}

hashwrite(f, header, hdrlen);

hashwrite(f, dheader + pos, sizeof(dheader) - pos);

hdrlen += sizeof(dheader) - pos;

} else if (type == OBJ_REF_DELTA) {

/*

if (limit && hdrlen + hashsz + datalen + hashsz >= limit) {

if (st)

close_istream(st);

free(buf);

return 0;

}

hashwrite(f, header, hdrlen);

hashwrite(f, DELTA(entry)->idx.oid.hash, hashsz);

hdrlen += hashsz;

} else {

if (limit && hdrlen + datalen + hashsz >= limit) {

if (st)

close_istream(st);

free(buf);

return 0;

}

hashwrite(f, header, hdrlen);

}

if (st) {

datalen = write_large_blob_data(st, f, &entry->idx.oid);

close_istream(st);

} else {

hashwrite(f, buf, datalen);

free(buf);

}

return hdrlen + datalen;

}

static off_t write_reuse_object(struct hashfile *f, struct object_entry *entry,

unsigned long limit, int usable_delta)

{

struct packed_git *p = IN_PACK(entry);

struct pack_window *w_curs = NULL;

uint32_t pos;

off_t offset;

enum object_type type = oe_type(entry);

off_t datalen;

unsigned char header[MAX_PACK_OBJECT_HEADER],

dheader[MAX_PACK_OBJECT_HEADER];

unsigned hdrlen;

const unsigned hashsz = the_hash_algo->rawsz;

unsigned long entry_size = SIZE(entry);

if (DELTA(entry))

type = (allow_ofs_delta && DELTA(entry)->idx.offset) ?

OBJ_OFS_DELTA : OBJ_REF_DELTA;

hdrlen = encode_in_pack_object_header(header, sizeof(header),

type, entry_size);

offset = entry->in_pack_offset;

if (offset_to_pack_pos(p, offset, &pos) < 0)

die(_("write_reuse_object: could not locate %s, expected at "

"offset %"PRIuMAX" in pack %s"),

oid_to_hex(&entry->idx.oid), (uintmax_t)offset,

p->pack_name);

datalen = pack_pos_to_offset(p, pos + 1) - offset;

if (!pack_to_stdout && p->index_version > 1 &&

check_pack_crc(p, &w_curs, offset, datalen,

pack_pos_to_index(p, pos))) {

error(_("bad packed object CRC for %s"),

oid_to_hex(&entry->idx.oid));

unuse_pack(&w_curs);

return write_no_reuse_object(f, entry, limit, usable_delta);

}

offset += entry->in_pack_header_size;

datalen -= entry->in_pack_header_size;

if (!pack_to_stdout && p->index_version == 1 &&

check_pack_inflate(p, &w_curs, offset, datalen, entry_size)) {

error(_("corrupt packed object for %s"),

oid_to_hex(&entry->idx.oid));

unuse_pack(&w_curs);

return write_no_reuse_object(f, entry, limit, usable_delta);

}

if (type == OBJ_OFS_DELTA) {

off_t ofs = entry->idx.offset - DELTA(entry)->idx.offset;

unsigned pos = sizeof(dheader) - 1;

dheader[pos] = ofs & 127;

while (ofs >>= 7)

dheader[--pos] = 128 | (--ofs & 127);

if (limit && hdrlen + sizeof(dheader) - pos + datalen + hashsz >= limit) {

unuse_pack(&w_curs);

return 0;

}

hashwrite(f, header, hdrlen);

hashwrite(f, dheader + pos, sizeof(dheader) - pos);

hdrlen += sizeof(dheader) - pos;

reused_delta++;

} else if (type == OBJ_REF_DELTA) {

if (limit && hdrlen + hashsz + datalen + hashsz >= limit) {

unuse_pack(&w_curs);

return 0;

}

hashwrite(f, header, hdrlen);

hashwrite(f, DELTA(entry)->idx.oid.hash, hashsz);

hdrlen += hashsz;

reused_delta++;

} else {

if (limit && hdrlen + datalen + hashsz >= limit) {

unuse_pack(&w_curs);

return 0;

}

hashwrite(f, header, hdrlen);

}

copy_pack_data(f, p, &w_curs, offset, datalen);

unuse_pack(&w_curs);

reused++;

return hdrlen + datalen;

}

static off_t write_object(struct hashfile *f,

struct object_entry *entry,

off_t write_offset)

{

unsigned long limit;

off_t len;

int usable_delta, to_reuse;

if (!pack_to_stdout)

crc32_begin(f);

/* apply size limit if limited packsize and not first object */

if (!pack_size_limit || !nr_written)

limit = 0;

else if (pack_size_limit <= write_offset)

/*

limit = 1;

else

limit = pack_size_limit - write_offset;

if (!DELTA(entry))

usable_delta = 0; /* no delta */

else if (!pack_size_limit)

usable_delta = 1; /* unlimited packfile */

else if (DELTA(entry)->idx.offset == (off_t)-1)

usable_delta = 0; /* base was written to another pack */

else if (DELTA(entry)->idx.offset)

usable_delta = 1; /* base already exists in this pack */

else

usable_delta = 0; /* base could end up in another pack */

if (!reuse_object)

to_reuse = 0; /* explicit */

else if (!IN_PACK(entry))

to_reuse = 0; /* can't reuse what we don't have */

else if (oe_type(entry) == OBJ_REF_DELTA ||

oe_type(entry) == OBJ_OFS_DELTA)

/* check_object() decided it for us ... */

to_reuse = usable_delta;

/* ... but pack split may override that */

else if (oe_type(entry) != entry->in_pack_type)

to_reuse = 0; /* pack has delta which is unusable */

else if (DELTA(entry))

to_reuse = 0; /* we want to pack afresh */

else

to_reuse = 1; /* we have it in-pack undeltified,

if (!to_reuse)

len = write_no_reuse_object(f, entry, limit, usable_delta);

else

len = write_reuse_object(f, entry, limit, usable_delta);

if (!len)

return 0;

if (usable_delta)

written_delta++;

written++;

if (!pack_to_stdout)

entry->idx.crc32 = crc32_end(f);

return len;

}

enum write_one_status {

};

static enum write_one_status write_one(struct hashfile *f,

struct object_entry *e,

off_t *offset)

{

off_t size;

int recursing;

/*

recursing = (e->idx.offset == 1);

if (recursing) {

warning(_("recursive delta detected for object %s"),

oid_to_hex(&e->idx.oid));

return WRITE_ONE_RECURSIVE;

} else if (e->idx.offset || e->preferred_base) {

/* offset is non zero if object is written already. */

return WRITE_ONE_SKIP;

}

/* if we are deltified, write out base object first. */

if (DELTA(e)) {

e->idx.offset = 1; /* now recurse */

switch (write_one(f, DELTA(e), offset)) {

case WRITE_ONE_RECURSIVE:

/* we cannot depend on this one */

SET_DELTA(e, NULL);

break;

default:

break;

case WRITE_ONE_BREAK:

e->idx.offset = recursing;

return WRITE_ONE_BREAK;

}

}

e->idx.offset = *offset;

size = write_object(f, e, *offset);

if (!size) {

e->idx.offset = recursing;

return WRITE_ONE_BREAK;

}

written_list[nr_written++] = &e->idx;

/* make sure off_t is sufficiently large not to wrap */

if (signed_add_overflows(*offset, size))

die(_("pack too large for current definition of off_t"));

*offset += size;

return WRITE_ONE_WRITTEN;

}

static int mark_tagged(const char *path, const struct object_id *oid, int flag,

void *cb_data)

{

struct object_id peeled;

struct object_entry *entry = packlist_find(&to_pack, oid);

if (entry)

entry->tagged = 1;

if (!peel_iterated_oid(oid, &peeled)) {

entry = packlist_find(&to_pack, &peeled);

if (entry)

entry->tagged = 1;

}

return 0;

}

static inline unsigned char oe_layer(struct packing_data *pack,

struct object_entry *e)

{

if (!pack->layer)

return 0;

return pack->layer[e - pack->objects];

}

static inline void add_to_write_order(struct object_entry **wo,

unsigned int *endp,

struct object_entry *e)

{

if (e->filled || oe_layer(&to_pack, e) != write_layer)

return;

wo[(*endp)++] = e;

e->filled = 1;

}

static void add_descendants_to_write_order(struct object_entry **wo,

unsigned int *endp,

struct object_entry *e)

{

int add_to_order = 1;

while (e) {

if (add_to_order) {

struct object_entry *s;

/* add this node... */

add_to_write_order(wo, endp, e);

/* all its siblings... */

for (s = DELTA_SIBLING(e); s; s = DELTA_SIBLING(s)) {

add_to_write_order(wo, endp, s);

}

}

/* drop down a level to add left subtree nodes if possible */

if (DELTA_CHILD(e)) {

add_to_order = 1;

e = DELTA_CHILD(e);

} else {

add_to_order = 0;

/* our sibling might have some children, it is next */

if (DELTA_SIBLING(e)) {

e = DELTA_SIBLING(e);

continue;

}

/* go back to our parent node */

e = DELTA(e);

while (e && !DELTA_SIBLING(e)) {

/* we're on the right side of a subtree, keep

e = DELTA(e);

}

if (!e) {

/* done- we hit our original root node */

return;

}

/* pass it off to sibling at this level */

e = DELTA_SIBLING(e);

}

};

}

static void add_family_to_write_order(struct object_entry **wo,

unsigned int *endp,

struct object_entry *e)

{

struct object_entry *root;

for (root = e; DELTA(root); root = DELTA(root))

; /* nothing */

add_descendants_to_write_order(wo, endp, root);

}

static void compute_layer_order(struct object_entry **wo, unsigned int *wo_end)

{

unsigned int i, last_untagged;

struct object_entry *objects = to_pack.objects;

for (i = 0; i < to_pack.nr_objects; i++) {

if (objects[i].tagged)

break;

add_to_write_order(wo, wo_end, &objects[i]);

}

last_untagged = i;

/*

for (; i < to_pack.nr_objects; i++) {

if (objects[i].tagged)

add_to_write_order(wo, wo_end, &objects[i]);

}

/*

for (i = last_untagged; i < to_pack.nr_objects; i++) {

if (oe_type(&objects[i]) != OBJ_COMMIT &&

oe_type(&objects[i]) != OBJ_TAG)

continue;

add_to_write_order(wo, wo_end, &objects[i]);

}

/*

for (i = last_untagged; i < to_pack.nr_objects; i++) {

if (oe_type(&objects[i]) != OBJ_TREE)

continue;

add_to_write_order(wo, wo_end, &objects[i]);

}

/*

for (i = last_untagged; i < to_pack.nr_objects; i++) {

if (!objects[i].filled && oe_layer(&to_pack, &objects[i]) == write_layer)

add_family_to_write_order(wo, wo_end, &objects[i]);

}

}

static struct object_entry **compute_write_order(void)

{

uint32_t max_layers = 1;

unsigned int i, wo_end;

struct object_entry **wo;

struct object_entry *objects = to_pack.objects;

for (i = 0; i < to_pack.nr_objects; i++) {

objects[i].tagged = 0;

objects[i].filled = 0;

SET_DELTA_CHILD(&objects[i], NULL);

SET_DELTA_SIBLING(&objects[i], NULL);

}

/*

for (i = to_pack.nr_objects; i > 0;) {

struct object_entry *e = &objects[--i];

if (!DELTA(e))

continue;

/* Mark me as the first child */

e->delta_sibling_idx = DELTA(e)->delta_child_idx;

SET_DELTA_CHILD(DELTA(e), e);

}

/*

for_each_tag_ref(mark_tagged, NULL);

if (use_delta_islands)

max_layers = compute_pack_layers(&to_pack);

ALLOC_ARRAY(wo, to_pack.nr_objects);

wo_end = 0;

for (; write_layer < max_layers; ++write_layer)

compute_layer_order(wo, &wo_end);

if (wo_end != to_pack.nr_objects)

die(_("ordered %u objects, expected %"PRIu32),

wo_end, to_pack.nr_objects);

return wo;

}

static struct reused_chunk {

} *reused_chunks;

static int reused_chunks_nr;

static int reused_chunks_alloc;

static void record_reused_object(off_t where, off_t offset)

{

if (reused_chunks_nr && reused_chunks[reused_chunks_nr-1].difference == offset)

return;

ALLOC_GROW(reused_chunks, reused_chunks_nr + 1,

reused_chunks_alloc);

reused_chunks[reused_chunks_nr].original = where;

reused_chunks[reused_chunks_nr].difference = offset;

reused_chunks_nr++;

}

static off_t find_reused_offset(off_t where)

{

int lo = 0, hi = reused_chunks_nr;

while (lo < hi) {

int mi = lo + ((hi - lo) / 2);

if (where == reused_chunks[mi].original)

return reused_chunks[mi].difference;

if (where < reused_chunks[mi].original)

hi = mi;

else

lo = mi + 1;

}

/*

assert(lo);