Merge branch 'en/merge-recursive-directory-rename-fixes'
[thirdparty/git.git] / merge-recursive.c
index ec60715..11869ad 100644 (file)
@@ -4,30 +4,40 @@
  * The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006
  */
 #include "cache.h"
-#include "config.h"
+#include "merge-recursive.h"
+
 #include "advice.h"
-#include "lockfile.h"
-#include "cache-tree.h"
-#include "object-store.h"
-#include "repository.h"
-#include "commit.h"
+#include "alloc.h"
+#include "attr.h"
 #include "blob.h"
 #include "builtin.h"
-#include "tree-walk.h"
+#include "cache-tree.h"
+#include "commit.h"
+#include "commit-reach.h"
+#include "config.h"
 #include "diff.h"
 #include "diffcore.h"
+#include "dir.h"
+#include "ll-merge.h"
+#include "lockfile.h"
+#include "object-store.h"
+#include "repository.h"
+#include "revision.h"
+#include "string-list.h"
+#include "submodule.h"
 #include "tag.h"
-#include "alloc.h"
+#include "tree-walk.h"
 #include "unpack-trees.h"
-#include "string-list.h"
 #include "xdiff-interface.h"
-#include "ll-merge.h"
-#include "attr.h"
-#include "merge-recursive.h"
-#include "dir.h"
-#include "submodule.h"
-#include "revision.h"
-#include "commit-reach.h"
+
+struct merge_options_internal {
+       int call_depth;
+       int needed_rename_limit;
+       struct hashmap current_file_dir_set;
+       struct string_list df_conflict_file_set;
+       struct unpack_trees_options unpack_opts;
+       struct index_state orig_index;
+};
 
 struct path_hashmap_entry {
        struct hashmap_entry e;
@@ -35,14 +45,16 @@ struct path_hashmap_entry {
 };
 
 static int path_hashmap_cmp(const void *cmp_data,
-                           const void *entry,
-                           const void *entry_or_key,
+                           const struct hashmap_entry *eptr,
+                           const struct hashmap_entry *entry_or_key,
                            const void *keydata)
 {
-       const struct path_hashmap_entry *a = entry;
-       const struct path_hashmap_entry *b = entry_or_key;
+       const struct path_hashmap_entry *a, *b;
        const char *key = keydata;
 
+       a = container_of(eptr, const struct path_hashmap_entry, e);
+       b = container_of(entry_or_key, const struct path_hashmap_entry, e);
+
        if (ignore_case)
                return strcasecmp(a->path, key ? key : b->path);
        else
@@ -54,6 +66,24 @@ static unsigned int path_hash(const char *path)
        return ignore_case ? strihash(path) : strhash(path);
 }
 
+/*
+ * For dir_rename_entry, directory names are stored as a full path from the
+ * toplevel of the repository and do not include a trailing '/'.  Also:
+ *
+ *   dir:                original name of directory being renamed
+ *   non_unique_new_dir: if true, could not determine new_dir
+ *   new_dir:            final name of directory being renamed
+ *   possible_new_dirs:  temporary used to help determine new_dir; see comments
+ *                       in get_directory_renames() for details
+ */
+struct dir_rename_entry {
+       struct hashmap_entry ent;
+       char *dir;
+       unsigned non_unique_new_dir:1;
+       struct strbuf new_dir;
+       struct string_list possible_new_dirs;
+};
+
 static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap,
                                                      char *dir)
 {
@@ -61,18 +91,20 @@ static struct dir_rename_entry *dir_rename_find_entry(struct hashmap *hashmap,
 
        if (dir == NULL)
                return NULL;
-       hashmap_entry_init(&key, strhash(dir));
+       hashmap_entry_init(&key.ent, strhash(dir));
        key.dir = dir;
-       return hashmap_get(hashmap, &key, NULL);
+       return hashmap_get_entry(hashmap, &key, ent, NULL);
 }
 
 static int dir_rename_cmp(const void *unused_cmp_data,
-                         const void *entry,
-                         const void *entry_or_key,
+                         const struct hashmap_entry *eptr,
+                         const struct hashmap_entry *entry_or_key,
                          const void *unused_keydata)
 {
-       const struct dir_rename_entry *e1 = entry;
-       const struct dir_rename_entry *e2 = entry_or_key;
+       const struct dir_rename_entry *e1, *e2;
+
+       e1 = container_of(eptr, const struct dir_rename_entry, ent);
+       e2 = container_of(entry_or_key, const struct dir_rename_entry, ent);
 
        return strcmp(e1->dir, e2->dir);
 }
@@ -85,34 +117,46 @@ static void dir_rename_init(struct hashmap *map)
 static void dir_rename_entry_init(struct dir_rename_entry *entry,
                                  char *directory)
 {
-       hashmap_entry_init(entry, strhash(directory));
+       hashmap_entry_init(&entry->ent, strhash(directory));
        entry->dir = directory;
        entry->non_unique_new_dir = 0;
        strbuf_init(&entry->new_dir, 0);
        string_list_init(&entry->possible_new_dirs, 0);
 }
 
+struct collision_entry {
+       struct hashmap_entry ent;
+       char *target_file;
+       struct string_list source_files;
+       unsigned reported_already:1;
+};
+
 static struct collision_entry *collision_find_entry(struct hashmap *hashmap,
                                                    char *target_file)
 {
        struct collision_entry key;
 
-       hashmap_entry_init(&key, strhash(target_file));
+       hashmap_entry_init(&key.ent, strhash(target_file));
        key.target_file = target_file;
-       return hashmap_get(hashmap, &key, NULL);
+       return hashmap_get_entry(hashmap, &key, ent, NULL);
 }
 
-static int collision_cmp(void *unused_cmp_data,
-                        const struct collision_entry *e1,
-                        const struct collision_entry *e2,
+static int collision_cmp(const void *unused_cmp_data,
+                        const struct hashmap_entry *eptr,
+                        const struct hashmap_entry *entry_or_key,
                         const void *unused_keydata)
 {
+       const struct collision_entry *e1, *e2;
+
+       e1 = container_of(eptr, const struct collision_entry, ent);
+       e2 = container_of(entry_or_key, const struct collision_entry, ent);
+
        return strcmp(e1->target_file, e2->target_file);
 }
 
 static void collision_init(struct hashmap *map)
 {
-       hashmap_init(map, (hashmap_cmp_fn) collision_cmp, NULL, 0);
+       hashmap_init(map, collision_cmp, NULL, 0);
 }
 
 static void flush_output(struct merge_options *opt)
@@ -284,7 +328,8 @@ static inline void setup_rename_conflict_info(enum rename_type rename_type,
 
 static int show(struct merge_options *opt, int v)
 {
-       return (!opt->call_depth && opt->verbosity >= v) || opt->verbosity >= 5;
+       return (!opt->priv->call_depth && opt->verbosity >= v) ||
+               opt->verbosity >= 5;
 }
 
 __attribute__((format (printf, 3, 4)))
@@ -295,7 +340,7 @@ static void output(struct merge_options *opt, int v, const char *fmt, ...)
        if (!show(opt, v))
                return;
 
-       strbuf_addchars(&opt->obuf, ' ', opt->call_depth * 2);
+       strbuf_addchars(&opt->obuf, ' ', opt->priv->call_depth * 2);
 
        va_start(ap, fmt);
        strbuf_vaddf(&opt->obuf, fmt, ap);
@@ -310,7 +355,7 @@ static void output_commit_title(struct merge_options *opt, struct commit *commit
 {
        struct merge_remote_desc *desc;
 
-       strbuf_addchars(&opt->obuf, ' ', opt->call_depth * 2);
+       strbuf_addchars(&opt->obuf, ' ', opt->priv->call_depth * 2);
        desc = merge_remote_util(commit);
        if (desc)
                strbuf_addf(&opt->obuf, "virtual %s\n", desc->name);
@@ -358,6 +403,11 @@ static int add_cacheinfo(struct merge_options *opt,
        return ret;
 }
 
+static inline int merge_detect_rename(struct merge_options *opt)
+{
+       return (opt->detect_renames >= 0) ? opt->detect_renames : 1;
+}
+
 static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)
 {
        parse_tree(tree);
@@ -373,74 +423,43 @@ static int unpack_trees_start(struct merge_options *opt,
        struct tree_desc t[3];
        struct index_state tmp_index = { NULL };
 
-       memset(&opt->unpack_opts, 0, sizeof(opt->unpack_opts));
-       if (opt->call_depth)
-               opt->unpack_opts.index_only = 1;
+       memset(&opt->priv->unpack_opts, 0, sizeof(opt->priv->unpack_opts));
+       if (opt->priv->call_depth)
+               opt->priv->unpack_opts.index_only = 1;
        else
-               opt->unpack_opts.update = 1;
-       opt->unpack_opts.merge = 1;
-       opt->unpack_opts.head_idx = 2;
-       opt->unpack_opts.fn = threeway_merge;
-       opt->unpack_opts.src_index = opt->repo->index;
-       opt->unpack_opts.dst_index = &tmp_index;
-       opt->unpack_opts.aggressive = !merge_detect_rename(opt);
-       setup_unpack_trees_porcelain(&opt->unpack_opts, "merge");
+               opt->priv->unpack_opts.update = 1;
+       opt->priv->unpack_opts.merge = 1;
+       opt->priv->unpack_opts.head_idx = 2;
+       opt->priv->unpack_opts.fn = threeway_merge;
+       opt->priv->unpack_opts.src_index = opt->repo->index;
+       opt->priv->unpack_opts.dst_index = &tmp_index;
+       opt->priv->unpack_opts.aggressive = !merge_detect_rename(opt);
+       setup_unpack_trees_porcelain(&opt->priv->unpack_opts, "merge");
 
        init_tree_desc_from_tree(t+0, common);
        init_tree_desc_from_tree(t+1, head);
        init_tree_desc_from_tree(t+2, merge);
 
-       rc = unpack_trees(3, t, &opt->unpack_opts);
+       rc = unpack_trees(3, t, &opt->priv->unpack_opts);
        cache_tree_free(&opt->repo->index->cache_tree);
 
        /*
-        * Update opt->repo->index to match the new results, AFTER saving a copy
-        * in opt->orig_index.  Update src_index to point to the saved copy.
-        * (verify_uptodate() checks src_index, and the original index is
-        * the one that had the necessary modification timestamps.)
+        * Update opt->repo->index to match the new results, AFTER saving a
+        * copy in opt->priv->orig_index.  Update src_index to point to the
+        * saved copy.  (verify_uptodate() checks src_index, and the original
+        * index is the one that had the necessary modification timestamps.)
         */
-       opt->orig_index = *opt->repo->index;
+       opt->priv->orig_index = *opt->repo->index;
        *opt->repo->index = tmp_index;
-       opt->unpack_opts.src_index = &opt->orig_index;
+       opt->priv->unpack_opts.src_index = &opt->priv->orig_index;
 
        return rc;
 }
 
 static void unpack_trees_finish(struct merge_options *opt)
 {
-       discard_index(&opt->orig_index);
-       clear_unpack_trees_porcelain(&opt->unpack_opts);
-}
-
-struct tree *write_tree_from_memory(struct merge_options *opt)
-{
-       struct tree *result = NULL;
-       struct index_state *istate = opt->repo->index;
-
-       if (unmerged_index(istate)) {
-               int i;
-               fprintf(stderr, "BUG: There are unmerged index entries:\n");
-               for (i = 0; i < istate->cache_nr; i++) {
-                       const struct cache_entry *ce = istate->cache[i];
-                       if (ce_stage(ce))
-                               fprintf(stderr, "BUG: %d %.*s\n", ce_stage(ce),
-                                       (int)ce_namelen(ce), ce->name);
-               }
-               BUG("unmerged index entries in merge-recursive.c");
-       }
-
-       if (!istate->cache_tree)
-               istate->cache_tree = cache_tree();
-
-       if (!cache_tree_fully_valid(istate->cache_tree) &&
-           cache_tree_update(istate, 0) < 0) {
-               err(opt, _("error building trees"));
-               return NULL;
-       }
-
-       result = lookup_tree(opt->repo, &istate->cache_tree->oid);
-
-       return result;
+       discard_index(&opt->priv->orig_index);
+       clear_unpack_trees_porcelain(&opt->priv->unpack_opts);
 }
 
 static int save_files_dirs(const struct object_id *oid,
@@ -454,8 +473,8 @@ static int save_files_dirs(const struct object_id *oid,
        strbuf_addstr(base, path);
 
        FLEX_ALLOC_MEM(entry, path, base->buf, base->len);
-       hashmap_entry_init(entry, path_hash(entry->path));
-       hashmap_add(&opt->current_file_dir_set, entry);
+       hashmap_entry_init(&entry->e, path_hash(entry->path));
+       hashmap_add(&opt->priv->current_file_dir_set, &entry->e);
 
        strbuf_setlen(base, baselen);
        return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0);
@@ -586,7 +605,7 @@ static void record_df_conflict_files(struct merge_options *opt,
         * If we're merging merge-bases, we don't want to bother with
         * any working directory changes.
         */
-       if (opt->call_depth)
+       if (opt->priv->call_depth)
                return;
 
        /* Ensure D/F conflicts are adjacent in the entries list. */
@@ -598,7 +617,7 @@ static void record_df_conflict_files(struct merge_options *opt,
        df_sorted_entries.cmp = string_list_df_name_compare;
        string_list_sort(&df_sorted_entries);
 
-       string_list_clear(&opt->df_conflict_file_set, 1);
+       string_list_clear(&opt->priv->df_conflict_file_set, 1);
        for (i = 0; i < df_sorted_entries.nr; i++) {
                const char *path = df_sorted_entries.items[i].string;
                int len = strlen(path);
@@ -614,7 +633,7 @@ static void record_df_conflict_files(struct merge_options *opt,
                    len > last_len &&
                    memcmp(path, last_file, last_len) == 0 &&
                    path[last_len] == '/') {
-                       string_list_insert(&opt->df_conflict_file_set, last_file);
+                       string_list_insert(&opt->priv->df_conflict_file_set, last_file);
                }
 
                /*
@@ -681,8 +700,8 @@ static void update_entry(struct stage_data *entry,
 static int remove_file(struct merge_options *opt, int clean,
                       const char *path, int no_wd)
 {
-       int update_cache = opt->call_depth || clean;
-       int update_working_directory = !opt->call_depth && !no_wd;
+       int update_cache = opt->priv->call_depth || clean;
+       int update_working_directory = !opt->priv->call_depth && !no_wd;
 
        if (update_cache) {
                if (remove_file_from_index(opt->repo->index, path))
@@ -712,7 +731,9 @@ static void add_flattened_path(struct strbuf *out, const char *s)
                        out->buf[i] = '_';
 }
 
-static char *unique_path(struct merge_options *opt, const char *path, const char *branch)
+static char *unique_path(struct merge_options *opt,
+                        const char *path,
+                        const char *branch)
 {
        struct path_hashmap_entry *entry;
        struct strbuf newpath = STRBUF_INIT;
@@ -723,16 +744,16 @@ static char *unique_path(struct merge_options *opt, const char *path, const char
        add_flattened_path(&newpath, branch);
 
        base_len = newpath.len;
-       while (hashmap_get_from_hash(&opt->current_file_dir_set,
+       while (hashmap_get_from_hash(&opt->priv->current_file_dir_set,
                                     path_hash(newpath.buf), newpath.buf) ||
-              (!opt->call_depth && file_exists(newpath.buf))) {
+              (!opt->priv->call_depth && file_exists(newpath.buf))) {
                strbuf_setlen(&newpath, base_len);
                strbuf_addf(&newpath, "_%d", suffix++);
        }
 
        FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len);
-       hashmap_entry_init(entry, path_hash(entry->path));
-       hashmap_add(&opt->current_file_dir_set, entry);
+       hashmap_entry_init(&entry->e, path_hash(entry->path));
+       hashmap_add(&opt->priv->current_file_dir_set, &entry->e);
        return strbuf_detach(&newpath, NULL);
 }
 
@@ -775,7 +796,7 @@ static int dir_in_way(struct index_state *istate, const char *path,
 static int was_tracked_and_matches(struct merge_options *opt, const char *path,
                                   const struct diff_filespec *blob)
 {
-       int pos = index_name_pos(&opt->orig_index, path, strlen(path));
+       int pos = index_name_pos(&opt->priv->orig_index, path, strlen(path));
        struct cache_entry *ce;
 
        if (0 > pos)
@@ -783,7 +804,7 @@ static int was_tracked_and_matches(struct merge_options *opt, const char *path,
                return 0;
 
        /* See if the file we were tracking before matches */
-       ce = opt->orig_index.cache[pos];
+       ce = opt->priv->orig_index.cache[pos];
        return (oid_eq(&ce->oid, &blob->oid) && ce->ce_mode == blob->mode);
 }
 
@@ -792,7 +813,7 @@ static int was_tracked_and_matches(struct merge_options *opt, const char *path,
  */
 static int was_tracked(struct merge_options *opt, const char *path)
 {
-       int pos = index_name_pos(&opt->orig_index, path, strlen(path));
+       int pos = index_name_pos(&opt->priv->orig_index, path, strlen(path));
 
        if (0 <= pos)
                /* we were tracking this path before the merge */
@@ -849,12 +870,12 @@ static int was_dirty(struct merge_options *opt, const char *path)
        struct cache_entry *ce;
        int dirty = 1;
 
-       if (opt->call_depth || !was_tracked(opt, path))
+       if (opt->priv->call_depth || !was_tracked(opt, path))
                return !dirty;
 
-       ce = index_file_exists(opt->unpack_opts.src_index,
+       ce = index_file_exists(opt->priv->unpack_opts.src_index,
                               path, strlen(path), ignore_case);
-       dirty = verify_uptodate(ce, &opt->unpack_opts) != 0;
+       dirty = verify_uptodate(ce, &opt->priv->unpack_opts) != 0;
        return dirty;
 }
 
@@ -864,8 +885,8 @@ static int make_room_for_path(struct merge_options *opt, const char *path)
        const char *msg = _("failed to create path '%s'%s");
 
        /* Unlink any D/F conflict files that are in the way */
-       for (i = 0; i < opt->df_conflict_file_set.nr; i++) {
-               const char *df_path = opt->df_conflict_file_set.items[i].string;
+       for (i = 0; i < opt->priv->df_conflict_file_set.nr; i++) {
+               const char *df_path = opt->priv->df_conflict_file_set.items[i].string;
                size_t pathlen = strlen(path);
                size_t df_pathlen = strlen(df_path);
                if (df_pathlen < pathlen &&
@@ -875,7 +896,7 @@ static int make_room_for_path(struct merge_options *opt, const char *path)
                               _("Removing %s to make room for subdirectory\n"),
                               df_path);
                        unlink(df_path);
-                       unsorted_string_list_delete_item(&opt->df_conflict_file_set,
+                       unsorted_string_list_delete_item(&opt->priv->df_conflict_file_set,
                                                         i, 0);
                        break;
                }
@@ -916,7 +937,7 @@ static int update_file_flags(struct merge_options *opt,
 {
        int ret = 0;
 
-       if (opt->call_depth)
+       if (opt->priv->call_depth)
                update_wd = 0;
 
        if (update_wd) {
@@ -935,9 +956,11 @@ static int update_file_flags(struct merge_options *opt,
                }
 
                buf = read_object_file(&contents->oid, &type, &size);
-               if (!buf)
-                       return err(opt, _("cannot read object %s '%s'"),
-                                  oid_to_hex(&contents->oid), path);
+               if (!buf) {
+                       ret = err(opt, _("cannot read object %s '%s'"),
+                                 oid_to_hex(&contents->oid), path);
+                       goto free_buf;
+               }
                if (type != OBJ_BLOB) {
                        ret = err(opt, _("blob expected for %s '%s'"),
                                  oid_to_hex(&contents->oid), path);
@@ -945,7 +968,8 @@ static int update_file_flags(struct merge_options *opt,
                }
                if (S_ISREG(contents->mode)) {
                        struct strbuf strbuf = STRBUF_INIT;
-                       if (convert_to_working_tree(opt->repo->index, path, buf, size, &strbuf)) {
+                       if (convert_to_working_tree(opt->repo->index,
+                                                   path, buf, size, &strbuf)) {
                                free(buf);
                                size = strbuf.len;
                                buf = strbuf_detach(&strbuf, NULL);
@@ -998,7 +1022,7 @@ static int update_file(struct merge_options *opt,
                       const char *path)
 {
        return update_file_flags(opt, contents, path,
-                                opt->call_depth || clean, !opt->call_depth);
+                                opt->priv->call_depth || clean, !opt->priv->call_depth);
 }
 
 /* Low level file merging, update and removal */
@@ -1020,22 +1044,22 @@ static int merge_3way(struct merge_options *opt,
 {
        mmfile_t orig, src1, src2;
        struct ll_merge_options ll_opts = {0};
-       char *base_name, *name1, *name2;
+       char *base, *name1, *name2;
        int merge_status;
 
        ll_opts.renormalize = opt->renormalize;
        ll_opts.extra_marker_size = extra_marker_size;
        ll_opts.xdl_opts = opt->xdl_opts;
 
-       if (opt->call_depth) {
+       if (opt->priv->call_depth) {
                ll_opts.virtual_ancestor = 1;
                ll_opts.variant = 0;
        } else {
                switch (opt->recursive_variant) {
-               case MERGE_RECURSIVE_OURS:
+               case MERGE_VARIANT_OURS:
                        ll_opts.variant = XDL_MERGE_FAVOR_OURS;
                        break;
-               case MERGE_RECURSIVE_THEIRS:
+               case MERGE_VARIANT_THEIRS:
                        ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;
                        break;
                default:
@@ -1044,16 +1068,13 @@ static int merge_3way(struct merge_options *opt,
                }
        }
 
-       assert(a->path && b->path);
-       if (strcmp(a->path, b->path) ||
-           (opt->ancestor != NULL && strcmp(a->path, o->path) != 0)) {
-               base_name = opt->ancestor == NULL ? NULL :
-                       mkpathdup("%s:%s", opt->ancestor, o->path);
+       assert(a->path && b->path && o->path && opt->ancestor);
+       if (strcmp(a->path, b->path) || strcmp(a->path, o->path) != 0) {
+               base  = mkpathdup("%s:%s", opt->ancestor, o->path);
                name1 = mkpathdup("%s:%s", branch1, a->path);
                name2 = mkpathdup("%s:%s", branch2, b->path);
        } else {
-               base_name = opt->ancestor == NULL ? NULL :
-                       mkpathdup("%s", opt->ancestor);
+               base  = mkpathdup("%s", opt->ancestor);
                name1 = mkpathdup("%s", branch1);
                name2 = mkpathdup("%s", branch2);
        }
@@ -1062,11 +1083,11 @@ static int merge_3way(struct merge_options *opt,
        read_mmblob(&src1, &a->oid);
        read_mmblob(&src2, &b->oid);
 
-       merge_status = ll_merge(result_buf, a->path, &orig, base_name,
+       merge_status = ll_merge(result_buf, a->path, &orig, base,
                                &src1, name1, &src2, name2,
                                opt->repo->index, &ll_opts);
 
-       free(base_name);
+       free(base);
        free(name1);
        free(name2);
        free(orig.ptr);
@@ -1161,7 +1182,7 @@ static int merge_submodule(struct merge_options *opt,
        struct object_array merges;
 
        int i;
-       int search = !opt->call_depth;
+       int search = !opt->priv->call_depth;
 
        /* store a in result in case we fail */
        oidcpy(result, a);
@@ -1345,15 +1366,15 @@ static int merge_mode_and_contents(struct merge_options *opt,
                                                        &b->oid);
                } else if (S_ISLNK(a->mode)) {
                        switch (opt->recursive_variant) {
-                       case MERGE_RECURSIVE_NORMAL:
+                       case MERGE_VARIANT_NORMAL:
                                oidcpy(&result->blob.oid, &a->oid);
                                if (!oid_eq(&a->oid, &b->oid))
                                        result->clean = 0;
                                break;
-                       case MERGE_RECURSIVE_OURS:
+                       case MERGE_VARIANT_OURS:
                                oidcpy(&result->blob.oid, &a->oid);
                                break;
-                       case MERGE_RECURSIVE_THEIRS:
+                       case MERGE_VARIANT_THEIRS:
                                oidcpy(&result->blob.oid, &b->oid);
                                break;
                        }
@@ -1379,10 +1400,11 @@ static int handle_rename_via_dir(struct merge_options *opt,
        const struct rename *ren = ci->ren1;
        const struct diff_filespec *dest = ren->pair->two;
        char *file_path = dest->path;
-       int mark_conflicted = (opt->detect_directory_renames == 1);
+       int mark_conflicted = (opt->detect_directory_renames ==
+                              MERGE_DIRECTORY_RENAMES_CONFLICT);
        assert(ren->dir_rename_original_dest);
 
-       if (!opt->call_depth && would_lose_untracked(opt, dest->path)) {
+       if (!opt->priv->call_depth && would_lose_untracked(opt, dest->path)) {
                mark_conflicted = 1;
                file_path = unique_path(opt, dest->path, ren->branch);
                output(opt, 1, _("Error: Refusing to lose untracked file at %s; "
@@ -1425,12 +1447,12 @@ static int handle_change_delete(struct merge_options *opt,
        const char *update_path = path;
        int ret = 0;
 
-       if (dir_in_way(opt->repo->index, path, !opt->call_depth, 0) ||
-           (!opt->call_depth && would_lose_untracked(opt, path))) {
+       if (dir_in_way(opt->repo->index, path, !opt->priv->call_depth, 0) ||
+           (!opt->priv->call_depth && would_lose_untracked(opt, path))) {
                update_path = alt_path = unique_path(opt, path, change_branch);
        }
 
-       if (opt->call_depth) {
+       if (opt->priv->call_depth) {
                /*
                 * We cannot arbitrarily accept either a_sha or b_sha as
                 * correct; since there is no true "middle point" between
@@ -1505,14 +1527,14 @@ static int handle_rename_delete(struct merge_options *opt,
                                     opt->branch2 : opt->branch1);
 
        if (handle_change_delete(opt,
-                                opt->call_depth ? orig->path : dest->path,
-                                opt->call_depth ? NULL : orig->path,
+                                opt->priv->call_depth ? orig->path : dest->path,
+                                opt->priv->call_depth ? NULL : orig->path,
                                 orig, dest,
                                 rename_branch, delete_branch,
                                 _("rename"), _("renamed")))
                return -1;
 
-       if (opt->call_depth)
+       if (opt->priv->call_depth)
                return remove_file_from_index(opt->repo->index, dest->path);
        else
                return update_stages(opt, dest->path, NULL,
@@ -1549,7 +1571,7 @@ static int handle_file_collision(struct merge_options *opt,
        /*
         * In the recursive case, we just opt to undo renames
         */
-       if (opt->call_depth && (prev_path1 || prev_path2)) {
+       if (opt->priv->call_depth && (prev_path1 || prev_path2)) {
                /* Put first file (a->oid, a->mode) in its original spot */
                if (prev_path1) {
                        if (update_file(opt, 1, a, prev_path1))
@@ -1578,10 +1600,10 @@ static int handle_file_collision(struct merge_options *opt,
        /* Remove rename sources if rename/add or rename/rename(2to1) */
        if (prev_path1)
                remove_file(opt, 1, prev_path1,
-                           opt->call_depth || would_lose_untracked(opt, prev_path1));
+                           opt->priv->call_depth || would_lose_untracked(opt, prev_path1));
        if (prev_path2)
                remove_file(opt, 1, prev_path2,
-                           opt->call_depth || would_lose_untracked(opt, prev_path2));
+                           opt->priv->call_depth || would_lose_untracked(opt, prev_path2));
 
        /*
         * Remove the collision path, if it wouldn't cause dirty contents
@@ -1623,12 +1645,12 @@ static int handle_file_collision(struct merge_options *opt,
        null.mode = 0;
 
        if (merge_mode_and_contents(opt, &null, a, b, collide_path,
-                                   branch1, branch2, opt->call_depth * 2, &mfi))
+                                   branch1, branch2, opt->priv->call_depth * 2, &mfi))
                return -1;
        mfi.clean &= !alt_path;
        if (update_file(opt, mfi.clean, &mfi.blob, update_path))
                return -1;
-       if (!mfi.clean && !opt->call_depth &&
+       if (!mfi.clean && !opt->priv->call_depth &&
            update_stages(opt, collide_path, NULL, a, b))
                return -1;
        free(alt_path);
@@ -1668,7 +1690,7 @@ static int handle_rename_add(struct merge_options *opt,
                                    &ci->ren1->src_entry->stages[other_stage],
                                    prev_path_desc,
                                    opt->branch1, opt->branch2,
-                                   1 + opt->call_depth * 2, &mfi))
+                                   1 + opt->priv->call_depth * 2, &mfi))
                return -1;
        free(prev_path_desc);
 
@@ -1686,7 +1708,7 @@ static char *find_path_for_conflict(struct merge_options *opt,
                                    const char *branch2)
 {
        char *new_path = NULL;
-       if (dir_in_way(opt->repo->index, path, !opt->call_depth, 0)) {
+       if (dir_in_way(opt->repo->index, path, !opt->priv->call_depth, 0)) {
                new_path = unique_path(opt, path, branch1);
                output(opt, 1, _("%s is a directory in %s adding "
                               "as %s instead"),
@@ -1717,17 +1739,17 @@ static int handle_rename_rename_1to2(struct merge_options *opt,
               "rename \"%s\"->\"%s\" in \"%s\"%s"),
               o->path, a->path, ci->ren1->branch,
               o->path, b->path, ci->ren2->branch,
-              opt->call_depth ? _(" (left unresolved)") : "");
+              opt->priv->call_depth ? _(" (left unresolved)") : "");
 
        path_desc = xstrfmt("%s and %s, both renamed from %s",
                            a->path, b->path, o->path);
        if (merge_mode_and_contents(opt, o, a, b, path_desc,
                                    ci->ren1->branch, ci->ren2->branch,
-                                   opt->call_depth * 2, &mfi))
+                                   opt->priv->call_depth * 2, &mfi))
                return -1;
        free(path_desc);
 
-       if (opt->call_depth) {
+       if (opt->priv->call_depth) {
                /*
                 * FIXME: For rename/add-source conflicts (if we could detect
                 * such), this is wrong.  We should instead find a unique
@@ -1842,12 +1864,12 @@ static int handle_rename_rename_2to1(struct merge_options *opt,
                                    &ci->ren1->src_entry->stages[ostage1],
                                    path_side_1_desc,
                                    opt->branch1, opt->branch2,
-                                   1 + opt->call_depth * 2, &mfi_c1) ||
+                                   1 + opt->priv->call_depth * 2, &mfi_c1) ||
            merge_mode_and_contents(opt, b,
                                    &ci->ren2->src_entry->stages[ostage2],
                                    c2, path_side_2_desc,
                                    opt->branch1, opt->branch2,
-                                   1 + opt->call_depth * 2, &mfi_c2))
+                                   1 + opt->priv->call_depth * 2, &mfi_c2))
                return -1;
        free(path_side_1_desc);
        free(path_side_2_desc);
@@ -1881,17 +1903,15 @@ static struct diff_queue_struct *get_diffpairs(struct merge_options *opt,
         */
        if (opts.detect_rename > DIFF_DETECT_RENAME)
                opts.detect_rename = DIFF_DETECT_RENAME;
-       opts.rename_limit = opt->merge_rename_limit >= 0 ? opt->merge_rename_limit :
-                           opt->diff_rename_limit >= 0 ? opt->diff_rename_limit :
-                           1000;
+       opts.rename_limit = (opt->rename_limit >= 0) ? opt->rename_limit : 1000;
        opts.rename_score = opt->rename_score;
        opts.show_rename_progress = opt->show_rename_progress;
        opts.output_format = DIFF_FORMAT_NO_OUTPUT;
        diff_setup_done(&opts);
        diff_tree_oid(&o_tree->object.oid, &tree->object.oid, "", &opts);
        diffcore_std(&opts);
-       if (opts.needed_rename_limit > opt->needed_rename_limit)
-               opt->needed_rename_limit = opts.needed_rename_limit;
+       if (opts.needed_rename_limit > opt->priv->needed_rename_limit)
+               opt->priv->needed_rename_limit = opts.needed_rename_limit;
 
        ret = xmalloc(sizeof(*ret));
        *ret = diff_queued_diff;
@@ -2060,7 +2080,7 @@ static void remove_hashmap_entries(struct hashmap *dir_renames,
 
        for (i = 0; i < items_to_remove->nr; i++) {
                entry = items_to_remove->items[i].util;
-               hashmap_remove(dir_renames, entry, NULL);
+               hashmap_remove(dir_renames, &entry->ent, NULL);
        }
        string_list_clear(items_to_remove, 0);
 }
@@ -2183,8 +2203,8 @@ static void handle_directory_level_conflicts(struct merge_options *opt,
        struct string_list remove_from_head = STRING_LIST_INIT_NODUP;
        struct string_list remove_from_merge = STRING_LIST_INIT_NODUP;
 
-       hashmap_iter_init(dir_re_head, &iter);
-       while ((head_ent = hashmap_iter_next(&iter))) {
+       hashmap_for_each_entry(dir_re_head, &iter, head_ent,
+                               ent /* member name */) {
                merge_ent = dir_rename_find_entry(dir_re_merge, head_ent->dir);
                if (merge_ent &&
                    !head_ent->non_unique_new_dir &&
@@ -2208,8 +2228,8 @@ static void handle_directory_level_conflicts(struct merge_options *opt,
        remove_hashmap_entries(dir_re_head, &remove_from_head);
        remove_hashmap_entries(dir_re_merge, &remove_from_merge);
 
-       hashmap_iter_init(dir_re_merge, &iter);
-       while ((merge_ent = hashmap_iter_next(&iter))) {
+       hashmap_for_each_entry(dir_re_merge, &iter, merge_ent,
+                               ent /* member name */) {
                head_ent = dir_rename_find_entry(dir_re_head, merge_ent->dir);
                if (tree_has_path(opt->repo, merge, merge_ent->dir)) {
                        /* 2. This wasn't a directory rename after all */
@@ -2288,7 +2308,7 @@ static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs)
                if (!entry) {
                        entry = xmalloc(sizeof(*entry));
                        dir_rename_entry_init(entry, old_dir);
-                       hashmap_put(dir_renames, entry);
+                       hashmap_put(dir_renames, &entry->ent);
                } else {
                        free(old_dir);
                }
@@ -2313,8 +2333,8 @@ static struct hashmap *get_directory_renames(struct diff_queue_struct *pairs)
         * we set non_unique_new_dir.  Once we've determined the winner (or
         * that there is no winner), we no longer need possible_new_dirs.
         */
-       hashmap_iter_init(dir_renames, &iter);
-       while ((entry = hashmap_iter_next(&iter))) {
+       hashmap_for_each_entry(dir_renames, &iter, entry,
+                               ent /* member name */) {
                int max = 0;
                int bad_max = 0;
                char *best = NULL;
@@ -2417,8 +2437,9 @@ static void compute_collisions(struct hashmap *collisions,
                if (!collision_ent) {
                        collision_ent = xcalloc(1,
                                                sizeof(struct collision_entry));
-                       hashmap_entry_init(collision_ent, strhash(new_path));
-                       hashmap_put(collisions, collision_ent);
+                       hashmap_entry_init(&collision_ent->ent,
+                                               strhash(new_path));
+                       hashmap_put(collisions, &collision_ent->ent);
                        collision_ent->target_file = new_path;
                } else {
                        free(new_path);
@@ -2671,12 +2692,12 @@ static struct string_list *get_renames(struct merge_options *opt,
                                                             entries);
        }
 
-       hashmap_iter_init(&collisions, &iter);
-       while ((e = hashmap_iter_next(&iter))) {
+       hashmap_for_each_entry(&collisions, &iter, e,
+                               ent /* member name */) {
                free(e->target_file);
                string_list_clear(&e->source_files, 0);
        }
-       hashmap_free(&collisions, 1);
+       hashmap_free_entries(&collisions, struct collision_entry, ent);
        return renames;
 }
 
@@ -2889,13 +2910,13 @@ static void initial_cleanup_rename(struct diff_queue_struct *pairs,
        struct hashmap_iter iter;
        struct dir_rename_entry *e;
 
-       hashmap_iter_init(dir_renames, &iter);
-       while ((e = hashmap_iter_next(&iter))) {
+       hashmap_for_each_entry(dir_renames, &iter, e,
+                               ent /* member name */) {
                free(e->dir);
                strbuf_release(&e->new_dir);
                /* possible_new_dirs already cleared in get_directory_renames */
        }
-       hashmap_free(dir_renames, 1);
+       hashmap_free_entries(dir_renames, struct dir_rename_entry, ent);
        free(dir_renames);
 
        free(pairs->queue);
@@ -2922,8 +2943,9 @@ static int detect_and_process_renames(struct merge_options *opt,
        head_pairs = get_diffpairs(opt, common, head);
        merge_pairs = get_diffpairs(opt, common, merge);
 
-       if ((opt->detect_directory_renames == 2) ||
-           (opt->detect_directory_renames == 1 && !opt->call_depth)) {
+       if ((opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_TRUE) ||
+           (opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_CONFLICT &&
+            !opt->priv->call_depth)) {
                dir_re_head = get_directory_renames(head_pairs);
                dir_re_merge = get_directory_renames(merge_pairs);
 
@@ -3080,13 +3102,13 @@ static int handle_content_merge(struct merge_file_info *mfi,
                reason = _("add/add");
 
        assert(o->path && a->path && b->path);
-       if (ci && dir_in_way(opt->repo->index, path, !opt->call_depth,
+       if (ci && dir_in_way(opt->repo->index, path, !opt->priv->call_depth,
                             S_ISGITLINK(ci->ren1->pair->two->mode)))
                df_conflict_remains = 1;
 
        if (merge_mode_and_contents(opt, o, a, b, path,
                                    opt->branch1, opt->branch2,
-                                   opt->call_depth * 2, mfi))
+                                   opt->priv->call_depth * 2, mfi))
                return -1;
 
        /*
@@ -3102,7 +3124,7 @@ static int handle_content_merge(struct merge_file_info *mfi,
 
                output(opt, 3, _("Skipped %s (merged same as existing)"), path);
                if (add_cacheinfo(opt, &mfi->blob, path,
-                                 0, (!opt->call_depth && !is_dirty), 0))
+                                 0, (!opt->priv->call_depth && !is_dirty), 0))
                        return -1;
                /*
                 * However, add_cacheinfo() will delete the old cache entry
@@ -3110,8 +3132,8 @@ static int handle_content_merge(struct merge_file_info *mfi,
                 * flag to avoid making the file appear as if it were
                 * deleted by the user.
                 */
-               pos = index_name_pos(&opt->orig_index, path, strlen(path));
-               ce = opt->orig_index.cache[pos];
+               pos = index_name_pos(&opt->priv->orig_index, path, strlen(path));
+               ce = opt->priv->orig_index.cache[pos];
                if (ce_skip_worktree(ce)) {
                        pos = index_name_pos(opt->repo->index, path, strlen(path));
                        ce = opt->repo->index->cache[pos];
@@ -3132,7 +3154,7 @@ static int handle_content_merge(struct merge_file_info *mfi,
 
        if (df_conflict_remains || is_dirty) {
                char *new_path;
-               if (opt->call_depth) {
+               if (opt->priv->call_depth) {
                        remove_file_from_index(opt->repo->index, path);
                } else {
                        if (!mfi->clean) {
@@ -3181,7 +3203,8 @@ static int handle_rename_normal(struct merge_options *opt,
        clean = handle_content_merge(&mfi, opt, path, was_dirty(opt, path),
                                     o, a, b, ci);
 
-       if (clean && opt->detect_directory_renames == 1 &&
+       if (clean &&
+           opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_CONFLICT &&
            ren->dir_rename_original_dest) {
                if (update_stages(opt, path,
                                  NULL,
@@ -3226,12 +3249,12 @@ static int warn_about_dir_renamed_entries(struct merge_options *opt,
                return clean;
 
        /* Sanity checks */
-       assert(opt->detect_directory_renames > 0);
+       assert(opt->detect_directory_renames > MERGE_DIRECTORY_RENAMES_NONE);
        assert(ren->dir_rename_original_type == 'A' ||
               ren->dir_rename_original_type == 'R');
 
        /* Check whether to treat directory renames as a conflict */
-       clean = (opt->detect_directory_renames == 2);
+       clean = (opt->detect_directory_renames == MERGE_DIRECTORY_RENAMES_TRUE);
 
        is_add = (ren->dir_rename_original_type == 'A');
        if (ren->dir_rename_original_type == 'A' && clean) {
@@ -3390,7 +3413,7 @@ static int process_entry(struct merge_options *opt,
                        conf = _("directory/file");
                }
                if (dir_in_way(opt->repo->index, path,
-                              !opt->call_depth && !S_ISGITLINK(a->mode),
+                              !opt->priv->call_depth && !S_ISGITLINK(a->mode),
                               0)) {
                        char *new_path = unique_path(opt, path, add_branch);
                        clean_merge = 0;
@@ -3399,7 +3422,7 @@ static int process_entry(struct merge_options *opt,
                               conf, path, other_branch, path, new_path);
                        if (update_file(opt, 0, contents, new_path))
                                clean_merge = -1;
-                       else if (opt->call_depth)
+                       else if (opt->priv->call_depth)
                                remove_file_from_index(opt->repo->index, path);
                        free(new_path);
                } else {
@@ -3439,37 +3462,32 @@ static int process_entry(struct merge_options *opt,
        return clean_merge;
 }
 
-int merge_trees(struct merge_options *opt,
-               struct tree *head,
-               struct tree *merge,
-               struct tree *common,
-               struct tree **result)
+static int merge_trees_internal(struct merge_options *opt,
+                               struct tree *head,
+                               struct tree *merge,
+                               struct tree *merge_base,
+                               struct tree **result)
 {
        struct index_state *istate = opt->repo->index;
        int code, clean;
-       struct strbuf sb = STRBUF_INIT;
-
-       if (!opt->call_depth && repo_index_has_changes(opt->repo, head, &sb)) {
-               err(opt, _("Your local changes to the following files would be overwritten by merge:\n  %s"),
-                   sb.buf);
-               return -1;
-       }
 
        if (opt->subtree_shift) {
-               merge = shift_tree_object(opt->repo, head, merge, opt->subtree_shift);
-               common = shift_tree_object(opt->repo, head, common, opt->subtree_shift);
+               merge = shift_tree_object(opt->repo, head, merge,
+                                         opt->subtree_shift);
+               merge_base = shift_tree_object(opt->repo, head, merge_base,
+                                              opt->subtree_shift);
        }
 
-       if (oid_eq(&common->object.oid, &merge->object.oid)) {
+       if (oid_eq(&merge_base->object.oid, &merge->object.oid)) {
                output(opt, 0, _("Already up to date!"));
                *result = head;
                return 1;
        }
 
-       code = unpack_trees_start(opt, common, head, merge);
+       code = unpack_trees_start(opt, merge_base, head, merge);
 
        if (code != 0) {
-               if (show(opt, 4) || opt->call_depth)
+               if (show(opt, 4) || opt->priv->call_depth)
                        err(opt, _("merging of trees %s and %s failed"),
                            oid_to_hex(&head->object.oid),
                            oid_to_hex(&merge->object.oid));
@@ -3488,12 +3506,13 @@ int merge_trees(struct merge_options *opt,
                 * opposed to decaring a local hashmap is for convenience
                 * so that we don't have to pass it to around.
                 */
-               hashmap_init(&opt->current_file_dir_set, path_hashmap_cmp, NULL, 512);
+               hashmap_init(&opt->priv->current_file_dir_set, path_hashmap_cmp,
+                            NULL, 512);
                get_files_dirs(opt, head);
                get_files_dirs(opt, merge);
 
                entries = get_unmerged(opt->repo->index);
-               clean = detect_and_process_renames(opt, common, head, merge,
+               clean = detect_and_process_renames(opt, merge_base, head, merge,
                                                   entries, &re_info);
                record_df_conflict_files(opt, entries);
                if (clean < 0)
@@ -3524,7 +3543,8 @@ int merge_trees(struct merge_options *opt,
                string_list_clear(entries, 1);
                free(entries);
 
-               hashmap_free(&opt->current_file_dir_set, 1);
+               hashmap_free_entries(&opt->priv->current_file_dir_set,
+                                       struct path_hashmap_entry, e);
 
                if (clean < 0) {
                        unpack_trees_finish(opt);
@@ -3536,7 +3556,8 @@ int merge_trees(struct merge_options *opt,
 
        unpack_trees_finish(opt);
 
-       if (opt->call_depth && !(*result = write_tree_from_memory(opt)))
+       if (opt->priv->call_depth &&
+           !(*result = write_in_core_index_as_tree(opt->repo)))
                return -1;
 
        return clean;
@@ -3557,16 +3578,18 @@ static struct commit_list *reverse_commit_list(struct commit_list *list)
  * Merge the commits h1 and h2, return the resulting virtual
  * commit object and a flag indicating the cleanness of the merge.
  */
-int merge_recursive(struct merge_options *opt,
-                   struct commit *h1,
-                   struct commit *h2,
-                   struct commit_list *ca,
-                   struct commit **result)
+static int merge_recursive_internal(struct merge_options *opt,
+                                   struct commit *h1,
+                                   struct commit *h2,
+                                   struct commit_list *merge_bases,
+                                   struct commit **result)
 {
        struct commit_list *iter;
-       struct commit *merged_common_ancestors;
-       struct tree *mrtree;
+       struct commit *merged_merge_bases;
+       struct tree *result_tree;
        int clean;
+       const char *ancestor_name;
+       struct strbuf merge_base_abbrev = STRBUF_INIT;
 
        if (show(opt, 4)) {
                output(opt, 4, _("Merging:"));
@@ -3574,32 +3597,43 @@ int merge_recursive(struct merge_options *opt,
                output_commit_title(opt, h2);
        }
 
-       if (!ca) {
-               ca = get_merge_bases(h1, h2);
-               ca = reverse_commit_list(ca);
+       if (!merge_bases) {
+               merge_bases = get_merge_bases(h1, h2);
+               merge_bases = reverse_commit_list(merge_bases);
        }
 
        if (show(opt, 5)) {
-               unsigned cnt = commit_list_count(ca);
+               unsigned cnt = commit_list_count(merge_bases);
 
                output(opt, 5, Q_("found %u common ancestor:",
                                "found %u common ancestors:", cnt), cnt);
-               for (iter = ca; iter; iter = iter->next)
+               for (iter = merge_bases; iter; iter = iter->next)
                        output_commit_title(opt, iter->item);
        }
 
-       merged_common_ancestors = pop_commit(&ca);
-       if (merged_common_ancestors == NULL) {
+       merged_merge_bases = pop_commit(&merge_bases);
+       if (merged_merge_bases == NULL) {
                /* if there is no common ancestor, use an empty tree */
                struct tree *tree;
 
                tree = lookup_tree(opt->repo, opt->repo->hash_algo->empty_tree);
-               merged_common_ancestors = make_virtual_commit(opt->repo, tree, "ancestor");
+               merged_merge_bases = make_virtual_commit(opt->repo, tree,
+                                                        "ancestor");
+               ancestor_name = "empty tree";
+       } else if (opt->ancestor && !opt->priv->call_depth) {
+               ancestor_name = opt->ancestor;
+       } else if (merge_bases) {
+               ancestor_name = "merged common ancestors";
+       } else {
+               strbuf_add_unique_abbrev(&merge_base_abbrev,
+                                        &merged_merge_bases->object.oid,
+                                        DEFAULT_ABBREV);
+               ancestor_name = merge_base_abbrev.buf;
        }
 
-       for (iter = ca; iter; iter = iter->next) {
+       for (iter = merge_bases; iter; iter = iter->next) {
                const char *saved_b1, *saved_b2;
-               opt->call_depth++;
+               opt->priv->call_depth++;
                /*
                 * When the merge fails, the result contains files
                 * with conflict markers. The cleanness flag is
@@ -3613,45 +3647,134 @@ int merge_recursive(struct merge_options *opt,
                saved_b2 = opt->branch2;
                opt->branch1 = "Temporary merge branch 1";
                opt->branch2 = "Temporary merge branch 2";
-               if (merge_recursive(opt, merged_common_ancestors, iter->item,
-                                   NULL, &merged_common_ancestors) < 0)
+               if (merge_recursive_internal(opt, merged_merge_bases, iter->item,
+                                            NULL, &merged_merge_bases) < 0)
                        return -1;
                opt->branch1 = saved_b1;
                opt->branch2 = saved_b2;
-               opt->call_depth--;
+               opt->priv->call_depth--;
 
-               if (!merged_common_ancestors)
+               if (!merged_merge_bases)
                        return err(opt, _("merge returned no commit"));
        }
 
        discard_index(opt->repo->index);
-       if (!opt->call_depth)
+       if (!opt->priv->call_depth)
                repo_read_index(opt->repo);
 
-       opt->ancestor = "merged common ancestors";
-       clean = merge_trees(opt, get_commit_tree(h1), get_commit_tree(h2),
-                           get_commit_tree(merged_common_ancestors),
-                           &mrtree);
+       opt->ancestor = ancestor_name;
+       clean = merge_trees_internal(opt,
+                                    repo_get_commit_tree(opt->repo, h1),
+                                    repo_get_commit_tree(opt->repo, h2),
+                                    repo_get_commit_tree(opt->repo,
+                                                         merged_merge_bases),
+                                    &result_tree);
+       strbuf_release(&merge_base_abbrev);
+       opt->ancestor = NULL;  /* avoid accidental re-use of opt->ancestor */
        if (clean < 0) {
                flush_output(opt);
                return clean;
        }
 
-       if (opt->call_depth) {
-               *result = make_virtual_commit(opt->repo, mrtree, "merged tree");
+       if (opt->priv->call_depth) {
+               *result = make_virtual_commit(opt->repo, result_tree,
+                                             "merged tree");
                commit_list_insert(h1, &(*result)->parents);
                commit_list_insert(h2, &(*result)->parents->next);
        }
+       return clean;
+}
+
+static int merge_start(struct merge_options *opt, struct tree *head)
+{
+       struct strbuf sb = STRBUF_INIT;
+
+       /* Sanity checks on opt */
+       assert(opt->repo);
+
+       assert(opt->branch1 && opt->branch2);
+
+       assert(opt->detect_renames >= -1 &&
+              opt->detect_renames <= DIFF_DETECT_COPY);
+       assert(opt->detect_directory_renames >= MERGE_DIRECTORY_RENAMES_NONE &&
+              opt->detect_directory_renames <= MERGE_DIRECTORY_RENAMES_TRUE);
+       assert(opt->rename_limit >= -1);
+       assert(opt->rename_score >= 0 && opt->rename_score <= MAX_SCORE);
+       assert(opt->show_rename_progress >= 0 && opt->show_rename_progress <= 1);
+
+       assert(opt->xdl_opts >= 0);
+       assert(opt->recursive_variant >= MERGE_VARIANT_NORMAL &&
+              opt->recursive_variant <= MERGE_VARIANT_THEIRS);
+
+       assert(opt->verbosity >= 0 && opt->verbosity <= 5);
+       assert(opt->buffer_output <= 2);
+       assert(opt->obuf.len == 0);
+
+       assert(opt->priv == NULL);
+
+       /* Sanity check on repo state; index must match head */
+       if (repo_index_has_changes(opt->repo, head, &sb)) {
+               err(opt, _("Your local changes to the following files would be overwritten by merge:\n  %s"),
+                   sb.buf);
+               strbuf_release(&sb);
+               return -1;
+       }
+
+       opt->priv = xcalloc(1, sizeof(*opt->priv));
+       string_list_init(&opt->priv->df_conflict_file_set, 1);
+       return 0;
+}
+
+static void merge_finalize(struct merge_options *opt)
+{
        flush_output(opt);
-       if (!opt->call_depth && opt->buffer_output < 2)
+       if (!opt->priv->call_depth && opt->buffer_output < 2)
                strbuf_release(&opt->obuf);
        if (show(opt, 2))
                diff_warn_rename_limit("merge.renamelimit",
-                                      opt->needed_rename_limit, 0);
+                                      opt->priv->needed_rename_limit, 0);
+       FREE_AND_NULL(opt->priv);
+}
+
+int merge_trees(struct merge_options *opt,
+               struct tree *head,
+               struct tree *merge,
+               struct tree *merge_base)
+{
+       int clean;
+       struct tree *ignored;
+
+       assert(opt->ancestor != NULL);
+
+       if (merge_start(opt, head))
+               return -1;
+       clean = merge_trees_internal(opt, head, merge, merge_base, &ignored);
+       merge_finalize(opt);
+
        return clean;
 }
 
-static struct commit *get_ref(struct repository *repo, const struct object_id *oid,
+int merge_recursive(struct merge_options *opt,
+                   struct commit *h1,
+                   struct commit *h2,
+                   struct commit_list *merge_bases,
+                   struct commit **result)
+{
+       int clean;
+
+       assert(opt->ancestor == NULL ||
+              !strcmp(opt->ancestor, "constructed merge base"));
+
+       if (merge_start(opt, repo_get_commit_tree(opt->repo, h1)))
+               return -1;
+       clean = merge_recursive_internal(opt, h1, h2, merge_bases, result);
+       merge_finalize(opt);
+
+       return clean;
+}
+
+static struct commit *get_ref(struct repository *repo,
+                             const struct object_id *oid,
                              const char *name)
 {
        struct object *object;
@@ -3672,8 +3795,8 @@ static struct commit *get_ref(struct repository *repo, const struct object_id *o
 int merge_recursive_generic(struct merge_options *opt,
                            const struct object_id *head,
                            const struct object_id *merge,
-                           int num_base_list,
-                           const struct object_id **base_list,
+                           int num_merge_bases,
+                           const struct object_id **merge_bases,
                            struct commit **result)
 {
        int clean;
@@ -3682,15 +3805,18 @@ int merge_recursive_generic(struct merge_options *opt,
        struct commit *next_commit = get_ref(opt->repo, merge, opt->branch2);
        struct commit_list *ca = NULL;
 
-       if (base_list) {
+       if (merge_bases) {
                int i;
-               for (i = 0; i < num_base_list; ++i) {
+               for (i = 0; i < num_merge_bases; ++i) {
                        struct commit *base;
-                       if (!(base = get_ref(opt->repo, base_list[i], oid_to_hex(base_list[i]))))
+                       if (!(base = get_ref(opt->repo, merge_bases[i],
+                                            oid_to_hex(merge_bases[i]))))
                                return err(opt, _("Could not parse object '%s'"),
-                                          oid_to_hex(base_list[i]));
+                                          oid_to_hex(merge_bases[i]));
                        commit_list_insert(base, &ca);
                }
+               if (num_merge_bases == 1)
+                       opt->ancestor = "constructed merge base";
        }
 
        repo_hold_locked_index(opt->repo, &lock, LOCK_DIE_ON_ERROR);
@@ -3712,22 +3838,25 @@ static void merge_recursive_config(struct merge_options *opt)
 {
        char *value = NULL;
        git_config_get_int("merge.verbosity", &opt->verbosity);
-       git_config_get_int("diff.renamelimit", &opt->diff_rename_limit);
-       git_config_get_int("merge.renamelimit", &opt->merge_rename_limit);
+       git_config_get_int("diff.renamelimit", &opt->rename_limit);
+       git_config_get_int("merge.renamelimit", &opt->rename_limit);
        if (!git_config_get_string("diff.renames", &value)) {
-               opt->diff_detect_rename = git_config_rename("diff.renames", value);
+               opt->detect_renames = git_config_rename("diff.renames", value);
                free(value);
        }
        if (!git_config_get_string("merge.renames", &value)) {
-               opt->merge_detect_rename = git_config_rename("merge.renames", value);
+               opt->detect_renames = git_config_rename("merge.renames", value);
                free(value);
        }
        if (!git_config_get_string("merge.directoryrenames", &value)) {
                int boolval = git_parse_maybe_bool(value);
                if (0 <= boolval) {
-                       opt->detect_directory_renames = boolval ? 2 : 0;
+                       opt->detect_directory_renames = boolval ?
+                               MERGE_DIRECTORY_RENAMES_TRUE :
+                               MERGE_DIRECTORY_RENAMES_NONE;
                } else if (!strcasecmp(value, "conflict")) {
-                       opt->detect_directory_renames = 1;
+                       opt->detect_directory_renames =
+                               MERGE_DIRECTORY_RENAMES_CONFLICT;
                } /* avoid erroring on values from future versions of git */
                free(value);
        }
@@ -3739,23 +3868,25 @@ void init_merge_options(struct merge_options *opt,
 {
        const char *merge_verbosity;
        memset(opt, 0, sizeof(struct merge_options));
+
        opt->repo = repo;
+
+       opt->detect_renames = -1;
+       opt->detect_directory_renames = MERGE_DIRECTORY_RENAMES_CONFLICT;
+       opt->rename_limit = -1;
+
        opt->verbosity = 2;
        opt->buffer_output = 1;
-       opt->diff_rename_limit = -1;
-       opt->merge_rename_limit = -1;
+       strbuf_init(&opt->obuf, 0);
+
        opt->renormalize = 0;
-       opt->diff_detect_rename = -1;
-       opt->merge_detect_rename = -1;
-       opt->detect_directory_renames = 1;
+
        merge_recursive_config(opt);
        merge_verbosity = getenv("GIT_MERGE_VERBOSITY");
        if (merge_verbosity)
                opt->verbosity = strtol(merge_verbosity, NULL, 10);
        if (opt->verbosity >= 5)
                opt->buffer_output = 0;
-       strbuf_init(&opt->obuf, 0);
-       string_list_init(&opt->df_conflict_file_set, 1);
 }
 
 int parse_merge_opt(struct merge_options *opt, const char *s)
@@ -3765,9 +3896,9 @@ int parse_merge_opt(struct merge_options *opt, const char *s)
        if (!s || !*s)
                return -1;
        if (!strcmp(s, "ours"))
-               opt->recursive_variant = MERGE_RECURSIVE_OURS;
+               opt->recursive_variant = MERGE_VARIANT_OURS;
        else if (!strcmp(s, "theirs"))
-               opt->recursive_variant = MERGE_RECURSIVE_THEIRS;
+               opt->recursive_variant = MERGE_VARIANT_THEIRS;
        else if (!strcmp(s, "subtree"))
                opt->subtree_shift = "";
        else if (skip_prefix(s, "subtree=", &arg))
@@ -3798,16 +3929,16 @@ int parse_merge_opt(struct merge_options *opt, const char *s)
        else if (!strcmp(s, "no-renormalize"))
                opt->renormalize = 0;
        else if (!strcmp(s, "no-renames"))
-               opt->merge_detect_rename = 0;
+               opt->detect_renames = 0;
        else if (!strcmp(s, "find-renames")) {
-               opt->merge_detect_rename = 1;
+               opt->detect_renames = 1;
                opt->rename_score = 0;
        }
        else if (skip_prefix(s, "find-renames=", &arg) ||
                 skip_prefix(s, "rename-threshold=", &arg)) {
                if ((opt->rename_score = parse_rename_score(&arg)) == -1 || *arg != 0)
                        return -1;
-               opt->merge_detect_rename = 1;
+               opt->detect_renames = 1;
        }
        /*
         * Please update $__git_merge_strategy_options in