Comparison mismatch causes assert using VStudio STL

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
28 messages Options
12
Reply | Threaded
Open this post in threaded view
|

Comparison mismatch causes assert using VStudio STL

Chuck Rose III

Hola LLVMers,

 

We saw a problem with some code in LiveIntervalAnalysis.h/.c which we’ve fixed locally.  We’d like to get a patch to the mainline and want to know how you’d like it fixed.  A couple of things come together to cause the problem:

 

  struct Idx2MBBCompare {

    bool operator()(const IdxMBBPair &LHS, const IdxMBBPair &RHS) const {

      return LHS.first < RHS.first;

    }

 

This comparator function compares the first elements of the IdxMBBPair.  This is in contrast to the default comparator for std::pairs, which compares the second element if the first elements are equal before making a final decision.  In this case, it makes a lot of sense given that the second in the pair is just a pointer.

 

In LiveIntervals::runOnMachineFunction, the map is sorted with this:

 

  std::sort(Idx2MBBMap.begin(), Idx2MBBMap.end(), Idx2MBBCompare());

 

Ok so far.

 

Here is where the problem arises:

 

    std::lower_bound(Idx2MBBMap.begin(), Idx2MBBMap.end(), LR.start);

 

By omitting the explicit comparator operator, the default is used which looks at second.  Not a huge problem in general, since you don’t really care that the pointers are sorted.

 

Visual Studio’s debug STL, however, is quite the stickler.  Debug lower_bound checks to see that the container is sorted and since lower_bound isn’t given a comparison function, it uses the default one which isn’t the one used to sort the container, and (boom!) it asserts if the memory stars aren’t aligned properly.

 

In our code we fixed this by ditching the Idx2MBBCompare operator and just added:

 

+  inline bool operator<(const IdxMBBPair &LHS, const IdxMBBPair &RHS) {

+    return (LHS.first < RHS.first);

+  }

 

The alternative is to make sure the Idx2MBBCompare is passed into the appropriate places.

 

How would you like this to be fixed?  I can tool it up, but I don’t want to step on someone else’s feet.

 

Thanks,

Chuck.

 

 

 

 

 

 


_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

LLVMBuilder vs LLVMFoldingBuilder

Dominic Hamon
Hello llvm dev peeps

I would like to use an LLVMBuilder pointer as a base pointer to
reference either an LLVMBuilder or an LLVMFoldingBuilder. As the methods
in the Folding builder have the same names as the base class, I thought
about submitting a patch whereby the base class methods would become
virtual. However, the base class methods return specific types while the
Folding builder, for good reason, return more general Value* types.

Would it be reasonable for me to submit a patch whereby the LLVMBuilder
methods also return the general Value* type and the LLVMFoldingBuilder
methods become virtual overrides of the base class methods?

Users (such as myself) could then decide at runtime which type of
builder they wish to use.

Another option that was discussed in #llvm is to nuke LLVMBuilder and
rename LLVMFoldingBuilder to LLVMBuilder. If this was the case, I'd
argue for a flag in the Builder that could retain the old non-folding
functionality for debugging purposes.

Your thoughts please?
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Comparison mismatch causes assert using VStudio STL

Evan Cheng-2
In reply to this post by Chuck Rose III

On Apr 2, 2008, at 9:32 AM, Chuck Rose III wrote:
Hola LLVMers,
 
We saw a problem with some code in LiveIntervalAnalysis.h/.c which we’ve fixed locally.  We’d like to get a patch to the mainline and want to know how you’d like it fixed.  A couple of things come together to cause the problem:
 
  struct Idx2MBBCompare {
    bool operator()(const IdxMBBPair &LHS, const IdxMBBPair &RHS) const {
      return LHS.first < RHS.first;
    }
 
This comparator function compares the first elements of the IdxMBBPair.  This is in contrast to the default comparator for std::pairs, which compares the second element if the first elements are equal before making a final decision.  In this case, it makes a lot of sense given that the second in the pair is just a pointer.
 
In LiveIntervals::runOnMachineFunction, the map is sorted with this:
 
  std::sort(Idx2MBBMap.begin(), Idx2MBBMap.end(), Idx2MBBCompare());
 
Ok so far.
 
Here is where the problem arises:
 
    std::lower_bound(Idx2MBBMap.begin(), Idx2MBBMap.end(), LR.start);
 
By omitting the explicit comparator operator, the default is used which looks at second.  Not a huge problem in general, since you don’t really care that the pointers are sorted.
 
Visual Studio’s debug STL, however, is quite the stickler.  Debug lower_bound checks to see that the container is sorted and since lower_bound isn’t given a comparison function, it uses the default one which isn’t the one used to sort the container, and (boom!) it asserts if the memory stars aren’t aligned properly.
 
In our code we fixed this by ditching the Idx2MBBCompare operator and just added:
 
+  inline bool operator<(const IdxMBBPair &LHS, const IdxMBBPair &RHS) {
+    return (LHS.first < RHS.first);
+  }

I think this is right fix for it. Any chance you can do some sanity testing? Please commit after you have run it though MultiSource portion of llvm test suite. Thanks!

Evan

 
The alternative is to make sure the Idx2MBBCompare is passed into the appropriate places.
 
How would you like this to be fixed?  I can tool it up, but I don’t want to step on someone else’s feet.
 
Thanks,
Chuck.
 
 
 
 
 
 
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev


_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: LLVMBuilder vs LLVMFoldingBuilder

Duncan Sands
In reply to this post by Dominic Hamon
Hi,

> Another option that was discussed in #llvm is to nuke LLVMBuilder and
> rename LLVMFoldingBuilder to LLVMBuilder. If this was the case, I'd
> argue for a flag in the Builder that could retain the old non-folding
> functionality for debugging purposes.

this plan sounds good to me.  However it's not clear to me how useful a
debug flag would really be.

Ciao,

Duncan.
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: LLVMBuilder vs LLVMFoldingBuilder

Dominic Hamon
Duncan Sands wrote:

>> Another option that was discussed in #llvm is to nuke LLVMBuilder and
>> rename LLVMFoldingBuilder to LLVMBuilder. If this was the case, I'd
>> argue for a flag in the Builder that could retain the old non-folding
>> functionality for debugging purposes.
>>    
>
> this plan sounds good to me.  However it's not clear to me how useful a
> debug flag would really be.
>
>  
I know that using the LLVMBuilder was useful to me in the early days of
my work with LLVM to see exactly how the IR matched with what I expected
it to given the input. It's only now that I'm working on global
variables that require ConstantExpr types for initialisers that I
started to use the LLVMFoldingBuilder.

I'll work on the patch and submit it here when it's ready.

Thanks
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: LLVMBuilder vs LLVMFoldingBuilder

Chris Lattner
In reply to this post by Dominic Hamon

On Apr 2, 2008, at 9:54 AM, Dominic Hamon wrote:

> Hello llvm dev peeps
>
> I would like to use an LLVMBuilder pointer as a base pointer to
> reference either an LLVMBuilder or an LLVMFoldingBuilder. As the  
> methods
> in the Folding builder have the same names as the base class, I  
> thought
> about submitting a patch whereby the base class methods would become
> virtual. However, the base class methods return specific types while  
> the
> Folding builder, for good reason, return more general Value* types.
>
> Would it be reasonable for me to submit a patch whereby the  
> LLVMBuilder
> methods also return the general Value* type and the LLVMFoldingBuilder
> methods become virtual overrides of the base class methods?

No, please don't do this.  The idea of llvmbuilder is that it is a  
"free" wrapper around the other existing API calls.  Making the  
methods virtual would make them much more expensive.

> Users (such as myself) could then decide at runtime which type of
> builder they wish to use.

Why do you want this?

> Another option that was discussed in #llvm is to nuke LLVMBuilder and
> rename LLVMFoldingBuilder to LLVMBuilder.

I'd strongly prefer this.  The non-folding builder is not very useful  
for anything, and anyone who wants unfolded instructions can call the  
instruction ctors directly.

> If this was the case, I'd
> argue for a flag in the Builder that could retain the old non-folding
> functionality for debugging purposes.

Why?

-Chris
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Joachim Durchholz

Am Donnerstag, den 03.04.2008, 19:29 -0700 schrieb Chris Lattner:
> On Apr 2, 2008, at 9:54 AM, Dominic Hamon wrote:
>
> > Would it be reasonable for me to submit a patch whereby [...] the
> > LLVMFoldingBuilder methods become virtual overrides of the base
> > class methods?
>
> No, please don't do this.  The idea of llvmbuilder is that it is a  
> "free" wrapper around the other existing API calls.  Making the  
> methods virtual would make them much more expensive.

Wouldn't the class of the objects be known at compile time in most
cases? This is essentially just a case of precomputing constants, so I
think this should be possible.

If yes, the compiler can predetermine the type, hence the virtual method
table that will be used, and can replace the virtual call with a static
one.

Does such an approach make sense with LLVM?
(I'd want to do such things for my personal language project, so the
answer would be affecting compilation strategy.)

Regards,
Jo

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: LLVMBuilder vs LLVMFoldingBuilder

Dominic Hamon
In reply to this post by Chris Lattner
Chris Lattner wrote:

> On Apr 2, 2008, at 9:54 AM, Dominic Hamon wrote:
>  
>> Would it be reasonable for me to submit a patch whereby the  
>> LLVMBuilder
>> methods also return the general Value* type and the LLVMFoldingBuilder
>> methods become virtual overrides of the base class methods?
>>    
>
> No, please don't do this.  The idea of llvmbuilder is that it is a  
> "free" wrapper around the other existing API calls.  Making the  
> methods virtual would make them much more expensive.
>
>  
Is this why the other API calls are all inline in the class? To avoid
the overhead of the function call?
>> Users (such as myself) could then decide at runtime which type of
>> builder they wish to use.
>>    
>
> Why do you want this?
>  
At the time that I was considering this, I saw that the Folding Builder
was a derived class of Builder and assumed, apparently wrongly, that the
intention was to create further derived versions of the Builder with
other potential optimisations.

If the Folding Builder is meant as a general replacement for the
Builder, then the second approach does make much more sense.

>> Another option that was discussed in #llvm is to nuke LLVMBuilder and
>> rename LLVMFoldingBuilder to LLVMBuilder.
>>    
>
> I'd strongly prefer this.  The non-folding builder is not very useful  
> for anything, and anyone who wants unfolded instructions can call the  
> instruction ctors directly.
>
>  
>> If this was the case, I'd
>> argue for a flag in the Builder that could retain the old non-folding
>> functionality for debugging purposes.
>>    
>
> Why?
>
>  
I used this non-folding functionality to create more explicit IR that I
could check against my input to my parser. It made debugging far easier
in the early stages of adding new parsing functionality.

Dom
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Chris Lattner
In reply to this post by Joachim Durchholz
On Fri, 4 Apr 2008, Joachim Durchholz wrote:

>> No, please don't do this.  The idea of llvmbuilder is that it is a
>> "free" wrapper around the other existing API calls.  Making the
>> methods virtual would make them much more expensive.
>
> Wouldn't the class of the objects be known at compile time in most
> cases? This is essentially just a case of precomputing constants, so I
> think this should be possible.
>
> If yes, the compiler can predetermine the type, hence the virtual method
> table that will be used, and can replace the virtual call with a static
> one.

Please verify that this actually happens in practice with llvm-gcc and
gcc.

-Chris

--
http://nondot.org/sabre/
http://llvm.org/
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Joachim Durchholz

Am Freitag, den 04.04.2008, 11:19 -0700 schrieb Chris Lattner:

> On Fri, 4 Apr 2008, Joachim Durchholz wrote:
> >> No, please don't do this.  The idea of llvmbuilder is that it is a
> >> "free" wrapper around the other existing API calls.  Making the
> >> methods virtual would make them much more expensive.
> >
> > Wouldn't the class of the objects be known at compile time in most
> > cases? This is essentially just a case of precomputing constants, so I
> > think this should be possible.
> >
> > If yes, the compiler can predetermine the type, hence the virtual method
> > table that will be used, and can replace the virtual call with a static
> > one.
>
> Please verify that this actually happens in practice with llvm-gcc and
> gcc.

If that's already the case (which I'll gladly believe), where does the
performance overhead for virtual functions come from?
(Just curious.)

Regards,
Jo

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Jonathan S. Shapiro-2
In general, the C++ compiler does NOT know the type of the leaf class
when performing a virtual method invocation. In particular, a parameter
(including "this") alleging to be a Foo* (Foo being some class) may
actually be any subclass of Foo, so unless the compiler can trace the
value flow all the way from the instantiation, it can't tell.

The necessary tracing is (a) hard, (b) whole-program, and (c) therefore
not supportable without a lot of linker support that isn't available in
practice.


On Fri, 2008-04-04 at 21:09 +0200, Joachim Durchholz wrote:

> Am Freitag, den 04.04.2008, 11:19 -0700 schrieb Chris Lattner:
> > On Fri, 4 Apr 2008, Joachim Durchholz wrote:
> > >> No, please don't do this.  The idea of llvmbuilder is that it is a
> > >> "free" wrapper around the other existing API calls.  Making the
> > >> methods virtual would make them much more expensive.
> > >
> > > Wouldn't the class of the objects be known at compile time in most
> > > cases? This is essentially just a case of precomputing constants, so I
> > > think this should be possible.
> > >
> > > If yes, the compiler can predetermine the type, hence the virtual method
> > > table that will be used, and can replace the virtual call with a static
> > > one.
> >
> > Please verify that this actually happens in practice with llvm-gcc and
> > gcc.
>
> If that's already the case (which I'll gladly believe), where does the
> performance overhead for virtual functions come from?
> (Just curious.)
>
> Regards,
> Jo
>
> _______________________________________________
> LLVM Developers mailing list
> [hidden email]         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Chris Lattner
In reply to this post by Joachim Durchholz
On Fri, 4 Apr 2008, Joachim Durchholz wrote:
>> Please verify that this actually happens in practice with llvm-gcc and
>> gcc.
>
> If that's already the case (which I'll gladly believe), where does the
> performance overhead for virtual functions come from?
> (Just curious.)

I don't understand what you're asking.  Please rephrase.

-Chris

--
http://nondot.org/sabre/
http://llvm.org/
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Joachim Durchholz

Am Freitag, den 04.04.2008, 13:06 -0700 schrieb Chris Lattner:
> On Fri, 4 Apr 2008, Joachim Durchholz wrote:
> >> Please verify that this actually happens in practice with llvm-gcc and
> >> gcc.
> >
> > If that's already the case (which I'll gladly believe), where does the
> > performance overhead for virtual functions come from?
> > (Just curious.)
>
> I don't understand what you're asking.  Please rephrase.

Rephrased answer going to Jonathan's post.

Regards,
Jo

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Joachim Durchholz
In reply to this post by Jonathan S. Shapiro-2
Am Freitag, den 04.04.2008, 15:19 -0400 schrieb Jonathan S. Shapiro:
> In general, the C++ compiler does NOT know the type of the leaf class
> when performing a virtual method invocation. In particular, a parameter
> (including "this") alleging to be a Foo* (Foo being some class) may
> actually be any subclass of Foo, so unless the compiler can trace the
> value flow all the way from the instantiation, it can't tell.

Right.

> The necessary tracing is (a) hard, (b) whole-program, and (c) therefore
> not supportable without a lot of linker support that isn't available in
> practice.

I'm not sure how hard (a) really is. It's being done in other imperative
OO languages, and quite successful there (the SmartEiffel folks have
reported they can eliminate the vtable lookup in about 90% of call
sites, reaping all the rewards of inlining etc. for these; you can
assume that practically all functions in Eiffel are declared virtual, in
fact you have to declare them nonvirtual if you want that and people
almost never do it).
In C++, integer-to-pointer tricks and array indexing via pointers could
make alias analysis more difficult. Is it that much harder that the
percentage of call sites to replace with static calls drops
significantly?

I agree with (b).

I agree with the "lot of linker support" bit in (c), but not quite with
the "isn't available in practice" part - isn't link-time optimization
one of LLVM's particular highlights?


I agree with Chris' reservations about virtual functions if a
gcc-compiled llvm-gcc is the norm.
If a bootstrapped llvm-gcc, compiled with itself, is the norm, *and*
alias analysis is good enough to deal with C++ as it is used in
llvm-gcc, then using virtual functions should not be a serious problem.


This all, of course, assuming I didn't overlook anything relevant.
Which is exactly my question: did I overlook something?

Oh, and this one, of course: are there ramifications for compilers that
use LLVM as a backend?
In particular: If a language makes any and all functions virtual, is
LLVM able to unvirtualize them (at the link stage, if necessary)?

Regards,
Jo

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Mike Stump
On Apr 4, 2008, at 3:59 PM, Joachim Durchholz wrote:
>
> I'm not sure how hard (a) really is. It's being done in other  
> imperative
> OO languages, and quite successful there (the SmartEiffel folks have
> reported they can eliminate the vtable lookup in about 90% of call
> sites,

Are those the folks that don't do separate compilation or dynamic  
libraries?  :-)
_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: Virtual methods (was: LLVMBuilder vs LLVMFoldingBuilder)

Joachim Durchholz

Am Freitag, den 04.04.2008, 16:18 -0700 schrieb Mike Stump:

> On Apr 4, 2008, at 3:59 PM, Joachim Durchholz wrote:
> >
> > I'm not sure how hard (a) really is. It's being done in other  
> > imperative
> > OO languages, and quite successful there (the SmartEiffel folks have
> > reported they can eliminate the vtable lookup in about 90% of call
> > sites,
>
> Are those the folks that don't do separate compilation or dynamic  
> libraries?  :-)

Exactly.
But then they don't have have the architecture for smart linking. (Well,
they didn't when I last looked, which was a few years ago.)

Regards,
Jo

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: LLVMBuilder vs LLVMFoldingBuilder

Dominic Hamon
In reply to this post by Duncan Sands
Duncan Sands wrote:

>> Another option that was discussed in #llvm is to nuke LLVMBuilder and
>> rename LLVMFoldingBuilder to LLVMBuilder. If this was the case, I'd
>> argue for a flag in the Builder that could retain the old non-folding
>> functionality for debugging purposes.
>>    
>
> this plan sounds good to me.  However it's not clear to me how useful a
> debug flag would really be.
>
>  
After further discussion in #llvm, and lots of compiling and
re-compiling, please find attached the first attempt at the patch with
this change. There are two patches attached, one for llvm and one for
llvm-gcc42.

Please note, there's quite a substantial API change in this patch:
LLVMBuilder has been renamed to IRBuilder and has absorbed the
constant-folding functionality from LLVMFoldingBuilder.

I've updated the tutorial html to refer to the correct includes and
classes and tweaked Chapter 4 in particular to explain the constant
folding optimizations rather than to explain how to use the
LLVMFoldingBuilder to improve the code generation and these changes are
included in the patch.

This is my first patch so please let me know if there are any problems
or anything I need to do differently.

Thanks




Property changes on: .
___________________________________________________________________
Name: svn:ignore
   + libstdc++-v3


