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

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 😄

Author: bors

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;
+}

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;

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);

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())

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())
             }

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::*;

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)]

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)

src/test/run-make-fulldeps/c-link-to-rust-va-list-fn/checkrust.rs

@@ -0,0 +1,127 @@
+// 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.
+
+#![crate_type = "staticlib"]
+#![feature(c_variadic)]
+use std::ffi::VaList;
+use std::slice;
+use std::ffi::CStr;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub enum AnswerType {
+    Double,
+    Long,
+    Int,
+    Byte,
+    CStr,
+    Skip,
+}
+
+#[repr(C)]
+pub union AnswerData {
+    pub double: f64,
+    pub long: i64,
+    pub int: i32,
+    pub byte: i8,
+    pub cstr: *const i8,
+    pub skip_ty: AnswerType,
+}
+
+#[repr(C)]
+pub struct Answer {
+    tag: AnswerType,
+    data: AnswerData,
+}
+
+#[no_mangle]
+pub unsafe fn compare_answers(answers: &[Answer], mut ap: VaList) -> usize {
+    for (i, answer) in answers.iter().enumerate() {
+        match answer {
+            Answer { tag: AnswerType::Double, data: AnswerData { double: d } } => {
+                let tmp = ap.arg::<f64>();
+                if d.floor() != tmp.floor() {
+                    println!("Double: {} != {}", d, tmp);
+                    return i + 1;
+                }
+            }
+            Answer { tag: AnswerType::Long, data: AnswerData { long: l } } => {
+                let tmp =  ap.arg::<i64>();
+                if *l != tmp {
+                    println!("Long: {} != {}", l, tmp);
+                    return i + 1;
+                }
+            }
+            Answer { tag: AnswerType::Int, data: AnswerData { int: n } } => {
+                let tmp = ap.arg::<i32>();
+                if *n != tmp {
+                    println!("Int: {} != {}", n, tmp);
+                    return i + 1;
+                }
+            }
+            Answer { tag: AnswerType::Byte, data: AnswerData { byte: b } } => {
+                let tmp = ap.arg::<i8>();
+                if *b != tmp {
+                    println!("Byte: {} != {}", b, tmp);
+                    return i + 1;
+                }
+            }
+            Answer { tag: AnswerType::CStr, data: AnswerData { cstr: c0 } } => {
+                let c1 = ap.arg::<*const i8>();
+                let cstr0 = CStr::from_ptr(*c0);
+                let cstr1 = CStr::from_ptr(c1);
+                if cstr0 != cstr1 {
+                    println!("C String: {:?} != {:?}", cstr0, cstr1);
+                    return i + 1;
+                }
+            }
+            _ => {
+                println!("Unknown type!");
+                return i + 1;
+            }
+        }
+    }
+    return 0;
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn check_rust(argc: usize, answers: *const Answer, ap: VaList) -> usize {
+    let slice = slice::from_raw_parts(answers, argc);
+    compare_answers(slice, ap)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn check_rust_copy(argc: usize, answers: *const Answer,
+                                         mut ap: VaList) -> usize {
+    let slice = slice::from_raw_parts(answers, argc);
+    let mut skip_n = 0;
+    for (i, answer) in slice.iter().enumerate() {
+        match answer {
+            Answer { tag: AnswerType::Skip, data: AnswerData { skip_ty } } => {
+                match skip_ty {
+                    AnswerType::Double => { ap.arg::<f64>(); }
+                    AnswerType::Long => { ap.arg::<i64>(); }
+                    AnswerType::Int => { ap.arg::<i32>(); }
+                    AnswerType::Byte => { ap.arg::<i8>(); }
+                    AnswerType::CStr => { ap.arg::<*const i8>(); }
+                    _ => { return i; }
+                };
+            }
+            _ => {
+                skip_n = i;
+                break;
+            }
+        }
+    }
+
+    ap.copy(|ap| {
+        compare_answers(&slice[skip_n..], ap)
+    })
+}

src/test/run-make-fulldeps/c-link-to-rust-va-list-fn/test.c

@@ -0,0 +1,82 @@
+// 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.
+
+#include <stdarg.h>
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum {
+    TAG_DOUBLE,
+    TAG_LONG,
+    TAG_INT,
+    TAG_BYTE,
+    TAG_CSTR,
+    TAG_SKIP,
+} tag;
+
+typedef struct {
+    tag answer_type;
+    union {
+        double double_precision;
+        int64_t num_long;
+        int32_t num_int;
+        int8_t byte;
+        char* cstr;
+        tag skip_ty;
+    } answer_data;
+} answer;
+
+#define MK_DOUBLE(n) \
+    { TAG_DOUBLE, { .double_precision = n } }
+#define MK_LONG(n) \
+    { TAG_LONG, { .num_long = n } }
+#define MK_INT(n) \
+    { TAG_INT, { .num_int = n } }
+#define MK_BYTE(b) \
+    { TAG_BYTE, { .byte = b } }
+#define MK_CSTR(s) \
+    { TAG_CSTR, { .cstr = s } }
+#define MK_SKIP(ty) \
+    { TAG_SKIP, { .skip_ty = TAG_ ## ty } }
+
+extern size_t check_rust(size_t argc, const answer* answers, va_list ap);
+extern size_t check_rust_copy(size_t argc, const answer* answers, va_list ap);
+
+size_t test_check_rust(size_t argc, const answer* answers, ...) {
+    size_t ret = 0;
+    va_list ap;
+    va_start(ap, answers);
+    ret = check_rust(argc, answers, ap);
+    va_end(ap);
+    return ret;
+}
+
+size_t test_check_rust_copy(size_t argc, const answer* answers, ...) {
+    size_t ret = 0;
+    va_list ap;
+    va_start(ap, answers);
+    ret = check_rust_copy(argc, answers, ap);
+    va_end(ap);
+    return ret;
+}
+
+int main(int argc, char* argv[]) {
+    answer answers0[] = {MK_DOUBLE(3.14), MK_BYTE('a'), MK_DOUBLE(6.28),
+                         MK_INT(42), MK_LONG(12l), MK_CSTR("Hello, World!")};
+    assert(test_check_rust(4, answers0, 3.14, 'a', 6.28, 42, 12l,
+                           "Hello, World!") == 0);
+
+    answer answers1[] = { MK_SKIP(DOUBLE), MK_SKIP(INT), MK_SKIP(BYTE),
+                          MK_SKIP(CSTR), MK_CSTR("Correctly skipped and copied list") };
+    assert(test_check_rust_copy(5, answers1, 6.28, 16, 'A', "Skip Me!",
+                                "Correctly skipped and copied list") == 0);
+    return 0;
+}

src/tools/tidy/src/pal.rs

@@ -78,6 +78,13 @@ const EXCEPTION_PATHS: &[&str] = &[
     "src/libcore/tests",
     "src/liballoc/tests/lib.rs",
 
+    // The `VaList` implementation must have platform specific code.
+    // The Windows implementation of a `va_list` is always a character
+    // pointer regardless of the target architecture. As a result,
+    // we must use `#[cfg(windows)]` to conditionally compile the
+    // correct `VaList` structure for windows.
+    "src/libcore/ffi.rs",
+
     // non-std crates
     "src/test",
     "src/tools",