# HG changeset patch
# User lindquist
# Date 1210694291 -7200
# Node ID 9d44ec83acd1d551d35e53a26cb6a55c18df7786
# Parent  11fe364b9a3e9d8488dd6ceaea45effc06a80ec5
[svn r221] Update: Switched to the 2.3 LLVM svn branch, http://llvm.org/svn/llvm-project/llvm/branches/release_23 .
Fixed: Implemented volatile statements. Uses the LLVM memory barrier intrinsic, closes #21 .

diff -r 11fe364b9a3e -r 9d44ec83acd1 dmd/mars.c
--- a/dmd/mars.c	Tue May 13 16:16:50 2008 +0200
+++ b/dmd/mars.c	Tue May 13 17:58:11 2008 +0200
@@ -158,7 +158,7 @@
 
 void usage()
 {
-    printf("LLVM D Compiler %s (based on DMD %s and LLVM 2.2)\n%s\n%s\n",
+    printf("LLVM D Compiler %s (based on DMD %s and LLVM 2.3)\n%s\n%s\n",
     global.llvmdc_version, global.version, global.copyright, global.written);
     printf("\
 D Language Documentation: http://www.digitalmars.com/d/1.0/index.html\n\
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/arrays.cpp
--- a/gen/arrays.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/arrays.cpp	Tue May 13 17:58:11 2008 +0200
@@ -248,7 +248,7 @@
     llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, funcname);
     assert(fn);
     Logger::cout() << "calling array init function: " << *fn <<'\n';
-    llvm::CallInst* call = new llvm::CallInst(fn, args.begin(), args.end(), "", gIR->scopebb());
+    llvm::CallInst* call = llvm::CallInst::Create(fn, args.begin(), args.end(), "", gIR->scopebb());
     call->setCallingConv(llvm::CallingConv::C);
 }
 
@@ -444,7 +444,7 @@
     llargs[2] = sz1;
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 }
 
 void DtoArrayCopyToSlice(DSliceValue* dst, DValue* src)
@@ -464,7 +464,7 @@
     llargs[2] = sz1;
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -487,7 +487,7 @@
     llargs[2] = n;
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -579,7 +579,7 @@
     DSliceValue* slice = DtoResizeDynArray(array->getType(), array, newdim);
 
     llvm::Value* ptr = slice->ptr;
-    ptr = new llvm::GetElementPtrInst(ptr, idx, "tmp", gIR->scopebb());
+    ptr = llvm::GetElementPtrInst::Create(ptr, idx, "tmp", gIR->scopebb());
 
     DValue* dptr = new DVarValue(exp->type, ptr, true);
 
@@ -897,7 +897,7 @@
     args.push_back(llvm::ConstantInt::get(DtoSize_t(), nsz, false));
 
     llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_array_cast_len");
-    return new llvm::CallInst(fn, args.begin(), args.end(), "tmp", gIR->scopebb());
+    return llvm::CallInst::Create(fn, args.begin(), args.end(), "tmp", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/classes.cpp
--- a/gen/classes.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/classes.cpp	Tue May 13 17:58:11 2008 +0200
@@ -883,7 +883,7 @@
     llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -911,7 +911,7 @@
             a = DtoBitCast(a, aty);
         ctorargs.push_back(a);
     }
-    llvm::CallInst* call = new llvm::CallInst(fn, ctorargs.begin(), ctorargs.end(), "tmp", gIR->scopebb());
+    llvm::CallInst* call = llvm::CallInst::Create(fn, ctorargs.begin(), ctorargs.end(), "tmp", gIR->scopebb());
     call->setCallingConv(DtoCallingConv(LINKd));
 
     return new DImValue(type, call, false);
@@ -926,7 +926,7 @@
     {
         FuncDeclaration* fd = (FuncDeclaration*)arr->data[i];
         assert(fd->ir.irFunc->func);
-        new llvm::CallInst(fd->ir.irFunc->func, instance, "", gIR->scopebb());
+        llvm::CallInst::Create(fd->ir.irFunc->func, instance, "", gIR->scopebb());
     }
 }
 
@@ -1162,7 +1162,7 @@
                 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
             //Logger::cout() << "indexing: " << *ptr << '\n';
             if (vd->ir.irField->indexOffset)
-                ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
+                ptr = llvm::GetElementPtrInst::Create(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
             //Logger::cout() << "indexing: " << *ptr << '\n';
             return ptr;
         }
@@ -1175,7 +1175,7 @@
                 ptr = DtoGEP(ptr, idxs, "tmp");
                 if (ptr->getType() != llt)
                     ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
-                ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
+                ptr = llvm::GetElementPtrInst::Create(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
                 std::vector<unsigned> tmp;
                 return DtoIndexStruct(ptr, ssd, t, os-vd->offset, tmp);
             }
@@ -1198,7 +1198,7 @@
     size_t llt_sz = getABITypeSize(llt->getContainedType(0));
     assert(os % llt_sz == 0);
     ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