Index: gcc/llvm-convert.cpp
===================================================================
--- gcc/llvm-convert.cpp (revision 49475)
+++ gcc/llvm-convert.cpp (working copy)
@@ -406,12 +406,12 @@
   struct FunctionPrologArgumentConversion : public DefaultABIClient {
     tree FunctionDecl;
     Function::arg_iterator &AI;
-    LLVMFoldingBuilder Builder;
+    IRBuilder Builder;
     std::vector<Value*> LocStack;
     std::vector<std::string> NameStack;
     FunctionPrologArgumentConversion(tree FnDecl,
                                      Function::arg_iterator &ai,
-                                     const LLVMFoldingBuilder &B)
+                                     const IRBuilder &B)
       : FunctionDecl(FnDecl), AI(ai), Builder(B) {}
     
     void setName(const std::string &Name) {
@@ -1251,7 +1251,7 @@
 /// CopyAggregate - Recursively traverse the potientially aggregate src/dest
 /// ptrs, copying all of the elements.
 static void CopyAggregate(MemRef DestLoc, MemRef SrcLoc,
-                          LLVMFoldingBuilder &Builder, tree gccType) {
+                          IRBuilder &Builder, tree gccType) {
   assert(DestLoc.Ptr->getType() == SrcLoc.Ptr->getType() &&
          "Cannot copy between two pointers of different type!");
   const Type *ElTy =
@@ -1341,7 +1341,7 @@
 
 /// ZeroAggregate - Recursively traverse the potentially aggregate DestLoc,
 /// zero'ing all of the elements.
-static void ZeroAggregate(MemRef DestLoc, LLVMFoldingBuilder &Builder) {
+static void ZeroAggregate(MemRef DestLoc, IRBuilder &Builder) {
   const Type *ElTy =
     cast<PointerType>(DestLoc.Ptr->getType())->getElementType();
   if (ElTy->isFirstClassType()) {
@@ -2308,7 +2308,7 @@
     const FunctionType *FTy;
     const MemRef *DestLoc;
     bool useReturnSlot;
-    LLVMFoldingBuilder &Builder;
+    IRBuilder &Builder;
     Value *TheValue;
     MemRef RetBuf;
     bool isShadowRet;
@@ -2318,7 +2318,7 @@
                                    const FunctionType *FnTy,
                                    const MemRef *destloc,
                                    bool ReturnSlotOpt,
-                                   LLVMFoldingBuilder &b)
+                                   IRBuilder &b)
       : CallOperands(ops), FTy(FnTy), DestLoc(destloc),
         useReturnSlot(ReturnSlotOpt), Builder(b), isShadowRet(false),
         isAggrRet(false) { }
Index: gcc/llvm-internal.h
===================================================================
--- gcc/llvm-internal.h (revision 49475)
+++ gcc/llvm-internal.h (working copy)
@@ -37,7 +37,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include "llvm/Support/Streams.h"
 
 extern "C" {
@@ -279,7 +279,7 @@
 
   /// Builder - Instruction creator, the location to insert into is always the
   /// same as &Fn->back().
-  LLVMFoldingBuilder Builder;
+  IRBuilder Builder;
 
   // AllocaInsertionPoint - Place to insert alloca instructions.  Lazily created
   // and managed by CreateTemporary.

Index: include/llvm/Support/LLVMBuilder.h
===================================================================
--- include/llvm/Support/LLVMBuilder.h (revision 49474)
+++ include/llvm/Support/LLVMBuilder.h (working copy)
@@ -1,780 +0,0 @@
-//===-- llvm/Support/LLVMBuilder.h - Builder for LLVM Instrs ----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the LLVMBuilder class, which is used as a convenient way
-// to create LLVM instructions with a consistent and simplified interface.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_LLVMBUILDER_H
-#define LLVM_SUPPORT_LLVMBUILDER_H
-
-#include "llvm/BasicBlock.h"
-#include "llvm/Instructions.h"
-#include "llvm/Constants.h"
-
-namespace llvm {
-
-/// LLVMBuilder - This provides a uniform API for creating instructions and
-/// inserting them into a basic block: either at the end of a BasicBlock, or
-/// at a specific iterator location in a block.
-///
-/// Note that the builder does not expose the full generality of LLVM
-/// instructions.  For example, it cannot be used to create instructions with
-/// arbitrary names (specifically, names with nul characters in them) - It only
-/// supports nul-terminated C strings.  For fully generic names, use
-/// I->setName().  For access to extra instruction properties, use the mutators
-/// (e.g. setVolatile) on the instructions after they have been created.
-class LLVMBuilder {
-  BasicBlock *BB;
-  BasicBlock::iterator InsertPt;
-public:
-  LLVMBuilder() { ClearInsertionPoint(); }
-  explicit LLVMBuilder(BasicBlock *TheBB) { SetInsertPoint(TheBB); }
-  LLVMBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) {
-    SetInsertPoint(TheBB, IP);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Builder configuration methods
-  //===--------------------------------------------------------------------===//
-
-  /// ClearInsertionPoint - Clear the insertion point: created instructions will
-  /// not be inserted into a block.
-  void ClearInsertionPoint() {
-    BB = 0;
-  }
-  
-  BasicBlock *GetInsertBlock() const { return BB; }
-  
-  /// SetInsertPoint - This specifies that created instructions should be
-  /// appended to the end of the specified block.
-  void SetInsertPoint(BasicBlock *TheBB) {
-    BB = TheBB;
-    InsertPt = BB->end();
-  }
-  
-  /// SetInsertPoint - This specifies that created instructions should be
-  /// inserted at the specified point.
-  void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
-    BB = TheBB;
-    InsertPt = IP;
-  }
-  
-  /// Insert - Insert and return the specified instruction.
-  template<typename InstTy>
-  InstTy *Insert(InstTy *I) const {
-    InsertHelper(I);
-    return I;
-  }
-  
-  /// InsertHelper - Insert the specified instruction at the specified insertion
-  /// point.  This is split out of Insert so that it isn't duplicated for every
-  /// template instantiation.
-  void InsertHelper(Instruction *I) const {
-    if (BB) BB->getInstList().insert(InsertPt, I);
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Terminators
-  //===--------------------------------------------------------------------===//
-
-  /// CreateRetVoid - Create a 'ret void' instruction.
-  ReturnInst *CreateRetVoid() {
-    return Insert(ReturnInst::Create());
-  }
-
-  /// @verbatim
-  /// CreateRet - Create a 'ret <val>' instruction.
-  /// @endverbatim
-  ReturnInst *CreateRet(Value *V) {
-    return Insert(ReturnInst::Create(V));
-  }
-
-  ReturnInst *CreateRet(Value * const* retVals, unsigned N) {
-    return Insert(ReturnInst::Create(retVals,  N));
-  }
-
-  GetResultInst *CreateGetResult(Value *V, unsigned Index, const char *Name = "") {
-    return Insert(new GetResultInst(V, Index, Name));
-  }
-
-  /// CreateBr - Create an unconditional 'br label X' instruction.
-  BranchInst *CreateBr(BasicBlock *Dest) {
-    return Insert(BranchInst::Create(Dest));
-  }
-
-  /// CreateCondBr - Create a conditional 'br Cond, TrueDest, FalseDest'
-  /// instruction.
-  BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) {
-    return Insert(BranchInst::Create(True, False, Cond));
-  }
-  
-  /// CreateSwitch - Create a switch instruction with the specified value,
-  /// default dest, and with a hint for the number of cases that will be added
-  /// (for efficient allocation).
-  SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) {
-    return Insert(SwitchInst::Create(V, Dest, NumCases));
-  }
-  
-  /// CreateInvoke - Create an invoke instruction.
-  template<typename InputIterator>
-  InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
-                           BasicBlock *UnwindDest, InputIterator ArgBegin,
-                           InputIterator ArgEnd, const char *Name = "") {
-    return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest,
-                                     ArgBegin, ArgEnd, Name));
-  }
-  
-  UnwindInst *CreateUnwind() {
-    return Insert(new UnwindInst());
-  }
-
-  UnreachableInst *CreateUnreachable() {
-    return Insert(new UnreachableInst());
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Binary Operators
-  //===--------------------------------------------------------------------===//
-
-  BinaryOperator *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createAdd(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createSub(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createMul(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createUDiv(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createSDiv(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createFDiv(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createURem(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createSRem(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createFRem(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createShl(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createLShr(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createAShr(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createAnd(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createOr(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createXor(LHS, RHS, Name));
-  }
-
-  BinaryOperator *CreateBinOp(Instruction::BinaryOps Opc,
-                              Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::create(Opc, LHS, RHS, Name));
-  }
-  
-  BinaryOperator *CreateNeg(Value *V, const char *Name = "") {
-    return Insert(BinaryOperator::createNeg(V, Name));
-  }
-  BinaryOperator *CreateNot(Value *V, const char *Name = "") {
-    return Insert(BinaryOperator::createNot(V, Name));
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Memory Instructions
-  //===--------------------------------------------------------------------===//
-  
-  MallocInst *CreateMalloc(const Type *Ty, Value *ArraySize = 0,
-                           const char *Name = "") {
-    return Insert(new MallocInst(Ty, ArraySize, Name));
-  }
-  AllocaInst *CreateAlloca(const Type *Ty, Value *ArraySize = 0,
-                           const char *Name = "") {
-    return Insert(new AllocaInst(Ty, ArraySize, Name));
-  }
-  FreeInst *CreateFree(Value *Ptr) {
-    return Insert(new FreeInst(Ptr));
-  }
-  LoadInst *CreateLoad(Value *Ptr, const char *Name = 0) {
-    return Insert(new LoadInst(Ptr, Name));
-  }
-  LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const char *Name = 0) {
-    return Insert(new LoadInst(Ptr, Name, isVolatile));
-  }
-  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
-    return Insert(new StoreInst(Val, Ptr, isVolatile));
-  }
-  template<typename InputIterator>
-  GetElementPtrInst *CreateGEP(Value *Ptr, InputIterator IdxBegin,
-                               InputIterator IdxEnd, const char *Name = "") {
-    return(Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd, Name)));
-  }
-  GetElementPtrInst *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
-    return Insert(GetElementPtrInst::Create(Ptr, Idx, Name));
-  }
-  GetElementPtrInst *CreateStructGEP(Value *Ptr, unsigned Idx,
-                                     const char *Name = "") {
-    llvm::Value *Idxs[] = {
-      ConstantInt::get(llvm::Type::Int32Ty, 0),
-      ConstantInt::get(llvm::Type::Int32Ty, Idx)
-    };
-    return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2, Name));
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Cast/Conversion Operators
-  //===--------------------------------------------------------------------===//
-  
-  TruncInst *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
-    return Insert(new TruncInst(V, DestTy, Name));
-  }
-  ZExtInst *CreateZExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return Insert(new ZExtInst(V, DestTy, Name));
-  }
-  SExtInst *CreateSExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return Insert(new SExtInst(V, DestTy, Name));
-  }
-  FPToUIInst *CreateFPToUI(Value *V, const Type *DestTy, const char *Name = ""){
-    return Insert(new FPToUIInst(V, DestTy, Name));
-  }
-  FPToSIInst *CreateFPToSI(Value *V, const Type *DestTy, const char *Name = ""){
-    return Insert(new FPToSIInst(V, DestTy, Name));
-  }
-  UIToFPInst *CreateUIToFP(Value *V, const Type *DestTy, const char *Name = ""){
-    return Insert(new UIToFPInst(V, DestTy, Name));
-  }
-  SIToFPInst *CreateSIToFP(Value *V, const Type *DestTy, const char *Name = ""){
-    return Insert(new SIToFPInst(V, DestTy, Name));
-  }
-  FPTruncInst *CreateFPTrunc(Value *V, const Type *DestTy,
-                             const char *Name = "") {
-    return Insert(new FPTruncInst(V, DestTy, Name));
-  }
-  FPExtInst *CreateFPExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return Insert(new FPExtInst(V, DestTy, Name));
-  }
-  PtrToIntInst *CreatePtrToInt(Value *V, const Type *DestTy,
-                               const char *Name = "") {
-    return Insert(new PtrToIntInst(V, DestTy, Name));
-  }
-  IntToPtrInst *CreateIntToPtr(Value *V, const Type *DestTy,
-                               const char *Name = "") {
-    return Insert(new IntToPtrInst(V, DestTy, Name));
-  }
-  BitCastInst *CreateBitCast(Value *V, const Type *DestTy,
-                             const char *Name = "") {
-    return Insert(new BitCastInst(V, DestTy, Name));
-  }
-  
-  CastInst *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy,
-                       const char *Name = "") {
-    return Insert(CastInst::create(Op, V, DestTy, Name));
-  }
-  CastInst *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
-                          const char *Name = "") {
-    return Insert(CastInst::createIntegerCast(V, DestTy, isSigned, Name));
-  }
-  
-  
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Compare Instructions
-  //===--------------------------------------------------------------------===//
-  
-  ICmpInst *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_EQ, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_NE, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_UGT, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_UGE, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_ULT, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_ULE, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_SGT, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_SGE, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_SLT, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_SLE, LHS, RHS, Name));
-  }
-  
-  FCmpInst *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OEQ, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OGT, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OGE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OLT, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OLE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_ONE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_ORD, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UNO, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UEQ, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UGT, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UGE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_ULT, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_ULE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UNE, LHS, RHS, Name));
-  }
-  
-  
-  ICmpInst *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS,
-                       const char *Name = "") {
-    return Insert(new ICmpInst(P, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS,
-                       const char *Name = "") {
-    return Insert(new FCmpInst(P, LHS, RHS, Name));
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Other Instructions
-  //===--------------------------------------------------------------------===//
-  
-  PHINode *CreatePHI(const Type *Ty, const char *Name = "") {
-    return Insert(PHINode::Create(Ty, Name));
-  }
-
-  CallInst *CreateCall(Value *Callee, const char *Name = "") {
-    return Insert(CallInst::Create(Callee, Name));
-  }
-  CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") {
-    return Insert(CallInst::Create(Callee, Arg, Name));
-  }
-
-  template<typename InputIterator>
-  CallInst *CreateCall(Value *Callee, InputIterator ArgBegin,
-                       InputIterator ArgEnd, const char *Name = "") {
-    return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd, Name));
-  }
-  
-  SelectInst *CreateSelect(Value *C, Value *True, Value *False,
-                           const char *Name = "") {
-    return Insert(SelectInst::Create(C, True, False, Name));
-  }
-  
-  VAArgInst *CreateVAArg(Value *List, const Type *Ty, const char *Name = "") {
-    return Insert(new VAArgInst(List, Ty, Name));
-  }
-  
-  ExtractElementInst *CreateExtractElement(Value *Vec, Value *Idx,
-                                           const char *Name = "") {
-    return Insert(new ExtractElementInst(Vec, Idx, Name));
-  }
-  
-  InsertElementInst *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
-                                         const char *Name = "") {
-    return Insert(InsertElementInst::Create(Vec, NewElt, Idx, Name));
-  }
-  
-  ShuffleVectorInst *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
-                                         const char *Name = "") {
-    return Insert(new ShuffleVectorInst(V1, V2, Mask, Name));
-  }
-};
-
-/// LLVMFoldingBuilder - A version of LLVMBuilder that constant folds operands
-/// as they come in.
-class LLVMFoldingBuilder : public LLVMBuilder {
-    
-public:
-  LLVMFoldingBuilder() {}
-  explicit LLVMFoldingBuilder(BasicBlock *TheBB)
-    : LLVMBuilder(TheBB) {}
-  LLVMFoldingBuilder(BasicBlock *TheBB, BasicBlock::iterator IP)
-    : LLVMBuilder(TheBB, IP) {}
-
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Binary Operators
-  //===--------------------------------------------------------------------===//
-
-  Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getAdd(LC, RC);
-    return LLVMBuilder::CreateAdd(LHS, RHS, Name);
-  }
-
-  Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getSub(LC, RC);
-    return LLVMBuilder::CreateSub(LHS, RHS, Name);
-  }
-
-  Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getMul(LC, RC);
-    return LLVMBuilder::CreateMul(LHS, RHS, Name);
-  }
-
-  Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getUDiv(LC, RC);
-    return LLVMBuilder::CreateUDiv(LHS, RHS, Name);
-  }
-
-  Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getSDiv(LC, RC);
-    return LLVMBuilder::CreateSDiv(LHS, RHS, Name);
-  }
-
-  Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getFDiv(LC, RC);
-    return LLVMBuilder::CreateFDiv(LHS, RHS, Name);
-  }
-
-  Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getURem(LC, RC);
-    return LLVMBuilder::CreateURem(LHS, RHS, Name);
-  }
-
-  Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getSRem(LC, RC);
-    return LLVMBuilder::CreateSRem(LHS, RHS, Name);
-  }
-
-  Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getFRem(LC, RC);
-    return LLVMBuilder::CreateFRem(LHS, RHS, Name);
-  }
-
-  Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getAnd(LC, RC);
-    return LLVMBuilder::CreateAnd(LHS, RHS, Name);
-  }
-
-  Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getOr(LC, RC);
-    return LLVMBuilder::CreateOr(LHS, RHS, Name);
-  }
-
-  Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getXor(LC, RC);
-    return LLVMBuilder::CreateXor(LHS, RHS, Name);
-  }
-
-  Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getShl(LC, RC);
-    return LLVMBuilder::CreateShl(LHS, RHS, Name);
-  }
-
-  Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getLShr(LC, RC);
-    return LLVMBuilder::CreateLShr(LHS, RHS, Name);
-  }
-
-  Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getAShr(LC, RC);
-    return LLVMBuilder::CreateAShr(LHS, RHS, Name);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Memory Instructions
-  //===--------------------------------------------------------------------===//
-
-  template<typename InputIterator>
-  Value *CreateGEP(Value *Ptr, InputIterator IdxBegin,
-                   InputIterator IdxEnd, const char *Name = "") {
-    
-    if (Constant *PC = dyn_cast<Constant>(Ptr)) {
-      // Every index must be constant.
-      InputIterator i;
-      for (i = IdxBegin; i < IdxEnd; ++i)
-        if (!dyn_cast<Constant>(*i))
-          break;
-      if (i == IdxEnd)
-        return ConstantExpr::getGetElementPtr(PC, &IdxBegin[0], IdxEnd - IdxBegin);
-    }
-    return LLVMBuilder::CreateGEP(Ptr, IdxBegin, IdxEnd, Name);
-  }
-  Value *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
-    if (Constant *PC = dyn_cast<Constant>(Ptr))
-      if (Constant *IC = dyn_cast<Constant>(Idx))
-        return ConstantExpr::getGetElementPtr(PC, &IC, 1);
-    return LLVMBuilder::CreateGEP(Ptr, Idx, Name);
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Cast/Conversion Operators
-  //===--------------------------------------------------------------------===//
-  
-  Value *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
-    return CreateCast(Instruction::Trunc, V, DestTy, Name);
-  }
-  Value *CreateZExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return CreateCast(Instruction::ZExt, V, DestTy, Name);
-  }
-  Value *CreateSExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return CreateCast(Instruction::SExt, V, DestTy, Name);
-  }
-  Value *CreateFPToUI(Value *V, const Type *DestTy, const char *Name = ""){
-    return CreateCast(Instruction::FPToUI, V, DestTy, Name);
-  }
-  Value *CreateFPToSI(Value *V, const Type *DestTy, const char *Name = ""){
-    return CreateCast(Instruction::FPToSI, V, DestTy, Name);
-  }
-  Value *CreateUIToFP(Value *V, const Type *DestTy, const char *Name = ""){
-    return CreateCast(Instruction::UIToFP, V, DestTy, Name);
-  }
-  Value *CreateSIToFP(Value *V, const Type *DestTy, const char *Name = ""){
-    return CreateCast(Instruction::SIToFP, V, DestTy, Name);
-  }
-  Value *CreateFPTrunc(Value *V, const Type *DestTy,
-                       const char *Name = "") {
-    return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
-  }
-  Value *CreateFPExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return CreateCast(Instruction::FPExt, V, DestTy, Name);
-  }
-  Value *CreatePtrToInt(Value *V, const Type *DestTy,
-                        const char *Name = "") {
-    return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
-  }
-  Value *CreateIntToPtr(Value *V, const Type *DestTy,
-                        const char *Name = "") {
-    return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
-  }
-  Value *CreateBitCast(Value *V, const Type *DestTy,
-                       const char *Name = "") {
-    return CreateCast(Instruction::BitCast, V, DestTy, Name);
-  }
-
-  Value *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy,
-                    const char *Name = "") {
-    if (V->getType() == DestTy)
-      return V;
-    if (Constant *VC = dyn_cast<Constant>(V))
-      return ConstantExpr::getCast(Op, VC, DestTy);
-    return LLVMBuilder::CreateCast(Op, V, DestTy, Name);
-  }
-  Value *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
-                       const char *Name = "") {
-    if (V->getType() == DestTy)
-      return V;
-    if (Constant *VC = dyn_cast<Constant>(V))
-      return ConstantExpr::getIntegerCast(VC, DestTy, isSigned);
-    return LLVMBuilder::CreateIntCast(V, DestTy, isSigned, Name);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Compare Instructions
-  //===--------------------------------------------------------------------===//
-  
-  Value *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
-  }
-  Value *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
-  }
-  Value *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
-  }
-  Value *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
-  }
-  Value *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
-  }
-  Value *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
-  }
-  Value *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
-  }
-  Value *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
-  }
-  Value *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
-  }
-  Value *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
-  }
-
-  Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name);
-  }
-  Value *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name);
-  }
-  Value *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name);
-  }
-  Value *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name);
-  }
-  Value *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name);
-  }
-  
-  Value *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS,
-                    const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getCompare(P, LC, RC);
-    return LLVMBuilder::CreateICmp(P, LHS, RHS, Name);
-  }
-
-  Value *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS,
-                    const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getCompare(P, LC, RC);
-    return LLVMBuilder::CreateFCmp(P, LHS, RHS, Name);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Other Instructions
-  //===--------------------------------------------------------------------===//
-  
-  Value *CreateSelect(Value *C, Value *True, Value *False,
-                      const char *Name = "") {
-    if (Constant *CC = dyn_cast<Constant>(C))
-      if (Constant *TC = dyn_cast<Constant>(True))
-        if (Constant *FC = dyn_cast<Constant>(False))
-          return ConstantExpr::getSelect(CC, TC, FC);
-    return LLVMBuilder::CreateSelect(C, True, False, Name);
-  }
-  
-  Value *CreateExtractElement(Value *Vec, Value *Idx,
-                              const char *Name = "") {
-    if (Constant *VC = dyn_cast<Constant>(Vec))
-      if (Constant *IC = dyn_cast<Constant>(Idx))
-        return ConstantExpr::getExtractElement(VC, IC);
-    return LLVMBuilder::CreateExtractElement(Vec, Idx, Name);
-  }
-  
-  Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
-                             const char *Name = "") {
-    if (Constant *VC = dyn_cast<Constant>(Vec))
-      if (Constant *NC = dyn_cast<Constant>(NewElt))
-        if (Constant *IC = dyn_cast<Constant>(Idx))
-          return ConstantExpr::getInsertElement(VC, NC, IC);
-    return LLVMBuilder::CreateInsertElement(Vec, NewElt, Idx, Name);
-  }
-  
-  Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
-                             const char *Name = "") {
-    if (Constant *V1C = dyn_cast<Constant>(V1))
-      if (Constant *V2C = dyn_cast<Constant>(V2))
-        if (Constant *MC = dyn_cast<Constant>(Mask))
-          return ConstantExpr::getShuffleVector(V1C, V2C, MC);
-    return LLVMBuilder::CreateShuffleVector(V1, V2, Mask, Name);
-  }
-};
-  
-}
-
-#endif
Index: include/llvm/Support/IRBuilder.h
===================================================================
--- include/llvm/Support/IRBuilder.h (revision 0)
+++ include/llvm/Support/IRBuilder.h (revision 0)
@@ -0,0 +1,525 @@
+//===-- llvm/Support/FoldingBuilder.h - Builder for LLVM Instrs ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the IRBuilder class, which is used as a convenient way
+// to create LLVM instructions with a consistent and simplified interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_IRBUILDER_H
+#define LLVM_SUPPORT_IRBUILDER_H
+
+#include "llvm/BasicBlock.h"
+#include "llvm/Instructions.h"
+#include "llvm/Constants.h"
+
+namespace llvm {
+
+/// FoldingBuilder - This provides a uniform API for creating instructions and
+/// inserting them into a basic block: either at the end of a BasicBlock, or
+/// at a specific iterator location in a block.
+///
+/// Note that the builder does not expose the full generality of LLVM
+/// instructions.  For example, it cannot be used to create instructions with
+/// arbitrary names (specifically, names with nul characters in them) - It only
+/// supports nul-terminated C strings.  For fully generic names, use
+/// I->setName().  For access to extra instruction properties, use the mutators
+/// (e.g. setVolatile) on the instructions after they have been created.
+class IRBuilder {
+  BasicBlock *BB;
+  BasicBlock::iterator InsertPt;
+public:
+  IRBuilder() { ClearInsertionPoint(); }
+  explicit IRBuilder(BasicBlock *TheBB) { SetInsertPoint(TheBB); }
+  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) {
+    SetInsertPoint(TheBB, IP);
+  }
+
+  //===--------------------------------------------------------------------===//
+  // Builder configuration methods
+  //===--------------------------------------------------------------------===//
+
+  /// ClearInsertionPoint - Clear the insertion point: created instructions will
+  /// not be inserted into a block.
+  void ClearInsertionPoint() {
+    BB = 0;
+  }
+  
+  BasicBlock *GetInsertBlock() const { return BB; }
+  
+  /// SetInsertPoint - This specifies that created instructions should be
+  /// appended to the end of the specified block.
+  void SetInsertPoint(BasicBlock *TheBB) {
+    BB = TheBB;
+    InsertPt = BB->end();
+  }
+  
+  /// SetInsertPoint - This specifies that created instructions should be
+  /// inserted at the specified point.
+  void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
+    BB = TheBB;
+    InsertPt = IP;
+  }
+  
+  /// Insert - Insert and return the specified instruction.
+  template<typename InstTy>
+  InstTy *Insert(InstTy *I) const {
+    InsertHelper(I);
+    return I;
+  }
+  
+  /// InsertHelper - Insert the specified instruction at the specified insertion
+  /// point.  This is split out of Insert so that it isn't duplicated for every
+  /// template instantiation.
+  void InsertHelper(Instruction *I) const {
+    if (BB) BB->getInstList().insert(InsertPt, I);
+  }
+  
+  //===--------------------------------------------------------------------===//
+  // Instruction creation methods: Terminators
+  //===--------------------------------------------------------------------===//
+
+  /// CreateRetVoid - Create a 'ret void' instruction.
+  ReturnInst *CreateRetVoid() {
+    return Insert(ReturnInst::Create());
+  }
+
+  /// @verbatim
+  /// CreateRet - Create a 'ret <val>' instruction.
+  /// @endverbatim
+  ReturnInst *CreateRet(Value *V) {
+    return Insert(ReturnInst::Create(V));
+  }
+
+  ReturnInst *CreateRet(Value * const* retVals, unsigned N) {
+    return Insert(ReturnInst::Create(retVals,  N));
+  }
+  
+  GetResultInst *CreateGetResult(Value *V, unsigned Index, const char *Name = "") {
+    return Insert(new GetResultInst(V, Index, Name));
+  }
+    
+  /// CreateBr - Create an unconditional 'br label X' instruction.
+  BranchInst *CreateBr(BasicBlock *Dest) {
+    return Insert(BranchInst::Create(Dest));
+  }
+
+  /// CreateCondBr - Create a conditional 'br Cond, TrueDest, FalseDest'
+  /// instruction.
+  BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) {
+    return Insert(BranchInst::Create(True, False, Cond));
+  }
+  
+  /// CreateSwitch - Create a switch instruction with the specified value,
+  /// default dest, and with a hint for the number of cases that will be added
+  /// (for efficient allocation).
+  SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) {
+    return Insert(SwitchInst::Create(V, Dest, NumCases));
+  }
+  
+  /// CreateInvoke - Create an invoke instruction.
+  template<typename InputIterator>
+  InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
+                           BasicBlock *UnwindDest, InputIterator ArgBegin,
+                           InputIterator ArgEnd, const char *Name = "") {
+    return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest,
+                                     ArgBegin, ArgEnd, Name));
+  }
+  
+  UnwindInst *CreateUnwind() {
+    return Insert(new UnwindInst());
+  }
+
+  UnreachableInst *CreateUnreachable() {
+    return Insert(new UnreachableInst());
+  }
+  
+  //===--------------------------------------------------------------------===//
+  // Instruction creation methods: Binary Operators
+  //===--------------------------------------------------------------------===//
+
+  Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getAdd(LC, RC);      
+    return Insert(BinaryOperator::createAdd(LHS, RHS, Name));
+  }
+  Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getSub(LC, RC);
+    return Insert(BinaryOperator::createSub(LHS, RHS, Name));
+  }
+  Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getMul(LC, RC);
+    return Insert(BinaryOperator::createMul(LHS, RHS, Name));
+  }
+  Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
+      if (Constant *LC = dyn_cast<Constant>(LHS))
+          if (Constant *RC = dyn_cast<Constant>(RHS))
+              return ConstantExpr::getUDiv(LC, RC);
+      return Insert(BinaryOperator::createUDiv(LHS, RHS, Name));
+  }
+  Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getSDiv(LC, RC);      
+    return Insert(BinaryOperator::createSDiv(LHS, RHS, Name));
+  }
+  Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getFDiv(LC, RC);      
+    return Insert(BinaryOperator::createFDiv(LHS, RHS, Name));
+  }
+  Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getURem(LC, RC);
+    return Insert(BinaryOperator::createURem(LHS, RHS, Name));
+  }
+  Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getSRem(LC, RC);
+    return Insert(BinaryOperator::createSRem(LHS, RHS, Name));
+  }
+  Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getFRem(LC, RC);
+    return Insert(BinaryOperator::createFRem(LHS, RHS, Name));
+  }
+  Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getShl(LC, RC);
+    return Insert(BinaryOperator::createShl(LHS, RHS, Name));
+  }
+  Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getLShr(LC, RC);
+    return Insert(BinaryOperator::createLShr(LHS, RHS, Name));
+  }
+  Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getAShr(LC, RC);
+    return Insert(BinaryOperator::createAShr(LHS, RHS, Name));
+  }
+  Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getAnd(LC, RC);
+    return Insert(BinaryOperator::createAnd(LHS, RHS, Name));
+  }
+  Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getOr(LC, RC);
+    return Insert(BinaryOperator::createOr(LHS, RHS, Name));
+  }
+  Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getXor(LC, RC);
+    return Insert(BinaryOperator::createXor(LHS, RHS, Name));
+  }
+
+  BinaryOperator *CreateBinOp(Instruction::BinaryOps Opc,
+                              Value *LHS, Value *RHS, const char *Name = "") {
+    return Insert(BinaryOperator::create(Opc, LHS, RHS, Name));
+  }
+  
+  BinaryOperator *CreateNeg(Value *V, const char *Name = "") {
+    return Insert(BinaryOperator::createNeg(V, Name));
+  }
+  BinaryOperator *CreateNot(Value *V, const char *Name = "") {
+    return Insert(BinaryOperator::createNot(V, Name));
+  }
+  
+  //===--------------------------------------------------------------------===//
+  // Instruction creation methods: Memory Instructions
+  //===--------------------------------------------------------------------===//
+  
+  MallocInst *CreateMalloc(const Type *Ty, Value *ArraySize = 0,
+                           const char *Name = "") {
+    return Insert(new MallocInst(Ty, ArraySize, Name));
+  }
+  AllocaInst *CreateAlloca(const Type *Ty, Value *ArraySize = 0,
+                           const char *Name = "") {
+    return Insert(new AllocaInst(Ty, ArraySize, Name));
+  }
+  FreeInst *CreateFree(Value *Ptr) {
+    return Insert(new FreeInst(Ptr));
+  }
+  LoadInst *CreateLoad(Value *Ptr, const char *Name = 0) {
+    return Insert(new LoadInst(Ptr, Name));
+  }
+  LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const char *Name = 0) {
+    return Insert(new LoadInst(Ptr, Name, isVolatile));
+  }
+  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
+    return Insert(new StoreInst(Val, Ptr, isVolatile));
+  }
+  template<typename InputIterator>
+  Value *CreateGEP(Value *Ptr, InputIterator IdxBegin,
+                               InputIterator IdxEnd, const char *Name = "") {
+      
+    if (Constant *PC = dyn_cast<Constant>(Ptr)) {
+        // Every index must be constant.
+        InputIterator i;
+        for (i = IdxBegin; i < IdxEnd; ++i) {
+            if (!dyn_cast<Constant>(*i))
+                  break;
+        }
+        if (i == IdxEnd)
+            return ConstantExpr::getGetElementPtr(PC, &IdxBegin[0], IdxEnd - IdxBegin);
+    }      
+    return(Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd, Name)));
+  }
+  Value *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
+    if (Constant *PC = dyn_cast<Constant>(Ptr))
+        if (Constant *IC = dyn_cast<Constant>(Idx))
+            return ConstantExpr::getGetElementPtr(PC, &IC, 1);
+    return Insert(GetElementPtrInst::Create(Ptr, Idx, Name));
+  }
+  GetElementPtrInst *CreateStructGEP(Value *Ptr, unsigned Idx,
+                                     const char *Name = "") {
+    llvm::Value *Idxs[] = {
+      ConstantInt::get(llvm::Type::Int32Ty, 0),
+      ConstantInt::get(llvm::Type::Int32Ty, Idx)
+    };
+    return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2, Name));
+  }
+  
+  //===--------------------------------------------------------------------===//
+  // Instruction creation methods: Cast/Conversion Operators
+  //===--------------------------------------------------------------------===//
+    
+    Value *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
+        return CreateCast(Instruction::Trunc, V, DestTy, Name);
+    }
+    Value *CreateZExt(Value *V, const Type *DestTy, const char *Name = "") {
+        return CreateCast(Instruction::ZExt, V, DestTy, Name);
+    }
+    Value *CreateSExt(Value *V, const Type *DestTy, const char *Name = "") {
+        return CreateCast(Instruction::SExt, V, DestTy, Name);
+    }
+    Value *CreateFPToUI(Value *V, const Type *DestTy, const char *Name = ""){
+        return CreateCast(Instruction::FPToUI, V, DestTy, Name);
+    }
+    Value *CreateFPToSI(Value *V, const Type *DestTy, const char *Name = ""){
+        return CreateCast(Instruction::FPToSI, V, DestTy, Name);
+    }
+    Value *CreateUIToFP(Value *V, const Type *DestTy, const char *Name = ""){
+        return CreateCast(Instruction::UIToFP, V, DestTy, Name);
+    }
+    Value *CreateSIToFP(Value *V, const Type *DestTy, const char *Name = ""){
+        return CreateCast(Instruction::SIToFP, V, DestTy, Name);
+    }
+    Value *CreateFPTrunc(Value *V, const Type *DestTy,
+                         const char *Name = "") {
+        return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
+    }
+    Value *CreateFPExt(Value *V, const Type *DestTy, const char *Name = "") {
+        return CreateCast(Instruction::FPExt, V, DestTy, Name);
+    }
+    Value *CreatePtrToInt(Value *V, const Type *DestTy,
+                          const char *Name = "") {
+        return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
+    }
+    Value *CreateIntToPtr(Value *V, const Type *DestTy,
+                          const char *Name = "") {
+        return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
+    }
+    Value *CreateBitCast(Value *V, const Type *DestTy,
+                         const char *Name = "") {
+        return CreateCast(Instruction::BitCast, V, DestTy, Name);
+    }
+
+    Value *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy,
+                       const char *Name = "") {
+        if (V->getType() == DestTy)
+            return V;
+        if (Constant *VC = dyn_cast<Constant>(V))
+            return ConstantExpr::getCast(Op, VC, DestTy);      
+        return Insert(CastInst::create(Op, V, DestTy, Name));
+    }
+    Value *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
+                          const char *Name = "") {
+        if (V->getType() == DestTy)
+          return V;
+        if (Constant *VC = dyn_cast<Constant>(V))
+          return ConstantExpr::getIntegerCast(VC, DestTy, isSigned);
+        return Insert(CastInst::createIntegerCast(V, DestTy, isSigned, Name));
+    }
+
+
+
+    //===--------------------------------------------------------------------===//
+    // Instruction creation methods: Compare Instructions
+    //===--------------------------------------------------------------------===//
+    
+    Value *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
+    }
+    Value *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
+    }
+    Value *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
+    }
+    Value *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
+    }
+    Value *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
+    }
+    Value *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
+    }
+    Value *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
+    }
+    Value *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
+    }
+    Value *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
+    }
+    Value *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
+    }
+    
+    Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name);
+    }
+    Value *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name);
+    }
+    Value *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name);
+    }
+    Value *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name);
+    }
+    Value *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name);
+    }
+
+    Value *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS,
+                       const char *Name = "") {
+        if (Constant *LC = dyn_cast<Constant>(LHS))
+            if (Constant *RC = dyn_cast<Constant>(RHS))
+                return ConstantExpr::getCompare(P, LC, RC);      
+        return Insert(new ICmpInst(P, LHS, RHS, Name));
+    }
+    Value *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS,
+                       const char *Name = "") {
+        if (Constant *LC = dyn_cast<Constant>(LHS))
+            if (Constant *RC = dyn_cast<Constant>(RHS))
+                return ConstantExpr::getCompare(P, LC, RC);
+        return Insert(new FCmpInst(P, LHS, RHS, Name));
+    }
+
+    //===--------------------------------------------------------------------===//
+    // Instruction creation methods: Other Instructions
+    //===--------------------------------------------------------------------===//
+
+    PHINode *CreatePHI(const Type *Ty, const char *Name = "") {
+        return Insert(PHINode::Create(Ty, Name));
+    }
+
+    CallInst *CreateCall(Value *Callee, const char *Name = "") {
+        return Insert(CallInst::Create(Callee, Name));
+    }
+    CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") {
+        return Insert(CallInst::Create(Callee, Arg, Name));
+    }
+
+    template<typename InputIterator>
+    CallInst *CreateCall(Value *Callee, InputIterator ArgBegin,
+                       InputIterator ArgEnd, const char *Name = "") {
+        return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd, Name));
+    }
+
+    Value *CreateSelect(Value *C, Value *True, Value *False,
+                           const char *Name = "") {
+        if (Constant *CC = dyn_cast<Constant>(C))
+            if (Constant *TC = dyn_cast<Constant>(True))
+                if (Constant *FC = dyn_cast<Constant>(False))
+                    return ConstantExpr::getSelect(CC, TC, FC);      
+        return Insert(SelectInst::Create(C, True, False, Name));
+    }
+
+    VAArgInst *CreateVAArg(Value *List, const Type *Ty, const char *Name = "") {
+        return Insert(new VAArgInst(List, Ty, Name));
+    }
+
+    Value *CreateExtractElement(Value *Vec, Value *Idx,
+                                           const char *Name = "") {
+        if (Constant *VC = dyn_cast<Constant>(Vec))
+          if (Constant *IC = dyn_cast<Constant>(Idx))
+              return ConstantExpr::getExtractElement(VC, IC);
+        return Insert(new ExtractElementInst(Vec, Idx, Name));
+    }
+
+    Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
+                                         const char *Name = "") {
+        if (Constant *VC = dyn_cast<Constant>(Vec))
+          if (Constant *NC = dyn_cast<Constant>(NewElt))
+              if (Constant *IC = dyn_cast<Constant>(Idx))
+                  return ConstantExpr::getInsertElement(VC, NC, IC);
+        return Insert(InsertElementInst::Create(Vec, NewElt, Idx, Name));
+    }
+
+    Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
+                                         const char *Name = "") {
+        if (Constant *V1C = dyn_cast<Constant>(V1))
+          if (Constant *V2C = dyn_cast<Constant>(V2))
+              if (Constant *MC = dyn_cast<Constant>(Mask))
+                  return ConstantExpr::getShuffleVector(V1C, V2C, MC);      
+        return Insert(new ShuffleVectorInst(V1, V2, Mask, Name));
+    }
+};
+  
+}
+
+#endif
Index: include/llvm-c/Core.h
===================================================================
--- include/llvm-c/Core.h (revision 49474)
+++ include/llvm-c/Core.h (working copy)
@@ -38,7 +38,7 @@
 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
    and 'unwrap' conversion functions. */
 #include "llvm/Module.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 
 extern "C" {
 #endif
@@ -689,7 +689,7 @@
   DEFINE_ISA_CONVERSION_FUNCTIONS   (Value,              LLVMValueRef         )
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
-  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef       )
+  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder, LLVMBuilderRef       )
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider,     LLVMModuleProviderRef)
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
Index: docs/tutorial/LangImpl3.html
===================================================================
--- docs/tutorial/LangImpl3.html (revision 49474)
+++ docs/tutorial/LangImpl3.html (working copy)
@@ -111,7 +111,7 @@
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
 
 static Module *TheModule;
