Auto merge of #49878 - dlrobertson:va_list_pt0, r=eddyb

bors · bors · commit 8117c30bde8f · 2018-09-28T23:19:11.000Z
libcore: Add VaList and variadic arg handling intrinsics ## Summary - Add intrinsics for `va_start`, `va_end`, `va_copy`, and `va_arg`. - Add `core::va_list::VaList` to `libcore`. Part 1 of (at least) 3 for #44930 Comments and critiques are very much welcomed 😄
diff --git a/src/libcore/ffi.rs b/src/libcore/ffi.rs
@@ -1,3 +1,13 @@
+// Copyright 2018 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.
+
 #![stable(feature = "", since = "1.30.0")]
 
 #![allow(non_camel_case_types)]
@@ -40,3 +50,204 @@ impl fmt::Debug for c_void {
         f.pad("c_void")
     }
 }
+
+#[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"),
+              not(target_arch = "x86_64"), not(stage0)),
+          windows))]
+#[unstable(feature = "c_variadic",
+           reason = "the `c_variadic` feature has not been properly tested on \
+                     all supported platforms",
+  issue = "27745")]
+/// Basic implementation of a `va_list`.
+extern {
+    type VaListImpl;
+}
+
+
+#[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"),
+              not(target_arch = "x86_64"), not(stage0)),
+          windows))]
+impl fmt::Debug for VaListImpl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "va_list* {:p}", self)
+    }
+}
+
+#[cfg(all(target_arch = "aarch64", not(windows), not(stage0)))]
+#[repr(C)]
+#[derive(Debug)]
+#[unstable(feature = "c_variadic",
+           reason = "the `c_variadic` feature has not been properly tested on \
+                     all supported platforms",
+  issue = "27745")]
+/// AArch64 ABI implementation of a `va_list`. See the
+/// [Aarch64 Procedure Call Standard] for more details.
+///
+/// [AArch64 Procedure Call Standard]:
+/// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055b/IHI0055B_aapcs64.pdf
+struct VaListImpl {
+    stack: *mut (),
+    gr_top: *mut (),
+    vr_top: *mut (),
+    gr_offs: i32,
+    vr_offs: i32,
+}
+
+#[cfg(all(target_arch = "powerpc", not(windows), not(stage0)))]
+#[repr(C)]
+#[derive(Debug)]
+#[unstable(feature = "c_variadic",
+           reason = "the `c_variadic` feature has not been properly tested on \
+                     all supported platforms",
+  issue = "27745")]
+/// PowerPC ABI implementation of a `va_list`.
+struct VaListImpl {
+    gpr: u8,
+    fpr: u8,
+    reserved: u16,
+    overflow_arg_area: *mut (),
+    reg_save_area: *mut (),
+}
+
+#[cfg(all(target_arch = "x86_64", not(windows), not(stage0)))]
+#[repr(C)]
+#[derive(Debug)]
+#[unstable(feature = "c_variadic",
+           reason = "the `c_variadic` feature has not been properly tested on \
+                     all supported platforms",
+  issue = "27745")]
+/// x86_64 ABI implementation of a `va_list`.
+struct VaListImpl {
+    gp_offset: i32,
+    fp_offset: i32,
+    overflow_arg_area: *mut (),
+    reg_save_area: *mut (),
+}
+
+/// A wrapper for a `va_list`
+#[cfg(not(stage0))]
+#[lang = "va_list"]
+#[derive(Debug)]
+#[unstable(feature = "c_variadic",
+           reason = "the `c_variadic` feature has not been properly tested on \
+                     all supported platforms",
+  issue = "27745")]
+#[repr(transparent)]
+pub struct VaList<'a>(&'a mut VaListImpl);
+
+// The VaArgSafe trait needs to be used in public interfaces, however, the trait
+// itself must not be allowed to be used outside this module. Allowing users to
+// implement the trait for a new type (thereby allowing the va_arg intrinsic to
+// be used on a new type) is likely to cause undefined behavior.
+//
+// FIXME(dlrobertson): In order to use the VaArgSafe trait in a public interface
+// but also ensure it cannot be used elsewhere, the trait needs to be public
+// within a private module. Once RFC 2145 has been implemented look into
+// improving this.
+#[cfg(not(stage0))]
+mod sealed_trait {
+    /// Trait which whitelists the allowed types to be used with [VaList::arg]
+    ///
+    /// [VaList::va_arg]: struct.VaList.html#method.arg
+    #[unstable(feature = "c_variadic",
+               reason = "the `c_variadic` feature has not been properly tested on \
+                         all supported platforms",
+      issue = "27745")]
+    pub trait VaArgSafe {}
+}
+
+#[cfg(not(stage0))]
+macro_rules! impl_va_arg_safe {
+    ($($t:ty),+) => {
+        $(
+            #[unstable(feature = "c_variadic",
+                       reason = "the `c_variadic` feature has not been properly tested on \
+                                 all supported platforms",
+              issue = "27745")]
+            impl sealed_trait::VaArgSafe for $t {}
+        )+
+    }
+}
+
+#[cfg(not(stage0))]
+impl_va_arg_safe!{i8, i16, i32, i64, usize}
+#[cfg(not(stage0))]
+impl_va_arg_safe!{u8, u16, u32, u64, isize}
+#[cfg(not(stage0))]
+impl_va_arg_safe!{f64}
+
+#[cfg(not(stage0))]
+#[unstable(feature = "c_variadic",
+           reason = "the `c_variadic` feature has not been properly tested on \
+                     all supported platforms",
+  issue = "27745")]
+impl<T> sealed_trait::VaArgSafe for *mut T {}
+#[cfg(not(stage0))]
+#[unstable(feature = "c_variadic",
+           reason = "the `c_variadic` feature has not been properly tested on \
+                     all supported platforms",
+  issue = "27745")]
+impl<T> sealed_trait::VaArgSafe for *const T {}
+
+#[cfg(not(stage0))]
+impl<'a> VaList<'a> {
+    #[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"),
+                  not(target_arch = "x86_64")),
+              windows))]
+    unsafe fn to_intrinsic_ptr(&mut self) -> *mut i8 {
+        &mut self.0 as *mut _ as *mut i8
+    }
+
+    #[cfg(all(any(target_arch = "aarch64", target_arch = "powerpc",
+                  target_arch = "x86_64"),
+              not(windows)))]
+    unsafe fn to_intrinsic_ptr(&mut self) -> *mut i8 {
+        self.0 as *mut _ as *mut i8
+    }
+
+    /// Advance to the next arg.
+    #[unstable(feature = "c_variadic",
+               reason = "the `c_variadic` feature has not been properly tested on \
+                         all supported platforms",
+      issue = "27745")]
+    pub unsafe fn arg<T: sealed_trait::VaArgSafe>(&mut self) -> T {
+        va_arg(self.to_intrinsic_ptr())
+    }
+
+    /// Copy the `va_list` at the current location.
+    #[unstable(feature = "c_variadic",
+               reason = "the `c_variadic` feature has not been properly tested on \
+                         all supported platforms",
+      issue = "27745")]
+    pub unsafe fn copy<F, R>(&mut self, f: F) -> R
+            where F: for<'copy> FnOnce(VaList<'copy>) -> R {
+        #[cfg(all(any(target_arch = "aarch64", target_arch = "powerpc",
+                      target_arch = "x86_64"),
+                  not(windows)))]
+        let ap_inner = &mut ::mem::uninitialized::<VaListImpl>();
+        #[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"),
+                      not(target_arch = "x86_64")),
+                  windows))]
+        let ap_inner: &mut VaListImpl = &mut *(1 as *mut VaListImpl);
+        let mut ap = VaList(ap_inner);
+        let ap_ptr = ap.to_intrinsic_ptr();
+        va_copy(ap_ptr, self.to_intrinsic_ptr());
+        let ret = f(ap);
+        va_end(ap_ptr);
+        ret
+    }
+}
+
+#[cfg(not(stage0))]
+extern "rust-intrinsic" {
+    /// Destroy the arglist `ap` after initialization with `va_start` or
+    /// `va_copy`.
+    fn va_end(ap: *mut i8);
+
+    /// Copy the current location of arglist `src` to the arglist `dst`.
+    fn va_copy(dst: *mut i8, src: *const i8);
+
+    /// Loads an argument of type `T` from the `va_list` `ap` and increment the
+    /// argument `ap` points to.
+    fn va_arg<T: sealed_trait::VaArgSafe>(ap: *mut i8) -> T;
+}
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
@@ -279,6 +279,7 @@ language_item_table! {
     IndexMutTraitLangItem,           "index_mut",               index_mut_trait;
 
     UnsafeCellTypeLangItem,          "unsafe_cell",             unsafe_cell_type;
+    VaListTypeLangItem,              "va_list",                 va_list;
 
     DerefTraitLangItem,              "deref",                   deref_trait;
     DerefMutTraitLangItem,           "deref_mut",               deref_mut_trait;
diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs
@@ -768,6 +768,11 @@ fn declare_intrinsic(cx: &CodegenCx<'ll, '_>, key: &str) -> Option<&'ll Value> {
     ifn!("llvm.assume", fn(i1) -> void);
     ifn!("llvm.prefetch", fn(i8p, t_i32, t_i32, t_i32) -> void);
 
+    // variadic intrinsics
+    ifn!("llvm.va_start", fn(i8p) -> void);
+    ifn!("llvm.va_end", fn(i8p) -> void);
+    ifn!("llvm.va_copy", fn(i8p, i8p) -> void);
+
     if cx.sess().opts.debuginfo != DebugInfo::None {
         ifn!("llvm.dbg.declare", fn(Type::metadata(cx), Type::metadata(cx)) -> void);
         ifn!("llvm.dbg.value", fn(Type::metadata(cx), t_i64, Type::metadata(cx)) -> void);
diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
@@ -23,9 +23,9 @@ use glue;
 use type_::Type;
 use type_of::LayoutLlvmExt;
 use rustc::ty::{self, Ty};
-use rustc::ty::layout::{HasDataLayout, LayoutOf};
+use rustc::ty::layout::{self, Primitive, HasDataLayout, LayoutOf};
 use rustc::hir;
-use syntax::ast;
+use syntax::ast::{self, FloatTy};
 use syntax::symbol::Symbol;
 use builder::Builder;
 use value::Value;
@@ -78,6 +78,9 @@ fn get_simple_intrinsic(cx: &CodegenCx<'ll, '_>, name: &str) -> Option<&'ll Valu
         "roundf64" => "llvm.round.f64",
         "assume" => "llvm.assume",
         "abort" => "llvm.trap",
+        "va_start" => "llvm.va_start",
+        "va_copy" => "llvm.va_copy",
+        "va_end" => "llvm.va_end",
         _ => return None
     };
     Some(cx.get_intrinsic(&llvm_name))
@@ -141,6 +144,26 @@ pub fn codegen_intrinsic_call(
             let llfn = cx.get_intrinsic(&("llvm.debugtrap"));
             bx.call(llfn, &[], None)
         }
+        "va_arg" => {
+            match fn_ty.ret.layout.abi {
+                layout::Abi::Scalar(ref scalar) => {
+                    match scalar.value {
+                        Primitive::Int(..) |
+                        Primitive::Float(FloatTy::F64) |
+                        Primitive::Pointer => {
+                            bx.va_arg(args[0].immediate(), llret_ty)
+                        }
+                        // `va_arg` should never be used with the return type f32.
+                        Primitive::Float(FloatTy::F32) => {
+                            bug!("the va_arg intrinsic does not work with `f32`")
+                        }
+                    }
+                }
+                _ => {
+                    bug!("the va_arg intrinsic does not work with non-scalar types")
+                }
+            }
+        }
         "size_of" => {
             let tp_ty = substs.type_at(0);
             C_usize(cx, cx.size_of(tp_ty).bytes())
diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs
@@ -321,6 +321,18 @@ pub fn check_intrinsic_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                 (0, vec![tcx.mk_fn_ptr(fn_ty), mut_u8, mut_u8], tcx.types.i32)
             }
 
+            "va_start" | "va_end" => {
+                (0, vec![tcx.mk_mut_ptr(tcx.types.i8)], tcx.mk_unit())
+            }
+
+            "va_copy" => {
+                (0, vec![tcx.mk_mut_ptr(tcx.types.i8), tcx.mk_imm_ptr(tcx.types.i8)], tcx.mk_unit())
+            }
+
+            "va_arg" => {
+                (1, vec![tcx.mk_mut_ptr(tcx.types.i8)], param(0))
+            }
+
             "nontemporal_store" => {
                 (1, vec![ tcx.mk_mut_ptr(param(0)), param(0) ], tcx.mk_unit())
             }
diff --git a/src/libstd/ffi/mod.rs b/src/libstd/ffi/mod.rs
@@ -176,3 +176,12 @@ pub use core::ffi::c_void;
 
 mod c_str;
 mod os_str;
+#[unstable(feature = "c_variadic",
+           reason = "the `c_variadic` feature has not been properly tested on \
+                     all supported platforms",
+           issue = "27745")]
+#[cfg(any(target_arch = "aarch64", target_arch = "arm", target_arch = "mips",
+          target_arch = "powerpc", target_arch = "powerpc64", target_arch = "x86",
+          target_arch = "x86_64"))]
+#[cfg(not(stage0))]
+pub use core::ffi::*;
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
@@ -245,6 +245,7 @@
 #![feature(array_error_internals)]
 #![feature(asm)]
 #![feature(box_syntax)]
+#![feature(c_variadic)]
 #![feature(cfg_target_has_atomic)]
 #![feature(cfg_target_thread_local)]
 #![feature(cfg_target_vendor)]
diff --git a/src/test/run-make-fulldeps/c-link-to-rust-va-list-fn/Makefile b/src/test/run-make-fulldeps/c-link-to-rust-va-list-fn/Makefile
@@ -0,0 +1,6 @@
+-include ../tools.mk
+
+all:
+	$(RUSTC) checkrust.rs
+	$(CC) test.c $(call STATICLIB,checkrust) $(call OUT_EXE,test) $(EXTRACFLAGS)
+	$(call RUN,test)
diff --git a/src/test/run-make-fulldeps/c-link-to-rust-va-list-fn/checkrust.rs b/src/test/run-make-fulldeps/c-link-to-rust-va-list-fn/checkrust.rs
diff --git a/src/test/run-make-fulldeps/c-link-to-rust-va-list-fn/test.c b/src/test/run-make-fulldeps/c-link-to-rust-va-list-fn/test.c
diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