-    return new llvm::GetElementPtrInst(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
+    return llvm::GetElementPtrInst::Create(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1360,12 +1360,12 @@
     gname.append(cd->mangle());
     gname.append("12__destructorMFZv");
 
-    llvm::Function* func = new llvm::Function(fnTy, DtoInternalLinkage(cd), gname, gIR->module);
+    llvm::Function* func = llvm::Function::Create(fnTy, DtoInternalLinkage(cd), gname, gIR->module);
     llvm::Value* thisptr = func->arg_begin();
     thisptr->setName("this");
 
-    llvm::BasicBlock* bb = new llvm::BasicBlock("entry", func);
-    LLVMBuilder builder(bb);
+    llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry", func);
+    IRBuilder builder(bb);
 
     for (size_t i = 0; i < cd->dtors.dim; i++)
     {
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/complex.cpp
--- a/gen/complex.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/complex.cpp	Tue May 13 17:58:11 2008 +0200
@@ -135,9 +135,9 @@
     llvm::Constant* undef = llvm::UndefValue::get(base);
     llvm::Constant* zero;
     if (ty == Tfloat32 || ty == Timaginary32 || ty == Tcomplex32)
-        zero = llvm::ConstantFP::get(llvm::Type::FloatTy, llvm::APFloat(0.0f));
+        zero = llvm::ConstantFP::get(llvm::APFloat(0.0f));
     else if (ty == Tfloat64 || ty == Timaginary64 || ty == Tcomplex64 || ty == Tfloat80 || ty == Timaginary80 || ty == Tcomplex80)
-        zero = llvm::ConstantFP::get(llvm::Type::DoubleTy, llvm::APFloat(0.0));
+        zero = llvm::ConstantFP::get(llvm::APFloat(0.0));
 
     if (t->isimaginary()) {
         return new DComplexValue(to, zero, val->getRVal());
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/dwarftypes.cpp
--- a/gen/dwarftypes.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/dwarftypes.cpp	Tue May 13 17:58:11 2008 +0200
@@ -155,25 +155,25 @@
   
   // Function Declarations
   
-  Function* func_llvm_dbg_func_start = new Function(
+  Function* func_llvm_dbg_func_start = Function::Create(
     /*Type=*/FuncTy_3,
     /*Linkage=*/GlobalValue::ExternalLinkage,
     /*Name=*/"llvm.dbg.func.start", mod); // (external, no body)
   func_llvm_dbg_func_start->setCallingConv(CallingConv::C);
   
-  Function* func_llvm_dbg_stoppoint = new Function(
+  Function* func_llvm_dbg_stoppoint = Function::Create(
     /*Type=*/FuncTy_4,
     /*Linkage=*/GlobalValue::ExternalLinkage,
     /*Name=*/"llvm.dbg.stoppoint", mod); // (external, no body)
   func_llvm_dbg_stoppoint->setCallingConv(CallingConv::C);
   
-  Function* func_llvm_dbg_declare = new Function(
+  Function* func_llvm_dbg_declare = Function::Create(
     /*Type=*/FuncTy_5,
     /*Linkage=*/GlobalValue::ExternalLinkage,
     /*Name=*/"llvm.dbg.declare", mod); // (external, no body)
   func_llvm_dbg_declare->setCallingConv(CallingConv::C);
   
-  Function* func_llvm_dbg_region_end = new Function(
+  Function* func_llvm_dbg_region_end = Function::Create(
     /*Type=*/FuncTy_3,
     /*Linkage=*/GlobalValue::ExternalLinkage,
     /*Name=*/"llvm.dbg.region.end", mod); // (external, no body)
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/functions.cpp
--- a/gen/functions.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/functions.cpp	Tue May 13 17:58:11 2008 +0200
@@ -362,7 +362,7 @@
     const llvm::FunctionType* functype = DtoFunctionType(fdecl);
     llvm::Function* func = vafunc ? vafunc : gIR->module->getFunction(mangled_name);
     if (!func)
-        func = new llvm::Function(functype, DtoLinkage(fdecl), mangled_name, gIR->module);
+        func = llvm::Function::Create(functype, DtoLinkage(fdecl), mangled_name, gIR->module);
     else
         assert(func->getFunctionType() == functype);
 
@@ -489,8 +489,11 @@
             if (fd->isMain())
                 gIR->emitMain = true;
 
-            llvm::BasicBlock* beginbb = new llvm::BasicBlock("entry",func);
-            llvm::BasicBlock* endbb = new llvm::BasicBlock("endentry",func);
+            std::string entryname("entry_");
+            entryname.append(fd->toPrettyChars());
+
+            llvm::BasicBlock* beginbb = llvm::BasicBlock::Create(entryname,func);
+            llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endentry",func);
 
             //assert(gIR->scopes.empty());
             gIR->scopes.push_back(IRScope(beginbb, endbb));
@@ -608,10 +611,10 @@
                         // pass the previous block into this block
                         if (global.params.symdebug) DtoDwarfFuncEnd(fd);
                         if (func->getReturnType() == llvm::Type::VoidTy) {
-                            new llvm::ReturnInst(gIR->scopebb());
+                            llvm::ReturnInst::Create(gIR->scopebb());
                         }
                         else {
-                            new llvm::ReturnInst(llvm::UndefValue::get(func->getReturnType()), gIR->scopebb());
+                            llvm::ReturnInst::Create(llvm::UndefValue::get(func->getReturnType()), gIR->scopebb());
                         }
                     }
                 }
@@ -636,10 +639,10 @@
                 else {
                     new llvm::UnreachableInst(lastbb);
                     /*if (func->getReturnType() == llvm::Type::VoidTy) {
-                        new llvm::ReturnInst(lastbb);
+                        llvm::ReturnInst::Create(lastbb);
                     }
                     else {
-                        new llvm::ReturnInst(llvm::UndefValue::get(func->getReturnType()), lastbb);
+                        llvm::ReturnInst::Create(llvm::UndefValue::get(func->getReturnType()), lastbb);
                     }*/
                 }
             }
@@ -670,18 +673,18 @@
     const llvm::Type* rettype = (const llvm::Type*)llvm::Type::Int32Ty;
 
     llvm::FunctionType* functype = llvm::FunctionType::get(rettype, pvec, false);
-    llvm::Function* func = new llvm::Function(functype,llvm::GlobalValue::ExternalLinkage,"main",ir.module);
+    llvm::Function* func = llvm::Function::Create(functype,llvm::GlobalValue::ExternalLinkage,"main",ir.module);
 
-    llvm::BasicBlock* bb = new llvm::BasicBlock("entry",func);
+    llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry",func);
 
     // call static ctors
     llvm::Function* fn = LLVM_D_GetRuntimeFunction(ir.module,"_moduleCtor");
-    llvm::Instruction* apt = new llvm::CallInst(fn,"",bb);
+    llvm::Instruction* apt = llvm::CallInst::Create(fn,"",bb);
 
     // run unit tests if -unittest is provided
     if (global.params.useUnitTests) {
         fn = LLVM_D_GetRuntimeFunction(ir.module,"_moduleUnitTests");
-        llvm::Instruction* apt = new llvm::CallInst(fn,"",bb);
+        llvm::Instruction* apt = llvm::CallInst::Create(fn,"",bb);
     }
 
     // call user main function
@@ -709,22 +712,22 @@
         ptr = DtoGEPi(a,0,1,"tmp",bb);
         new llvm::StoreInst(arr,ptr,bb);
         args.push_back(a);
-        new llvm::CallInst(mfn, args.begin(), args.end(), "", bb);
-        call = new llvm::CallInst(ir.mainFunc,a,"ret",bb);
+        llvm::CallInst::Create(mfn, args.begin(), args.end(), "", bb);
+        call = llvm::CallInst::Create(ir.mainFunc,a,"ret",bb);
     }
     else
     {
         // main with no arguments
-        call = new llvm::CallInst(ir.mainFunc,"ret",bb);
+        call = llvm::CallInst::Create(ir.mainFunc,"ret",bb);
     }
     call->setCallingConv(ir.mainFunc->getCallingConv());
 
     // call static dtors
     fn = LLVM_D_GetRuntimeFunction(ir.module,"_moduleDtor");
-    new llvm::CallInst(fn,"",bb);
+    llvm::CallInst::Create(fn,"",bb);
 
     // return
-    new llvm::ReturnInst(call,bb);
+    llvm::ReturnInst::Create(call,bb);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/irstate.cpp
--- a/gen/irstate.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/irstate.cpp	Tue May 13 17:58:11 2008 +0200
@@ -57,6 +57,7 @@
     llvm_DeclareMemSet64 = NULL;
     llvm_DeclareMemCpy32 = NULL;
     llvm_DeclareMemCpy64 = NULL;
+    llvm_DeclareMemBarrier = NULL;
 }
 
 IrFunction* IRState::func()
@@ -120,9 +121,9 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-LLVMBuilder* IRBuilderHelper::operator->()
+IRBuilder* IRBuilderHelper::operator->()
 {
-    LLVMBuilder& b = state->scope().builder;
+    IRBuilder& b = state->scope().builder;
     assert(b.GetInsertBlock() != NULL);
     return &b;
 }
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/irstate.h
--- a/gen/irstate.h	Tue May 13 16:16:50 2008 +0200
+++ b/gen/irstate.h	Tue May 13 17:58:11 2008 +0200
@@ -32,7 +32,7 @@
 {
     llvm::BasicBlock* begin;
     llvm::BasicBlock* end;
-    LLVMBuilder builder;
+    IRBuilder builder;
 
     IRScope();
     IRScope(llvm::BasicBlock* b, llvm::BasicBlock* e);
@@ -53,7 +53,7 @@
 struct IRBuilderHelper
 {
     IRState* state;
-    LLVMBuilder* operator->();
+    IRBuilder* operator->();
 };
 
 struct IRExp
@@ -146,6 +146,7 @@
     llvm::Function* llvm_DeclareMemSet64;
     llvm::Function* llvm_DeclareMemCpy32;
     llvm::Function* llvm_DeclareMemCpy64;
+    llvm::Function* llvm_DeclareMemBarrier;
 };
 
 #endif // LLVMDC_GEN_IRSTATE_H
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/llvm.h
--- a/gen/llvm.h	Tue May 13 16:16:50 2008 +0200
+++ b/gen/llvm.h	Tue May 13 17:58:11 2008 +0200
@@ -13,7 +13,7 @@
 
 #include "llvm/Target/TargetData.h"
 
-#include "llvm/Support/LLVMBuilder.h"
-using llvm::LLVMBuilder;
+#include "llvm/Support/IRBuilder.h"
+using llvm::IRBuilder;
 
 #endif // GEN_LLVM_H
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/runtime.cpp
--- a/gen/runtime.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/runtime.cpp	Tue May 13 17:58:11 2008 +0200
@@ -217,9 +217,9 @@
         types.push_back(stringTy);
         types.push_back(intTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname3, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname3, M);
     }
 
     // void _d_assert_msg( char[] msg, char[] file, uint line )
@@ -230,7 +230,7 @@
         types.push_back(stringTy);
         types.push_back(intTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -243,7 +243,7 @@
         std::vector<const llvm::Type*> types;
         types.push_back(typeInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // void* _d_newarrayT(TypeInfo ti, size_t length)
@@ -255,8 +255,8 @@
         types.push_back(typeInfoTy);
         types.push_back(sizeTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
     }
 
     // void* _d_arraysetlengthT(TypeInfo ti, size_t newlength, size_t plength, void* pdata)
@@ -270,8 +270,8 @@
         types.push_back(sizeTy);
         types.push_back(voidPtrTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
     }
 
     // Object _d_newclass(ClassInfo ci)
@@ -280,7 +280,7 @@
         std::vector<const llvm::Type*> types;
         types.push_back(classInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -296,7 +296,7 @@
         types.push_back(sizeTy); \
         types.push_back(TY); \
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
     }
 
     ARRAY_INIT(boolTy,"i1")
@@ -320,7 +320,7 @@
         types.push_back(voidPtrTy);
         types.push_back(sizeTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -335,8 +335,8 @@
         types.push_back(TY); \
         types.push_back(rt_dg1()); \
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
     }
     STR_APPLY1(stringTy, "_aApplycw1", "_aApplycd1")
     STR_APPLY1(wstringTy, "_aApplywc1", "_aApplywd1")
@@ -351,8 +351,8 @@
         types.push_back(TY); \
         types.push_back(rt_dg2()); \
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
     }
     STR_APPLY2(stringTy, "_aApplycw2", "_aApplycd2")
     STR_APPLY2(wstringTy, "_aApplywc2", "_aApplywd2")
@@ -367,8 +367,8 @@
         types.push_back(TY); \
         types.push_back(rt_dg1()); \
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
     }
     STR_APPLY_R1(stringTy, "_aApplyRcw1", "_aApplyRcd1")
     STR_APPLY_R1(wstringTy, "_aApplyRwc1", "_aApplyRwd1")
@@ -383,8 +383,8 @@
         types.push_back(TY); \
         types.push_back(rt_dg2()); \
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M); \
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M); \
     }
     STR_APPLY_R2(stringTy, "_aApplyRcw2", "_aApplyRcd2")
     STR_APPLY_R2(wstringTy, "_aApplyRwc2", "_aApplyRwd2")