-static LLVMBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 </pre>
 </div>
@@ -123,7 +123,7 @@
 
 <p>The <tt>Builder</tt> object is a helper object that makes it easy to generate
 LLVM instructions.  Instances of the <a
-href="http://llvm.org/doxygen/LLVMBuilder_8h-source.html"><tt>LLVMBuilder</tt></a>
+href="http://llvm.org/doxygen/IRBuilder_8h-source.html"><tt>IRBuilder</tt></a>
 class keep track of the current place to insert instructions and has methods to
 create new instructions.</p>
 
@@ -216,7 +216,7 @@
 </p>
 
 <p>In the example above, the LLVM builder class is starting to show its value.  
-LLVMBuilder knows where to insert the newly created instruction, all you have to
+IRBuilder knows where to insert the newly created instruction, all you have to
 do is specify what instruction to create (e.g. with <tt>CreateAdd</tt>), which
 operands to use (<tt>L</tt> and <tt>R</tt> here) and optionally provide a name
 for the generated instruction.</p>
@@ -680,7 +680,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
 #include "llvm/Analysis/Verifier.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -1023,7 +1023,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
Index: docs/tutorial/LangImpl4.html
===================================================================
--- docs/tutorial/LangImpl4.html (revision 49474)
+++ docs/tutorial/LangImpl4.html (working copy)
@@ -56,8 +56,8 @@
 
 <p>
 Our demonstration for Chapter 3 is elegant and easy to extend.  Unfortunately,
-it does not produce wonderful code.  For example, when compiling simple code,
-we don't get obvious optimizations:</p>
+it does not produce wonderful code.  The IRBuilder, however, does give us
+obvious optimizations when compiling simple code:</p>
 
 <div class="doc_code">
 <pre>
@@ -65,57 +65,45 @@
 Read function definition:
 define double @test(double %x) {
 entry:
-        %addtmp = add double 1.000000e+00, 2.000000e+00
-        %addtmp1 = add double %addtmp, %x
-        ret double %addtmp1
+        %addtmp = add double 3.000000e+00, %x
+        ret double %addtmp
 }
 </pre>
 </div>
 
-<p>This code is a very, very literal transcription of the AST built by parsing
-the input. As such, this transcription lacks optimizations like constant folding (we'd like to get "<tt>add x, 3.0</tt>" in the example above) as well as other more important
-optimizations.  Constant folding, in particular, is a very common and very
-important optimization: so much so that many language implementors implement
-constant folding support in their AST representation.</p>
+<p>This code is not a literal transcription of the AST built by parsing the
+input. That would be:
 
-<p>With LLVM, you don't need this support in the AST.  Since all calls to build LLVM IR go through
-the LLVM builder, it would be nice if the builder itself checked to see if there
-was a constant folding opportunity when you call it.  If so, it could just do
-the constant fold and return the constant instead of creating an instruction.
-This is exactly what the <tt>LLVMFoldingBuilder</tt> class does.  Lets make one
-change:
-
 <div class="doc_code">
 <pre>
-static LLVMFoldingBuilder Builder;
-</pre>
-</div>
-
-<p>All we did was switch from <tt>LLVMBuilder</tt> to
-<tt>LLVMFoldingBuilder</tt>.  Though we change no other code, we now have all of our
-instructions implicitly constant folded without us having to do anything
-about it.  For example, the input above now compiles to:</p>
-
-<div class="doc_code">
-<pre>
 ready&gt; <b>def test(x) 1+2+x;</b>
 Read function definition:
 define double @test(double %x) {
 entry:
-        %addtmp = add double 3.000000e+00, %x
-        ret double %addtmp
+        %addtmp = add double 2.000000e+00, 1.000000e+00
+        %addtmp1 = add double %addtmp, %x
+        ret double %addtmp1
 }
 </pre>
 </div>
 
-<p>Well, that was easy :).  In practice, we recommend always using
-<tt>LLVMFoldingBuilder</tt> when generating code like this.  It has no
+Constant folding, as seen above, in particular, is a very common and very
+important optimization: so much so that many language implementors implement
+constant folding support in their AST representation.</p>
+
+<p>With LLVM, you don't need this support in the AST.  Since all calls to build
+LLVM IR go through the LLVM IR builder, the builder itself checked to see if
+there was a constant folding opportunity when you call it.  If so, it just does
+the constant fold and return the constant instead of creating an instruction.
+
+<p>Well, that iss easy :).  In practice, we recommend always using
+<tt>IRBuilder</tt> when generating code like this.  It has no
 "syntactic overhead" for its use (you don't have to uglify your compiler with
 constant checks everywhere) and it can dramatically reduce the amount of
 LLVM IR that is generated in some cases (particular for languages with a macro
 preprocessor or that use a lot of constants).</p>
 
