Skip to content
  1. Apr 18, 2011
  2. Apr 17, 2011
  3. Apr 15, 2011
  4. Apr 14, 2011
  5. Apr 13, 2011
  6. Apr 11, 2011
  7. Apr 09, 2011
  8. Apr 07, 2011
    • Bill Wendling's avatar
      Replace the old algorithm that emitted the "print the alias for an instruction" · bc3f7904
      Bill Wendling authored
      with the newer, cleaner model. It uses the IAPrinter class to hold the
      information that is needed to match an instruction with its alias. This also
      takes into account the available features of the platform.
      
      There is one bit of ugliness. The way the logic determines if a pattern is
      unique is O(N**2), which is gross. But in reality, the number of items it's
      checking against isn't large. So while it's N**2, it shouldn't be a massive time
      sink.
      
      llvm-svn: 129110
      bc3f7904
  9. Apr 06, 2011
  10. Apr 04, 2011
  11. Mar 31, 2011
  12. Mar 26, 2011
  13. Mar 24, 2011
  14. Mar 23, 2011
  15. Mar 22, 2011
  16. Mar 21, 2011
  17. Mar 19, 2011
    • Daniel Dunbar's avatar
      Revert r127953, "SimplifyCFG has stopped duplicating returns into predecessors · 327cd36f
      Daniel Dunbar authored
      to canonicalize IR", it broke a lot of things.
      
      llvm-svn: 127954
      327cd36f
    • Evan Cheng's avatar
      SimplifyCFG has stopped duplicating returns into predecessors to canonicalize IR · 824a7113
      Evan Cheng authored
      to have single return block (at least getting there) for optimizations. This
      is general goodness but it would prevent some tailcall optimizations.
      One specific case is code like this:
      int f1(void);
      int f2(void);
      int f3(void);
      int f4(void);
      int f5(void);
      int f6(void);
      int foo(int x) {
        switch(x) {
        case 1: return f1();
        case 2: return f2();
        case 3: return f3();
        case 4: return f4();
        case 5: return f5();
        case 6: return f6();
        }
      }
      
      =>
      LBB0_2:                                 ## %sw.bb
        callq   _f1
        popq    %rbp
        ret
      LBB0_3:                                 ## %sw.bb1
        callq   _f2
        popq    %rbp
        ret
      LBB0_4:                                 ## %sw.bb3
        callq   _f3
        popq    %rbp
        ret
      
      This patch teaches codegenprep to duplicate returns when the return value
      is a phi and where the phi operands are produced by tail calls followed by
      an unconditional branch:
      
      sw.bb7:                                           ; preds = %entry
        %call8 = tail call i32 @f5() nounwind
        br label %return
      sw.bb9:                                           ; preds = %entry
        %call10 = tail call i32 @f6() nounwind
        br label %return
      return:
        %retval.0 = phi i32 [ %call10, %sw.bb9 ], [ %call8, %sw.bb7 ], ... [ 0, %entry ]
        ret i32 %retval.0
      
      This allows codegen to generate better code like this:
      
      LBB0_2:                                 ## %sw.bb
              jmp     _f1                     ## TAILCALL
      LBB0_3:                                 ## %sw.bb1
              jmp     _f2                     ## TAILCALL
      LBB0_4:                                 ## %sw.bb3
              jmp     _f3                     ## TAILCALL
      
      rdar://9147433
      
      llvm-svn: 127953
      824a7113
    • Nadav Rotem's avatar
      Add support for legalizing UINT_TO_FP of vectors on platforms which do · e7a101cc
      Nadav Rotem authored
      not have native support for this operation (such as X86).
      The legalized code uses two vector INT_TO_FP operations and is faster
      than scalarizing.
      
      llvm-svn: 127951
      e7a101cc
Loading