Revert "Merge branch 'jn/fix_alloca_callconv'"

This reverts commit 66489fa, reversing
changes made to 9611554.

This was the wrong version of the branch to merge into master.

Author: vtjnash

base/inference.jl

@@ -3052,7 +3052,6 @@ end
 function remove_redundant_temp_vars(ast, sa)
     varinfo = ast.args[2][1]
     gensym_types = ast.args[2][3]
-    body = ast.args[3]
     for (v,init) in sa
         if ((isa(init,Symbol) || isa(init,SymbolNode)) &&
             any(vi->symequal(vi[1],init), varinfo) &&
@@ -3061,7 +3060,7 @@ function remove_redundant_temp_vars(ast, sa)
             # this transformation is not valid for vars used before def.
             # we need to preserve the point of assignment to know where to
             # throw errors (issue #4645).
-            if !occurs_undef(v, body, varinfo)
+            if !occurs_undef(v, ast.args[3], varinfo)
 
                 # the transformation is not ideal if the assignment
                 # is present for the auto-unbox functionality
@@ -3070,7 +3069,7 @@ function remove_redundant_temp_vars(ast, sa)
                 # everywhere later in the function
                 if (isa(init,SymbolNode) ? (init.typ <: (isa(v,GenSym)?gensym_types[(v::GenSym).id+1]:local_typeof(v, varinfo))) : true)
                     delete_var!(ast, v)
-                    sym_replace(body, Any[v], Void[], Any[init], Void[])
+                    sym_replace(ast.args[3], [v], [], [init], [])
                 end
             end
         end

src/builtins.c

@@ -273,7 +273,7 @@ static int NOINLINE compare_fields(jl_value_t *a, jl_value_t *b,
     return 1;
 }
 
-int jl_egal(jl_value_t *a, jl_value_t *b) // warning: a,b may NOT have been gc-rooted by the caller
+int jl_egal(jl_value_t *a, jl_value_t *b)
 {
     if (a == b)
         return 1;

src/ccall.cpp

@@ -221,24 +221,22 @@ static Constant *julia_const_to_llvm(jl_value_t *e)
         }
         JL_GC_POP();
         Type *t = julia_struct_to_llvm(jt);
-        if (type_is_ghost(t))
+        if (t == T_void || t->isEmptyTy())
             return UndefValue::get(NoopType);
-        if (t->isVectorTy())
-            return ConstantVector::get(ArrayRef<Constant*>(fields,llvm_nf));
-
-        Constant *init;
         if (t->isStructTy()) {
             StructType *st = dyn_cast<StructType>(t);
             assert(st);
-            init = ConstantStruct::get(st, ArrayRef<Constant*>(fields,llvm_nf));
+            return ConstantStruct::get(st, ArrayRef<Constant*>(fields,llvm_nf));
+        }
+        else if (t->isVectorTy()) {
+            return ConstantVector::get(ArrayRef<Constant*>(fields,llvm_nf));
         }
         else {
             assert(t->isArrayTy());
             ArrayType *at = dyn_cast<ArrayType>(t);
             assert(at);
-            init = ConstantArray::get(at, ArrayRef<Constant*>(fields,llvm_nf));
+            return ConstantArray::get(at, ArrayRef<Constant*>(fields,llvm_nf));
         }
-        return new GlobalVariable(*jl_Module, t, true, GlobalVariable::ExternalLinkage, init);
     }
     return NULL;
 }