-<p>On the other hand, the <tt>LLVMFoldingBuilder</tt> is limited by the fact
+<p>On the other hand, the <tt>IRBuilder</tt> is limited by the fact
 that it does all of its analysis inline with the code as it is built.  If you
 take a slightly more complex example:</p>
 
@@ -525,7 +513,7 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -868,7 +856,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMFoldingBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 static FunctionPassManager *TheFPM;
 
Index: docs/tutorial/LangImpl5.html
===================================================================
--- docs/tutorial/LangImpl5.html (revision 49474)
+++ docs/tutorial/LangImpl5.html (working copy)
@@ -400,7 +400,7 @@
 
 <p>Once the blocks are created, we can emit the conditional branch that chooses
 between them.  Note that creating new blocks does not implicitly affect the
-LLVMBuilder, so it is still inserting into the block that the condition
+IRBuilder, so it is still inserting into the block that the condition
 went into.  Also note that it is creating a branch to the "then" block and the
 "else" block, even though the "else" block isn't inserted into the function yet.
 This is all ok: it is the standard way that LLVM supports forward
@@ -907,7 +907,7 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -1352,7 +1352,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMFoldingBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 static FunctionPassManager *TheFPM;
 
Index: docs/tutorial/LangImpl6.html
===================================================================
--- docs/tutorial/LangImpl6.html (revision 49474)
+++ docs/tutorial/LangImpl6.html (working copy)
@@ -827,7 +827,7 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -1357,7 +1357,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMFoldingBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 static FunctionPassManager *TheFPM;
 
