Merge branch 'master' into release-0.16.0

Author: redstar

gen/abi-aarch64.cpp

@@ -110,14 +110,13 @@ struct AArch64TargetABI : TargetABI
     }
 
     void vaCopy(LLValue* pDest, LLValue* src) {
-        // Analog to va_start, we need to allocate a __va_list struct on the stack first
-        // and set the passed 'dest' char* pointer to its address.
-        LLValue* valistmem = DtoRawAlloca(getValistType(), 0, "__va_list_mem");
-        DtoStore(DtoBitCast(valistmem, getVoidPtrType()), pDest);
-
-        // Now bitcopy the source struct over the destination struct.
-        src = DtoBitCast(src, valistmem->getType());
-        DtoStore(DtoLoad(src), valistmem); // *(__va_list*)dest = *(__va_list*)src
+        // Analog to va_start, we need to allocate a new __va_list struct on the stack,
+        // fill it with a bitcopy of the source struct...
+        src = DtoLoad(DtoBitCast(src, getValistType()->getPointerTo())); // *(__va_list*)src
+        LLValue* valistmem = DtoAllocaDump(src, 0, "__va_list_mem");
+        // ... and finally set the passed 'dest' char* pointer to the new struct's address.
+        DtoStore(DtoBitCast(valistmem, getVoidPtrType()),
+            DtoBitCast(pDest, getPtrToType(getVoidPtrType())));
     }
 
     LLValue* prepareVaArg(LLValue* pAp)

gen/abi-generic.h

