Structure Sharing Assumptions

The compiler assumes that certain kinds of RTL expressions are unique; there do not exist two distinct objects representing the same value. In other cases, it makes an opposite assumption: that no RTL expression object of a certain kind appears in more than one place in the containing structure.

These assumptions refer to a single function; except for the RTL objects that describe global variables and external functions, and a few standard objects such as small integer constants, no RTL objects are common to two functions.

• Each pseudo-register has only a single reg object to represent it, and therefore only a single machine mode.
• For any symbolic label, there is only one symbol_ref object referring to it.
• There is only one const_int expression with value 0, only one with value 1, and only one with value -1. Some other integer values are also stored uniquely.
• There is only one pc expression.
• There is only one cc0 expression.
• There is only one const_double expression with value 0 for each floating point mode. Likewise for values 1 and 2.
• No label_ref or scratch appears in more than one place in the RTL structure; in other words, it is safe to do a tree-walk of all the insns in the function and assume that each time a label_ref or scratch is seen it is distinct from all others that are seen.
• Only one mem object is normally created for each static variable or stack slot, so these objects are frequently shared in all the places they appear. However, separate but equal objects for these variables are occasionally made.
• When a single asm statement has multiple output operands, a distinct asm_operands expression is made for each output operand. However, these all share the vector which contains the sequence of input operands. This sharing is used later on to test whether two asm_operands expressions come from the same statement, so all optimizations must carefully preserve the sharing if they copy the vector at all.
• No RTL object appears in more than one place in the RTL structure except as described above. Many passes of the compiler rely on this by assuming that they can modify RTL objects in place without unwanted side-effects on other insns.
• During initial RTL generation, shared structure is freely introduced. After all the RTL for a function has been generated, all shared structure is copied by unshare_all_rtl in `emit-rtl.c', after which the above rules are guaranteed to be followed.
• During the combiner pass, shared structure within an insn can exist temporarily. However, the shared structure is copied before the combiner is finished with the insn. This is done by calling copy_rtx_if_shared, which is a subroutine of unshare_all_rtl.

Go to the first, previous, next, last section, table of contents.