Index: docs/tutorial/LangImpl7.html
===================================================================
--- docs/tutorial/LangImpl7.html (revision 49474)
+++ docs/tutorial/LangImpl7.html (working copy)
@@ -422,14 +422,14 @@
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &amp;VarName) {
-  LLVMBuilder TmpB(&amp;TheFunction-&gt;getEntryBlock(),
+  IRBuilder TmpB(&amp;TheFunction-&gt;getEntryBlock(),
                    TheFunction-&gt;getEntryBlock().begin());
   return TmpB.CreateAlloca(Type::DoubleTy, 0, VarName.c_str());
 }
 </pre>
 </div>
 
-<p>This funny looking code creates an LLVMBuilder object that is pointing at
+<p>This funny looking code creates an IRBuilder object that is pointing at
 the first instruction (.begin()) of the entry block.  It then creates an alloca
 with the expected name and returns it.  Because all values in Kaleidoscope are
 doubles, there is no need to pass in a type to use.</p>
@@ -1009,7 +1009,7 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -1605,7 +1605,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMFoldingBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, AllocaInst*&gt; NamedValues;
 static FunctionPassManager *TheFPM;
 
@@ -1615,7 +1615,7 @@
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &amp;VarName) {
-  LLVMBuilder TmpB(&amp;TheFunction-&gt;getEntryBlock(),
+  IRBuilder TmpB(&amp;TheFunction-&gt;getEntryBlock(),
                    TheFunction-&gt;getEntryBlock().begin());
   return TmpB.CreateAlloca(Type::DoubleTy, 0, VarName.c_str());
 }
Index: docs/tutorial/JITTutorial1.html
===================================================================
--- docs/tutorial/JITTutorial1.html (revision 49474)
+++ docs/tutorial/JITTutorial1.html (working copy)
@@ -60,7 +60,7 @@
 #include &lt;llvm/CallingConv.h&gt;
 #include &lt;llvm/Analysis/Verifier.h&gt;
 #include &lt;llvm/Assembly/PrintModulePass.h&gt;
-#include &lt;llvm/Support/LLVMBuilder.h&gt;
+#include &lt;llvm/Support/IRBuilder.h&gt;
 </pre>
 </div>
 
@@ -143,11 +143,11 @@
 <div class="doc_code">
 <pre>
   BasicBlock* block = new BasicBlock("entry", mul_add);
-  LLVMBuilder builder(block);
+  IRBuilder builder(block);
 </pre>
 </div>
 
-<p>We create a new basic block, as you might expect, by calling its constructor.  All we need to tell it is its name and the function to which it belongs.  In addition, we’re creating an <code>LLVMBuilder</code> object, which is a convenience interface for creating instructions and appending them to the end of a block.  Instructions can be created through their constructors as well, but some of their interfaces are quite complicated.  Unless you need a lot of control, using <code>LLVMBuilder</code> will make your life simpler.</p>
+<p>We create a new basic block, as you might expect, by calling its constructor.  All we need to tell it is its name and the function to which it belongs.  In addition, we’re creating an <code>IRBuilder</code> object, which is a convenience interface for creating instructions and appending them to the end of a block.  Instructions can be created through their constructors as well, but some of their interfaces are quite complicated.  Unless you need a lot of control, using <code>IRBuilder</code> will make your life simpler.</p>
 
 <div class="doc_code">
 <pre>
@@ -163,7 +163,7 @@
 </pre>
 </div>
 
-<p>The final step in creating our function is to create the instructions that make it up.  Our <code>mul_add</code> function is composed of just three instructions: a multiply, an add, and a return.  <code>LLVMBuilder</code> gives us a simple interface for constructing these instructions and appending them to the “entry” block.  Each of the calls to <code>LLVMBuilder</code> returns a <code>Value*</code> that represents the value yielded by the instruction.  You’ll also notice that, above, <code>x</code>, <code>y</code>, and <code>z</code> are also <code>Value*</code>’s, so it’s clear that instructions operate on <code>Value*</code>’s.</p>
+<p>The final step in creating our function is to create the instructions that make it up.  Our <code>mul_add</code> function is composed of just three instructions: a multiply, an add, and a return.  <code>IRBuilder</code> gives us a simple interface for constructing these instructions and appending them to the “entry” block.  Each of the calls to <code>IRBuilder</code> returns a <code>Value*</code> that represents the value yielded by the instruction.  You’ll also notice that, above, <code>x</code>, <code>y</code>, and <code>z</code> are also <code>Value*</code>’s, so it’s clear that instructions operate on <code>Value*</code>’s.</p>
 
 <p>And that’s it!  Now you can compile and run your code, and get a wonderful textual print out of the LLVM IR we saw at the beginning.  To compile, use the following command line as a guide:</p>
 
Index: docs/tutorial/JITTutorial2.html
===================================================================
--- docs/tutorial/JITTutorial2.html (revision 49474)
+++ docs/tutorial/JITTutorial2.html (working copy)
@@ -56,7 +56,7 @@
 #include &lt;llvm/PassManager.h&gt;
 #include &lt;llvm/Analysis/Verifier.h&gt;
 #include &lt;llvm/Assembly/PrintModulePass.h&gt;
-#include &lt;llvm/Support/LLVMBuilder.h&gt;
+#include &lt;llvm/Support/IRBuilder.h&gt;
 
 using namespace llvm;
 
@@ -110,13 +110,13 @@
 
 <div class="doc_code">
 <pre>
-  LLVMBuilder builder(entry);
+  IRBuilder builder(entry);
   Value* xEqualsY = builder.CreateICmpEQ(x, y, &quot;tmp&quot;);
   builder.CreateCondBr(xEqualsY, ret, cond_false);
 </pre>
 </div>
 
-<p>Our next block, <code>ret</code>, is pretty simple: it just returns the value of <code>x</code>.  Recall that this block is only reached if <code>x == y</code>, so this is the correct behavior.  Notice that instead of creating a new <code>LLVMBuilder</code> for each block, we can use <code>SetInsertPoint</code> to retarget our existing one.  This saves on construction and memory allocation costs.</p>
+<p>Our next block, <code>ret</code>, is pretty simple: it just returns the value of <code>x</code>.  Recall that this block is only reached if <code>x == y</code>, so this is the correct behavior.  Notice that instead of creating a new <code>IRBuilder</code> for each block, we can use <code>SetInsertPoint</code> to retarget our existing one.  This saves on construction and memory allocation costs.</p>
 
 <div class="doc_code">
 <pre>
Index: docs/tutorial/OCamlLangImpl3.html
===================================================================
--- docs/tutorial/OCamlLangImpl3.html (revision 49474)
+++ docs/tutorial/OCamlLangImpl3.html (working copy)
@@ -108,7 +108,7 @@
 
 <p>The <tt>Codegen.builder</tt> object is a helper object that makes it easy to
 generate LLVM instructions.  Instances of the <a
-href="http://llvm.org/doxygen/LLVMBuilder_8h-source.html"><tt>LLVMBuilder</tt></a>
+href="http://llvm.org/doxygen/IRBuilder_8h-source.html"><tt>IRBuilder</tt></a>
 class keep track of the current place to insert instructions and has methods to
 create new instructions.</p>
 
@@ -194,7 +194,7 @@
 </p>
 
 <p>In the example above, the LLVM builder class is starting to show its value.
-LLVMBuilder knows where to insert the newly created instruction, all you have to
+IRBuilder knows where to insert the newly created instruction, all you have to
 do is specify what instruction to create (e.g. with <tt>Llvm.create_add</tt>),
 which operands to use (<tt>lhs</tt> and <tt>rhs</tt> here) and optionally
 provide a name for the generated instruction.</p>
Index: docs/tutorial/OCamlLangImpl4.html
===================================================================
--- docs/tutorial/OCamlLangImpl4.html (revision 49474)
+++ docs/tutorial/OCamlLangImpl4.html (working copy)
@@ -58,7 +58,8 @@
 
 <div class="doc_text">
 
-<p><b>Note:</b> the ocaml bindings already use <tt>LLVMFoldingBuilder</tt>.<p>
+<p><b>Note:</b> the default <tt>IRBuilder</tt> now always includes the constant
+folding optimisations below.<p>
 
 <p>
 Our demonstration for Chapter 3 is elegant and easy to extend.  Unfortunately,
Index: docs/tutorial/OCamlLangImpl5.html
===================================================================
--- docs/tutorial/OCamlLangImpl5.html (revision 49474)
+++ docs/tutorial/OCamlLangImpl5.html (working copy)
@@ -455,7 +455,7 @@
 
 <p>Once the blocks are created, we can emit the conditional branch that chooses
 between them.  Note that creating new blocks does not implicitly affect the
-LLVMBuilder, so it is still inserting into the block that the condition
+IRBuilder, so it is still inserting into the block that the condition
 went into.  This is why we needed to save the "start" block.</p>
 
 <div class="doc_code">
Index: bindings/ocaml/llvm/llvm_ocaml.c
===================================================================
--- bindings/ocaml/llvm/llvm_ocaml.c (revision 49474)
+++ bindings/ocaml/llvm/llvm_ocaml.c (working copy)
@@ -776,7 +776,7 @@
 }
 
 static struct custom_operations builder_ops = {
-  (char *) "LLVMBuilder",
+  (char *) "IRBuilder",
   llvm_finalize_builder,
   custom_compare_default,
   custom_hash_default,
Index: Xcode/LLVM.xcodeproj/project.pbxproj
===================================================================
--- Xcode/LLVM.xcodeproj/project.pbxproj (revision 49474)
+++ Xcode/LLVM.xcodeproj/project.pbxproj (working copy)
@@ -162,7 +162,6 @@
  9F7794280C73CB6100551F9C /* MipsTargetMachine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MipsTargetMachine.h; sourceTree = "<group>"; };
  9F77942F0C73CB7900551F9C /* MSILWriter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MSILWriter.cpp; sourceTree = "<group>"; };
  9F7794300C73CB7900551F9C /* MSILWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MSILWriter.h; sourceTree = "<group>"; };
- 9F7794870C73D51000551F9C /* LLVMBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LLVMBuilder.h; sourceTree = "<group>"; };
  9F7794880C73D51000551F9C /* MemoryBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryBuffer.h; sourceTree = "<group>"; };
  9F7794890C73D51000551F9C /* Streams.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Streams.h; sourceTree = "<group>"; };
  9F7C23E50CB81C2100498408 /* Analysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Analysis.h; sourceTree = "<group>"; };
@@ -1071,6 +1070,32 @@
  DE8170AB08CFB44D0093BDEF /* TableGenBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = TableGenBackend.cpp; sourceTree = "<group>"; };
  DE8170AC08CFB44D0093BDEF /* TableGenBackend.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = TableGenBackend.h; sourceTree = "<group>"; };
  DEFAB19D0959E9A100E0AB42 /* DwarfWriter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = DwarfWriter.h; path = ../include/llvm/CodeGen/DwarfWriter.h; sourceTree = SOURCE_ROOT; };
+ F22627320DAE34D10008F441 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = index.html; sourceTree = "<group>"; };
+ F22627330DAE34D20008F441 /* JITTutorial1.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = JITTutorial1.html; sourceTree = "<group>"; };
+ F22627340DAE34D20008F441 /* JITTutorial2-1.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "JITTutorial2-1.png"; sourceTree = "<group>"; };
+ F22627350DAE34D20008F441 /* JITTutorial2.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = JITTutorial2.html; sourceTree = "<group>"; };
+ F22627360DAE34D20008F441 /* LangImpl1.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl1.html; sourceTree = "<group>"; };
+ F22627370DAE34D20008F441 /* LangImpl2.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl2.html; sourceTree = "<group>"; };
+ F22627380DAE34D20008F441 /* LangImpl3.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl3.html; sourceTree = "<group>"; };
+ F22627390DAE34D20008F441 /* LangImpl4.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl4.html; sourceTree = "<group>"; };
+ F226273A0DAE34D20008F441 /* LangImpl5-cfg.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "LangImpl5-cfg.png"; sourceTree = "<group>"; };
+ F226273B0DAE34D20008F441 /* LangImpl5.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl5.html; sourceTree = "<group>"; };
+ F226273C0DAE34D20008F441 /* LangImpl6.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl6.html; sourceTree = "<group>"; };
+ F226273D0DAE34D20008F441 /* LangImpl7.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl7.html; sourceTree = "<group>"; };
+ F226273E0DAE34D20008F441 /* LangImpl8.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl8.html; sourceTree = "<group>"; };
+ F226273F0DAE34D20008F441 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = "<group>"; };
+ F22627400DAE34D20008F441 /* OCamlLangImpl1.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl1.html; sourceTree = "<group>"; };
+ F22627410DAE34D20008F441 /* OCamlLangImpl2.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl2.html; sourceTree = "<group>"; };
+ F22627420DAE34D20008F441 /* OCamlLangImpl3.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl3.html; sourceTree = "<group>"; };
+ F22627430DAE34D20008F441 /* OCamlLangImpl4.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl4.html; sourceTree = "<group>"; };
+ F22627440DAE34D20008F441 /* OCamlLangImpl5.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl5.html; sourceTree = "<group>"; };
+ F22627450DAE34D20008F441 /* OCamlLangImpl6.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl6.html; sourceTree = "<group>"; };
+ F22627460DAE34D20008F441 /* OCamlLangImpl7.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl7.html; sourceTree = "<group>"; };
+ F22761DF0DAD09CD003D8065 /* BrainF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = BrainF.cpp; path = BrainF/BrainF.cpp; sourceTree = "<group>"; };
+ F22761E00DAD09CD003D8065 /* BrainF.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = BrainF.h; path = BrainF/BrainF.h; sourceTree = "<group>"; };
+ F22761E10DAD09CD003D8065 /* BrainFDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = BrainFDriver.cpp; path = BrainF/BrainFDriver.cpp; sourceTree = "<group>"; };
+ F27C8CE90DAD2EF900A33844 /* IRBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IRBuilder.h; sourceTree = "<group>"; };
+ F27C8CFF0DAD307700A33844 /* ShadowStackCollector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ShadowStackCollector.cpp; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXGroup section */
@@ -1580,6 +1605,7 @@
  DE66ED3E08ABEC2A00323D32 /* lib/CodeGen */ = {
  isa = PBXGroup;
  children = (
+ F27C8CFF0DAD307700A33844 /* ShadowStackCollector.cpp */,
  754221420D171DFC00DDB61B /* MachineLICM.cpp */,
  9FE450AB0C77AB6100C4FEA4 /* README.txt */,
  DE66ED8308ABEC2B00323D32 /* SelectionDAG */,
@@ -2417,6 +2443,7 @@
  DE66F26E08ABF03200323D32 /* Support */ = {
  isa = PBXGroup;
  children = (
+ F27C8CE90DAD2EF900A33844 /* IRBuilder.h */,
  DE66F27008ABF03200323D32 /* AIXDataTypesFix.h */,
  9F5B90CE0D0CE89300CDFDEA /* AlignOf.h */,
  CF8F1B430B64F74400BB4199 /* Allocator.h */,
@@ -2440,7 +2467,6 @@
  DE66F28108ABF03200323D32 /* InstIterator.h */,
  DE66F28208ABF03200323D32 /* InstVisitor.h */,
  DE66F28308ABF03200323D32 /* LeakDetector.h */,
- 9F7794870C73D51000551F9C /* LLVMBuilder.h */,
  CF8F1B460B64F74400BB4199 /* ManagedStatic.h */,
  DE66F28408ABF03200323D32 /* Mangler.h */,
  DE66F28508ABF03200323D32 /* MathExtras.h */,
@@ -2631,6 +2657,7 @@
  DE66F38D08ABF35C00323D32 /* docs */ = {
  isa = PBXGroup;
  children = (
+ F22627310DAE34D10008F441 /* tutorial */,
  DE66F38F08ABF35C00323D32 /* AliasAnalysis.html */,
  DE66F39008ABF35C00323D32 /* Bugpoint.html */,
  DE66F39208ABF35C00323D32 /* GCCFEBuildInstrs.html */,
@@ -2717,6 +2744,9 @@
  DE66F3FD08ABF37000323D32 /* examples */ = {
  isa = PBXGroup;
  children = (
+ F22761DF0DAD09CD003D8065 /* BrainF.cpp */,
+ F22761E00DAD09CD003D8065 /* BrainF.h */,
+ F22761E10DAD09CD003D8065 /* BrainFDriver.cpp */,
  DE66F40E08ABF37000323D32 /* fibonacci.cpp */,
  DE66F41508ABF37000323D32 /* HowToUseJIT.cpp */,
  DE66F41E08ABF37000323D32 /* ModuleMaker.cpp */,
@@ -2771,6 +2801,34 @@
  path = TableGen;
  sourceTree = "<group>";
  };
+ F22627310DAE34D10008F441 /* tutorial */ = {
+ isa = PBXGroup;
+ children = (
+ F22627320DAE34D10008F441 /* index.html */,
+ F22627330DAE34D20008F441 /* JITTutorial1.html */,
+ F22627340DAE34D20008F441 /* JITTutorial2-1.png */,
+ F22627350DAE34D20008F441 /* JITTutorial2.html */,
+ F22627360DAE34D20008F441 /* LangImpl1.html */,
+ F22627370DAE34D20008F441 /* LangImpl2.html */,
+ F22627380DAE34D20008F441 /* LangImpl3.html */,
+ F22627390DAE34D20008F441 /* LangImpl4.html */,
+ F226273A0DAE34D20008F441 /* LangImpl5-cfg.png */,
+ F226273B0DAE34D20008F441 /* LangImpl5.html */,
+ F226273C0DAE34D20008F441 /* LangImpl6.html */,
+ F226273D0DAE34D20008F441 /* LangImpl7.html */,
+ F226273E0DAE34D20008F441 /* LangImpl8.html */,
+ F226273F0DAE34D20008F441 /* Makefile */,
+ F22627400DAE34D20008F441 /* OCamlLangImpl1.html */,
+ F22627410DAE34D20008F441 /* OCamlLangImpl2.html */,
+ F22627420DAE34D20008F441 /* OCamlLangImpl3.html */,
+ F22627430DAE34D20008F441 /* OCamlLangImpl4.html */,
+ F22627440DAE34D20008F441 /* OCamlLangImpl5.html */,
+ F22627450DAE34D20008F441 /* OCamlLangImpl6.html */,
+ F22627460DAE34D20008F441 /* OCamlLangImpl7.html */,
+ );
+ path = tutorial;
+ sourceTree = "<group>";
+ };
 /* End PBXGroup section */
 
 /* Begin PBXLegacyTarget section */
Index: lib/CodeGen/ShadowStackCollector.cpp
===================================================================
--- lib/CodeGen/ShadowStackCollector.cpp (revision 49474)
+++ lib/CodeGen/ShadowStackCollector.cpp (working copy)
@@ -31,7 +31,7 @@
 #include "llvm/CodeGen/Collector.h"
 #include "llvm/IntrinsicInst.h"
 #include "llvm/Module.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 
 using namespace llvm;
 
@@ -61,9 +61,9 @@
     Constant *GetFrameMap(Function &F);
     const Type* GetConcreteStackEntryType(Function &F);
     void CollectRoots(Function &F);
-    static GetElementPtrInst *CreateGEP(LLVMBuilder &B, Value *BasePtr,
+    static GetElementPtrInst *CreateGEP(IRBuilder &B, Value *BasePtr,
                                         int Idx1, const char *Name);
-    static GetElementPtrInst *CreateGEP(LLVMBuilder &B, Value *BasePtr,
+    static GetElementPtrInst *CreateGEP(IRBuilder &B, Value *BasePtr,
                                         int Idx1, int Idx2, const char *Name);
   };
   
@@ -86,13 +86,13 @@
     // State.
     int State;
     Function::iterator StateBB, StateE;
-    LLVMBuilder Builder;
+    IRBuilder Builder;
     
   public:
     EscapeEnumerator(Function &F, const char *N = "cleanup")
       : F(F), CleanupBBName(N), State(0) {}
     
-    LLVMBuilder *Next() {
+    IRBuilder *Next() {
       switch (State) {
       default:
         return 0;
@@ -339,20 +339,28 @@
 }
 
 GetElementPtrInst *
-ShadowStackCollector::CreateGEP(LLVMBuilder &B, Value *BasePtr,
+ShadowStackCollector::CreateGEP(IRBuilder &B, Value *BasePtr,
                                 int Idx, int Idx2, const char *Name) {
   Value *Indices[] = { ConstantInt::get(Type::Int32Ty, 0),
                        ConstantInt::get(Type::Int32Ty, Idx),
                        ConstantInt::get(Type::Int32Ty, Idx2) };
-  return B.CreateGEP(BasePtr, Indices, Indices + 3, Name);
+  Value* Val = B.CreateGEP(BasePtr, Indices, Indices + 3, Name);
+    
+  assert(isa<GetElementPtrInst>(Val) && "Unexpected folded constant");
+    
+  return dyn_cast<GetElementPtrInst>(Val);
 }
 
 GetElementPtrInst *
-ShadowStackCollector::CreateGEP(LLVMBuilder &B, Value *BasePtr,
+ShadowStackCollector::CreateGEP(IRBuilder &B, Value *BasePtr,
                                 int Idx, const char *Name) {
   Value *Indices[] = { ConstantInt::get(Type::Int32Ty, 0),
                        ConstantInt::get(Type::Int32Ty, Idx) };
-  return B.CreateGEP(BasePtr, Indices, Indices + 2, Name);
+  Value *Val = B.CreateGEP(BasePtr, Indices, Indices + 2, Name);
+    
+  assert(isa<GetElementPtrInst>(Val) && "Unexpected folded constant");
+
+  return dyn_cast<GetElementPtrInst>(Val);
 }
 
 /// runOnFunction - Insert code to maintain the shadow stack.
@@ -371,7 +379,7 @@
   
   // Build the shadow stack entry at the very start of the function.
   BasicBlock::iterator IP = F.getEntryBlock().begin();
-  LLVMBuilder AtEntry(IP->getParent(), IP);
+  IRBuilder AtEntry(IP->getParent(), IP);
   
   Instruction *StackEntry   = AtEntry.CreateAlloca(ConcreteStackEntryTy, 0,
                                                    "gc_frame");
@@ -409,7 +417,7 @@
   
   // For each instruction that escapes...
   EscapeEnumerator EE(F, "gc_cleanup");
-  while (LLVMBuilder *AtExit = EE.Next()) {
+  while (IRBuilder *AtExit = EE.Next()) {
     // Pop the entry from the shadow stack. Don't reuse CurrentHead from
     // AtEntry, since that would make the value live for the entire function.
     Instruction *EntryNextPtr2 = CreateGEP(*AtExit, StackEntry, 0, 0,
Index: lib/VMCore/Core.cpp
===================================================================
--- lib/VMCore/Core.cpp (revision 49474)
+++ lib/VMCore/Core.cpp (working copy)
@@ -962,7 +962,7 @@
 /*===-- Instruction builders ----------------------------------------------===*/
 
 LLVMBuilderRef LLVMCreateBuilder() {
-  return wrap(new LLVMFoldingBuilder());
+  return wrap(new IRBuilder());
 }
 
 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
Index: examples/BrainF/BrainF.cpp
===================================================================
--- examples/BrainF/BrainF.cpp (revision 49474)
+++ examples/BrainF/BrainF.cpp (working copy)
@@ -71,7 +71,7 @@
   brainf_func = cast<Function>(module->
     getOrInsertFunction("brainf", Type::VoidTy, NULL));
 
-  builder = new LLVMBuilder(BasicBlock::Create(label, brainf_func));
+  builder = new IRBuilder(BasicBlock::Create(label, brainf_func));
 
   //%arr = malloc i8, i32 %d
   ConstantInt *val_mem = ConstantInt::get(APInt(32, memtotal));
@@ -193,7 +193,7 @@
           Value *tape_0 = getchar_call;
 
           //%tape.%d = trunc i32 %tape.%d to i8
-          TruncInst *tape_1 = builder->
+          Value *tape_1 = builder->
             CreateTrunc(tape_0, IntegerType::Int8Ty, tapereg);
 
           //store i8 %tape.%d, i8 *%head.%d
@@ -207,7 +207,7 @@
           LoadInst *tape_0 = builder->CreateLoad(curhead, tapereg);
 
           //%tape.%d = sext i8 %tape.%d to i32
-          SExtInst *tape_1 = builder->
+          Value *tape_1 = builder->
             CreateSExt(tape_0, IntegerType::Int32Ty, tapereg);
 
           //call i32 @putchar(i32 %tape.%d)
@@ -232,15 +232,15 @@
           if (comflag & flag_arraybounds)
           {
             //%test.%d = icmp uge i8 *%head.%d, %arrmax
-            ICmpInst *test_0 = builder->
+            Value *test_0 = builder->
               CreateICmpUGE(curhead, ptr_arrmax, testreg);
 
             //%test.%d = icmp ult i8 *%head.%d, %arr
-            ICmpInst *test_1 = builder->
+            Value *test_1 = builder->
               CreateICmpULT(curhead, ptr_arr, testreg);
 
             //%test.%d = or i1 %test.%d, %test.%d
-            BinaryOperator *test_2 = builder->
+            Value *test_2 = builder->
               CreateOr(test_0, test_1, testreg);
 
             //br i1 %test.%d, label %main.%d, label %main.%d
@@ -259,7 +259,7 @@
           LoadInst *tape_0 = builder->CreateLoad(curhead, tapereg);
 
           //%tape.%d = add i8 %tape.%d, %d
-          BinaryOperator *tape_1 = builder->
+          Value *tape_1 = builder->
             CreateAdd(tape_0, ConstantInt::get(APInt(8, curvalue)), tapereg);
 
           //store i8 %tape.%d, i8 *%head.%d\n"
Index: examples/BrainF/BrainF.h
===================================================================
--- examples/BrainF/BrainF.h (revision 49474)
+++ examples/BrainF/BrainF.h (working copy)
@@ -16,7 +16,7 @@
 #define BRAINF_H
 
 #include "llvm/Module.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 
 using namespace llvm;
 
@@ -84,7 +84,7 @@
     BasicBlock *aberrorbb;
 
     /// Variables
-    LLVMBuilder *builder;
+    IRBuilder *builder;
     Value *curhead;
 };
 

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: LLVMBuilder vs LLVMFoldingBuilder

Dominic Hamon
Dominic Hamon wrote:

> Duncan Sands wrote:
>>> Another option that was discussed in #llvm is to nuke LLVMBuilder
>>> and rename LLVMFoldingBuilder to LLVMBuilder. If this was the case,
>>> I'd argue for a flag in the Builder that could retain the old
>>> non-folding functionality for debugging purposes.
>>>    
>>
>> this plan sounds good to me.  However it's not clear to me how useful a
>> debug flag would really be.
>>
>>  
>
> This is my first patch so please let me know if there are any problems
> or anything I need to do differently.
And there were. updated patches attached.

Index: include/llvm/Support/LLVMBuilder.h
===================================================================
--- include/llvm/Support/LLVMBuilder.h (revision 49474)
+++ include/llvm/Support/LLVMBuilder.h (working copy)
@@ -1,780 +0,0 @@
-//===-- llvm/Support/LLVMBuilder.h - Builder for LLVM Instrs ----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the LLVMBuilder class, which is used as a convenient way
-// to create LLVM instructions with a consistent and simplified interface.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_LLVMBUILDER_H
-#define LLVM_SUPPORT_LLVMBUILDER_H
-
-#include "llvm/BasicBlock.h"
-#include "llvm/Instructions.h"
-#include "llvm/Constants.h"
-
-namespace llvm {
-
-/// LLVMBuilder - This provides a uniform API for creating instructions and
-/// inserting them into a basic block: either at the end of a BasicBlock, or
-/// at a specific iterator location in a block.
-///
-/// Note that the builder does not expose the full generality of LLVM
-/// instructions.  For example, it cannot be used to create instructions with
-/// arbitrary names (specifically, names with nul characters in them) - It only
-/// supports nul-terminated C strings.  For fully generic names, use
-/// I->setName().  For access to extra instruction properties, use the mutators
-/// (e.g. setVolatile) on the instructions after they have been created.
-class LLVMBuilder {
-  BasicBlock *BB;
-  BasicBlock::iterator InsertPt;
-public:
-  LLVMBuilder() { ClearInsertionPoint(); }
-  explicit LLVMBuilder(BasicBlock *TheBB) { SetInsertPoint(TheBB); }
-  LLVMBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) {
-    SetInsertPoint(TheBB, IP);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Builder configuration methods
-  //===--------------------------------------------------------------------===//
-
-  /// ClearInsertionPoint - Clear the insertion point: created instructions will
-  /// not be inserted into a block.
-  void ClearInsertionPoint() {
-    BB = 0;
-  }
-  
-  BasicBlock *GetInsertBlock() const { return BB; }
-  
-  /// SetInsertPoint - This specifies that created instructions should be
-  /// appended to the end of the specified block.
-  void SetInsertPoint(BasicBlock *TheBB) {
-    BB = TheBB;
-    InsertPt = BB->end();
-  }
-  
-  /// SetInsertPoint - This specifies that created instructions should be
-  /// inserted at the specified point.
-  void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
-    BB = TheBB;
-    InsertPt = IP;
-  }
-  
-  /// Insert - Insert and return the specified instruction.
-  template<typename InstTy>
-  InstTy *Insert(InstTy *I) const {
-    InsertHelper(I);
-    return I;
-  }
-  
-  /// InsertHelper - Insert the specified instruction at the specified insertion
-  /// point.  This is split out of Insert so that it isn't duplicated for every
-  /// template instantiation.
-  void InsertHelper(Instruction *I) const {
-    if (BB) BB->getInstList().insert(InsertPt, I);
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Terminators
-  //===--------------------------------------------------------------------===//
-
-  /// CreateRetVoid - Create a 'ret void' instruction.
-  ReturnInst *CreateRetVoid() {
-    return Insert(ReturnInst::Create());
-  }
-
-  /// @verbatim
-  /// CreateRet - Create a 'ret <val>' instruction.
-  /// @endverbatim
-  ReturnInst *CreateRet(Value *V) {
-    return Insert(ReturnInst::Create(V));
-  }
-
-  ReturnInst *CreateRet(Value * const* retVals, unsigned N) {
-    return Insert(ReturnInst::Create(retVals,  N));
-  }
-
-  GetResultInst *CreateGetResult(Value *V, unsigned Index, const char *Name = "") {
-    return Insert(new GetResultInst(V, Index, Name));
-  }
-
-  /// CreateBr - Create an unconditional 'br label X' instruction.
-  BranchInst *CreateBr(BasicBlock *Dest) {
-    return Insert(BranchInst::Create(Dest));
-  }
-
-  /// CreateCondBr - Create a conditional 'br Cond, TrueDest, FalseDest'
-  /// instruction.
-  BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) {
-    return Insert(BranchInst::Create(True, False, Cond));
-  }
-  
-  /// CreateSwitch - Create a switch instruction with the specified value,
-  /// default dest, and with a hint for the number of cases that will be added
-  /// (for efficient allocation).
-  SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) {
-    return Insert(SwitchInst::Create(V, Dest, NumCases));
-  }
-  
-  /// CreateInvoke - Create an invoke instruction.
-  template<typename InputIterator>
-  InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
-                           BasicBlock *UnwindDest, InputIterator ArgBegin,
-                           InputIterator ArgEnd, const char *Name = "") {
-    return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest,
-                                     ArgBegin, ArgEnd, Name));
-  }
-  
-  UnwindInst *CreateUnwind() {
-    return Insert(new UnwindInst());
-  }
-
-  UnreachableInst *CreateUnreachable() {
-    return Insert(new UnreachableInst());
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Binary Operators
-  //===--------------------------------------------------------------------===//
-
-  BinaryOperator *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createAdd(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createSub(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createMul(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createUDiv(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createSDiv(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createFDiv(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createURem(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createSRem(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createFRem(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createShl(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createLShr(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createAShr(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createAnd(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createOr(LHS, RHS, Name));
-  }
-  BinaryOperator *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::createXor(LHS, RHS, Name));
-  }
-
-  BinaryOperator *CreateBinOp(Instruction::BinaryOps Opc,
-                              Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(BinaryOperator::create(Opc, LHS, RHS, Name));
-  }
-  
-  BinaryOperator *CreateNeg(Value *V, const char *Name = "") {
-    return Insert(BinaryOperator::createNeg(V, Name));
-  }
-  BinaryOperator *CreateNot(Value *V, const char *Name = "") {
-    return Insert(BinaryOperator::createNot(V, Name));
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Memory Instructions
-  //===--------------------------------------------------------------------===//
-  
-  MallocInst *CreateMalloc(const Type *Ty, Value *ArraySize = 0,
-                           const char *Name = "") {
-    return Insert(new MallocInst(Ty, ArraySize, Name));
-  }
-  AllocaInst *CreateAlloca(const Type *Ty, Value *ArraySize = 0,
-                           const char *Name = "") {
-    return Insert(new AllocaInst(Ty, ArraySize, Name));
-  }
-  FreeInst *CreateFree(Value *Ptr) {
-    return Insert(new FreeInst(Ptr));
-  }
-  LoadInst *CreateLoad(Value *Ptr, const char *Name = 0) {
-    return Insert(new LoadInst(Ptr, Name));
-  }
-  LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const char *Name = 0) {
-    return Insert(new LoadInst(Ptr, Name, isVolatile));
-  }
-  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
-    return Insert(new StoreInst(Val, Ptr, isVolatile));
-  }
-  template<typename InputIterator>
-  GetElementPtrInst *CreateGEP(Value *Ptr, InputIterator IdxBegin,
-                               InputIterator IdxEnd, const char *Name = "") {
-    return(Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd, Name)));
-  }
-  GetElementPtrInst *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
-    return Insert(GetElementPtrInst::Create(Ptr, Idx, Name));
-  }
-  GetElementPtrInst *CreateStructGEP(Value *Ptr, unsigned Idx,
-                                     const char *Name = "") {
-    llvm::Value *Idxs[] = {
-      ConstantInt::get(llvm::Type::Int32Ty, 0),
-      ConstantInt::get(llvm::Type::Int32Ty, Idx)
-    };
-    return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2, Name));
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Cast/Conversion Operators
-  //===--------------------------------------------------------------------===//
-  
-  TruncInst *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
-    return Insert(new TruncInst(V, DestTy, Name));
-  }
-  ZExtInst *CreateZExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return Insert(new ZExtInst(V, DestTy, Name));
-  }
-  SExtInst *CreateSExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return Insert(new SExtInst(V, DestTy, Name));
-  }
-  FPToUIInst *CreateFPToUI(Value *V, const Type *DestTy, const char *Name = ""){
-    return Insert(new FPToUIInst(V, DestTy, Name));
-  }
-  FPToSIInst *CreateFPToSI(Value *V, const Type *DestTy, const char *Name = ""){
-    return Insert(new FPToSIInst(V, DestTy, Name));
-  }
-  UIToFPInst *CreateUIToFP(Value *V, const Type *DestTy, const char *Name = ""){
-    return Insert(new UIToFPInst(V, DestTy, Name));
-  }
-  SIToFPInst *CreateSIToFP(Value *V, const Type *DestTy, const char *Name = ""){
-    return Insert(new SIToFPInst(V, DestTy, Name));
-  }
-  FPTruncInst *CreateFPTrunc(Value *V, const Type *DestTy,
-                             const char *Name = "") {
-    return Insert(new FPTruncInst(V, DestTy, Name));
-  }
-  FPExtInst *CreateFPExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return Insert(new FPExtInst(V, DestTy, Name));
-  }
-  PtrToIntInst *CreatePtrToInt(Value *V, const Type *DestTy,
-                               const char *Name = "") {
-    return Insert(new PtrToIntInst(V, DestTy, Name));
-  }
-  IntToPtrInst *CreateIntToPtr(Value *V, const Type *DestTy,
-                               const char *Name = "") {
-    return Insert(new IntToPtrInst(V, DestTy, Name));
-  }
-  BitCastInst *CreateBitCast(Value *V, const Type *DestTy,
-                             const char *Name = "") {
-    return Insert(new BitCastInst(V, DestTy, Name));
-  }
-  
-  CastInst *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy,
-                       const char *Name = "") {
-    return Insert(CastInst::create(Op, V, DestTy, Name));
-  }
-  CastInst *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
-                          const char *Name = "") {
-    return Insert(CastInst::createIntegerCast(V, DestTy, isSigned, Name));
-  }
-  
-  
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Compare Instructions
-  //===--------------------------------------------------------------------===//
-  
-  ICmpInst *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_EQ, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_NE, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_UGT, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_UGE, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_ULT, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_ULE, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_SGT, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_SGE, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_SLT, LHS, RHS, Name));
-  }
-  ICmpInst *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new ICmpInst(ICmpInst::ICMP_SLE, LHS, RHS, Name));
-  }
-  
-  FCmpInst *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OEQ, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OGT, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OGE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OLT, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_OLE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_ONE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_ORD, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UNO, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UEQ, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UGT, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UGE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_ULT, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_ULE, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") {
-    return Insert(new FCmpInst(FCmpInst::FCMP_UNE, LHS, RHS, Name));
-  }
-  
-  
-  ICmpInst *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS,
-                       const char *Name = "") {
-    return Insert(new ICmpInst(P, LHS, RHS, Name));
-  }
-  FCmpInst *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS,
-                       const char *Name = "") {
-    return Insert(new FCmpInst(P, LHS, RHS, Name));
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Other Instructions
-  //===--------------------------------------------------------------------===//
-  
-  PHINode *CreatePHI(const Type *Ty, const char *Name = "") {
-    return Insert(PHINode::Create(Ty, Name));
-  }
-
-  CallInst *CreateCall(Value *Callee, const char *Name = "") {
-    return Insert(CallInst::Create(Callee, Name));
-  }
-  CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") {
-    return Insert(CallInst::Create(Callee, Arg, Name));
-  }
-
-  template<typename InputIterator>
-  CallInst *CreateCall(Value *Callee, InputIterator ArgBegin,
-                       InputIterator ArgEnd, const char *Name = "") {
-    return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd, Name));
-  }
-  
-  SelectInst *CreateSelect(Value *C, Value *True, Value *False,
-                           const char *Name = "") {
-    return Insert(SelectInst::Create(C, True, False, Name));
-  }
-  
-  VAArgInst *CreateVAArg(Value *List, const Type *Ty, const char *Name = "") {
-    return Insert(new VAArgInst(List, Ty, Name));
-  }
-  
-  ExtractElementInst *CreateExtractElement(Value *Vec, Value *Idx,
-                                           const char *Name = "") {
-    return Insert(new ExtractElementInst(Vec, Idx, Name));
-  }
-  
-  InsertElementInst *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
-                                         const char *Name = "") {
-    return Insert(InsertElementInst::Create(Vec, NewElt, Idx, Name));
-  }
-  
-  ShuffleVectorInst *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
-                                         const char *Name = "") {
-    return Insert(new ShuffleVectorInst(V1, V2, Mask, Name));
-  }
-};
-
-/// LLVMFoldingBuilder - A version of LLVMBuilder that constant folds operands
-/// as they come in.
-class LLVMFoldingBuilder : public LLVMBuilder {
-    
-public:
-  LLVMFoldingBuilder() {}
-  explicit LLVMFoldingBuilder(BasicBlock *TheBB)
-    : LLVMBuilder(TheBB) {}
-  LLVMFoldingBuilder(BasicBlock *TheBB, BasicBlock::iterator IP)
-    : LLVMBuilder(TheBB, IP) {}
-
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Binary Operators
-  //===--------------------------------------------------------------------===//
-
-  Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getAdd(LC, RC);
-    return LLVMBuilder::CreateAdd(LHS, RHS, Name);
-  }
-
-  Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getSub(LC, RC);
-    return LLVMBuilder::CreateSub(LHS, RHS, Name);
-  }
-
-  Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getMul(LC, RC);
-    return LLVMBuilder::CreateMul(LHS, RHS, Name);
-  }
-
-  Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getUDiv(LC, RC);
-    return LLVMBuilder::CreateUDiv(LHS, RHS, Name);
-  }
-
-  Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getSDiv(LC, RC);
-    return LLVMBuilder::CreateSDiv(LHS, RHS, Name);
-  }
-
-  Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getFDiv(LC, RC);
-    return LLVMBuilder::CreateFDiv(LHS, RHS, Name);
-  }
-
-  Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getURem(LC, RC);
-    return LLVMBuilder::CreateURem(LHS, RHS, Name);
-  }
-
-  Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getSRem(LC, RC);
-    return LLVMBuilder::CreateSRem(LHS, RHS, Name);
-  }
-
-  Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getFRem(LC, RC);
-    return LLVMBuilder::CreateFRem(LHS, RHS, Name);
-  }
-
-  Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getAnd(LC, RC);
-    return LLVMBuilder::CreateAnd(LHS, RHS, Name);
-  }
-
-  Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getOr(LC, RC);
-    return LLVMBuilder::CreateOr(LHS, RHS, Name);
-  }
-
-  Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getXor(LC, RC);
-    return LLVMBuilder::CreateXor(LHS, RHS, Name);
-  }
-
-  Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getShl(LC, RC);
-    return LLVMBuilder::CreateShl(LHS, RHS, Name);
-  }
-
-  Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getLShr(LC, RC);
-    return LLVMBuilder::CreateLShr(LHS, RHS, Name);
-  }
-
-  Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getAShr(LC, RC);
-    return LLVMBuilder::CreateAShr(LHS, RHS, Name);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Memory Instructions
-  //===--------------------------------------------------------------------===//
-
-  template<typename InputIterator>
-  Value *CreateGEP(Value *Ptr, InputIterator IdxBegin,
-                   InputIterator IdxEnd, const char *Name = "") {
-    
-    if (Constant *PC = dyn_cast<Constant>(Ptr)) {
-      // Every index must be constant.
-      InputIterator i;
-      for (i = IdxBegin; i < IdxEnd; ++i)
-        if (!dyn_cast<Constant>(*i))
-          break;
-      if (i == IdxEnd)
-        return ConstantExpr::getGetElementPtr(PC, &IdxBegin[0], IdxEnd - IdxBegin);
-    }
-    return LLVMBuilder::CreateGEP(Ptr, IdxBegin, IdxEnd, Name);
-  }
-  Value *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
-    if (Constant *PC = dyn_cast<Constant>(Ptr))
-      if (Constant *IC = dyn_cast<Constant>(Idx))
-        return ConstantExpr::getGetElementPtr(PC, &IC, 1);
-    return LLVMBuilder::CreateGEP(Ptr, Idx, Name);
-  }
-  
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Cast/Conversion Operators
-  //===--------------------------------------------------------------------===//
-  
-  Value *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
-    return CreateCast(Instruction::Trunc, V, DestTy, Name);
-  }
-  Value *CreateZExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return CreateCast(Instruction::ZExt, V, DestTy, Name);
-  }
-  Value *CreateSExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return CreateCast(Instruction::SExt, V, DestTy, Name);
-  }
-  Value *CreateFPToUI(Value *V, const Type *DestTy, const char *Name = ""){
-    return CreateCast(Instruction::FPToUI, V, DestTy, Name);
-  }
-  Value *CreateFPToSI(Value *V, const Type *DestTy, const char *Name = ""){
-    return CreateCast(Instruction::FPToSI, V, DestTy, Name);
-  }
-  Value *CreateUIToFP(Value *V, const Type *DestTy, const char *Name = ""){
-    return CreateCast(Instruction::UIToFP, V, DestTy, Name);
-  }
-  Value *CreateSIToFP(Value *V, const Type *DestTy, const char *Name = ""){
-    return CreateCast(Instruction::SIToFP, V, DestTy, Name);
-  }
-  Value *CreateFPTrunc(Value *V, const Type *DestTy,
-                       const char *Name = "") {
-    return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
-  }
-  Value *CreateFPExt(Value *V, const Type *DestTy, const char *Name = "") {
-    return CreateCast(Instruction::FPExt, V, DestTy, Name);
-  }
-  Value *CreatePtrToInt(Value *V, const Type *DestTy,
-                        const char *Name = "") {
-    return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
-  }
-  Value *CreateIntToPtr(Value *V, const Type *DestTy,
-                        const char *Name = "") {
-    return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
-  }
-  Value *CreateBitCast(Value *V, const Type *DestTy,
-                       const char *Name = "") {
-    return CreateCast(Instruction::BitCast, V, DestTy, Name);
-  }
-
-  Value *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy,
-                    const char *Name = "") {
-    if (V->getType() == DestTy)
-      return V;
-    if (Constant *VC = dyn_cast<Constant>(V))
-      return ConstantExpr::getCast(Op, VC, DestTy);
-    return LLVMBuilder::CreateCast(Op, V, DestTy, Name);
-  }
-  Value *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
-                       const char *Name = "") {
-    if (V->getType() == DestTy)
-      return V;
-    if (Constant *VC = dyn_cast<Constant>(V))
-      return ConstantExpr::getIntegerCast(VC, DestTy, isSigned);
-    return LLVMBuilder::CreateIntCast(V, DestTy, isSigned, Name);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Compare Instructions
-  //===--------------------------------------------------------------------===//
-  
-  Value *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
-  }
-  Value *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
-  }
-  Value *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
-  }
-  Value *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
-  }
-  Value *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
-  }
-  Value *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
-  }
-  Value *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
-  }
-  Value *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
-  }
-  Value *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
-  }
-  Value *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
-  }
-
-  Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name);
-  }
-  Value *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name);
-  }
-  Value *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name);
-  }
-  Value *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name);
-  }
-  Value *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name);
-  }
-  Value *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") {
-    return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name);
-  }
-  
-  Value *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS,
-                    const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getCompare(P, LC, RC);
-    return LLVMBuilder::CreateICmp(P, LHS, RHS, Name);
-  }
-
-  Value *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS,
-                    const char *Name = "") {
-    if (Constant *LC = dyn_cast<Constant>(LHS))
-      if (Constant *RC = dyn_cast<Constant>(RHS))
-        return ConstantExpr::getCompare(P, LC, RC);
-    return LLVMBuilder::CreateFCmp(P, LHS, RHS, Name);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Instruction creation methods: Other Instructions
-  //===--------------------------------------------------------------------===//
-  
-  Value *CreateSelect(Value *C, Value *True, Value *False,
-                      const char *Name = "") {
-    if (Constant *CC = dyn_cast<Constant>(C))
-      if (Constant *TC = dyn_cast<Constant>(True))
-        if (Constant *FC = dyn_cast<Constant>(False))
-          return ConstantExpr::getSelect(CC, TC, FC);
-    return LLVMBuilder::CreateSelect(C, True, False, Name);
-  }
-  
-  Value *CreateExtractElement(Value *Vec, Value *Idx,
-                              const char *Name = "") {
-    if (Constant *VC = dyn_cast<Constant>(Vec))
-      if (Constant *IC = dyn_cast<Constant>(Idx))
-        return ConstantExpr::getExtractElement(VC, IC);
-    return LLVMBuilder::CreateExtractElement(Vec, Idx, Name);
-  }
-  
-  Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
-                             const char *Name = "") {
-    if (Constant *VC = dyn_cast<Constant>(Vec))
-      if (Constant *NC = dyn_cast<Constant>(NewElt))
-        if (Constant *IC = dyn_cast<Constant>(Idx))
-          return ConstantExpr::getInsertElement(VC, NC, IC);
-    return LLVMBuilder::CreateInsertElement(Vec, NewElt, Idx, Name);
-  }
-  
-  Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
-                             const char *Name = "") {
-    if (Constant *V1C = dyn_cast<Constant>(V1))
-      if (Constant *V2C = dyn_cast<Constant>(V2))
-        if (Constant *MC = dyn_cast<Constant>(Mask))
-          return ConstantExpr::getShuffleVector(V1C, V2C, MC);
-    return LLVMBuilder::CreateShuffleVector(V1, V2, Mask, Name);
-  }
-};
-  
-}
-
-#endif
Index: include/llvm/Support/IRBuilder.h
===================================================================
--- include/llvm/Support/IRBuilder.h (revision 0)
+++ include/llvm/Support/IRBuilder.h (revision 0)
@@ -0,0 +1,525 @@
+//===-- llvm/Support/IRBuilder.h - Builder for LLVM Instrs -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the IRBuilder class, which is used as a convenient way
+// to create LLVM instructions with a consistent and simplified interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_IRBUILDER_H
+#define LLVM_SUPPORT_IRBUILDER_H
+
+#include "llvm/BasicBlock.h"
+#include "llvm/Instructions.h"
+#include "llvm/Constants.h"
+
+namespace llvm {
+
+/// IRBuilder - This provides a uniform API for creating instructions and
+/// inserting them into a basic block: either at the end of a BasicBlock, or
+/// at a specific iterator location in a block.
+///
+/// Note that the builder does not expose the full generality of LLVM
+/// instructions.  For example, it cannot be used to create instructions with
+/// arbitrary names (specifically, names with nul characters in them) - It only
+/// supports nul-terminated C strings.  For fully generic names, use
+/// I->setName().  For access to extra instruction properties, use the mutators
+/// (e.g. setVolatile) on the instructions after they have been created.
+class IRBuilder {
+  BasicBlock *BB;
+  BasicBlock::iterator InsertPt;
+public:
+  IRBuilder() { ClearInsertionPoint(); }
+  explicit IRBuilder(BasicBlock *TheBB) { SetInsertPoint(TheBB); }
+  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) {
+    SetInsertPoint(TheBB, IP);
+  }
+
+  //===--------------------------------------------------------------------===//
+  // Builder configuration methods
+  //===--------------------------------------------------------------------===//
+
+  /// ClearInsertionPoint - Clear the insertion point: created instructions will
+  /// not be inserted into a block.
+  void ClearInsertionPoint() {
+    BB = 0;
+  }
+  
+  BasicBlock *GetInsertBlock() const { return BB; }
+  
+  /// SetInsertPoint - This specifies that created instructions should be
+  /// appended to the end of the specified block.
+  void SetInsertPoint(BasicBlock *TheBB) {
+    BB = TheBB;
+    InsertPt = BB->end();
+  }
+  
+  /// SetInsertPoint - This specifies that created instructions should be
+  /// inserted at the specified point.
+  void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
+    BB = TheBB;
+    InsertPt = IP;
+  }
+  
+  /// Insert - Insert and return the specified instruction.
+  template<typename InstTy>
+  InstTy *Insert(InstTy *I) const {
+    InsertHelper(I);
+    return I;
+  }
+  
+  /// InsertHelper - Insert the specified instruction at the specified insertion
+  /// point.  This is split out of Insert so that it isn't duplicated for every
+  /// template instantiation.
+  void InsertHelper(Instruction *I) const {
+    if (BB) BB->getInstList().insert(InsertPt, I);
+  }
+  
+  //===--------------------------------------------------------------------===//
+  // Instruction creation methods: Terminators
+  //===--------------------------------------------------------------------===//
+
+  /// CreateRetVoid - Create a 'ret void' instruction.
+  ReturnInst *CreateRetVoid() {
+    return Insert(ReturnInst::Create());
+  }
+
+  /// @verbatim
+  /// CreateRet - Create a 'ret <val>' instruction.
+  /// @endverbatim
+  ReturnInst *CreateRet(Value *V) {
+    return Insert(ReturnInst::Create(V));
+  }
+
+  ReturnInst *CreateRet(Value * const* retVals, unsigned N) {
+    return Insert(ReturnInst::Create(retVals,  N));
+  }
+  
+  GetResultInst *CreateGetResult(Value *V, unsigned Index, const char *Name = "") {
+    return Insert(new GetResultInst(V, Index, Name));
+  }
+    
+  /// CreateBr - Create an unconditional 'br label X' instruction.
+  BranchInst *CreateBr(BasicBlock *Dest) {
+    return Insert(BranchInst::Create(Dest));
+  }
+
+  /// CreateCondBr - Create a conditional 'br Cond, TrueDest, FalseDest'
+  /// instruction.
+  BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) {
+    return Insert(BranchInst::Create(True, False, Cond));
+  }
+  
+  /// CreateSwitch - Create a switch instruction with the specified value,
+  /// default dest, and with a hint for the number of cases that will be added
+  /// (for efficient allocation).
+  SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) {
+    return Insert(SwitchInst::Create(V, Dest, NumCases));
+  }
+  
+  /// CreateInvoke - Create an invoke instruction.
+  template<typename InputIterator>
+  InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
+                           BasicBlock *UnwindDest, InputIterator ArgBegin,
+                           InputIterator ArgEnd, const char *Name = "") {
+    return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest,
+                                     ArgBegin, ArgEnd, Name));
+  }
+  
+  UnwindInst *CreateUnwind() {
+    return Insert(new UnwindInst());
+  }
+
+  UnreachableInst *CreateUnreachable() {
+    return Insert(new UnreachableInst());
+  }
+  
+  //===--------------------------------------------------------------------===//
+  // Instruction creation methods: Binary Operators
+  //===--------------------------------------------------------------------===//
+
+  Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getAdd(LC, RC);      
+    return Insert(BinaryOperator::createAdd(LHS, RHS, Name));
+  }
+  Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getSub(LC, RC);
+    return Insert(BinaryOperator::createSub(LHS, RHS, Name));
+  }
+  Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getMul(LC, RC);
+    return Insert(BinaryOperator::createMul(LHS, RHS, Name));
+  }
+  Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
+      if (Constant *LC = dyn_cast<Constant>(LHS))
+          if (Constant *RC = dyn_cast<Constant>(RHS))
+              return ConstantExpr::getUDiv(LC, RC);
+      return Insert(BinaryOperator::createUDiv(LHS, RHS, Name));
+  }
+  Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getSDiv(LC, RC);      
+    return Insert(BinaryOperator::createSDiv(LHS, RHS, Name));
+  }
+  Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getFDiv(LC, RC);      
+    return Insert(BinaryOperator::createFDiv(LHS, RHS, Name));
+  }
+  Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getURem(LC, RC);
+    return Insert(BinaryOperator::createURem(LHS, RHS, Name));
+  }
+  Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getSRem(LC, RC);
+    return Insert(BinaryOperator::createSRem(LHS, RHS, Name));
+  }
+  Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getFRem(LC, RC);
+    return Insert(BinaryOperator::createFRem(LHS, RHS, Name));
+  }
+  Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getShl(LC, RC);
+    return Insert(BinaryOperator::createShl(LHS, RHS, Name));
+  }
+  Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getLShr(LC, RC);
+    return Insert(BinaryOperator::createLShr(LHS, RHS, Name));
+  }
+  Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getAShr(LC, RC);
+    return Insert(BinaryOperator::createAShr(LHS, RHS, Name));
+  }
+  Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getAnd(LC, RC);
+    return Insert(BinaryOperator::createAnd(LHS, RHS, Name));
+  }
+  Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getOr(LC, RC);
+    return Insert(BinaryOperator::createOr(LHS, RHS, Name));
+  }
+  Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
+    if (Constant *LC = dyn_cast<Constant>(LHS))
+        if (Constant *RC = dyn_cast<Constant>(RHS))
+            return ConstantExpr::getXor(LC, RC);
+    return Insert(BinaryOperator::createXor(LHS, RHS, Name));
+  }
+
+  BinaryOperator *CreateBinOp(Instruction::BinaryOps Opc,
+                              Value *LHS, Value *RHS, const char *Name = "") {
+    return Insert(BinaryOperator::create(Opc, LHS, RHS, Name));
+  }
+  
+  BinaryOperator *CreateNeg(Value *V, const char *Name = "") {
+    return Insert(BinaryOperator::createNeg(V, Name));
+  }
+  BinaryOperator *CreateNot(Value *V, const char *Name = "") {
+    return Insert(BinaryOperator::createNot(V, Name));
+  }
+  
+  //===--------------------------------------------------------------------===//
+  // Instruction creation methods: Memory Instructions
+  //===--------------------------------------------------------------------===//
+  
+  MallocInst *CreateMalloc(const Type *Ty, Value *ArraySize = 0,
+                           const char *Name = "") {
+    return Insert(new MallocInst(Ty, ArraySize, Name));
+  }
+  AllocaInst *CreateAlloca(const Type *Ty, Value *ArraySize = 0,
+                           const char *Name = "") {
+    return Insert(new AllocaInst(Ty, ArraySize, Name));
+  }
+  FreeInst *CreateFree(Value *Ptr) {
+    return Insert(new FreeInst(Ptr));
+  }
+  LoadInst *CreateLoad(Value *Ptr, const char *Name = 0) {
+    return Insert(new LoadInst(Ptr, Name));
+  }
+  LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const char *Name = 0) {
+    return Insert(new LoadInst(Ptr, Name, isVolatile));
+  }
+  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
+    return Insert(new StoreInst(Val, Ptr, isVolatile));
+  }
+  template<typename InputIterator>
+  Value *CreateGEP(Value *Ptr, InputIterator IdxBegin,
+                               InputIterator IdxEnd, const char *Name = "") {
+      
+    if (Constant *PC = dyn_cast<Constant>(Ptr)) {
+        // Every index must be constant.
+        InputIterator i;
+        for (i = IdxBegin; i < IdxEnd; ++i) {
+            if (!dyn_cast<Constant>(*i))
+                  break;
+        }
+        if (i == IdxEnd)
+            return ConstantExpr::getGetElementPtr(PC, &IdxBegin[0], IdxEnd - IdxBegin);
+    }      
+    return(Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd, Name)));
+  }
+  Value *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
+    if (Constant *PC = dyn_cast<Constant>(Ptr))
+        if (Constant *IC = dyn_cast<Constant>(Idx))
+            return ConstantExpr::getGetElementPtr(PC, &IC, 1);
+    return Insert(GetElementPtrInst::Create(Ptr, Idx, Name));
+  }
+  GetElementPtrInst *CreateStructGEP(Value *Ptr, unsigned Idx,
+                                     const char *Name = "") {
+    llvm::Value *Idxs[] = {
+      ConstantInt::get(llvm::Type::Int32Ty, 0),
+      ConstantInt::get(llvm::Type::Int32Ty, Idx)
+    };
+    return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2, Name));
+  }
+  
+  //===--------------------------------------------------------------------===//
+  // Instruction creation methods: Cast/Conversion Operators
+  //===--------------------------------------------------------------------===//
+    
+    Value *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
+        return CreateCast(Instruction::Trunc, V, DestTy, Name);
+    }
+    Value *CreateZExt(Value *V, const Type *DestTy, const char *Name = "") {
+        return CreateCast(Instruction::ZExt, V, DestTy, Name);
+    }
+    Value *CreateSExt(Value *V, const Type *DestTy, const char *Name = "") {
+        return CreateCast(Instruction::SExt, V, DestTy, Name);
+    }
+    Value *CreateFPToUI(Value *V, const Type *DestTy, const char *Name = ""){
+        return CreateCast(Instruction::FPToUI, V, DestTy, Name);
+    }
+    Value *CreateFPToSI(Value *V, const Type *DestTy, const char *Name = ""){
+        return CreateCast(Instruction::FPToSI, V, DestTy, Name);
+    }
+    Value *CreateUIToFP(Value *V, const Type *DestTy, const char *Name = ""){
+        return CreateCast(Instruction::UIToFP, V, DestTy, Name);
+    }
+    Value *CreateSIToFP(Value *V, const Type *DestTy, const char *Name = ""){
+        return CreateCast(Instruction::SIToFP, V, DestTy, Name);
+    }
+    Value *CreateFPTrunc(Value *V, const Type *DestTy,
+                         const char *Name = "") {
+        return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
+    }
+    Value *CreateFPExt(Value *V, const Type *DestTy, const char *Name = "") {
+        return CreateCast(Instruction::FPExt, V, DestTy, Name);
+    }
+    Value *CreatePtrToInt(Value *V, const Type *DestTy,
+                          const char *Name = "") {
+        return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
+    }
+    Value *CreateIntToPtr(Value *V, const Type *DestTy,
+                          const char *Name = "") {
+        return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
+    }
+    Value *CreateBitCast(Value *V, const Type *DestTy,
+                         const char *Name = "") {
+        return CreateCast(Instruction::BitCast, V, DestTy, Name);
+    }
+
+    Value *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy,
+                       const char *Name = "") {
+        if (V->getType() == DestTy)
+            return V;
+        if (Constant *VC = dyn_cast<Constant>(V))
+            return ConstantExpr::getCast(Op, VC, DestTy);      
+        return Insert(CastInst::create(Op, V, DestTy, Name));
+    }
+    Value *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
+                          const char *Name = "") {
+        if (V->getType() == DestTy)
+          return V;
+        if (Constant *VC = dyn_cast<Constant>(V))
+          return ConstantExpr::getIntegerCast(VC, DestTy, isSigned);
+        return Insert(CastInst::createIntegerCast(V, DestTy, isSigned, Name));
+    }
+
+
+
+    //===--------------------------------------------------------------------===//
+    // Instruction creation methods: Compare Instructions
+    //===--------------------------------------------------------------------===//
+    
+    Value *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
+    }
+    Value *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
+    }
+    Value *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
+    }
+    Value *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
+    }
+    Value *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
+    }
+    Value *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
+    }
+    Value *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
+    }
+    Value *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
+    }
+    Value *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
+    }
+    Value *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
+    }
+    
+    Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name);
+    }
+    Value *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name);
+    }
+    Value *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name);
+    }
+    Value *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name);
+    }
+    Value *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name);
+    }
+    Value *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") {
+        return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name);
+    }
+
+    Value *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS,
+                       const char *Name = "") {
+        if (Constant *LC = dyn_cast<Constant>(LHS))
+            if (Constant *RC = dyn_cast<Constant>(RHS))
+                return ConstantExpr::getCompare(P, LC, RC);      
+        return Insert(new ICmpInst(P, LHS, RHS, Name));
+    }
+    Value *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS,
+                       const char *Name = "") {
+        if (Constant *LC = dyn_cast<Constant>(LHS))
+            if (Constant *RC = dyn_cast<Constant>(RHS))
+                return ConstantExpr::getCompare(P, LC, RC);
+        return Insert(new FCmpInst(P, LHS, RHS, Name));
+    }
+
+    //===--------------------------------------------------------------------===//
+    // Instruction creation methods: Other Instructions
+    //===--------------------------------------------------------------------===//
+
+    PHINode *CreatePHI(const Type *Ty, const char *Name = "") {
+        return Insert(PHINode::Create(Ty, Name));
+    }
+
+    CallInst *CreateCall(Value *Callee, const char *Name = "") {
+        return Insert(CallInst::Create(Callee, Name));
+    }
+    CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") {
+        return Insert(CallInst::Create(Callee, Arg, Name));
+    }
+
+    template<typename InputIterator>
+    CallInst *CreateCall(Value *Callee, InputIterator ArgBegin,
+                       InputIterator ArgEnd, const char *Name = "") {
+        return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd, Name));
+    }
+
+    Value *CreateSelect(Value *C, Value *True, Value *False,
+                           const char *Name = "") {
+        if (Constant *CC = dyn_cast<Constant>(C))
+            if (Constant *TC = dyn_cast<Constant>(True))
+                if (Constant *FC = dyn_cast<Constant>(False))
+                    return ConstantExpr::getSelect(CC, TC, FC);      
+        return Insert(SelectInst::Create(C, True, False, Name));
+    }
+
+    VAArgInst *CreateVAArg(Value *List, const Type *Ty, const char *Name = "") {
+        return Insert(new VAArgInst(List, Ty, Name));
+    }
+
+    Value *CreateExtractElement(Value *Vec, Value *Idx,
+                                           const char *Name = "") {
+        if (Constant *VC = dyn_cast<Constant>(Vec))
+          if (Constant *IC = dyn_cast<Constant>(Idx))
+              return ConstantExpr::getExtractElement(VC, IC);
+        return Insert(new ExtractElementInst(Vec, Idx, Name));
+    }
+
+    Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
+                                         const char *Name = "") {
+        if (Constant *VC = dyn_cast<Constant>(Vec))
+          if (Constant *NC = dyn_cast<Constant>(NewElt))
+              if (Constant *IC = dyn_cast<Constant>(Idx))
+                  return ConstantExpr::getInsertElement(VC, NC, IC);
+        return Insert(InsertElementInst::Create(Vec, NewElt, Idx, Name));
+    }
+
+    Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
+                                         const char *Name = "") {
+        if (Constant *V1C = dyn_cast<Constant>(V1))
+          if (Constant *V2C = dyn_cast<Constant>(V2))
+              if (Constant *MC = dyn_cast<Constant>(Mask))
+                  return ConstantExpr::getShuffleVector(V1C, V2C, MC);      
+        return Insert(new ShuffleVectorInst(V1, V2, Mask, Name));
+    }
+};
+  
+}
+
+#endif
Index: include/llvm-c/Core.h
===================================================================
--- include/llvm-c/Core.h (revision 49474)
+++ include/llvm-c/Core.h (working copy)
@@ -38,7 +38,7 @@
 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
    and 'unwrap' conversion functions. */
 #include "llvm/Module.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 
 extern "C" {
 #endif
@@ -689,7 +689,7 @@
   DEFINE_ISA_CONVERSION_FUNCTIONS   (Value,              LLVMValueRef         )
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
-  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef       )
+  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder, LLVMBuilderRef       )
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider,     LLVMModuleProviderRef)
   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