@@ -265,19 +263,13 @@ static Value *emit_unbox(Type *to, Value *x, jl_value_t *jt)
         return UndefValue::get(to);
     }
     if (ty != jl_pvalue_llvmt) {
-        if (to->isAggregateType()) {
-            x = builder.CreateLoad(x); // something stack allocated
-            ty = x->getType();
-        }
-        else {
-            // bools are stored internally as int8 (for now)
-            if (ty == T_int1 && to == T_int8)
-                return builder.CreateZExt(x, T_int8);
-            if (ty->isPointerTy() && !to->isPointerTy())
-                return builder.CreatePtrToInt(x, to);
-            if (!ty->isPointerTy() && to->isPointerTy())
-                return builder.CreateIntToPtr(x, to);
-        }
+        // bools are stored internally as int8 (for now)
+        if (ty == T_int1 && to == T_int8)
+            return builder.CreateZExt(x, T_int8);
+        if (ty->isPointerTy() && !to->isPointerTy())
+            return builder.CreatePtrToInt(x, to);
+        if (!ty->isPointerTy() && to->isPointerTy())
+            return builder.CreateIntToPtr(x, to);
         if (ty != to) {
             // this can happen when a branch yielding a different type ends
             // up being dead code, and type inference knows that the other
@@ -287,20 +279,21 @@ static Value *emit_unbox(Type *to, Value *x, jl_value_t *jt)
         }
         return x;
     }
-    Value *p = x;
+    Value *p = data_pointer(x);
     if (to == T_int1) {
         // bools stored as int8, so an extra Trunc is needed to get an int1
         return builder.CreateTrunc(builder.
                                    CreateLoad(builder.
-                                              CreateBitCast(p, T_pint8)),
+                                              CreateBitCast(p, T_pint8), false),
                                    T_int1);
     }
     if (to->isStructTy() && !to->isSized()) {
         // empty struct - TODO - is this a good way to represent it?
         assert(to != T_void);
         return UndefValue::get(to);
     }
-    return builder.CreateAlignedLoad(builder.CreateBitCast(p, to->getPointerTo()), 16); // julia's gc gives 16-byte aligned addresses
+    // TODO: stricter alignment if possible
+    return builder.CreateAlignedLoad(builder.CreateBitCast(p, to->getPointerTo()), sizeof(void*), false);
 }
 
 // unbox trying to determine type automatically
@@ -334,9 +327,7 @@ static Value *auto_unbox(jl_value_t *x, jl_codectx_t *ctx)
     if (to == T_void) {
         return NULL;
     }
-    if (to->isAggregateType() && jl_is_immutable_datatype(bt)) // can lazy load on demand, no copy needed
-        return builder.CreateBitCast(v, to->getPointerTo());
-    return emit_reg2mem(emit_unbox(to, v, bt), ctx);
+    return emit_unbox(to, v, bt);
 }
 
 // figure out how many bits a bitstype has at compile time, or -1
@@ -366,10 +357,7 @@ static Value *generic_unbox(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
         jl_value_t *p = jl_tparam0(et);
         if (jl_is_leaf_type(p)) {
             Type *to = julia_type_to_llvm(p);
-            Value *lx = emit_unboxed(x,ctx);
-            if (to->isAggregateType() && lx->getType() == PointerType::get(to,0) && jl_is_immutable(p)) // can lazy load on demand, no copy needed
-                return lx;
-            return emit_reg2mem(emit_unbox(to, lx, p), ctx);
+            return emit_unbox(to, emit_unboxed(x,ctx), p);
         }
     }
     int nb = try_to_determine_bitstype_nbits(targ, ctx);
@@ -441,9 +429,6 @@ static Value *generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
 
     Value *vx = auto_unbox(x, ctx);
     Type *vxt = vx->getType();
-    if (llvmt->isAggregateType() && vxt->isPointerTy()) {
-        vxt = vxt->getContainedType(0);
-    }
     //if (vx->getType()->getPrimitiveSizeInBits() != (unsigned)nb)
     //    jl_errorf("box: expected argument with %d bits, got %d", nb,
     //              vx->getType()->getPrimitiveSizeInBits());
@@ -487,10 +472,7 @@ static Value *generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
     }
 
     // dynamically-determined type; evaluate.
-    if (llvmt->isAggregateType()) {
-        vx = builder.CreateLoad(vx); // something stack allocated
-    }
-    return allocate_box_dynamic(emit_expr(targ, ctx), ConstantInt::get(T_size,nb), vx);
+    return allocate_box_dynamic(emit_expr(targ, ctx), ConstantInt::get(T_size,(nb+7)/8), vx);
 }
 
 static Type *staticeval_bitstype(jl_value_t *targ, const char *fname, jl_codectx_t *ctx)

