Skip to content
  1. Jun 23, 2011
  3. Jun 18, 2011
  5. Jun 15, 2011
    • John McCall's avatar
      Add a new function attribute, nonlazybind, which inhibits lazy-loading · 4b7a8d68
      John McCall authored 
      optimizations when emitting calls to the function;  instead those calls may
use faster relocations which require the function to be immediately resolved
upon loading the dynamic object featuring the call.  This is useful when it
is known that the function will be called frequently and pervasively and
therefore there is no merit in delaying binding of the function.

Currently only implemented for x86-64, where it turns into a call through
the global offset table.

Patch by Dan Gohman, who assures me that he's going to add LangRef documentation
for this once it's committed.

llvm-svn: 133080
      4b7a8d68
  7. Jun 09, 2011
  9. Jun 07, 2011
  11. Jun 04, 2011
  13. Jun 03, 2011
  15. Jun 02, 2011
  17. Jun 01, 2011
  19. May 26, 2011
  21. May 24, 2011
  23. May 20, 2011
  25. May 19, 2011
  27. May 18, 2011
  29. May 17, 2011
  31. May 16, 2011
  33. May 11, 2011
    • Nadav Rotem's avatar
      · 8f971c27
      Nadav Rotem authored 
      Add custom lowering of X86 vector SRA/SRL/SHL when the shift amount is a splat vector.

llvm-svn: 131179
      8f971c27
  35. May 06, 2011
  37. Apr 20, 2011
  39. Apr 19, 2011
  41. Apr 15, 2011
  43. Mar 31, 2011
  45. Mar 26, 2011
  47. Mar 24, 2011
  49. Mar 23, 2011
  51. Mar 21, 2011
  53. 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