Index: docs/tutorial/LangImpl3.html
===================================================================
--- docs/tutorial/LangImpl3.html (revision 49474)
+++ docs/tutorial/LangImpl3.html (working copy)
@@ -111,7 +111,7 @@
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
 
 static Module *TheModule;
-static LLVMBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 </pre>
 </div>
@@ -123,7 +123,7 @@
 
 <p>The <tt>Builder</tt> object is a helper object that makes it easy to generate
 LLVM instructions.  Instances of the <a
-href="http://llvm.org/doxygen/LLVMBuilder_8h-source.html"><tt>LLVMBuilder</tt></a>
+href="http://llvm.org/doxygen/IRBuilder_8h-source.html"><tt>IRBuilder</tt></a>
 class keep track of the current place to insert instructions and has methods to
 create new instructions.</p>
 
@@ -216,7 +216,7 @@
 </p>
 
 <p>In the example above, the LLVM builder class is starting to show its value.  
-LLVMBuilder knows where to insert the newly created instruction, all you have to
+IRBuilder knows where to insert the newly created instruction, all you have to
 do is specify what instruction to create (e.g. with <tt>CreateAdd</tt>), which
 operands to use (<tt>L</tt> and <tt>R</tt> here) and optionally provide a name
 for the generated instruction.</p>