@@ -404,7 +404,7 @@
         types.push_back(sizeTy);
         types.push_back(sizeTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(sizeTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -420,7 +420,7 @@
         types.push_back(rt_ptr(rt_ptr(byteTy)));
         types.push_back(rt_array(stringTy->getContainedType(0)));
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -434,7 +434,7 @@
         std::vector<const llvm::Type*> types;
         types.push_back(voidPtrTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // cast interface
@@ -445,7 +445,7 @@
         types.push_back(voidPtrTy);
         types.push_back(classInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // dynamic cast
@@ -456,7 +456,7 @@
         types.push_back(objectTy);
         types.push_back(classInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -472,8 +472,8 @@
         types.push_back(stringTy);
         types.push_back(stringTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
     }
 
     // wchar[] _adReverseWchar(wchar[] a)
@@ -485,8 +485,8 @@
         types.push_back(wstringTy);
         types.push_back(wstringTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
     }
 
     // Array _adReverse(Array a, size_t szelem)
@@ -497,7 +497,7 @@
         types.push_back(rt_array(byteTy));
         types.push_back(sizeTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // Array _adDupT(TypeInfo ti, Array a)
@@ -508,7 +508,7 @@
         types.push_back(typeInfoTy);
         types.push_back(rt_array(byteTy));
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // int _adEq(Array a1, Array a2, TypeInfo ti)
@@ -521,8 +521,8 @@
         types.push_back(rt_array(byteTy));
         types.push_back(typeInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
     }
 
     // int _adCmpChar(Array a1, Array a2)
@@ -532,7 +532,7 @@
         types.push_back(rt_array(byteTy));
         types.push_back(rt_array(byteTy));
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // Array _adSort(Array a, TypeInfo ti)
@@ -543,7 +543,7 @@
         types.push_back(rt_array(byteTy));
         types.push_back(typeInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -556,7 +556,7 @@
         std::vector<const llvm::Type*> types;
         types.push_back(aaTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(sizeTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // void* _aaGet(AA* aa, TypeInfo keyti, size_t valuesize, void* pkey)
@@ -568,7 +568,7 @@
         types.push_back(sizeTy);
         types.push_back(voidPtrTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // void* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, void* pkey)
@@ -580,7 +580,7 @@
         types.push_back(sizeTy);
         types.push_back(voidPtrTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // void* _aaIn(AA aa, TypeInfo keyti, void* pkey)
@@ -591,7 +591,7 @@
         types.push_back(typeInfoTy);
         types.push_back(voidPtrTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // void _aaDel(AA aa, TypeInfo keyti, void* pkey)
@@ -602,7 +602,7 @@
         types.push_back(typeInfoTy);
         types.push_back(voidPtrTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // ArrayRet_t _aaValues(AA aa, size_t keysize, size_t valuesize)
@@ -614,7 +614,7 @@
         types.push_back(sizeTy);
         types.push_back(sizeTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // void* _aaRehash(AA* paa, TypeInfo keyti)
@@ -624,7 +624,7 @@
         types.push_back(aaTy);
         types.push_back(typeInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidPtrTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // ArrayRet_t _aaKeys(AA aa, size_t keysize)
@@ -635,7 +635,7 @@
         types.push_back(aaTy);
         types.push_back(sizeTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // int _aaApply(AA aa, size_t keysize, dg_t dg)
@@ -646,7 +646,7 @@
         types.push_back(sizeTy);
         types.push_back(rt_dg1());
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // int _aaApply2(AA aa, size_t keysize, dg2_t dg)
@@ -657,7 +657,7 @@
         types.push_back(sizeTy);
         types.push_back(rt_dg1());
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -671,8 +671,8 @@
         std::string fname2("_moduleDtor");
         std::vector<const llvm::Type*> types;
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname2, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -685,7 +685,7 @@
         std::vector<const llvm::Type*> types;
         types.push_back(voidPtrTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // Object _d_dynamic_cast(Object o, ClassInfo c)
@@ -695,7 +695,7 @@
         types.push_back(objectTy);
         types.push_back(classInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // Object _d_interface_cast(void* p, ClassInfo c)
@@ -705,7 +705,7 @@
         types.push_back(voidPtrTy);
         types.push_back(classInfoTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(objectTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -718,7 +718,7 @@
         std::vector<const llvm::Type*> types;
         types.push_back(objectTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(voidTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     /////////////////////////////////////////////////////////////////////////////////////
@@ -732,7 +732,7 @@
         types.push_back(rt_array(rt_array2(byteTy)));
         types.push_back(stringTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // int _d_switch_ustring(wchar[][] table, wchar[] ca)
@@ -742,7 +742,7 @@
         types.push_back(rt_array(rt_array2(shortTy)));
         types.push_back(wstringTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 
     // int _d_switch_dstring(dchar[][] table, dchar[] ca)
@@ -752,7 +752,7 @@
         types.push_back(rt_array(rt_array2(intTy)));
         types.push_back(dstringTy);
         const llvm::FunctionType* fty = llvm::FunctionType::get(intTy, types, false);
-        new llvm::Function(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
+        llvm::Function::Create(fty, llvm::GlobalValue::ExternalLinkage, fname, M);
     }
 }
 
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/statements.cpp
--- a/gen/statements.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/statements.cpp	Tue May 13 17:58:11 2008 +0200
@@ -92,8 +92,13 @@
 
             emit_finallyblocks(p, enclosingtryfinally, NULL);
 
+            if (gIR->func()->inVolatile) {
+                // store-load barrier
+                DtoMemoryBarrier(false, false, true, false);
+            }
+
             if (global.params.symdebug) DtoDwarfFuncEnd(f->decl);
-            new llvm::ReturnInst(p->scopebb());
+            llvm::ReturnInst::Create(p->scopebb());
 
         }
         else {
@@ -112,8 +117,13 @@
 
             emit_finallyblocks(p, enclosingtryfinally, NULL);
 
+            if (gIR->func()->inVolatile) {
+                // store-load barrier
+                DtoMemoryBarrier(false, false, true, false);
+            }
+
             if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
-            new llvm::ReturnInst(v, p->scopebb());
+            llvm::ReturnInst::Create(v, p->scopebb());
         }
     }
     else
@@ -121,8 +131,13 @@
         if (p->topfunc()->getReturnType() == llvm::Type::VoidTy) {
             emit_finallyblocks(p, enclosingtryfinally, NULL);
 
+            if (gIR->func()->inVolatile) {
+                // store-load barrier
+                DtoMemoryBarrier(false, false, true, false);
+            }
+
             if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
-            new llvm::ReturnInst(p->scopebb());
+            llvm::ReturnInst::Create(p->scopebb());
         }
         else {
             assert(0); // why should this ever happen?
@@ -173,15 +188,15 @@
 
     llvm::BasicBlock* oldend = gIR->scopeend();
 
-    llvm::BasicBlock* ifbb = new llvm::BasicBlock("if", gIR->topfunc(), oldend);
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("endif", gIR->topfunc(), oldend);
-    llvm::BasicBlock* elsebb = elsebody ? new llvm::BasicBlock("else", gIR->topfunc(), endbb) : endbb;
+    llvm::BasicBlock* ifbb = llvm::BasicBlock::Create("if", gIR->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endif", gIR->topfunc(), oldend);
+    llvm::BasicBlock* elsebb = elsebody ? llvm::BasicBlock::Create("else", gIR->topfunc(), endbb) : endbb;
 
     if (cond_val->getType() != llvm::Type::Int1Ty) {
         Logger::cout() << "if conditional: " << *cond_val << '\n';
         cond_val = DtoBoolean(cond_val);
     }
-    llvm::Value* ifgoback = new llvm::BranchInst(ifbb, elsebb, cond_val, gIR->scopebb());
+    llvm::Value* ifgoback = llvm::BranchInst::Create(ifbb, elsebb, cond_val, gIR->scopebb());
 
     // replace current scope
     gIR->scope() = IRScope(ifbb,elsebb);
@@ -189,7 +204,7 @@
     // do scoped statements
     ifbody->toIR(p);
     if (!gIR->scopereturned()) {
-        new llvm::BranchInst(endbb,gIR->scopebb());
+        llvm::BranchInst::Create(endbb,gIR->scopebb());
     }
 
     if (elsebody) {
@@ -197,7 +212,7 @@
         gIR->scope() = IRScope(elsebb,endbb);
         elsebody->toIR(p);
         if (!gIR->scopereturned()) {
-            new llvm::BranchInst(endbb,gIR->scopebb());
+            llvm::BranchInst::Create(endbb,gIR->scopebb());
         }
     }
 
@@ -223,10 +238,10 @@
     }
     else {
         assert(!p->scopereturned());
-        beginbb = new llvm::BasicBlock("scope", p->topfunc(), oldend);
-        new llvm::BranchInst(beginbb, p->scopebb());
+        beginbb = llvm::BasicBlock::Create("scope", p->topfunc(), oldend);
+        llvm::BranchInst::Create(beginbb, p->scopebb());
     }
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("endscope", p->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endscope", p->topfunc(), oldend);
 
     gIR->scope() = IRScope(beginbb, endbb);
 
@@ -246,13 +261,13 @@
 
     // create while blocks
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* whilebb = new llvm::BasicBlock("whilecond", gIR->topfunc(), oldend);
-    llvm::BasicBlock* whilebodybb = new llvm::BasicBlock("whilebody", gIR->topfunc(), oldend);
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("endwhile", gIR->topfunc(), oldend);
+    llvm::BasicBlock* whilebb = llvm::BasicBlock::Create("whilecond", gIR->topfunc(), oldend);
+    llvm::BasicBlock* whilebodybb = llvm::BasicBlock::Create("whilebody", gIR->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endwhile", gIR->topfunc(), oldend);
 
     // move into the while block
     p->ir->CreateBr(whilebb);
-    //new llvm::BranchInst(whilebb, gIR->scopebb());
+    //llvm::BranchInst::Create(whilebb, gIR->scopebb());
 
     // replace current scope
     gIR->scope() = IRScope(whilebb,endbb);
@@ -263,7 +278,7 @@
     delete cond_e;
 
     // conditional branch
-    llvm::Value* ifbreak = new llvm::BranchInst(whilebodybb, endbb, cond_val, p->scopebb());
+    llvm::Value* ifbreak = llvm::BranchInst::Create(whilebodybb, endbb, cond_val, p->scopebb());
 
     // rewrite scope
     gIR->scope() = IRScope(whilebodybb,endbb);
@@ -275,7 +290,7 @@
 
     // loop
     if (!gIR->scopereturned())
-        new llvm::BranchInst(whilebb, gIR->scopebb());
+        llvm::BranchInst::Create(whilebb, gIR->scopebb());
 
     // rewrite the scope
     gIR->scope() = IRScope(endbb,oldend);
@@ -290,12 +305,12 @@
 
     // create while blocks
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* dowhilebb = new llvm::BasicBlock("dowhile", gIR->topfunc(), oldend);
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("enddowhile", gIR->topfunc(), oldend);
+    llvm::BasicBlock* dowhilebb = llvm::BasicBlock::Create("dowhile", gIR->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("enddowhile", gIR->topfunc(), oldend);
 
     // move into the while block
     assert(!gIR->scopereturned());
-    new llvm::BranchInst(dowhilebb, gIR->scopebb());
+    llvm::BranchInst::Create(dowhilebb, gIR->scopebb());
 
     // replace current scope
     gIR->scope() = IRScope(dowhilebb,endbb);
@@ -311,7 +326,7 @@
     delete cond_e;
 
     // conditional branch
-    llvm::Value* ifbreak = new llvm::BranchInst(dowhilebb, endbb, cond_val, gIR->scopebb());
+    llvm::Value* ifbreak = llvm::BranchInst::Create(dowhilebb, endbb, cond_val, gIR->scopebb());
 
     // rewrite the scope
     gIR->scope() = IRScope(endbb,oldend);
@@ -326,10 +341,10 @@
 
     // create for blocks
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* forbb = new llvm::BasicBlock("forcond", gIR->topfunc(), oldend);
-    llvm::BasicBlock* forbodybb = new llvm::BasicBlock("forbody", gIR->topfunc(), oldend);
-    llvm::BasicBlock* forincbb = new llvm::BasicBlock("forinc", gIR->topfunc(), oldend);
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("endfor", gIR->topfunc(), oldend);
+    llvm::BasicBlock* forbb = llvm::BasicBlock::Create("forcond", gIR->topfunc(), oldend);
+    llvm::BasicBlock* forbodybb = llvm::BasicBlock::Create("forbody", gIR->topfunc(), oldend);
+    llvm::BasicBlock* forincbb = llvm::BasicBlock::Create("forinc", gIR->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endfor", gIR->topfunc(), oldend);
 
     // init
     if (init != 0)
@@ -337,7 +352,7 @@
 
     // move into the for condition block, ie. start the loop
     assert(!gIR->scopereturned());
-    new llvm::BranchInst(forbb, gIR->scopebb());
+    llvm::BranchInst::Create(forbb, gIR->scopebb());
 
     p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,forincbb,endbb));
 
@@ -351,7 +366,7 @@
 
     // conditional branch
     assert(!gIR->scopereturned());
-    new llvm::BranchInst(forbodybb, endbb, cond_val, gIR->scopebb());
+    llvm::BranchInst::Create(forbodybb, endbb, cond_val, gIR->scopebb());
 
     // rewrite scope
     gIR->scope() = IRScope(forbodybb,forincbb);
@@ -361,7 +376,7 @@
 
     // move into the for increment block
     if (!gIR->scopereturned())
-        new llvm::BranchInst(forincbb, gIR->scopebb());
+        llvm::BranchInst::Create(forincbb, gIR->scopebb());
     gIR->scope() = IRScope(forincbb, endbb);
 
     // increment
@@ -372,7 +387,7 @@
 
     // loop
     if (!gIR->scopereturned())
-        new llvm::BranchInst(forbb, gIR->scopebb());
+        llvm::BranchInst::Create(forbb, gIR->scopebb());
 
     p->loopbbs.pop_back();
 
@@ -402,7 +417,7 @@
         IRState::LoopScopeVec::reverse_iterator it;
         for(it = gIR->loopbbs.rbegin(); it != gIR->loopbbs.rend(); ++it) {
             if(it->s == targetLoopStatement) {
-                new llvm::BranchInst(it->end, gIR->scopebb());
+                llvm::BranchInst::Create(it->end, gIR->scopebb());
                 return;
             }
         }
@@ -410,7 +425,7 @@
     }
     else {
         emit_finallyblocks(p, enclosingtryfinally, gIR->loopbbs.back().enclosingtryfinally);
-        new llvm::BranchInst(gIR->loopbbs.back().end, gIR->scopebb());
+        llvm::BranchInst::Create(gIR->loopbbs.back().end, gIR->scopebb());
     }
 }
 
@@ -436,7 +451,7 @@
         IRState::LoopScopeVec::reverse_iterator it;
         for(it = gIR->loopbbs.rbegin(); it != gIR->loopbbs.rend(); ++it) {
             if(it->s == targetLoopStatement) {
-                new llvm::BranchInst(it->begin, gIR->scopebb());
+                llvm::BranchInst::Create(it->begin, gIR->scopebb());
                 return;
             }
         }
@@ -444,7 +459,7 @@
     }
     else {
         emit_finallyblocks(p, enclosingtryfinally, gIR->loopbbs.back().enclosingtryfinally);
-        new llvm::BranchInst(gIR->loopbbs.back().begin, gIR->scopebb());
+        llvm::BranchInst::Create(gIR->loopbbs.back().begin, gIR->scopebb());
     }
 }
 
@@ -469,13 +484,13 @@
     // create basic blocks
     llvm::BasicBlock* oldend = p->scopeend();
 
-    llvm::BasicBlock* trybb = new llvm::BasicBlock("try", p->topfunc(), oldend);
-    llvm::BasicBlock* finallybb = new llvm::BasicBlock("finally", p->topfunc(), oldend);
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("endtryfinally", p->topfunc(), oldend);
+    llvm::BasicBlock* trybb = llvm::BasicBlock::Create("try", p->topfunc(), oldend);
+    llvm::BasicBlock* finallybb = llvm::BasicBlock::Create("finally", p->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endtryfinally", p->topfunc(), oldend);
 
     // pass the previous BB into this
     assert(!gIR->scopereturned());
-    new llvm::BranchInst(trybb, p->scopebb());
+    llvm::BranchInst::Create(trybb, p->scopebb());
 
     // do the try block
     p->scope() = IRScope(trybb,finallybb);
@@ -485,7 +500,7 @@
 
     // terminate try BB
     if (!p->scopereturned())
-        new llvm::BranchInst(finallybb, p->scopebb());
+        llvm::BranchInst::Create(finallybb, p->scopebb());
 
     // do finally block
     p->scope() = IRScope(finallybb,endbb);
@@ -494,7 +509,7 @@
 
     // terminate finally
     if (!gIR->scopereturned()) {
-        new llvm::BranchInst(endbb, p->scopebb());
+        llvm::BranchInst::Create(endbb, p->scopebb());
     }
 
     // rewrite the scope
@@ -513,13 +528,13 @@
     // create basic blocks
     llvm::BasicBlock* oldend = p->scopeend();
 
-    llvm::BasicBlock* trybb = new llvm::BasicBlock("try", p->topfunc(), oldend);
-    llvm::BasicBlock* catchbb = new llvm::BasicBlock("catch", p->topfunc(), oldend);
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("endtrycatch", p->topfunc(), oldend);
+    llvm::BasicBlock* trybb = llvm::BasicBlock::Create("try", p->topfunc(), oldend);
+    llvm::BasicBlock* catchbb = llvm::BasicBlock::Create("catch", p->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endtrycatch", p->topfunc(), oldend);
 
     // pass the previous BB into this
     assert(!gIR->scopereturned());
-    new llvm::BranchInst(trybb, p->scopebb());
+    llvm::BranchInst::Create(trybb, p->scopebb());
 
     // do the try block
     p->scope() = IRScope(trybb,catchbb);
@@ -527,11 +542,11 @@
     body->toIR(p);
 
     if (!gIR->scopereturned())
-        new llvm::BranchInst(endbb, p->scopebb());
+        llvm::BranchInst::Create(endbb, p->scopebb());
 
     // do catch
     p->scope() = IRScope(catchbb,oldend);
-    new llvm::BranchInst(endbb, p->scopebb());
+    llvm::BranchInst::Create(endbb, p->scopebb());
     /*assert(catches);
     for(size_t i=0; i<catches->dim; ++i)
     {
@@ -643,7 +658,7 @@
         CaseStatement* cs = (CaseStatement*)cases->data[i];
 
         std::string lblname("case");
-        llvm::BasicBlock* bb = new llvm::BasicBlock(lblname, p->topfunc(), oldend);
+        llvm::BasicBlock* bb = llvm::BasicBlock::Create(lblname, p->topfunc(), oldend);
         cs->bodyBB = bb;
 
         std::vector<llvm::ConstantInt*> tmp;
@@ -711,12 +726,12 @@
     // default
     llvm::BasicBlock* defbb = 0;
     if (!hasNoDefault) {
-        defbb = new llvm::BasicBlock("default", p->topfunc(), oldend);
+        defbb = llvm::BasicBlock::Create("default", p->topfunc(), oldend);
         sdefault->bodyBB = defbb;
     }
 
     // end (break point)
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("switchend", p->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("switchend", p->topfunc(), oldend);
 
     // condition var
     llvm::Value* condVal;
@@ -729,7 +744,7 @@
     else {
         condVal = call_string_switch_runtime(switchTable, condition);
     }
-    llvm::SwitchInst* si = new llvm::SwitchInst(condVal, defbb ? defbb : endbb, cases->dim, p->scopebb());
+    llvm::SwitchInst* si = llvm::SwitchInst::Create(condVal, defbb ? defbb : endbb, cases->dim, p->scopebb());
 
     // add the cases
     size_t n = vcases.size();
@@ -754,7 +769,7 @@
         llvm::BasicBlock* curbb = p->scopebb();
         if (curbb->empty() || !curbb->back().isTerminator())
         {
-            new llvm::BranchInst(nextbb, curbb);
+            llvm::BranchInst::Create(nextbb, curbb);
         }
     }
 
@@ -770,7 +785,7 @@
         llvm::BasicBlock* curbb = p->scopebb();
         if (curbb->empty() || !curbb->back().isTerminator())
         {
-            new llvm::BranchInst(endbb, curbb);
+            llvm::BranchInst::Create(endbb, curbb);
         }
     }
 
@@ -794,7 +809,7 @@
     LOG_SCOPE;
 
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("unrolledend", p->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("unrolledend", p->topfunc(), oldend);
 
     p->scope() = IRScope(p->scopebb(),endbb);
     p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,p->scopebb(),endbb));
@@ -807,7 +822,7 @@
 
     p->loopbbs.pop_back();
 
-    new llvm::BranchInst(endbb, p->scopebb());
+    llvm::BranchInst::Create(endbb, p->scopebb());
     p->scope() = IRScope(endbb,oldend);
 }
 
@@ -916,12 +931,12 @@
     }
 
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* condbb = new llvm::BasicBlock("foreachcond", p->topfunc(), oldend);
-    llvm::BasicBlock* bodybb = new llvm::BasicBlock("foreachbody", p->topfunc(), oldend);
-    llvm::BasicBlock* nextbb = new llvm::BasicBlock("foreachnext", p->topfunc(), oldend);
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("foreachend", p->topfunc(), oldend);
+    llvm::BasicBlock* condbb = llvm::BasicBlock::Create("foreachcond", p->topfunc(), oldend);
+    llvm::BasicBlock* bodybb = llvm::BasicBlock::Create("foreachbody", p->topfunc(), oldend);
+    llvm::BasicBlock* nextbb = llvm::BasicBlock::Create("foreachnext", p->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("foreachend", p->topfunc(), oldend);
 
-    new llvm::BranchInst(condbb, p->scopebb());
+    llvm::BranchInst::Create(condbb, p->scopebb());
 
     // condition
     p->scope() = IRScope(condbb,bodybb);
@@ -936,7 +951,7 @@
         load = llvm::BinaryOperator::createSub(load,llvm::ConstantInt::get(keytype, 1, false),"tmp",p->scopebb());
         new llvm::StoreInst(load, keyvar, p->scopebb());
     }
-    new llvm::BranchInst(bodybb, endbb, done, p->scopebb());
+    llvm::BranchInst::Create(bodybb, endbb, done, p->scopebb());
 
     // init body
     p->scope() = IRScope(bodybb,nextbb);
@@ -947,7 +962,7 @@
     if (aggrtype->ty == Tsarray)
         value->ir.irLocal->value = DtoGEP(val,zero,loadedKey,"tmp");
     else if (aggrtype->ty == Tarray)
-        value->ir.irLocal->value = new llvm::GetElementPtrInst(val,loadedKey,"tmp",p->scopebb());
+        value->ir.irLocal->value = llvm::GetElementPtrInst::Create(val,loadedKey,"tmp",p->scopebb());
 
     if (!value->isRef() && !value->isOut()) {
         DValue* dst = new DVarValue(value->type, valvar, true);
@@ -962,7 +977,7 @@
     p->loopbbs.pop_back();
 
     if (!p->scopereturned())
-        new llvm::BranchInst(nextbb, p->scopebb());
+        llvm::BranchInst::Create(nextbb, p->scopebb());
 
     // next
     p->scope() = IRScope(nextbb,endbb);
@@ -971,7 +986,7 @@
         load = p->ir->CreateAdd(load, llvm::ConstantInt::get(keytype, 1, false), "tmp");
         DtoStore(load, keyvar);
     }
-    new llvm::BranchInst(condbb, p->scopebb());
+    llvm::BranchInst::Create(condbb, p->scopebb());
 
     // end
     p->scope() = IRScope(endbb,oldend);
@@ -990,10 +1005,10 @@
     if (llvmBB)
         llvmBB->moveBefore(oldend);
     else
-        llvmBB = new llvm::BasicBlock("label", p->topfunc(), oldend);
+        llvmBB = llvm::BasicBlock::Create("label", p->topfunc(), oldend);
 
     if (!p->scopereturned())
-        new llvm::BranchInst(llvmBB, p->scopebb());
+        llvm::BranchInst::Create(llvmBB, p->scopebb());
 
     p->scope() = IRScope(llvmBB,oldend);
     if (statement)
@@ -1010,10 +1025,10 @@
     assert(tf == NULL);
 
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* bb = new llvm::BasicBlock("aftergoto", p->topfunc(), oldend);
+    llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergoto", p->topfunc(), oldend);
 
     if (label->statement->llvmBB == NULL)
-        label->statement->llvmBB = new llvm::BasicBlock("label", p->topfunc());
+        label->statement->llvmBB = llvm::BasicBlock::Create("label", p->topfunc());
     assert(!p->scopereturned());
 
     // find finallys between goto and label
@@ -1029,7 +1044,7 @@
     // emit code for finallys between goto and label
     emit_finallyblocks(p, enclosingtryfinally, endfinally);
 
-    new llvm::BranchInst(label->statement->llvmBB, p->scopebb());
+    llvm::BranchInst::Create(label->statement->llvmBB, p->scopebb());
     p->scope() = IRScope(bb,oldend);
 }
 
@@ -1041,14 +1056,14 @@
     LOG_SCOPE;
 
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* bb = new llvm::BasicBlock("aftergotodefault", p->topfunc(), oldend);
+    llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergotodefault", p->topfunc(), oldend);
 
     assert(!p->scopereturned());
     assert(sw->sdefault->bodyBB);
 
     emit_finallyblocks(p, enclosingtryfinally, sw->enclosingtryfinally);
 
-    new llvm::BranchInst(sw->sdefault->bodyBB, p->scopebb());
+    llvm::BranchInst::Create(sw->sdefault->bodyBB, p->scopebb());
     p->scope() = IRScope(bb,oldend);
 }
 
@@ -1060,14 +1075,14 @@
     LOG_SCOPE;
 
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* bb = new llvm::BasicBlock("aftergotocase", p->topfunc(), oldend);
+    llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergotocase", p->topfunc(), oldend);
 
     assert(!p->scopereturned());
     assert(cs->bodyBB);
 
     emit_finallyblocks(p, enclosingtryfinally, sw->enclosingtryfinally);
 
-    new llvm::BranchInst(cs->bodyBB, p->scopebb());
+    llvm::BranchInst::Create(cs->bodyBB, p->scopebb());
     p->scope() = IRScope(bb,oldend);
 }
 
@@ -1144,7 +1159,35 @@
 
     Logger::attention(loc, "volatile is currently ignored. only the body will be emitted");
 
-    statement->toIR(p);
+    // mark in volate
+    bool old = gIR->func()->inVolatile;
+    gIR->func()->inVolatile = true;
+
+    // has statement
+    if (statement != NULL)
+    {
+        // load-store
+        DtoMemoryBarrier(false, true, false, false);
+
+        // do statement
+        statement->toIR(p);
+
+        // not point in a unreachable barrier, terminating statements should insert this themselves.
+        if (statement->fallOffEnd())
+        {
+            // store-load
+            DtoMemoryBarrier(false, false, true, false);
+        }
+    }
+    // barrier only
+    else
+    {
+        // load-store & store-load
+        DtoMemoryBarrier(false, true, true, false);
+    }
+
+    // restore volatile state
+    gIR->func()->inVolatile = old;
 }
 
 //////////////////////////////////////////////////////////////////////////////
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/structs.cpp
--- a/gen/structs.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/structs.cpp	Tue May 13 17:58:11 2008 +0200
@@ -43,7 +43,7 @@
     llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    llvm::Value* ret = new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    llvm::Value* ret = llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 
     return ret;
 }
@@ -71,7 +71,7 @@
     llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    return new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    return llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -130,7 +130,7 @@
             if (ptr->getType() != llt)
                 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
             if (vd->ir.irField->indexOffset)
-                ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
+                ptr = llvm::GetElementPtrInst::Create(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
             return ptr;
         }
         else if (vdtype->ty == Tstruct && (vd->offset + vdtype->size()) > os) {
@@ -142,7 +142,7 @@
                 ptr = DtoGEP(ptr, idxs, "tmp");
                 if (ptr->getType() != llt)
                     ptr = DtoBitCast(ptr, llt);
-                ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
+                ptr = llvm::GetElementPtrInst::Create(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
                 std::vector<unsigned> tmp;
                 return DtoIndexStruct(ptr, ssd, t, os-vd->offset, tmp);
             }
@@ -163,7 +163,7 @@
     size_t llt_sz = getTypeStoreSize(llt->getContainedType(0));
     assert(os % llt_sz == 0);
     ptr = DtoBitCast(ptr, llt);
-    return new llvm::GetElementPtrInst(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
+    return llvm::GetElementPtrInst::Create(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/toir.cpp
--- a/gen/toir.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/toir.cpp	Tue May 13 17:58:11 2008 +0200
@@ -631,7 +631,7 @@
                     return new DImValue(type, l->getRVal());
                 }
             }
-            llvm::Value* v = new llvm::GetElementPtrInst(l->getRVal(), r->getRVal(), "tmp", p->scopebb());
+            llvm::Value* v = llvm::GetElementPtrInst::Create(l->getRVal(), r->getRVal(), "tmp", p->scopebb());
             return new DImValue(type, v);
         }
         else if (t->iscomplex()) {
@@ -663,7 +663,7 @@
 
     DValue* res;
     if (DtoDType(e1->type)->ty == Tpointer) {
-        llvm::Value* gep = new llvm::GetElementPtrInst(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
+        llvm::Value* gep = llvm::GetElementPtrInst::Create(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
         res = new DImValue(type, gep);
     }
     else if (t->iscomplex()) {
@@ -713,7 +713,7 @@
     }
     else if (t1->ty == Tpointer) {
         llvm::Value* idx = p->ir->CreateNeg(r->getRVal(), "tmp");
-        llvm::Value* v = new llvm::GetElementPtrInst(l->getRVal(), idx, "tmp", p->scopebb());
+        llvm::Value* v = llvm::GetElementPtrInst::Create(l->getRVal(), idx, "tmp", p->scopebb());
         return new DImValue(type, v);
     }
     else if (t->iscomplex()) {
@@ -742,7 +742,7 @@
         llvm::Value* tmp = r->getRVal();
         llvm::Value* zero = llvm::ConstantInt::get(tmp->getType(),0,false);
         tmp = llvm::BinaryOperator::createSub(zero,tmp,"tmp",p->scopebb());
-        tmp = new llvm::GetElementPtrInst(l->getRVal(),tmp,"tmp",p->scopebb());
+        tmp = llvm::GetElementPtrInst::Create(l->getRVal(),tmp,"tmp",p->scopebb());
         res = new DImValue(type, tmp);
     }
     else if (t->iscomplex()) {
@@ -1204,7 +1204,7 @@
     //Logger::cout() << "Calling: " << *funcval << '\n';
 
     // call the function
-    llvm::CallInst* call = new llvm::CallInst(funcval, llargs.begin(), llargs.end(), varname, p->scopebb());
+    llvm::CallInst* call = llvm::CallInst::Create(funcval, llargs.begin(), llargs.end(), varname, p->scopebb());
     llvm::Value* retllval = (retinptr) ? llargs[0] : call;
 
     if (retinptr && dfn && dfn->func && dfn->func->runTimeHack) {
@@ -1548,7 +1548,7 @@
 
     llvm::Value* arrptr = 0;
     if (e1type->ty == Tpointer) {
-        arrptr = new llvm::GetElementPtrInst(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
+        arrptr = llvm::GetElementPtrInst::Create(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
     }
     else if (e1type->ty == Tsarray) {
         arrptr = DtoGEP(l->getRVal(), zero, r->getRVal(),"tmp",p->scopebb());
@@ -1556,7 +1556,7 @@
     else if (e1type->ty == Tarray) {
         arrptr = DtoGEP(l->getRVal(),zero,one,"tmp",p->scopebb());
         arrptr = new llvm::LoadInst(arrptr,"tmp",p->scopebb());
-        arrptr = new llvm::GetElementPtrInst(arrptr,r->getRVal(),"tmp",p->scopebb());
+        arrptr = llvm::GetElementPtrInst::Create(arrptr,r->getRVal(),"tmp",p->scopebb());
     }
     else if (e1type->ty == Taarray) {
         return DtoAAIndex(type, l, r);
@@ -1615,7 +1615,7 @@
 
             llvm::ConstantInt* c = llvm::cast<llvm::ConstantInt>(cv->c);
             if (!(lwr_is_zero = c->isZero())) {
-                emem = new llvm::GetElementPtrInst(emem,cv->c,"tmp",p->scopebb());
+                emem = llvm::GetElementPtrInst::Create(emem,cv->c,"tmp",p->scopebb());
             }
         }
         else
@@ -1623,13 +1623,13 @@
             if (e1type->ty == Tarray) {
                 llvm::Value* tmp = DtoGEP(vmem,zero,one,"tmp",p->scopebb());
                 tmp = new llvm::LoadInst(tmp,"tmp",p->scopebb());
-                emem = new llvm::GetElementPtrInst(tmp,lo->getRVal(),"tmp",p->scopebb());
+                emem = llvm::GetElementPtrInst::Create(tmp,lo->getRVal(),"tmp",p->scopebb());
             }
             else if (e1type->ty == Tsarray) {
                 emem = DtoGEP(vmem,zero,lo->getRVal(),"tmp",p->scopebb());
             }
             else if (e1type->ty == Tpointer) {
-                emem = new llvm::GetElementPtrInst(v->getRVal(),lo->getRVal(),"tmp",p->scopebb());
+                emem = llvm::GetElementPtrInst::Create(v->getRVal(),lo->getRVal(),"tmp",p->scopebb());
             }
             else {
                 Logger::println("type = %s", e1type->toChars());
@@ -1903,12 +1903,12 @@
         llvm::Constant* minusone = llvm::ConstantInt::get(DtoSize_t(),(uint64_t)-1,true);
         llvm::Constant* plusone = llvm::ConstantInt::get(DtoSize_t(),(uint64_t)1,false);
         llvm::Constant* whichone = (op == TOKplusplus) ? plusone : minusone;
-        post = new llvm::GetElementPtrInst(val, whichone, "tmp", p->scopebb());
+        post = llvm::GetElementPtrInst::Create(val, whichone, "tmp", p->scopebb());
     }
     else if (e1type->isfloating())
     {
         assert(e2type->isfloating());
-        llvm::Value* one = llvm::ConstantFP::get(val->getType(), llvm::APFloat(1.0f));
+        llvm::Value* one = DtoConstFP(e1type, 1.0);
         if (op == TOKplusplus) {
             post = llvm::BinaryOperator::createAdd(val,one,"tmp",p->scopebb());
         }
@@ -2140,22 +2140,22 @@
 
     // create basic blocks
     llvm::BasicBlock* oldend = p->scopeend();
-    llvm::BasicBlock* assertbb = new llvm::BasicBlock("assert", p->topfunc(), oldend);
-    llvm::BasicBlock* endbb = new llvm::BasicBlock("endassert", p->topfunc(), oldend);
+    llvm::BasicBlock* assertbb = llvm::BasicBlock::Create("assert", p->topfunc(), oldend);
+    llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endassert", p->topfunc(), oldend);
 
     // test condition
     llvm::Value* condval = cond->getRVal();
     condval = DtoBoolean(condval);
 
     // branch
-    new llvm::BranchInst(endbb, assertbb, condval, p->scopebb());
+    llvm::BranchInst::Create(endbb, assertbb, condval, p->scopebb());
 
     // call assert runtime functions
     p->scope() = IRScope(assertbb,endbb);
     DtoAssert(&loc, msg ? msg->toElem(p) : NULL);
 
     if (!gIR->scopereturned())
-        new llvm::BranchInst(endbb, p->scopebb());
+        llvm::BranchInst::Create(endbb, p->scopebb());
 
     // rewrite the scope
     p->scope() = IRScope(endbb,oldend);
@@ -2196,12 +2196,12 @@
     DValue* u = e1->toElem(p);
 
     llvm::BasicBlock* oldend = p->scopeend();
-    llvm::BasicBlock* andand = new llvm::BasicBlock("andand", gIR->topfunc(), oldend);
-    llvm::BasicBlock* andandend = new llvm::BasicBlock("andandend", gIR->topfunc(), oldend);
+    llvm::BasicBlock* andand = llvm::BasicBlock::Create("andand", gIR->topfunc(), oldend);
+    llvm::BasicBlock* andandend = llvm::BasicBlock::Create("andandend", gIR->topfunc(), oldend);
 
     llvm::Value* ubool = DtoBoolean(u->getRVal());
     new llvm::StoreInst(ubool,resval,p->scopebb());
-    new llvm::BranchInst(andand,andandend,ubool,p->scopebb());
+    llvm::BranchInst::Create(andand,andandend,ubool,p->scopebb());
 
     p->scope() = IRScope(andand, andandend);
     DValue* v = e2->toElem(p);
@@ -2209,7 +2209,7 @@
     llvm::Value* vbool = DtoBoolean(v->getRVal());
     llvm::Value* uandvbool = llvm::BinaryOperator::create(llvm::BinaryOperator::And, ubool, vbool,"tmp",p->scopebb());
     new llvm::StoreInst(uandvbool,resval,p->scopebb());
-    new llvm::BranchInst(andandend,p->scopebb());
+    llvm::BranchInst::Create(andandend,p->scopebb());
 
     p->scope() = IRScope(andandend, oldend);
 
@@ -2232,19 +2232,19 @@
     DValue* u = e1->toElem(p);
 
     llvm::BasicBlock* oldend = p->scopeend();
-    llvm::BasicBlock* oror = new llvm::BasicBlock("oror", gIR->topfunc(), oldend);
-    llvm::BasicBlock* ororend = new llvm::BasicBlock("ororend", gIR->topfunc(), oldend);
+    llvm::BasicBlock* oror = llvm::BasicBlock::Create("oror", gIR->topfunc(), oldend);
+    llvm::BasicBlock* ororend = llvm::BasicBlock::Create("ororend", gIR->topfunc(), oldend);
 
     llvm::Value* ubool = DtoBoolean(u->getRVal());
     new llvm::StoreInst(ubool,resval,p->scopebb());
-    new llvm::BranchInst(ororend,oror,ubool,p->scopebb());
+    llvm::BranchInst::Create(ororend,oror,ubool,p->scopebb());
 
     p->scope() = IRScope(oror, ororend);
     DValue* v = e2->toElem(p);
 
     llvm::Value* vbool = DtoBoolean(v->getRVal());
     new llvm::StoreInst(vbool,resval,p->scopebb());
-    new llvm::BranchInst(ororend,p->scopebb());
+    llvm::BranchInst::Create(ororend,p->scopebb());
 
     p->scope() = IRScope(ororend, oldend);
 
@@ -2463,23 +2463,23 @@
     DVarValue* dvv = new DVarValue(type, resval, true);
 
     llvm::BasicBlock* oldend = p->scopeend();
-    llvm::BasicBlock* condtrue = new llvm::BasicBlock("condtrue", gIR->topfunc(), oldend);
-    llvm::BasicBlock* condfalse = new llvm::BasicBlock("condfalse", gIR->topfunc(), oldend);
-    llvm::BasicBlock* condend = new llvm::BasicBlock("condend", gIR->topfunc(), oldend);
+    llvm::BasicBlock* condtrue = llvm::BasicBlock::Create("condtrue", gIR->topfunc(), oldend);
+    llvm::BasicBlock* condfalse = llvm::BasicBlock::Create("condfalse", gIR->topfunc(), oldend);
+    llvm::BasicBlock* condend = llvm::BasicBlock::Create("condend", gIR->topfunc(), oldend);
 
     DValue* c = econd->toElem(p);
     llvm::Value* cond_val = DtoBoolean(c->getRVal());
-    new llvm::BranchInst(condtrue,condfalse,cond_val,p->scopebb());
+    llvm::BranchInst::Create(condtrue,condfalse,cond_val,p->scopebb());
 
     p->scope() = IRScope(condtrue, condfalse);
     DValue* u = e1->toElem(p);
     DtoAssign(dvv, u);
-    new llvm::BranchInst(condend,p->scopebb());
+    llvm::BranchInst::Create(condend,p->scopebb());
 
     p->scope() = IRScope(condfalse, condend);
     DValue* v = e2->toElem(p);
     DtoAssign(dvv, v);
-    new llvm::BranchInst(condend,p->scopebb());
+    llvm::BranchInst::Create(condend,p->scopebb());
 
     p->scope() = IRScope(condend, oldend);
     return dvv;
@@ -2521,15 +2521,7 @@
     if (t->isintegral())
         zero = llvm::ConstantInt::get(val->getType(), 0, true);
     else if (t->isfloating()) {
-        if (t->ty == Tfloat32 || t->ty == Timaginary32)
-            zero = llvm::ConstantFP::get(val->getType(), llvm::APFloat(0.0f));
-        else if (t->ty == Tfloat64 || t->ty == Tfloat80 || t->ty == Timaginary64 || t->ty == Timaginary80)
-            zero = llvm::ConstantFP::get(val->getType(), llvm::APFloat(0.0));
-        else
-        {
-            Logger::println("unhandled fp negation of type %s", t->toChars());
-            assert(0);
-        }
+        zero = DtoConstFP(type, 0.0);
     }
     else
         assert(0);
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/tollvm.cpp
--- a/gen/tollvm.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/tollvm.cpp	Tue May 13 17:58:11 2008 +0200
@@ -272,6 +272,38 @@
     return gIR->llvm_DeclareMemCpy64;
 }
 
+// llvm.memory.barrier
+static llvm::Function* LLVM_DeclareMemBarrier()
+{
+    if (gIR->llvm_DeclareMemBarrier == 0) {
+        std::vector<const llvm::Type*> pvec;
+        pvec.push_back(llvm::Type::Int1Ty);
+        pvec.push_back(llvm::Type::Int1Ty);
+        pvec.push_back(llvm::Type::Int1Ty);
+        pvec.push_back(llvm::Type::Int1Ty);
+        pvec.push_back(llvm::Type::Int1Ty);
+        llvm::FunctionType* functype = llvm::FunctionType::get(llvm::Type::VoidTy, pvec, false);
+        gIR->llvm_DeclareMemBarrier = llvm::cast<llvm::Function>(gIR->module->getOrInsertFunction("llvm.memory.barrier", functype));
+        assert(gIR->llvm_DeclareMemBarrier != NULL);
+    }
+    return gIR->llvm_DeclareMemBarrier;
+}
+
+void DtoMemoryBarrier(bool ll, bool ls, bool sl, bool ss, bool device)
+{
+    llvm::Function* fn = LLVM_DeclareMemBarrier();
+    assert(fn != NULL);
+
+    llvm::SmallVector<llvm::Value*, 5> llargs;
+    llargs.push_back(DtoConstBool(ll));
+    llargs.push_back(DtoConstBool(ls));
+    llargs.push_back(DtoConstBool(sl));
+    llargs.push_back(DtoConstBool(ss));
+    llargs.push_back(DtoConstBool(device));
+
+    llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////
 
 llvm::Value* DtoDelegateToNull(llvm::Value* v)
@@ -291,7 +323,7 @@
     llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    llvm::Value* ret = new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    llvm::Value* ret = llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 
     return ret;
 }
@@ -318,7 +350,7 @@
     llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    return new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    return llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -616,7 +648,7 @@
     v[0] = i0;
     v[1] = i1;
     Logger::cout() << "DtoGEP: " << *ptr << ", " << *i0 << ", " << *i1 << '\n';
-    return new llvm::GetElementPtrInst(ptr, v.begin(), v.end(), var, bb?bb:gIR->scopebb());
+    return llvm::GetElementPtrInst::Create(ptr, v.begin(), v.end(), var, bb?bb:gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -633,14 +665,14 @@
         dst[i] = llvm::ConstantInt::get(llvm::Type::Int32Ty, src[i], false);
     }
     //ostr << '\n';*/
-    return new llvm::GetElementPtrInst(ptr, dst.begin(), dst.end(), var, bb?bb:gIR->scopebb());
+    return llvm::GetElementPtrInst::Create(ptr, dst.begin(), dst.end(), var, bb?bb:gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
 llvm::Value* DtoGEPi(llvm::Value* ptr, unsigned i, const std::string& var, llvm::BasicBlock* bb)
 {
-    return new llvm::GetElementPtrInst(ptr, llvm::ConstantInt::get(llvm::Type::Int32Ty, i, false), var, bb?bb:gIR->scopebb());
+    return llvm::GetElementPtrInst::Create(ptr, llvm::ConstantInt::get(llvm::Type::Int32Ty, i, false), var, bb?bb:gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -650,7 +682,7 @@
     std::vector<llvm::Value*> v(2);
     v[0] = llvm::ConstantInt::get(llvm::Type::Int32Ty, i0, false);
     v[1] = llvm::ConstantInt::get(llvm::Type::Int32Ty, i1, false);
-    return new llvm::GetElementPtrInst(ptr, v.begin(), v.end(), var, bb?bb:gIR->scopebb());
+    return llvm::GetElementPtrInst::Create(ptr, v.begin(), v.end(), var, bb?bb:gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -704,7 +736,7 @@
 
     // call
     llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, fname);
-    llvm::CallInst* call = new llvm::CallInst(fn, args.begin(), args.end(), "", gIR->scopebb());
+    llvm::CallInst* call = llvm::CallInst::Create(fn, args.begin(), args.end(), "", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1234,9 +1266,9 @@
 {
     TY ty = DtoDType(t)->ty;
     if (ty == Tfloat32 || ty == Timaginary32)
-        return llvm::ConstantFP::get(llvm::Type::FloatTy, llvm::APFloat(float(value)));
+        return llvm::ConstantFP::get(llvm::APFloat(float(value)));
     else if (ty == Tfloat64 || ty == Timaginary64 || ty == Tfloat80 || ty == Timaginary80)
-        return llvm::ConstantFP::get(llvm::Type::DoubleTy, llvm::APFloat(double(value)));
+        return llvm::ConstantFP::get(llvm::APFloat(double(value)));
 }
 
 
@@ -1288,7 +1320,7 @@
     llargs[2] = nbytes;
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1317,19 +1349,22 @@
     llargs[2] = nbytes;
     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
 
-    new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
+    llvm::CallInst::Create(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
 llvm::Value* DtoLoad(llvm::Value* src)
 {
-    return gIR->ir->CreateLoad(src,"tmp");
+    llvm::Value* ld = gIR->ir->CreateLoad(src,"tmp");
+    //ld->setVolatile(gIR->func()->inVolatile);
+    return ld;
 }
 
 void DtoStore(llvm::Value* src, llvm::Value* dst)
 {
-    gIR->ir->CreateStore(src,dst);
+    llvm::Value* st = gIR->ir->CreateStore(src,dst);
+    //st->setVolatile(gIR->func()->inVolatile);
 }
 
 bool DtoCanLoad(llvm::Value* ptr)
@@ -1460,8 +1495,8 @@
 
     // check flag and do init if not already done
     llvm::BasicBlock* oldend = gIR->scopeend();
-    llvm::BasicBlock* initbb = new llvm::BasicBlock("ifnotinit",gIR->topfunc(),oldend);
-    llvm::BasicBlock* endinitbb = new llvm::BasicBlock("ifnotinitend",gIR->topfunc(),oldend);
+    llvm::BasicBlock* initbb = llvm::BasicBlock::Create("ifnotinit",gIR->topfunc(),oldend);
+    llvm::BasicBlock* endinitbb = llvm::BasicBlock::Create("ifnotinitend",gIR->topfunc(),oldend);
     llvm::Value* cond = gIR->ir->CreateICmpEQ(gIR->ir->CreateLoad(gflag,"tmp"),DtoConstBool(false));
     gIR->ir->CreateCondBr(cond, initbb, endinitbb);
     gIR->scope() = IRScope(initbb,endinitbb);
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/tollvm.h
--- a/gen/tollvm.h	Tue May 13 16:16:50 2008 +0200
+++ b/gen/tollvm.h	Tue May 13 17:58:11 2008 +0200
@@ -105,6 +105,7 @@
 // llvm wrappers
 void DtoMemSetZero(llvm::Value* dst, llvm::Value* nbytes);
 void DtoMemCpy(llvm::Value* dst, llvm::Value* src, llvm::Value* nbytes);
+void DtoMemoryBarrier(bool ll, bool ls, bool sl, bool ss, bool device=false);
 bool DtoCanLoad(llvm::Value* ptr);
 llvm::Value* DtoLoad(llvm::Value* src);
 void DtoStore(llvm::Value* src, llvm::Value* dst);
diff -r 11fe364b9a3e -r 9d44ec83acd1 gen/toobj.cpp
--- a/gen/toobj.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/gen/toobj.cpp	Tue May 13 17:58:11 2008 +0200
@@ -190,11 +190,11 @@
     std::vector<const llvm::Type*> argsTy;
     const llvm::FunctionType* fnTy = llvm::FunctionType::get(llvm::Type::VoidTy,argsTy,false);
     assert(gIR->module->getFunction(name) == NULL);
-    llvm::Function* fn = new llvm::Function(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
+    llvm::Function* fn = llvm::Function::Create(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
     fn->setCallingConv(llvm::CallingConv::Fast);
 
-    llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
-    LLVMBuilder builder(bb);
+    llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry", fn);
+    IRBuilder builder(bb);
 
     for (size_t i=0; i<n; i++) {
         llvm::Function* f = gIR->ctors[i]->ir.irFunc->func;
@@ -224,11 +224,11 @@
     std::vector<const llvm::Type*> argsTy;
     const llvm::FunctionType* fnTy = llvm::FunctionType::get(llvm::Type::VoidTy,argsTy,false);
     assert(gIR->module->getFunction(name) == NULL);
-    llvm::Function* fn = new llvm::Function(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
+    llvm::Function* fn = llvm::Function::Create(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
     fn->setCallingConv(llvm::CallingConv::Fast);
 
-    llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
-    LLVMBuilder builder(bb);
+    llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry", fn);
+    IRBuilder builder(bb);
 
     for (size_t i=0; i<n; i++) {
         llvm::Function* f = gIR->dtors[i]->ir.irFunc->func;
@@ -258,11 +258,11 @@
     std::vector<const llvm::Type*> argsTy;
     const llvm::FunctionType* fnTy = llvm::FunctionType::get(llvm::Type::VoidTy,argsTy,false);
     assert(gIR->module->getFunction(name) == NULL);
-    llvm::Function* fn = new llvm::Function(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
+    llvm::Function* fn = llvm::Function::Create(fnTy, llvm::GlobalValue::InternalLinkage, name, gIR->module);
     fn->setCallingConv(llvm::CallingConv::Fast);
 
-    llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
-    LLVMBuilder builder(bb);
+    llvm::BasicBlock* bb = llvm::BasicBlock::Create("entry", fn);
+    IRBuilder builder(bb);
 
     for (size_t i=0; i<n; i++) {
         llvm::Function* f = gIR->unitTests[i]->ir.irFunc->func;
diff -r 11fe364b9a3e -r 9d44ec83acd1 ir/irfunction.cpp
--- a/ir/irfunction.cpp	Tue May 13 16:16:50 2008 +0200
+++ b/ir/irfunction.cpp	Tue May 13 17:58:11 2008 +0200
@@ -26,6 +26,7 @@
     dwarfSubProg = NULL;
 
     srcfileArg = NULL;
+    inVolatile = false;
 }
 
 IrFunction::~IrFunction()
diff -r 11fe364b9a3e -r 9d44ec83acd1 ir/irfunction.h
--- a/ir/irfunction.h	Tue May 13 16:16:50 2008 +0200
+++ b/ir/irfunction.h	Tue May 13 17:58:11 2008 +0200
@@ -24,6 +24,8 @@
 
     llvm::AllocaInst* srcfileArg;
 
+    bool inVolatile;
+
     IrFunction(FuncDeclaration* fd);
     virtual ~IrFunction();
 };