@@ -82,24 +82,23 @@ struct LLTypeMemoryLayout
 /// Removes padding fields for (non-union-containing!) structs
 struct RemoveStructPadding : ABIRewrite {
     /// get a rewritten value back to its original form
-    LLValue* get(Type* dty, DValue* v) {
+    LLValue* get(Type* dty, LLValue* v) {
         LLValue* lval = DtoAlloca(dty, ".rewritetmp");
         getL(dty, v, lval);
         return lval;
     }
 
     /// get a rewritten value back to its original form and store result in provided lvalue
-    /// this one is optional and defaults to calling the one above
-    void getL(Type* dty, DValue* v, LLValue* lval) {
+    void getL(Type* dty, LLValue* v, LLValue* lval) {
         // Make sure the padding is zero, so struct comparisons work.
         // TODO: Only do this if there's padding, and/or only initialize padding.
         DtoMemSetZero(lval, DtoConstSize_t(getTypePaddedSize(DtoType(dty))));
-        DtoPaddedStruct(dty->toBasetype(), v->getRVal(), lval);
+        DtoPaddedStruct(dty->toBasetype(), v, lval);
     }
 
     /// put out rewritten value
-    LLValue* put(Type* dty, DValue* v) {
-        return DtoUnpaddedStruct(dty->toBasetype(), v->getRVal());
+    LLValue* put(DValue* v) {
+        return DtoUnpaddedStruct(v->getType()->toBasetype(), v->getRVal());
     }
 
     /// return the transformed type for this rewrite
@@ -154,26 +153,22 @@ struct IntegerRewrite : ABIRewrite
         return LLTypeMemoryLayout::typesAreEquivalent(llType, integerType);
     }
 
-    LLValue* get(Type* dty, DValue* dv)
+    LLValue* get(Type* dty, LLValue* v)
     {
-        LLValue* integer = dv->getRVal();
-        LLValue* integerDump = storeToMemory(integer, 0, ".IntegerRewrite_dump");
-
+        LLValue* integerDump = DtoAllocaDump(v, dty, ".IntegerRewrite_dump");
         LLType* type = DtoType(dty);
         return loadFromMemory(integerDump, type, ".IntegerRewrite_getResult");
     }
 
-    void getL(Type* dty, DValue* dv, LLValue* lval)
+    void getL(Type* dty, LLValue* v, LLValue* lval)
     {
-        LLValue* integer = dv->getRVal();
-        storeToMemory(integer, lval);
+        storeToMemory(v, lval);
     }
 
-    LLValue* put(Type* dty, DValue* dv)
+    LLValue* put(DValue* dv)
     {
-        assert(dty == dv->getType());
         LLValue* address = getAddressOf(dv);
-        LLType* integerType = getIntegerType(dty->size());
+        LLType* integerType = getIntegerType(dv->getType()->size());
         return loadFromMemory(address, integerType, ".IntegerRewrite_putResult");
     }
 
@@ -205,21 +200,19 @@ struct ExplicitByvalRewrite : ABIRewrite
     ExplicitByvalRewrite(size_t alignment = 16) : alignment(alignment)
     { }
 
-    LLValue* get(Type* dty, DValue* v)
+    LLValue* get(Type* dty, LLValue* v)
     {
-        LLValue* pointer = v->getRVal();
-        return DtoLoad(pointer, ".ExplicitByvalRewrite_getResult");
+        return DtoLoad(v, ".ExplicitByvalRewrite_getResult");
     }
 
-    void getL(Type* dty, DValue* v, LLValue* lval)
+    void getL(Type* dty, LLValue* v, LLValue* lval)
     {
-        LLValue* pointer = v->getRVal();
-        DtoAggrCopy(lval, pointer);
+        DtoAggrCopy(lval, v);
     }
 
-    LLValue* put(Type* dty, DValue* v)
+    LLValue* put(DValue* v)
     {
-        if (DtoIsPassedByRef(dty))
+        if (DtoIsPassedByRef(v->getType()))
         {
             LLValue* originalPointer = v->getRVal();
             LLType* type = originalPointer->getType()->getPointerElementType();
@@ -228,9 +221,7 @@ struct ExplicitByvalRewrite : ABIRewrite
             return copyForCallee;
         }
 
-        LLValue* originalValue = v->getRVal();
-        LLValue* copyForCallee = storeToMemory(originalValue, alignment, ".ExplicitByvalRewrite_putResult");
-        return copyForCallee;
+        return DtoAllocaDump(v->getRVal(), alignment, ".ExplicitByvalRewrite_putResult");
     }
 
     LLType* type(Type* dty, LLType* t)

gen/abi-x86-64.cpp

@@ -160,22 +160,21 @@ namespace {
  * memory so that it's then readable as the other type (i.e., bit-casting).
  */
 struct X86_64_C_struct_rewrite : ABIRewrite {
-    LLValue* get(Type* dty, DValue* v)
+    LLValue* get(Type* dty, LLValue* v)
     {
-        LLValue* address = storeToMemory(v->getRVal(), 0, ".X86_64_C_struct_rewrite_dump");
+        LLValue* address = DtoAllocaDump(v, dty, ".X86_64_C_struct_rewrite_dump");
         LLType* type = DtoType(dty);
         return loadFromMemory(address, type, ".X86_64_C_struct_rewrite_getResult");
     }
 
-    void getL(Type* dty, DValue* v, LLValue* lval) {
-        storeToMemory(v->getRVal(), lval);
+    void getL(Type* dty, LLValue* v, LLValue* lval) {
+        storeToMemory(v, lval);
     }
 
-    LLValue* put(Type* dty, DValue* v) {
-        assert(dty == v->getType());
+    LLValue* put(DValue* v) {
         LLValue* address = getAddressOf(v);
 
-        LLType* abiTy = getAbiType(dty);
+        LLType* abiTy = getAbiType(v->getType());
         assert(abiTy && "Why are we rewriting a non-rewritten type?");
 
         return loadFromMemory(address, abiTy, ".X86_64_C_struct_rewrite_putResult");
@@ -195,18 +194,15 @@ struct X86_64_C_struct_rewrite : ABIRewrite {
  * the ByVal LLVM attribute.
  */
 struct ImplicitByvalRewrite : ABIRewrite {
-    LLValue* get(Type* dty, DValue* v) {
-        LLValue* pointer = v->getRVal();
-        return DtoLoad(pointer, ".ImplicitByvalRewrite_getResult");
+    LLValue* get(Type* dty, LLValue* v) {
+        return DtoLoad(v, ".ImplicitByvalRewrite_getResult");
     }
 
-    void getL(Type* dty, DValue* v, LLValue* lval) {
-        LLValue* pointer = v->getRVal();
-        DtoAggrCopy(lval, pointer);
+    void getL(Type* dty, LLValue* v, LLValue* lval) {
+        DtoAggrCopy(lval, v);
     }
 
-    LLValue* put(Type* dty, DValue* v) {
-        assert(dty == v->getType());
+    LLValue* put(DValue* v) {
         return getAddressOf(v);
     }
 
@@ -388,15 +384,13 @@ LLValue* X86_64TargetABI::prepareVaStart(LLValue* pAp) {
 }
 
 void X86_64TargetABI::vaCopy(LLValue* pDest, LLValue* src) {
-    // Analog to va_start, we need to allocate a __va_list struct on the stack first
-    // and set the passed 'dest' char* pointer to its address.
-    LLValue* valistmem = DtoRawAlloca(getValistType(), 0, "__va_list_mem");
+    // Analog to va_start, we need to allocate a new __va_list struct on the stack,
+    // fill it with a bitcopy of the source struct...
+    src = DtoLoad(DtoBitCast(src, getValistType()->getPointerTo())); // *(__va_list*)src
+    LLValue* valistmem = DtoAllocaDump(src, 0, "__va_list_mem");
+    // ... and finally set the passed 'dest' char* pointer to the new struct's address.
     DtoStore(DtoBitCast(valistmem, getVoidPtrType()),
         DtoBitCast(pDest, getPtrToType(getVoidPtrType())));
-
-    // Now bitcopy the source struct over the destination struct.
-    src = DtoBitCast(src, valistmem->getType());
-    DtoStore(DtoLoad(src), valistmem); // *(__va_list*)dest = *(__va_list*)src
 }
 
 LLValue* X86_64TargetABI::prepareVaArg(LLValue* pAp)

gen/abi.cpp

@@ -28,7 +28,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void ABIRewrite::getL(Type* dty, DValue* v, LLValue* lval)
+void ABIRewrite::getL(Type* dty, LLValue* v, LLValue* lval)
 {
     LLValue* rval = get(dty, v);
     assert(rval->getType() == lval->getType()->getContainedType(0));
@@ -49,29 +49,22 @@ LLValue* ABIRewrite::getAddressOf(DValue* v)
     if (v->isLVal())
         return v->getLVal();
 
-    return storeToMemory(v->getRVal(), 0, ".getAddressOf_dump");
-}
-
-LLValue* ABIRewrite::storeToMemory(LLValue* rval, size_t alignment, const char* name)
-{
-    LLValue* address = DtoRawAlloca(rval->getType(), alignment, name);
-    DtoStore(rval, address);
-    return address;
+    return DtoAllocaDump(v, ".getAddressOf_dump");
 }
 
 void ABIRewrite::storeToMemory(LLValue* rval, LLValue* address)
 {
     LLType* pointerType = address->getType();
     assert(pointerType->isPointerTy());
-    LLType* pointerElementType = pointerType->getPointerElementType();
+    LLType* pointeeType = pointerType->getPointerElementType();
 
     LLType* rvalType = rval->getType();
-    if (rvalType != pointerElementType)
+    if (rvalType != pointeeType)
     {
-        if (getTypeStoreSize(rvalType) > getTypeAllocSize(pointerElementType))
+        if (getTypeStoreSize(rvalType) > getTypeAllocSize(pointeeType))
         {
             // not enough allocated memory
-            LLValue* paddedDump = storeToMemory(rval, 0, ".storeToMemory_paddedDump");
+            LLValue* paddedDump = DtoAllocaDump(rval, 0, ".storeToMemory_paddedDump");
             DtoAggrCopy(address, paddedDump);
             return;
         }
@@ -86,16 +79,16 @@ LLValue* ABIRewrite::loadFromMemory(LLValue* address, LLType* asType, const char
 {
     LLType* pointerType = address->getType();
     assert(pointerType->isPointerTy());
-    LLType* pointerElementType = pointerType->getPointerElementType();
+    LLType* pointeeType = pointerType->getPointerElementType();
 
-    if (asType == pointerElementType)
+    if (asType == pointeeType)
         return DtoLoad(address, name);
 
-    if (getTypeStoreSize(asType) > getTypeAllocSize(pointerElementType))
+    if (getTypeStoreSize(asType) > getTypeAllocSize(pointeeType))
     {
         // not enough allocated memory
         LLValue* paddedDump = DtoRawAlloca(asType, 0, ".loadFromMemory_paddedDump");
-        DtoMemCpy(paddedDump, address, DtoConstSize_t(getTypeAllocSize(pointerElementType)));
+        DtoMemCpy(paddedDump, address, DtoConstSize_t(getTypeAllocSize(pointeeType)));
         return DtoLoad(paddedDump, name);
     }
 

gen/abi.h

@@ -44,14 +44,14 @@ struct ABIRewrite
     virtual ~ABIRewrite() {}
 
     /// get a rewritten value back to its original form
-    virtual llvm::Value* get(Type* dty, DValue* v) = 0;
+    virtual llvm::Value* get(Type* dty, llvm::Value* v) = 0;
 
     /// get a rewritten value back to its original form and store result in provided lvalue
     /// this one is optional and defaults to calling the one above
-    virtual void getL(Type* dty, DValue* v, llvm::Value* lval);
+    virtual void getL(Type* dty, llvm::Value* v, llvm::Value* lval);
 
     /// put out rewritten value
-    virtual llvm::Value* put(Type* dty, DValue* v) = 0;
+    virtual llvm::Value* put(DValue* v) = 0;
 
     /// should return the transformed type for this rewrite
     virtual llvm::Type* type(Type* dty, llvm::Type* t) = 0;
@@ -62,10 +62,6 @@ struct ABIRewrite
     // Returns the address of a D value, storing it to memory first if need be.
     static llvm::Value* getAddressOf(DValue* v);
 
-    // Stores a LL value to memory and returns its address.
-    static llvm::Value* storeToMemory(llvm::Value* rval, size_t alignment = 0,
-        const char* name = ".store_result");
-
     // Stores a LL value to a specified memory address. The element type of the provided
     // pointer doesn't need to match the value type (=> suited for bit-casting).
     static void storeToMemory(llvm::Value* rval, llvm::Value* address);

gen/arrays.cpp

@@ -150,8 +150,7 @@ static void DtoArrayInit(Loc& loc, LLValue* ptr, LLValue* length, DValue* dvalue
                                                         gIR->topfunc());
 
     // initialize iterator
-    LLValue *itr = DtoAlloca(Type::tsize_t, "arrayinit.itr");
-    DtoStore(DtoConstSize_t(0), itr);
+    LLValue *itr = DtoAllocaDump(DtoConstSize_t(0), 0, "arrayinit.itr");
 
     // move into the for condition block, ie. start the loop
     assert(!gIR->scopereturned());

gen/asmstmt.cpp

@@ -512,7 +512,7 @@ void CompoundAsmStatement_toIR(CompoundAsmStatement *stmt, IRState* p)
 
     // location of the special value determining the goto label
     // will be set if post-asm dispatcher block is needed
-    llvm::AllocaInst* jump_target = 0;
+    LLValue* jump_target = 0;
 
     {
         FuncDeclaration* fd = gIR->func()->decl;
@@ -577,8 +577,7 @@ void CompoundAsmStatement_toIR(CompoundAsmStatement *stmt, IRState* p)
             outSetterStmt->code += asmGotoEndLabel.str()+":\n";
 
             // create storage for and initialize the temporary
-            jump_target = DtoAlloca(Type::tint32, "__llvm_jump_target");
-            gIR->ir->CreateStore(DtoConstUint(0), jump_target);
+            jump_target = DtoAllocaDump(DtoConstUint(0), 0, "__llvm_jump_target");
             // setup variable for output from asm
             outSetterStmt->out_c = "=*m,";
             outSetterStmt->out.push_back(jump_target);

gen/functions.cpp

@@ -819,8 +819,7 @@ void DtoDefineFunction(FuncDeclaration* fd)
         LLValue* thismem = thisvar;
         if (!irFty.arg_this->byref)
         {
-            thismem = DtoRawAlloca(thisvar->getType(), 0, "this"); // FIXME: align?
-            DtoStore(thisvar, thismem);
+            thismem = DtoAllocaDump(thisvar, 0, "this");
             irFunc->thisArg = thismem;
         }
 
@@ -832,12 +831,7 @@ void DtoDefineFunction(FuncDeclaration* fd)
 
     // give the 'nestArg' storage
     if (irFty.arg_nest)
-    {
-        LLValue *nestArg = irFunc->nestArg;
-        LLValue *val = DtoRawAlloca(nestArg->getType(), 0, "nestedFrame");
-        DtoStore(nestArg, val);
-        irFunc->nestArg = val;
-    }
+        irFunc->nestArg = DtoAllocaDump(irFunc->nestArg, 0, "nestedFrame");
 
     // give arguments storage and debug info
     if (fd->parameters)
@@ -873,8 +867,7 @@ void DtoDefineFunction(FuncDeclaration* fd)
                     LLValue* mem = DtoAlloca(irparam->arg->type, vd->ident->toChars());
 
                     // let the abi transform the argument back first
-                    DImValue arg_dval(vd->type, irparam->value);
-                    irFty.getParam(vd->type, llArgIdx, &arg_dval, mem);
+                    irFty.getParam(vd->type, llArgIdx, irparam->value, mem);
 
                     // set the arg var value to the alloca
                     irparam->value = mem;
@@ -912,10 +905,7 @@ void DtoDefineFunction(FuncDeclaration* fd)
             llvm::CallInst::Create(GET_INTRINSIC_DECL(vastart), vaStartArg, "", gIR->scopebb());
 
             // copy _arguments to a memory location
-            LLType* argumentsType = irFunc->_arguments->getType();
-            LLValue* argumentsmem = DtoRawAlloca(argumentsType, 0, "_arguments_mem");
-            new llvm::StoreInst(irFunc->_arguments, argumentsmem, gIR->scopebb());
-            irFunc->_arguments = argumentsmem;
+            irFunc->_arguments = DtoAllocaDump(irFunc->_arguments, 0, "_arguments_mem");
         }
 
         // output function body