version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "bitflags"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
[[package]]
name = "bootstrap"
version = "0.0.0"
"curl 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"docopt 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "error-chain 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"filetime 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"flate2 0.2.19 (registry+https://github.com/rust-lang/crates.io-index)",
"fs2 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "git2 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "git2 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
"git2-curl 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"hamcrest 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "jobserver 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
- "libgit2-sys 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libgit2-sys 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
"miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl 0.9.12 (registry+https://github.com/rust-lang/crates.io-index)",
"psapi-sys 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+ "scoped-tls 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"semver 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"cargo 0.20.0",
"filetime 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"flate2 0.2.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "git2 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "git2 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
"hamcrest 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.9.0"
dependencies = [
"curl 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "error-chain 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-[[package]]
-name = "either"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
[[package]]
name = "enum_primitive"
version = "0.1.1"
[[package]]
name = "git2"
-version = "0.6.5"
+version = "0.6.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
- "libgit2-sys 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libgit2-sys 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl-probe 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl-sys 0.9.12 (registry+https://github.com/rust-lang/crates.io-index)",
"url 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"curl 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "git2 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "git2 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
"url 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
]
[[package]]
-name = "itertools"
-version = "0.5.10"
+name = "itoa"
+version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "either 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
[[package]]
-name = "itoa"
-version = "0.3.1"
+name = "jobserver"
+version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
[[package]]
name = "kernel32-sys"
[[package]]
name = "libgit2-sys"
-version = "0.6.11"
+version = "0.6.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"cmake 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)",
"ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
-[[package]]
-name = "multimap"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
[[package]]
name = "net2"
version = "0.2.29"
"languageserver-types 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
"racer 2.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-analysis 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-data 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-analysis 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-data 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-vfs 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustfmt 0.8.4 (git+https://github.com/rust-lang-nursery/rustfmt)",
+ "rls-vfs 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustfmt 0.9.0 (git+https://github.com/rust-lang-nursery/rustfmt?branch=libsyntax)",
"serde 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "rls-analysis"
-version = "0.2.1"
+version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"derive-new 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-data 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-data 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
]
"rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
]
+[[package]]
+name = "rls-data"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
[[package]]
name = "rls-span"
version = "0.4.0"
[[package]]
name = "rls-vfs"
-version = "0.3.0"
+version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"racer 2.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "rustfmt"
-version = "0.8.4"
-source = "git+https://github.com/rust-lang-nursery/rustfmt#bf9b3fa1d7cab2f7bd541539d397a92b4954ec96"
+version = "0.9.0"
+source = "git+https://github.com/rust-lang-nursery/rustfmt?branch=libsyntax#6c1de7694782d9f710b2f00b1f650f266a99b384"
dependencies = [
"diff 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"getopts 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
- "itertools 0.5.10 (registry+https://github.com/rust-lang/crates.io-index)",
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "multimap 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "strings 0.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "syntex_errors 0.58.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "syntex_syntax 0.58.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "strings 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"term 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"toml 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-segmentation 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "walkdir 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
+[[package]]
+name = "scoped-tls"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
[[package]]
name = "semver"
version = "0.7.0"
[[package]]
name = "strings"
-version = "0.0.1"
+version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-xid 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
-[[package]]
-name = "syntex_errors"
-version = "0.58.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
- "syntex_pos 0.58.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "term 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
[[package]]
name = "syntex_pos"
version = "0.52.0"
"rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
]
-[[package]]
-name = "syntex_pos"
-version = "0.58.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
[[package]]
name = "syntex_syntax"
version = "0.52.0"
"unicode-xid 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
-[[package]]
-name = "syntex_syntax"
-version = "0.58.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bitflags 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
- "syntex_errors 0.58.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "syntex_pos 0.58.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
[[package]]
name = "tar"
version = "0.4.13"
"checksum bitflags 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4f67931368edf3a9a51d29886d245f1c3db2f1ef0dcc9e35ff70341b78c10d23"
"checksum bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d"
"checksum bitflags 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1370e9fc2a6ae53aea8b7a5110edbd08836ed87c88736dfabccade1c2b44bff4"
+"checksum bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4efd02e230a02e18f92fc2735f44597385ed02ad8f831e7c1c1156ee5e1ab3a5"
"checksum bufstream 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f382711e76b9de6c744cc00d0497baba02fb00a787f088c879f01d09468e32"
"checksum cargo 0.20.0 (git+https://github.com/rust-lang/cargo)" = "<none>"
"checksum cfg-if 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "de1e760d7b6535af4241fca8bd8adf68e2e7edacc6b29f5d399050c5e48cf88c"
"checksum diff 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0a515461b6c8c08419850ced27bc29e86166dcdcde8fbe76f8b1f0589bb49472"
"checksum docopt 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ab32ea6e284d87987066f21a9e809a73c14720571ef34516f0890b3d355ccfd8"
"checksum dtoa 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "80c8b71fd71146990a9742fc06dcbbde19161a267e0ad4e572c35162f4578c90"
-"checksum either 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "18785c1ba806c258137c937e44ada9ee7e69a37e3c72077542cd2f069d78562a"
"checksum enum_primitive 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "be4551092f4d519593039259a9ed8daedf0da12e5109c5280338073eaeb81180"
"checksum env_logger 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "15abd780e45b3ea4f76b4e9a26ff4843258dd8a3eed2775a0e7368c2e7936c2f"
"checksum env_logger 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e3856f1697098606fc6cb97a93de88ca3f3bc35bb878c725920e6e82ecf05e83"
"checksum gcc 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)" = "5f837c392f2ea61cb1576eac188653df828c861b7137d74ea4a5caa89621f9e6"
"checksum gdi32-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0912515a8ff24ba900422ecda800b52f4016a56251922d397c576bf92c690518"
"checksum getopts 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "d9047cfbd08a437050b363d35ef160452c5fe8ea5187ae0a624708c91581d685"
-"checksum git2 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "9de9df4358c17e448a778d90cd0272e1dab5eae30244502333fa2001c4e24357"
+"checksum git2 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "aa01936ac96555c083c0e8553f672616274408d9d3fc5b8696603fbf63ff43ee"
"checksum git2-curl 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "68676bc784bf0bef83278898929bf64a251e87c0340723d0b93fa096c9c5bf8e"
"checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
"checksum hamcrest 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bf088f042a467089e9baa4972f57f9247e42a0cc549ba264c7a04fbb8ecb89d4"
"checksum handlebars 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)" = "15bdf598fc3c2de40c6b340213028301c0d225eea55a2294e6cc148074e557a1"
"checksum idna 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6ac85ec3f80c8e4e99d9325521337e14ec7555c458a14e377d189659a427f375"
-"checksum itertools 0.5.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4833d6978da405305126af4ac88569b5d71ff758581ce5a987dbfa3755f694fc"
"checksum itoa 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "eb2f404fbc66fd9aac13e998248505e7ecb2ad8e44ab6388684c5fb11c6c251c"
+"checksum jobserver 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "c43fc6e4066b2adf0539c854daa1d926d7f23e6926e019850d34b8ae46391b2e"
"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
"checksum languageserver-types 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97c2985bfcbbcb0189cfa25e1c10c1ac7111df2b6214b652c690127aefdf4e5b"
"checksum lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3b37545ab726dd833ec6420aaba8231c5b320814b9029ad585555d2a03e94fbf"
"checksum libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)" = "babb8281da88cba992fa1f4ddec7d63ed96280a1a53ec9b919fd37b53d71e502"
-"checksum libgit2-sys 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d9dc31ee90fb179b706d35fb672e91d0b74e950d7fb4ea7eae3c0f5ecbf2d3d3"
+"checksum libgit2-sys 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "df18a822100352d9863b302faf6f8f25c0e77f0e60feb40e5dbe1238b7f13b1d"
"checksum libssh2-sys 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0db4ec23611747ef772db1c4d650f8bd762f07b461727ec998f953c614024b75"
"checksum libz-sys 1.0.13 (registry+https://github.com/rust-lang/crates.io-index)" = "e5ee912a45d686d393d5ac87fac15ba0ba18daae14e8e7543c63ebf7fb7e970c"
"checksum log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "5141eca02775a762cc6cd564d8d2c50f67c0ea3a372cbf1c51592b3e029e10ad"
"checksum memchr 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1dbccc0e46f1ea47b9f17e6d67c5a96bd27030519c519c9c91327e31275a47b4"
"checksum miniz-sys 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "28eaee17666671fa872e567547e8428e83308ebe5808cdf6a0e28397dbe2c726"
"checksum miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
-"checksum multimap 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9223f4774d08e06185e44e555b9a7561243d387bac49c78a6205c42d6975fbf2"
"checksum net2 0.2.29 (registry+https://github.com/rust-lang/crates.io-index)" = "bc01404e7568680f1259aa5729539f221cb1e6d047a0d9053cab4be8a73b5d67"
"checksum num 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)" = "98b15ba84e910ea7a1973bccd3df7b31ae282bf9d8bd2897779950c9b8303d40"
"checksum num-bigint 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)" = "ba6d838b16e56da1b6c383d065ff1ec3c7d7797f65a3e8f6ba7092fd87820bac"
"checksum regex 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4278c17d0f6d62dfef0ab00028feb45bd7d2102843f80763474eeb1be8a10c01"
"checksum regex-syntax 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "f9ec002c35e86791825ed294b50008eea9ddfc8def4420124fbc6b08db834957"
"checksum regex-syntax 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9191b1f57603095f105d317e375d19b1c9c5c3185ea9633a99a6dcbed04457"
-"checksum rls-analysis 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a62d88c341375c6f3f8b2e18b9b364896e7d3e7aa916907de717d0267e116506"
+"checksum rls-analysis 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "8d77d58e8933752142b5b92e3f8ba6d6f1630be6da5627c492268a43f79ffbda"
"checksum rls-data 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fc4277ce3c57f456b11fe3145b181a844a25201bab5cbaa1978457e6e2f27d47"
+"checksum rls-data 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "374a8fad31cc0681a7bfd8a04079dd4afd0e981d34e18a171b1a467445bdf51e"
"checksum rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5d7c7046dc6a92f2ae02ed302746db4382e75131b9ce20ce967259f6b5867a6a"
-"checksum rls-vfs 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "986eada111517bcb5a7a75205b3f2b70c82e7766653cca61a23f5afce79bdb94"
+"checksum rls-vfs 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ace07060dd154731b39254864245cbdd33c8f5f64fe1f630a089c72e2468f854"
"checksum rustc-demangle 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "3058a43ada2c2d0b92b3ae38007a2d0fa5e9db971be260e0171408a4ff471c95"
"checksum rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)" = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
-"checksum rustfmt 0.8.4 (git+https://github.com/rust-lang-nursery/rustfmt)" = "<none>"
+"checksum rustfmt 0.9.0 (git+https://github.com/rust-lang-nursery/rustfmt?branch=libsyntax)" = "<none>"
"checksum same-file 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d931a44fdaa43b8637009e7632a02adc4f2b2e0733c08caa4cf00e8da4a117a7"
+"checksum scoped-tls 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f417c22df063e9450888a7561788e9bd46d3bb3c1466435b4eccb903807f147d"
"checksum semver 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3fdd61b85a0fa777f7fb7c454b9189b2941b110d1385ce84d7f76efdf1606a85"
"checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
"checksum serde 0.9.15 (registry+https://github.com/rust-lang/crates.io-index)" = "34b623917345a631dc9608d5194cc206b3fe6c3554cd1c75b937e55e285254af"
"checksum serde_json 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "48b04779552e92037212c3615370f6bd57a40ebba7f20e554ff9f55e41a69a7b"
"checksum shell-escape 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "dd5cc96481d54583947bfe88bf30c23d53f883c6cd0145368b69989d97b84ef8"
"checksum stable_deref_trait 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "15132e0e364248108c5e2c02e3ab539be8d6f5d52a01ca9bbf27ed657316f02b"
-"checksum strings 0.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "54f86446ab480b4f60782188f4f78886465c5793aee248cbb48b7fdc0d022420"
+"checksum strings 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "da75d8bf2c4d210d63dd09581a041b036001f9f6e03d9b151dbff810fb7ba26a"
"checksum strsim 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "67f84c44fbb2f91db7fef94554e6b2ac05909c9c0b0bc23bb98d3a1aebfe7f7c"
"checksum strsim 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b4d15c810519a91cf877e7e36e63fe068815c678181439f2f29e2562147c3694"
"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
"checksum syn 0.8.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6ae6fb0dcc9bd85f89a1a4adc0df2fd90c90c98849d61433983dd7a9df6363f7"
"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
"checksum syntex_errors 0.52.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9e52bffe6202cfb67587784cf23e0ec5bf26d331eef4922a16d5c42e12aa1e9b"
-"checksum syntex_errors 0.58.1 (registry+https://github.com/rust-lang/crates.io-index)" = "867cc5c2d7140ae7eaad2ae9e8bf39cb18a67ca651b7834f88d46ca98faadb9c"
"checksum syntex_pos 0.52.0 (registry+https://github.com/rust-lang/crates.io-index)" = "955ef4b16af4c468e4680d1497f873ff288f557d338180649e18f915af5e15ac"
-"checksum syntex_pos 0.58.1 (registry+https://github.com/rust-lang/crates.io-index)" = "13ad4762fe52abc9f4008e85c4fb1b1fe3aa91ccb99ff4826a439c7c598e1047"
"checksum syntex_syntax 0.52.0 (registry+https://github.com/rust-lang/crates.io-index)" = "76a302e717e348aa372ff577791c3832395650073b8d8432f8b3cb170b34afde"
-"checksum syntex_syntax 0.58.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6e0e4dbae163dd98989464c23dd503161b338790640e11537686f2ef0f25c791"
"checksum tar 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)" = "281285b717926caa919ad905ef89c63d75805c7d89437fb873100925a53f2b1b"
"checksum tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "87974a6f5c1dfb344d733055601650059a3363de2a6104819293baff662132d6"
"checksum term 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d168af3930b369cfe245132550579d47dfd873d69470755a19c2c6568dbbd989"
use std::collections::HashSet;
use std::env;
use std::fmt;
-use std::fs;
+use std::fs::{self, File};
use std::path::{PathBuf, Path};
use std::process::Command;
+use std::io::Read;
use build_helper::output;
while let Some(p) = stack.pop() {
if p.is_dir() {
- stack.extend(t!(p.read_dir()).map(|p| t!(p).path()));
+ stack.extend(t!(p.read_dir()).map(|p| t!(p).path()).filter(|p| {
+ p.extension().and_then(|s| s.to_str()) == Some("md") &&
+ // The nostarch directory in the book is for no starch, and so isn't guaranteed to
+ // build. We don't care if it doesn't build, so skip it.
+ p.to_str().map_or(true, |p| !p.contains("nostarch"))
+ }));
continue
}
- if p.extension().and_then(|s| s.to_str()) != Some("md") {
- continue
- }
-
- // The nostarch directory in the book is for no starch, and so isn't guaranteed to build.
- // we don't care if it doesn't build, so skip it.
- use std::ffi::OsStr;
- let path: &OsStr = p.as_ref();
- if let Some(path) = path.to_str() {
- if path.contains("nostarch") {
- continue;
- }
- }
-
- println!("doc tests for: {}", p.display());
markdown_test(build, compiler, &p);
}
}
}
fn markdown_test(build: &Build, compiler: &Compiler, markdown: &Path) {
+ let mut file = t!(File::open(markdown));
+ let mut contents = String::new();
+ t!(file.read_to_string(&mut contents));
+ if !contents.contains("```") {
+ return;
+ }
+
+ println!("doc tests for: {}", markdown.display());
let mut cmd = Command::new(build.rustdoc(compiler));
build.add_rustc_lib_path(compiler, &mut cmd);
build.add_rust_test_threads(&mut cmd);
if build.is_rust_llvm(target) {
cargo.env("LLVM_RUSTLLVM", "1");
}
+ if let Some(ref cfg_file) = build.flags.config {
+ let cfg_path = t!(PathBuf::from(cfg_file).canonicalize());
+ cargo.env("CFG_LLVM_TOML", cfg_path.into_os_string());
+ }
cargo.env("LLVM_CONFIG", build.llvm_config(target));
let target_config = build.config.target_config.get(target);
if let Some(s) = target_config.and_then(|c| c.llvm_config.as_ref()) {
./x.py build
./x.py build --stage 1
- For a quick build with a usable compile, you can pass:
+ For a quick build of a usable compiler, you can pass:
- ./x.py build --stage 1 src/libtest");
+ ./x.py build --stage 1 src/libtest
+
+ This will first build everything once (like --stage 0 without further
+ arguments would), and then use the compiler built in stage 0 to build
+ src/libtest and its dependencies.
+ Once this is done, build/$ARCH/stage1 contains a usable compiler.");
}
"test" => {
subcommand_help.push_str("\n
--- /dev/null
+# The Rustdoc Book
+
+- [What is rustdoc?](what-is-rustdoc.md)
+- [Command-line arguments](command-line-arguments.md)
+- [In-source directives](in-source-directives.md)
+- [Documentation tests](documentation-tests.md)
+- [Plugins](plugins.md)
+- [Passes](passes.md)
\ No newline at end of file
--- /dev/null
+# Command-line arguments
+
+Here's the list of arguments you can pass to `rustdoc`:
+
+## `-h`/`--help`: help
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc -h
+$ rustdoc --help
+```
+
+This will show `rustdoc`'s built-in help, which largely consists of
+a list of possible command-line flags.
+
+Some of `rustdoc`'s flags are unstable; this page only shows stable
+options, `--help` will show them all.
+
+## `-V`/`--version`: version information
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc -V
+$ rustdoc --version
+```
+
+This will show `rustdoc`'s version, which will look something
+like this:
+
+```text
+rustdoc 1.17.0 (56124baa9 2017-04-24)
+```
+
+## `-v`/`--verbose`: more verbose output
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc -v src/lib.rs
+$ rustdoc --verbose src/lib.rs
+```
+
+This enables "verbose mode", which means that more information will be written
+to standard out. What is written depends on the other flags you've passed in.
+For example, with `--version`:
+
+```text
+$ rustdoc --verbose --version
+rustdoc 1.17.0 (56124baa9 2017-04-24)
+binary: rustdoc
+commit-hash: hash
+commit-date: date
+host: host-triple
+release: 1.17.0
+LLVM version: 3.9
+```
+
+## `-r`/`--input-format`: input format
+
+This flag is currently ignored; the idea is that `rustdoc` would support various
+input formats, and you could specify them via this flag.
+
+Rustdoc only supports Rust source code and Markdown input formats. If the
+file ends in `.md` or `.markdown`, `rustdoc` treats it as a Markdown file.
+Otherwise, it assumes that the input file is Rust.
+
+
+## `-w`/`--output-format`: output format
+
+This flag is currently ignored; the idea is that `rustdoc` would support
+various output formats, and you could specify them via this flag.
+
+Rustdoc only supports HTML output, and so this flag is redundant today.
+
+## `-o`/`--output`: output path
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs -o target\\doc
+$ rustdoc src/lib.rs --output target\\doc
+```
+
+By default, `rustdoc`'s output appears in a directory named `doc` in
+the current working directory. With this flag, it will place all output
+into the directory you specify.
+
+
+## `--crate-name`: controlling the name of the crate
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --crate-name mycrate
+```
+
+By default, `rustodc` assumes that the name of your crate is the same name
+as the `.rs` file. `--crate-name` lets you override this assumption with
+whatever name you choose.
+
+## `-L`/`--library-path`:
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs -L target/debug/deps
+$ rustdoc src/lib.rs --library-path target/debug/deps
+```
+
+If your crate has dependencies, `rustdoc` needs to know where to find them.
+Passing `--library-path` gives `rustdoc` a list of places to look for these
+dependencies.
+
+This flag takes any number of directories as its argument, and will use all of
+them when searching.
+
+
+## `--cfg`: passing configuration flags
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --cfg feature="foo"
+```
+
+This flag accepts the same values as `rustc --cfg`, and uses it to configure
+compilation. The example above uses `feature`, but any of the `cfg` values
+are acceptable.
+
+## `--extern`: specify a dependency's location
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --extern lazy-static=/path/to/lazy-static
+```
+
+Similar to `--library-path`, `--extern` is about specifying the location
+of a dependency. `--library-path` provides directories to search in, `--extern`
+instead lets you specify exactly which dependency is located where.
+
+
+## `--plugin-path`: loading plugins
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --plugin-path=/path/to/plugins
+```
+
+Similar to `--library-path`, but for plugins. For more, see
+the [chapter on plugins](plugins.html).
+
+See also: `--plugins`.
+
+## `--passes`: add more rustdoc passes
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc --passes list
+$ rustdoc src/lib.rs --passes strip-priv-imports
+```
+
+An argument of "list" will print a list of possible "rustdoc passes", and other
+arguments will be the name of which passes to run in addition to the defaults.
+
+For more details on passes, see [the chapter on them](passes.html).
+
+See also `--no-defaults`.
+
+## `--plugins`:
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --plugins foo bar
+```
+
+For more, see the [chapter on plugins](plugins.html).
+
+See also: `--plugin-path`.
+
+## `--no-defaults`: don't run default passes
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --no-defaults
+```
+
+By default, `rustdoc` will run several passes over your code. This
+removes those defaults, allowing you to use `--passes` to specify
+exactly which passes you want.
+
+For more details on passes, see [the chapter on them](passes.html).
+
+See also `--passes`.
+
+## `--test`: run code examples as tests
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --test
+```
+
+This flag will run your code examples as tests. For more, see [the chapter
+on documentation tests](documentation-tests.html).
+
+See also `--test-args`.
+
+## `--test-args`:
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --test --test-args ignored
+```
+
+This flag will pass options to the test runner when running documentation tests.
+For more, see [the chapter on documentation tests](documentation-tests.html).
+
+See also `--test`.
+
+## `--target`:
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --target x86_64-pc-windows-gnu
+```
+
+Similar to the `--target` flag for `rustc`, this generates documentation
+for a target triple that's different than your host triple.
+
+All of the usual caveats of cross-compiling code apply.
+
+## `--markdown-css`: include more CSS files when rendering markdown
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc README.md --markdown-css foo.css
+```
+
+When rendering Markdown files, this will create a `<link>` element in the
+`<head>` section of the generated HTML. For example, with the invocation above,
+
+```html
+<link rel="stylesheet" type="text/css" href="foo.css">
+```
+
+will be added.
+
+When rendering Rust files, this flag is ignored.
+
+## `--html-in-header`: include more HTML in <head>
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --html-in-header header.html
+$ rustdoc README.md --html-in-header header.html
+```
+
+This flag takes a list of files, and inserts them into the `<head>` section of
+the rendered documentation.
+
+## `--html-before-content`: include more HTML before the content
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --html-before-content extra.html
+$ rustdoc README.md --html-before-content extra.html
+```
+
+This flag takes a list of files, and inserts them inside the `<body>` tag but
+before the other content `rustodc` would normally produce in the rendered
+documentation.
+
+## `--html-after-content`: include more HTML after the content
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --html-after-content extra.html
+$ rustdoc README.md --html-after-content extra.html
+```
+
+This flag takes a list of files, and inserts them before the `</body>` tag but
+after the other content `rustodc` would normally produce in the rendered
+documentation.
+
+
+## `--markdown-playground-url`: control the location of the playground
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc README.md --markdown-playground-url https://play.rust-lang.org/
+```
+
+When rendering a Markdown file, this flag gives the base URL of the Rust
+Playround, to use for generating `Run` buttons.
+
+
+## `--markdown-no-toc`: don't generate a table of contents
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc README.md --markdown-no-toc
+```
+
+When generating documentation from a Markdown file, by default, `rustdoc` will
+generate a table of contents. This flag supresses that, and no TOC will be
+generated.
+
+
+## `-e`/`--extend-css`: extend rustdoc's CSS
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs -e extra.css
+$ rustdoc src/lib.rs --extend-css extra.css
+```
+
+With this flag, the contents of the files you pass are included at the bottom
+of Rustdoc's `theme.css` file.
+
+While this flag is stable, the contents of `theme.css` are not, so be careful!
+Updates may break your theme extensions.
+
+## `--sysroot`: override the system root
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs --sysroot /path/to/sysroot
+```
+
+Similar to `rustc --sysroot`, this lets you change the sysroot `rustdoc` uses
+when compiling your code.
\ No newline at end of file
--- /dev/null
+# Documentation tests
+
+Coming soon!
\ No newline at end of file
--- /dev/null
+# In-source directives
+
+Coming soon!
\ No newline at end of file
--- /dev/null
+# Passes
+
+Coming soon!
\ No newline at end of file
--- /dev/null
+# Plugins
+
+Coming soon!
\ No newline at end of file
--- /dev/null
+# What is rustdoc?
+
+The standard Rust distribution ships with a tool called `rustdoc`. Its job is
+to generate documentation for Rust projects. On a fundamental level, Rustdoc
+takes as an argument either a crate root or a Markdown file, and produces HTML,
+CSS, and JavaScript.
+
+## Basic usage
+
+Let's give it a try! Let's create a new project with Cargo:
+
+```bash
+$ cargo new docs
+$ cd docs
+```
+
+In `src/lib.rs`, you'll find that Cargo has generated some sample code. Delete
+it and replace it with this:
+
+```rust
+/// foo is a function
+fn foo() {}
+```
+
+Let's run `rustdoc` on our code. To do so, we can call it with the path to
+our crate root like this:
+
+```bash
+$ rustdoc src/lib.rs
+```
+
+This will create a new directory, `doc`, with a website inside! In our case,
+the main page is located in `doc/lib/index.html`. If you open that up in
+a web browser, you'll see a page with a search bar, and "Crate lib" at the
+top, with no contents. There's two problems with this: first, why does it
+think that our package is named "lib"? Second, why does it not have any
+contents?
+
+The first problem is due to `rustdoc` trying to be helpful; like `rustc`,
+it assumes that our crate's name is the name of the file for the crate
+root. To fix this, we can pass in a command-line flag:
+
+```bash
+$ rustdoc src/lib.rs --crate-name docs
+```
+
+Now, `doc/docs/index.html` will be generated, and the page says "Crate docs."
+
+For the second issue, it's because our function `foo` is not public; `rustdoc`
+defaults to generating documentation for only public functions. If we change
+our code...
+
+```rust
+/// foo is a function
+pub fn foo() {}
+```
+
+... and then re-run `rustdoc`:
+
+```bash
+$ rustdoc src/lib.rs --crate-name docs
+```
+
+We'll have some generated documentation. Open up `doc/docs/index.html` and
+check it out! It should show a link to the `foo` function's page, which
+is located at `doc/docs/fn.foo.html`. On that page, you'll see the "foo is
+a function" we put inside the documentation comment in our crate.
+
+## Using rustdoc with Cargo
+
+Cargo also has integration with `rustdoc` to make it easier to generate
+docs. Instead of the `rustdoc` command, we could have done this:
+
+```bash
+$ cargo doc
+```
+
+Internally, this calls out to `rustdoc` like this:
+
+```bash
+$ rustdoc --crate-name docs srclib.rs -o <path>\docs\target\doc -L
+dependency=<path>docs\target\debug\deps
+```
+
+You can see this with `cargo doc --verbose`.
+
+It generates the correct `--crate-name` for us, as well as pointing to
+`src/lib.rs` But what about those other arguments? `-o` controls the
+*o*utput of our docs. Instead of a top-level `doc` directory, you'll
+notice that Cargo puts generated documentation under `target`. That's
+the idiomatic place for generated files in Cargo projects. Also, it
+passes `-L`, a flag that helps rustdoc find the dependencies
+your code relies on. If our project used dependencies, we'd get
+documentation for them as well!
+
+## Using standalone Markdown files
+
+`rustdoc` can also generate HTML from standalone Markdown files. Let's
+give it a try: create a `README.md` file with these contents:
+
+```text
+ # Docs
+
+ This is a project to test out `rustdoc`.
+
+ [Here is a link!](https://www.rust-lang.org)
+
+ ## Subheading
+
+ ```rust
+ fn foo() -> i32 {
+ 1 + 1
+ }
+ ```
+```
+
+And call `rustdoc` on it:
+
+```bash
+$ rustdoc README.md
+```
+
+You'll find an HTML file in `docs/doc/README.html` generated from its
+Markdown contents.
+
+Cargo currently does not understand standalone Markdown files, unfortunately.
+
+## Summary
+
+This covers the simplest use-cases of `rustdoc`. The rest of this book will
+explain all of the options that `rustdoc` has, and how to use them.
\ No newline at end of file
{
"platform": "arm_v",
"intrinsic_prefix": "",
- "llvm_prefix": "llvm.neon.v",
+ "llvm_prefix": "llvm.arm.neon.v",
"number_info": {
"signed": {
"kind": "s",
/// Creates an iterator starting at the same point, but stepping by
/// the given amount at each iteration.
///
- /// Note that it will always return the first element of the range,
+ /// Note that it will always return the first element of the iterator,
/// regardless of the step given.
///
/// # Panics
/// This will invoke the [`panic!`] macro if the provided expression cannot be
/// evaluated to `true` at runtime.
///
+/// # Uses
+///
/// Assertions are always checked in both debug and release builds, and cannot
/// be disabled. See [`debug_assert!`] for assertions that are not enabled in
/// release builds by default.
/// Other use-cases of `assert!` include [testing] and enforcing run-time
/// invariants in safe code (whose violation cannot result in unsafety).
///
-/// This macro has a second version, where a custom panic message can
+/// # Custom Messages
+///
+/// This macro has a second form, where a custom panic message can
/// be provided with or without arguments for formatting.
///
/// [`panic!`]: macro.panic.html
);
}
-/// Asserts that two expressions are equal to each other.
+/// Asserts that two expressions are equal to each other (using [`PartialEq`]).
///
/// On panic, this macro will print the values of the expressions with their
/// debug representations.
///
-/// Like [`assert!`], this macro has a second version, where a custom
+/// Like [`assert!`], this macro has a second form, where a custom
/// panic message can be provided.
///
+/// [`PartialEq`]: cmp/trait.PartialEq.html
/// [`assert!`]: macro.assert.html
///
/// # Examples
});
}
-/// Asserts that two expressions are not equal to each other.
+/// Asserts that two expressions are not equal to each other (using [`PartialEq`]).
///
/// On panic, this macro will print the values of the expressions with their
/// debug representations.
///
-/// Like `assert!()`, this macro has a second version, where a custom
+/// Like [`assert!`], this macro has a second form, where a custom
/// panic message can be provided.
///
+/// [`PartialEq`]: cmp/trait.PartialEq.html
/// [`assert!`]: macro.assert.html
///
/// # Examples
/// Like [`assert!`], this macro also has a second version, where a custom panic
/// message can be provided.
///
+/// # Uses
+///
/// Unlike [`assert!`], `debug_assert!` statements are only enabled in non
/// optimized builds by default. An optimized build will omit all
/// `debug_assert!` statements unless `-C debug-assertions` is passed to the
/// but not `Copy`.
///
/// [`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must also implement
-/// [`Clone`]. If a type is `Copy` then its [`Clone`] implementation need only return `*self`
+/// [`Clone`]. If a type is `Copy` then its [`Clone`] implementation only needs to return `*self`
/// (see the example above).
///
/// ## When can my type be `Copy`?
use convert::TryFrom;
use fmt;
use intrinsics;
-use mem::size_of;
use str::FromStr;
/// Provides intentionally-wrapped arithmetic on `T`.
(self.wrapping_sub(1)) & self == 0 && !(self == 0)
}
+ // Returns one less than next power of two.
+ // (For 8u8 next power of two is 8u8 and for 6u8 it is 8u8)
+ //
+ // 8u8.one_less_than_next_power_of_two() == 7
+ // 6u8.one_less_than_next_power_of_two() == 7
+ //
+ // This method cannot overflow, as in the `next_power_of_two`
+ // overflow cases it instead ends up returning the maximum value
+ // of the type, and can return 0 for 0.
+ fn one_less_than_next_power_of_two(self) -> Self {
+ if self <= 1 { return 0; }
+
+ // Because `p > 0`, it cannot consist entirely of leading zeros.
+ // That means the shift is always in-bounds, and some processors
+ // (such as intel pre-haswell) have more efficient ctlz
+ // intrinsics when the argument is non-zero.
+ let p = self - 1;
+ let z = p.leading_zeros();
+ <$SelfT>::max_value() >> z
+ }
+
/// Returns the smallest power of two greater than or equal to `self`.
- /// Unspecified behavior on overflow.
+ ///
+ /// When return value overflows (i.e. `self > (1 << (N-1))` for type
+ /// `uN`), it panics in debug mode and return value is wrapped to 0 in
+ /// release mode (the only situation in which method can return 0).
///
/// # Examples
///
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn next_power_of_two(self) -> Self {
- let bits = size_of::<Self>() * 8;
- let one: Self = 1;
- one << ((bits - self.wrapping_sub(one).leading_zeros() as usize) % bits)
+ self.one_less_than_next_power_of_two() + 1
}
/// Returns the smallest power of two greater than or equal to `n`. If
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn checked_next_power_of_two(self) -> Option<Self> {
- let npot = self.next_power_of_two();
- if npot >= self {
- Some(npot)
- } else {
- None
- }
+ self.one_less_than_next_power_of_two().checked_add(1)
}
}
}
pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(target_os = "ios", target_arch = "arm"));
-pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext) -> EHAction {
+pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext)
+ -> Result<EHAction, ()>
+{
if lsda.is_null() {
- return EHAction::None;
+ return Ok(EHAction::None)
}
let func_start = context.func_start;
let start_encoding = reader.read::<u8>();
// base address for landing pad offsets
let lpad_base = if start_encoding != DW_EH_PE_omit {
- read_encoded_pointer(&mut reader, context, start_encoding)
+ read_encoded_pointer(&mut reader, context, start_encoding)?
} else {
func_start
};
if !USING_SJLJ_EXCEPTIONS {
while reader.ptr < action_table {
- let cs_start = read_encoded_pointer(&mut reader, context, call_site_encoding);
- let cs_len = read_encoded_pointer(&mut reader, context, call_site_encoding);
- let cs_lpad = read_encoded_pointer(&mut reader, context, call_site_encoding);
+ let cs_start = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
+ let cs_len = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
+ let cs_lpad = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
let cs_action = reader.read_uleb128();
// Callsite table is sorted by cs_start, so if we've passed the ip, we
// may stop searching.
}
if ip < func_start + cs_start + cs_len {
if cs_lpad == 0 {
- return EHAction::None;
+ return Ok(EHAction::None)
} else {
let lpad = lpad_base + cs_lpad;
- return interpret_cs_action(cs_action, lpad);
+ return Ok(interpret_cs_action(cs_action, lpad))
}
}
}
// Ip is not present in the table. This should not happen... but it does: issue #35011.
// So rather than returning EHAction::Terminate, we do this.
- EHAction::None
+ Ok(EHAction::None)
} else {
// SjLj version:
// The "IP" is an index into the call-site table, with two exceptions:
// -1 means 'no-action', and 0 means 'terminate'.
match ip as isize {
- -1 => return EHAction::None,
- 0 => return EHAction::Terminate,
+ -1 => return Ok(EHAction::None),
+ 0 => return Ok(EHAction::Terminate),
_ => (),
}
let mut idx = ip;
// Can never have null landing pad for sjlj -- that would have
// been indicated by a -1 call site index.
let lpad = (cs_lpad + 1) as usize;
- return interpret_cs_action(cs_action, lpad);
+ return Ok(interpret_cs_action(cs_action, lpad))
}
}
}
}
#[inline]
-fn round_up(unrounded: usize, align: usize) -> usize {
- assert!(align.is_power_of_two());
- (unrounded + align - 1) & !(align - 1)
+fn round_up(unrounded: usize, align: usize) -> Result<usize, ()> {
+ if align.is_power_of_two() {
+ Ok((unrounded + align - 1) & !(align - 1))
+ } else {
+ Err(())
+ }
}
unsafe fn read_encoded_pointer(reader: &mut DwarfReader,
context: &EHContext,
encoding: u8)
- -> usize {
- assert!(encoding != DW_EH_PE_omit);
+ -> Result<usize, ()> {
+ if encoding == DW_EH_PE_omit {
+ return Err(())
+ }
// DW_EH_PE_aligned implies it's an absolute pointer value
if encoding == DW_EH_PE_aligned {
- reader.ptr = round_up(reader.ptr as usize, mem::size_of::<usize>()) as *const u8;
- return reader.read::<usize>();
+ reader.ptr = round_up(reader.ptr as usize, mem::size_of::<usize>())? as *const u8;
+ return Ok(reader.read::<usize>())
}
let mut result = match encoding & 0x0F {
DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
DW_EH_PE_sdata8 => reader.read::<i64>() as usize,
- _ => panic!(),
+ _ => return Err(()),
};
result += match encoding & 0x70 {
// relative to address of the encoded value, despite the name
DW_EH_PE_pcrel => reader.ptr as usize,
DW_EH_PE_funcrel => {
- assert!(context.func_start != 0);
+ if context.func_start == 0 {
+ return Err(())
+ }
context.func_start
}
DW_EH_PE_textrel => (*context.get_text_start)(),
DW_EH_PE_datarel => (*context.get_data_start)(),
- _ => panic!(),
+ _ => return Err(()),
};
if encoding & DW_EH_PE_indirect != 0 {
result = *(result as *const usize);
}
- result
+ Ok(result)
}
if version != 1 {
return uw::_URC_FATAL_PHASE1_ERROR;
}
- let eh_action = find_eh_action(context);
+ let eh_action = match find_eh_action(context) {
+ Ok(action) => action,
+ Err(_) => return uw::_URC_FATAL_PHASE1_ERROR,
+ };
if actions as i32 & uw::_UA_SEARCH_PHASE as i32 != 0 {
match eh_action {
EHAction::None |
// _Unwind_Context in our libunwind bindings and fetch the required data from there directly,
// bypassing DWARF compatibility functions.
- let eh_action = find_eh_action(context);
+ let eh_action = match find_eh_action(context) {
+ Ok(action) => action,
+ Err(_) => return uw::_URC_FAILURE,
+ };
if search_phase {
match eh_action {
EHAction::None |
}
}
-unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) -> EHAction {
+unsafe fn find_eh_action(context: *mut uw::_Unwind_Context)
+ -> Result<EHAction, ()>
+{
let lsda = uw::_Unwind_GetLanguageSpecificData(context) as *const u8;
let mut ip_before_instr: c_int = 0;
let ip = uw::_Unwind_GetIPInfo(context, &mut ip_before_instr);
get_data_start: &|| unimplemented!(),
};
match find_eh_action(dc.HandlerData, &eh_ctx) {
- EHAction::None => None,
- EHAction::Cleanup(lpad) |
- EHAction::Catch(lpad) => Some(lpad),
- EHAction::Terminate => intrinsics::abort(),
+ Err(_) |
+ Ok(EHAction::None) => None,
+ Ok(EHAction::Cleanup(lpad)) |
+ Ok(EHAction::Catch(lpad)) => Some(lpad),
+ Ok(EHAction::Terminate) => intrinsics::abort(),
}
}
started: https://doc.rust-lang.org/book/
"##,
+E0602: r##"
+An unknown lint was used on the command line.
+
+Erroneous example:
+
+```ignore
+rustc -D bogus omse_file.rs
+```
+
+Maybe you just misspelled the lint name or the lint doesn't exist anymore.
+Either way, try to update/remove it in order to fix the error.
+"##,
+
}
#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum CtorKind {
- // Constructor function automatically created by a tuple struct/variant.
+ /// Constructor function automatically created by a tuple struct/variant.
Fn,
- // Constructor constant automatically created by a unit struct/variant.
+ /// Constructor constant automatically created by a unit struct/variant.
Const,
- // Unusable name in value namespace created by a struct variant.
+ /// Unusable name in value namespace created by a struct variant.
Fictive,
}
}
}
-// Definition mapping
+/// Definition mapping
pub type DefMap = NodeMap<PathResolution>;
-// This is the replacement export map. It maps a module to all of the exports
-// within.
+
+/// This is the replacement export map. It maps a module to all of the exports
+/// within.
pub type ExportMap = NodeMap<Vec<Export>>;
#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)]
pub struct Export {
- pub ident: ast::Ident, // The name of the target.
- pub def: Def, // The definition of the target.
- pub span: Span, // The span of the target definition.
+ /// The name of the target.
+ pub ident: ast::Ident,
+ /// The definition of the target.
+ pub def: Def,
+ /// The span of the target definition.
+ pub span: Span,
}
impl CtorKind {
}
}
+ /// A human readable kind name
pub fn kind_name(&self) -> &'static str {
match *self {
Def::Fn(..) => "function",
impl DefId {
+ /// Make a local `DefId` with the given index.
pub fn local(index: DefIndex) -> DefId {
DefId { krate: LOCAL_CRATE, index: index }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Lowers the AST to the HIR.
-//
-// Since the AST and HIR are fairly similar, this is mostly a simple procedure,
-// much like a fold. Where lowering involves a bit more work things get more
-// interesting and there are some invariants you should know about. These mostly
-// concern spans and ids.
-//
-// Spans are assigned to AST nodes during parsing and then are modified during
-// expansion to indicate the origin of a node and the process it went through
-// being expanded. Ids are assigned to AST nodes just before lowering.
-//
-// For the simpler lowering steps, ids and spans should be preserved. Unlike
-// expansion we do not preserve the process of lowering in the spans, so spans
-// should not be modified here. When creating a new node (as opposed to
-// 'folding' an existing one), then you create a new id using `next_id()`.
-//
-// You must ensure that ids are unique. That means that you should only use the
-// id from an AST node in a single HIR node (you can assume that AST node ids
-// are unique). Every new node must have a unique id. Avoid cloning HIR nodes.
-// If you do, you must then set the new node's id to a fresh one.
-//
-// Spans are used for error messages and for tools to map semantics back to
-// source code. It is therefore not as important with spans as ids to be strict
-// about use (you can't break the compiler by screwing up a span). Obviously, a
-// HIR node can only have a single span. But multiple nodes can have the same
-// span and spans don't need to be kept in order, etc. Where code is preserved
-// by lowering, it should have the same span as in the AST. Where HIR nodes are
-// new it is probably best to give a span for the whole AST node being lowered.
-// All nodes should have real spans, don't use dummy spans. Tools are likely to
-// get confused if the spans from leaf AST nodes occur in multiple places
-// in the HIR, especially for multiple identifiers.
+//! Lowers the AST to the HIR.
+//!
+//! Since the AST and HIR are fairly similar, this is mostly a simple procedure,
+//! much like a fold. Where lowering involves a bit more work things get more
+//! interesting and there are some invariants you should know about. These mostly
+//! concern spans and ids.
+//!
+//! Spans are assigned to AST nodes during parsing and then are modified during
+//! expansion to indicate the origin of a node and the process it went through
+//! being expanded. Ids are assigned to AST nodes just before lowering.
+//!
+//! For the simpler lowering steps, ids and spans should be preserved. Unlike
+//! expansion we do not preserve the process of lowering in the spans, so spans
+//! should not be modified here. When creating a new node (as opposed to
+//! 'folding' an existing one), then you create a new id using `next_id()`.
+//!
+//! You must ensure that ids are unique. That means that you should only use the
+//! id from an AST node in a single HIR node (you can assume that AST node ids
+//! are unique). Every new node must have a unique id. Avoid cloning HIR nodes.
+//! If you do, you must then set the new node's id to a fresh one.
+//!
+//! Spans are used for error messages and for tools to map semantics back to
+//! source code. It is therefore not as important with spans as ids to be strict
+//! about use (you can't break the compiler by screwing up a span). Obviously, a
+//! HIR node can only have a single span. But multiple nodes can have the same
+//! span and spans don't need to be kept in order, etc. Where code is preserved
+//! by lowering, it should have the same span as in the AST. Where HIR nodes are
+//! new it is probably best to give a span for the whole AST node being lowered.
+//! All nodes should have real spans, don't use dummy spans. Tools are likely to
+//! get confused if the spans from leaf AST nodes occur in multiple places
+//! in the HIR, especially for multiple identifiers.
use hir;
use hir::map::{Definitions, DefKey, REGULAR_SPACE};
pub struct LoweringContext<'a> {
crate_root: Option<&'static str>,
+
// Use to assign ids to hir nodes that do not directly correspond to an ast node
sess: &'a Session,
+
// As we walk the AST we must keep track of the current 'parent' def id (in
// the form of a DefIndex) so that if we create a new node which introduces
// a definition, then we can properly create the def id.
}
pub trait Resolver {
- // Resolve a hir path generated by the lowerer when expanding `for`, `if let`, etc.
+ /// Resolve a hir path generated by the lowerer when expanding `for`, `if let`, etc.
fn resolve_hir_path(&mut self, path: &mut hir::Path, is_value: bool);
- // Obtain the resolution for a node id
+ /// Obtain the resolution for a node id
fn get_resolution(&mut self, id: NodeId) -> Option<PathResolution>;
- // We must keep the set of definitions up to date as we add nodes that weren't in the AST.
- // This should only return `None` during testing.
+ /// We must keep the set of definitions up to date as we add nodes that weren't in the AST.
+ /// This should only return `None` during testing.
fn definitions(&mut self) -> &mut Definitions;
}
Region(ty::RegionKind),
}
-// type Edge = Constraint;
#[derive(Clone, PartialEq, Eq, Debug, Copy)]
enum Edge<'tcx> {
Constraint(Constraint<'tcx>),
mod graphviz;
-// A constraint that influences the inference process.
+/// A constraint that influences the inference process.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum Constraint<'tcx> {
- // One region variable is subregion of another
+ /// One region variable is subregion of another
ConstrainVarSubVar(RegionVid, RegionVid),
- // Concrete region is subregion of region variable
+ /// Concrete region is subregion of region variable
ConstrainRegSubVar(Region<'tcx>, RegionVid),
- // Region variable is subregion of concrete region. This does not
- // directly affect inference, but instead is checked after
- // inference is complete.
+ /// Region variable is subregion of concrete region. This does not
+ /// directly affect inference, but instead is checked after
+ /// inference is complete.
ConstrainVarSubReg(RegionVid, Region<'tcx>),
- // A constraint where neither side is a variable. This does not
- // directly affect inference, but instead is checked after
- // inference is complete.
+ /// A constraint where neither side is a variable. This does not
+ /// directly affect inference, but instead is checked after
+ /// inference is complete.
ConstrainRegSubReg(Region<'tcx>, Region<'tcx>),
}
-// VerifyGenericBound(T, _, R, RS): The parameter type `T` (or
-// associated type) must outlive the region `R`. `T` is known to
-// outlive `RS`. Therefore verify that `R <= RS[i]` for some
-// `i`. Inference variables may be involved (but this verification
-// step doesn't influence inference).
+/// VerifyGenericBound(T, _, R, RS): The parameter type `T` (or
+/// associated type) must outlive the region `R`. `T` is known to
+/// outlive `RS`. Therefore verify that `R <= RS[i]` for some
+/// `i`. Inference variables may be involved (but this verification
+/// step doesn't influence inference).
#[derive(Debug)]
pub struct Verify<'tcx> {
kind: GenericKind<'tcx>,
Projection(ty::ProjectionTy<'tcx>),
}
-// When we introduce a verification step, we wish to test that a
-// particular region (let's call it `'min`) meets some bound.
-// The bound is described the by the following grammar:
+/// When we introduce a verification step, we wish to test that a
+/// particular region (let's call it `'min`) meets some bound.
+/// The bound is described the by the following grammar:
#[derive(Debug)]
pub enum VerifyBound<'tcx> {
- // B = exists {R} --> some 'r in {R} must outlive 'min
- //
- // Put another way, the subject value is known to outlive all
- // regions in {R}, so if any of those outlives 'min, then the
- // bound is met.
+ /// B = exists {R} --> some 'r in {R} must outlive 'min
+ ///
+ /// Put another way, the subject value is known to outlive all
+ /// regions in {R}, so if any of those outlives 'min, then the
+ /// bound is met.
AnyRegion(Vec<Region<'tcx>>),
- // B = forall {R} --> all 'r in {R} must outlive 'min
- //
- // Put another way, the subject value is known to outlive some
- // region in {R}, so if all of those outlives 'min, then the bound
- // is met.
+ /// B = forall {R} --> all 'r in {R} must outlive 'min
+ ///
+ /// Put another way, the subject value is known to outlive some
+ /// region in {R}, so if all of those outlives 'min, then the bound
+ /// is met.
AllRegions(Vec<Region<'tcx>>),
- // B = exists {B} --> 'min must meet some bound b in {B}
+ /// B = exists {B} --> 'min must meet some bound b in {B}
AnyBound(Vec<VerifyBound<'tcx>>),
- // B = forall {B} --> 'min must meet all bounds b in {B}
+ /// B = forall {B} --> 'min must meet all bounds b in {B}
AllBounds(Vec<VerifyBound<'tcx>>),
}
tcx: TyCtxt<'a, 'gcx, 'tcx>,
var_origins: RefCell<Vec<RegionVariableOrigin>>,
- // Constraints of the form `A <= B` introduced by the region
- // checker. Here at least one of `A` and `B` must be a region
- // variable.
+ /// Constraints of the form `A <= B` introduced by the region
+ /// checker. Here at least one of `A` and `B` must be a region
+ /// variable.
constraints: RefCell<FxHashMap<Constraint<'tcx>, SubregionOrigin<'tcx>>>,
- // A "verify" is something that we need to verify after inference is
- // done, but which does not directly affect inference in any way.
- //
- // An example is a `A <= B` where neither `A` nor `B` are
- // inference variables.
+ /// A "verify" is something that we need to verify after inference is
+ /// done, but which does not directly affect inference in any way.
+ ///
+ /// An example is a `A <= B` where neither `A` nor `B` are
+ /// inference variables.
verifys: RefCell<Vec<Verify<'tcx>>>,
- // A "given" is a relationship that is known to hold. In particular,
- // we often know from closure fn signatures that a particular free
- // region must be a subregion of a region variable:
- //
- // foo.iter().filter(<'a> |x: &'a &'b T| ...)
- //
- // In situations like this, `'b` is in fact a region variable
- // introduced by the call to `iter()`, and `'a` is a bound region
- // on the closure (as indicated by the `<'a>` prefix). If we are
- // naive, we wind up inferring that `'b` must be `'static`,
- // because we require that it be greater than `'a` and we do not
- // know what `'a` is precisely.
- //
- // This hashmap is used to avoid that naive scenario. Basically we
- // record the fact that `'a <= 'b` is implied by the fn signature,
- // and then ignore the constraint when solving equations. This is
- // a bit of a hack but seems to work.
+ /// A "given" is a relationship that is known to hold. In particular,
+ /// we often know from closure fn signatures that a particular free
+ /// region must be a subregion of a region variable:
+ ///
+ /// foo.iter().filter(<'a> |x: &'a &'b T| ...)
+ ///
+ /// In situations like this, `'b` is in fact a region variable
+ /// introduced by the call to `iter()`, and `'a` is a bound region
+ /// on the closure (as indicated by the `<'a>` prefix). If we are
+ /// naive, we wind up inferring that `'b` must be `'static`,
+ /// because we require that it be greater than `'a` and we do not
+ /// know what `'a` is precisely.
+ ///
+ /// This hashmap is used to avoid that naive scenario. Basically we
+ /// record the fact that `'a <= 'b` is implied by the fn signature,
+ /// and then ignore the constraint when solving equations. This is
+ /// a bit of a hack but seems to work.
givens: RefCell<FxHashSet<(Region<'tcx>, ty::RegionVid)>>,
lubs: RefCell<CombineMap<'tcx>>,
skolemization_count: Cell<u32>,
bound_count: Cell<u32>,
- // The undo log records actions that might later be undone.
- //
- // Note: when the undo_log is empty, we are not actively
- // snapshotting. When the `start_snapshot()` method is called, we
- // push an OpenSnapshot entry onto the list to indicate that we
- // are now actively snapshotting. The reason for this is that
- // otherwise we end up adding entries for things like the lower
- // bound on a variable and so forth, which can never be rolled
- // back.
+ /// The undo log records actions that might later be undone.
+ ///
+ /// Note: when the undo_log is empty, we are not actively
+ /// snapshotting. When the `start_snapshot()` method is called, we
+ /// push an OpenSnapshot entry onto the list to indicate that we
+ /// are now actively snapshotting. The reason for this is that
+ /// otherwise we end up adding entries for things like the lower
+ /// bound on a variable and so forth, which can never be rolled
+ /// back.
undo_log: RefCell<Vec<UndoLogEntry<'tcx>>>,
+
unification_table: RefCell<UnificationTable<ty::RegionVid>>,
- // This contains the results of inference. It begins as an empty
- // option and only acquires a value after inference is complete.
+ /// This contains the results of inference. It begins as an empty
+ /// option and only acquires a value after inference is complete.
values: RefCell<Option<Vec<VarValue<'tcx>>>>,
}
for verify in self.verifys.borrow().iter() {
debug!("collect_errors: verify={:?}", verify);
let sub = normalize(self.tcx, var_data, verify.region);
+
+ // This was an inference variable which didn't get
+ // constrained, therefore it can be assume to hold.
+ if let ty::ReEmpty = *sub {
+ continue;
+ }
+
if verify.bound.is_met(region_rels, var_data, sub) {
continue;
}
continue;
}
}
- },
- Err(FindLintError::Removed) => { continue; }
+ }
+ Err(FindLintError::Removed) => continue,
}
}
};
Some(sess.struct_warn(msg))
},
CheckLintNameResult::NoLint => {
- Some(sess.struct_err(&format!("unknown lint: `{}`", lint_name)))
+ Some(struct_err!(sess, E0602, "unknown lint: `{}`", lint_name))
}
};
m.push_str(&(if n == 1 {
help_name
} else {
- format!("one of {}'s {} elided {}lifetimes", help_name, n,
+ format!("one of {}'s {} {}lifetimes", help_name, n,
if have_bound_regions { "free " } else { "" } )
})[..]);
use hir::intravisit::{Visitor, NestedVisitorMap};
use hir::map::NodeExpr;
use hir::def_id::DefId;
-use infer::{self, InferCtxt};
+use infer::{self, InferCtxt, InferTables, InferTablesRef};
use infer::type_variable::TypeVariableOrigin;
use rustc::lint::builtin::EXTRA_REQUIREMENT_IN_IMPL;
use std::fmt;
ty::Predicate::ClosureKind(closure_def_id, kind) => {
let found_kind = self.closure_kind(closure_def_id).unwrap();
let closure_span = self.tcx.hir.span_if_local(closure_def_id).unwrap();
+ let node_id = self.tcx.hir.as_local_node_id(closure_def_id).unwrap();
let mut err = struct_span_err!(
self.tcx.sess, closure_span, E0525,
"expected a closure that implements the `{}` trait, \
but this closure only implements `{}`",
kind,
found_kind);
- err.span_note(
+
+ err.span_label(
obligation.cause.span,
- &format!("the requirement to implement \
- `{}` derives from here", kind));
+ format!("the requirement to implement `{}` derives from here", kind));
+
+ let infer_tables = match self.tables {
+ InferTables::Interned(tables) =>
+ Some(InferTablesRef::Interned(tables)),
+ InferTables::InProgress(tables) =>
+ Some(InferTablesRef::InProgress(tables.borrow())),
+ InferTables::Missing => None,
+ };
+
+ // Additional context information explaining why the closure only implements
+ // a particular trait.
+ if let Some(tables) = infer_tables {
+ match tables.closure_kinds.get(&node_id) {
+ Some(&(ty::ClosureKind::FnOnce, Some((span, name)))) => {
+ err.span_note(span, &format!(
+ "closure is `FnOnce` because it moves the \
+ variable `{}` out of its environment", name));
+ },
+ Some(&(ty::ClosureKind::FnMut, Some((span, name)))) => {
+ err.span_note(span, &format!(
+ "closure is `FnMut` because it mutates the \
+ variable `{}` here", name));
+ },
+ _ => {}
+ }
+ }
+
err.emit();
return;
}
println!("cargo:rerun-if-changed={}", llvm_config.display());
+ if let Some(cfg_toml) = env::var_os("CFG_LLVM_TOML") {
+ let cfg_path = PathBuf::from(cfg_toml);
+ println!("cargo:rerun-if-changed={}", cfg_path.display());
+ }
+
// Test whether we're cross-compiling LLVM. This is a pretty rare case
// currently where we're producing an LLVM for a different platform than
// what this build script is currently running on.
const A: AtomicUsize = ATOMIC_USIZE_INIT;
static B: &'static AtomicUsize = &A;
-// error: cannot borrow a constant which contains interior mutability, create a
-// static instead
+// error: cannot borrow a constant which may contain interior mutability,
+// create a static instead
```
A `const` represents a constant value that should never change. If one takes
const A: Cell<usize> = Cell::new(1);
const B: &'static Cell<usize> = &A;
-// error: cannot borrow a constant which contains interior mutability, create
-// a static instead
+// error: cannot borrow a constant which may contain interior mutability,
+// create a static instead
// or:
struct C { a: Cell<usize> }
self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
span_err!(self.tcx.sess, self.span, E0492,
- "cannot borrow a constant which contains \
+ "cannot borrow a constant which may contain \
interior mutability, create a static instead");
}
}
"hadd_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vhadds.v8i8")
+ definition: Named("llvm.arm.neon.vhadds.v8i8")
},
"hadd_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vhaddu.v8i8")
+ definition: Named("llvm.arm.neon.vhaddu.v8i8")
},
"hadd_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vhadds.v4i16")
+ definition: Named("llvm.arm.neon.vhadds.v4i16")
},
"hadd_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vhaddu.v4i16")
+ definition: Named("llvm.arm.neon.vhaddu.v4i16")
},
"hadd_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vhadds.v2i32")
+ definition: Named("llvm.arm.neon.vhadds.v2i32")
},
"hadd_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vhaddu.v2i32")
+ definition: Named("llvm.arm.neon.vhaddu.v2i32")
},
"haddq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vhadds.v16i8")
+ definition: Named("llvm.arm.neon.vhadds.v16i8")
},
"haddq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vhaddu.v16i8")
+ definition: Named("llvm.arm.neon.vhaddu.v16i8")
},
"haddq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vhadds.v8i16")
+ definition: Named("llvm.arm.neon.vhadds.v8i16")
},
"haddq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vhaddu.v8i16")
+ definition: Named("llvm.arm.neon.vhaddu.v8i16")
},
"haddq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vhadds.v4i32")
+ definition: Named("llvm.arm.neon.vhadds.v4i32")
},
"haddq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vhaddu.v4i32")
+ definition: Named("llvm.arm.neon.vhaddu.v4i32")
},
"rhadd_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vrhadds.v8i8")
+ definition: Named("llvm.arm.neon.vrhadds.v8i8")
},
"rhadd_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vrhaddu.v8i8")
+ definition: Named("llvm.arm.neon.vrhaddu.v8i8")
},
"rhadd_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vrhadds.v4i16")
+ definition: Named("llvm.arm.neon.vrhadds.v4i16")
},
"rhadd_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vrhaddu.v4i16")
+ definition: Named("llvm.arm.neon.vrhaddu.v4i16")
},
"rhadd_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vrhadds.v2i32")
+ definition: Named("llvm.arm.neon.vrhadds.v2i32")
},
"rhadd_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vrhaddu.v2i32")
+ definition: Named("llvm.arm.neon.vrhaddu.v2i32")
},
"rhaddq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vrhadds.v16i8")
+ definition: Named("llvm.arm.neon.vrhadds.v16i8")
},
"rhaddq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vrhaddu.v16i8")
+ definition: Named("llvm.arm.neon.vrhaddu.v16i8")
},
"rhaddq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vrhadds.v8i16")
+ definition: Named("llvm.arm.neon.vrhadds.v8i16")
},
"rhaddq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vrhaddu.v8i16")
+ definition: Named("llvm.arm.neon.vrhaddu.v8i16")
},
"rhaddq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vrhadds.v4i32")
+ definition: Named("llvm.arm.neon.vrhadds.v4i32")
},
"rhaddq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vrhaddu.v4i32")
+ definition: Named("llvm.arm.neon.vrhaddu.v4i32")
},
"qadd_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vqadds.v8i8")
+ definition: Named("llvm.arm.neon.vqadds.v8i8")
},
"qadd_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vqaddu.v8i8")
+ definition: Named("llvm.arm.neon.vqaddu.v8i8")
},
"qadd_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vqadds.v4i16")
+ definition: Named("llvm.arm.neon.vqadds.v4i16")
},
"qadd_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vqaddu.v4i16")
+ definition: Named("llvm.arm.neon.vqaddu.v4i16")
},
"qadd_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vqadds.v2i32")
+ definition: Named("llvm.arm.neon.vqadds.v2i32")
},
"qadd_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vqaddu.v2i32")
+ definition: Named("llvm.arm.neon.vqaddu.v2i32")
},
"qadd_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vqadds.v1i64")
+ definition: Named("llvm.arm.neon.vqadds.v1i64")
},
"qadd_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::U64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vqaddu.v1i64")
+ definition: Named("llvm.arm.neon.vqaddu.v1i64")
},
"qaddq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vqadds.v16i8")
+ definition: Named("llvm.arm.neon.vqadds.v16i8")
},
"qaddq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vqaddu.v16i8")
+ definition: Named("llvm.arm.neon.vqaddu.v16i8")
},
"qaddq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vqadds.v8i16")
+ definition: Named("llvm.arm.neon.vqadds.v8i16")
},
"qaddq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vqaddu.v8i16")
+ definition: Named("llvm.arm.neon.vqaddu.v8i16")
},
"qaddq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vqadds.v4i32")
+ definition: Named("llvm.arm.neon.vqadds.v4i32")
},
"qaddq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vqaddu.v4i32")
+ definition: Named("llvm.arm.neon.vqaddu.v4i32")
},
"qaddq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vqadds.v2i64")
+ definition: Named("llvm.arm.neon.vqadds.v2i64")
},
"qaddq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vqaddu.v2i64")
+ definition: Named("llvm.arm.neon.vqaddu.v2i64")
},
"raddhn_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vraddhn.v8i8")
+ definition: Named("llvm.arm.neon.vraddhn.v8i8")
},
"raddhn_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vraddhn.v8i8")
+ definition: Named("llvm.arm.neon.vraddhn.v8i8")
},
"raddhn_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vraddhn.v4i16")
+ definition: Named("llvm.arm.neon.vraddhn.v4i16")
},
"raddhn_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vraddhn.v4i16")
+ definition: Named("llvm.arm.neon.vraddhn.v4i16")
},
"raddhn_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vraddhn.v2i32")
+ definition: Named("llvm.arm.neon.vraddhn.v2i32")
},
"raddhn_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vraddhn.v2i32")
+ definition: Named("llvm.arm.neon.vraddhn.v2i32")
},
"fma_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
"qdmulh_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vsqdmulh.v4i16")
+ definition: Named("llvm.arm.neon.vsqdmulh.v4i16")
},
"qdmulh_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vsqdmulh.v2i32")
+ definition: Named("llvm.arm.neon.vsqdmulh.v2i32")
},
"qdmulhq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vsqdmulh.v8i16")
+ definition: Named("llvm.arm.neon.vsqdmulh.v8i16")
},
"qdmulhq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vsqdmulh.v4i32")
+ definition: Named("llvm.arm.neon.vsqdmulh.v4i32")
},
"qrdmulh_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vsqrdmulh.v4i16")
+ definition: Named("llvm.arm.neon.vsqrdmulh.v4i16")
},
"qrdmulh_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vsqrdmulh.v2i32")
+ definition: Named("llvm.arm.neon.vsqrdmulh.v2i32")
},
"qrdmulhq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vsqrdmulh.v8i16")
+ definition: Named("llvm.arm.neon.vsqrdmulh.v8i16")
},
"qrdmulhq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vsqrdmulh.v4i32")
+ definition: Named("llvm.arm.neon.vsqrdmulh.v4i32")
},
"mull_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vmulls.v8i16")
+ definition: Named("llvm.arm.neon.vmulls.v8i16")
},
"mull_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vmullu.v8i16")
+ definition: Named("llvm.arm.neon.vmullu.v8i16")
},
"mull_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vmulls.v4i32")
+ definition: Named("llvm.arm.neon.vmulls.v4i32")
},
"mull_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vmullu.v4i32")
+ definition: Named("llvm.arm.neon.vmullu.v4i32")
},
"mull_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vmulls.v2i64")
+ definition: Named("llvm.arm.neon.vmulls.v2i64")
},
"mull_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vmullu.v2i64")
+ definition: Named("llvm.arm.neon.vmullu.v2i64")
},
"qdmullq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vsqdmull.v8i16")
+ definition: Named("llvm.arm.neon.vsqdmull.v8i16")
},
"qdmullq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vsqdmull.v4i32")
+ definition: Named("llvm.arm.neon.vsqdmull.v4i32")
},
"hsub_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vhsubs.v8i8")
+ definition: Named("llvm.arm.neon.vhsubs.v8i8")
},
"hsub_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vhsubu.v8i8")
+ definition: Named("llvm.arm.neon.vhsubu.v8i8")
},
"hsub_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vhsubs.v4i16")
+ definition: Named("llvm.arm.neon.vhsubs.v4i16")
},
"hsub_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vhsubu.v4i16")
+ definition: Named("llvm.arm.neon.vhsubu.v4i16")
},
"hsub_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vhsubs.v2i32")
+ definition: Named("llvm.arm.neon.vhsubs.v2i32")
},
"hsub_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vhsubu.v2i32")
+ definition: Named("llvm.arm.neon.vhsubu.v2i32")
},
"hsubq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vhsubs.v16i8")
+ definition: Named("llvm.arm.neon.vhsubs.v16i8")
},
"hsubq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vhsubu.v16i8")
+ definition: Named("llvm.arm.neon.vhsubu.v16i8")
},
"hsubq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vhsubs.v8i16")
+ definition: Named("llvm.arm.neon.vhsubs.v8i16")
},
"hsubq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vhsubu.v8i16")
+ definition: Named("llvm.arm.neon.vhsubu.v8i16")
},
"hsubq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vhsubs.v4i32")
+ definition: Named("llvm.arm.neon.vhsubs.v4i32")
},
"hsubq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vhsubu.v4i32")
+ definition: Named("llvm.arm.neon.vhsubu.v4i32")
},
"qsub_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vqsubs.v8i8")
+ definition: Named("llvm.arm.neon.vqsubs.v8i8")
},
"qsub_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vqsubu.v8i8")
+ definition: Named("llvm.arm.neon.vqsubu.v8i8")
},
"qsub_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vqsubs.v4i16")
+ definition: Named("llvm.arm.neon.vqsubs.v4i16")
},
"qsub_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vqsubu.v4i16")
+ definition: Named("llvm.arm.neon.vqsubu.v4i16")
},
"qsub_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vqsubs.v2i32")
+ definition: Named("llvm.arm.neon.vqsubs.v2i32")
},
"qsub_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vqsubu.v2i32")
+ definition: Named("llvm.arm.neon.vqsubu.v2i32")
},
"qsub_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vqsubs.v1i64")
+ definition: Named("llvm.arm.neon.vqsubs.v1i64")
},
"qsub_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::U64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vqsubu.v1i64")
+ definition: Named("llvm.arm.neon.vqsubu.v1i64")
},
"qsubq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vqsubs.v16i8")
+ definition: Named("llvm.arm.neon.vqsubs.v16i8")
},
"qsubq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vqsubu.v16i8")
+ definition: Named("llvm.arm.neon.vqsubu.v16i8")
},
"qsubq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vqsubs.v8i16")
+ definition: Named("llvm.arm.neon.vqsubs.v8i16")
},
"qsubq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vqsubu.v8i16")
+ definition: Named("llvm.arm.neon.vqsubu.v8i16")
},
"qsubq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vqsubs.v4i32")
+ definition: Named("llvm.arm.neon.vqsubs.v4i32")
},
"qsubq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vqsubu.v4i32")
+ definition: Named("llvm.arm.neon.vqsubu.v4i32")
},
"qsubq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vqsubs.v2i64")
+ definition: Named("llvm.arm.neon.vqsubs.v2i64")
},
"qsubq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vqsubu.v2i64")
+ definition: Named("llvm.arm.neon.vqsubu.v2i64")
},
"rsubhn_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vrsubhn.v8i8")
+ definition: Named("llvm.arm.neon.vrsubhn.v8i8")
},
"rsubhn_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vrsubhn.v8i8")
+ definition: Named("llvm.arm.neon.vrsubhn.v8i8")
},
"rsubhn_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vrsubhn.v4i16")
+ definition: Named("llvm.arm.neon.vrsubhn.v4i16")
},
"rsubhn_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vrsubhn.v4i16")
+ definition: Named("llvm.arm.neon.vrsubhn.v4i16")
},
"rsubhn_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vrsubhn.v2i32")
+ definition: Named("llvm.arm.neon.vrsubhn.v2i32")
},
"rsubhn_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vrsubhn.v2i32")
+ definition: Named("llvm.arm.neon.vrsubhn.v2i32")
},
"abd_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vabds.v8i8")
+ definition: Named("llvm.arm.neon.vabds.v8i8")
},
"abd_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vabdu.v8i8")
+ definition: Named("llvm.arm.neon.vabdu.v8i8")
},
"abd_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vabds.v4i16")
+ definition: Named("llvm.arm.neon.vabds.v4i16")
},
"abd_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vabdu.v4i16")
+ definition: Named("llvm.arm.neon.vabdu.v4i16")
},
"abd_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vabds.v2i32")
+ definition: Named("llvm.arm.neon.vabds.v2i32")
},
"abd_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vabdu.v2i32")
+ definition: Named("llvm.arm.neon.vabdu.v2i32")
},
"abd_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vabdf.v2f32")
+ definition: Named("llvm.arm.neon.vabdf.v2f32")
},
"abdq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vabds.v16i8")
+ definition: Named("llvm.arm.neon.vabds.v16i8")
},
"abdq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vabdu.v16i8")
+ definition: Named("llvm.arm.neon.vabdu.v16i8")
},
"abdq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vabds.v8i16")
+ definition: Named("llvm.arm.neon.vabds.v8i16")
},
"abdq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vabdu.v8i16")
+ definition: Named("llvm.arm.neon.vabdu.v8i16")
},
"abdq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vabds.v4i32")
+ definition: Named("llvm.arm.neon.vabds.v4i32")
},
"abdq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vabdu.v4i32")
+ definition: Named("llvm.arm.neon.vabdu.v4i32")
},
"abdq_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
output: &::F32x4,
- definition: Named("llvm.neon.vabdf.v4f32")
+ definition: Named("llvm.arm.neon.vabdf.v4f32")
},
"max_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vmaxs.v8i8")
+ definition: Named("llvm.arm.neon.vmaxs.v8i8")
},
"max_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vmaxu.v8i8")
+ definition: Named("llvm.arm.neon.vmaxu.v8i8")
},
"max_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vmaxs.v4i16")
+ definition: Named("llvm.arm.neon.vmaxs.v4i16")
},
"max_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vmaxu.v4i16")
+ definition: Named("llvm.arm.neon.vmaxu.v4i16")
},
"max_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vmaxs.v2i32")
+ definition: Named("llvm.arm.neon.vmaxs.v2i32")
},
"max_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vmaxu.v2i32")
+ definition: Named("llvm.arm.neon.vmaxu.v2i32")
},
"max_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vmaxf.v2f32")
+ definition: Named("llvm.arm.neon.vmaxf.v2f32")
},
"maxq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vmaxs.v16i8")
+ definition: Named("llvm.arm.neon.vmaxs.v16i8")
},
"maxq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vmaxu.v16i8")
+ definition: Named("llvm.arm.neon.vmaxu.v16i8")
},
"maxq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vmaxs.v8i16")
+ definition: Named("llvm.arm.neon.vmaxs.v8i16")
},
"maxq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vmaxu.v8i16")
+ definition: Named("llvm.arm.neon.vmaxu.v8i16")
},
"maxq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vmaxs.v4i32")
+ definition: Named("llvm.arm.neon.vmaxs.v4i32")
},
"maxq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vmaxu.v4i32")
+ definition: Named("llvm.arm.neon.vmaxu.v4i32")
},
"maxq_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
output: &::F32x4,
- definition: Named("llvm.neon.vmaxf.v4f32")
+ definition: Named("llvm.arm.neon.vmaxf.v4f32")
},
"min_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vmins.v8i8")
+ definition: Named("llvm.arm.neon.vmins.v8i8")
},
"min_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vminu.v8i8")
+ definition: Named("llvm.arm.neon.vminu.v8i8")
},
"min_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vmins.v4i16")
+ definition: Named("llvm.arm.neon.vmins.v4i16")
},
"min_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vminu.v4i16")
+ definition: Named("llvm.arm.neon.vminu.v4i16")
},
"min_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vmins.v2i32")
+ definition: Named("llvm.arm.neon.vmins.v2i32")
},
"min_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vminu.v2i32")
+ definition: Named("llvm.arm.neon.vminu.v2i32")
},
"min_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vminf.v2f32")
+ definition: Named("llvm.arm.neon.vminf.v2f32")
},
"minq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vmins.v16i8")
+ definition: Named("llvm.arm.neon.vmins.v16i8")
},
"minq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vminu.v16i8")
+ definition: Named("llvm.arm.neon.vminu.v16i8")
},
"minq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vmins.v8i16")
+ definition: Named("llvm.arm.neon.vmins.v8i16")
},
"minq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vminu.v8i16")
+ definition: Named("llvm.arm.neon.vminu.v8i16")
},
"minq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vmins.v4i32")
+ definition: Named("llvm.arm.neon.vmins.v4i32")
},
"minq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vminu.v4i32")
+ definition: Named("llvm.arm.neon.vminu.v4i32")
},
"minq_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
output: &::F32x4,
- definition: Named("llvm.neon.vminf.v4f32")
+ definition: Named("llvm.arm.neon.vminf.v4f32")
},
"shl_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vshls.v8i8")
+ definition: Named("llvm.arm.neon.vshls.v8i8")
},
"shl_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::I8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vshlu.v8i8")
+ definition: Named("llvm.arm.neon.vshlu.v8i8")
},
"shl_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vshls.v4i16")
+ definition: Named("llvm.arm.neon.vshls.v4i16")
},
"shl_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::I16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vshlu.v4i16")
+ definition: Named("llvm.arm.neon.vshlu.v4i16")
},
"shl_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vshls.v2i32")
+ definition: Named("llvm.arm.neon.vshls.v2i32")
},
"shl_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::I32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vshlu.v2i32")
+ definition: Named("llvm.arm.neon.vshlu.v2i32")
},
"shl_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vshls.v1i64")
+ definition: Named("llvm.arm.neon.vshls.v1i64")
},
"shl_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::I64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vshlu.v1i64")
+ definition: Named("llvm.arm.neon.vshlu.v1i64")
},
"shlq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vshls.v16i8")
+ definition: Named("llvm.arm.neon.vshls.v16i8")
},
"shlq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::I8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vshlu.v16i8")
+ definition: Named("llvm.arm.neon.vshlu.v16i8")
},
"shlq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vshls.v8i16")
+ definition: Named("llvm.arm.neon.vshls.v8i16")
},
"shlq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::I16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vshlu.v8i16")
+ definition: Named("llvm.arm.neon.vshlu.v8i16")
},
"shlq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vshls.v4i32")
+ definition: Named("llvm.arm.neon.vshls.v4i32")
},
"shlq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::I32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vshlu.v4i32")
+ definition: Named("llvm.arm.neon.vshlu.v4i32")
},
"shlq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vshls.v2i64")
+ definition: Named("llvm.arm.neon.vshls.v2i64")
},
"shlq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::I64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vshlu.v2i64")
+ definition: Named("llvm.arm.neon.vshlu.v2i64")
},
"qshl_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vqshls.v8i8")
+ definition: Named("llvm.arm.neon.vqshls.v8i8")
},
"qshl_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::I8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vqshlu.v8i8")
+ definition: Named("llvm.arm.neon.vqshlu.v8i8")
},
"qshl_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vqshls.v4i16")
+ definition: Named("llvm.arm.neon.vqshls.v4i16")
},
"qshl_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::I16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vqshlu.v4i16")
+ definition: Named("llvm.arm.neon.vqshlu.v4i16")
},
"qshl_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vqshls.v2i32")
+ definition: Named("llvm.arm.neon.vqshls.v2i32")
},
"qshl_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::I32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vqshlu.v2i32")
+ definition: Named("llvm.arm.neon.vqshlu.v2i32")
},
"qshl_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vqshls.v1i64")
+ definition: Named("llvm.arm.neon.vqshls.v1i64")
},
"qshl_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::I64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vqshlu.v1i64")
+ definition: Named("llvm.arm.neon.vqshlu.v1i64")
},
"qshlq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vqshls.v16i8")
+ definition: Named("llvm.arm.neon.vqshls.v16i8")
},
"qshlq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::I8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vqshlu.v16i8")
+ definition: Named("llvm.arm.neon.vqshlu.v16i8")
},
"qshlq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vqshls.v8i16")
+ definition: Named("llvm.arm.neon.vqshls.v8i16")
},
"qshlq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::I16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vqshlu.v8i16")
+ definition: Named("llvm.arm.neon.vqshlu.v8i16")
},
"qshlq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vqshls.v4i32")
+ definition: Named("llvm.arm.neon.vqshls.v4i32")
},
"qshlq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::I32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vqshlu.v4i32")
+ definition: Named("llvm.arm.neon.vqshlu.v4i32")
},
"qshlq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vqshls.v2i64")
+ definition: Named("llvm.arm.neon.vqshls.v2i64")
},
"qshlq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::I64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vqshlu.v2i64")
+ definition: Named("llvm.arm.neon.vqshlu.v2i64")
},
"rshl_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vrshls.v8i8")
+ definition: Named("llvm.arm.neon.vrshls.v8i8")
},
"rshl_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::I8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vrshlu.v8i8")
+ definition: Named("llvm.arm.neon.vrshlu.v8i8")
},
"rshl_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vrshls.v4i16")
+ definition: Named("llvm.arm.neon.vrshls.v4i16")
},
"rshl_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::I16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vrshlu.v4i16")
+ definition: Named("llvm.arm.neon.vrshlu.v4i16")
},
"rshl_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vrshls.v2i32")
+ definition: Named("llvm.arm.neon.vrshls.v2i32")
},
"rshl_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::I32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vrshlu.v2i32")
+ definition: Named("llvm.arm.neon.vrshlu.v2i32")
},
"rshl_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vrshls.v1i64")
+ definition: Named("llvm.arm.neon.vrshls.v1i64")
},
"rshl_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::I64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vrshlu.v1i64")
+ definition: Named("llvm.arm.neon.vrshlu.v1i64")
},
"rshlq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vrshls.v16i8")
+ definition: Named("llvm.arm.neon.vrshls.v16i8")
},
"rshlq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::I8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vrshlu.v16i8")
+ definition: Named("llvm.arm.neon.vrshlu.v16i8")
},
"rshlq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vrshls.v8i16")
+ definition: Named("llvm.arm.neon.vrshls.v8i16")
},
"rshlq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::I16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vrshlu.v8i16")
+ definition: Named("llvm.arm.neon.vrshlu.v8i16")
},
"rshlq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vrshls.v4i32")
+ definition: Named("llvm.arm.neon.vrshls.v4i32")
},
"rshlq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::I32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vrshlu.v4i32")
+ definition: Named("llvm.arm.neon.vrshlu.v4i32")
},
"rshlq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vrshls.v2i64")
+ definition: Named("llvm.arm.neon.vrshls.v2i64")
},
"rshlq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::I64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vrshlu.v2i64")
+ definition: Named("llvm.arm.neon.vrshlu.v2i64")
},
"qrshl_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vqrshls.v8i8")
+ definition: Named("llvm.arm.neon.vqrshls.v8i8")
},
"qrshl_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::I8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vqrshlu.v8i8")
+ definition: Named("llvm.arm.neon.vqrshlu.v8i8")
},
"qrshl_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vqrshls.v4i16")
+ definition: Named("llvm.arm.neon.vqrshls.v4i16")
},
"qrshl_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::I16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vqrshlu.v4i16")
+ definition: Named("llvm.arm.neon.vqrshlu.v4i16")
},
"qrshl_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vqrshls.v2i32")
+ definition: Named("llvm.arm.neon.vqrshls.v2i32")
},
"qrshl_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::I32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vqrshlu.v2i32")
+ definition: Named("llvm.arm.neon.vqrshlu.v2i32")
},
"qrshl_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vqrshls.v1i64")
+ definition: Named("llvm.arm.neon.vqrshls.v1i64")
},
"qrshl_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::I64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vqrshlu.v1i64")
+ definition: Named("llvm.arm.neon.vqrshlu.v1i64")
},
"qrshlq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vqrshls.v16i8")
+ definition: Named("llvm.arm.neon.vqrshls.v16i8")
},
"qrshlq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::I8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vqrshlu.v16i8")
+ definition: Named("llvm.arm.neon.vqrshlu.v16i8")
},
"qrshlq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vqrshls.v8i16")
+ definition: Named("llvm.arm.neon.vqrshls.v8i16")
},
"qrshlq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::I16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vqrshlu.v8i16")
+ definition: Named("llvm.arm.neon.vqrshlu.v8i16")
},
"qrshlq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vqrshls.v4i32")
+ definition: Named("llvm.arm.neon.vqrshls.v4i32")
},
"qrshlq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::I32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vqrshlu.v4i32")
+ definition: Named("llvm.arm.neon.vqrshlu.v4i32")
},
"qrshlq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vqrshls.v2i64")
+ definition: Named("llvm.arm.neon.vqrshls.v2i64")
},
"qrshlq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::I64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vqrshlu.v2i64")
+ definition: Named("llvm.arm.neon.vqrshlu.v2i64")
},
"qshrun_n_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::U32]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vsqshrun.v8i8")
+ definition: Named("llvm.arm.neon.vsqshrun.v8i8")
},
"qshrun_n_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::U32]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vsqshrun.v4i16")
+ definition: Named("llvm.arm.neon.vsqshrun.v4i16")
},
"qshrun_n_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::U32]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vsqshrun.v2i32")
+ definition: Named("llvm.arm.neon.vsqshrun.v2i32")
},
"qrshrun_n_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::U32]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vsqrshrun.v8i8")
+ definition: Named("llvm.arm.neon.vsqrshrun.v8i8")
},
"qrshrun_n_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::U32]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vsqrshrun.v4i16")
+ definition: Named("llvm.arm.neon.vsqrshrun.v4i16")
},
"qrshrun_n_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::U32]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vsqrshrun.v2i32")
+ definition: Named("llvm.arm.neon.vsqrshrun.v2i32")
},
"qshrn_n_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::U32]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vqshrns.v8i8")
+ definition: Named("llvm.arm.neon.vqshrns.v8i8")
},
"qshrn_n_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U32]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vqshrnu.v8i8")
+ definition: Named("llvm.arm.neon.vqshrnu.v8i8")
},
"qshrn_n_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::U32]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vqshrns.v4i16")
+ definition: Named("llvm.arm.neon.vqshrns.v4i16")
},
"qshrn_n_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vqshrnu.v4i16")
+ definition: Named("llvm.arm.neon.vqshrnu.v4i16")
},
"qshrn_n_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::U32]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vqshrns.v2i32")
+ definition: Named("llvm.arm.neon.vqshrns.v2i32")
},
"qshrn_n_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U32]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vqshrnu.v2i32")
+ definition: Named("llvm.arm.neon.vqshrnu.v2i32")
},
"rshrn_n_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::U32]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vrshrn.v8i8")
+ definition: Named("llvm.arm.neon.vrshrn.v8i8")
},
"rshrn_n_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U32]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vrshrn.v8i8")
+ definition: Named("llvm.arm.neon.vrshrn.v8i8")
},
"rshrn_n_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::U32]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vrshrn.v4i16")
+ definition: Named("llvm.arm.neon.vrshrn.v4i16")
},
"rshrn_n_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vrshrn.v4i16")
+ definition: Named("llvm.arm.neon.vrshrn.v4i16")
},
"rshrn_n_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::U32]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vrshrn.v2i32")
+ definition: Named("llvm.arm.neon.vrshrn.v2i32")
},
"rshrn_n_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U32]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vrshrn.v2i32")
+ definition: Named("llvm.arm.neon.vrshrn.v2i32")
},
"qrshrn_n_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::U32]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vqrshrns.v8i8")
+ definition: Named("llvm.arm.neon.vqrshrns.v8i8")
},
"qrshrn_n_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U32]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vqrshrnu.v8i8")
+ definition: Named("llvm.arm.neon.vqrshrnu.v8i8")
},
"qrshrn_n_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::U32]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vqrshrns.v4i16")
+ definition: Named("llvm.arm.neon.vqrshrns.v4i16")
},
"qrshrn_n_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vqrshrnu.v4i16")
+ definition: Named("llvm.arm.neon.vqrshrnu.v4i16")
},
"qrshrn_n_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::U32]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vqrshrns.v2i32")
+ definition: Named("llvm.arm.neon.vqrshrns.v2i32")
},
"qrshrn_n_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U32]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vqrshrnu.v2i32")
+ definition: Named("llvm.arm.neon.vqrshrnu.v2i32")
},
"sri_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vvsri.v8i8")
+ definition: Named("llvm.arm.neon.vvsri.v8i8")
},
"sri_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vvsri.v8i8")
+ definition: Named("llvm.arm.neon.vvsri.v8i8")
},
"sri_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vvsri.v4i16")
+ definition: Named("llvm.arm.neon.vvsri.v4i16")
},
"sri_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vvsri.v4i16")
+ definition: Named("llvm.arm.neon.vvsri.v4i16")
},
"sri_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vvsri.v2i32")
+ definition: Named("llvm.arm.neon.vvsri.v2i32")
},
"sri_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vvsri.v2i32")
+ definition: Named("llvm.arm.neon.vvsri.v2i32")
},
"sri_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vvsri.v1i64")
+ definition: Named("llvm.arm.neon.vvsri.v1i64")
},
"sri_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::U64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vvsri.v1i64")
+ definition: Named("llvm.arm.neon.vvsri.v1i64")
},
"sriq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vvsri.v16i8")
+ definition: Named("llvm.arm.neon.vvsri.v16i8")
},
"sriq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vvsri.v16i8")
+ definition: Named("llvm.arm.neon.vvsri.v16i8")
},
"sriq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vvsri.v8i16")
+ definition: Named("llvm.arm.neon.vvsri.v8i16")
},
"sriq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vvsri.v8i16")
+ definition: Named("llvm.arm.neon.vvsri.v8i16")
},
"sriq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vvsri.v4i32")
+ definition: Named("llvm.arm.neon.vvsri.v4i32")
},
"sriq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vvsri.v4i32")
+ definition: Named("llvm.arm.neon.vvsri.v4i32")
},
"sriq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vvsri.v2i64")
+ definition: Named("llvm.arm.neon.vvsri.v2i64")
},
"sriq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vvsri.v2i64")
+ definition: Named("llvm.arm.neon.vvsri.v2i64")
},
"sli_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vvsli.v8i8")
+ definition: Named("llvm.arm.neon.vvsli.v8i8")
},
"sli_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vvsli.v8i8")
+ definition: Named("llvm.arm.neon.vvsli.v8i8")
},
"sli_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vvsli.v4i16")
+ definition: Named("llvm.arm.neon.vvsli.v4i16")
},
"sli_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vvsli.v4i16")
+ definition: Named("llvm.arm.neon.vvsli.v4i16")
},
"sli_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vvsli.v2i32")
+ definition: Named("llvm.arm.neon.vvsli.v2i32")
},
"sli_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vvsli.v2i32")
+ definition: Named("llvm.arm.neon.vvsli.v2i32")
},
"sli_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vvsli.v1i64")
+ definition: Named("llvm.arm.neon.vvsli.v1i64")
},
"sli_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::U64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vvsli.v1i64")
+ definition: Named("llvm.arm.neon.vvsli.v1i64")
},
"sliq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vvsli.v16i8")
+ definition: Named("llvm.arm.neon.vvsli.v16i8")
},
"sliq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vvsli.v16i8")
+ definition: Named("llvm.arm.neon.vvsli.v16i8")
},
"sliq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vvsli.v8i16")
+ definition: Named("llvm.arm.neon.vvsli.v8i16")
},
"sliq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vvsli.v8i16")
+ definition: Named("llvm.arm.neon.vvsli.v8i16")
},
"sliq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vvsli.v4i32")
+ definition: Named("llvm.arm.neon.vvsli.v4i32")
},
"sliq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vvsli.v4i32")
+ definition: Named("llvm.arm.neon.vvsli.v4i32")
},
"sliq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vvsli.v2i64")
+ definition: Named("llvm.arm.neon.vvsli.v2i64")
},
"sliq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vvsli.v2i64")
+ definition: Named("llvm.arm.neon.vvsli.v2i64")
},
"vqmovn_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vqxtns.v8i8")
+ definition: Named("llvm.arm.neon.vqxtns.v8i8")
},
"vqmovn_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U16x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vqxtnu.v8i8")
+ definition: Named("llvm.arm.neon.vqxtnu.v8i8")
},
"vqmovn_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vqxtns.v4i16")
+ definition: Named("llvm.arm.neon.vqxtns.v4i16")
},
"vqmovn_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vqxtnu.v4i16")
+ definition: Named("llvm.arm.neon.vqxtnu.v4i16")
},
"vqmovn_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I64x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vqxtns.v2i32")
+ definition: Named("llvm.arm.neon.vqxtns.v2i32")
},
"vqmovn_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U64x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vqxtnu.v2i32")
+ definition: Named("llvm.arm.neon.vqxtnu.v2i32")
},
"abs_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vabs.v8i8")
+ definition: Named("llvm.arm.neon.vabs.v8i8")
},
"abs_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vabs.v4i16")
+ definition: Named("llvm.arm.neon.vabs.v4i16")
},
"abs_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vabs.v2i32")
+ definition: Named("llvm.arm.neon.vabs.v2i32")
},
"absq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vabs.v16i8")
+ definition: Named("llvm.arm.neon.vabs.v16i8")
},
"absq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vabs.v8i16")
+ definition: Named("llvm.arm.neon.vabs.v8i16")
},
"absq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vabs.v4i32")
+ definition: Named("llvm.arm.neon.vabs.v4i32")
},
"abs_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::F32x2]; &INPUTS },
"qabs_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vsqabs.v8i8")
+ definition: Named("llvm.arm.neon.vsqabs.v8i8")
},
"qabs_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vsqabs.v4i16")
+ definition: Named("llvm.arm.neon.vsqabs.v4i16")
},
"qabs_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vsqabs.v2i32")
+ definition: Named("llvm.arm.neon.vsqabs.v2i32")
},
"qabsq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vsqabs.v16i8")
+ definition: Named("llvm.arm.neon.vsqabs.v16i8")
},
"qabsq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vsqabs.v8i16")
+ definition: Named("llvm.arm.neon.vsqabs.v8i16")
},
"qabsq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vsqabs.v4i32")
+ definition: Named("llvm.arm.neon.vsqabs.v4i32")
},
"qneg_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vsqneg.v8i8")
+ definition: Named("llvm.arm.neon.vsqneg.v8i8")
},
"qneg_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vsqneg.v4i16")
+ definition: Named("llvm.arm.neon.vsqneg.v4i16")
},
"qneg_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vsqneg.v2i32")
+ definition: Named("llvm.arm.neon.vsqneg.v2i32")
},
"qnegq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vsqneg.v16i8")
+ definition: Named("llvm.arm.neon.vsqneg.v16i8")
},
"qnegq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vsqneg.v8i16")
+ definition: Named("llvm.arm.neon.vsqneg.v8i16")
},
"qnegq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vsqneg.v4i32")
+ definition: Named("llvm.arm.neon.vsqneg.v4i32")
},
"clz_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x8]; &INPUTS },
"cls_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vcls.v8i8")
+ definition: Named("llvm.arm.neon.vcls.v8i8")
},
"cls_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vcls.v8i8")
+ definition: Named("llvm.arm.neon.vcls.v8i8")
},
"cls_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vcls.v4i16")
+ definition: Named("llvm.arm.neon.vcls.v4i16")
},
"cls_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vcls.v4i16")
+ definition: Named("llvm.arm.neon.vcls.v4i16")
},
"cls_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vcls.v2i32")
+ definition: Named("llvm.arm.neon.vcls.v2i32")
},
"cls_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vcls.v2i32")
+ definition: Named("llvm.arm.neon.vcls.v2i32")
},
"clsq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vcls.v16i8")
+ definition: Named("llvm.arm.neon.vcls.v16i8")
},
"clsq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vcls.v16i8")
+ definition: Named("llvm.arm.neon.vcls.v16i8")
},
"clsq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vcls.v8i16")
+ definition: Named("llvm.arm.neon.vcls.v8i16")
},
"clsq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vcls.v8i16")
+ definition: Named("llvm.arm.neon.vcls.v8i16")
},
"clsq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vcls.v4i32")
+ definition: Named("llvm.arm.neon.vcls.v4i32")
},
"clsq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vcls.v4i32")
+ definition: Named("llvm.arm.neon.vcls.v4i32")
},
"cnt_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x8]; &INPUTS },
"recpe_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vrecpe.v2i32")
+ definition: Named("llvm.arm.neon.vrecpe.v2i32")
},
"recpe_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vrecpe.v2f32")
+ definition: Named("llvm.arm.neon.vrecpe.v2f32")
},
"recpeq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vrecpe.v4i32")
+ definition: Named("llvm.arm.neon.vrecpe.v4i32")
},
"recpeq_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
output: &::F32x4,
- definition: Named("llvm.neon.vrecpe.v4f32")
+ definition: Named("llvm.arm.neon.vrecpe.v4f32")
},
"recps_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vfrecps.v2f32")
+ definition: Named("llvm.arm.neon.vfrecps.v2f32")
},
"recpsq_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
output: &::F32x4,
- definition: Named("llvm.neon.vfrecps.v4f32")
+ definition: Named("llvm.arm.neon.vfrecps.v4f32")
},
"sqrt_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::F32x2]; &INPUTS },
"rsqrte_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vrsqrte.v2i32")
+ definition: Named("llvm.arm.neon.vrsqrte.v2i32")
},
"rsqrte_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vrsqrte.v2f32")
+ definition: Named("llvm.arm.neon.vrsqrte.v2f32")
},
"rsqrteq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vrsqrte.v4i32")
+ definition: Named("llvm.arm.neon.vrsqrte.v4i32")
},
"rsqrteq_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
output: &::F32x4,
- definition: Named("llvm.neon.vrsqrte.v4f32")
+ definition: Named("llvm.arm.neon.vrsqrte.v4f32")
},
"rsqrts_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vrsqrts.v2f32")
+ definition: Named("llvm.arm.neon.vrsqrts.v2f32")
},
"rsqrtsq_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
output: &::F32x4,
- definition: Named("llvm.neon.vrsqrts.v4f32")
+ definition: Named("llvm.arm.neon.vrsqrts.v4f32")
},
"bsl_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vbsl.v8i8")
+ definition: Named("llvm.arm.neon.vbsl.v8i8")
},
"bsl_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vbsl.v8i8")
+ definition: Named("llvm.arm.neon.vbsl.v8i8")
},
"bsl_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vbsl.v4i16")
+ definition: Named("llvm.arm.neon.vbsl.v4i16")
},
"bsl_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vbsl.v4i16")
+ definition: Named("llvm.arm.neon.vbsl.v4i16")
},
"bsl_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vbsl.v2i32")
+ definition: Named("llvm.arm.neon.vbsl.v2i32")
},
"bsl_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vbsl.v2i32")
+ definition: Named("llvm.arm.neon.vbsl.v2i32")
},
"bsl_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::I64x1]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vbsl.v1i64")
+ definition: Named("llvm.arm.neon.vbsl.v1i64")
},
"bsl_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::U64x1]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vbsl.v1i64")
+ definition: Named("llvm.arm.neon.vbsl.v1i64")
},
"bslq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vbsl.v16i8")
+ definition: Named("llvm.arm.neon.vbsl.v16i8")
},
"bslq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vbsl.v16i8")
+ definition: Named("llvm.arm.neon.vbsl.v16i8")
},
"bslq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vbsl.v8i16")
+ definition: Named("llvm.arm.neon.vbsl.v8i16")
},
"bslq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vbsl.v8i16")
+ definition: Named("llvm.arm.neon.vbsl.v8i16")
},
"bslq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vbsl.v4i32")
+ definition: Named("llvm.arm.neon.vbsl.v4i32")
},
"bslq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vbsl.v4i32")
+ definition: Named("llvm.arm.neon.vbsl.v4i32")
},
"bslq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::I64x2]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vbsl.v2i64")
+ definition: Named("llvm.arm.neon.vbsl.v2i64")
},
"bslq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vbsl.v2i64")
+ definition: Named("llvm.arm.neon.vbsl.v2i64")
},
"padd_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vpadd.v8i8")
+ definition: Named("llvm.arm.neon.vpadd.v8i8")
},
"padd_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vpadd.v8i8")
+ definition: Named("llvm.arm.neon.vpadd.v8i8")
},
"padd_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vpadd.v4i16")
+ definition: Named("llvm.arm.neon.vpadd.v4i16")
},
"padd_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vpadd.v4i16")
+ definition: Named("llvm.arm.neon.vpadd.v4i16")
},
"padd_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vpadd.v2i32")
+ definition: Named("llvm.arm.neon.vpadd.v2i32")
},
"padd_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vpadd.v2i32")
+ definition: Named("llvm.arm.neon.vpadd.v2i32")
},
"padd_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vpadd.v2f32")
+ definition: Named("llvm.arm.neon.vpadd.v2f32")
},
"paddl_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x8]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vpaddls.v4i16.v8i8")
+ definition: Named("llvm.arm.neon.vpaddls.v4i16.v8i8")
},
"paddl_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U8x8]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vpaddlu.v4i16.v8i8")
+ definition: Named("llvm.arm.neon.vpaddlu.v4i16.v8i8")
},
"paddl_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x4]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vpaddls.v2i32.v4i16")
+ definition: Named("llvm.arm.neon.vpaddls.v2i32.v4i16")
},
"paddl_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U16x4]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vpaddlu.v2i32.v4i16")
+ definition: Named("llvm.arm.neon.vpaddlu.v2i32.v4i16")
},
"paddl_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x2]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vpaddls.v1i64.v2i32")
+ definition: Named("llvm.arm.neon.vpaddls.v1i64.v2i32")
},
"paddl_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x2]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vpaddlu.v1i64.v2i32")
+ definition: Named("llvm.arm.neon.vpaddlu.v1i64.v2i32")
},
"paddlq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vpaddls.v8i16.v16i8")
+ definition: Named("llvm.arm.neon.vpaddls.v8i16.v16i8")
},
"paddlq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U8x16]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vpaddlu.v8i16.v16i8")
+ definition: Named("llvm.arm.neon.vpaddlu.v8i16.v16i8")
},
"paddlq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I16x8]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vpaddls.v4i32.v8i16")
+ definition: Named("llvm.arm.neon.vpaddls.v4i32.v8i16")
},
"paddlq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U16x8]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vpaddlu.v4i32.v8i16")
+ definition: Named("llvm.arm.neon.vpaddlu.v4i32.v8i16")
},
"paddlq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vpaddls.v2i64.v4i32")
+ definition: Named("llvm.arm.neon.vpaddls.v2i64.v4i32")
},
"paddlq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 1] = [&::U32x4]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vpaddlu.v2i64.v4i32")
+ definition: Named("llvm.arm.neon.vpaddlu.v2i64.v4i32")
},
"padal_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I8x8]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vpadals.v4i16.v4i16")
+ definition: Named("llvm.arm.neon.vpadals.v4i16.v4i16")
},
"padal_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U8x8]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vpadalu.v4i16.v4i16")
+ definition: Named("llvm.arm.neon.vpadalu.v4i16.v4i16")
},
"padal_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I16x4]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vpadals.v2i32.v2i32")
+ definition: Named("llvm.arm.neon.vpadals.v2i32.v2i32")
},
"padal_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U16x4]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vpadalu.v2i32.v2i32")
+ definition: Named("llvm.arm.neon.vpadalu.v2i32.v2i32")
},
"padal_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x1, &::I32x2]; &INPUTS },
output: &::I64x1,
- definition: Named("llvm.neon.vpadals.v1i64.v1i64")
+ definition: Named("llvm.arm.neon.vpadals.v1i64.v1i64")
},
"padal_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x1, &::U32x2]; &INPUTS },
output: &::U64x1,
- definition: Named("llvm.neon.vpadalu.v1i64.v1i64")
+ definition: Named("llvm.arm.neon.vpadalu.v1i64.v1i64")
},
"padalq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I8x16]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vpadals.v8i16.v8i16")
+ definition: Named("llvm.arm.neon.vpadals.v8i16.v8i16")
},
"padalq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U8x16]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vpadalu.v8i16.v8i16")
+ definition: Named("llvm.arm.neon.vpadalu.v8i16.v8i16")
},
"padalq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I16x8]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vpadals.v4i32.v4i32")
+ definition: Named("llvm.arm.neon.vpadals.v4i32.v4i32")
},
"padalq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U16x8]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vpadalu.v4i32.v4i32")
+ definition: Named("llvm.arm.neon.vpadalu.v4i32.v4i32")
},
"padalq_s64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I64x2, &::I32x4]; &INPUTS },
output: &::I64x2,
- definition: Named("llvm.neon.vpadals.v2i64.v2i64")
+ definition: Named("llvm.arm.neon.vpadals.v2i64.v2i64")
},
"padalq_u64" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U32x4]; &INPUTS },
output: &::U64x2,
- definition: Named("llvm.neon.vpadalu.v2i64.v2i64")
+ definition: Named("llvm.arm.neon.vpadalu.v2i64.v2i64")
},
"pmax_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vpmaxs.v8i8")
+ definition: Named("llvm.arm.neon.vpmaxs.v8i8")
},
"pmax_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vpmaxu.v8i8")
+ definition: Named("llvm.arm.neon.vpmaxu.v8i8")
},
"pmax_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vpmaxs.v4i16")
+ definition: Named("llvm.arm.neon.vpmaxs.v4i16")
},
"pmax_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vpmaxu.v4i16")
+ definition: Named("llvm.arm.neon.vpmaxu.v4i16")
},
"pmax_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vpmaxs.v2i32")
+ definition: Named("llvm.arm.neon.vpmaxs.v2i32")
},
"pmax_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vpmaxu.v2i32")
+ definition: Named("llvm.arm.neon.vpmaxu.v2i32")
},
"pmax_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vpmaxf.v2f32")
+ definition: Named("llvm.arm.neon.vpmaxf.v2f32")
},
"pmin_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vpmins.v8i8")
+ definition: Named("llvm.arm.neon.vpmins.v8i8")
},
"pmin_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vpminu.v8i8")
+ definition: Named("llvm.arm.neon.vpminu.v8i8")
},
"pmin_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x4, &::I16x4]; &INPUTS },
output: &::I16x4,
- definition: Named("llvm.neon.vpmins.v4i16")
+ definition: Named("llvm.arm.neon.vpmins.v4i16")
},
"pmin_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x4, &::U16x4]; &INPUTS },
output: &::U16x4,
- definition: Named("llvm.neon.vpminu.v4i16")
+ definition: Named("llvm.arm.neon.vpminu.v4i16")
},
"pmin_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x2, &::I32x2]; &INPUTS },
output: &::I32x2,
- definition: Named("llvm.neon.vpmins.v2i32")
+ definition: Named("llvm.arm.neon.vpmins.v2i32")
},
"pmin_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x2, &::U32x2]; &INPUTS },
output: &::U32x2,
- definition: Named("llvm.neon.vpminu.v2i32")
+ definition: Named("llvm.arm.neon.vpminu.v2i32")
},
"pmin_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x2, &::F32x2]; &INPUTS },
output: &::F32x2,
- definition: Named("llvm.neon.vpminf.v2f32")
+ definition: Named("llvm.arm.neon.vpminf.v2f32")
},
"pminq_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
output: &::I8x16,
- definition: Named("llvm.neon.vpmins.v16i8")
+ definition: Named("llvm.arm.neon.vpmins.v16i8")
},
"pminq_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
output: &::U8x16,
- definition: Named("llvm.neon.vpminu.v16i8")
+ definition: Named("llvm.arm.neon.vpminu.v16i8")
},
"pminq_s16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
output: &::I16x8,
- definition: Named("llvm.neon.vpmins.v8i16")
+ definition: Named("llvm.arm.neon.vpmins.v8i16")
},
"pminq_u16" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
output: &::U16x8,
- definition: Named("llvm.neon.vpminu.v8i16")
+ definition: Named("llvm.arm.neon.vpminu.v8i16")
},
"pminq_s32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
output: &::I32x4,
- definition: Named("llvm.neon.vpmins.v4i32")
+ definition: Named("llvm.arm.neon.vpmins.v4i32")
},
"pminq_u32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
output: &::U32x4,
- definition: Named("llvm.neon.vpminu.v4i32")
+ definition: Named("llvm.arm.neon.vpminu.v4i32")
},
"pminq_f32" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
output: &::F32x4,
- definition: Named("llvm.neon.vpminf.v4f32")
+ definition: Named("llvm.arm.neon.vpminf.v4f32")
},
"tbl1_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::I8x8, &::U8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vtbl1")
+ definition: Named("llvm.arm.neon.vtbl1")
},
"tbl1_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vtbl1")
+ definition: Named("llvm.arm.neon.vtbl1")
},
"tbx1_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 3] = [&::I8x8, &::I8x8, &::U8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vtbx1")
+ definition: Named("llvm.arm.neon.vtbx1")
},
"tbx1_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 3] = [&::U8x8, &::U8x8, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vtbx1")
+ definition: Named("llvm.arm.neon.vtbx1")
},
"tbl2_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [{ static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vtbl2")
+ definition: Named("llvm.arm.neon.vtbl2")
},
"tbl2_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [{ static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vtbl2")
+ definition: Named("llvm.arm.neon.vtbl2")
},
"tbx2_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [{ static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 2] = [&::I8x8, &::I8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vtbx2")
+ definition: Named("llvm.arm.neon.vtbx2")
},
"tbx2_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [{ static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 2] = [&::U8x8, &::U8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vtbx2")
+ definition: Named("llvm.arm.neon.vtbx2")
},
"tbl3_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [{ static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 3] = [&::I8x8, &::I8x8, &::I8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vtbl3")
+ definition: Named("llvm.arm.neon.vtbl3")
},
"tbl3_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [{ static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 3] = [&::U8x8, &::U8x8, &::U8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vtbl3")
+ definition: Named("llvm.arm.neon.vtbl3")
},
"tbx3_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 3] = [&::I8x8, { static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 3] = [&::I8x8, &::I8x8, &::I8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vtbx3")
+ definition: Named("llvm.arm.neon.vtbx3")
},
"tbx3_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 3] = [&::U8x8, { static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 3] = [&::U8x8, &::U8x8, &::U8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vtbx3")
+ definition: Named("llvm.arm.neon.vtbx3")
},
"tbl4_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [{ static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 4] = [&::I8x8, &::I8x8, &::I8x8, &::I8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vtbl4")
+ definition: Named("llvm.arm.neon.vtbl4")
},
"tbl4_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 2] = [{ static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 4] = [&::U8x8, &::U8x8, &::U8x8, &::U8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vtbl4")
+ definition: Named("llvm.arm.neon.vtbl4")
},
"tbx4_s8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 3] = [&::I8x8, { static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 4] = [&::I8x8, &::I8x8, &::I8x8, &::I8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::I8x8,
- definition: Named("llvm.neon.vtbx4")
+ definition: Named("llvm.arm.neon.vtbx4")
},
"tbx4_u8" => Intrinsic {
inputs: { static INPUTS: [&'static Type; 3] = [&::U8x8, { static AGG: Type = Type::Aggregate(true, { static PARTS: [&'static Type; 4] = [&::U8x8, &::U8x8, &::U8x8, &::U8x8]; &PARTS }); &AGG }, &::U8x8]; &INPUTS },
output: &::U8x8,
- definition: Named("llvm.neon.vtbx4")
+ definition: Named("llvm.arm.neon.vtbx4")
},
_ => return None,
})
-> Result<Option<Rc<SyntaxExtension>>, Determinacy> {
let def = match invoc.kind {
InvocationKind::Attr { attr: None, .. } => return Ok(None),
- _ => match self.resolve_invoc_to_def(invoc, scope, force) {
- Ok(def) => def,
- Err(determinacy) => return Err(determinacy),
- },
+ _ => self.resolve_invoc_to_def(invoc, scope, force)?,
};
self.macro_defs.insert(invoc.expansion_data.mark, def.def_id());
return r;
}
-// The third parameter is for an env vars, used to set up the path for MSVC
-// to find its DLLs
+// The third parameter is for env vars, used on windows to set up the
+// path for MSVC to find its DLLs, and gcc to find its bundled
+// toolchain
pub fn get_linker(sess: &Session) -> (String, Command, Vec<(OsString, OsString)>) {
+ let envs = vec![("PATH".into(), command_path(sess))];
+
if let Some(ref linker) = sess.opts.cg.linker {
- (linker.clone(), Command::new(linker), vec![])
+ (linker.clone(), Command::new(linker), envs)
} else if sess.target.target.options.is_like_msvc {
let (cmd, envs) = msvc_link_exe_cmd(sess);
("link.exe".to_string(), cmd, envs)
} else {
- (sess.target.target.options.linker.clone(),
- Command::new(&sess.target.target.options.linker), vec![])
+ let linker = &sess.target.target.options.linker;
+ (linker.clone(), Command::new(&linker), envs)
}
}
})
}
-fn command_path(sess: &Session, extra: Option<PathBuf>) -> OsString {
+fn command_path(sess: &Session) -> OsString {
// The compiler's sysroot often has some bundled tools, so add it to the
// PATH for the child.
let mut new_path = sess.host_filesearch(PathKind::All)
if let Some(path) = env::var_os("PATH") {
new_path.extend(env::split_paths(&path));
}
- new_path.extend(extra);
env::join_paths(new_path).unwrap()
}
src: input.map(|p| p.to_path_buf()),
lib_search_paths: archive_search_paths(sess),
ar_prog: get_ar_prog(sess),
- command_path: command_path(sess, None),
+ command_path: command_path(sess),
}
}
// The invocations of cc share some flags across platforms
let (pname, mut cmd, envs) = get_linker(sess);
- // This will set PATH on MSVC
+ // This will set PATH on windows
cmd.envs(envs);
let root = sess.target_filesearch(PathKind::Native).get_lib_path();
let a = base::from_immediate(bcx, a);
let b = base::from_immediate(bcx, b);
- bcx.store(a, bcx.struct_gep(lldest, ix0), f_align);
- bcx.store(b, bcx.struct_gep(lldest, ix1), f_align);
+
+ // See comment above about zero-sized values.
+ let (a_zst, b_zst) = common::type_pair_fields(bcx.ccx, operand.ty)
+ .map_or((false, false), |[a_ty, b_ty]| {
+ (common::type_is_zero_size(bcx.ccx, a_ty),
+ common::type_is_zero_size(bcx.ccx, b_ty))
+ });
+
+ if !a_zst {
+ bcx.store(a, bcx.struct_gep(lldest, ix0), f_align);
+ }
+ if !b_zst {
+ bcx.store(b, bcx.struct_gep(lldest, ix1), f_align);
+ }
}
}
}
// overloaded lvalue ops, and will be fixed by them in order to get
// the correct region.
let mut source = self.node_ty(expr.id);
- if let Some(adjustments) = self.tables.borrow_mut().adjustments.get_mut(&expr.id) {
+ // Do not mutate adjustments in place, but rather take them,
+ // and replace them after mutating them, to avoid having the
+ // tables borrowed during (`deref_mut`) method resolution.
+ let previous_adjustments = self.tables.borrow_mut().adjustments.remove(&expr.id);
+ if let Some(mut adjustments) = previous_adjustments {
let pref = LvaluePreference::PreferMutLvalue;
- for adjustment in adjustments {
+ for adjustment in &mut adjustments {
if let Adjust::Deref(Some(ref mut deref)) = adjustment.kind {
if let Some(ok) = self.try_overloaded_deref(expr.span, source, pref) {
let method = self.register_infer_ok_obligations(ok);
}
source = adjustment.target;
}
+ self.tables.borrow_mut().adjustments.insert(expr.id, adjustments);
}
match expr.node {
use syntax::ptr::P;
use syntax::symbol::{Symbol, InternedString, keywords};
use syntax::util::lev_distance::find_best_match_for_name;
-use syntax_pos::{self, BytePos, Span, DUMMY_SP};
+use syntax_pos::{self, BytePos, Span};
use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
use rustc::hir::itemlikevisit::ItemLikeVisitor;
value)
}
- pub fn write_nil(&self, node_id: ast::NodeId) {
- self.write_ty(node_id, self.tcx.mk_nil());
- }
-
- pub fn write_error(&self, node_id: ast::NodeId) {
- self.write_ty(node_id, self.tcx.types.err);
- }
-
pub fn require_type_meets(&self,
ty: Ty<'tcx>,
span: Span,
pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
// Don't do all the complex logic below for DeclItem.
match stmt.node {
- hir::StmtDecl(ref decl, id) => {
+ hir::StmtDecl(ref decl, _) => {
match decl.node {
hir::DeclLocal(_) => {}
hir::DeclItem(_) => {
- self.write_nil(id);
return;
}
}
self.diverges.set(Diverges::Maybe);
self.has_errors.set(false);
- let (node_id, _span) = match stmt.node {
- hir::StmtDecl(ref decl, id) => {
- let span = match decl.node {
+ match stmt.node {
+ hir::StmtDecl(ref decl, _) => {
+ match decl.node {
hir::DeclLocal(ref l) => {
self.check_decl_local(&l);
- l.span
}
- hir::DeclItem(_) => {/* ignore for now */
- DUMMY_SP
- }
- };
- (id, span)
+ hir::DeclItem(_) => {/* ignore for now */}
+ }
}
- hir::StmtExpr(ref expr, id) => {
+ hir::StmtExpr(ref expr, _) => {
// Check with expected type of ()
self.check_expr_has_type(&expr, self.tcx.mk_nil());
- (id, expr.span)
}
- hir::StmtSemi(ref expr, id) => {
+ hir::StmtSemi(ref expr, _) => {
self.check_expr(&expr);
- (id, expr.span)
}
- };
-
- if self.has_errors.get() {
- self.write_error(node_id);
- } else {
- self.write_nil(node_id);
}
// Combine the diverging and has_error flags.
NestedVisitorMap::None
}
- fn visit_stmt(&mut self, s: &'gcx hir::Stmt) {
- self.visit_node_id(s.span, s.node.id());
- intravisit::walk_stmt(self, s);
- }
-
fn visit_expr(&mut self, e: &'gcx hir::Expr) {
self.fix_scalar_builtin_expr(e);
pub fn is_ty_method(&self) -> bool {
self.type_() == ItemType::TyMethod
}
+ pub fn is_typedef(&self) -> bool {
+ self.type_() == ItemType::Typedef
+ }
pub fn is_primitive(&self) -> bool {
self.type_() == ItemType::Primitive
}
where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true },
type_ = t.type_)?;
- document(w, cx, it)
+ document(w, cx, it)?;
+
+ // Render any items associated directly to this alias, as otherwise they
+ // won't be visible anywhere in the docs. It would be nice to also show
+ // associated items from the aliased type (see discussion in #32077), but
+ // we need #14072 to make sense of the generics.
+ render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
impl<'a> fmt::Display for Sidebar<'a> {
let parentlen = cx.current.len() - if it.is_mod() {1} else {0};
if it.is_struct() || it.is_trait() || it.is_primitive() || it.is_union()
- || it.is_enum() || it.is_mod()
+ || it.is_enum() || it.is_mod() || it.is_typedef()
{
write!(fmt, "<p class='location'>")?;
match it.inner {
clean::PrimitiveItem(..) => write!(fmt, "Primitive Type ")?,
clean::UnionItem(..) => write!(fmt, "Union ")?,
clean::EnumItem(..) => write!(fmt, "Enum ")?,
+ clean::TypedefItem(..) => write!(fmt, "Type Definition ")?,
clean::ModuleItem(..) => if it.is_crate() {
write!(fmt, "Crate ")?;
} else {
clean::PrimitiveItem(ref p) => sidebar_primitive(fmt, it, p)?,
clean::UnionItem(ref u) => sidebar_union(fmt, it, u)?,
clean::EnumItem(ref e) => sidebar_enum(fmt, it, e)?,
+ clean::TypedefItem(ref t, _) => sidebar_typedef(fmt, it, t)?,
clean::ModuleItem(ref m) => sidebar_module(fmt, it, &m.items)?,
_ => (),
}
Ok(())
}
+fn sidebar_typedef(fmt: &mut fmt::Formatter, it: &clean::Item,
+ _t: &clean::Typedef) -> fmt::Result {
+ let sidebar = sidebar_assoc_items(it);
+
+ if !sidebar.is_empty() {
+ write!(fmt, "<div class=\"block items\"><ul>{}</ul></div>", sidebar)?;
+ }
+ Ok(())
+}
+
fn sidebar_union(fmt: &mut fmt::Formatter, it: &clean::Item,
u: &clean::Union) -> fmt::Result {
let mut sidebar = String::new();
/// Failure to call [`from_raw`] will lead to a memory leak.
///
/// [`from_raw`]: #method.from_raw
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ffi::CString;
+ ///
+ /// let c_string = CString::new("foo").unwrap();
+ ///
+ /// let ptr = c_string.into_raw();
+ ///
+ /// unsafe {
+ /// assert_eq!(b'f', *ptr as u8);
+ /// assert_eq!(b'o', *ptr.offset(1) as u8);
+ /// assert_eq!(b'o', *ptr.offset(2) as u8);
+ /// assert_eq!(b'\0', *ptr.offset(3) as u8);
+ ///
+ /// // retake pointer to free memory
+ /// let _ = CString::from_raw(ptr);
+ /// }
+ /// ```
#[stable(feature = "cstr_memory", since = "1.4.0")]
pub fn into_raw(self) -> *mut c_char {
Box::into_raw(self.into_inner()) as *mut c_char
///
/// The returned buffer does **not** contain the trailing nul separator and
/// it is guaranteed to not have any interior nul bytes.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ffi::CString;
+ ///
+ /// let c_string = CString::new("foo").unwrap();
+ /// let bytes = c_string.into_bytes();
+ /// assert_eq!(bytes, vec![b'f', b'o', b'o']);
+ /// ```
#[stable(feature = "cstring_into", since = "1.7.0")]
pub fn into_bytes(self) -> Vec<u8> {
let mut vec = self.into_inner().into_vec();
/// includes the trailing nul byte.
///
/// [`into_bytes`]: #method.into_bytes
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ffi::CString;
+ ///
+ /// let c_string = CString::new("foo").unwrap();
+ /// let bytes = c_string.into_bytes_with_nul();
+ /// assert_eq!(bytes, vec![b'f', b'o', b'o', b'\0']);
+ /// ```
#[stable(feature = "cstring_into", since = "1.7.0")]
pub fn into_bytes_with_nul(self) -> Vec<u8> {
self.into_inner().into_vec()
///
/// The returned slice does **not** contain the trailing nul separator and
/// it is guaranteed to not have any interior nul bytes.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ffi::CString;
+ ///
+ /// let c_string = CString::new("foo").unwrap();
+ /// let bytes = c_string.as_bytes();
+ /// assert_eq!(bytes, &[b'f', b'o', b'o']);
+ /// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn as_bytes(&self) -> &[u8] {
&self.inner[..self.inner.len() - 1]
/// includes the trailing nul byte.
///
/// [`as_bytes`]: #method.as_bytes
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ffi::CString;
+ ///
+ /// let c_string = CString::new("foo").unwrap();
+ /// let bytes = c_string.as_bytes_with_nul();
+ /// assert_eq!(bytes, &[b'f', b'o', b'o', b'\0']);
+ /// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn as_bytes_with_nul(&self) -> &[u8] {
&self.inner
fn $test_name() {
#![test]
assert_eq!((0 as $T).checked_next_power_of_two(), Some(1));
- assert!(($T::MAX / 2).checked_next_power_of_two().is_some());
+ let smax = $T::MAX >> 1;
+ assert_eq!(smax.checked_next_power_of_two(), Some(smax+1));
+ assert_eq!((smax + 1).checked_next_power_of_two(), Some(smax + 1));
+ assert_eq!((smax + 2).checked_next_power_of_two(), None);
assert_eq!(($T::MAX - 1).checked_next_power_of_two(), None);
assert_eq!($T::MAX.checked_next_power_of_two(), None);
let mut next_power = 1;
/// This is a "helper marker trait" used to provide impl blocks for the
/// `UnwindSafe` trait, for more information see that documentation.
#[stable(feature = "catch_unwind", since = "1.9.0")]
-#[rustc_on_unimplemented = "the type {Self} contains interior mutability \
+#[rustc_on_unimplemented = "the type {Self} may contain interior mutability \
and a reference may not be safely transferrable \
across a catch_unwind boundary"]
pub trait RefUnwindSafe {}
use ffi::OsStr;
use fmt;
+use fs;
use io;
use path::Path;
use str;
/// .expect("ls command failed to start");
/// ```
#[stable(feature = "process", since = "1.0.0")]
- pub fn stdin(&mut self, cfg: Stdio) -> &mut Command {
- self.inner.stdin(cfg.0);
+ pub fn stdin<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command {
+ self.inner.stdin(cfg.into().0);
self
}
/// .expect("ls command failed to start");
/// ```
#[stable(feature = "process", since = "1.0.0")]
- pub fn stdout(&mut self, cfg: Stdio) -> &mut Command {
- self.inner.stdout(cfg.0);
+ pub fn stdout<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command {
+ self.inner.stdout(cfg.into().0);
self
}
/// .expect("ls command failed to start");
/// ```
#[stable(feature = "process", since = "1.0.0")]
- pub fn stderr(&mut self, cfg: Stdio) -> &mut Command {
- self.inner.stderr(cfg.0);
+ pub fn stderr<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command {
+ self.inner.stderr(cfg.into().0);
self
}
}
}
+#[stable(feature = "stdio_from", since = "1.20.0")]
+impl From<ChildStdin> for Stdio {
+ fn from(child: ChildStdin) -> Stdio {
+ Stdio::from_inner(child.into_inner().into())
+ }
+}
+
+#[stable(feature = "stdio_from", since = "1.20.0")]
+impl From<ChildStdout> for Stdio {
+ fn from(child: ChildStdout) -> Stdio {
+ Stdio::from_inner(child.into_inner().into())
+ }
+}
+
+#[stable(feature = "stdio_from", since = "1.20.0")]
+impl From<ChildStderr> for Stdio {
+ fn from(child: ChildStderr) -> Stdio {
+ Stdio::from_inner(child.into_inner().into())
+ }
+}
+
+#[stable(feature = "stdio_from", since = "1.20.0")]
+impl From<fs::File> for Stdio {
+ fn from(file: fs::File) -> Stdio {
+ Stdio::from_inner(file.into_inner().into())
+ }
+}
+
/// Describes the result of a process after it has terminated.
///
/// This `struct` is used to represent the exit status of a child process.
}
}
+impl From<AnonPipe> for Stdio {
+ fn from(pipe: AnonPipe) -> Stdio {
+ Stdio::Fd(pipe.into_fd())
+ }
+}
+
+impl From<File> for Stdio {
+ fn from(file: File) -> Stdio {
+ Stdio::Fd(file.into_fd())
+ }
+}
+
impl ChildStdio {
fn fd(&self) -> Option<usize> {
match *self {
}
}
+impl From<AnonPipe> for Stdio {
+ fn from(pipe: AnonPipe) -> Stdio {
+ Stdio::Fd(pipe.into_fd())
+ }
+}
+
+impl From<File> for Stdio {
+ fn from(file: File) -> Stdio {
+ Stdio::Fd(file.into_fd())
+ }
+}
+
impl ChildStdio {
pub fn fd(&self) -> Option<c_int> {
match *self {
}
}
+impl From<AnonPipe> for Stdio {
+ fn from(pipe: AnonPipe) -> Stdio {
+ Stdio::Handle(pipe.into_handle())
+ }
+}
+
+impl From<File> for Stdio {
+ fn from(file: File) -> Stdio {
+ Stdio::Handle(file.into_handle())
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
// Processes
////////////////////////////////////////////////////////////////////////////////
let mac = respan(lo.to(self.prev_span), Mac_ { path: pth, tts: tts });
(keywords::Invalid.ident(), ast::TraitItemKind::Macro(mac))
} else {
- let (constness, unsafety, abi) = match self.parse_fn_front_matter() {
- Ok(cua) => cua,
- Err(e) => return Err(e),
- };
+ let (constness, unsafety, abi) = self.parse_fn_front_matter()?;
let ident = self.parse_ident()?;
let mut generics = self.parse_generics()?;
impl<T: Decodable> Decodable for P<[T]> {
fn decode<D: Decoder>(d: &mut D) -> Result<P<[T]>, D::Error> {
- Ok(P::from_vec(match Decodable::decode(d) {
- Ok(t) => t,
- Err(e) => return Err(e)
- }))
+ Ok(P::from_vec(Decodable::decode(d)?))
}
}
// The interner in thread-local, so `Symbol` shouldn't move between threads.
impl !Send for Symbol { }
+impl !Sync for Symbol { }
impl Symbol {
/// Maps a string to its interned representation.
#![crate_type = "lib"]
use std::marker::PhantomData;
-
+#[derive(Copy, Clone)]
struct Zst { phantom: PhantomData<Zst> }
// CHECK-LABEL: @mir
+// CHECK-NOT: store{{.*}}undef
#[no_mangle]
-fn mir(){
- // CHECK-NOT: getelementptr
- // CHECK-NOT: store{{.*}}undef
+fn mir() {
let x = Zst { phantom: PhantomData };
+ let y = (x, 0);
+ drop(y);
+ drop((0, x));
}
--- /dev/null
+// Copyright 2017 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.
+
+// compile-flags:-D bogus
+
+// error-pattern:E0602
+// error-pattern:requested on the command line with `-D bogus`
+
+fn main() {}
const A: UnsafeCell<usize> = UnsafeCell::new(1);
const B: &'static UnsafeCell<usize> = &A;
-//~^ ERROR: cannot borrow a constant which contains interior mutability
+//~^ ERROR: cannot borrow a constant which may contain interior mutability
struct C { a: UnsafeCell<usize> }
const D: C = C { a: UnsafeCell::new(1) };
const E: &'static UnsafeCell<usize> = &D.a;
-//~^ ERROR: cannot borrow a constant which contains interior mutability
+//~^ ERROR: cannot borrow a constant which may contain interior mutability
const F: &'static C = &D;
-//~^ ERROR: cannot borrow a constant which contains interior mutability
+//~^ ERROR: cannot borrow a constant which may contain interior mutability
fn main() {}
fn parse_type(iter: Box<Iterator<Item=&str>+'static>) -> &str { iter.next() }
//~^ ERROR missing lifetime specifier [E0106]
-//~^^ HELP 2 elided lifetimes
+//~^^ HELP 2 lifetimes
fn parse_type_2(iter: fn(&u8)->&u8) -> &str { iter() }
//~^ ERROR missing lifetime specifier [E0106]
fn f(a: &S, b: i32) -> &i32 {
//~^ ERROR missing lifetime specifier [E0106]
-//~^^ HELP does not say which one of `a`'s 2 elided lifetimes it is borrowed from
+//~^^ HELP does not say which one of `a`'s 2 lifetimes it is borrowed from
panic!();
}
fn g(a: &S, b: bool, c: &i32) -> &i32 {
//~^ ERROR missing lifetime specifier [E0106]
-//~^^ HELP does not say whether it is borrowed from one of `a`'s 2 elided lifetimes or `c`
+//~^^ HELP does not say whether it is borrowed from one of `a`'s 2 lifetimes or `c`
panic!();
}
fn h(a: &bool, b: bool, c: &S, d: &i32) -> &i32 {
//~^ ERROR missing lifetime specifier [E0106]
-//~^^ HELP does not say whether it is borrowed from `a`, one of `c`'s 2 elided lifetimes, or `d`
+//~^^ HELP does not say whether it is borrowed from `a`, one of `c`'s 2 lifetimes, or `d`
panic!();
}
// Lifetime annotation needed because we have two lifetimes: one as a parameter
// and one on the reference.
fn h(_x: &Foo) -> &isize { //~ ERROR missing lifetime specifier
-//~^ HELP the signature does not say which one of `_x`'s 2 elided lifetimes it is borrowed from
+//~^ HELP the signature does not say which one of `_x`'s 2 lifetimes it is borrowed from
panic!()
}
--- /dev/null
+// Copyright 2017 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.
+
+// ignore-cross-compile
+
+#![feature(rustc_private)]
+
+extern crate rustc_back;
+
+use std::env;
+use std::fs::File;
+use std::io;
+use std::io::{Read, Write};
+use std::process::{Command, Stdio};
+
+use rustc_back::tempdir::TempDir;
+
+fn main() {
+ if env::args().len() > 1 {
+ child().unwrap()
+ } else {
+ parent().unwrap()
+ }
+}
+
+fn parent() -> io::Result<()> {
+ let td = TempDir::new("foo").unwrap();
+ let input = td.path().join("input");
+ let output = td.path().join("output");
+
+ File::create(&input)?.write_all(b"foo\n")?;
+
+ // Set up this chain:
+ // $ me <file | me | me >file
+ // ... to duplicate each line 8 times total.
+
+ let mut child1 = Command::new(env::current_exe()?)
+ .arg("first")
+ .stdin(File::open(&input)?) // tests File::into()
+ .stdout(Stdio::piped())
+ .spawn()?;
+
+ let mut child3 = Command::new(env::current_exe()?)
+ .arg("third")
+ .stdin(Stdio::piped())
+ .stdout(File::create(&output)?) // tests File::into()
+ .spawn()?;
+
+ // Started out of order so we can test both `ChildStdin` and `ChildStdout`.
+ let mut child2 = Command::new(env::current_exe()?)
+ .arg("second")
+ .stdin(child1.stdout.take().unwrap()) // tests ChildStdout::into()
+ .stdout(child3.stdin.take().unwrap()) // tests ChildStdin::into()
+ .spawn()?;
+
+ assert!(child1.wait()?.success());
+ assert!(child2.wait()?.success());
+ assert!(child3.wait()?.success());
+
+ let mut data = String::new();
+ File::open(&output)?.read_to_string(&mut data)?;
+ for line in data.lines() {
+ assert_eq!(line, "foo");
+ }
+ assert_eq!(data.lines().count(), 8);
+ Ok(())
+}
+
+fn child() -> io::Result<()> {
+ // double everything
+ let mut input = vec![];
+ io::stdin().read_to_end(&mut input)?;
+ io::stdout().write_all(&input)?;
+ io::stdout().write_all(&input)?;
+ Ok(())
+}
Command::new(name)
.arg("--child")
.stdin(Stdio::inherit())
- .stdout(unsafe { FromRawFd::from_raw_fd(libc::STDERR_FILENO) })
- .stderr(unsafe { FromRawFd::from_raw_fd(libc::STDOUT_FILENO) })
+ .stdout(unsafe { Stdio::from_raw_fd(libc::STDERR_FILENO) })
+ .stderr(unsafe { Stdio::from_raw_fd(libc::STDOUT_FILENO) })
.spawn()
};
--- /dev/null
+// Copyright 2017 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.
+
+use std::ops::{Deref, DerefMut};
+
+struct CheckedDeref<T, F> {
+ value: T,
+ check: F
+}
+
+impl<F: Fn(&T) -> bool, T> Deref for CheckedDeref<T, F> {
+ type Target = T;
+ fn deref(&self) -> &T {
+ assert!((self.check)(&self.value));
+ &self.value
+ }
+}
+
+impl<F: Fn(&T) -> bool, T> DerefMut for CheckedDeref<T, F> {
+ fn deref_mut(&mut self) -> &mut T {
+ assert!((self.check)(&self.value));
+ &mut self.value
+ }
+}
+
+
+fn main() {
+ let mut v = CheckedDeref {
+ value: vec![0],
+ check: |v: &Vec<_>| !v.is_empty()
+ };
+ v.push(1);
+ assert_eq!(*v, vec![0, 1]);
+}
--- /dev/null
+// Copyright 2017 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.
+
+struct Foo<T>(T);
+
+struct IntoIter<T>(T);
+
+impl<'a, T: 'a> Iterator for IntoIter<T> {
+ type Item = ();
+
+ fn next(&mut self) -> Option<()> {
+ None
+ }
+}
+
+impl<T> IntoIterator for Foo<T> {
+ type Item = ();
+ type IntoIter = IntoIter<T>;
+
+ fn into_iter(self) -> IntoIter<T> {
+ IntoIter(self.0)
+ }
+}
+
+fn main() {}
fn evil_lincoln() { let _evil = println!("lincoln"); }
+fn dots() {
+ assert_eq!(String::from(".................................................."),
+ format!("{:?}", .. .. .. .. .. .. .. .. .. .. .. .. ..
+ .. .. .. .. .. .. .. .. .. .. .. ..));
+}
+
+fn you_eight() {
+ assert_eq!(8, {
+ macro_rules! u8 {
+ (u8) => {
+ mod u8 {
+ pub fn u8<'u8>(u8: &'u8 u8) -> &'u8 u8 {
+ "u8";
+ u8
+ }
+ }
+ };
+ }
+
+ u8!(u8);
+ let &u8: &u8 = u8::u8(&8u8);
+ u8
+ });
+}
+
+fn fishy() {
+ assert_eq!(String::from("><>"),
+ String::<>::from::<>("><>").chars::<>().rev::<>().collect::<String>());
+}
+
pub fn main() {
strange();
funny();
canttouchthis();
angrydome();
evil_lincoln();
+ dots();
+ you_eight();
+ fishy();
}
--- /dev/null
+// Copyright 2017 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.
+
+pub trait MyTrait {
+ fn method_on_mytrait() {}
+}
+
+pub struct MyStruct;
+
+impl MyStruct {
+ pub fn method_on_mystruct() {}
+}
+
+// @has typedef/type.MyAlias.html
+// @has - '//*[@class="impl"]//code' 'impl MyAlias'
+// @has - '//*[@class="impl"]//code' 'impl MyTrait for MyAlias'
+// @has - 'Alias docstring'
+// @has - '//*[@class="sidebar"]//p[@class="location"]' 'Type Definition MyAlias'
+// @has - '//*[@class="sidebar"]//a[@href="#methods"]' 'Methods'
+// @has - '//*[@class="sidebar"]//a[@href="#implementations"]' 'Trait Implementations'
+/// Alias docstring
+pub type MyAlias = MyStruct;
+
+impl MyAlias {
+ pub fn method_on_myalias() {}
+}
+
+impl MyTrait for MyAlias {}
--- /dev/null
+// Copyright 2017 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.
+
+fn foo() -> Box<Fn()> {
+ let num = 5;
+
+ let closure = || {
+ num += 1;
+ };
+
+ Box::new(closure)
+}
+
+fn main() {}
--- /dev/null
+error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`
+ --> $DIR/issue-26046-fn-mut.rs:14:19
+ |
+14 | let closure = || {
+ | ___________________^
+15 | | num += 1;
+16 | | };
+ | |_____^
+17 |
+18 | Box::new(closure)
+ | ----------------- the requirement to implement `Fn` derives from here
+ |
+note: closure is `FnMut` because it mutates the variable `num` here
+ --> $DIR/issue-26046-fn-mut.rs:15:9
+ |
+15 | num += 1;
+ | ^^^
+
+error: aborting due to previous error(s)
+
--- /dev/null
+// Copyright 2017 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.
+
+fn get_closure() -> Box<Fn() -> Vec<u8>> {
+ let vec = vec![1u8, 2u8];
+
+ let closure = move || {
+ vec
+ };
+
+ Box::new(closure)
+}
+
+fn main() {}
--- /dev/null
+error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
+ --> $DIR/issue-26046-fn-once.rs:14:19
+ |
+14 | let closure = move || {
+ | ___________________^
+15 | | vec
+16 | | };
+ | |_____^
+17 |
+18 | Box::new(closure)
+ | ----------------- the requirement to implement `Fn` derives from here
+ |
+note: closure is `FnOnce` because it moves the variable `vec` out of its environment
+ --> $DIR/issue-26046-fn-once.rs:15:9
+ |
+15 | vec
+ | ^^^
+
+error: aborting due to previous error(s)
+
--- /dev/null
+// Copyright 2017 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.
+
+use std::collections::HashMap;
+
+fn main() {
+ let dict: HashMap<i32, i32> = HashMap::new();
+ let debug_dump_dict = || {
+ for (key, value) in dict {
+ println!("{:?} - {:?}", key, value);
+ }
+ };
+ debug_dump_dict();
+ debug_dump_dict();
+ //~^ ERROR use of moved value: `debug_dump_dict`
+ //~| NOTE closure cannot be invoked more than once because it moves the
+ //~| variable `dict` out of its environment
+}
--- /dev/null
+error[E0382]: use of moved value: `debug_dump_dict`
+ --> $DIR/issue-42065.rs:21:5
+ |
+20 | debug_dump_dict();
+ | --------------- value moved here
+21 | debug_dump_dict();
+ | ^^^^^^^^^^^^^^^ value used here after move
+ |
+note: closure cannot be invoked more than once because it moves the variable `dict` out of its environment
+ --> $DIR/issue-42065.rs:16:29
+ |
+16 | for (key, value) in dict {
+ | ^^^^
+
+error: aborting due to previous error(s)
+
+++ /dev/null
-// Copyright 2017 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.
-
-use std::collections::HashMap;
-
-fn main() {
- let dict: HashMap<i32, i32> = HashMap::new();
- let debug_dump_dict = || {
- for (key, value) in dict {
- println!("{:?} - {:?}", key, value);
- }
- };
- debug_dump_dict();
- debug_dump_dict();
- //~^ ERROR use of moved value: `debug_dump_dict`
- //~| NOTE closure cannot be invoked more than once because it moves the
- //~| variable `dict` out of its environment
-}
+++ /dev/null
-error[E0382]: use of moved value: `debug_dump_dict`
- --> $DIR/fn_once-moved.rs:21:5
- |
-20 | debug_dump_dict();
- | --------------- value moved here
-21 | debug_dump_dict();
- | ^^^^^^^^^^^^^^^ value used here after move
- |
-note: closure cannot be invoked more than once because it moves the variable `dict` out of its environment
- --> $DIR/fn_once-moved.rs:16:29
- |
-16 | for (key, value) in dict {
- | ^^^^
-
-error: aborting due to previous error(s)
-
--- /dev/null
+// 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.
+
+use std::cell::Cell;
+use std::panic::catch_unwind;
+fn main() {
+ let mut x = Cell::new(22);
+ catch_unwind(|| { x.set(23); });
+}
--- /dev/null
+error[E0277]: the trait bound `std::cell::UnsafeCell<i32>: std::panic::RefUnwindSafe` is not satisfied in `std::cell::Cell<i32>`
+ --> $DIR/interior-mutability.rs:15:5
+ |
+15 | catch_unwind(|| { x.set(23); });
+ | ^^^^^^^^^^^^ the type std::cell::UnsafeCell<i32> may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+ |
+ = help: within `std::cell::Cell<i32>`, the trait `std::panic::RefUnwindSafe` is not implemented for `std::cell::UnsafeCell<i32>`
+ = note: required because it appears within the type `std::cell::Cell<i32>`
+ = note: required because of the requirements on the impl of `std::panic::UnwindSafe` for `&std::cell::Cell<i32>`
+ = note: required because it appears within the type `[closure@$DIR/interior-mutability.rs:15:18: 15:35 x:&std::cell::Cell<i32>]`
+ = note: required by `std::panic::catch_unwind`
+
+error: aborting due to previous error(s)
+
-Subproject commit 82733b01471a2c62bb1cec966d888c52ff118914
+Subproject commit bbfe9b3a9d64aa8698b18cbb3803b3fa00ee3f44
-Subproject commit 38ca9b702b73c03959e447f5dae56eff7497c986
+Subproject commit bfe80cfa8db75500e67ca8762465d27662674637
projects / rust.git / commitdiff