Skip to content
  1. Oct 19, 2007
    • Evan Cheng's avatar
      Local spiller optimization: · 35ff7937
      Evan Cheng authored
      Turn a store folding instruction into a load folding instruction. e.g.
           xorl  %edi, %eax
           movl  %eax, -32(%ebp)
           movl  -36(%ebp), %eax
           orl   %eax, -32(%ebp)
      =>
           xorl  %edi, %eax
           orl   -36(%ebp), %eax
           mov   %eax, -32(%ebp)
      This enables the unfolding optimization for a subsequent instruction which will
      also eliminate the newly introduced store instruction.
      
      llvm-svn: 43192
      35ff7937
  2. Oct 13, 2007
    • Evan Cheng's avatar
      Local spiller optimization: · b6307650
      Evan Cheng authored
      Turn this:
      movswl  %ax, %eax
      movl    %eax, -36(%ebp)
      xorl    %edi, -36(%ebp)
      into
      movswl  %ax, %eax
      xorl    %edi, %eax
      movl    %eax, -36(%ebp)
      by unfolding the load / store xorl into an xorl and a store when we know the
      value in the spill slot is available in a register. This doesn't change the
      number of instructions but reduce the number of times memory is accessed.
      
      Also unfold some load folding instructions and reuse the value when similar
      situation presents itself.
      
      llvm-svn: 42947
      b6307650
  3. Oct 12, 2007
  4. Sep 26, 2007
  5. Sep 14, 2007
  6. Sep 06, 2007
    • David Greene's avatar
      · a6d5d2a6
      David Greene authored
      Add instruction dump output.  This helps find bugs.
      
      llvm-svn: 41744
      a6d5d2a6
  7. Aug 15, 2007
  8. Aug 14, 2007
  9. Jul 11, 2007
  10. Jun 19, 2007
    • Dan Gohman's avatar
      Replace M_REMATERIALIZIBLE and the newly-added isOtherReMaterializableLoad · 9e820649
      Dan Gohman authored
      with a general target hook to identify rematerializable instructions. Some
      instructions are only rematerializable with specific operands, such as loads
      from constant pools, while others are always rematerializable. This hook
      allows both to be identified as being rematerializable with the same
      mechanism.
      
      llvm-svn: 37644
      9e820649
  11. Jun 14, 2007
  12. Apr 26, 2007
  13. Apr 04, 2007
  14. Mar 30, 2007
  15. Mar 27, 2007
  16. Mar 20, 2007
  17. Mar 03, 2007
  18. Mar 02, 2007
  19. Mar 01, 2007
  20. Feb 25, 2007
  21. Feb 23, 2007
  22. Feb 21, 2007
  23. Feb 20, 2007
  24. Feb 08, 2007
    • Evan Cheng's avatar
      Fixed a long standing spiller bug that's exposed by Thumb: · 6ad6fdb7
      Evan Cheng authored
      The code sequence before the spiller is something like:
                       = tMOVrr
              %reg1117 = tMOVrr
              %reg1078 = tLSLri %reg1117, 2
      
      The it starts spilling:
              %r0 = tRestore <fi#5>, 0
              %r1 = tRestore <fi#7>, 0
              %r1 = tMOVrr %r1<kill>
              tSpill %r1, <fi#5>, 0
              %reg1078 = tLSLri %reg1117, 2
      
      It restores the value while processing the first tMOVrr. At this point, the
      spiller remembers fi#5 is available in %r0. Next it processes the second move.
      It restores the source before the move and spills the result afterwards. The
      move becomes a noop and is deleted. However, a spill has been inserted and that
      should invalidate reuse of %r0 for fi#5 and add reuse of %r1 for fi#5.
      Therefore, %reg1117 (which is also assigned fi#5) should get %r1, not %r0.
      
      llvm-svn: 34039
      6ad6fdb7
  25. Jan 23, 2007
  26. Jan 19, 2007
    • Evan Cheng's avatar
      GetRegForReload() now keeps track which registers have been considered and... · fc74e2de
      Evan Cheng authored
      GetRegForReload() now keeps track which registers have been considered and rejected during its quest to find a suitable reload register. This avoids an infinite loop in case like this:
        t1 := op t2, t3
        t2 <- assigned r0 for use by the reload but ended up reuse r1
        t3 <- assigned r1 for use by the reload but ended up reuse r0
        t1 <- desires r1
              sees r1 is taken by t2, tries t2's reload register r0
              sees r0 is taken by t3, tries t3's reload register r1
              sees r1 is taken by t2, tries t2's reload register r0 ...
      
      llvm-svn: 33382
      fc74e2de
  27. Dec 19, 2006
  28. Dec 17, 2006
  29. Dec 15, 2006
  30. Dec 14, 2006
    • Evan Cheng's avatar
      Fix a long-standing spiller bug: · 4c306ae0
      Evan Cheng authored
      If a spillslot value is available in a register, and there is a noop copy that
      targets that register, the spiller correctly decide not to invalidate the
      spillslot register.
      
      However, even though the noop copy does not clobbers the value. It does start a
      new intersecting live range. That means the spillslot register is available for
      use but should not be reused for a two-address instruction modref operand which
      would clobber the new live range.
      
      When we remove the noop copy, update the available information by clearing the
      canClobber bit.
      
      llvm-svn: 32576
      4c306ae0
Loading