src/cgutils.cpp

@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 import Base.copy, Base.==
-const verbose = false
+const verbose  = false
 ccall((:set_verbose, "./libccalltest"), Void, (Int32,), verbose)
 
 # Test for proper argument register truncation
@@ -115,7 +115,7 @@ b = ccall((:test_big, "./libccalltest"), Struct_Big, (Struct_Big,), a)
 @test b.y == sbig.y - 2
 @test b.z == sbig.z - Int('A')
 
-verbose && Libc.flush_cstdio()
+verbose && flush_cstdio()
 verbose && println("Testing cfunction roundtrip: ")
 # cfunction roundtrip
 for (t,v) in ((Complex{Int32},:ci32),(Complex{Int64},:ci64),
@@ -184,13 +184,7 @@ for (t,v) in ((Complex{Int32},:ci32),(Complex{Int64},:ci64),
         if ($(t).mutable)
             @test !(b === a)
         end
-        b = ccall(cfunction($fname,Any,(Ref{$t},)),Any,(Ref{$t},),$v)
-        verbose && println("C: ",b)
-        @test b == $v
-        @test b === c
-        if ($(t).mutable)
-            @test !(b === a)
-        end
         #b = ccall(cfunction($fname,Any,(Ref{Any},)),Any,(Ref{Any},),$v) # unimplemented
+        #b = ccall(cfunction($fname,Any,(Ref{$t},)),Any,(Ref{$t},),$v) # broken due to #2818
     end
 end

src/codegen.cpp

@@ -2,24 +2,6 @@
 
 using Base.llvmcall
 
-#function add1234(x::Tuple{Int32,Int32,Int32,Int32})
-#    llvmcall("""%3 = add <4 x i32> %1, %0
-#                ret <4 x i32> %3""",
-#        Tuple{Int32,Int32,Int32,Int32},
-#        Tuple{Tuple{Int32,Int32,Int32,Int32},
-#        Tuple{Int32,Int32,Int32,Int32}},
-#        (Int32(1),Int32(2),Int32(3),Int32(4)),
-#        x)
-#end
-#
-#function add1234(x::NTuple{4,Int64})
-#    llvmcall("""%3 = add <4 x i64> %1, %0
-#      ret <4 x i64> %3""",NTuple{4,Int64},
-#      Tuple{NTuple{4,Int64},NTuple{4,Int64}},
-#        (Int64(1),Int64(2),Int64(3),Int64(4)),
-#      x)
-#end
-#
 function add1234(x::Tuple{Int32,Int32,Int32,Int32})
     llvmcall("""%3 = extractvalue [4 x i32] %0, 0
       %4 = extractvalue [4 x i32] %0, 1
@@ -43,6 +25,14 @@ function add1234(x::Tuple{Int32,Int32,Int32,Int32})
         x)
 end
 
+# function add1234(x::NTuple{4,Int64})
+#     llvmcall("""%3 = add <4 x i64> %1, %0
+#       ret <4 x i64> %3""",NTuple{4,Int64},
+#       Tuple{NTuple{4,Int64},NTuple{4,Int64}},
+#         (Int64(1),Int64(2),Int64(3),Int64(4)),
+#       x)
+# end
+
 @test add1234(map(Int32,(2,3,4,5))) === map(Int32,(3,5,7,9))
 #@test add1234(map(Int64,(2,3,4,5))) === map(Int64,(3,5,7,9))
 
@@ -54,11 +44,7 @@ baremodule PlusTest
 
     function +(x::Int32, y::Int32)
         llvmcall("""%3 = add i32 %1, %0
-                    ret i32 %3""",
-            Int32,
-            Tuple{Int32, Int32},
-            x,
-            y)
+                    ret i32 %3""", Int32, Tuple{Int32, Int32}, x, y)
     end
-    @test Int32(1) + Int32(2) == Int32(3)
+    @test Int32(1)+Int32(2)==Int32(3)
 end