@@ -680,7 +680,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
 #include "llvm/Analysis/Verifier.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -1023,7 +1023,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
Index: docs/tutorial/LangImpl4.html
===================================================================
--- docs/tutorial/LangImpl4.html (revision 49474)
+++ docs/tutorial/LangImpl4.html (working copy)
@@ -56,8 +56,8 @@
 
 <p>
 Our demonstration for Chapter 3 is elegant and easy to extend.  Unfortunately,
-it does not produce wonderful code.  For example, when compiling simple code,
-we don't get obvious optimizations:</p>
+it does not produce wonderful code.  The IRBuilder, however, does give us
+obvious optimizations when compiling simple code:</p>
 
 <div class="doc_code">
 <pre>
@@ -65,57 +65,45 @@
 Read function definition:
 define double @test(double %x) {
 entry:
-        %addtmp = add double 1.000000e+00, 2.000000e+00
-        %addtmp1 = add double %addtmp, %x
-        ret double %addtmp1
+        %addtmp = add double 3.000000e+00, %x
+        ret double %addtmp
 }
 </pre>
 </div>
 
-<p>This code is a very, very literal transcription of the AST built by parsing
-the input. As such, this transcription lacks optimizations like constant folding (we'd like to get "<tt>add x, 3.0</tt>" in the example above) as well as other more important
-optimizations.  Constant folding, in particular, is a very common and very
-important optimization: so much so that many language implementors implement
-constant folding support in their AST representation.</p>
+<p>This code is not a literal transcription of the AST built by parsing the
+input. That would be:
 
-<p>With LLVM, you don't need this support in the AST.  Since all calls to build LLVM IR go through
-the LLVM builder, it would be nice if the builder itself checked to see if there
-was a constant folding opportunity when you call it.  If so, it could just do
-the constant fold and return the constant instead of creating an instruction.
-This is exactly what the <tt>LLVMFoldingBuilder</tt> class does.  Lets make one
-change:
-
 <div class="doc_code">
 <pre>
-static LLVMFoldingBuilder Builder;
-</pre>
-</div>
-
-<p>All we did was switch from <tt>LLVMBuilder</tt> to
-<tt>LLVMFoldingBuilder</tt>.  Though we change no other code, we now have all of our
-instructions implicitly constant folded without us having to do anything
-about it.  For example, the input above now compiles to:</p>
-
-<div class="doc_code">
-<pre>
 ready&gt; <b>def test(x) 1+2+x;</b>
 Read function definition:
 define double @test(double %x) {
 entry:
-        %addtmp = add double 3.000000e+00, %x
-        ret double %addtmp
+        %addtmp = add double 2.000000e+00, 1.000000e+00
+        %addtmp1 = add double %addtmp, %x
+        ret double %addtmp1
 }
 </pre>
 </div>
 
-<p>Well, that was easy :).  In practice, we recommend always using
-<tt>LLVMFoldingBuilder</tt> when generating code like this.  It has no
+Constant folding, as seen above, in particular, is a very common and very
+important optimization: so much so that many language implementors implement
+constant folding support in their AST representation.</p>
+
+<p>With LLVM, you don't need this support in the AST.  Since all calls to build
+LLVM IR go through the LLVM IR builder, the builder itself checked to see if
+there was a constant folding opportunity when you call it.  If so, it just does
+the constant fold and return the constant instead of creating an instruction.
+
+<p>Well, that iss easy :).  In practice, we recommend always using
+<tt>IRBuilder</tt> when generating code like this.  It has no
 "syntactic overhead" for its use (you don't have to uglify your compiler with
 constant checks everywhere) and it can dramatically reduce the amount of
 LLVM IR that is generated in some cases (particular for languages with a macro
 preprocessor or that use a lot of constants).</p>
 
-<p>On the other hand, the <tt>LLVMFoldingBuilder</tt> is limited by the fact
+<p>On the other hand, the <tt>IRBuilder</tt> is limited by the fact
 that it does all of its analysis inline with the code as it is built.  If you
 take a slightly more complex example:</p>
 
@@ -525,7 +513,7 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -868,7 +856,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMFoldingBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 static FunctionPassManager *TheFPM;
 
Index: docs/tutorial/LangImpl5.html
===================================================================
--- docs/tutorial/LangImpl5.html (revision 49474)
+++ docs/tutorial/LangImpl5.html (working copy)
@@ -400,7 +400,7 @@
 
 <p>Once the blocks are created, we can emit the conditional branch that chooses
 between them.  Note that creating new blocks does not implicitly affect the
-LLVMBuilder, so it is still inserting into the block that the condition
+IRBuilder, so it is still inserting into the block that the condition
 went into.  Also note that it is creating a branch to the "then" block and the
 "else" block, even though the "else" block isn't inserted into the function yet.
 This is all ok: it is the standard way that LLVM supports forward
@@ -907,7 +907,7 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -1352,7 +1352,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMFoldingBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 static FunctionPassManager *TheFPM;
 
Index: docs/tutorial/LangImpl6.html
===================================================================
--- docs/tutorial/LangImpl6.html (revision 49474)
+++ docs/tutorial/LangImpl6.html (working copy)
@@ -827,7 +827,7 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -1357,7 +1357,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMFoldingBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, Value*&gt; NamedValues;
 static FunctionPassManager *TheFPM;
 
