Refactor and simplify target ABI system.

The big changes in abi-x86-64.cpp are an UNTESTED attempt to clean
things up.
The simplifications may be too daring, but I hope LLVM gets it right
without too much help from our side.

Author: kinke

gen/abi-generic.h

@@ -24,143 +24,86 @@
 /// Removes padding fields for (non-union-containing!) structs
 struct RemoveStructPadding : ABIRewrite {
     /// get a rewritten value back to its original form
-    virtual LLValue* get(Type* dty, DValue* v) {
+    LLValue* get(Type* dty, DValue* 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
-    virtual void getL(Type* dty, DValue* v, llvm::Value* lval) {
+    void getL(Type* dty, DValue* 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);
     }
 
     /// put out rewritten value
-    virtual LLValue* put(Type* dty, DValue* v) {
+    LLValue* put(Type* dty, DValue* v) {
         return DtoUnpaddedStruct(dty->toBasetype(), v->getRVal());
     }
 
     /// return the transformed type for this rewrite
-    virtual LLType* type(Type* dty, LLType* t) {
+    LLType* type(Type* dty, LLType* t) {
         return DtoUnpaddedStructType(dty->toBasetype());
     }
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
-// simply swap of real/imag parts for proper x87 complex abi
-struct X87_complex_swap : ABIRewrite
-{
-    LLValue* get(Type*, DValue* v)
-    {
-        return DtoAggrPairSwap(v->getRVal());
-    }
-    LLValue* put(Type*, DValue* v)
-    {
-        return DtoAggrPairSwap(v->getRVal());
-    }
-    LLType* type(Type*, LLType* t)
-    {
-        return t;
-    }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-// Rewrites a cfloat (2x32 bits) as 64-bit integer.
-// Assumes a little-endian byte order.
-struct CfloatToInt : ABIRewrite
-{
-    // i64 -> {float,float}
-    LLValue* get(Type*, DValue* dv)
-    {
-        LLValue* in = dv->getRVal();
-
-        // extract real part
-        LLValue* rpart = gIR->ir->CreateTrunc(in, LLType::getInt32Ty(gIR->context()));
-        rpart = gIR->ir->CreateBitCast(rpart, LLType::getFloatTy(gIR->context()), ".re");
-
-        // extract imag part
-        LLValue* ipart = gIR->ir->CreateLShr(in, LLConstantInt::get(LLType::getInt64Ty(gIR->context()), 32, false));
-        ipart = gIR->ir->CreateTrunc(ipart, LLType::getInt32Ty(gIR->context()));
-        ipart = gIR->ir->CreateBitCast(ipart, LLType::getFloatTy(gIR->context()), ".im");
-
-        // return {float,float} aggr pair with same bits
-        return DtoAggrPair(rpart, ipart, ".final_cfloat");
-    }
-
-    // {float,float} -> i64
-    LLValue* put(Type*, DValue* dv)
-    {
-        LLValue* v = dv->getRVal();
-
-        // extract real
-        LLValue* r = gIR->ir->CreateExtractValue(v, 0);
-        // cast to i32
-        r = gIR->ir->CreateBitCast(r, LLType::getInt32Ty(gIR->context()));
-        // zext to i64
-        r = gIR->ir->CreateZExt(r, LLType::getInt64Ty(gIR->context()));
-
-        // extract imag
-        LLValue* i = gIR->ir->CreateExtractValue(v, 1);
-        // cast to i32
-        i = gIR->ir->CreateBitCast(i, LLType::getInt32Ty(gIR->context()));
-        // zext to i64
-        i = gIR->ir->CreateZExt(i, LLType::getInt64Ty(gIR->context()));
-        // shift up
-        i = gIR->ir->CreateShl(i, LLConstantInt::get(LLType::getInt64Ty(gIR->context()), 32, false));
-
-        // combine and return
-        return v = gIR->ir->CreateOr(r, i);
-    }
-
-    // {float,float} -> i64
-    LLType* type(Type*, LLType* t)
-    {
-        return LLType::getInt64Ty(gIR->context());
-    }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
 /**
  * Rewrites a composite type parameter to an integer of the same size.
  *
  * This is needed in order to be able to use LLVM's inreg attribute to put
  * struct and static array parameters into registers, because the attribute has
  * slightly different semantics. For example, LLVM would store a [4 x i8] inreg
  * in four registers (zero-extended), instead of a single 32bit one.
- *
- * The LLVM value in dv is expected to be a pointer to the parameter, as
- * generated when lowering struct/static array paramters to LLVM byval.
  */
 struct CompositeToInt : ABIRewrite
 {
     LLValue* get(Type* dty, DValue* dv)
     {
         Logger::println("rewriting integer -> %s", dty->toChars());
-        LLValue* mem = DtoAlloca(dty, ".int_to_composite");
-        LLValue* v = dv->getRVal();
-        DtoStore(v, DtoBitCast(mem, getPtrToType(v->getType())));
-        return DtoLoad(mem);
+
+        LLValue* address = 0; // of passed Int
+
+        if (dv->isLVal())                                                 // dv is already in memory:
+            address = dv->getLVal();                                      //   address = &<passed Int>
+        else {                                                            // dump dv to memory:
+            LLValue* v = dv->getRVal();                                   //   v = <passed Int>
+            address = DtoRawAlloca(v->getType(), 0, ".int_to_composite"); //   address = new Int
+            DtoStore(v, address);                                         //   *address = v
+        }
+
+        LLType* pTy = getPtrToType(DtoType(dty));
+        return DtoLoad(DtoBitCast(address, pTy), "get-result"); // *(Type*)address
     }
 
-    void getL(Type* dty, DValue* dv, llvm::Value* lval)
+    void getL(Type* dty, DValue* dv, LLValue* lval)
     {
         Logger::println("rewriting integer -> %s", dty->toChars());
-        LLValue* v = dv->getRVal();
-        DtoStore(v, DtoBitCast(lval, getPtrToType(v->getType())));
+        LLValue* v = dv->getRVal();                                // v = <passed Int>
+        DtoStore(v, DtoBitCast(lval, getPtrToType(v->getType()))); // *(Int*)lval = v
     }
 
     LLValue* put(Type* dty, DValue* dv)
     {
         Logger::println("rewriting %s -> integer", dty->toChars());
-        LLType* t = LLIntegerType::get(gIR->context(), dty->size() * 8);
-        return DtoLoad(DtoBitCast(dv->getRVal(), getPtrToType(t)));
+
+        LLValue* address = 0; // of original parameter dv
+
+        if (dv->getRVal()->getType()->isPointerTy())       // dv has been lowered to a pointer to the struct/static array:
+            address = dv->getRVal();                       //   address = dv
+        else if (dv->isLVal())                             // dv is already in memory:
+            address = dv->getLVal();                       //   address = &dv
+        else {                                             // dump dv to memory:
+            address = DtoAlloca(dty, ".composite_to_int"); //   address = new Type
+            DtoStore(dv->getRVal(), address);              //   *address = dv
+        }
+
+        LLType* intType = type(dty, 0);
+        return DtoLoad(DtoBitCast(address, getPtrToType(intType)), "put-result"); // *(Int*)address
     }
 
     LLType* type(Type* t, LLType*)
@@ -170,4 +113,58 @@ struct CompositeToInt : ABIRewrite
     }
 };
 
+//////////////////////////////////////////////////////////////////////////////
+
+// FIXME: This should actually be handled by LLVM and the ByVal arg attribute.
+struct byval_rewrite : ABIRewrite
+{
+    const size_t alignment;
+
+    byval_rewrite(size_t alignment = 16) : alignment(alignment)
+    { }
+
+    // Get instance from pointer.
+    LLValue* get(Type* dty, DValue* v)
+    {
+        LLValue* ptr = v->getRVal();
+        return DtoLoad(ptr); // *ptr
+    }
+
+    // Convert the caller's instance to a pointer for the callee.
+    // The pointer points to a dedicated copy for the callee which
+    // is allocated by the caller.
+    LLValue* put(Type* dty, DValue* v)
+    {
+        /* NOTE: probably not safe
+        // optimization: do not copy if parameter is not mutable
+        if (!dty->isMutable() && v->isLVal())
+            return v->getLVal();
+        */
+
+        LLValue* original = v->getRVal();
+        LLValue* copy;
+
+        LLType* type = original->getType();
+        if (type->isPointerTy())
+        {
+            type = type->getPointerElementType();
+            copy = DtoRawAlloca(type, alignment, "copy_for_callee");
+            DtoStore(DtoLoad(original), copy); // *copy = *original
+        }
+        else
+        {
+            copy = DtoRawAlloca(type, alignment, "copy_for_callee");
+            DtoStore(original, copy);          // *copy = original
+        }
+
+        return copy;
+    }
+
+    // T => T*
+    LLType* type(Type* dty, LLType* t)
+    {
+        return getPtrToType(DtoType(dty));
+    }
+};
+
 #endif

gen/abi-ppc64.cpp

@@ -20,48 +20,8 @@
 #include "gen/llvmhelpers.h"
 #include "gen/tollvm.h"
 
-// Implements byval argument passing for scalar non-struct types.
-struct PPC64_byval_rewrite : ABIRewrite
-{
-    // Get instance from pointer.
-    LLValue* get(Type* dty, DValue* v)
-    {
-        LLValue* ptr = v->getRVal();
-        return DtoLoad(ptr); // *ptr
-    }
-
-    // Get instance from pointer, and store in the provided location.
-    void getL(Type* dty, DValue* v, llvm::Value* lval)
-    {
-        LLValue* ptr = v->getRVal();
-        DtoStore(DtoLoad(ptr), lval); // *lval = *ptr
-    }
-
-    // Turn an instance into a pointer (to a private copy for the callee,
-    // allocated by the caller).
-    LLValue* put(Type* dty, DValue* v)
-    {
-        /* NOTE: probably not safe
-        // optimization: do not copy if parameter is not mutable
-        if (!dty->isMutable() && v->isLVal())
-        return v->getLVal();
-        */
-
-        LLValue* original = v->getRVal();
-        LLValue* copy = DtoRawAlloca(original->getType(), 16, "copy_for_callee");
-        DtoStore(original, copy); // *copy = *original
-        return copy;
-    }
-
-    /// should return the transformed type for this rewrite
-    LLType* type(Type* dty, LLType* t)
-    {
-        return getPtrToType(DtoType(dty));
-    }
-};
-
 struct PPC64TargetABI : TargetABI {
-    PPC64_byval_rewrite byval_rewrite;
+    byval_rewrite byval_rewrite;
     CompositeToInt compositeToInt;
     const bool Is64Bit;
 
@@ -114,40 +74,44 @@ struct PPC64TargetABI : TargetABI {
     void rewriteFunctionType(TypeFunction* tf, IrFuncTy &fty)
     {
         // EXPLICIT PARAMETERS
-
-        for (IrFuncTy::ArgRIter I = fty.args.rbegin(), E = fty.args.rend(); I != E; ++I)
+        for (IrFuncTy::ArgIter I = fty.args.begin(), E = fty.args.end(); I != E; ++I)
         {
             IrFuncTyArg& arg = **I;
 
             if (arg.byref)
                 continue;
 
-            Type* ty = arg.type->toBasetype();
+            rewriteArgument(arg);
+        }
+    }
 
-            if ((ty->ty == Tstruct || ty->ty == Tsarray))
+    void rewriteArgument(IrFuncTyArg& arg)
+    {
+        Type* ty = arg.type->toBasetype();
+
+        if (ty->ty == Tstruct || ty->ty == Tsarray)
+        {
+            if (canRewriteAsInt(ty))
+            {
+                arg.rewrite = &compositeToInt;
+                arg.ltype = compositeToInt.type(arg.type, arg.ltype);
+            }
+            else
             {
-                if (canRewriteAsInt(ty))
-                {
-                    arg.rewrite = &compositeToInt;
-                    arg.ltype = compositeToInt.type(arg.type, arg.ltype);
-                }
-                else
-                {
-                    // these types are passed byval:
-                    // the caller allocates a copy and then passes a pointer to the copy
-                    arg.rewrite = &byval_rewrite;
-                    arg.ltype = byval_rewrite.type(arg.type, arg.ltype);
-                }
+                // these types are passed byval:
+                // the caller allocates a copy and then passes a pointer to the copy
+                arg.rewrite = &byval_rewrite;
+                arg.ltype = byval_rewrite.type(arg.type, arg.ltype);
 
                 // the copy is treated as a local variable of the callee
                 // hence add the NoAlias and NoCapture attributes
 #if LDC_LLVM_VER >= 303
                 arg.attrs.clear();
                 arg.attrs.addAttribute(llvm::Attribute::NoAlias)
-                    .addAttribute(llvm::Attribute::NoCapture);
+                         .addAttribute(llvm::Attribute::NoCapture);
 #elif LDC_LLVM_VER == 302
                 arg.attrs = llvm::Attributes::get(gIR->context(), llvm::AttrBuilder().addAttribute(llvm::Attributes::NoAlias)
-                    .addAttribute(llvm::Attributes::NoCapture));
+                                                                                     .addAttribute(llvm::Attributes::NoCapture));
 #else
                 arg.attrs = llvm::Attribute::NoAlias | llvm::Attribute::NoCapture;
 #endif