static int restore_untracked(struct object_id *u_tree)
{
int res;
struct child_process cp = CHILD_PROCESS_INIT;
/*
* We need to run restore files from a given index, but without
* affecting the current index, so we use GIT_INDEX_FILE with
* run_command to fork processes that will not interfere.
*/
cp.git_cmd = 1;
argv_array_push(&cp.args, "read-tree");
argv_array_push(&cp.args, oid_to_hex(u_tree));
argv_array_pushf(&cp.env_array, "GIT_INDEX_FILE=%s",
stash_index_path.buf);
if (run_command(&cp)) {
remove_path(stash_index_path.buf);
return -1;
}
child_process_init(&cp);
cp.git_cmd = 1;
argv_array_pushl(&cp.args, "checkout-index", "--all", NULL);
argv_array_pushf(&cp.env_array, "GIT_INDEX_FILE=%s",
stash_index_path.buf);
res = run_command(&cp);
remove_path(stash_index_path.buf);
return res;
}
static int stash_patch(struct stash_info *info, struct pathspec ps,
struct strbuf *out_patch, int quiet)
{
int ret = 0;
struct child_process cp_read_tree = CHILD_PROCESS_INIT;
struct child_process cp_add_i = CHILD_PROCESS_INIT;
struct child_process cp_diff_tree = CHILD_PROCESS_INIT;
struct index_state istate = { NULL };
remove_path(stash_index_path.buf);
cp_read_tree.git_cmd = 1;
argv_array_pushl(&cp_read_tree.args, "read-tree", "HEAD", NULL);
argv_array_pushf(&cp_read_tree.env_array, "GIT_INDEX_FILE=%s",
stash_index_path.buf);
if (run_command(&cp_read_tree)) {
ret = -1;
goto done;
}
/* Find out what the user wants. */
cp_add_i.git_cmd = 1;
argv_array_pushl(&cp_add_i.args, "add--interactive", "--patch=stash",
"--", NULL);
add_pathspecs(&cp_add_i.args, ps);
argv_array_pushf(&cp_add_i.env_array, "GIT_INDEX_FILE=%s",
stash_index_path.buf);
if (run_command(&cp_add_i)) {
ret = -1;
goto done;
}
/* State of the working tree. */
if (write_index_as_tree(&info->w_tree, &istate, stash_index_path.buf, 0,
NULL)) {
ret = -1;
goto done;
}
cp_diff_tree.git_cmd = 1;
argv_array_pushl(&cp_diff_tree.args, "diff-tree", "-p", "HEAD",
oid_to_hex(&info->w_tree), "--", NULL);
if (pipe_command(&cp_diff_tree, NULL, 0, out_patch, 0, NULL, 0)) {
ret = -1;
goto done;
}
if (!out_patch->len) {
if (!quiet)
fprintf_ln(stderr, _("No changes selected"));
ret = 1;
}
done:
discard_index(&istate);
remove_path(stash_index_path.buf);
return ret;
}
void delete_path(FILE *fp)
{
filepath_t *this = remove_path(fp);
if (this) {
free_filepath(this);
}
}
static int stash_working_tree(struct stash_info *info, struct pathspec ps)
{
int ret = 0;
struct rev_info rev;
struct child_process cp_upd_index = CHILD_PROCESS_INIT;
struct strbuf diff_output = STRBUF_INIT;
struct index_state istate = { NULL };
init_revisions(&rev, NULL);
set_alternate_index_output(stash_index_path.buf);
if (reset_tree(&info->i_tree, 0, 0)) {
ret = -1;
goto done;
}
set_alternate_index_output(NULL);
rev.prune_data = ps;
rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
rev.diffopt.format_callback = add_diff_to_buf;
rev.diffopt.format_callback_data = &diff_output;
if (read_cache_preload(&rev.diffopt.pathspec) < 0) {
ret = -1;
goto done;
}
add_pending_object(&rev, parse_object(the_repository, &info->b_commit),
"");
if (run_diff_index(&rev, 0)) {
ret = -1;
goto done;
}
cp_upd_index.git_cmd = 1;
argv_array_pushl(&cp_upd_index.args, "update-index", "-z", "--add",
"--remove", "--stdin", NULL);
argv_array_pushf(&cp_upd_index.env_array, "GIT_INDEX_FILE=%s",
stash_index_path.buf);
if (pipe_command(&cp_upd_index, diff_output.buf, diff_output.len,
NULL, 0, NULL, 0)) {
ret = -1;
goto done;
}
if (write_index_as_tree(&info->w_tree, &istate, stash_index_path.buf, 0,
NULL)) {
ret = -1;
goto done;
}
done:
discard_index(&istate);
UNLEAK(rev);
object_array_clear(&rev.pending);
strbuf_release(&diff_output);
remove_path(stash_index_path.buf);
return ret;
}
static afc_error_t cmd_rm(int argc, const char *argv[])
{
afc_error_t result;
char *path = NULL;
bool recurse = false;
if (argc < 1) {
warnx("usage: rm [-r] <file> ...");
return AFC_E_INVALID_ARG;
}
if (argc > 1 && (recurse = str_is_equal("-r", argv[0]))) {
argc--;
argv++;
}
for (int i = 0; i < argc; i++) {
path = build_absolute_path(argv[i]);
if (!path)
return AFC_E_INTERNAL_ERROR;
result = remove_path(path, recurse);
free(path);
if (result == AFC_E_OBJECT_NOT_FOUND)
afc_warn(result, "%s", argv[i]);
return result;
}
return AFC_E_SUCCESS;
}
/*
* Adds a prefix to the file name:
* "tutu.txt" + "old-" => "old-tutu.txt"
**/
void add_prefix_to_file_name(char* dest,const char* src,const char* prefix) {
char tmp[1024];
get_path(src,dest);
strcat(dest,prefix);
remove_path(src,tmp);
strcat(dest,tmp);
}
// Pushes the path record for fp onto the input stack
void pfmarkinput(void *fp, cell *up)
{
filepath_t *this = remove_path((FILE *)fp);
if (this) {
this->next = input_stack.next;
input_stack.next = this;
}
}
/*
arg_parse() parses the command line arguments, setting appropriate globals.
argc and argv should be passed directly from the command line
*/
void arg_parse( int argc, char** argv )
{
int i = 0;
/*extract program name from command line (remove path, if present) */
pname = remove_path( argv[0] );
/*parse commandline options */
while( TRUE )
{
char* arg_check;
int arg = getopt( argc, argv, OPTIONS );
if( arg == -1 )
break;
switch( arg )
{
/* user asked for help */
case 'h':
usage( pname );
exit(0);
break;
/* catch invalid arguments */
default:
fatal_error( "-%c: invalid option\nTry '%s -h' for help.",
optopt, pname );
}
}
/* make sure input and output files are specified */
if( argc - optind < 1 )
fatal_error( "no input image specified.\nTry '%s -h' for help.", pname );
if( argc - optind < 2 )
fatal_error( "no reference images specified.\nTry '%s -h' for help.",
pname );
/* import input image */
in_img = cvLoadImage( argv[optind], 1 );
if( ! in_img )
fatal_error("error importing image from %s", argv[optind]);
/* import reference images */
num_ref_imgs = argc - ++optind;
ref_imgs = (IplImage **)malloc( num_ref_imgs * sizeof( IplImage*) );
while( optind < argc )
{
ref_imgs[i] = cvLoadImage( argv[optind], 1 );
if( ! ref_imgs[i] )
{
fprintf(stderr, "Error: could not load reference image from %s\n",
argv[optind]);
num_ref_imgs--;
}
else
i++;
optind++;
}
}
static rc_t ref_seq_load_main( const p_context ctx )
{
KDirectory *dir;
rc_t rc = KDirectoryNativeDir( &dir );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "ref_seq_load_main:KDirectoryNativeDir() failed" );
}
else
{
VDBManager *mgr;
rc = VDBManagerMakeUpdate ( &mgr, dir );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "ref_seq_load_main:VDBManagerMakeRead() failed" );
}
else
{
rc = prepare_load( dir, ctx );
if ( rc != 0 )
{
LOGERR( klogInt, rc, "ref_seq_load_main:prepare_load() failed" );
}
else
{
char tblpath[ 4096 ];
rc = KDirectoryResolvePath( dir, true, tblpath, sizeof tblpath, ctx->dst_path );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "ref_seq_load_main:KDirectoryResolvePath() failed" );
}
else
{
KPathType type = VDBManagerPathType( mgr, tblpath );
if ( type != kptNotFound )
{
rc = RC( rcExe, rcDatabase, rcCreating, rcFile, rcExists );
PLOGERR( klogErr, ( klogErr, rc, "$(path)", "path=%s", tblpath ) );
}
}
}
if ( rc == 0 )
{
rc = perform_load( ctx, dir, mgr ); /* <====================== */
if ( rc != 0 )
{
remove_path( dir, ctx->dst_path, ctx->quiet );
}
}
VDBManagerRelease( mgr );
}
KDirectoryRelease( dir );
}
return rc;
}
static afc_error_t remove_path(char *path, bool recurse)
{
afc_error_t result;
char **infolist = NULL;
bool is_dir;
result = afc_get_file_info(afc, path, &infolist);
if (result != AFC_E_SUCCESS) {
if (result != AFC_E_OBJECT_NOT_FOUND)
afc_warn(result, "%s: stat failed: %s", __func__, path);
return result;
}
if (recurse && is_directory(path, &is_dir) == AFC_E_SUCCESS && is_dir) {
char **list = NULL;
result = afc_read_directory(afc, path, &list);
if (result != AFC_E_SUCCESS) {
afc_warn(result, "%s", path);
return result;
}
for (int i = 0; list[i] && result == AFC_E_SUCCESS; i++) {
if (str_is_equal(list[i], "."))
; // NOP
else if (str_is_equal(list[i], ".."))
; // NOP
else {
char *subdir_path;
if (asprintf(&subdir_path, "%s/%s", path, list[i]) > 0) {
result = remove_path(subdir_path, recurse);
free(subdir_path);
}
else {
warn("%s: %s", __func__, "asprintf");
}
}
free(list[i]);
}
free(list);
}
if (recurse)
printf("removing: %s\n", path);
result = afc_remove_path(afc, path);
if (result != AFC_E_SUCCESS)
afc_warn(result, "%s", path);
return result;
}
static void remove_path(char *path, int options) {
struct stat st;
// Stat file
if (stat(path, &st) < 0) {
perror(path);
return;
}
if (S_ISDIR(st.st_mode)) {
struct dirent *dp;
DIR *dirp;
char *fn;
int more;
// Remove files in directory recursively
if (options & VERBOSE) printf("deleting all files in %s\n", path);
dirp = opendir(path);
if (!dirp) {
perror(path);
return;
}
// Keep scanning directory until it is empty
more = 1;
while (more) {
more = 0;
while ((dp = readdir(dirp))) {
more = 1;
fn = join_path(path, dp->d_name);
if (!fn) {
fprintf(stderr, "error: out of memory\n");
closedir(dirp);
return;
}
remove_path(fn, options);
}
if (more) rewinddir(dirp);
}
closedir(dirp);
// Remove directory
if (options & VERBOSE) printf("removing directory %s\n", path);
if (rmdir(path) < 0) perror(path);
} else {
// Remove file
if (options & VERBOSE) printf("removing file %s\n", path);
if (unlink(path) < 0) perror(path);
}
}
void downstream_manager::close(stream_slot slot) {
CAF_LOG_TRACE(CAF_ARG(slot));
auto ptr = path(slot);
if (ptr == nullptr) {
CAF_LOG_DEBUG("cannot close unknown slot:" << slot);
return;
}
if (buffered(slot) == 0 && ptr->clean()) {
CAF_LOG_DEBUG("path clean, remove immediately;" << CAF_ARG(slot));
remove_path(slot, none, false);
return;
}
CAF_LOG_DEBUG("path not clean, set to closing;" << CAF_ARG(slot));
ptr->closing = true;
}
static void
unloop_loops (bitmap loop_closed_ssa_invalidated,
bool *irred_invalidated)
{
while (loops_to_unloop.length ())
{
struct loop *loop = loops_to_unloop.pop ();
int n_unroll = loops_to_unloop_nunroll.pop ();
basic_block latch = loop->latch;
edge latch_edge = loop_latch_edge (loop);
int flags = latch_edge->flags;
location_t locus = latch_edge->goto_locus;
gcall *stmt;
gimple_stmt_iterator gsi;
remove_exits_and_undefined_stmts (loop, n_unroll);
/* Unloop destroys the latch edge. */
unloop (loop, irred_invalidated, loop_closed_ssa_invalidated);
/* Create new basic block for the latch edge destination and wire
it in. */
stmt = gimple_build_call (builtin_decl_implicit (BUILT_IN_UNREACHABLE), 0);
latch_edge = make_edge (latch, create_basic_block (NULL, NULL, latch), flags);
latch_edge->probability = 0;
latch_edge->count = 0;
latch_edge->flags |= flags;
latch_edge->goto_locus = locus;
latch_edge->dest->loop_father = current_loops->tree_root;
latch_edge->dest->count = 0;
latch_edge->dest->frequency = 0;
set_immediate_dominator (CDI_DOMINATORS, latch_edge->dest, latch_edge->src);
gsi = gsi_start_bb (latch_edge->dest);
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
}
loops_to_unloop.release ();
loops_to_unloop_nunroll.release ();
/* Remove edges in peeled copies. */
unsigned i;
edge e;
FOR_EACH_VEC_ELT (edges_to_remove, i, e)
{
bool ok = remove_path (e);
gcc_assert (ok);
}
static int remove_file(struct merge_options *o, int clean,
const char *path, int no_wd)
{
int update_cache = o->call_depth || clean;
int update_working_directory = !o->call_depth && !no_wd;
if (update_cache) {
if (remove_file_from_cache(path))
return -1;
}
if (update_working_directory) {
if (remove_path(path) && errno != ENOENT)
return -1;
}
return 0;
}
static int remove_file(int clean, const char *path, int no_wd)
{
int update_cache = index_only || clean;
int update_working_directory = !index_only && !no_wd;
if (update_cache) {
if (remove_file_from_cache(path))
return -1;
}
if (update_working_directory) {
unlink(path);
if (errno != ENOENT || errno != EISDIR)
return -1;
remove_path(path);
}
return 0;
}
int store_remove_pathf(const char *fmt, ...)
{
#ifdef ANDROID
return ENOSYS;
#else
char path[1024];
va_list ap;
int err;
va_start(ap, fmt);
err = re_vsnprintf(path, sizeof(path), fmt, ap);
va_end(ap);
if (err == -1)
return EINVAL;
return remove_path(path);
#endif
}
bool Target::check_paths(double stamp)
{
// 因为第一帧选择特征点时，可能某些特征点不在运动目标上，应该去掉 ...
// FIXME: 仅仅在第5帧时进行检查 ....
if (layers_.size() != 5) {
return true;
}
// 在第五帧，强制删除距离太小的特征点 ...
int n = get_path_cnt();
for (int i = n - 1; i >= 0; i--) {
PATH path = get_path(i);
if (distance(path) < min_dis_5frames_) {
remove_path(i);
}
}
return get_path_cnt() > min_pts_;
}
int display_fst2_file_stat(const char* name,U_FILE*ferr)
{
struct FST2_free_info fst2_free;
Fst2* fst2=load_abstract_fst2(name,1,&fst2_free);
char name_without_path[FILENAME_MAX];
remove_path(name,name_without_path);
if (fst2==NULL) {
error("Cannot load graph %s\n",name);
if (ferr != NULL)
u_fprintf(ferr,"Cannot load graph %s\n",name);
return 0;
}
u_printf("Statistics of graph %s: ",name_without_path);
if (ferr != NULL)
u_fprintf(ferr,"Statistics of graph %s: ",name_without_path);
display_fst2_stat(fst2,ferr);
free_abstract_Fst2(fst2,&fst2_free);
return 1;
}
static int remove_file(struct merge_options *o, int clean,
const char *path, int no_wd,
unsigned int ctime, unsigned int mtime)
{
int update_cache = o->call_depth || clean;
int update_working_directory = !o->call_depth && !no_wd;
if (o->collect_blocks_only)
return 0;
if (update_cache) {
if (remove_file_from_index(o->index, path))
return -1;
}
if (update_working_directory) {
if (remove_path(o->worktree, path, ctime, mtime))
return -1;
}
return 0;
}
static int save_untracked_files(struct stash_info *info, struct strbuf *msg,
struct strbuf files)
{
int ret = 0;
struct strbuf untracked_msg = STRBUF_INIT;
struct child_process cp_upd_index = CHILD_PROCESS_INIT;
struct index_state istate = { NULL };
cp_upd_index.git_cmd = 1;
argv_array_pushl(&cp_upd_index.args, "update-index", "-z", "--add",
"--remove", "--stdin", NULL);
argv_array_pushf(&cp_upd_index.env_array, "GIT_INDEX_FILE=%s",
stash_index_path.buf);
strbuf_addf(&untracked_msg, "untracked files on %s\n", msg->buf);
if (pipe_command(&cp_upd_index, files.buf, files.len, NULL, 0,
NULL, 0)) {
ret = -1;
goto done;
}
if (write_index_as_tree(&info->u_tree, &istate, stash_index_path.buf, 0,
NULL)) {
ret = -1;
goto done;
}
if (commit_tree(untracked_msg.buf, untracked_msg.len,
&info->u_tree, NULL, &info->u_commit, NULL, NULL)) {
ret = -1;
goto done;
}
done:
discard_index(&istate);
strbuf_release(&untracked_msg);
remove_path(stash_index_path.buf);
return ret;
}
static int remove_package(char *pkgname, struct pkgdb *db, int options) {
struct pkg *pkg;
struct section *files;
// Find package and load manifest
pkg = find_package(db, pkgname);
if (!pkg) {
fprintf(stderr, "%s: package not found\n", pkgname);
return 1;
}
if (pkg->removed) return 0;
if (!pkg->manifest) {
if (options & VERBOSE) printf("reading manifest from %s\n", pkg->inffile);
pkg->manifest = read_properties(pkg->inffile);
if (!pkg->manifest) {
fprintf(stderr, "%s: unable to read manifest\n", pkg->inffile);
return 1;
}
}
// Remove package files
files = find_section(pkg->manifest, "files");
if (files) {
struct property *p;
for (p = files->properties; p; p = p->next) {
remove_path(p->name, options);
}
}
// Remove manifest file
unlink(pkg->inffile);
// Remove package from package database
pkg->removed = 1;
db->dirty = 1;
return 0;
}
static bool
try_unroll_loop_completely (struct loop *loop,
edge exit, tree niter,
enum unroll_level ul,
HOST_WIDE_INT maxiter,
location_t locus)
{
unsigned HOST_WIDE_INT n_unroll = 0, ninsns, unr_insns;
struct loop_size size;
bool n_unroll_found = false;
edge edge_to_cancel = NULL;
int report_flags = MSG_OPTIMIZED_LOCATIONS | TDF_RTL | TDF_DETAILS;
/* See if we proved number of iterations to be low constant.
EXIT is an edge that will be removed in all but last iteration of
the loop.
EDGE_TO_CACNEL is an edge that will be removed from the last iteration
of the unrolled sequence and is expected to make the final loop not
rolling.
If the number of execution of loop is determined by standard induction
variable test, then EXIT and EDGE_TO_CANCEL are the two edges leaving
from the iv test. */
if (tree_fits_uhwi_p (niter))
{
n_unroll = tree_to_uhwi (niter);
n_unroll_found = true;
edge_to_cancel = EDGE_SUCC (exit->src, 0);
if (edge_to_cancel == exit)
edge_to_cancel = EDGE_SUCC (exit->src, 1);
}
/* We do not know the number of iterations and thus we can not eliminate
the EXIT edge. */
else
exit = NULL;
/* See if we can improve our estimate by using recorded loop bounds. */
if (maxiter >= 0
&& (!n_unroll_found || (unsigned HOST_WIDE_INT)maxiter < n_unroll))
{
n_unroll = maxiter;
n_unroll_found = true;
/* Loop terminates before the IV variable test, so we can not
remove it in the last iteration. */
edge_to_cancel = NULL;
}
if (!n_unroll_found)
return false;
if (n_unroll > (unsigned) PARAM_VALUE (PARAM_MAX_COMPLETELY_PEEL_TIMES))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d "
"(--param max-completely-peeled-times limit reached).\n",
loop->num);
return false;
}
if (!edge_to_cancel)
edge_to_cancel = loop_edge_to_cancel (loop);
if (n_unroll)
{
sbitmap wont_exit;
edge e;
unsigned i;
bool large;
vec<edge> to_remove = vNULL;
if (ul == UL_SINGLE_ITER)
return false;
large = tree_estimate_loop_size
(loop, exit, edge_to_cancel, &size,
PARAM_VALUE (PARAM_MAX_COMPLETELY_PEELED_INSNS));
ninsns = size.overall;
if (large)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: it is too large.\n",
loop->num);
return false;
}
unr_insns = estimated_unrolled_size (&size, n_unroll);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " Loop size: %d\n", (int) ninsns);
fprintf (dump_file, " Estimated size after unrolling: %d\n",
(int) unr_insns);
}
/* If the code is going to shrink, we don't need to be extra cautious
on guessing if the unrolling is going to be profitable. */
if (unr_insns
/* If there is IV variable that will become constant, we save
one instruction in the loop prologue we do not account
otherwise. */
<= ninsns + (size.constant_iv != false))
;
/* We unroll only inner loops, because we do not consider it profitable
otheriwse. We still can cancel loopback edge of not rolling loop;
this is always a good idea. */
else if (ul == UL_NO_GROWTH)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: size would grow.\n",
loop->num);
return false;
}
/* Outer loops tend to be less interesting candidates for complete
unrolling unless we can do a lot of propagation into the inner loop
body. For now we disable outer loop unrolling when the code would
grow. */
else if (loop->inner)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: "
"it is not innermost and code would grow.\n",
loop->num);
return false;
}
/* If there is call on a hot path through the loop, then
there is most probably not much to optimize. */
else if (size.num_non_pure_calls_on_hot_path)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: "
"contains call and code would grow.\n",
loop->num);
return false;
}
/* If there is pure/const call in the function, then we
can still optimize the unrolled loop body if it contains
some other interesting code than the calls and code
storing or cumulating the return value. */
else if (size.num_pure_calls_on_hot_path
/* One IV increment, one test, one ivtmp store
and one useful stmt. That is about minimal loop
doing pure call. */
&& (size.non_call_stmts_on_hot_path
<= 3 + size.num_pure_calls_on_hot_path))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: "
"contains just pure calls and code would grow.\n",
loop->num);
return false;
}
/* Complette unrolling is major win when control flow is removed and
one big basic block is created. If the loop contains control flow
the optimization may still be a win because of eliminating the loop
overhead but it also may blow the branch predictor tables.
Limit number of branches on the hot path through the peeled
sequence. */
else if (size.num_branches_on_hot_path * (int)n_unroll
> PARAM_VALUE (PARAM_MAX_PEEL_BRANCHES))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: "
" number of branches on hot path in the unrolled sequence"
" reach --param max-peel-branches limit.\n",
loop->num);
return false;
}
else if (unr_insns
> (unsigned) PARAM_VALUE (PARAM_MAX_COMPLETELY_PEELED_INSNS))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: "
"(--param max-completely-peeled-insns limit reached).\n",
loop->num);
return false;
}
dump_printf_loc (report_flags, locus,
"loop turned into non-loop; it never loops.\n");
initialize_original_copy_tables ();
wont_exit = sbitmap_alloc (n_unroll + 1);
bitmap_ones (wont_exit);
bitmap_clear_bit (wont_exit, 0);
if (!gimple_duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
n_unroll, wont_exit,
exit, &to_remove,
DLTHE_FLAG_UPDATE_FREQ
| DLTHE_FLAG_COMPLETTE_PEEL))
{
free_original_copy_tables ();
free (wont_exit);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Failed to duplicate the loop\n");
return false;
}
FOR_EACH_VEC_ELT (to_remove, i, e)
{
bool ok = remove_path (e);
gcc_assert (ok);
}
to_remove.release ();
free (wont_exit);
free_original_copy_tables ();
}
int cmd_rm(int argc, const char **argv, const char *prefix)
{
int i, newfd;
const char **pathspec;
char *seen;
git_config(git_default_config, NULL);
argc = parse_options(argc, argv, prefix, builtin_rm_options,
builtin_rm_usage, 0);
if (!argc)
usage_with_options(builtin_rm_usage, builtin_rm_options);
if (!index_only)
setup_work_tree();
newfd = hold_locked_index(&lock_file, 1);
if (read_cache() < 0)
die(_("index file corrupt"));
/*
* Drop trailing directory separators from directories so we'll find
* submodules in the index.
*/
for (i = 0; i < argc; i++) {
size_t pathlen = strlen(argv[i]);
if (pathlen && is_dir_sep(argv[i][pathlen - 1]) &&
is_directory(argv[i])) {
do {
pathlen--;
} while (pathlen && is_dir_sep(argv[i][pathlen - 1]));
argv[i] = xmemdupz(argv[i], pathlen);
}
}
pathspec = get_pathspec(prefix, argv);
refresh_index(&the_index, REFRESH_QUIET, pathspec, NULL, NULL);
seen = NULL;
for (i = 0; pathspec[i] ; i++)
/* nothing */;
seen = xcalloc(i, 1);
for (i = 0; i < active_nr; i++) {
struct cache_entry *ce = active_cache[i];
if (!match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, seen))
continue;
ALLOC_GROW(list.entry, list.nr + 1, list.alloc);
list.entry[list.nr].name = ce->name;
list.entry[list.nr++].is_submodule = S_ISGITLINK(ce->ce_mode);
}
if (pathspec) {
const char *match;
int seen_any = 0;
for (i = 0; (match = pathspec[i]) != NULL ; i++) {
if (!seen[i]) {
if (!ignore_unmatch) {
die(_("pathspec '%s' did not match any files"),
match);
}
}
else {
seen_any = 1;
}
if (!recursive && seen[i] == MATCHED_RECURSIVELY)
die(_("not removing '%s' recursively without -r"),
*match ? match : ".");
}
if (! seen_any)
exit(0);
}
/*
* If not forced, the file, the index and the HEAD (if exists)
* must match; but the file can already been removed, since
* this sequence is a natural "novice" way:
*
* rm F; git rm F
*
* Further, if HEAD commit exists, "diff-index --cached" must
* report no changes unless forced.
*/
if (!force) {
unsigned char sha1[20];
if (get_sha1("HEAD", sha1))
hashclr(sha1);
if (check_local_mod(sha1, index_only))
exit(1);
} else if (!index_only) {
if (check_submodules_use_gitfiles())
exit(1);
}
/*
* First remove the names from the index: we won't commit
* the index unless all of them succeed.
*/
for (i = 0; i < list.nr; i++) {
const char *path = list.entry[i].name;
if (!quiet)
printf("rm '%s'\n", path);
if (remove_file_from_cache(path))
die(_("git rm: unable to remove %s"), path);
}
if (show_only)
return 0;
/*
* Then, unless we used "--cached", remove the filenames from
* the workspace. If we fail to remove the first one, we
* abort the "git rm" (but once we've successfully removed
* any file at all, we'll go ahead and commit to it all:
* by then we've already committed ourselves and can't fail
* in the middle)
*/
if (!index_only) {
int removed = 0;
for (i = 0; i < list.nr; i++) {
const char *path = list.entry[i].name;
if (list.entry[i].is_submodule) {
if (is_empty_dir(path)) {
if (!rmdir(path)) {
removed = 1;
continue;
}
} else {
struct strbuf buf = STRBUF_INIT;
strbuf_addstr(&buf, path);
if (!remove_dir_recursively(&buf, 0)) {
removed = 1;
strbuf_release(&buf);
continue;
}
strbuf_release(&buf);
/* Fallthrough and let remove_path() fail. */
}
}
if (!remove_path(path)) {
removed = 1;
continue;
}
if (!removed)
die_errno("git rm: '%s'", path);
}
}
if (active_cache_changed) {
if (write_cache(newfd, active_cache, active_nr) ||
commit_locked_index(&lock_file))
die(_("Unable to write new index file"));
}
return 0;
}
static DBusMessage *remove_connection(DBusConnection *conn,
DBusMessage *msg, void *data)
{
return remove_path(conn, msg, &connection_paths, "ConnectionRemoved");
}
bool
Purger::operator()(jobid::JobId const& id)
{
ContextPtr log_ctx;
try {
log_ctx = create_context(id, get_host_x509_proxy(), f_sequence_code);
}
catch (CannotCreateLBContext& e) {
Error(
id.toString()
<< ": CannotCreateLBContext from host proxy, error code #"
<< e.error_code()
);
return false;
}
ContextPtr log_proxy_ctx;
if (m_have_lb_proxy) {
try {
log_proxy_ctx = create_context_proxy(id, get_host_x509_proxy(), f_sequence_code);
} catch (CannotCreateLBContext& e) {
Error(
id.toString()
<< ": CannotCreateLBProxyContext from host proxy, error code #"
<< e.error_code()
);
log_proxy_ctx = log_ctx;
}
}
edg_wll_JobStat job_status;
edg_wll_InitStatus(&job_status);
utilities::scope_guard free_job_status(
boost::bind(edg_wll_FreeStatus, &job_status)
);
switch( query_job_status(job_status, id, log_ctx) ) {
case 0: break; // query succeeded
case EIDRM: // identifier removed(matching job already purged)
case ENOENT: // no matching jobs found
Info(id.toString() << ": forced removal, unknown/removed L&B job");
if (m_have_lb_proxy) {
return remove_path(
jobid_to_absolute_path(id),
log_proxy_ctx
);
} else {
return remove_path(
jobid_to_absolute_path(id),
log_ctx
);
}
default:
return false;
}
// Reads the TYPE of the JOB...
bool is_dag =
(job_status.jobtype == EDG_WLL_STAT_DAG ) ||
(job_status.jobtype == EDG_WLL_STAT_COLLECTION);
if (is_dag &&
(m_skip_status_checking || is_status_removable(job_status)) &&
( !m_threshold || is_threshold_overcome(job_status, m_threshold))
) { // removing dag and children
std::vector<std::string> children;
if (job_status.children) {
char** i = &job_status.children[0];
while(*i) {
children.push_back(std::string(*i));
++i;
}
}
ContextPtr this_context = (m_have_lb_proxy) ? log_proxy_ctx : log_ctx;
std::vector<std::string>::const_iterator i = children.begin();
std::vector<std::string>::const_iterator const e = children.end();
size_t n = 0;
for( ; i != e; ++i ) {
jobid::JobId const job_id(*i);
change_logging_job(this_context, job_id, m_have_lb_proxy);
if (!remove_path(strid_to_absolute_path(*i), log_proxy_ctx)) {
++n;
}
}
Info(
id.toString() << ": "
<< children.size() - n << '/' << children.size() << " nodes removed"
);
change_logging_job(this_context, jobid::JobId(id), m_have_lb_proxy);
bool path_removed = remove_path(
jobid_to_absolute_path(id),
this_context
);
if (path_removed) {
Info(
id.toString()<< ": removed " << StatToString(job_status) << " dag "
);
}
return path_removed;
}
bool const is_dag_node = job_status.parent_job != 0;
// if the job is a dag node we should skip its removal
// unless it is an orphan node or so requested
if (is_dag_node && m_force_dag_node_removal ) {
bool path_removed = false;
if (m_have_lb_proxy) {
path_removed = remove_path(
jobid_to_absolute_path(id),
log_proxy_ctx
);
} else {
path_removed = remove_path(
jobid_to_absolute_path(id),
log_ctx
);
}
if (path_removed) {
Info(
id.toString() << ": removed "
<< StatToString(job_status) << " node"
);
}
return path_removed;
}
if (is_dag_node && m_force_orphan_node_removal) try {
jobid::JobId const p_id(job_status.parent_job);
fs::path pp(jobid_to_absolute_path(p_id));
if (!fs::exists(pp)) {
bool path_removed = false;
if (m_have_lb_proxy) {
path_removed = remove_path(
jobid_to_absolute_path(id),
log_proxy_ctx
);
} else {
path_removed = remove_path(
jobid_to_absolute_path(id),
log_ctx
);
}
if (path_removed) {
Info(
id.toString() << ": removed "
<< StatToString(job_status) << " orphan node"
);
}
return path_removed;
}
} catch(...) { // TODO: refine catch
return false;
}
if ((m_skip_status_checking || is_status_removable(job_status))
&& (!m_threshold
|| is_threshold_overcome(job_status, m_threshold)
)
)
{ // removing normal job
bool path_removed = false;
if (m_have_lb_proxy) {
path_removed = remove_path(
jobid_to_absolute_path(id),
log_proxy_ctx
);
} else {
path_removed = remove_path(
jobid_to_absolute_path(id),
log_ctx
);
}
if (path_removed) {
Info(
id.toString() << ": removed " << StatToString(job_status) << " job"
);
return path_removed;
}
}
return false;
}
/**
* This function loads a DLF or a DLC. It computes information about tokens
* that will be used during the Locate operation. For instance, if we have the
* following line:
*
* extended,.A
*
* and if the .fst2 to be applied to the text contains the pattern <A> with,
* number 456, then the function will mark the "extended" token to be matched
* by the pattern 456. Moreover, all case variations will be taken into account,
* so that the "Extended" and "EXTENDED" tokens will also be updated.
*
* The two parameters 'is_DIC_pattern' and 'is_CDIC_pattern'
* indicate if the .fst2 contains the corresponding patterns. For instance, if
* the pattern "<CDIC>" is used in the grammar, it means that any token sequence that is a
* compound word must be marked as be matched by this pattern.
*/
void load_dic_for_locate(const char* dic_name,int mask_encoding_compatibility_input,Alphabet* alphabet,
int number_of_patterns,int is_DIC_pattern,
int is_CDIC_pattern,
struct lemma_node* root,struct locate_parameters* parameters) {
struct string_hash* tokens=parameters->tokens;
U_FILE* f;
unichar line[DIC_LINE_SIZE];
f=u_fopen_existing_versatile_encoding(mask_encoding_compatibility_input,dic_name,U_READ);
if (f==NULL) {
error("Cannot open dictionary %s\n",dic_name);
return;
}
/* We parse all the lines */
int lines=0;
char name[FILENAME_MAX];
remove_path(dic_name,name);
while (EOF!=u_fgets(line,f)) {
lines++;
if (lines%10000==0) {
u_printf("%s: %d lines loaded... \r",name,lines);
}
if (line[0]=='/') {
/* NOTE: DLF and DLC files are not supposed to contain comment
* lines, but we test them, just in the case */
continue;
}
struct dela_entry* entry=tokenize_DELAF_line(line,1);
if (entry==NULL) {
/* This case should never happen */
error("Invalid dictionary line in load_dic_for_locate\n");
continue;
}
/* We add the inflected form to the list of forms associated to the lemma.
* This will be used to replace patterns like "<be>" by the actual list of
* forms that can be matched by it, for optimization reasons */
add_inflected_form_for_lemma(entry->inflected,entry->lemma,root);
/* We get the list of all tokens that can be matched by the inflected form of this
* this entry, with regards to case variations (see the "extended" example above). */
struct list_int* ptr=get_token_list_for_sequence(entry->inflected,alphabet,tokens);
/* We save the list pointer to free it later */
struct list_int* ptr_copy=ptr;
/* Here, we will deal with all simple words */
while (ptr!=NULL) {
int i=ptr->n;
/* If the current token can be matched, then it can be recognized by the "<DIC>" pattern */
parameters->token_control[i]=(unsigned char)(get_control_byte(tokens->value[i],alphabet,NULL,parameters->tokenization_policy)|DIC_TOKEN_BIT_MASK);
if (number_of_patterns) {
/* We look for matching patterns only if there are some */
struct list_pointer* list=get_matching_patterns(entry,parameters->pattern_tree_root);
if (list!=NULL) {
/* If we have some patterns to add */
if (parameters->matching_patterns[i]==NULL) {
/* We allocate the pattern bit array, if needed */
parameters->matching_patterns[i]=new_bit_array(number_of_patterns,ONE_BIT);
}
struct list_pointer* tmp=list;
while (tmp!=NULL) {
/* Then we add all the pattern numbers to the bit array */
set_value(parameters->matching_patterns[i],((struct constraint_list*)(tmp->pointer))->pattern_number,1);
tmp=tmp->next;
}
/* Finally, we free the constraint list */
free_list_pointer(list);
}
}
ptr=ptr->next;
}
/* Finally, we free the token list */
free_list_int(ptr_copy);
if (!is_a_simple_word(entry->inflected,parameters->tokenization_policy,alphabet)) {
/* If the inflected form is a compound word */
if (is_DIC_pattern || is_CDIC_pattern) {
/* If the .fst2 contains "<DIC>" and/or "<CDIC>", then we
* must note that all compound words can be matched by them */
add_compound_word_with_no_pattern(entry->inflected,alphabet,tokens,parameters->DLC_tree,parameters->tokenization_policy);
}
if (number_of_patterns) {
/* We look for matching patterns only if there are some */
/* We look if the compound word can be matched by some patterns */
struct list_pointer* list=get_matching_patterns(entry,parameters->pattern_tree_root);
struct list_pointer* tmp=list;
while (tmp!=NULL) {
/* If the word is matched by at least one pattern, we store it. */
int pattern_number=((struct constraint_list*)(tmp->pointer))->pattern_number;
add_compound_word_with_pattern(entry->inflected,pattern_number,alphabet,tokens,parameters->DLC_tree,parameters->tokenization_policy);
tmp=tmp->next;
}
free_list_pointer(list);
}
}
free_dela_entry(entry);
}
if (lines>10000) {
u_printf("\n");
}
u_fclose(f);
}
int main_CheckDic(int argc,char* const argv[]) {
if (argc==1) {
usage();
return 0;
}
int is_a_DELAF=-1;
int strict_unprotected=0;
int skip_path=0;
char alph[FILENAME_MAX]="";
Encoding encoding_output = DEFAULT_ENCODING_OUTPUT;
int bom_output = DEFAULT_BOM_OUTPUT;
int mask_encoding_compatibility_input = DEFAULT_MASK_ENCODING_COMPATIBILITY_INPUT;
int val,index=-1;
int space_warnings=1;
struct OptVars* vars=new_OptVars();
while (EOF!=(val=getopt_long_TS(argc,argv,optstring_CheckDic,lopts_CheckDic,&index,vars))) {
switch(val) {
case 'f': is_a_DELAF=1; break;
case 's': is_a_DELAF=0; break;
case 'h': usage(); return 0;
case 'r': strict_unprotected=1; break;
case 't': strict_unprotected=0; break;
case 'n': space_warnings=0; break;
case 'p': skip_path=1; break;
case 'a': if (vars->optarg[0]=='\0') {
fatal_error("Empty alphabet argument\n");
}
strcpy(alph,vars->optarg);
break;
case 'k': if (vars->optarg[0]=='\0') {
fatal_error("Empty input_encoding argument\n");
}
decode_reading_encoding_parameter(&mask_encoding_compatibility_input,vars->optarg);
break;
case 'q': if (vars->optarg[0]=='\0') {
fatal_error("Empty output_encoding argument\n");
}
decode_writing_encoding_parameter(&encoding_output,&bom_output,vars->optarg);
break;
case ':': if (index==-1) fatal_error("Missing argument for option -%c\n",vars->optopt);
else fatal_error("Missing argument for option --%s\n",lopts_CheckDic[index].name);
case '?': if (index==-1) fatal_error("Invalid option -%c\n",vars->optopt);
else fatal_error("Invalid option --%s\n",vars->optarg);
break;
}
index=-1;
}
if (is_a_DELAF==-1 || vars->optind!=argc-1) {
error("Invalid arguments: rerun with --help\n");
return 1;
}
U_FILE* dic=u_fopen_existing_versatile_encoding(mask_encoding_compatibility_input,argv[vars->optind],U_READ);
if (dic==NULL) {
fatal_error("Cannot open dictionary %s\n",argv[vars->optind]);
}
Alphabet* alphabet0=NULL;
if (alph[0]!='\0') {
alphabet0=load_alphabet(alph,1);
}
char output_filename[FILENAME_MAX];
get_path(argv[vars->optind],output_filename);
strcat(output_filename,"CHECK_DIC.TXT");
U_FILE* out=u_fopen_versatile_encoding(encoding_output,bom_output,mask_encoding_compatibility_input,output_filename,U_WRITE);
if (out==NULL) {
u_fclose(dic);
fatal_error("Cannot create %s\n",output_filename);
}
u_printf("Checking %s...\n",argv[vars->optind]);
unichar line[CHECKDIC_LINE_SIZE];
int line_number=1;
/*
* We declare and initialize an array in order to know which
* letters are used in the dictionary.
*/
int i;
char* alphabet=(char*)malloc(sizeof(char)*MAX_NUMBER_OF_UNICODE_CHARS);
if (alphabet==NULL) {
fatal_alloc_error("CheckDic's main");
}
memset(alphabet,0,sizeof(char)*MAX_NUMBER_OF_UNICODE_CHARS);
/*
* We use two structures for the storage of the codes found in the
* dictionary. Note that 'semantic_codes' is used to store both grammatical and
* semantic codes.
*/
struct string_hash* semantic_codes=new_string_hash();
struct string_hash* inflectional_codes=new_string_hash();
struct string_hash* simple_lemmas=new_string_hash(DONT_USE_VALUES);
struct string_hash* compound_lemmas=new_string_hash(DONT_USE_VALUES);
int n_simple_entries=0;
int n_compound_entries=0;
/*
* We read all the lines and check them.
*/
while (EOF!=u_fgets_limit2(line,DIC_LINE_SIZE,dic)) {
if (line[0]=='\0') {
/* If we have an empty line, we print a unicode error message
* into the output file */
u_fprintf(out,"Line %d: empty line\n",line_number);
}
else if (line[0]=='/') {
/* If a line starts with '/', it is a commment line, so
* we ignore it */
}
else {
/* If we have a line to check, we check it according to the
* dictionary type */
check_DELA_line(line,out,is_a_DELAF,line_number,alphabet,semantic_codes,
inflectional_codes,simple_lemmas,compound_lemmas,
&n_simple_entries,&n_compound_entries,alphabet0,strict_unprotected);
}
/* At regular intervals, we display a message on the standard
* output to show that the program is working */
if (line_number%10000==0) {
u_printf("%d lines read...\r",line_number);
}
line_number++;
}
u_printf("%d lines read\n",line_number-1);
u_fclose(dic);
/*
* Once we have checked all the lines, we print some informations
* in the output file.
*/
u_fprintf(out,"-----------------------------------\n");
u_fprintf(out,"------------- Stats -------------\n");
u_fprintf(out,"-----------------------------------\n");
if (skip_path != 0) {
char filename_without_path[FILENAME_MAX];
remove_path(argv[vars->optind],filename_without_path);
u_fprintf(out,"File: %s\n",filename_without_path);
}
else {
u_fprintf(out,"File: %s\n",argv[vars->optind]);
}
u_fprintf(out,"Type: %s\n",is_a_DELAF?"DELAF":"DELAS");
u_fprintf(out,"%d line%s read\n",line_number-1,(line_number-1>1)?"s":"");
u_fprintf(out,"%d simple entr%s ",n_simple_entries,(n_simple_entries>1)?"ies":"y");
u_fprintf(out,"for %d distinct lemma%s\n",simple_lemmas->size,(simple_lemmas->size>1)?"s":"");
u_fprintf(out,"%d compound entr%s ",n_compound_entries,(n_compound_entries>1)?"ies":"y");
u_fprintf(out,"for %d distinct lemma%s\n",compound_lemmas->size,(compound_lemmas->size>1)?"s":"");
/**
* We print the list of the characters that are used, with
* their unicode numbers shown in hexadecimal. This can be useful
* to detect different characters that are graphically identical
* like 'A' (upper of latin 'a' or upper of greek alpha ?).
*/
u_fprintf(out,"-----------------------------------\n");
u_fprintf(out,"---- All chars used in forms ----\n");
u_fprintf(out,"-----------------------------------\n");
unichar r[4];
unichar r2[7];
r[1]=' ';
r[2]='(';
r[3]='\0';
r2[5]='\n';
r2[6]='\0';
for (i=0;i<MAX_NUMBER_OF_UNICODE_CHARS;i++) {
if (alphabet[i]) {
u_fprintf(out,"%C (%04X)\n",i,i);
}
}
/*
* Then we print the list of all grammatical and semantic codes used in the
* dictionary. If a code contains a non ASCII character, a space or a tabulation,
* we print a warning.
*/
u_fprintf(out,"-------------------------------------------------------------\n");
u_fprintf(out,"---- %3d grammatical/semantic code%s",semantic_codes->size,(semantic_codes->size>1)?"s used in dictionary ----\n":" used in dictionary -----\n");
u_fprintf(out,"-------------------------------------------------------------\n");
unichar comment[2000];
for (i=0;i<semantic_codes->size;i++) {
/* We print the code, followed if necessary by a warning */
u_fprintf(out,"%S",semantic_codes->value[i]);
if (warning_on_code(semantic_codes->value[i],comment,space_warnings)) {
u_fprintf(out," %S",comment);
}
u_fprintf(out,"\n");
}
/*
* Finally, we print the list of inflectional codes,
* with warnings in the case of non ASCII letters, spaces
* or tabulations.
*/
u_fprintf(out,"-----------------------------------------------------\n");
u_fprintf(out,"---- %3d inflectional code%s",inflectional_codes->size,(inflectional_codes->size>1)?"s used in dictionary ----\n":" used in dictionary -----\n");
u_fprintf(out,"-----------------------------------------------------\n");
for (i=0;i<inflectional_codes->size;i++) {
u_fprintf(out,"%S",inflectional_codes->value[i]);
if (warning_on_code(inflectional_codes->value[i],comment,space_warnings)) {
u_fprintf(out," %S",comment);
}
u_fprintf(out,"\n");
}
u_fclose(out);
free_OptVars(vars);
u_printf("Done.\n");
/* Note that we don't free anything since it would only waste time */
free(alphabet);
if (alphabet0!=NULL) {
free_alphabet(alphabet0);
}
#if (defined(UNITEX_LIBRARY) || defined(UNITEX_RELEASE_MEMORY_AT_EXIT))
/* cleanup for no leak on library */
free_string_hash(semantic_codes);
free_string_hash(inflectional_codes);
free_string_hash(simple_lemmas);
free_string_hash(compound_lemmas);
#endif
return 0;
}
/* Unswitch single LOOP. COND_CHECKED holds list of conditions we already
unswitched on and are therefore known to be true in this LOOP. NUM is
number of unswitchings done; do not allow it to grow too much, it is too
easy to create example on that the code would grow exponentially.
Returns true LOOP was unswitched. */
static bool
unswitch_single_loop (struct loop *loop, rtx cond_checked, int num)
{
basic_block *bbs;
struct loop *nloop;
unsigned i;
rtx cond, rcond = NULL_RTX, conds, rconds, acond, cinsn;
int repeat;
edge e;
HOST_WIDE_INT iterations;
/* Do not unswitch too much. */
if (num > PARAM_VALUE (PARAM_MAX_UNSWITCH_LEVEL))
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching anymore, hit max level\n");
return false;
}
/* Only unswitch innermost loops. */
if (loop->inner)
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, not innermost loop\n");
return false;
}
/* We must be able to duplicate loop body. */
if (!can_duplicate_loop_p (loop))
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, can't duplicate loop\n");
return false;
}
/* The loop should not be too large, to limit code growth. */
if (num_loop_insns (loop) > PARAM_VALUE (PARAM_MAX_UNSWITCH_INSNS))
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, loop too big\n");
return false;
}
/* Do not unswitch in cold areas. */
if (optimize_loop_for_size_p (loop))
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, not hot area\n");
return false;
}
/* Nor if the loop usually does not roll. */
iterations = estimated_loop_iterations_int (loop);
if (iterations >= 0 && iterations <= 1)
{
if (dump_file)
fprintf (dump_file, ";; Not unswitching, loop iterations < 1\n");
return false;
}
do
{
repeat = 0;
cinsn = NULL_RTX;
/* Find a bb to unswitch on. */
bbs = get_loop_body (loop);
iv_analysis_loop_init (loop);
for (i = 0; i < loop->num_nodes; i++)
if ((cond = may_unswitch_on (bbs[i], loop, &cinsn)))
break;
if (i == loop->num_nodes)
{
free (bbs);
return false;
}
if (cond != const0_rtx
&& cond != const_true_rtx)
{
rcond = reversed_condition (cond);
if (rcond)
rcond = canon_condition (rcond);
/* Check whether the result can be predicted. */
for (acond = cond_checked; acond; acond = XEXP (acond, 1))
simplify_using_condition (XEXP (acond, 0), &cond, NULL);
}
if (cond == const_true_rtx)
{
/* Remove false path. */
e = FALLTHRU_EDGE (bbs[i]);
remove_path (e);
free (bbs);
repeat = 1;
}
else if (cond == const0_rtx)
{
/* Remove true path. */
e = BRANCH_EDGE (bbs[i]);
remove_path (e);
free (bbs);
repeat = 1;
}
} while (repeat);
/* We found the condition we can unswitch on. */
conds = alloc_EXPR_LIST (0, cond, cond_checked);
if (rcond)
rconds = alloc_EXPR_LIST (0, rcond, cond_checked);
else
rconds = cond_checked;
if (dump_file)
fprintf (dump_file, ";; Unswitching loop\n");
/* Unswitch the loop on this condition. */
nloop = unswitch_loop (loop, bbs[i], copy_rtx_if_shared (cond), cinsn);
gcc_assert (nloop);
/* Invoke itself on modified loops. */
unswitch_single_loop (nloop, rconds, num + 1);
unswitch_single_loop (loop, conds, num + 1);
free_EXPR_LIST_node (conds);
if (rcond)
free_EXPR_LIST_node (rconds);
free (bbs);
return true;
}
static struct loop *
unswitch_loop (struct loop *loop, basic_block unswitch_on, rtx cond, rtx cinsn)
{
edge entry, latch_edge, true_edge, false_edge, e;
basic_block switch_bb, unswitch_on_alt;
struct loop *nloop;
int irred_flag, prob;
rtx seq;
/* Some sanity checking. */
gcc_assert (flow_bb_inside_loop_p (loop, unswitch_on));
gcc_assert (EDGE_COUNT (unswitch_on->succs) == 2);
gcc_assert (just_once_each_iteration_p (loop, unswitch_on));
gcc_assert (!loop->inner);
gcc_assert (flow_bb_inside_loop_p (loop, EDGE_SUCC (unswitch_on, 0)->dest));
gcc_assert (flow_bb_inside_loop_p (loop, EDGE_SUCC (unswitch_on, 1)->dest));
entry = loop_preheader_edge (loop);
/* Make a copy. */
irred_flag = entry->flags & EDGE_IRREDUCIBLE_LOOP;
entry->flags &= ~EDGE_IRREDUCIBLE_LOOP;
if (!duplicate_loop_to_header_edge (loop, entry, 1,
NULL, NULL, NULL, 0))
return NULL;
entry->flags |= irred_flag;
/* Record the block with condition we unswitch on. */
unswitch_on_alt = get_bb_copy (unswitch_on);
true_edge = BRANCH_EDGE (unswitch_on_alt);
false_edge = FALLTHRU_EDGE (unswitch_on);
latch_edge = single_succ_edge (get_bb_copy (loop->latch));
/* Create a block with the condition. */
prob = true_edge->probability;
switch_bb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
seq = compare_and_jump_seq (XEXP (cond, 0), XEXP (cond, 1), GET_CODE (cond),
block_label (true_edge->dest),
prob, cinsn);
emit_insn_after (seq, BB_END (switch_bb));
e = make_edge (switch_bb, true_edge->dest, 0);
e->probability = prob;
e->count = latch_edge->count * prob / REG_BR_PROB_BASE;
e = make_edge (switch_bb, FALLTHRU_EDGE (unswitch_on)->dest, EDGE_FALLTHRU);
e->probability = false_edge->probability;
e->count = latch_edge->count * (false_edge->probability) / REG_BR_PROB_BASE;
if (irred_flag)
{
switch_bb->flags |= BB_IRREDUCIBLE_LOOP;
EDGE_SUCC (switch_bb, 0)->flags |= EDGE_IRREDUCIBLE_LOOP;
EDGE_SUCC (switch_bb, 1)->flags |= EDGE_IRREDUCIBLE_LOOP;
}
else
{
switch_bb->flags &= ~BB_IRREDUCIBLE_LOOP;
EDGE_SUCC (switch_bb, 0)->flags &= ~EDGE_IRREDUCIBLE_LOOP;
EDGE_SUCC (switch_bb, 1)->flags &= ~EDGE_IRREDUCIBLE_LOOP;
}
/* Loopify from the copy of LOOP body, constructing the new loop. */
nloop = loopify (latch_edge,
single_pred_edge (get_bb_copy (loop->header)), switch_bb,
BRANCH_EDGE (switch_bb), FALLTHRU_EDGE (switch_bb), true,
prob, REG_BR_PROB_BASE - prob);
copy_loop_info (loop, nloop);
/* Remove branches that are now unreachable in new loops. */
remove_path (true_edge);
remove_path (false_edge);
/* Preserve the simple loop preheaders. */
split_edge (loop_preheader_edge (loop));
split_edge (loop_preheader_edge (nloop));
return nloop;
}
int cmd_rm(int argc, const char **argv, const char *prefix)
{
int i;
struct pathspec pathspec;
char *seen;
gitmodules_config();
git_config(git_default_config, NULL);
argc = parse_options(argc, argv, prefix, builtin_rm_options,
builtin_rm_usage, 0);
if (!argc)
usage_with_options(builtin_rm_usage, builtin_rm_options);
if (!index_only)
setup_work_tree();
hold_locked_index(&lock_file, 1);
if (read_cache() < 0)
die(_("index file corrupt"));
parse_pathspec(&pathspec, 0,
PATHSPEC_PREFER_CWD |
PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
prefix, argv);
refresh_index(&the_index, REFRESH_QUIET, &pathspec, NULL, NULL);
seen = xcalloc(pathspec.nr, 1);
for (i = 0; i < active_nr; i++) {
const struct cache_entry *ce = active_cache[i];
if (!ce_path_match(ce, &pathspec, seen))
continue;
ALLOC_GROW(list.entry, list.nr + 1, list.alloc);
list.entry[list.nr].name = xstrdup(ce->name);
list.entry[list.nr].is_submodule = S_ISGITLINK(ce->ce_mode);
if (list.entry[list.nr++].is_submodule &&
!is_staging_gitmodules_ok())
die (_("Please stage your changes to .gitmodules or stash them to proceed"));
}
if (pathspec.nr) {
const char *original;
int seen_any = 0;
for (i = 0; i < pathspec.nr; i++) {
original = pathspec.items[i].original;
if (!seen[i]) {
if (!ignore_unmatch) {
die(_("pathspec '%s' did not match any files"),
original);
}
}
else {
seen_any = 1;
}
if (!recursive && seen[i] == MATCHED_RECURSIVELY)
die(_("not removing '%s' recursively without -r"),
*original ? original : ".");
}
if (!seen_any)
exit(0);
}
/*
* If not forced, the file, the index and the HEAD (if exists)
* must match; but the file can already been removed, since
* this sequence is a natural "novice" way:
*
* rm F; git rm F
*
* Further, if HEAD commit exists, "diff-index --cached" must
* report no changes unless forced.
*/
if (!force) {
unsigned char sha1[20];
if (get_sha1("HEAD", sha1))
hashclr(sha1);
if (check_local_mod(sha1, index_only))
exit(1);
} else if (!index_only) {
if (check_submodules_use_gitfiles())
exit(1);
}
/*
* First remove the names from the index: we won't commit
* the index unless all of them succeed.
*/
for (i = 0; i < list.nr; i++) {
const char *path = list.entry[i].name;
if (!quiet)
printf("rm '%s'\n", path);
if (remove_file_from_cache(path))
die(_("git rm: unable to remove %s"), path);
}
if (show_only)
return 0;
/*
* Then, unless we used "--cached", remove the filenames from
* the workspace. If we fail to remove the first one, we
* abort the "git rm" (but once we've successfully removed
* any file at all, we'll go ahead and commit to it all:
* by then we've already committed ourselves and can't fail
* in the middle)
*/
if (!index_only) {
int removed = 0, gitmodules_modified = 0;
for (i = 0; i < list.nr; i++) {
const char *path = list.entry[i].name;
if (list.entry[i].is_submodule) {
if (is_empty_dir(path)) {
if (!rmdir(path)) {
removed = 1;
if (!remove_path_from_gitmodules(path))
gitmodules_modified = 1;
continue;
}
} else {
struct strbuf buf = STRBUF_INIT;
strbuf_addstr(&buf, path);
if (!remove_dir_recursively(&buf, 0)) {
removed = 1;
if (!remove_path_from_gitmodules(path))
gitmodules_modified = 1;
strbuf_release(&buf);
continue;
} else if (!file_exists(path))
/* Submodule was removed by user */
if (!remove_path_from_gitmodules(path))
gitmodules_modified = 1;
strbuf_release(&buf);
/* Fallthrough and let remove_path() fail. */
}
}
if (!remove_path(path)) {
removed = 1;
continue;
}
if (!removed)
die_errno("git rm: '%s'", path);
}
if (gitmodules_modified)
stage_updated_gitmodules();
}
if (active_cache_changed) {
if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
die(_("Unable to write new index file"));
}
return 0;
}