Index: docs/tutorial/LangImpl7.html
===================================================================
--- docs/tutorial/LangImpl7.html (revision 49474)
+++ docs/tutorial/LangImpl7.html (working copy)
@@ -422,14 +422,14 @@
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &amp;VarName) {
-  LLVMBuilder TmpB(&amp;TheFunction-&gt;getEntryBlock(),
+  IRBuilder TmpB(&amp;TheFunction-&gt;getEntryBlock(),
                    TheFunction-&gt;getEntryBlock().begin());
   return TmpB.CreateAlloca(Type::DoubleTy, 0, VarName.c_str());
 }
 </pre>
 </div>
 
-<p>This funny looking code creates an LLVMBuilder object that is pointing at
+<p>This funny looking code creates an IRBuilder object that is pointing at
 the first instruction (.begin()) of the entry block.  It then creates an alloca
 with the expected name and returns it.  Because all values in Kaleidoscope are
 doubles, there is no need to pass in a type to use.</p>
@@ -1009,7 +1009,7 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Transforms/Scalar.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include &lt;cstdio&gt;
 #include &lt;string&gt;
 #include &lt;map&gt;
@@ -1605,7 +1605,7 @@
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
-static LLVMFoldingBuilder Builder;
+static IRBuilder Builder;
 static std::map&lt;std::string, AllocaInst*&gt; NamedValues;
 static FunctionPassManager *TheFPM;
 
@@ -1615,7 +1615,7 @@
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &amp;VarName) {
-  LLVMBuilder TmpB(&amp;TheFunction-&gt;getEntryBlock(),
+  IRBuilder TmpB(&amp;TheFunction-&gt;getEntryBlock(),
                    TheFunction-&gt;getEntryBlock().begin());
   return TmpB.CreateAlloca(Type::DoubleTy, 0, VarName.c_str());
 }
Index: docs/tutorial/JITTutorial1.html
===================================================================
--- docs/tutorial/JITTutorial1.html (revision 49474)
+++ docs/tutorial/JITTutorial1.html (working copy)
@@ -60,7 +60,7 @@
 #include &lt;llvm/CallingConv.h&gt;
 #include &lt;llvm/Analysis/Verifier.h&gt;
 #include &lt;llvm/Assembly/PrintModulePass.h&gt;
-#include &lt;llvm/Support/LLVMBuilder.h&gt;
+#include &lt;llvm/Support/IRBuilder.h&gt;
 </pre>
 </div>
 
@@ -143,11 +143,11 @@
 <div class="doc_code">
 <pre>
   BasicBlock* block = new BasicBlock("entry", mul_add);
-  LLVMBuilder builder(block);
+  IRBuilder builder(block);
 </pre>
 </div>
 
-<p>We create a new basic block, as you might expect, by calling its constructor.  All we need to tell it is its name and the function to which it belongs.  In addition, we’re creating an <code>LLVMBuilder</code> object, which is a convenience interface for creating instructions and appending them to the end of a block.  Instructions can be created through their constructors as well, but some of their interfaces are quite complicated.  Unless you need a lot of control, using <code>LLVMBuilder</code> will make your life simpler.</p>
+<p>We create a new basic block, as you might expect, by calling its constructor.  All we need to tell it is its name and the function to which it belongs.  In addition, we’re creating an <code>IRBuilder</code> object, which is a convenience interface for creating instructions and appending them to the end of a block.  Instructions can be created through their constructors as well, but some of their interfaces are quite complicated.  Unless you need a lot of control, using <code>IRBuilder</code> will make your life simpler.</p>
 
 <div class="doc_code">
 <pre>
@@ -163,7 +163,7 @@
 </pre>
 </div>
 
-<p>The final step in creating our function is to create the instructions that make it up.  Our <code>mul_add</code> function is composed of just three instructions: a multiply, an add, and a return.  <code>LLVMBuilder</code> gives us a simple interface for constructing these instructions and appending them to the “entry” block.  Each of the calls to <code>LLVMBuilder</code> returns a <code>Value*</code> that represents the value yielded by the instruction.  You’ll also notice that, above, <code>x</code>, <code>y</code>, and <code>z</code> are also <code>Value*</code>’s, so it’s clear that instructions operate on <code>Value*</code>’s.</p>
+<p>The final step in creating our function is to create the instructions that make it up.  Our <code>mul_add</code> function is composed of just three instructions: a multiply, an add, and a return.  <code>IRBuilder</code> gives us a simple interface for constructing these instructions and appending them to the “entry” block.  Each of the calls to <code>IRBuilder</code> returns a <code>Value*</code> that represents the value yielded by the instruction.  You’ll also notice that, above, <code>x</code>, <code>y</code>, and <code>z</code> are also <code>Value*</code>’s, so it’s clear that instructions operate on <code>Value*</code>’s.</p>
 
 <p>And that’s it!  Now you can compile and run your code, and get a wonderful textual print out of the LLVM IR we saw at the beginning.  To compile, use the following command line as a guide:</p>
 
Index: docs/tutorial/JITTutorial2.html
===================================================================
--- docs/tutorial/JITTutorial2.html (revision 49474)
+++ docs/tutorial/JITTutorial2.html (working copy)
@@ -56,7 +56,7 @@
 #include &lt;llvm/PassManager.h&gt;
 #include &lt;llvm/Analysis/Verifier.h&gt;
 #include &lt;llvm/Assembly/PrintModulePass.h&gt;
-#include &lt;llvm/Support/LLVMBuilder.h&gt;
+#include &lt;llvm/Support/IRBuilder.h&gt;
 
 using namespace llvm;
 
@@ -110,13 +110,13 @@
 
 <div class="doc_code">
 <pre>
-  LLVMBuilder builder(entry);
+  IRBuilder builder(entry);
   Value* xEqualsY = builder.CreateICmpEQ(x, y, &quot;tmp&quot;);
   builder.CreateCondBr(xEqualsY, ret, cond_false);
 </pre>
 </div>
 
-<p>Our next block, <code>ret</code>, is pretty simple: it just returns the value of <code>x</code>.  Recall that this block is only reached if <code>x == y</code>, so this is the correct behavior.  Notice that instead of creating a new <code>LLVMBuilder</code> for each block, we can use <code>SetInsertPoint</code> to retarget our existing one.  This saves on construction and memory allocation costs.</p>
+<p>Our next block, <code>ret</code>, is pretty simple: it just returns the value of <code>x</code>.  Recall that this block is only reached if <code>x == y</code>, so this is the correct behavior.  Notice that instead of creating a new <code>IRBuilder</code> for each block, we can use <code>SetInsertPoint</code> to retarget our existing one.  This saves on construction and memory allocation costs.</p>
 
 <div class="doc_code">
 <pre>
Index: docs/tutorial/OCamlLangImpl3.html
===================================================================
--- docs/tutorial/OCamlLangImpl3.html (revision 49474)
+++ docs/tutorial/OCamlLangImpl3.html (working copy)
@@ -108,7 +108,7 @@
 
 <p>The <tt>Codegen.builder</tt> object is a helper object that makes it easy to
 generate LLVM instructions.  Instances of the <a
-href="http://llvm.org/doxygen/LLVMBuilder_8h-source.html"><tt>LLVMBuilder</tt></a>
+href="http://llvm.org/doxygen/IRBuilder_8h-source.html"><tt>IRBuilder</tt></a>
 class keep track of the current place to insert instructions and has methods to
 create new instructions.</p>
 
@@ -194,7 +194,7 @@
 </p>
 
 <p>In the example above, the LLVM builder class is starting to show its value.
-LLVMBuilder knows where to insert the newly created instruction, all you have to
+IRBuilder knows where to insert the newly created instruction, all you have to
 do is specify what instruction to create (e.g. with <tt>Llvm.create_add</tt>),
 which operands to use (<tt>lhs</tt> and <tt>rhs</tt> here) and optionally
 provide a name for the generated instruction.</p>
Index: docs/tutorial/OCamlLangImpl4.html
===================================================================
--- docs/tutorial/OCamlLangImpl4.html (revision 49474)
+++ docs/tutorial/OCamlLangImpl4.html (working copy)
@@ -58,7 +58,8 @@
 
 <div class="doc_text">
 
-<p><b>Note:</b> the ocaml bindings already use <tt>LLVMFoldingBuilder</tt>.<p>
+<p><b>Note:</b> the default <tt>IRBuilder</tt> now always includes the constant
+folding optimisations below.<p>
 
 <p>
 Our demonstration for Chapter 3 is elegant and easy to extend.  Unfortunately,
Index: docs/tutorial/OCamlLangImpl5.html
===================================================================
--- docs/tutorial/OCamlLangImpl5.html (revision 49474)
+++ docs/tutorial/OCamlLangImpl5.html (working copy)
@@ -455,7 +455,7 @@
 
 <p>Once the blocks are created, we can emit the conditional branch that chooses
 between them.  Note that creating new blocks does not implicitly affect the
-LLVMBuilder, so it is still inserting into the block that the condition
+IRBuilder, so it is still inserting into the block that the condition
 went into.  This is why we needed to save the "start" block.</p>
 
 <div class="doc_code">
Index: bindings/ocaml/llvm/llvm_ocaml.c
===================================================================
--- bindings/ocaml/llvm/llvm_ocaml.c (revision 49474)
+++ bindings/ocaml/llvm/llvm_ocaml.c (working copy)
@@ -776,7 +776,7 @@
 }
 
 static struct custom_operations builder_ops = {
-  (char *) "LLVMBuilder",
+  (char *) "IRBuilder",
   llvm_finalize_builder,
   custom_compare_default,
   custom_hash_default,
Index: Xcode/LLVM.xcodeproj/project.pbxproj
===================================================================
--- Xcode/LLVM.xcodeproj/project.pbxproj (revision 49474)
+++ Xcode/LLVM.xcodeproj/project.pbxproj (working copy)
@@ -162,7 +162,6 @@
  9F7794280C73CB6100551F9C /* MipsTargetMachine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MipsTargetMachine.h; sourceTree = "<group>"; };
  9F77942F0C73CB7900551F9C /* MSILWriter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MSILWriter.cpp; sourceTree = "<group>"; };
  9F7794300C73CB7900551F9C /* MSILWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MSILWriter.h; sourceTree = "<group>"; };
- 9F7794870C73D51000551F9C /* LLVMBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LLVMBuilder.h; sourceTree = "<group>"; };
  9F7794880C73D51000551F9C /* MemoryBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryBuffer.h; sourceTree = "<group>"; };
  9F7794890C73D51000551F9C /* Streams.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Streams.h; sourceTree = "<group>"; };
  9F7C23E50CB81C2100498408 /* Analysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Analysis.h; sourceTree = "<group>"; };
@@ -1071,6 +1070,32 @@
  DE8170AB08CFB44D0093BDEF /* TableGenBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = TableGenBackend.cpp; sourceTree = "<group>"; };
  DE8170AC08CFB44D0093BDEF /* TableGenBackend.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = TableGenBackend.h; sourceTree = "<group>"; };
  DEFAB19D0959E9A100E0AB42 /* DwarfWriter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = DwarfWriter.h; path = ../include/llvm/CodeGen/DwarfWriter.h; sourceTree = SOURCE_ROOT; };
+ F22627320DAE34D10008F441 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = index.html; sourceTree = "<group>"; };
+ F22627330DAE34D20008F441 /* JITTutorial1.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = JITTutorial1.html; sourceTree = "<group>"; };
+ F22627340DAE34D20008F441 /* JITTutorial2-1.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "JITTutorial2-1.png"; sourceTree = "<group>"; };
+ F22627350DAE34D20008F441 /* JITTutorial2.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = JITTutorial2.html; sourceTree = "<group>"; };
+ F22627360DAE34D20008F441 /* LangImpl1.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl1.html; sourceTree = "<group>"; };
+ F22627370DAE34D20008F441 /* LangImpl2.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl2.html; sourceTree = "<group>"; };
+ F22627380DAE34D20008F441 /* LangImpl3.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl3.html; sourceTree = "<group>"; };
+ F22627390DAE34D20008F441 /* LangImpl4.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl4.html; sourceTree = "<group>"; };
+ F226273A0DAE34D20008F441 /* LangImpl5-cfg.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "LangImpl5-cfg.png"; sourceTree = "<group>"; };
+ F226273B0DAE34D20008F441 /* LangImpl5.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl5.html; sourceTree = "<group>"; };
+ F226273C0DAE34D20008F441 /* LangImpl6.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl6.html; sourceTree = "<group>"; };
+ F226273D0DAE34D20008F441 /* LangImpl7.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl7.html; sourceTree = "<group>"; };
+ F226273E0DAE34D20008F441 /* LangImpl8.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = LangImpl8.html; sourceTree = "<group>"; };
+ F226273F0DAE34D20008F441 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = "<group>"; };
+ F22627400DAE34D20008F441 /* OCamlLangImpl1.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl1.html; sourceTree = "<group>"; };
+ F22627410DAE34D20008F441 /* OCamlLangImpl2.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl2.html; sourceTree = "<group>"; };
+ F22627420DAE34D20008F441 /* OCamlLangImpl3.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl3.html; sourceTree = "<group>"; };
+ F22627430DAE34D20008F441 /* OCamlLangImpl4.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl4.html; sourceTree = "<group>"; };
+ F22627440DAE34D20008F441 /* OCamlLangImpl5.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl5.html; sourceTree = "<group>"; };
+ F22627450DAE34D20008F441 /* OCamlLangImpl6.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl6.html; sourceTree = "<group>"; };
+ F22627460DAE34D20008F441 /* OCamlLangImpl7.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = OCamlLangImpl7.html; sourceTree = "<group>"; };
+ F22761DF0DAD09CD003D8065 /* BrainF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = BrainF.cpp; path = BrainF/BrainF.cpp; sourceTree = "<group>"; };
+ F22761E00DAD09CD003D8065 /* BrainF.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = BrainF.h; path = BrainF/BrainF.h; sourceTree = "<group>"; };
+ F22761E10DAD09CD003D8065 /* BrainFDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = BrainFDriver.cpp; path = BrainF/BrainFDriver.cpp; sourceTree = "<group>"; };
+ F27C8CE90DAD2EF900A33844 /* IRBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IRBuilder.h; sourceTree = "<group>"; };
+ F27C8CFF0DAD307700A33844 /* ShadowStackCollector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ShadowStackCollector.cpp; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXGroup section */
@@ -1580,6 +1605,7 @@
  DE66ED3E08ABEC2A00323D32 /* lib/CodeGen */ = {
  isa = PBXGroup;
  children = (
+ F27C8CFF0DAD307700A33844 /* ShadowStackCollector.cpp */,
  754221420D171DFC00DDB61B /* MachineLICM.cpp */,
  9FE450AB0C77AB6100C4FEA4 /* README.txt */,
  DE66ED8308ABEC2B00323D32 /* SelectionDAG */,
@@ -2417,6 +2443,7 @@
  DE66F26E08ABF03200323D32 /* Support */ = {
  isa = PBXGroup;
  children = (
+ F27C8CE90DAD2EF900A33844 /* IRBuilder.h */,
  DE66F27008ABF03200323D32 /* AIXDataTypesFix.h */,
  9F5B90CE0D0CE89300CDFDEA /* AlignOf.h */,
  CF8F1B430B64F74400BB4199 /* Allocator.h */,
@@ -2440,7 +2467,6 @@
  DE66F28108ABF03200323D32 /* InstIterator.h */,
  DE66F28208ABF03200323D32 /* InstVisitor.h */,
  DE66F28308ABF03200323D32 /* LeakDetector.h */,
- 9F7794870C73D51000551F9C /* LLVMBuilder.h */,
  CF8F1B460B64F74400BB4199 /* ManagedStatic.h */,
  DE66F28408ABF03200323D32 /* Mangler.h */,
  DE66F28508ABF03200323D32 /* MathExtras.h */,
@@ -2631,6 +2657,7 @@
  DE66F38D08ABF35C00323D32 /* docs */ = {
  isa = PBXGroup;
  children = (
+ F22627310DAE34D10008F441 /* tutorial */,
  DE66F38F08ABF35C00323D32 /* AliasAnalysis.html */,
  DE66F39008ABF35C00323D32 /* Bugpoint.html */,
  DE66F39208ABF35C00323D32 /* GCCFEBuildInstrs.html */,
@@ -2717,6 +2744,9 @@
  DE66F3FD08ABF37000323D32 /* examples */ = {
  isa = PBXGroup;
  children = (
+ F22761DF0DAD09CD003D8065 /* BrainF.cpp */,
+ F22761E00DAD09CD003D8065 /* BrainF.h */,
+ F22761E10DAD09CD003D8065 /* BrainFDriver.cpp */,
  DE66F40E08ABF37000323D32 /* fibonacci.cpp */,
  DE66F41508ABF37000323D32 /* HowToUseJIT.cpp */,
  DE66F41E08ABF37000323D32 /* ModuleMaker.cpp */,
@@ -2771,6 +2801,34 @@
  path = TableGen;
  sourceTree = "<group>";
  };
+ F22627310DAE34D10008F441 /* tutorial */ = {
+ isa = PBXGroup;
+ children = (
+ F22627320DAE34D10008F441 /* index.html */,
+ F22627330DAE34D20008F441 /* JITTutorial1.html */,
+ F22627340DAE34D20008F441 /* JITTutorial2-1.png */,
+ F22627350DAE34D20008F441 /* JITTutorial2.html */,
+ F22627360DAE34D20008F441 /* LangImpl1.html */,
+ F22627370DAE34D20008F441 /* LangImpl2.html */,
+ F22627380DAE34D20008F441 /* LangImpl3.html */,
+ F22627390DAE34D20008F441 /* LangImpl4.html */,
+ F226273A0DAE34D20008F441 /* LangImpl5-cfg.png */,
+ F226273B0DAE34D20008F441 /* LangImpl5.html */,
+ F226273C0DAE34D20008F441 /* LangImpl6.html */,
+ F226273D0DAE34D20008F441 /* LangImpl7.html */,
+ F226273E0DAE34D20008F441 /* LangImpl8.html */,
+ F226273F0DAE34D20008F441 /* Makefile */,
+ F22627400DAE34D20008F441 /* OCamlLangImpl1.html */,
+ F22627410DAE34D20008F441 /* OCamlLangImpl2.html */,
+ F22627420DAE34D20008F441 /* OCamlLangImpl3.html */,
+ F22627430DAE34D20008F441 /* OCamlLangImpl4.html */,
+ F22627440DAE34D20008F441 /* OCamlLangImpl5.html */,
+ F22627450DAE34D20008F441 /* OCamlLangImpl6.html */,
+ F22627460DAE34D20008F441 /* OCamlLangImpl7.html */,
+ );
+ path = tutorial;
+ sourceTree = "<group>";
+ };
 /* End PBXGroup section */
 
 /* Begin PBXLegacyTarget section */
Index: lib/CodeGen/ShadowStackCollector.cpp
===================================================================
--- lib/CodeGen/ShadowStackCollector.cpp (revision 49474)
+++ lib/CodeGen/ShadowStackCollector.cpp (working copy)
@@ -31,7 +31,7 @@
 #include "llvm/CodeGen/Collector.h"
 #include "llvm/IntrinsicInst.h"
 #include "llvm/Module.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 
 using namespace llvm;
 
@@ -61,9 +61,9 @@
     Constant *GetFrameMap(Function &F);
     const Type* GetConcreteStackEntryType(Function &F);
     void CollectRoots(Function &F);
-    static GetElementPtrInst *CreateGEP(LLVMBuilder &B, Value *BasePtr,
+    static GetElementPtrInst *CreateGEP(IRBuilder &B, Value *BasePtr,
                                         int Idx1, const char *Name);
-    static GetElementPtrInst *CreateGEP(LLVMBuilder &B, Value *BasePtr,
+    static GetElementPtrInst *CreateGEP(IRBuilder &B, Value *BasePtr,
                                         int Idx1, int Idx2, const char *Name);
   };
   
@@ -86,13 +86,13 @@
     // State.
     int State;
     Function::iterator StateBB, StateE;
-    LLVMBuilder Builder;
+    IRBuilder Builder;
     
   public:
     EscapeEnumerator(Function &F, const char *N = "cleanup")
       : F(F), CleanupBBName(N), State(0) {}
     
-    LLVMBuilder *Next() {
+    IRBuilder *Next() {
       switch (State) {
       default:
         return 0;
@@ -339,20 +339,28 @@
 }
 
 GetElementPtrInst *
-ShadowStackCollector::CreateGEP(LLVMBuilder &B, Value *BasePtr,
+ShadowStackCollector::CreateGEP(IRBuilder &B, Value *BasePtr,
                                 int Idx, int Idx2, const char *Name) {
   Value *Indices[] = { ConstantInt::get(Type::Int32Ty, 0),
                        ConstantInt::get(Type::Int32Ty, Idx),
                        ConstantInt::get(Type::Int32Ty, Idx2) };
-  return B.CreateGEP(BasePtr, Indices, Indices + 3, Name);
+  Value* Val = B.CreateGEP(BasePtr, Indices, Indices + 3, Name);
+    
+  assert(isa<GetElementPtrInst>(Val) && "Unexpected folded constant");
+    
+  return dyn_cast<GetElementPtrInst>(Val);
 }
 
 GetElementPtrInst *
-ShadowStackCollector::CreateGEP(LLVMBuilder &B, Value *BasePtr,
+ShadowStackCollector::CreateGEP(IRBuilder &B, Value *BasePtr,
                                 int Idx, const char *Name) {
   Value *Indices[] = { ConstantInt::get(Type::Int32Ty, 0),
                        ConstantInt::get(Type::Int32Ty, Idx) };
-  return B.CreateGEP(BasePtr, Indices, Indices + 2, Name);
+  Value *Val = B.CreateGEP(BasePtr, Indices, Indices + 2, Name);
+    
+  assert(isa<GetElementPtrInst>(Val) && "Unexpected folded constant");
+
+  return dyn_cast<GetElementPtrInst>(Val);
 }
 
 /// runOnFunction - Insert code to maintain the shadow stack.
@@ -371,7 +379,7 @@
   
   // Build the shadow stack entry at the very start of the function.
   BasicBlock::iterator IP = F.getEntryBlock().begin();
-  LLVMBuilder AtEntry(IP->getParent(), IP);
+  IRBuilder AtEntry(IP->getParent(), IP);
   
   Instruction *StackEntry   = AtEntry.CreateAlloca(ConcreteStackEntryTy, 0,
                                                    "gc_frame");
@@ -409,7 +417,7 @@
   
   // For each instruction that escapes...
   EscapeEnumerator EE(F, "gc_cleanup");
-  while (LLVMBuilder *AtExit = EE.Next()) {
+  while (IRBuilder *AtExit = EE.Next()) {
     // Pop the entry from the shadow stack. Don't reuse CurrentHead from
     // AtEntry, since that would make the value live for the entire function.
     Instruction *EntryNextPtr2 = CreateGEP(*AtExit, StackEntry, 0, 0,
Index: lib/VMCore/Core.cpp
===================================================================
--- lib/VMCore/Core.cpp (revision 49474)
+++ lib/VMCore/Core.cpp (working copy)
@@ -962,7 +962,7 @@
 /*===-- Instruction builders ----------------------------------------------===*/
 
 LLVMBuilderRef LLVMCreateBuilder() {
-  return wrap(new LLVMFoldingBuilder());
+  return wrap(new IRBuilder());
 }
 
 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
Index: examples/BrainF/BrainF.cpp
===================================================================
--- examples/BrainF/BrainF.cpp (revision 49474)
+++ examples/BrainF/BrainF.cpp (working copy)
@@ -71,7 +71,7 @@
   brainf_func = cast<Function>(module->
     getOrInsertFunction("brainf", Type::VoidTy, NULL));
 
-  builder = new LLVMBuilder(BasicBlock::Create(label, brainf_func));
+  builder = new IRBuilder(BasicBlock::Create(label, brainf_func));
 
   //%arr = malloc i8, i32 %d
   ConstantInt *val_mem = ConstantInt::get(APInt(32, memtotal));
@@ -193,7 +193,7 @@
           Value *tape_0 = getchar_call;
 
           //%tape.%d = trunc i32 %tape.%d to i8
-          TruncInst *tape_1 = builder->
+          Value *tape_1 = builder->
             CreateTrunc(tape_0, IntegerType::Int8Ty, tapereg);
 
           //store i8 %tape.%d, i8 *%head.%d
@@ -207,7 +207,7 @@
           LoadInst *tape_0 = builder->CreateLoad(curhead, tapereg);
 
           //%tape.%d = sext i8 %tape.%d to i32
-          SExtInst *tape_1 = builder->
+          Value *tape_1 = builder->
             CreateSExt(tape_0, IntegerType::Int32Ty, tapereg);
 
           //call i32 @putchar(i32 %tape.%d)
@@ -232,15 +232,15 @@
           if (comflag & flag_arraybounds)
           {
             //%test.%d = icmp uge i8 *%head.%d, %arrmax
-            ICmpInst *test_0 = builder->
+            Value *test_0 = builder->
               CreateICmpUGE(curhead, ptr_arrmax, testreg);
 
             //%test.%d = icmp ult i8 *%head.%d, %arr
-            ICmpInst *test_1 = builder->
+            Value *test_1 = builder->
               CreateICmpULT(curhead, ptr_arr, testreg);
 
             //%test.%d = or i1 %test.%d, %test.%d
-            BinaryOperator *test_2 = builder->
+            Value *test_2 = builder->
               CreateOr(test_0, test_1, testreg);
 
             //br i1 %test.%d, label %main.%d, label %main.%d
@@ -259,7 +259,7 @@
           LoadInst *tape_0 = builder->CreateLoad(curhead, tapereg);
 
           //%tape.%d = add i8 %tape.%d, %d
-          BinaryOperator *tape_1 = builder->
+          Value *tape_1 = builder->
             CreateAdd(tape_0, ConstantInt::get(APInt(8, curvalue)), tapereg);
 
           //store i8 %tape.%d, i8 *%head.%d\n"
Index: examples/BrainF/BrainF.h
===================================================================
--- examples/BrainF/BrainF.h (revision 49474)
+++ examples/BrainF/BrainF.h (working copy)
@@ -16,7 +16,7 @@
 #define BRAINF_H
 
 #include "llvm/Module.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 
 using namespace llvm;
 
@@ -84,7 +84,7 @@
     BasicBlock *aberrorbb;
 
     /// Variables
-    LLVMBuilder *builder;
+    IRBuilder *builder;
     Value *curhead;
 };
 

Index: gcc/llvm-convert.cpp
===================================================================
--- gcc/llvm-convert.cpp (revision 49475)
+++ gcc/llvm-convert.cpp (working copy)
@@ -406,12 +406,12 @@
   struct FunctionPrologArgumentConversion : public DefaultABIClient {
     tree FunctionDecl;
     Function::arg_iterator &AI;
-    LLVMFoldingBuilder Builder;
+    IRBuilder Builder;
     std::vector<Value*> LocStack;
     std::vector<std::string> NameStack;
     FunctionPrologArgumentConversion(tree FnDecl,
                                      Function::arg_iterator &ai,
-                                     const LLVMFoldingBuilder &B)
+                                     const IRBuilder &B)
       : FunctionDecl(FnDecl), AI(ai), Builder(B) {}
     
     void setName(const std::string &Name) {
@@ -1251,7 +1251,7 @@
 /// CopyAggregate - Recursively traverse the potientially aggregate src/dest
 /// ptrs, copying all of the elements.
 static void CopyAggregate(MemRef DestLoc, MemRef SrcLoc,
-                          LLVMFoldingBuilder &Builder, tree gccType) {
+                          IRBuilder &Builder, tree gccType) {
   assert(DestLoc.Ptr->getType() == SrcLoc.Ptr->getType() &&
          "Cannot copy between two pointers of different type!");
   const Type *ElTy =
@@ -1341,7 +1341,7 @@
 
 /// ZeroAggregate - Recursively traverse the potentially aggregate DestLoc,
 /// zero'ing all of the elements.
-static void ZeroAggregate(MemRef DestLoc, LLVMFoldingBuilder &Builder) {
+static void ZeroAggregate(MemRef DestLoc, IRBuilder &Builder) {
   const Type *ElTy =
     cast<PointerType>(DestLoc.Ptr->getType())->getElementType();
   if (ElTy->isFirstClassType()) {
@@ -2308,7 +2308,7 @@
     const FunctionType *FTy;
     const MemRef *DestLoc;
     bool useReturnSlot;
-    LLVMFoldingBuilder &Builder;
+    IRBuilder &Builder;
     Value *TheValue;
     MemRef RetBuf;
     bool isShadowRet;
@@ -2318,7 +2318,7 @@
                                    const FunctionType *FnTy,
                                    const MemRef *destloc,
                                    bool ReturnSlotOpt,
-                                   LLVMFoldingBuilder &b)
+                                   IRBuilder &b)
       : CallOperands(ops), FTy(FnTy), DestLoc(destloc),
         useReturnSlot(ReturnSlotOpt), Builder(b), isShadowRet(false),
         isAggrRet(false) { }
Index: gcc/llvm-internal.h
===================================================================
--- gcc/llvm-internal.h (revision 49475)
+++ gcc/llvm-internal.h (working copy)
@@ -37,7 +37,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Support/LLVMBuilder.h"
+#include "llvm/Support/IRBuilder.h"
 #include "llvm/Support/Streams.h"
 
 extern "C" {
@@ -279,7 +279,7 @@
 
   /// Builder - Instruction creator, the location to insert into is always the
   /// same as &Fn->back().
-  LLVMFoldingBuilder Builder;
+  IRBuilder Builder;
 
   // AllocaInsertionPoint - Place to insert alloca instructions.  Lazily created
   // and managed by CreateTemporary.

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: LLVMBuilder vs LLVMFoldingBuilder

Chris Lattner
On Apr 10, 2008, at 7:05 AM, Dominic Hamon wrote:

> Dominic Hamon wrote:
>> Duncan Sands wrote:
>>>> Another option that was discussed in #llvm is to nuke LLVMBuilder  
>>>> and rename LLVMFoldingBuilder to LLVMBuilder. If this was the  
>>>> case, I'd argue for a flag in the Builder that could retain the  
>>>> old non-folding functionality for debugging purposes.
>>>>
>>>
>>> this plan sounds good to me.  However it's not clear to me how  
>>> useful a
>>> debug flag would really be.
>>>
>>>
>>
>> This is my first patch so please let me know if there are any  
>> problems or anything I need to do differently.

>>
> And there were. updated patches attached.

Looking good.  One big comment: Please attach patches to email instead  
of including them inline.

Some nits:

> +  Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
> +    if (Constant *LC = dyn_cast<Constant>(LHS))
> +        if (Constant *RC = dyn_cast<Constant>(RHS))
> +            return ConstantExpr::getMul(LC, RC);
> +    return Insert(BinaryOperator::createMul(LHS, RHS, Name));
> +  }

Please consistently indent by 2, not 4.

>
> +
> +    Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
> +                                         const char *Name = "") {

Very picky, but 'const char *Name' should line up with 'Value *Vec'.

> Index: gcc/llvm-convert.cpp
> ===================================================================
> --- gcc/llvm-convert.cpp (revision 49475)
> +++ gcc/llvm-convert.cpp (working copy)

Please attach llvm-gcc patches as a separate patch file.

Otherwise looks great!

-Chris

_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
Reply | Threaded
Open this post in threaded view
|

Re: LLVMBuilder vs LLVMFoldingBuilder

Gordon Henriksen-3
On Apr 11, 2008, at 02:19, Chris Lattner wrote:

> On Apr 10, 2008, at 7:05 AM, Dominic Hamon wrote:
>
>> And there were. updated patches attached.
>
> Looking good.  One big comment: Please attach patches to email  
> instead of including them inline.

Thunderbird and Mail are once again conspiring against Chris. The fix  
is to make Thunderbird attach attachments instead of placing them  
inline:

http://lists.cs.uiuc.edu/pipermail/llvmdev/2008-January/011992.html

— Gordon


_______________________________________________
LLVM Developers mailing list
[hidden email]         http://llvm.cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
12