<html>
  <head>

    <meta http-equiv="content-type" content="text/html; charset=utf-8">
  </head>
  <body bgcolor="#FFFFFF" text="#000000">
    <p>I'm working on enhancing EarlyCSE to use MemorySSA and have come
      across the following issue due to differences in EarlyCSE and
      MemorySSA's handling of !invariant.load.  EarlyCSE will *not*
      currently optimize the following code by replacing %x2 with %x and
      removing the second load:<br>
    </p>
    <blockquote>
      <p>B1:<br>
      </p>
      <p>  %x = load %p</p>
      <p>  clobber()<br>
      </p>
      ...<br>
      <br>
      B2: // dominated by B1<br>
      <br>
        %x2 = load %p !invariant.load<br>
    </blockquote>
    <br>
    Sanjoy (who added the !invariant.load support to EarlyCSE) and I
    discussed this, and I believe we are both in agreement that this
    optimization should be legal.  I'd like to make sure there is
    agreement on this and possibly clarify the LangRef wording on
    !invariant.load to make the legality of this transformation more
    clear.<br>
    <br>
    Sanjoy suggested the following:<br>
    <blockquote>Instead of "The existence
      of the !invariant.load metadata on the instruction tells the
      optimizer
      and code generator that the address operand to this load points to
      memory which can be assumed unchanged." we say "It is undefined
      behavior to invariant_load from a location that has been changed
      since
      it became dereferenceable".  In the current langref, I find "The
      existence" somewhat confusing, since it seems to imply that adding
      dead code can change the behavior of the program.<br>
      <br>
      I don't want to specify the semantics in a way that:<br>
      <br>
         int* ptr = ...<br>
         int k0 = *ptr; // normal load<br>
         clobber();<br>
         int k1 = *ptr; // normal load<br>
      <br>
       
      has a different meaning than<br>
      <br>
         int* ptr = ...<br>
         int k0 = *ptr; // normal load<br>
         clobber();<br>
         int k1 = *ptr; // normal load<br>
         if (<always false>) {<br>
           int k2 = *ptr; // !invariant load<br>
         }<br>
      <br>
       
      That is, adding dead code should not change the behavior of the<br>
       
      program -- the code guarded by (<always false>) should be
      able to have<br>
       
      any amount of junk without breaking the program, since it does not<br>
       
      actually execute.<br>
    </blockquote>
    <br>
    Does this seem like a clearer wording of the intended semantics?<br>
    <pre class="moz-signature" cols="72">-- 
Geoff Berry
Employee of Qualcomm Datacenter Technologies, Inc.
 Qualcomm Datacenter Technologies, Inc. as an affiliate of Qualcomm Technologies, Inc.  Qualcomm Technologies, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project.</pre>
  </body>
</html>