
	Where results make sense

Topic: Copy propagation

Related Topics

copy protection

carbon copy

copy and paste

copy editing

hard copy

Read copy update

copy editor

copy on write

Serial Copy Management System

Secure Copy Protocol

Deep copy

object copy

In the News (Thu 16 Feb 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	Constant folding - Wikipedia, the free encyclopedia
		A more advanced form of constant propagation known as sparse conditional constant propagation may be utilized to simultaneously remove dead code and more accurately propagate constants.
		In implementing a cross compiler, care must be taken to ensure that the behaviour of the arithmetic operations on the host architecture matches that on the target architecture, as otherwise enabling constant folding will change the behaviour of the program.
		Constant propagation can also cause conditional branches to simplify to one or more unconditional statements, when the conditional expression can be evaluated to true or false at compile time to determine the only possible outcome.
	en.wikipedia.org /wiki/Constant_folding (613 words)

	CopyPropagation < Pt < TWiki
		The goal of this assignment is to prepare the constant propagation implementation for the term rewrite system that is the target of the partial evaluator we are developing.
		After you have included the copy propagation of variables you are going to extend your code to copy propagate records with variables.
		Make sure the copy and constant propagation is working before you start with the copy propagation of records.
	www.cs.uu.nl /wiki/view/Pt/CopyPropagation?skin=print.pattern (856 words)

	[No title]
		;;; ;;; The SCs of the TN's primitive types is a subset of the SCs of the copied ;;; TN.
		When we see ;;; copy of a copy, we enter the first copy in the table with the second copy ;;; as a key.
		When we see a reference to a TN in a copy chain, we can only ;;; substitute the first copied TN for the reference when all intervening ;;; copies in the copy chain are also avaliable.
	www.cs.cmu.edu /afs/cs.cmu.edu/project/clisp/src/15/compiler/copyprop.lisp (1061 words)

	Tree SSA: tree-ssa-copy.c File Reference (Site not responding. Last check: 2007-10-12)
		Notice that while we make the LHS be 00827 a copy of the argument itself, we take the memory reference 00828 from the argument's value so that we can compare it to the 00829 memory reference of all the other arguments.
		Visit #1: x_54 is copy-of nothing (x_53 is a copy-of x_898 and x_52 is a copy of x_53, so they don't match) Visit #2: x_53 is copy-of nothing This problem is avoided by keeping a chain of copies, instead of the final copy-of value.
		Propagation would then proceed as follows (the notation a -> b means that a is a copy-of b): Visit #1: x_54 = PHI x_53 -> x_53 x_52 -> x_53 Result: x_54 -> x_53.
	people.redhat.com /dnovillo/pub/tree-ssa/doc/html/tree-ssa-copy_8c.html (3740 words)

	Compiler Optimization (Site not responding. Last check: 2007-10-12)
		The first is copy propagation, and the second is dead code elimination.
		Copy propagation needs only be done with one pass through the code.
		The output is the program after copy propagation and dead code elimination have been performed.
	www.eecis.udel.edu /~breech/contest.inet.spring.00/problems/compiler-opt.html (678 words)

	New Page 1 (Site not responding. Last check: 2007-10-12)
		Copy propagation is an analysis which identifies all points in the program to which the effect of the assignment reaches.
		That is, it identifiers all points in the program in which copy assignments are have been executed without intervening definitions of either "x" or "y".
		Describe how copy propagation can be computed using def-use chains, and show the results for this program.
	www.cs.cornell.edu /courses/cs612/2001sp/assignments/ps4 (277 words)

	Homework 4 (Site not responding. Last check: 2007-10-12)
		We have informally described the copy propagation optimization in class.
		Copy propagation is useful because it can create dead code, such as the first assignment to
		It is easy to do copy propagation within a basic block, but for the more general case of a control flow graph, we perform a dataflow analysis to determine which copy assignments reach uses of their left-hand variables without having either variable redefined.
	www.cs.cornell.edu /courses/cs412/2001sp/hw/hw4.html (614 words)

	Tree-SSA passes - GNU Compiler Collection (GCC) Internals
		When compiler temporaries are copies of user variables, it also renames the compiler temporary to the user variable resulting in better use of user symbols.
		This is similar to constant propagation but the lattice of values is the “copy-of” relation.
		This transformation is similar to constant propagation but instead of propagating single constant values, it propagates known value ranges.
	gcc.gnu.org /onlinedocs/gccint/Tree_002dSSA-passes.html (1899 words)

	: Package EDU.purdue.cs.bloat.trans
		Performs copy and constant propagation on the blocks in a control flow graph.
		Constant propagation removes unnecessary assignments by replacing variables that are assigned constant values with those values.
		Copy propagation removes unnecessary assignments to varibles to other variables.
	www.cs.purdue.edu /s3/projects/bloat/docs/api/EDU/purdue/cs/bloat/trans/package-summary.html (488 words)

	Scale Compiler Copy Propagation (Site not responding. Last check: 2007-10-12)
		Copy Propagation propagates the right argument of an assignment statement to the places where the left argument is used.
		Even in simple assignments we may not be able to perform the propagation successfully, if it is found that the variables aliased by the left argument and its use(s) have different SSA versions.
		In general, after the right argument of an assignment is propagated to all the uses of the left argument, the original assignment may be deleted.
	www-ali.cs.umass.edu /Scale/cp.html (230 words)

	Massimiliano Mantione's Blog (Site not responding. Last check: 2007-10-12)
		Copy propagation: This is the first step in eliminating unneeded variables: if a value is copied from A to B, then each time B is used copy propagation modifies the code to use A instead (of course, only until either A or B is assigned again!).
		Tree propagation: This is a code transformation that eliminates some variables completely from the JIT internal code representation.
		With the current register allocator, this means that their values will not be seen by the global regalloc, and will be handled directly by the local one.
	primates.ximian.com /~massi/blog/archive/2006/Mar-27.html (757 words)

	PGI \| Support \| Execution FAQ (Site not responding. Last check: 2007-10-12)
		The -Kieee switch may be used to disable propagating floating point values and to round the argument values passed to intrinsics (sin, cos, etc.).
		If copy propagation is disabled, stores of all left-hand sides will automatically be performed, and reloaded when needed.
		(Actually, copy propagation is only disabled for floating point operations, not integer,when the -Kieee switch is set.) Of course, with this particular example, setting the -pc switch will also adjust the result.
	www.pgroup.com /faq/execute.htm (2569 words)

	DevMaster.net - Linear Optimization
		But when this register was copy propagated, this means that also the previously allocated variable, which is the actual contained value, would not be written back to memory.
		Copy instructions skip this rule because we apply copy propagation and the register might not be used effectively after all, as described in the begin of this section.
		For example, load elimination is very simple in concept, but becomes harder when combined with copy propagation, spill elimination, etc. To prove it, we would have to identify the dependencies between the techniques, and show that for every operation related to register allocation, the total allocation state remains valid.
	www.devmaster.net /articles/linear-optimization (4475 words)

	Copy propagation without allocating registers - DevMaster.net Forums
		Copy propagation can identify the instructions that can be eliminated, but it can't avoid the allocation of these registers for the temporary variables.
		Whenever a register is copied to another, it assumes the first register won't be used again.
		It seems that copy propagation and load elimination are equivalent.
	www.devmaster.net /forums/showthread.php?t=2020 (2564 words)

	[No title]
		However since that which is * killed could be larger than the copy gen'd we need to make sure * we only kill parts of the copy, and not overflow into some other * copies bits.
		This makes the copy mask only represent that part * of the register actually involved in the copy.
		* * copy_in is the set of copies that reach this instruction.
	www.cs.cmu.edu /afs/cs.cmu.edu/project/cmcl/link.vcnectar/gnu960/src/gcc960/sun4/i_cp_prop.c (676 words)

	CS 701, Project 3 (Site not responding. Last check: 2007-10-12)
		Think about the order in which you process loops; an expression that is nested inside several loops should be moved out of as many of those loops as possible.
		Remember that copy propagation can create opportunities for loop-invariant code motion, so think about iterating these two optimizations for maximum effect.
		Please do not create any subdirectories in your handin directory, and be sure not to copy any object files or executable files (they take up a lot of space and may cause the directory to exceed its quota).
	www.cs.wisc.edu /~fischer/cs701.f01/proj3.html (776 words)

	Semple Analysis Engine: semple::analysis::ExpressionPropagation class Reference (Site not responding. Last check: 2007-10-12)
		Performs propagation of arbitrary expressions, as a generalization of both copy and constant propagation.
		This optimization permits the client to determine what particular expressions should be propagated.
		This function is only executed when the replacement is semantically correct; the client need only decide what replacement expressions should be propagated.
	www.cs.rpi.edu /~gregod/Semple/classsemple_1_1analysis_1_1ExpressionPropagation.html (274 words)

	Soot phase options
		Only propagate copies through ``regular'' locals, that is, those declared in the source bytecode.
		The first set in the pair stores new pointed-to objects that have not yet been propagated, while the second set stores old pointed-to objects that have been propagated and need not be reconsidered.
		When constructing a call graph on-the-fly during points-to analysis, Paddle normally propagates only those receivers that cause a method to be invoked to the this pointer of the method.
	www.sable.mcgill.ca /soot/tutorial/phase (8584 words)

	HF (high frequency) and VHF Radiowave Propagation Center: Live propagation and space weather data and forecasts (Site not responding. Last check: 2007-10-12)
		It is a "must read" for Radio Amateurs, Shortwave Listeners, and radio communicators of any type who need to make the most productive use of the radio spectrum, regardless of the time of day, the season of the year, or the state of the sunspot cycle.
		While many books cover RF propagation, most are geared to cellular telephone systems and, therefore, are limited in scope.
		In fact, it's the most comprehensive radio hobby magazine in the U.S. Packed with up-to-date information concisely written by the top writers in the field, Monitoring Times® is your foremost guide to profiles of broadcasting and communications installations; home projects; and tips on monitoring everything from air, sea, and space to distant ports of call.
	hfradio.org /propagation.html (1398 words)

	Copy Propagation (Site not responding. Last check: 2007-10-12)
		Copy propogation is similar to constant propagation, except we replace an expression with a variable instead of a constant.
		This is not beneficial in itself, but can lead to elimination of dead code and variables.
		The first statement could then be removed by dead code elimination on the assignment and component elimination on the variable if a was not used in any other places.
	users.chariot.net.au /~matty/ultra/optcat/Copy_Propagation.html (64 words)

	[No title] (Site not responding. Last check: 2007-10-12)
		This is so data type // info coming from suif is first propagated downward as far as possible.
		Start from the the op after the copy op and // scan until use.
		Now do the propagation if // possible by iterating over all reaching defs of s and their // uses and replacing operand s by operand r.
	www.eecs.umich.edu /~mahlke/583w04/homeworks/hw2/local_copy_propagate.cpp (929 words)

	Accurate Static Branch Prediction By Value Range Propagation (Site not responding. Last check: 2007-10-12)
		Heuristics are used as a fallback for cases where the value range of the variable cannot be determined statically.
		In the process, value range propagation subsumes both constant propagation and copy propagation.
		The value range propagation method can be implemented over any "factored" dataflow representation with a static single assignment property (such as SSA form or a dependence flow graph where the variables have been renamed to achieve single assignment).
	www.pattosoft.com.au /jason/Papers/ValueRangeProp (264 words)

	Comp.compilers: Re: Copy Propagation
		> 'x' is defined between the copy and the use of 'b'.
		Because they are distinct from the perspective of copies.
		You can see clearly that it is only a copy if b_1 and b_2 have the same
	compilers.iecc.com /comparch/article/05-03-006 (291 words)

	[No title] (Site not responding. Last check: 2007-10-12)
		Explain any changes that need to be made in the implementation of other language constructs and the runtime system (but don't worry about garbage collection at all).
		This question asks you to extend the global constant propagation algorithm given in class in two ways: (a) Recall local copy propagation, a local optimization similar to constant propagation.
		Extend the global constant propagation algorithm given in class to perform both constant and copy propagation.
	www.cs.berkeley.edu /~aiken/cs164.95/handouts/wasn4.txt (427 words)

	Comp.compilers: Linear-scan copy propagation
		Definition of the problem and goal: The purpose of copy propagation is
		the copy was not required and we could have continued to work with the
		propagated registers are good candidates for spilling themselves.
	compilers.iecc.com /comparch/article/03-11-046 (688 words)

	Red Hat \| GCC Optimization (Site not responding. Last check: 2007-10-12)
		GCC has both local and global copy propagation.
		This is similar to copy propagation, except that it applies to eliminating useless assignment operations involving constants.
		GCC uses weighted counts to allocate values into registers, which are used in more than once basic block.
	www.redhat.com /en_us/USA/home/gnupro/technicaldetails/gccoptimization (1168 words)

	[No title]
		Given copy statement x=y and use w=x, we can replace w=x with w=y only if the following conditions are met: x=y must be the only definition of x reaching w=x This can be determined through ud-chains There may be no definitions of y on any path from x=y to w=x.
		Given an assignment x = c, where c is a constant, replace later uses of x with uses of c, provided there are no intervening assignments to x.
		Similar to copy propagation Extra feature: It can analyze constant-value conditionals to determine whether a branch should be executed or not.
	www.cs.northwestern.edu /academics/courses/322/notes/14.ppt (888 words)

	Iterated Register Coalescing - George, Appel (ResearchIndex) (Site not responding. Last check: 2007-10-12)
		If your firewall is blocking outgoing connections to port 3125, you can use these links to download local copies.
		A good register allocator does copy propagation, eliminating many move instructions by "coloring" the source temporary and target temporary of a move with the same register.
		Having copy propagation in the register allocator often simplifies code generation.
	citeseer.ist.psu.edu /george96iterated.html (448 words)

	C-Breeze Compiler Infrastructure
		Note that copy statements with casts are ignored.
		References _bottom, _top, ambiguous, Block, procNode::body(), copyFlowVal::clone(), stmtNode::comment(), copies, create_copy_set(), create_kill_set(), defines, Gen, In, Kill, Label, local_copy_prop(), Out, solve_global_dataflow(), stmt_list, stmt_list_p, blockNode::stmts(), basicblockNode::succs(), copyFlowVal::to_bottom(), and procNode::walk().
		References _top, ambiguous, copyFlowVal::clone(), copies, idNode::decl(), defines, copyFlowVal::insert(), stmt_list_p, blockNode::stmts(), ThreeAddr, threeAddr_set, and threeAddr_set_p.
	www.cs.utexas.edu /users/c-breeze/html-with-pointers/classcopyPropChanger.html (368 words)

	[No title]
		Enables the following capabilities for performance gain: Constant propagation Copy propagation Dead-code elimination Global register allocation Global instruction scheduling and control speculation Loop unrolling Optimizes code selection Partial redundancy elimination Strength reduction/induction variable simplification Variable renaming Exception handling optimizations Tail recursions Peephole optimizations Structure assignment lowering and optimizations Dead store elimination ON by default.
		Enables the following optimizations: Inline function expansion Interprocedural constant propagation Monitoring module-level static variables Dead code elimination Propagation of function characteristics Multifile optimization Passing arguments in registers Loop-invariant code motion -prof_gen[x] Instructs the compiler to produce instrumented code in your object files in preparation for instrumented execution.
		Enables the following capabilities for performance gain: constant propagation copy propagation dead-code elimination global register allocation global instruction scheduling and control speculation loop unrolling optimized code selection partial redundancy elimination strength reduction/induction variable simplification variable renaming predication software pipelining -fp Disables the use of the ebp register in optimizations.
	www.spec.org /cpu/flags/AMD-20030421-ICC70-Linux.txt (1004 words)

Try your search on: Qwika (all wikis)