ir: Handle char in a more cross-platform way when possible.

Signed-off-by: Emilio Cobos Álvarez <emilio@crisal.io>

25 files changed, 206 insertions, 53 deletions

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 5586c146..ee4a9d4e 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -2471,7 +2471,8 @@ impl TryToRustTy for Type {
             TypeKind::Int(ik) => {
                 match ik {
                     IntKind::Bool => Ok(aster::ty::TyBuilder::new().bool()),
-                    IntKind::Char => Ok(raw_type(ctx, "c_schar")),
+                    IntKind::Char { .. } => Ok(raw_type(ctx, "c_char")),
+                    IntKind::SChar => Ok(raw_type(ctx, "c_schar")),
                     IntKind::UChar => Ok(raw_type(ctx, "c_uchar")),
                     IntKind::Short => Ok(raw_type(ctx, "c_short")),
                     IntKind::UShort => Ok(raw_type(ctx, "c_ushort")),
diff --git a/src/ir/context.rs b/src/ir/context.rs
index c95d5179..66e7e284 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -1090,8 +1090,38 @@ impl<'ctx> BindgenContext<'ctx> {
             CXType_Bool => TypeKind::Int(IntKind::Bool),
             CXType_Int => TypeKind::Int(IntKind::Int),
             CXType_UInt => TypeKind::Int(IntKind::UInt),
-            CXType_SChar | CXType_Char_S => TypeKind::Int(IntKind::Char),
-            CXType_UChar | CXType_Char_U => TypeKind::Int(IntKind::UChar),
+            CXType_SChar | CXType_Char_S |
+            CXType_UChar | CXType_Char_U => {
+                let spelling = ty.spelling();
+
+                debug_assert!(spelling.contains("char"),
+                              "This is the canonical type, so no aliases or \
+                               typedefs!");
+
+                let signed = match ty.kind() {
+                    CXType_SChar | CXType_Char_S => true,
+                    _ => false,
+                };
+
+                // Clang only gives us the signedness of the target platform.
+                //
+                // Match the spelling for common cases we can handle
+                // cross-platform.
+                match &*spelling {
+                    "char" | "const char" => {
+                        TypeKind::Int(IntKind::Char {
+                            is_signed: signed,
+                        })
+                    },
+                    _ => {
+                        if signed {
+                            TypeKind::Int(IntKind::SChar)
+                        } else {
+                            TypeKind::Int(IntKind::UChar)
+                        }
+                    },
+                }
+            }
             CXType_Short => TypeKind::Int(IntKind::Short),
             CXType_UShort => TypeKind::Int(IntKind::UShort),
             CXType_WChar | CXType_Char16 => TypeKind::Int(IntKind::U16),
diff --git a/src/ir/int.rs b/src/ir/int.rs
index 89068e0f..a4cb8bc7 100644
--- a/src/ir/int.rs
+++ b/src/ir/int.rs
@@ -6,12 +6,18 @@ pub enum IntKind {
     /// A `bool`.
     Bool,
 
-    /// A `char`.
-    Char,
+    /// A `signed char`.
+    SChar,
 
     /// An `unsigned char`.
     UChar,
 
+    /// A platform-dependent `char` type, with the signedness support.
+    Char {
+        /// Whether the char is signed for the target platform.
+        is_signed: bool,
+    },
+
     /// A `short`.
     Short,
 
@@ -84,9 +90,11 @@ impl IntKind {
             Bool | UChar | UShort | UInt | ULong | ULongLong | U8 | U16 |
             U32 | U64 | U128 => false,
 
-            Char | Short | Int | Long | LongLong | I8 | I16 | I32 | I64 |
+            SChar | Short | Int | Long | LongLong | I8 | I16 | I32 | I64 |
             I128 => true,
 
+            Char { is_signed } => is_signed,
+
             Custom { is_signed, .. } => is_signed,
         }
     }
@@ -97,7 +105,7 @@ impl IntKind {
     pub fn known_size(&self) -> Option<usize> {
         use self::IntKind::*;
         Some(match *self {
-            Bool | UChar | Char | U8 | I8 => 1,
+            Bool | UChar | SChar | U8 | I8 | Char { .. } => 1,
             U16 | I16 => 2,
             U32 | I32 => 4,
             U64 | I64 => 8,
diff --git a/tests/expectations/tests/anonymous-template-types.rs b/tests/expectations/tests/anonymous-template-types.rs
index bb4be105..c225b69d 100644
--- a/tests/expectations/tests/anonymous-template-types.rs
+++ b/tests/expectations/tests/anonymous-template-types.rs
@@ -15,7 +15,7 @@ impl <T> Default for Foo<T> {
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct Bar {
-    pub member: ::std::os::raw::c_schar,
+    pub member: ::std::os::raw::c_char,
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -28,6 +28,6 @@ impl <V> Default for Quux<V> {
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct Lobo {
-    pub also_member: ::std::os::raw::c_schar,
+    pub also_member: ::std::os::raw::c_char,
 }
-pub type AliasWithAnonType = ::std::os::raw::c_schar;
+pub type AliasWithAnonType = ::std::os::raw::c_char;
diff --git a/tests/expectations/tests/arg_keyword.rs b/tests/expectations/tests/arg_keyword.rs
index 23818328..cb1cc432 100644
--- a/tests/expectations/tests/arg_keyword.rs
+++ b/tests/expectations/tests/arg_keyword.rs
@@ -6,5 +6,5 @@
 
 extern "C" {
     #[link_name = "_Z3fooPKc"]
-    pub fn foo(type_: *const ::std::os::raw::c_schar);
+    pub fn foo(type_: *const ::std::os::raw::c_char);
 }
diff --git a/tests/expectations/tests/bitfield-method-same-name.rs b/tests/expectations/tests/bitfield-method-same-name.rs
index e180153b..ab74b1e5 100644
--- a/tests/expectations/tests/bitfield-method-same-name.rs
+++ b/tests/expectations/tests/bitfield-method-same-name.rs
@@ -19,22 +19,22 @@ fn bindgen_test_layout_Foo() {
 }
 extern "C" {
     #[link_name = "_ZN3Foo4typeEv"]
-    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_schar;
+    pub fn Foo_type(this: *mut Foo) -> ::std::os::raw::c_char;
 }
 extern "C" {
     #[link_name = "_ZN3Foo9set_type_Ec"]
-    pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_schar);
+    pub fn Foo_set_type_(this: *mut Foo, c: ::std::os::raw::c_char);
 }
 extern "C" {
     #[link_name = "_ZN3Foo8set_typeEc"]
-    pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_schar);
+    pub fn Foo_set_type(this: *mut Foo, c: ::std::os::raw::c_char);
 }
 impl Clone for Foo {
     fn clone(&self) -> Self { *self }
 }
 impl Foo {
     #[inline]
-    pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_schar {
+    pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char {
         let mask = 7usize as u8;
         let field_val: u8 =
             unsafe { ::std::mem::transmute(self._bitfield_1) };
@@ -43,7 +43,7 @@ impl Foo {
     }
     #[inline]
     pub fn set_type__bindgen_bitfield(&mut self,
-                                      val: ::std::os::raw::c_schar) {
+                                      val: ::std::os::raw::c_char) {
         let mask = 7usize as u8;
         let val = val as u8 as u8;
         let mut field_val: u8 =
@@ -53,15 +53,15 @@ impl Foo {
         self._bitfield_1 = unsafe { ::std::mem::transmute(field_val) };
     }
     #[inline]
-    pub unsafe fn type_(&mut self) -> ::std::os::raw::c_schar {
+    pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char {
         Foo_type(self)
     }
     #[inline]
-    pub unsafe fn set_type_(&mut self, c: ::std::os::raw::c_schar) {
+    pub unsafe fn set_type_(&mut self, c: ::std::os::raw::c_char) {
         Foo_set_type_(self, c)
     }
     #[inline]
-    pub unsafe fn set_type(&mut self, c: ::std::os::raw::c_schar) {
+    pub unsafe fn set_type(&mut self, c: ::std::os::raw::c_char) {
         Foo_set_type(self, c)
     }
 }
diff --git a/tests/expectations/tests/char.rs b/tests/expectations/tests/char.rs
new file mode 100644
index 00000000..5541d492
--- /dev/null
+++ b/tests/expectations/tests/char.rs
@@ -0,0 +1,95 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+pub type Char = ::std::os::raw::c_char;
+pub type SChar = ::std::os::raw::c_schar;
+pub type UChar = ::std::os::raw::c_uchar;
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Test {
+    pub ch: ::std::os::raw::c_char,
+    pub u: ::std::os::raw::c_uchar,
+    pub d: ::std::os::raw::c_schar,
+    pub cch: ::std::os::raw::c_char,
+    pub cu: ::std::os::raw::c_uchar,
+    pub cd: ::std::os::raw::c_schar,
+    pub Cch: Char,
+    pub Cu: UChar,
+    pub Cd: SChar,
+    pub Ccch: Char,
+    pub Ccu: UChar,
+    pub Ccd: SChar,
+}
+#[test]
+fn bindgen_test_layout_Test() {
+    assert_eq!(::std::mem::size_of::<Test>() , 12usize , concat ! (
+               "Size of: " , stringify ! ( Test ) ));
+    assert_eq! (::std::mem::align_of::<Test>() , 1usize , concat ! (
+                "Alignment of " , stringify ! ( Test ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . ch as * const _ as usize } ,
+                0usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( ch ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . u as * const _ as usize } ,
+                1usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( u ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . d as * const _ as usize } ,
+                2usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( d ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . cch as * const _ as usize } ,
+                3usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( cch ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . cu as * const _ as usize } ,
+                4usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( cu ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . cd as * const _ as usize } ,
+                5usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( cd ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . Cch as * const _ as usize } ,
+                6usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( Cch ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . Cu as * const _ as usize } ,
+                7usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( Cu ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . Cd as * const _ as usize } ,
+                8usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( Cd ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . Ccch as * const _ as usize } ,
+                9usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( Ccch ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . Ccu as * const _ as usize } ,
+                10usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( Ccu ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Test ) ) . Ccd as * const _ as usize } ,
+                11usize , concat ! (
+                "Alignment of field: " , stringify ! ( Test ) , "::" ,
+                stringify ! ( Ccd ) ));
+}
+impl Clone for Test {
+    fn clone(&self) -> Self { *self }
+}
diff --git a/tests/expectations/tests/class.rs b/tests/expectations/tests/class.rs
index edb2697b..56353a5e 100644
--- a/tests/expectations/tests/class.rs
+++ b/tests/expectations/tests/class.rs
@@ -64,7 +64,7 @@ impl <T> ::std::fmt::Debug for __BindgenUnionField<T> {
 #[repr(C)]
 pub struct C {
     pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_schar; 33usize],
+    pub big_array: [::std::os::raw::c_char; 33usize],
 }
 #[test]
 fn bindgen_test_layout_C() {
@@ -88,8 +88,8 @@ impl Default for C {
 #[repr(C)]
 pub struct C_with_zero_length_array {
     pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_schar; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_schar>,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
 }
 #[test]
 fn bindgen_test_layout_C_with_zero_length_array() {
@@ -124,8 +124,8 @@ impl Default for C_with_zero_length_array {
 #[repr(C)]
 pub struct C_with_incomplete_array {
     pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_schar; 33usize],
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_schar>,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
 }
 #[test]
 fn bindgen_test_layout_C_with_incomplete_array() {
@@ -142,9 +142,9 @@ impl Default for C_with_incomplete_array {
 #[repr(C)]
 pub struct C_with_zero_length_array_and_incomplete_array {
     pub a: ::std::os::raw::c_int,
-    pub big_array: [::std::os::raw::c_schar; 33usize],
-    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_schar>,
-    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_schar>,
+    pub big_array: [::std::os::raw::c_char; 33usize],
+    pub zero_length_array: __IncompleteArrayField<::std::os::raw::c_char>,
+    pub incomplete_array: __IncompleteArrayField<::std::os::raw::c_char>,
 }
 #[test]
 fn bindgen_test_layout_C_with_zero_length_array_and_incomplete_array() {
diff --git a/tests/expectations/tests/class_with_typedef.rs b/tests/expectations/tests/class_with_typedef.rs
index e962992d..642a7287 100644
--- a/tests/expectations/tests/class_with_typedef.rs
+++ b/tests/expectations/tests/class_with_typedef.rs
@@ -15,7 +15,7 @@ pub struct C {
     pub other_ptr: *mut AnotherInt,
 }
 pub type C_MyInt = ::std::os::raw::c_int;
-pub type C_Lookup = *const ::std::os::raw::c_schar;
+pub type C_Lookup = *const ::std::os::raw::c_char;
 #[test]
 fn bindgen_test_layout_C() {
     assert_eq!(::std::mem::size_of::<C>() , 72usize , concat ! (
diff --git a/tests/expectations/tests/constant-evaluate.rs b/tests/expectations/tests/constant-evaluate.rs
index ae0570ea..cdf097a2 100644
--- a/tests/expectations/tests/constant-evaluate.rs
+++ b/tests/expectations/tests/constant-evaluate.rs
@@ -14,7 +14,7 @@ pub const k: EasyToOverflow = 2147483648;
 pub const k_expr: EasyToOverflow = 0;
 pub const BAZ: ::std::os::raw::c_longlong = 24;
 pub const fuzz: f64 = 51.;
-pub const BAZZ: ::std::os::raw::c_schar = 53;
-pub const WAT: ::std::os::raw::c_schar = 0;
+pub const BAZZ: ::std::os::raw::c_char = 53;
+pub const WAT: ::std::os::raw::c_char = 0;
 pub const bytestring: &'static [u8; 4usize] = b"Foo\x00";
 pub const NOT_UTF8: [u8; 5usize] = [240, 40, 140, 40, 0];
diff --git a/tests/expectations/tests/inline_namespace_whitelist.rs b/tests/expectations/tests/inline_namespace_whitelist.rs
index d4a5aaff..96012684 100644
--- a/tests/expectations/tests/inline_namespace_whitelist.rs
+++ b/tests/expectations/tests/inline_namespace_whitelist.rs
@@ -11,6 +11,6 @@ pub mod root {
     pub mod std {
         #[allow(unused_imports)]
         use self::super::super::root;
-        pub type string = *const ::std::os::raw::c_schar;
+        pub type string = *const ::std::os::raw::c_char;
     }
 }
diff --git a/tests/expectations/tests/issue-493.rs b/tests/expectations/tests/issue-493.rs
index 155834a3..04fa1d8c 100644
--- a/tests/expectations/tests/issue-493.rs
+++ b/tests/expectations/tests/issue-493.rs
@@ -34,7 +34,7 @@ pub struct basic_string {
     pub _address: u8,
 }
 pub type basic_string_size_type = ::std::os::raw::c_ulonglong;
-pub type basic_string_value_type = ::std::os::raw::c_schar;
+pub type basic_string_value_type = ::std::os::raw::c_char;
 pub type basic_string_pointer = *mut basic_string_value_type;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
diff --git a/tests/expectations/tests/layout.rs b/tests/expectations/tests/layout.rs
index d0748672..115a108a 100644
--- a/tests/expectations/tests/layout.rs
+++ b/tests/expectations/tests/layout.rs
@@ -40,7 +40,7 @@ impl <T> ::std::marker::Copy for __IncompleteArrayField<T> { }
 #[repr(C, packed)]
 #[derive(Debug, Default, Copy)]
 pub struct header {
-    pub proto: ::std::os::raw::c_schar,
+    pub proto: ::std::os::raw::c_char,
     pub size: ::std::os::raw::c_uint,
     pub data: __IncompleteArrayField<::std::os::raw::c_uchar>,
     pub __bindgen_padding_0: [u8; 11usize],
diff --git a/tests/expectations/tests/layout_array.rs b/tests/expectations/tests/layout_array.rs
index eedc32b2..2cc85785 100644
--- a/tests/expectations/tests/layout_array.rs
+++ b/tests/expectations/tests/layout_array.rs
@@ -58,7 +58,7 @@ pub type rte_mempool_get_count =
 #[derive(Debug, Copy)]
 pub struct rte_mempool_ops {
     /**< Name of mempool ops struct. */
-    pub name: [::std::os::raw::c_schar; 32usize],
+    pub name: [::std::os::raw::c_char; 32usize],
     /**< Allocate private data. */
     pub alloc: rte_mempool_alloc_t,
     /**< Free the external pool. */
diff --git a/tests/expectations/tests/layout_cmdline_token.rs b/tests/expectations/tests/layout_cmdline_token.rs
index c2b10455..791ea9b3 100644
--- a/tests/expectations/tests/layout_cmdline_token.rs
+++ b/tests/expectations/tests/layout_cmdline_token.rs
@@ -64,7 +64,7 @@ pub struct cmdline_token_ops {
     pub parse: ::std::option::Option<unsafe extern "C" fn(arg1:
                                                               *mut cmdline_parse_token_hdr_t,
                                                           arg2:
-                                                              *const ::std::os::raw::c_schar,
+                                                              *const ::std::os::raw::c_char,
                                                           arg3:
                                                               *mut ::std::os::raw::c_void,
                                                           arg4:
@@ -80,7 +80,7 @@ pub struct cmdline_token_ops {
                                                                      arg2:
                                                                          ::std::os::raw::c_int,
                                                                      arg3:
-                                                                         *mut ::std::os::raw::c_schar,
+                                                                         *mut ::std::os::raw::c_char,
                                                                      arg4:
                                                                          ::std::os::raw::c_uint)
                                                     -> ::std::os::raw::c_int>,
@@ -88,7 +88,7 @@ pub struct cmdline_token_ops {
     pub get_help: ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                  *mut cmdline_parse_token_hdr_t,
                                                              arg2:
-                                                                 *mut ::std::os::raw::c_schar,
+                                                                 *mut ::std::os::raw::c_char,
                                                              arg3:
                                                                  ::std::os::raw::c_uint)
                                             -> ::std::os::raw::c_int>,
diff --git a/tests/expectations/tests/layout_kni_mbuf.rs b/tests/expectations/tests/layout_kni_mbuf.rs
index 209be0f1..d704267d 100644
--- a/tests/expectations/tests/layout_kni_mbuf.rs
+++ b/tests/expectations/tests/layout_kni_mbuf.rs
@@ -11,22 +11,22 @@ pub const RTE_CACHE_LINE_SIZE: ::std::os::raw::c_uint = 64;
 pub struct rte_kni_mbuf {
     pub buf_addr: *mut ::std::os::raw::c_void,
     pub buf_physaddr: u64,
-    pub pad0: [::std::os::raw::c_schar; 2usize],
+    pub pad0: [::std::os::raw::c_char; 2usize],
     /**< Start address of data in segment buffer. */
     pub data_off: u16,
-    pub pad1: [::std::os::raw::c_schar; 2usize],
+    pub pad1: [::std::os::raw::c_char; 2usize],
     /**< Number of segments. */
     pub nb_segs: u8,
-    pub pad4: [::std::os::raw::c_schar; 1usize],
+    pub pad4: [::std::os::raw::c_char; 1usize],
     /**< Offload features. */
     pub ol_flags: u64,
-    pub pad2: [::std::os::raw::c_schar; 4usize],
+    pub pad2: [::std::os::raw::c_char; 4usize],
     /**< Total pkt len: sum of all segment data_len. */
     pub pkt_len: u32,
     /**< Amount of data in segment buffer. */
     pub data_len: u16,
     pub __bindgen_padding_0: [u8; 22usize],
-    pub pad3: [::std::os::raw::c_schar; 8usize],
+    pub pad3: [::std::os::raw::c_char; 8usize],
     pub pool: *mut ::std::os::raw::c_void,
     pub next: *mut ::std::os::raw::c_void,
     pub __bindgen_padding_1: [u64; 5usize],
diff --git a/tests/expectations/tests/objc_class_method.rs b/tests/expectations/tests/objc_class_method.rs
index 768abe10..699f5619 100644
--- a/tests/expectations/tests/objc_class_method.rs
+++ b/tests/expectations/tests/objc_class_method.rs
@@ -19,7 +19,7 @@ pub trait Foo {
     -> *mut id;
     unsafe fn methodWithArg1_andArg2_andArg3_(intvalue: ::std::os::raw::c_int,
                                               ptr:
-                                                  *mut ::std::os::raw::c_schar,
+                                                  *mut ::std::os::raw::c_char,
                                               floatvalue: f32);
 }
 impl Foo for id {
@@ -45,7 +45,7 @@ impl Foo for id {
     }
     unsafe fn methodWithArg1_andArg2_andArg3_(intvalue: ::std::os::raw::c_int,
                                               ptr:
-                                                  *mut ::std::os::raw::c_schar,
+                                                  *mut ::std::os::raw::c_char,
                                               floatvalue: f32) {
         msg_send!(objc :: runtime :: Class :: get ( "Foo" ) . expect (
                   "Couldn\'t find Foo" ) ,
diff --git a/tests/expectations/tests/objc_method.rs b/tests/expectations/tests/objc_method.rs
index c9b9504f..d0342a21 100644
--- a/tests/expectations/tests/objc_method.rs
+++ b/tests/expectations/tests/objc_method.rs
@@ -20,7 +20,7 @@ pub trait Foo {
     unsafe fn methodWithArg1_andArg2_andArg3_(self,
                                               intvalue: ::std::os::raw::c_int,
                                               ptr:
-                                                  *mut ::std::os::raw::c_schar,
+                                                  *mut ::std::os::raw::c_char,
                                               floatvalue: f32);
 }
 impl Foo for id {
@@ -40,7 +40,7 @@ impl Foo for id {
     unsafe fn methodWithArg1_andArg2_andArg3_(self,
                                               intvalue: ::std::os::raw::c_int,
                                               ptr:
-                                                  *mut ::std::os::raw::c_schar,
+                                                  *mut ::std::os::raw::c_char,
                                               floatvalue: f32) {
         msg_send!(self ,
                   methodWithArg1:intvalue andArg2:ptr andArg3:floatvalue )
diff --git a/tests/expectations/tests/overloading.rs b/tests/expectations/tests/overloading.rs
index 99efe496..71002e23 100644
--- a/tests/expectations/tests/overloading.rs
+++ b/tests/expectations/tests/overloading.rs
@@ -6,7 +6,7 @@
 
 extern "C" {
     #[link_name = "_Z8Evaluatec"]
-    pub fn Evaluate(r: ::std::os::raw::c_schar) -> bool;
+    pub fn Evaluate(r: ::std::os::raw::c_char) -> bool;
 }
 extern "C" {
     #[link_name = "_Z8Evaluateii"]
diff --git a/tests/expectations/tests/struct_with_packing.rs b/tests/expectations/tests/struct_with_packing.rs
index 293cc534..cba3d475 100644
--- a/tests/expectations/tests/struct_with_packing.rs
+++ b/tests/expectations/tests/struct_with_packing.rs
@@ -7,7 +7,7 @@
 #[repr(C, packed)]
 #[derive(Debug, Default, Copy)]
 pub struct a {
-    pub b: ::std::os::raw::c_schar,
+    pub b: ::std::os::raw::c_char,
     pub c: ::std::os::raw::c_short,
 }
 #[test]
diff --git a/tests/expectations/tests/template-param-usage-7.rs b/tests/expectations/tests/template-param-usage-7.rs
index b0584479..2544ffd0 100644
--- a/tests/expectations/tests/template-param-usage-7.rs
+++ b/tests/expectations/tests/template-param-usage-7.rs
@@ -13,4 +13,4 @@ pub struct DoesNotUseU<T, V> {
 impl <T, V> Default for DoesNotUseU<T, V> {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
-pub type Alias = DoesNotUseU<::std::os::raw::c_int, ::std::os::raw::c_schar>;
+pub type Alias = DoesNotUseU<::std::os::raw::c_int, ::std::os::raw::c_char>;
diff --git a/tests/expectations/tests/union_with_big_member.rs b/tests/expectations/tests/union_with_big_member.rs
index 0a11b8bc..2b7a8eef 100644
--- a/tests/expectations/tests/union_with_big_member.rs
+++ b/tests/expectations/tests/union_with_big_member.rs
@@ -62,7 +62,7 @@ impl Default for WithBigArray {
 #[derive(Debug, Default, Copy)]
 pub struct WithBigArray2 {
     pub a: __BindgenUnionField<::std::os::raw::c_int>,
-    pub b: __BindgenUnionField<[::std::os::raw::c_schar; 33usize]>,
+    pub b: __BindgenUnionField<[::std::os::raw::c_char; 33usize]>,
     pub bindgen_union_field: [u32; 9usize],
 }
 #[test]
diff --git a/tests/expectations/tests/variadic-method.rs b/tests/expectations/tests/variadic-method.rs
index 6241c2cb..542e1e75 100644
--- a/tests/expectations/tests/variadic-method.rs
+++ b/tests/expectations/tests/variadic-method.rs
@@ -6,7 +6,7 @@
 
 extern "C" {
     #[link_name = "_Z3fooPKcz"]
-    pub fn foo(fmt: *const ::std::os::raw::c_schar, ...);
+    pub fn foo(fmt: *const ::std::os::raw::c_char, ...);
 }
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
@@ -22,7 +22,7 @@ fn bindgen_test_layout_Bar() {
 }
 extern "C" {
     #[link_name = "_ZN3Bar3fooEPKcz"]
-    pub fn Bar_foo(this: *mut Bar, fmt: *const ::std::os::raw::c_schar, ...);
+    pub fn Bar_foo(this: *mut Bar, fmt: *const ::std::os::raw::c_char, ...);
 }
 impl Clone for Bar {
     fn clone(&self) -> Self { *self }
diff --git a/tests/headers/char.h b/tests/headers/char.h
new file mode 100644
index 00000000..ae38653e
--- /dev/null
+++ b/tests/headers/char.h
@@ -0,0 +1,19 @@
+typedef char Char;
+typedef signed char SChar;
+typedef unsigned char UChar;
+
+struct Test {
+  char ch;
+  unsigned char u;
+  signed char d;
+  const char cch;
+  const unsigned char cu;
+  const signed char cd;
+
+  Char Cch;
+  UChar Cu;
+  SChar Cd;
+  const Char Ccch;
+  const UChar Ccu;
+  const SChar Ccd;
+};
diff --git a/tests/tests.rs b/tests/tests.rs
index 84b5e076..bb965bd7 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -156,7 +156,7 @@ fn test_header_contents() {
     assert_eq!(bindings, "/* automatically generated by rust-bindgen */
 
 extern \"C\" {
-    pub fn foo(a: *const ::std::os::raw::c_schar) -> ::std::os::raw::c_int;
+    pub fn foo(a: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
 }
 ");
 }