1
- //! Platform-specific types, as defined by C.
2
- //!
3
- //! Code that interacts via FFI will almost certainly be using the
4
- //! base types provided by C, which aren't nearly as nicely defined
5
- //! as Rust's primitive types. This module provides types which will
1
+ //! This module provides primitive types which will
6
2
//! match those defined by C, so that code that interacts with C will
7
3
//! refer to the correct types.
8
4
//!
9
- //! Contains only the primitive types, mod.rs contains additional types
10
-
11
- #![ stable( feature = "core_ffi" , since = "1.30.0" ) ]
5
+ //! primitives.rs only contains type definitions for consistent external parsing
12
6
13
7
type_alias ! { "c_char.md" , c_char = c_char_definition:: c_char; #[ doc( cfg( all( ) ) ) ] }
14
8
@@ -29,6 +23,112 @@ type_alias! { "c_ulonglong.md", c_ulonglong = u64; }
29
23
type_alias ! { "c_float.md" , c_float = f32 ; }
30
24
type_alias ! { "c_double.md" , c_double = f64 ; }
31
25
26
+ mod c_char_definition {
27
+ cfg_if ! {
28
+ // These are the targets on which c_char is unsigned. Usually the
29
+ // signedness is the same for all target_os values on a given architecture
30
+ // but there are some exceptions (see isSignedCharDefault() in clang).
31
+ //
32
+ // aarch64:
33
+ // Section 10 "Arm C and C++ language mappings" in Procedure Call Standard for the Arm®
34
+ // 64-bit Architecture (AArch64) says C/C++ char is unsigned byte.
35
+ // https://github.com/ARM-software/abi-aa/blob/2024Q3/aapcs64/aapcs64.rst#arm-c-and-c-language-mappings
36
+ // arm:
37
+ // Section 8 "Arm C and C++ Language Mappings" in Procedure Call Standard for the Arm®
38
+ // Architecture says C/C++ char is unsigned byte.
39
+ // https://github.com/ARM-software/abi-aa/blob/2024Q3/aapcs32/aapcs32.rst#arm-c-and-c-language-mappings
40
+ // csky:
41
+ // Section 2.1.2 "Primary Data Type" in C-SKY V2 CPU Applications Binary Interface
42
+ // Standards Manual says ANSI C char is unsigned byte.
43
+ // https://github.com/c-sky/csky-doc/blob/9f7121f7d40970ba5cc0f15716da033db2bb9d07/C-SKY_V2_CPU_Applications_Binary_Interface_Standards_Manual.pdf
44
+ // Note: this doesn't seem to match Clang's default (https://github.com/rust-lang/rust/issues/129945).
45
+ // hexagon:
46
+ // Section 3.1 "Basic data type" in Qualcomm Hexagon™ Application
47
+ // Binary Interface User Guide says "By default, the `char` data type is unsigned."
48
+ // https://docs.qualcomm.com/bundle/publicresource/80-N2040-23_REV_K_Qualcomm_Hexagon_Application_Binary_Interface_User_Guide.pdf
49
+ // msp430:
50
+ // Section 2.1 "Basic Types" in MSP430 Embedded Application Binary
51
+ // Interface says "The char type is unsigned by default".
52
+ // https://www.ti.com/lit/an/slaa534a/slaa534a.pdf
53
+ // powerpc/powerpc64:
54
+ // - PPC32 SysV: "Table 3-1 Scalar Types" in System V Application Binary Interface PowerPC
55
+ // Processor Supplement says ANSI C char is unsigned byte
56
+ // https://refspecs.linuxfoundation.org/elf/elfspec_ppc.pdf
57
+ // - PPC64 ELFv1: Section 3.1.4 "Fundamental Types" in 64-bit PowerPC ELF Application
58
+ // Binary Interface Supplement 1.9 says ANSI C is unsigned byte
59
+ // https://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi.html#FUND-TYPE
60
+ // - PPC64 ELFv2: Section 2.1.2.2 "Fundamental Types" in 64-Bit ELF V2 ABI Specification
61
+ // says char is unsigned byte
62
+ // https://openpowerfoundation.org/specifications/64bitelfabi/
63
+ // - AIX: XL C for AIX Language Reference says "By default, char behaves like an unsigned char."
64
+ // https://www.ibm.com/docs/en/xl-c-aix/13.1.3?topic=specifiers-character-types
65
+ // riscv32/riscv64:
66
+ // C/C++ type representations section in RISC-V Calling Conventions
67
+ // page in RISC-V ELF psABI Document says "char is unsigned."
68
+ // https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/draft-20240829-13bfa9f54634cb60d86b9b333e109f077805b4b3/riscv-cc.adoc#cc-type-representations
69
+ // s390x:
70
+ // - ELF: "Table 1.1.: Scalar types" in ELF Application Binary Interface s390x Supplement
71
+ // Version 1.6.1 categorize ISO C char in unsigned integer
72
+ // https://github.com/IBM/s390x-abi/releases/tag/v1.6.1
73
+ // - z/OS: XL C/C++ Language Reference says: "By default, char behaves like an unsigned char."
74
+ // https://www.ibm.com/docs/en/zos/3.1.0?topic=specifiers-character-types
75
+ // xtensa:
76
+ // Section 2.17.1 "Data Types and Alignment" of Xtensa LX Microprocessor Overview handbook
77
+ // says "`char` type is unsigned by default".
78
+ // https://loboris.eu/ESP32/Xtensa_lx%20Overview%20handbook.pdf
79
+ //
80
+ // On the following operating systems, c_char is signed by default, regardless of architecture.
81
+ // Darwin (macOS, iOS, etc.):
82
+ // Apple targets' c_char is signed by default even on arm
83
+ // https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms#Handle-data-types-and-data-alignment-properly
84
+ // Windows:
85
+ // Windows MSVC C++ Language Reference says "Microsoft-specific: Variables of type char
86
+ // are promoted to int as if from type signed char by default, unless the /J compilation
87
+ // option is used."
88
+ // https://learn.microsoft.com/en-us/cpp/cpp/fundamental-types-cpp?view=msvc-170#character-types
89
+ // L4Re:
90
+ // The kernel builds with -funsigned-char on all targets (but useserspace follows the
91
+ // architecture defaults). As we only have a target for userspace apps so there are no
92
+ // special cases for L4Re below.
93
+ // https://github.com/rust-lang/rust/pull/132975#issuecomment-2484645240
94
+ if #[ cfg( all(
95
+ not( windows) ,
96
+ not( target_vendor = "apple" ) ,
97
+ any(
98
+ target_arch = "aarch64" ,
99
+ target_arch = "arm" ,
100
+ target_arch = "csky" ,
101
+ target_arch = "hexagon" ,
102
+ target_arch = "msp430" ,
103
+ target_arch = "powerpc" ,
104
+ target_arch = "powerpc64" ,
105
+ target_arch = "riscv32" ,
106
+ target_arch = "riscv64" ,
107
+ target_arch = "s390x" ,
108
+ target_arch = "xtensa" ,
109
+ )
110
+ ) ) ] {
111
+ pub ( super ) type c_char = u8 ;
112
+ } else {
113
+ // On every other target, c_char is signed.
114
+ pub ( super ) type c_char = i8 ;
115
+ }
116
+ }
117
+ }
118
+
119
+ mod c_long_definition {
120
+ cfg_if ! {
121
+ if #[ cfg( all( target_pointer_width = "64" , not( windows) ) ) ] {
122
+ pub ( super ) type c_long = i64 ;
123
+ pub ( super ) type c_ulong = u64 ;
124
+ } else {
125
+ // The minimal size of `long` in the C standard is 32 bits
126
+ pub ( super ) type c_long = i32 ;
127
+ pub ( super ) type c_ulong = u32 ;
128
+ }
129
+ }
130
+ }
131
+
32
132
/// Equivalent to C's `size_t` type, from `stddef.h` (or `cstddef` for C++).
33
133
///
34
134
/// This type is currently always [`usize`], however in the future there may be
0 commit comments