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;
 };
 
