git
/
diffcore-rename.c
1724 строки · 51.5 Кб
1/*2*3* Copyright (C) 2005 Junio C Hamano4*/5/* Table of rename/copy destinations */22/* Mapping from break source pathname to break destination index */30static struct strintmap *break_idx = NULL;31{34/* Lookup by p->ONE->path */35int idx = break_idx ? strintmap_get(break_idx, p->one->path) : -1;36return (idx == -1) ? NULL : &rename_dst[idx];37}38/*40* Returns 0 on success, -1 if we found a duplicate.41*/42static int add_rename_dst(struct diff_filepair *p)43{44ALLOC_GROW(rename_dst, rename_dst_nr + 1, rename_dst_alloc);45rename_dst[rename_dst_nr].p = p;46rename_dst[rename_dst_nr].filespec_to_free = NULL;47rename_dst[rename_dst_nr].is_rename = 0;48rename_dst_nr++;49return 0;50}51/* Table of rename/copy src files */53static struct diff_rename_src {54struct diff_filepair *p;55unsigned short score; /* to remember the break score */56} *rename_src;57static int rename_src_nr, rename_src_alloc;58{61if (p->broken_pair) {62if (!break_idx) {63break_idx = xmalloc(sizeof(*break_idx));64strintmap_init_with_options(break_idx, -1, NULL, 0);65}66strintmap_set(break_idx, p->one->path, rename_dst_nr);67}68}74{77int src_len = strlen(src->path), dst_len = strlen(dst->path);78while (src_len && dst_len) {79char c1 = src->path[--src_len];80char c2 = dst->path[--dst_len];81if (c1 != c2)82return 0;83if (c1 == '/')84return 1;85}86return (!src_len || src->path[src_len - 1] == '/') &&87(!dst_len || dst->path[dst_len - 1] == '/');88}89{103struct inexact_prefetch_options *options = prefetch_options;104int i;105struct oid_array to_fetch = OID_ARRAY_INIT;106* The loop in diffcore_rename() will not need these111* blobs, so skip prefetching.112*/113continue; /* already found exact match */114diff_add_if_missing(options->repo, &to_fetch,115rename_dst[i].p->two);116}117for (i = 0; i < rename_src_nr; i++) {118if (options->skip_unmodified &&119diff_unmodified_pair(rename_src[i].p))120/*121* The loop in diffcore_rename() will not need these122* blobs, so skip prefetching.123*/124continue;125diff_add_if_missing(options->repo, &to_fetch,126rename_src[i].p->one);127}128promisor_remote_get_direct(options->repo, to_fetch.oid, to_fetch.nr);129oid_array_clear(&to_fetch);130}131{138/* src points at a file that existed in the original tree (or139* optionally a file in the destination tree) and dst points140* at a newly created file. They may be quite similar, in which141* case we want to say src is renamed to dst or src is copied into142* dst, and then some edit has been applied to dst.143*144* Compare them and return how similar they are, representing145* the score as an integer between 0 and MAX_SCORE.146*147* When there is an exact match, it is considered a better148* match than anything else; the destination does not even149* call into this function in that case.150*/151unsigned long max_size, delta_size, base_size, src_copied, literal_added;152int score;153* only when they are exact matches --- in other words, no edits156* after renaming.157*/158if (!S_ISREG(src->mode) || !S_ISREG(dst->mode))159return 0;160* Need to check that source and destination sizes are163* filled in before comparing them.164*165* If we already have "cnt_data" filled in, we know it's166* all good (avoid checking the size for zero, as that167* is a possible size - we really should have a flag to168* say whether the size is valid or not!)169*/170dpf_opt->check_size_only = 1;171* drastically. delta_size must be smaller than185* (MAX_SCORE-minimum_score)/MAX_SCORE * min(src->size, dst->size).186*187* Note that base_size == 0 case is handled here already188* and the final score computation below would not have a189* divide-by-zero issue.190*/191if (max_size * (MAX_SCORE-minimum_score) < delta_size * MAX_SCORE)192return 0;193* what percentage of material in dst are from source?208*/209if (!dst->size)210score = 0; /* should not happen */211else212score = (int)(src_copied * MAX_SCORE / max_size);213return score;214}215{218struct diff_filepair *src = rename_src[src_index].p;219struct diff_filepair *dst = rename_dst[dst_index].p;220}237/*239* We sort the rename similarity matrix with the score, in descending240* order (the most similar first).241*/242static int score_compare(const void *a_, const void *b_)243{244const struct diff_score *a = a_, *b = b_;245}257{267if (!filespec->oid_valid) {268if (diff_populate_filespec(r, filespec, NULL))269return 0;270hash_object_file(r->hash_algo, filespec->data, filespec->size,271OBJ_BLOB, &filespec->oid);272}273return oidhash(&filespec->oid);274}275{280int renames = 0;281struct diff_filespec *target = rename_dst[dst_index].p->two;282struct file_similarity *p, *best = NULL;283int i = 100, best_score = -1;284unsigned int hash = hash_filespec(options->repo, target);285* Find the best source match for specified destination.288*/289p = hashmap_get_entry_from_hash(srcs, hash, NULL,290struct file_similarity, entry);291hashmap_for_each_entry_from(srcs, p, entry) {292int score;293struct diff_filespec *source = p->filespec;294}325{331struct file_similarity *entry = mem_pool_alloc(pool, sizeof(*entry));332}339/*341* Find exact renames first.342*343* The first round matches up the up-to-date entries,344* and then during the second round we try to match345* cache-dirty entries as well.346*/347static int find_exact_renames(struct diff_options *options,348struct mem_pool *pool)349{350int i, renames = 0;351struct hashmap file_table;352* later on they will be retrieved in LIFO order.355*/356hashmap_init(&file_table, NULL, NULL, rename_src_nr);357for (i = rename_src_nr-1; i >= 0; i--)358insert_file_table(options->repo, pool,359&file_table, i,360rename_src[i].p->one);361}371{382char *slash = strrchr(filename, '/');383return slash ? xstrndup(filename, slash - filename) : xstrdup("");384}385{388char *slash = strrchr(filename, '/');389if (!slash)390slash = filename;391*slash = '\0';392}393{396int highest_count = 0;397const char *highest_destination_dir = NULL;398struct hashmap_iter iter;399struct strmap_entry *entry;400}411{416struct hashmap_iter iter;417struct strmap_entry *entry;418int first = 0, second = 0, unknown = 0;419strintmap_for_each_entry(counts, &iter, entry) {420const char *destination_dir = entry->key;421intptr_t count = (intptr_t)entry->value;422if (!strcmp(destination_dir, UNKNOWN_DIR)) {423unknown = count;424} else if (count >= first) {425second = first;426first = count;427} else if (count >= second) {428second = count;429}430}431return first > second + unknown;432}433{438struct strintmap *counts;439struct strmap_entry *e;440}454{460char *old_dir;461char *new_dir;462const char new_dir_first_char = newname[0];463int first_time_in_loop = 1;464* info->setup is 0 here in two cases: (1) all auxiliary468* vars (like dirs_removed) were NULL so469* initialize_dir_rename_info() returned early, or (2)470* either break detection or copy detection are active so471* that we never called initialize_dir_rename_info(). In472* the former case, we don't have enough info to know if473* directories were renamed (because dirs_removed lets us474* know about a necessary prerequisite, namely if they were475* removed), and in the latter, we don't care about476* directory renames or find_basename_matches.477*478* This matters because both basename and inexact matching479* will also call update_dir_rename_counts(). In either of480* the above two cases info->dir_rename_counts will not481* have been properly initialized which prevents us from482* updating it, but in these two cases we don't care about483* dir_rename_counts anyway, so we can just exit early.484*/485return;486* When renaming505* "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"506* then this suggests that both507* a/b/c/d/e/ => a/b/some/thing/else/e/508* a/b/c/d/ => a/b/some/thing/else/509* so we want to increment counters for both. We do NOT,510* however, also want to suggest that there was the following511* rename:512* a/b/c/ => a/b/some/thing/513* so we need to quit at that point.514*515* Note the when first_time_in_loop, we only strip off the516* basename, and we don't care if that's different.517*/518if (!first_time_in_loop) {519char *old_sub_dir = strchr(old_dir, '\0')+1;520char *new_sub_dir = strchr(new_dir, '\0')+1;521if (!*new_dir) {522/*523* Special case when renaming to root directory,524* i.e. when new_dir == "". In this case, we had525* something like526* a/b/subdir => subdir527* and so dirname_munge() sets things up so that528* old_dir = "a/b\0subdir\0"529* new_dir = "\0ubdir\0"530* We didn't have a '/' to overwrite a '\0' onto531* in new_dir, so we have to compare differently.532*/533if (new_dir_first_char != old_sub_dir[0] ||534strcmp(old_sub_dir+1, new_sub_dir))535break;536} else {537if (strcmp(old_sub_dir, new_sub_dir))538break;539}540}541* Above we suggested that we'd keep recording renames for544* all ancestor directories where the trailing directories545* matched, i.e. for546* "a/b/c/d/e/foo.c" -> "a/b/some/thing/else/e/foo.c"547* we'd increment rename counts for each of548* a/b/c/d/e/ => a/b/some/thing/else/e/549* a/b/c/d/ => a/b/some/thing/else/550* However, we only need the rename counts for directories551* in dirs_removed whose value is RELEVANT_FOR_SELF.552* However, we add one special case of also recording it for553* first_time_in_loop because find_basename_matches() can554* use that as a hint to find a good pairing.555*/556if (dirs_removed)557drd_flag = strintmap_get(dirs_removed, old_dir);558if (drd_flag == RELEVANT_FOR_SELF || first_time_in_loop)559increment_count(info, old_dir, new_dir);560}573{580struct hashmap_iter iter;581struct strmap_entry *entry;582int i;583* Loop setting up both info->idx_map, and doing setup of617* info->dir_rename_count.618*/619for (i = 0; i < rename_dst_nr; ++i) {620/*621* For non-renamed files, make idx_map contain mapping of622* filename -> index (index within rename_dst, that is)623*/624if (!rename_dst[i].is_rename) {625char *filename = rename_dst[i].p->two->path;626strintmap_set(&info->idx_map, filename, i);627continue;628}629* For everything else (i.e. renamed files), make632* dir_rename_count contain a map of a map:633* old_directory -> {new_directory -> count}634* In other words, for every pair look at the directories for635* the old filename and the new filename and count how many636* times that pairing occurs.637*/638update_dir_rename_counts(info, dirs_removed,639rename_dst[i].p->one->path,640rename_dst[i].p->two->path);641}642* Now we collapse656* dir_rename_count: old_directory -> {new_directory -> count}657* down to658* dir_rename_guess: old_directory -> best_new_directory659* where best_new_directory is the one with the highest count.660*/661strmap_for_each_entry(info->dir_rename_count, &iter, entry) {662/* entry->key is source_dir */663struct strintmap *counts = entry->value;664char *best_newdir;665}671{674struct hashmap_iter iter;675struct strmap_entry *entry;676}683{688struct hashmap_iter iter;689struct strmap_entry *entry;690struct string_list to_remove = STRING_LIST_INIT_NODUP;691int i;692* Although dir_rename_count was passed in719* diffcore_rename_extended() and we want to keep it around and720* return it to that caller, we first want to remove any counts in721* the maps associated with UNKNOWN_DIR entries and any data722* associated with directories that weren't renamed.723*/724strmap_for_each_entry(info->dir_rename_count, &iter, entry) {725const char *source_dir = entry->key;726struct strintmap *counts = entry->value;727}742{745/*746* gitbasename() has to worry about special drives, multiple747* directory separator characters, trailing slashes, NULL or748* empty strings, etc. We only work on filenames as stored in749* git, and thus get to ignore all those complications.750*/751const char *base = strrchr(filename, '/');752return base ? base + 1 : filename;753}754{757/*758* Our comparison of files with the same basename (see759* find_basename_matches() below), is only helpful when after exact760* rename detection we have exactly one file with a given basename761* among the rename sources and also only exactly one file with762* that basename among the rename destinations. When we have763* multiple files with the same basename in either set, we do not764* know which to compare against. However, there are some765* filenames that occur in large numbers (particularly766* build-related filenames such as 'Makefile', '.gitignore', or767* 'build.gradle' that potentially exist within every single768* subdirectory), and for performance we want to be able to quickly769* find renames for these files too.770*771* The reason basename comparisons are a useful heuristic was that it772* is common for people to move files across directories while keeping773* their filename the same. If we had a way of determining or even774* making a good educated guess about which directory these non-unique775* basename files had moved the file to, we could check it.776* Luckily...777*778* When an entire directory is in fact renamed, we have two factors779* helping us out:780* (a) the original directory disappeared giving us a hint781* about when we can apply an extra heuristic.782* (a) we often have several files within that directory and783* subdirectories that are renamed without changes784* So, rules for a heuristic:785* (0) If there basename matches are non-unique (the condition under786* which this function is called) AND787* (1) the directory in which the file was found has disappeared788* (i.e. dirs_removed is non-NULL and has a relevant entry) THEN789* (2) use exact renames of files within the directory to determine790* where the directory is likely to have been renamed to. IF791* there is at least one exact rename from within that792* directory, we can proceed.793* (3) If there are multiple places the directory could have been794* renamed to based on exact renames, ignore all but one of them.795* Just use the destination with the most renames going to it.796* (4) Check if applying that directory rename to the original file797* would result in a destination filename that is in the798* potential rename set. If so, return the index of the799* destination file (the index within rename_dst).800* (5) Compare the original file and returned destination for801* similarity, and if they are sufficiently similar, record the802* rename.803*804* This function, idx_possible_rename(), is only responsible for (4).805* The conditions/steps in (1)-(3) are handled via setting up806* dir_rename_count and dir_rename_guess in807* initialize_dir_rename_info(). Steps (0) and (5) are handled by808* the caller of this function.809*/810char *old_dir, *new_dir;811struct strbuf new_path = STRBUF_INIT;812int idx;813}831{841struct basename_prefetch_options *options = prefetch_options;842struct strintmap *relevant_sources = options->relevant_sources;843struct strintmap *sources = options->sources;844struct strintmap *dests = options->dests;845struct dir_rename_info *info = options->info;846int i;847struct oid_array to_fetch = OID_ARRAY_INIT;848* TODO: The following loops mirror the code/logic from851* find_basename_matches(), though not quite exactly. Maybe852* abstract the iteration logic out somehow?853*/854for (i = 0; i < rename_src_nr; ++i) {855char *filename = rename_src[i].p->one->path;856const char *base = NULL;857intptr_t src_index;858intptr_t dst_index;859* If the basename is unique among remaining sources, then867* src_index will equal 'i' and we can attempt to match it868* to a unique basename in the destinations. Otherwise,869* use directory rename heuristics, if possible.870*/871base = get_basename(filename);872src_index = strintmap_get(sources, base);873assert(src_index == -1 || src_index == i);874}903{910/*911* When I checked in early 2020, over 76% of file renames in linux912* just moved files to a different directory but kept the same913* basename. gcc did that with over 64% of renames, gecko did it914* with over 79%, and WebKit did it with over 89%.915*916* Therefore we can bypass the normal exhaustive NxM matrix917* comparison of similarities between all potential rename sources918* and destinations by instead using file basename as a hint (i.e.919* the portion of the filename after the last '/'), checking for920* similarity between files with the same basename, and if we find921* a pair that are sufficiently similar, record the rename pair and922* exclude those two from the NxM matrix.923*924* This *might* cause us to find a less than optimal pairing (if925* there is another file that we are even more similar to but has a926* different basename). Given the huge performance advantage927* basename matching provides, and given the frequency with which928* people use the same basename in real world projects, that's a929* trade-off we are willing to accept when doing just rename930* detection.931*932* If someone wants copy detection that implies they are willing to933* spend more cycles to find similarities between files, so it may934* be less likely that this heuristic is wanted. If someone is935* doing break detection, that means they do not want filename936* similarity to imply any form of content similiarity, and thus937* this heuristic would definitely be incompatible.938*/939* Create maps of basename -> fullname(s) for remaining sources and958* dests.959*/960strintmap_init_with_options(&sources, -1, NULL, 0);961strintmap_init_with_options(&dests, -1, NULL, 0);962for (i = 0; i < rename_src_nr; ++i) {963char *filename = rename_src[i].p->one->path;964const char *base;965* If the basename is unique among remaining sources, then1010* src_index will equal 'i' and we can attempt to match it1011* to a unique basename in the destinations. Otherwise,1012* use directory rename heuristics, if possible.1013*/1014base = get_basename(filename);1015src_index = strintmap_get(&sources, base);1016assert(src_index == -1 || src_index == i);1017* Found a rename so don't need text anymore; if we1051* didn't find a rename, the filespec_blob would get1052* re-used when doing the matrix of comparisons.1053*/1054diff_free_filespec_blob(one);1055diff_free_filespec_blob(two);1056}1057}1058}1064{1068int i, worst;1069}1080/*1082* Returns:1083* 0 if we are under the limit;1084* 1 if we need to disable inexact rename detection;1085* 2 if we would be under the limit if we were given -C instead of -C -C.1086*/1087static int too_many_rename_candidates(int num_destinations, int num_sources,1088struct diff_options *options)1089{1090int rename_limit = options->rename_limit;1091int i, limited_sources;1092* This basically does a test for the rename matrix not1097* growing larger than a "rename_limit" square matrix, ie:1098*1099* num_destinations * num_sources > rename_limit * rename_limit1100*1101* We use st_mult() to check overflow conditions; in the1102* exceptional circumstance that size_t isn't large enough to hold1103* the multiplication, the system won't be able to allocate enough1104* memory for the matrix anyway.1105*/1106if (rename_limit <= 0)1107return 0; /* treat as unlimited */1108if (st_mult(num_destinations, num_sources)1109<= st_mult(rename_limit, rename_limit))1110return 0;1111}1130{1138int count = 0, i;1139}1159{1163int i, new_num_src;1164* Note on reasons why we cull unneeded sources but not destinations:1172* 1) Pairings are stored in rename_dst (not rename_src), which we1173* need to keep around. So, we just can't cull rename_dst even1174* if we wanted to. But doing so wouldn't help because...1175*1176* 2) There is a matrix pairwise comparison that follows the1177* "Performing inexact rename detection" progress message.1178* Iterating over the destinations is done in the outer loop,1179* hence we only iterate over each of those once and we can1180* easily skip the outer loop early if the destination isn't1181* relevant. That's only one check per destination path to1182* skip.1183*1184* By contrast, the sources are iterated in the inner loop; if1185* we check whether a source can be skipped, then we'll be1186* checking it N separate times, once for each destination.1187* We don't want to have to iterate over known-not-needed1188* sources N times each, so avoid that by removing the sources1189* from rename_src here.1190*/1191for (i = 0, new_num_src = 0; i < rename_src_nr; i++) {1192struct diff_filespec *one = rename_src[i].p->one;1193* renames are stored in rename_dst, so if a rename has1196* already been detected using this source, we can just1197* remove the source knowing rename_dst has its info.1198*/1199if (!detecting_copies && one->rename_used)1200continue;1201}1214{1219/*1220* Directory renames are determined via an aggregate of all renames1221* under them and using a "majority wins" rule. The fact that1222* "majority wins", though, means we don't need all the renames1223* under the given directory, we only need enough to ensure we have1224* a majority.1225*/1226* Supplement dir_rename_count with number of potential renames,1238* marking all potential rename sources as mapping to UNKNOWN_DIR.1239*/1240for (i = 0; i < rename_src_nr; i++) {1241char *old_dir;1242struct diff_filespec *one = rename_src[i].p->one;1243* sources that are part of a rename will have already been1246* removed by a prior call to remove_unneeded_paths_from_src()1247*/1248assert(!one->rename_used);1249* old_dir and new_dir free'd in increment_count, but1263* get_dirname() gives us a new pointer we need to free for1264* old_dir. Also, if the loop runs 0 times we need old_dir1265* to be freed.1266*/1267free(old_dir);1268}1269* For any directory which we need a potential rename detected for1272* (i.e. those marked as RELEVANT_FOR_SELF in dirs_removed), check1273* whether we have enough renames to satisfy the "majority rules"1274* requirement such that detecting any more renames of files under1275* it won't change the result. For any such directory, mark that1276* we no longer need to detect a rename for it. However, since we1277* might need to still detect renames for an ancestor of that1278* directory, use RELEVANT_FOR_ANCESTOR.1279*/1280strmap_for_each_entry(info->dir_rename_count, &iter, entry) {1281/* entry->key is source_dir */1282struct strintmap *counts = entry->value;1283* sources that were not found in relevant_sources should1300* have already been removed by a prior call to1301* remove_unneeded_paths_from_src()1302*/1303assert(val != -1);1304}1341{1344if (!--spec->count)1345diff_free_filespec_data(spec);1346}1347{1351if (!pool) {1352free_filespec(spec);1353return;1354}1355* Similar to free_filespec(), but only frees the data. The spec1358* itself was allocated in the pool and should not be individually1359* freed.1360*/1361free_filespec_data(spec);1362}1363{1367if (!pool) {1368diff_free_filepair(p);1369return;1370}1371* Similar to diff_free_filepair() but only frees the data from the1374* filespecs; not the filespecs or the filepair which were1375* allocated from the pool.1376*/1377free_filespec_data(p->one);1378free_filespec_data(p->two);1379}1380{1388int detect_rename = options->detect_rename;1389int minimum_score = options->rename_score;1390struct diff_queue_struct *q = &diff_queued_diff;1391struct diff_queue_struct outq;1392struct diff_score *mx;1393int i, j, rename_count, skip_unmodified = 0;1394int num_destinations, dst_cnt;1395int num_sources, want_copies;1396struct progress *progress = NULL;1397struct mem_pool local_pool;1398struct dir_rename_info info;1399struct diff_populate_filespec_options dpf_options = {1400.check_binary = 0,1401.missing_object_cb = NULL,1402.missing_object_data = NULL1403};1404struct inexact_prefetch_options prefetch_options = {1405.repo = options->repo1406};1407* If the source is a broken "delete", and1443* they did not really want to get broken,1444* that means the source actually stays.1445* So we increment the "rename_used" score1446* by one, to indicate ourselves as a user1447*/1448if (p->broken_pair && !p->score)1449p->one->rename_used++;1450register_rename_src(p);1451}1452else if (want_copies) {1453/*1454* Increment the "rename_used" score by1455* one, to indicate ourselves as a user.1456*/1457p->one->rename_used++;1458register_rename_src(p);1459}1460}1461trace2_region_leave("diff", "setup", options->repo);1462if (rename_dst_nr == 0 || rename_src_nr == 0)1463goto cleanup; /* nothing to do */1464* We really want to cull the candidates list early1469* with cheap tests in order to avoid doing deltas.1470*/1471rename_count = find_exact_renames(options, &local_pool);1472/*1473* Discard local_pool immediately instead of at "cleanup:" in order1474* to reduce maximum memory usage; inexact rename detection uses up1475* a fair amount of memory, and mem_pools can too.1476*/1477mem_pool_discard(&local_pool, 0);1478trace2_region_leave("diff", "exact renames", options->repo);1479* Cull sources:1489* - remove ones corresponding to exact renames1490* - remove ones not found in relevant_sources1491*/1492trace2_region_enter("diff", "cull after exact", options->repo);1493remove_unneeded_paths_from_src(want_copies, relevant_sources);1494trace2_region_leave("diff", "cull after exact", options->repo);1495} else {1496/* Determine minimum score to match basenames */1497double factor = 0.5;1498char *basename_factor = getenv("GIT_BASENAME_FACTOR");1499int min_basename_score;1500* Cull sources:1509* - remove ones involved in renames (found via exact match)1510*/1511trace2_region_enter("diff", "cull after exact", options->repo);1512remove_unneeded_paths_from_src(want_copies, NULL);1513trace2_region_leave("diff", "cull after exact", options->repo);1514* Cull sources, again:1533* - remove ones involved in renames (found via basenames)1534* - remove ones not found in relevant_sources1535* and1536* - remove ones in relevant_sources which are needed only1537* for directory renames IF no ancestory directory1538* actually needs to know any more individual path1539* renames under them1540*/1541trace2_region_enter("diff", "cull basename", options->repo);1542remove_unneeded_paths_from_src(want_copies, relevant_sources);1543handle_early_known_dir_renames(&info, relevant_sources,1544dirs_removed);1545trace2_region_leave("diff", "cull basename", options->repo);1546}1547* Once we run estimate_similarity,1614* We do not need the text anymore.1615*/1616diff_free_filespec_blob(one);1617diff_free_filespec_blob(two);1618}1619dst_cnt++;1620display_progress(progress,1621(uint64_t)dst_cnt * (uint64_t)num_sources);1622}1623stop_progress(&progress);1624* are recorded in rename_dst. The original list is still in *q.1639*/1640trace2_region_enter("diff", "write back to queue", options->repo);1641DIFF_QUEUE_CLEAR(&outq);1642for (i = 0; i < q->nr; i++) {1643struct diff_filepair *p = q->queue[i];1644struct diff_filepair *pair_to_free = NULL;1645* Deletion1656*1657* We would output this delete record if:1658*1659* (1) this is a broken delete and the counterpart1660* broken create remains in the output; or1661* (2) this is not a broken delete, and rename_dst1662* does not have a rename/copy to move p->one->path1663* out of existence.1664*1665* Otherwise, the counterpart broken create1666* has been turned into a rename-edit; or1667* delete did not have a matching create to1668* begin with.1669*/1670if (DIFF_PAIR_BROKEN(p)) {1671/* broken delete */1672struct diff_rename_dst *dst = locate_rename_dst(p);1673if (!dst)1674BUG("tracking failed somehow; failed to find associated dst for broken pair");1675if (dst->is_rename)1676/* counterpart is now rename/copy */1677pair_to_free = p;1678}1679else {1680if (p->one->rename_used)1681/* this path remains */1682pair_to_free = p;1683}1684}1720{1723diffcore_rename_extended(options, NULL, NULL, NULL, NULL, NULL);1724}1725