Rollup merge of rust-lang#32732 - dotdash:ext_arg, r=eddyb

Manishearth · Manishearth · commit 81d3d712c78f · 2016-04-06T12:42:34.000+05:30
Handle integer-extending for C ABI

We need to supply sext/zext attributes to LLVM to ensure that arguments
are extended to the appropriate width in the correct way.

Most platforms extend integers less than 32 bits, though not all.
diff --git a/src/librustc_trans/abi.rs b/src/librustc_trans/abi.rs
@@ -80,6 +80,8 @@ pub struct ArgType {
     /// Only later will `original_ty` aka `%Foo` be used in the LLVM function
     /// pointer type, without ever having introspected it.
     pub ty: Type,
+    /// Signedness for integer types, None for other types
+    pub signedness: Option<bool>,
     /// Coerced LLVM Type
     pub cast: Option<Type>,
     /// Dummy argument, which is emitted before the real argument
@@ -94,6 +96,7 @@ impl ArgType {
             kind: ArgKind::Direct,
             original_ty: original_ty,
             ty: ty,
+            signedness: None,
             cast: None,
             pad: None,
             attrs: llvm::Attributes::default()
@@ -123,6 +126,19 @@ impl ArgType {
         self.kind = ArgKind::Ignore;
     }
 
+    pub fn extend_integer_width_to(&mut self, bits: u64) {
+        // Only integers have signedness
+        if let Some(signed) = self.signedness {
+            if self.ty.int_width() < bits {
+                self.attrs.set(if signed {
+                    llvm::Attribute::SExt
+                } else {
+                    llvm::Attribute::ZExt
+                });
+            }
+        }
+    }
+
     pub fn is_indirect(&self) -> bool {
         self.kind == ArgKind::Indirect
     }
@@ -268,6 +284,9 @@ impl FnType {
             } else {
                 let mut arg = ArgType::new(type_of::type_of(ccx, ty),
                                            type_of::sizing_type_of(ccx, ty));
+                if ty.is_integral() {
+                    arg.signedness = Some(ty.is_signed());
+                }
                 if llsize_of_real(ccx, arg.ty) == 0 {
                     // For some forsaken reason, x86_64-pc-windows-gnu
                     // doesn't ignore zero-sized struct arguments.
diff --git a/src/librustc_trans/cabi_aarch64.rs b/src/librustc_trans/cabi_aarch64.rs
@@ -163,6 +163,7 @@ fn is_homogenous_aggregate_ty(ty: Type) -> Option<(Type, u64)> {
 
 fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {
     if is_reg_ty(ret.ty) {
+        ret.extend_integer_width_to(32);
         return;
     }
     if let Some((base_ty, members)) = is_homogenous_aggregate_ty(ret.ty) {
@@ -190,6 +191,7 @@ fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {
 
 fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType) {
     if is_reg_ty(arg.ty) {
+        arg.extend_integer_width_to(32);
         return;
     }
     if let Some((base_ty, members)) = is_homogenous_aggregate_ty(arg.ty) {
diff --git a/src/librustc_trans/cabi_arm.rs b/src/librustc_trans/cabi_arm.rs
@@ -131,6 +131,7 @@ fn ty_size(ty: Type, align_fn: TyAlignFn) -> usize {
 
 fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType, align_fn: TyAlignFn) {
     if is_reg_ty(ret.ty) {
+        ret.extend_integer_width_to(32);
         return;
     }
     let size = ty_size(ret.ty, align_fn);
@@ -150,6 +151,7 @@ fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType, align_fn: TyAlignFn) {
 
 fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, align_fn: TyAlignFn) {
     if is_reg_ty(arg.ty) {
+        arg.extend_integer_width_to(32);
         return;
     }
     let align = align_fn(arg.ty);
diff --git a/src/librustc_trans/cabi_mips.rs b/src/librustc_trans/cabi_mips.rs
@@ -86,6 +86,14 @@ fn ty_size(ty: Type) -> usize {
     }
 }
 
+fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {
+    if is_reg_ty(ret.ty) {
+        ret.extend_integer_width_to(32);
+    } else {
+        ret.make_indirect(ccx);
+    }
+}
+
 fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {
     let orig_offset = *offset;
     let size = ty_size(arg.ty) * 8;
@@ -98,6 +106,8 @@ fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {
     if !is_reg_ty(arg.ty) {
         arg.cast = Some(struct_ty(ccx, arg.ty));
         arg.pad = padding_ty(ccx, align, orig_offset);
+    } else {
+        arg.extend_integer_width_to(32);
     }
 }
 
@@ -146,8 +156,8 @@ fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {
 }
 
 pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {
-    if !fty.ret.is_ignore() && !is_reg_ty(fty.ret.ty) {
-        fty.ret.make_indirect(ccx);
+    if !fty.ret.is_ignore() {
+        classify_ret_ty(ccx, &mut fty.ret);
     }
 
     let mut offset = if fty.ret.is_indirect() { 4 } else { 0 };
diff --git a/src/librustc_trans/cabi_powerpc.rs b/src/librustc_trans/cabi_powerpc.rs
@@ -82,6 +82,14 @@ fn ty_size(ty: Type) -> usize {
     }
 }
 
+fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {
+    if is_reg_ty(ret.ty) {
+        ret.extend_integer_width_to(32);
+    } else {
+        ret.make_indirect(ccx);
+    }
+}
+
 fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {
     let orig_offset = *offset;
     let size = ty_size(arg.ty) * 8;
@@ -94,6 +102,8 @@ fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {
     if !is_reg_ty(arg.ty) {
         arg.cast = Some(struct_ty(ccx, arg.ty));
         arg.pad = padding_ty(ccx, align, orig_offset);
+    } else {
+        arg.extend_integer_width_to(32);
     }
 }
 
@@ -141,8 +151,8 @@ fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {
 }
 
 pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {
-    if !fty.ret.is_ignore() && !is_reg_ty(fty.ret.ty) {
-        fty.ret.make_indirect(ccx);
+    if !fty.ret.is_ignore() {
+        classify_ret_ty(ccx, &mut fty.ret);
     }
 
     let mut offset = if fty.ret.is_indirect() { 4 } else { 0 };
diff --git a/src/librustc_trans/cabi_powerpc64.rs b/src/librustc_trans/cabi_powerpc64.rs
@@ -153,6 +153,7 @@ fn is_homogenous_aggregate_ty(ty: Type) -> Option<(Type, u64)> {
 
 fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {
     if is_reg_ty(ret.ty) {
+        ret.extend_integer_width_to(64);
         return;
     }
 
@@ -187,6 +188,7 @@ fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {
 
 fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType) {
     if is_reg_ty(arg.ty) {
+        arg.extend_integer_width_to(64);
         return;
     }
 
diff --git a/src/librustc_trans/cabi_x86.rs b/src/librustc_trans/cabi_x86.rs
@@ -15,25 +15,29 @@ use super::common::*;
 use super::machine::*;
 
 pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {
-    if !fty.ret.is_ignore() && fty.ret.ty.kind() == Struct {
-        // Returning a structure. Most often, this will use
-        // a hidden first argument. On some platforms, though,
-        // small structs are returned as integers.
-        //
-        // Some links:
-        // http://www.angelcode.com/dev/callconv/callconv.html
-        // Clang's ABI handling is in lib/CodeGen/TargetInfo.cpp
-        let t = &ccx.sess().target.target;
-        if t.options.is_like_osx || t.options.is_like_windows {
-            match llsize_of_alloc(ccx, fty.ret.ty) {
-                1 => fty.ret.cast = Some(Type::i8(ccx)),
-                2 => fty.ret.cast = Some(Type::i16(ccx)),
-                4 => fty.ret.cast = Some(Type::i32(ccx)),
-                8 => fty.ret.cast = Some(Type::i64(ccx)),
-                _ => fty.ret.make_indirect(ccx)
+    if !fty.ret.is_ignore() {
+        if fty.ret.ty.kind() == Struct {
+            // Returning a structure. Most often, this will use
+            // a hidden first argument. On some platforms, though,
+            // small structs are returned as integers.
+            //
+            // Some links:
+            // http://www.angelcode.com/dev/callconv/callconv.html
+            // Clang's ABI handling is in lib/CodeGen/TargetInfo.cpp
+            let t = &ccx.sess().target.target;
+            if t.options.is_like_osx || t.options.is_like_windows {
+                match llsize_of_alloc(ccx, fty.ret.ty) {
+                    1 => fty.ret.cast = Some(Type::i8(ccx)),
+                    2 => fty.ret.cast = Some(Type::i16(ccx)),
+                    4 => fty.ret.cast = Some(Type::i32(ccx)),
+                    8 => fty.ret.cast = Some(Type::i64(ccx)),
+                    _ => fty.ret.make_indirect(ccx)
+                }
+            } else {
+                fty.ret.make_indirect(ccx);
             }
         } else {
-            fty.ret.make_indirect(ccx);
+            fty.ret.extend_integer_width_to(32);
         }
     }
 
@@ -42,6 +46,8 @@ pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {
         if arg.ty.kind() == Struct {
             arg.make_indirect(ccx);
             arg.attrs.set(Attribute::ByVal);
+        } else {
+            arg.extend_integer_width_to(32);
         }
     }
 }
diff --git a/src/librustc_trans/cabi_x86_64.rs b/src/librustc_trans/cabi_x86_64.rs
@@ -400,6 +400,8 @@ pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {
             } else {
                 arg.cast = Some(llreg_ty(ccx, &cls));
             }
+        } else {
+            arg.extend_integer_width_to(32);
         }
     }
 
diff --git a/src/librustc_trans/cabi_x86_win64.rs b/src/librustc_trans/cabi_x86_win64.rs
@@ -26,6 +26,8 @@ pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {
                 8 => a.cast = Some(Type::i64(ccx)),
                 _ => a.make_indirect(ccx)
             }
+        } else {
+            a.extend_integer_width_to(32);
         }
     };
 
diff --git a/src/rt/rust_test_helpers.c b/src/rt/rust_test_helpers.c
@@ -243,3 +243,7 @@ double rust_interesting_average(uint64_t n, ...) {
     va_end(pairs);
     return sum / n;
 }
+
+int32_t rust_int8_to_int32(int8_t x) {
+    return (int32_t)x;
+}
diff --git a/src/test/run-pass/cabi-int-widening.rs b/src/test/run-pass/cabi-int-widening.rs
@@ -0,0 +1,22 @@
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[link(name = "rust_test_helpers")]
+extern {
+    fn rust_int8_to_int32(_: i8) -> i32;
+}
+
+fn main() {
+    let x = unsafe {
+        rust_int8_to_int32(-1)
+    };
+
+    assert!(x == -1);
+}

Original file line number	Diff line number	Diff line change
`@@ -163,6 +163,7 @@ fn is_homogenous_aggregate_ty(ty: Type) -> Option<(Type, u64)> {`
`163`	`163`
`164`	`164`	`fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {`
`165`	`165`	`if is_reg_ty(ret.ty) {`
	`166`	`+ ret.extend_integer_width_to(32);`
`166`	`167`	`return;`
`167`	`168`	`}`
`168`	`169`	`if let Some((base_ty, members)) = is_homogenous_aggregate_ty(ret.ty) {`
`@@ -190,6 +191,7 @@ fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {`
`190`	`191`
`191`	`192`	`fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType) {`
`192`	`193`	`if is_reg_ty(arg.ty) {`
	`194`	`+ arg.extend_integer_width_to(32);`
`193`	`195`	`return;`
`194`	`196`	`}`
`195`	`197`	`if let Some((base_ty, members)) = is_homogenous_aggregate_ty(arg.ty) {`
Original file line number	Diff line number	Diff line change
`@@ -131,6 +131,7 @@ fn ty_size(ty: Type, align_fn: TyAlignFn) -> usize {`
`131`	`131`
`132`	`132`	`fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType, align_fn: TyAlignFn) {`
`133`	`133`	`if is_reg_ty(ret.ty) {`
	`134`	`+ ret.extend_integer_width_to(32);`
`134`	`135`	`return;`
`135`	`136`	`}`
`136`	`137`	`let size = ty_size(ret.ty, align_fn);`
`@@ -150,6 +151,7 @@ fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType, align_fn: TyAlignFn) {`
`150`	`151`
`151`	`152`	`fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, align_fn: TyAlignFn) {`
`152`	`153`	`if is_reg_ty(arg.ty) {`
	`154`	`+ arg.extend_integer_width_to(32);`
`153`	`155`	`return;`
`154`	`156`	`}`
`155`	`157`	`let align = align_fn(arg.ty);`
Original file line number	Diff line number	Diff line change
`@@ -86,6 +86,14 @@ fn ty_size(ty: Type) -> usize {`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
	`89`	`+fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {`
	`90`	`+ if is_reg_ty(ret.ty) {`
	`91`	`+ ret.extend_integer_width_to(32);`
	`92`	`+ } else {`
	`93`	`+ ret.make_indirect(ccx);`
	`94`	`+ }`
	`95`	`+}`
	`96`	`+`
`89`	`97`	`fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {`
`90`	`98`	`let orig_offset = *offset;`
`91`	`99`	`let size = ty_size(arg.ty) * 8;`
`@@ -98,6 +106,8 @@ fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {`
`98`	`106`	`if !is_reg_ty(arg.ty) {`
`99`	`107`	`arg.cast = Some(struct_ty(ccx, arg.ty));`
`100`	`108`	`arg.pad = padding_ty(ccx, align, orig_offset);`
	`109`	`+ } else {`
	`110`	`+ arg.extend_integer_width_to(32);`
`101`	`111`	`}`
`102`	`112`	`}`
`103`	`113`
`@@ -146,8 +156,8 @@ fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {`
`146`	`156`	`}`
`147`	`157`
`148`	`158`	`pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {`
`149`		`- if !fty.ret.is_ignore() && !is_reg_ty(fty.ret.ty) {`
`150`		`- fty.ret.make_indirect(ccx);`
	`159`	`+ if !fty.ret.is_ignore() {`
	`160`	`+ classify_ret_ty(ccx, &mut fty.ret);`
`151`	`161`	`}`
`152`	`162`
`153`	`163`	`let mut offset = if fty.ret.is_indirect() { 4 } else { 0 };`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,14 @@ fn ty_size(ty: Type) -> usize {`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
	`85`	`+fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {`
	`86`	`+ if is_reg_ty(ret.ty) {`
	`87`	`+ ret.extend_integer_width_to(32);`
	`88`	`+ } else {`
	`89`	`+ ret.make_indirect(ccx);`
	`90`	`+ }`
	`91`	`+}`
	`92`	`+`
`85`	`93`	`fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {`
`86`	`94`	`let orig_offset = *offset;`
`87`	`95`	`let size = ty_size(arg.ty) * 8;`
`@@ -94,6 +102,8 @@ fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {`
`94`	`102`	`if !is_reg_ty(arg.ty) {`
`95`	`103`	`arg.cast = Some(struct_ty(ccx, arg.ty));`
`96`	`104`	`arg.pad = padding_ty(ccx, align, orig_offset);`
	`105`	`+ } else {`
	`106`	`+ arg.extend_integer_width_to(32);`
`97`	`107`	`}`
`98`	`108`	`}`
`99`	`109`
`@@ -141,8 +151,8 @@ fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {`
`141`	`151`	`}`
`142`	`152`
`143`	`153`	`pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {`
`144`		`- if !fty.ret.is_ignore() && !is_reg_ty(fty.ret.ty) {`
`145`		`- fty.ret.make_indirect(ccx);`
	`154`	`+ if !fty.ret.is_ignore() {`
	`155`	`+ classify_ret_ty(ccx, &mut fty.ret);`
`146`	`156`	`}`
`147`	`157`
`148`	`158`	`let mut offset = if fty.ret.is_indirect() { 4 } else { 0 };`
Original file line number	Diff line number	Diff line change
`@@ -153,6 +153,7 @@ fn is_homogenous_aggregate_ty(ty: Type) -> Option<(Type, u64)> {`
`153`	`153`
`154`	`154`	`fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {`
`155`	`155`	`if is_reg_ty(ret.ty) {`
	`156`	`+ ret.extend_integer_width_to(64);`
`156`	`157`	`return;`
`157`	`158`	`}`
`158`	`159`
`@@ -187,6 +188,7 @@ fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {`
`187`	`188`
`188`	`189`	`fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType) {`
`189`	`190`	`if is_reg_ty(arg.ty) {`
	`191`	`+ arg.extend_integer_width_to(64);`
`190`	`192`	`return;`
`191`	`193`	`}`
`192`	`194`
Original file line number	Diff line number	Diff line change
`@@ -400,6 +400,8 @@ pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {`
`400`	`400`	`} else {`
`401`	`401`	`arg.cast = Some(llreg_ty(ccx, &cls));`
`402`	`402`	`}`
	`403`	`+ } else {`
	`404`	`+ arg.extend_integer_width_to(32);`
`403`	`405`	`}`
`404`	`406`	`}`
`405`	`407`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,8 @@ pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {`
`26`	`26`	`8 => a.cast = Some(Type::i64(ccx)),`
`27`	`27`	`_ => a.make_indirect(ccx)`
`28`	`28`	`}`
	`29`	`+ } else {`
	`30`	`+ a.extend_integer_width_to(32);`
`29`	`31`	`}`
`30`	`32`	`};`
`31`	`33`
Original file line number	Diff line number	Diff line change
`@@ -243,3 +243,7 @@ double rust_interesting_average(uint64_t n, ...) {`
`243`	`243`	`va_end(pairs);`
`244`	`244`	`return sum / n;`
`245`	`245`	`}`
	`246`	`+`
	`247`	`+int32_t rust_int8_to_int32(int8_t x) {`
	`248`	`+ return (int32_t)x;`
	`249`	`+}`