Auto merge of #34412 - gnzlbg:document_platform_intrinsics_generate, r=alexcrichton

Add x86 intrinsics for bit manipulation (BMI 1.0, BMI 2.0, and TBM).

This PR adds the LLVM x86 intrinsics for the bit manipulation instruction sets (BMI 1.0, BMI 2.0, and TBM).

The objective of this pull-request is to allow building a library that implements all the algorithms offered by those instruction sets, using compiler intrinsics for the targets that support them (by means of `target_feature`).

The target features added are:

- `bmi`: Bit Manipulation Instruction Set 1.0, available in Intel >= Haswell and AMD's >= Jaguar/Piledriver,
- `bmi2`: Bit Manipulation Instruction Set 2.0, available in Intel >= Haswell and AMD's >= Excavator,
- `tbm`: Trailing Bit Manipulation, available only in AMD's Piledriver (won't be available in newer CPUs).

The intrinsics added are:

- BMI 1.0:
  - `bextr`: Bit field extract (with register).
- BMI 2.0:
  - `bzhi`: Zero high bits starting with specified bit position.
  - `pdep`: Parallel bits deposit.
  - `pext`: Parallel bits extract.
- TBM:
 - `bextri`: Bit field extract (with immediate).

18 files changed, 1000 insertions, 850 deletions

diff --git a/src/etc/platform-intrinsics/aarch64.json b/src/etc/platform-intrinsics/aarch64.json
index 79fd7699428..c8cda4077b7 100644
--- a/src/etc/platform-intrinsics/aarch64.json
+++ b/src/etc/platform-intrinsics/aarch64.json
@@ -1,6 +1,6 @@
 {
-    "platform": "aarch64",
-    "intrinsic_prefix": "aarch64_v",
+    "platform": "aarch64_v",
+    "intrinsic_prefix": "",
     "llvm_prefix": "llvm.aarch64.neon.",
     "number_info": {
         "signed": {
diff --git a/src/etc/platform-intrinsics/arm.json b/src/etc/platform-intrinsics/arm.json
index 97db7cbb3e0..39e49e239f3 100644
--- a/src/etc/platform-intrinsics/arm.json
+++ b/src/etc/platform-intrinsics/arm.json
@@ -1,6 +1,6 @@
 {
-    "platform": "arm",
-    "intrinsic_prefix": "arm_v",
+    "platform": "arm_v",
+    "intrinsic_prefix": "",
     "llvm_prefix": "llvm.neon.v",
     "number_info": {
         "signed": {
diff --git a/src/etc/platform-intrinsics/generator.py b/src/etc/platform-intrinsics/generator.py
index a21194962f9..a4a91170efb 100644
--- a/src/etc/platform-intrinsics/generator.py
+++ b/src/etc/platform-intrinsics/generator.py
@@ -26,10 +26,9 @@ SPEC = re.compile(
 class PlatformInfo(object):
     def __init__(self, json):
         self._platform = json['platform']
-        self._intrinsic_prefix = json['intrinsic_prefix']
 
-    def intrinsic_prefix(self):
-        return self._intrinsic_prefix
+    def platform_prefix(self):
+        return self._platform
 
 class IntrinsicSet(object):
     def __init__(self, platform, json):
@@ -38,6 +37,7 @@ class IntrinsicSet(object):
         self._intrinsics = json['intrinsics']
         self._widths = json['width_info']
         self._platform = platform
+        self._intrinsic_prefix = json['intrinsic_prefix']
 
     def intrinsics(self):
         for raw in self._intrinsics:
@@ -48,6 +48,9 @@ class IntrinsicSet(object):
     def platform(self):
         return self._platform
 
+    def intrinsic_prefix(self):
+        return self._intrinsic_prefix
+
     def llvm_prefix(self):
         return self._llvm_prefix
 
@@ -538,8 +541,14 @@ class MonomorphicIntrinsic(object):
                                       *self._args,
                                       width = self._width)
 
+    def platform_prefix(self):
+        return self._platform.platform().platform_prefix()
+
+    def intrinsic_set_name(self):
+        return self._platform.intrinsic_prefix()
+
     def intrinsic_name(self):
-        return self._platform.platform().intrinsic_prefix() + self.intrinsic_suffix()
+        return self._platform.intrinsic_prefix() + self.intrinsic_suffix()
 
     def compiler_args(self):
         return ', '.join(arg.compiler_ctor_ref() for arg in self._args_raw)
@@ -561,6 +570,27 @@ def parse_args():
         formatter_class = argparse.RawDescriptionHelpFormatter,
         description = 'Render an intrinsic definition JSON to various formats.',
         epilog = textwrap.dedent('''\
+        Quick How-To:
+
+        There are two operating modes: single file and multiple files.
+
+        For example, ARM is specified as a single file. To generate the
+        compiler-definitions for ARM just pass the script the "arm.json" file:
+
+        python generator.py --format compiler-defs arm.json
+
+        The X86 architecture is specified as multiple files (for the different
+        instruction sets that x86 supports). To generate the compiler
+        definitions one needs to pass the script a "platform information file"
+        (with the -i flag) next to the files of the different intruction sets.
+        For example, to generate the X86 compiler-definitions for SSE4.2, just:
+
+        python generator.py --format compiler-defs -i x86/info.json sse42.json
+
+        And to generate the compiler-definitions for SSE4.1 and SSE4.2, just:
+
+        python generator.py --format compiler-defs -i x86/info.json sse41.json sse42.json
+
         An intrinsic definition consists of a map with fields:
         - intrinsic: pattern for the name(s) of the vendor's C intrinsic(s)
         - llvm: pattern for the name(s) of the internal llvm intrinsic(s)
@@ -730,8 +760,9 @@ class ExternBlock(object):
         return 'extern "platform-intrinsic" {'
 
     def render(self, mono):
-        return '    fn {}{};'.format(mono.intrinsic_name(),
-                                     mono.intrinsic_signature())
+        return '    fn {}{}{};'.format(mono.platform_prefix(),
+                                       mono.intrinsic_name(),
+                                       mono.intrinsic_signature())
 
     def close(self):
         return '}'
@@ -765,7 +796,7 @@ use IntrinsicDef::Named;
 #[inline(never)]
 pub fn find(name: &str) -> Option<Intrinsic> {{
     if !name.starts_with("{0}") {{ return None }}
-    Some(match &name["{0}".len()..] {{'''.format(platform.intrinsic_prefix())
+    Some(match &name["{0}".len()..] {{'''.format(platform.platform_prefix())
 
     def render(self, mono):
         return '''\
@@ -773,7 +804,7 @@ pub fn find(name: &str) -> Option<Intrinsic> {{
             inputs: {{ static INPUTS: [&'static Type; {}] = [{}]; &INPUTS }},
             output: {},
             definition: Named("{}")
-        }},'''.format(mono.intrinsic_suffix(),
+        }},'''.format(mono.intrinsic_set_name() + mono.intrinsic_suffix(),
                       len(mono._args_raw),
                       mono.compiler_args(),
                       mono.compiler_ret(),
diff --git a/src/etc/platform-intrinsics/x86/avx.json b/src/etc/platform-intrinsics/x86/avx.json
index 05a4721aed8..1f41e2ecf3e 100644
--- a/src/etc/platform-intrinsics/x86/avx.json
+++ b/src/etc/platform-intrinsics/x86/avx.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.avx.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/avx2.json b/src/etc/platform-intrinsics/x86/avx2.json
index e88ff3d2b80..4e006c1c4cf 100644
--- a/src/etc/platform-intrinsics/x86/avx2.json
+++ b/src/etc/platform-intrinsics/x86/avx2.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.avx2.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/bmi.json b/src/etc/platform-intrinsics/x86/bmi.json
new file mode 100644
index 00000000000..24e2cbcf8aa
--- /dev/null
+++ b/src/etc/platform-intrinsics/x86/bmi.json
@@ -0,0 +1,13 @@
+{
+    "intrinsic_prefix": "_bmi",
+    "llvm_prefix": "llvm.x86.bmi.",
+    "intrinsics": [
+        {
+            "intrinsic": "_bextr_{0.bitwidth}",
+            "width": ["0"],
+            "llvm": "bextr.{0.bitwidth}",
+            "ret": "S(32-64)u",
+            "args": ["0", "0"]
+        }
+    ]
+}
diff --git a/src/etc/platform-intrinsics/x86/bmi2.json b/src/etc/platform-intrinsics/x86/bmi2.json
new file mode 100644
index 00000000000..f5a0db5ef51
--- /dev/null
+++ b/src/etc/platform-intrinsics/x86/bmi2.json
@@ -0,0 +1,27 @@
+{
+    "intrinsic_prefix": "_bmi2",
+    "llvm_prefix": "llvm.x86.bmi.",
+    "intrinsics": [
+        {
+            "intrinsic": "_bzhi_{0.bitwidth}",
+            "width": ["0"],
+            "llvm": "bzhi.{0.bitwidth}",
+            "ret": "S(32-64)u",
+            "args": ["0", "0"]
+        },
+        {
+            "intrinsic": "_pdep_{0.bitwidth}",
+            "width": ["0"],
+            "llvm": "pdep.{0.bitwidth}",
+            "ret": "S(32-64)u",
+            "args": ["0", "0"]
+        },
+        {
+            "intrinsic": "_pext_{0.bitwidth}",
+            "width": ["0"],
+            "llvm": "pext.{0.bitwidth}",
+            "ret": "S(32-64)u",
+            "args": ["0", "0"]
+        }
+    ]
+}
diff --git a/src/etc/platform-intrinsics/x86/fma.json b/src/etc/platform-intrinsics/x86/fma.json
index c922d166c8f..dcc26cd501c 100644
--- a/src/etc/platform-intrinsics/x86/fma.json
+++ b/src/etc/platform-intrinsics/x86/fma.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.fma.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/info.json b/src/etc/platform-intrinsics/x86/info.json
index d48bcd268a0..8e90b8579c4 100644
--- a/src/etc/platform-intrinsics/x86/info.json
+++ b/src/etc/platform-intrinsics/x86/info.json
@@ -1,26 +1,30 @@
 {
     "platform": "x86",
-    "intrinsic_prefix": "x86_mm",
     "number_info": {
         "signed": {
             "kind": "s",
             "kind_short": "",
             "data_type": { "pattern": "epi{bitwidth}" },
+            "bitwidth": { "pattern": "{bitwidth}" },
             "data_type_short": { "8": "b", "16": "w", "32": "d", "64": "q" }
         },
         "unsigned": {
             "kind": "u",
             "kind_short": "u",
             "data_type": { "pattern": "epu{bitwidth}" },
+            "bitwidth": { "pattern": "{bitwidth}" },
             "data_type_short": { "8": "b", "16": "w", "32": "d", "64": "q" }
         },
         "float": {
             "kind": "f",
             "data_type": { "32": "ps", "64": "pd" },
+            "bitwidth": { "pattern": "{bitwidth}" },
             "data_type_short": { "32": "ps", "64": "pd" }
         }
     },
     "width_info": {
+        "32":  { "width_mm": "32", "width_suffix": "" },
+        "64":  { "width_mm": "64", "width_suffix": "" },
         "128": { "width_mm": "", "width_suffix": "" },
         "256": { "width_mm": "256", "width_suffix": ".256" },
         "512": { "width_mm": "512", "width_suffix": ".512" }
diff --git a/src/etc/platform-intrinsics/x86/sse.json b/src/etc/platform-intrinsics/x86/sse.json
index adff0dc41b2..d8eef8a3514 100644
--- a/src/etc/platform-intrinsics/x86/sse.json
+++ b/src/etc/platform-intrinsics/x86/sse.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.sse.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/sse2.json b/src/etc/platform-intrinsics/x86/sse2.json
index d09980d95f3..4d6317d80a5 100644
--- a/src/etc/platform-intrinsics/x86/sse2.json
+++ b/src/etc/platform-intrinsics/x86/sse2.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.sse2.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/sse3.json b/src/etc/platform-intrinsics/x86/sse3.json
index ed13595929d..119bf208f7e 100644
--- a/src/etc/platform-intrinsics/x86/sse3.json
+++ b/src/etc/platform-intrinsics/x86/sse3.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.sse3.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/sse41.json b/src/etc/platform-intrinsics/x86/sse41.json
index de792cd1060..b499637e0d3 100644
--- a/src/etc/platform-intrinsics/x86/sse41.json
+++ b/src/etc/platform-intrinsics/x86/sse41.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.sse41.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/sse42.json b/src/etc/platform-intrinsics/x86/sse42.json
index c43ffef0dc5..fdee9c8a667 100644
--- a/src/etc/platform-intrinsics/x86/sse42.json
+++ b/src/etc/platform-intrinsics/x86/sse42.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.sse42.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/ssse3.json b/src/etc/platform-intrinsics/x86/ssse3.json
index af6afbb19a2..5a5617957b3 100644
--- a/src/etc/platform-intrinsics/x86/ssse3.json
+++ b/src/etc/platform-intrinsics/x86/ssse3.json
@@ -1,4 +1,5 @@
 {
+    "intrinsic_prefix": "_mm",
     "llvm_prefix": "llvm.x86.ssse3.",
     "intrinsics": [
         {
diff --git a/src/etc/platform-intrinsics/x86/tbm.json b/src/etc/platform-intrinsics/x86/tbm.json
new file mode 100644
index 00000000000..d1322cd60c4
--- /dev/null
+++ b/src/etc/platform-intrinsics/x86/tbm.json
@@ -0,0 +1,13 @@
+{
+    "intrinsic_prefix": "_tbm",
+    "llvm_prefix": "llvm.x86.tbm.",
+    "intrinsics": [
+        {
+            "intrinsic": "_bextri_u{0.bitwidth}",
+            "width": ["0"],
+            "llvm": "bextri.u{0.bitwidth}",
+            "ret": "S(32-64)u",
+            "args": ["0", "0"]
+        }
+    ]
+}
diff --git a/src/librustc_driver/target_features.rs b/src/librustc_driver/target_features.rs
index fad0af19a12..f2020303089 100644
--- a/src/librustc_driver/target_features.rs
+++ b/src/librustc_driver/target_features.rs
@@ -30,12 +30,15 @@ const ARM_WHITELIST: &'static [&'static str] = &[
 const X86_WHITELIST: &'static [&'static str] = &[
     "avx\0",
     "avx2\0",
+    "bmi\0",
+    "bmi2\0",
     "sse\0",
     "sse2\0",
     "sse3\0",
     "sse4.1\0",
     "sse4.2\0",
     "ssse3\0",
+    "tbm\0",
 ];
 
 /// Add `target_feature = "..."` cfgs for a variety of platform
diff --git a/src/librustc_platform_intrinsics/x86.rs b/src/librustc_platform_intrinsics/x86.rs
index 54e2cb929b8..91ecad8402f 100644
--- a/src/librustc_platform_intrinsics/x86.rs
+++ b/src/librustc_platform_intrinsics/x86.rs
@@ -20,1282 +20,1332 @@ use IntrinsicDef::Named;
 // LLVM, which causes makes compilation very slow. See #28273.
 #[inline(never)]
 pub fn find(name: &str) -> Option<Intrinsic> {
-    if !name.starts_with("x86_mm") { return None }
-    Some(match &name["x86_mm".len()..] {
-        "_movemask_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse.movmsk.ps")
-        },
-        "_max_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.sse.max.ps")
-        },
-        "_min_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.sse.min.ps")
-        },
-        "_rsqrt_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.sse.rsqrt.ps")
-        },
-        "_rcp_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.sse.rcp.ps")
-        },
-        "_sqrt_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.sqrt.v4f32")
-        },
-        "_storeu_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F32, Some(&::I8), false); &PTR }, &::F32x4]; &INPUTS },
-            output: &::VOID,
-            definition: Named("llvm.x86.sse.storeu.ps")
-        },
-        "_adds_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.sse2.padds.b")
-        },
-        "_adds_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
-            output: &::U8x16,
-            definition: Named("llvm.x86.sse2.paddus.b")
-        },
-        "_adds_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.sse2.padds.w")
-        },
-        "_adds_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse2.paddus.w")
-        },
-        "_avg_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
-            output: &::U8x16,
-            definition: Named("llvm.x86.sse2.pavg.b")
+    if !name.starts_with("x86") { return None }
+    Some(match &name["x86".len()..] {
+        "_mm256_abs_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::I8x32]; &INPUTS },
+            output: &::I8x32,
+            definition: Named("llvm.x86.avx2.pabs.b")
         },
-        "_avg_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse2.pavg.w")
+        "_mm256_abs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.pabs.w")
         },
-        "_lfence" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 0] = []; &INPUTS },
-            output: &::VOID,
-            definition: Named("llvm.x86.sse2.lfence")
+        "_mm256_abs_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::I32x8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.pabs.d")
         },
-        "_madd_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.sse2.pmadd.wd")
+        "_mm256_adds_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
+            output: &::I8x32,
+            definition: Named("llvm.x86.avx2.padds.b")
         },
-        "_maskmoveu_si128" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::U8x16, &::U8x16, { static PTR: Type = Type::Pointer(&::U8, None, false); &PTR }]; &INPUTS },
-            output: &::VOID,
-            definition: Named("llvm.x86.sse2.maskmov.dqu")
+        "_mm256_adds_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
+            output: &::U8x32,
+            definition: Named("llvm.x86.avx2.paddus.b")
         },
-        "_max_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.sse2.pmaxs.w")
+        "_mm256_adds_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.padds.w")
         },
-        "_max_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
-            output: &::U8x16,
-            definition: Named("llvm.x86.sse2.pmaxu.b")
+        "_mm256_adds_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
+            output: &::U16x16,
+            definition: Named("llvm.x86.avx2.paddus.w")
         },
-        "_max_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.sse2.max.pd")
+        "_mm256_avg_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
+            output: &::U8x32,
+            definition: Named("llvm.x86.avx2.pavg.b")
         },
-        "_mfence" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 0] = []; &INPUTS },
-            output: &::VOID,
-            definition: Named("llvm.x86.sse2.fence")
+        "_mm256_avg_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
+            output: &::U16x16,
+            definition: Named("llvm.x86.avx2.pavg.w")
         },
-        "_min_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.sse2.pmins.w")
+        "_mm256_hadd_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.phadd.w")
         },
-        "_min_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
-            output: &::U8x16,
-            definition: Named("llvm.x86.sse2.pminu.b")
+        "_mm256_hadd_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.phadd.d")
         },
-        "_min_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.sse2.min.pd")
+        "_mm256_hadds_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.phadd.sw")
         },
-        "_movemask_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::F64x2]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse2.movmsk.pd")
+        "_mm256_hsub_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.phsub.w")
         },
-        "_movemask_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse2.pmovmskb.128")
+        "_mm256_hsub_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.phsub.d")
         },
-        "_mul_epu32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
-            output: &::U64x2,
-            definition: Named("llvm.x86.sse2.pmulu.dq")
+        "_mm256_hsubs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.phsub.sw")
         },
-        "_mulhi_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.sse2.pmulh.w")
+        "_mm256_madd_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.pmadd.wd")
         },
-        "_mulhi_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse2.pmulhu.w")
+        "_mm256_maddubs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.pmadd.ub.sw")
         },
-        "_packs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.sse2.packsswb.128")
+        "_mm_mask_i32gather_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I32x4, { static PTR: Type = Type::Pointer(&::I32, Some(&::I8), true); &PTR }, &::I32x4, &::I32x4, &::I32_8]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.avx2.gather.d.d")
         },
-        "_packs_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.sse2.packssdw.128")
+        "_mm_mask_i32gather_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::F32x4, { static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I32x4, &::I32x4_F32, &::I32_8]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.avx2.gather.d.ps")
         },
-        "_packus_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::U8x16,
-            definition: Named("llvm.x86.sse2.packuswb.128")
+        "_mm256_mask_i32gather_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I32x8, { static PTR: Type = Type::Pointer(&::I32, Some(&::I8), true); &PTR }, &::I32x8, &::I32x8, &::I32_8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.gather.d.d.256")
         },
-        "_sad_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
-            output: &::U64x2,
-            definition: Named("llvm.x86.sse2.psad.bw")
+        "_mm256_mask_i32gather_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::F32x8, { static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I32x8, &::I32x8_F32, &::I32_8]; &INPUTS },
+            output: &::F32x8,
+            definition: Named("llvm.x86.avx2.gather.d.ps.256")
         },
-        "_sfence" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 0] = []; &INPUTS },
-            output: &::VOID,
-            definition: Named("llvm.x86.sse2.sfence")
+        "_mm_mask_i32gather_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I64x2, { static PTR: Type = Type::Pointer(&::I64, Some(&::I8), true); &PTR }, &::I32x4, &::I64x2, &::I32_8]; &INPUTS },
+            output: &::I64x2,
+            definition: Named("llvm.x86.avx2.gather.d.q")
         },
-        "_sqrt_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::F64x2]; &INPUTS },
+        "_mm_mask_i32gather_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::F64x2, { static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I32x4, &::I64x2_F64, &::I32_8]; &INPUTS },
             output: &::F64x2,
-            definition: Named("llvm.sqrt.v2f64")
-        },
-        "_storeu_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F64, Some(&::U8), false); &PTR }, &::F64x2]; &INPUTS },
-            output: &::VOID,
-            definition: Named("llvm.x86.sse2.storeu.pd")
-        },
-        "_storeu_si128" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::U8x16, Some(&::U8), false); &PTR }, &::U8x16]; &INPUTS },
-            output: &::VOID,
-            definition: Named("llvm.x86.sse2.storeu.dq")
-        },
-        "_subs_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.sse2.psubs.b")
+            definition: Named("llvm.x86.avx2.gather.d.pd")
         },
-        "_subs_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
-            output: &::U8x16,
-            definition: Named("llvm.x86.sse2.psubus.b")
+        "_mm256_mask_i32gather_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I64x4, { static PTR: Type = Type::Pointer(&::I64, Some(&::I8), true); &PTR }, &::I32x4, &::I64x4, &::I32_8]; &INPUTS },
+            output: &::I64x4,
+            definition: Named("llvm.x86.avx2.gather.d.q.256")
         },
-        "_subs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.sse2.psubs.w")
+        "_mm256_mask_i32gather_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::F64x4, { static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I32x4, &::I64x4_F64, &::I32_8]; &INPUTS },
+            output: &::F64x4,
+            definition: Named("llvm.x86.avx2.gather.d.pd.256")
         },
-        "_subs_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse2.psubus.w")
+        "_mm_mask_i64gather_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I32x4, { static PTR: Type = Type::Pointer(&::I32, Some(&::I8), true); &PTR }, &::I64x2, &::I32x4, &::I32_8]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.avx2.gather.q.d")
         },
-        "_addsub_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
+        "_mm_mask_i64gather_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::F32x4, { static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I64x2, &::I32x4_F32, &::I32_8]; &INPUTS },
             output: &::F32x4,
-            definition: Named("llvm.x86.sse3.addsub.ps")
+            definition: Named("llvm.x86.avx2.gather.q.ps")
         },
-        "_addsub_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.sse3.addsub.pd")
+        "_mm256_mask_i64gather_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I32x4, { static PTR: Type = Type::Pointer(&::I32, Some(&::I8), true); &PTR }, &::I64x4, &::I32x4, &::I32_8]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.avx2.gather.q.d")
         },
-        "_hadd_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
+        "_mm256_mask_i64gather_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::F32x4, { static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I64x4, &::I32x4_F32, &::I32_8]; &INPUTS },
             output: &::F32x4,
-            definition: Named("llvm.x86.sse3.hadd.ps")
-        },
-        "_hadd_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.sse3.hadd.pd")
+            definition: Named("llvm.x86.avx2.gather.q.ps")
         },
-        "_hsub_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.sse3.hsub.ps")
+        "_mm_mask_i64gather_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I64x2, { static PTR: Type = Type::Pointer(&::I64, Some(&::I8), true); &PTR }, &::I64x2, &::I64x2, &::I32_8]; &INPUTS },
+            output: &::I64x2,
+            definition: Named("llvm.x86.avx2.gather.q.q")
         },
-        "_hsub_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
+        "_mm_mask_i64gather_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::F64x2, { static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I64x2, &::I64x2_F64, &::I32_8]; &INPUTS },
             output: &::F64x2,
-            definition: Named("llvm.x86.sse3.hsub.pd")
-        },
-        "_lddqu_si128" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [{ static PTR: Type = Type::Pointer(&::U8x16, Some(&::I8), true); &PTR }]; &INPUTS },
-            output: &::U8x16,
-            definition: Named("llvm.x86.sse3.ldu.dq")
-        },
-        "_abs_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.ssse3.pabs.b.128")
-        },
-        "_abs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.ssse3.pabs.w.128")
+            definition: Named("llvm.x86.avx2.gather.q.pd")
         },
-        "_abs_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.ssse3.pabs.d.128")
+        "_mm256_mask_i64gather_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I64x4, { static PTR: Type = Type::Pointer(&::I64, Some(&::I8), true); &PTR }, &::I64x4, &::I64x4, &::I32_8]; &INPUTS },
+            output: &::I64x4,
+            definition: Named("llvm.x86.avx2.gather.q.q.256")
         },
-        "_hadd_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.ssse3.phadd.w.128")
+        "_mm256_mask_i64gather_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::F64x4, { static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I64x4, &::I64x4_F64, &::I32_8]; &INPUTS },
+            output: &::F64x4,
+            definition: Named("llvm.x86.avx2.gather.q.pd.256")
         },
-        "_hadd_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+        "_mm_maskload_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::I32x4, Some(&::I8), true); &PTR }, &::I32x4]; &INPUTS },
             output: &::I32x4,
-            definition: Named("llvm.x86.ssse3.phadd.d.128")
+            definition: Named("llvm.x86.avx2.maskload.d")
         },
-        "_hadds_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.ssse3.phadd.sw.128")
+        "_mm_maskload_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::I64x2, Some(&::I8), true); &PTR }, &::I64x2]; &INPUTS },
+            output: &::I64x2,
+            definition: Named("llvm.x86.avx2.maskload.q")
         },
-        "_hsub_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.ssse3.phsub.w.128")
+        "_mm256_maskload_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::I32x8, Some(&::I8), true); &PTR }, &::I32x8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.maskload.d.256")
         },
-        "_hsub_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.ssse3.phsub.d.128")
+        "_mm256_maskload_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::I64x4, Some(&::I8), true); &PTR }, &::I64x4]; &INPUTS },
+            output: &::I64x4,
+            definition: Named("llvm.x86.avx2.maskload.q.256")
         },
-        "_hsubs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.ssse3.phsub.sw.128")
+        "_mm_maskstore_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::I32, Some(&::I8), false); &PTR }, &::I32x4, &::I32x4]; &INPUTS },
+            output: &::VOID,
+            definition: Named("llvm.x86.avx2.maskstore.d")
         },
-        "_maddubs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::I8x16]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.ssse3.pmadd.ub.sw.128")
+        "_mm_maskstore_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::I64, Some(&::I8), false); &PTR }, &::I64x2, &::I64x2]; &INPUTS },
+            output: &::VOID,
+            definition: Named("llvm.x86.avx2.maskstore.q")
         },
-        "_mulhrs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.ssse3.pmul.hr.sw.128")
+        "_mm256_maskstore_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::I32, Some(&::I8), false); &PTR }, &::I32x8, &::I32x8]; &INPUTS },
+            output: &::VOID,
+            definition: Named("llvm.x86.avx2.maskstore.d.256")
         },
-        "_shuffle_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.ssse3.pshuf.b.128")
+        "_mm256_maskstore_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::I64, Some(&::I8), false); &PTR }, &::I64x4, &::I64x4]; &INPUTS },
+            output: &::VOID,
+            definition: Named("llvm.x86.avx2.maskstore.q.256")
         },
-        "_sign_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.ssse3.psign.b.128")
+        "_mm256_max_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
+            output: &::I8x32,
+            definition: Named("llvm.x86.avx2.pmaxs.b")
         },
-        "_sign_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
-            output: &::I16x8,
-            definition: Named("llvm.x86.ssse3.psign.w.128")
+        "_mm256_max_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
+            output: &::U8x32,
+            definition: Named("llvm.x86.avx2.pmaxu.b")
         },
-        "_sign_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.ssse3.psign.d.128")
+        "_mm256_max_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.pmaxs.w")
         },
-        "_dp_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::I32_8]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.sse41.dpps")
+        "_mm256_max_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
+            output: &::U16x16,
+            definition: Named("llvm.x86.avx2.pmaxu.w")
         },
-        "_dp_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::I32_8]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.sse41.dppd")
+        "_mm256_max_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.pmaxs.d")
         },
-        "_max_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.sse41.pmaxsb")
+        "_mm256_max_epu32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x8, &::U32x8]; &INPUTS },
+            output: &::U32x8,
+            definition: Named("llvm.x86.avx2.pmaxu.d")
         },
-        "_max_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse41.pmaxuw")
+        "_mm256_min_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
+            output: &::I8x32,
+            definition: Named("llvm.x86.avx2.pmins.b")
         },
-        "_max_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.sse41.pmaxsd")
+        "_mm256_min_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
+            output: &::U8x32,
+            definition: Named("llvm.x86.avx2.pminu.b")
         },
-        "_max_epu32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
-            output: &::U32x4,
-            definition: Named("llvm.x86.sse41.pmaxud")
+        "_mm256_min_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.pmins.w")
         },
-        "_min_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.sse41.pminsb")
+        "_mm256_min_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
+            output: &::U16x16,
+            definition: Named("llvm.x86.avx2.pminu.w")
         },
-        "_min_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse41.pminuw")
+        "_mm256_min_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.pmins.d")
         },
-        "_min_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.sse41.pminsd")
+        "_mm256_min_epu32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x8, &::U32x8]; &INPUTS },
+            output: &::U32x8,
+            definition: Named("llvm.x86.avx2.pminu.d")
         },
-        "_min_epu32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
-            output: &::U32x4,
-            definition: Named("llvm.x86.sse41.pminud")
+        "_mm256_movemask_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::I8x32]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.avx2.pmovmskb")
         },
-        "_minpos_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::U16x8]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse41.phminposuw")
+        "_mm256_mpsadbw_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::U8x32, &::U8x32, &::I32_8]; &INPUTS },
+            output: &::U16x16,
+            definition: Named("llvm.x86.avx2.mpsadbw")
         },
-        "_mpsadbw_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::U8x16, &::U8x16, &::I32_8]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse41.mpsadbw")
+        "_mm256_mul_epi64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::I64x4,
+            definition: Named("llvm.x86.avx2.pmulq.dq")
         },
-        "_mul_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
-            output: &::I64x2,
-            definition: Named("llvm.x86.sse41.pmuldq")
+        "_mm256_mul_epu64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x8, &::U32x8]; &INPUTS },
+            output: &::U64x4,
+            definition: Named("llvm.x86.avx2.pmulq.dq")
         },
-        "_packus_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
-            output: &::U16x8,
-            definition: Named("llvm.x86.sse41.packusdw")
+        "_mm256_mulhi_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.pmulhw.w")
         },
-        "_testc_si128" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse41.ptestc")
+        "_mm256_mulhi_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
+            output: &::U16x16,
+            definition: Named("llvm.x86.avx2.pmulhw.w")
         },
-        "_testnzc_si128" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse41.ptestnzc")
+        "_mm256_mulhrs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.pmul.hr.sw")
         },
-        "_testz_si128" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse41.ptestz")
+        "_mm256_packs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I8x32,
+            definition: Named("llvm.x86.avx2.packsswb")
         },
-        "_cmpestra" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpestria128")
+        "_mm256_packus_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::U8x32,
+            definition: Named("llvm.x86.avx2.packuswb")
         },
-        "_cmpestrc" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpestric128")
+        "_mm256_packs_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.packssdw")
         },
-        "_cmpestri" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpestri128")
+        "_mm256_packus_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::U16x16,
+            definition: Named("llvm.x86.avx2.packusdw")
         },
-        "_cmpestrm" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.sse42.pcmpestrm128")
+        "_mm256_permutevar8x32_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.permd")
         },
-        "_cmpestro" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpestrio128")
+        "_mm256_permutevar8x32_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::I32x8]; &INPUTS },
+            output: &::F32x8,
+            definition: Named("llvm.x86.avx2.permps")
         },
-        "_cmpestrs" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpestris128")
+        "_mm256_sad_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
+            output: &::U8x32,
+            definition: Named("llvm.x86.avx2.psad.bw")
         },
-        "_cmpestrz" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpestriz128")
+        "_mm256_shuffle_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
+            output: &::I8x32,
+            definition: Named("llvm.x86.avx2.pshuf.b")
         },
-        "_cmpistra" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpistria128")
+        "_mm256_sign_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
+            output: &::I8x32,
+            definition: Named("llvm.x86.avx2.psign.b")
         },
-        "_cmpistrc" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpistric128")
+        "_mm256_sign_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.psign.w")
         },
-        "_cmpistri" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpistri128")
+        "_mm256_sign_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
+            output: &::I32x8,
+            definition: Named("llvm.x86.avx2.psign.d")
         },
-        "_cmpistrm" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
-            output: &::I8x16,
-            definition: Named("llvm.x86.sse42.pcmpistrm128")
+        "_mm256_subs_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
+            output: &::I8x32,
+            definition: Named("llvm.x86.avx2.psubs.b")
         },
-        "_cmpistro" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpistrio128")
+        "_mm256_subs_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
+            output: &::U8x32,
+            definition: Named("llvm.x86.avx2.psubus.b")
         },
-        "_cmpistrs" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpistris128")
+        "_mm256_subs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
+            output: &::I16x16,
+            definition: Named("llvm.x86.avx2.psubs.w")
         },
-        "_cmpistrz" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.sse42.pcmpistriz128")
+        "_mm256_subs_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
+            output: &::U16x16,
+            definition: Named("llvm.x86.avx2.psubus.w")
         },
-        "256_addsub_ps" => Intrinsic {
+        "_mm256_addsub_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.addsub.ps.256")
         },
-        "256_addsub_pd" => Intrinsic {
+        "_mm256_addsub_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::F64x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.addsub.pd.256")
         },
-        "256_blendv_ps" => Intrinsic {
+        "_mm256_blendv_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.blendv.ps.256")
         },
-        "256_blendv_pd" => Intrinsic {
+        "_mm256_blendv_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.blendv.pd.256")
         },
-        "256_broadcast_ps" => Intrinsic {
+        "_mm256_broadcast_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [{ static PTR: Type = Type::Pointer(&::I8, None, true); &PTR }]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.vbroadcastf128.ps.256")
         },
-        "256_broadcast_pd" => Intrinsic {
+        "_mm256_broadcast_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [{ static PTR: Type = Type::Pointer(&::I8, None, true); &PTR }]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.vbroadcastf128.pd.256")
         },
-        "256_cmp_ps" => Intrinsic {
+        "_mm256_cmp_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::I8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.cmp.ps.256")
         },
-        "256_cmp_pd" => Intrinsic {
+        "_mm256_cmp_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::I8]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.cmp.pd.256")
         },
-        "256_cvtepi32_pd" => Intrinsic {
+        "_mm256_cvtepi32_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.cvtdq2.pd.256")
         },
-        "256_cvtepi32_ps" => Intrinsic {
+        "_mm256_cvtepi32_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::I32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.cvtdq2.ps.256")
         },
-        "256_cvtpd_epi32" => Intrinsic {
+        "_mm256_cvtpd_epi32" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F64x4]; &INPUTS },
             output: &::I32x4,
             definition: Named("llvm.x86.avx.cvt.pd2dq.256")
         },
-        "256_cvtpd_ps" => Intrinsic {
+        "_mm256_cvtpd_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F64x4]; &INPUTS },
             output: &::F32x4,
             definition: Named("llvm.x86.avx.cvt.pd2.ps.256")
         },
-        "256_cvtps_epi32" => Intrinsic {
+        "_mm256_cvtps_epi32" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F32x8]; &INPUTS },
             output: &::I32x8,
             definition: Named("llvm.x86.avx.cvt.ps2dq.256")
         },
-        "256_cvtps_pd" => Intrinsic {
+        "_mm256_cvtps_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.cvt.ps2.pd.256")
         },
-        "256_cvttpd_epi32" => Intrinsic {
+        "_mm256_cvttpd_epi32" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F64x4]; &INPUTS },
             output: &::I32x4,
             definition: Named("llvm.x86.avx.cvtt.pd2dq.256")
         },
-        "256_cvttps_epi32" => Intrinsic {
+        "_mm256_cvttps_epi32" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F32x8]; &INPUTS },
             output: &::I32x8,
             definition: Named("llvm.x86.avx.cvtt.ps2dq.256")
         },
-        "256_dp_ps" => Intrinsic {
+        "_mm256_dp_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::I32_8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.dp.ps.256")
         },
-        "256_hadd_ps" => Intrinsic {
+        "_mm256_hadd_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.hadd.ps.256")
         },
-        "256_hadd_pd" => Intrinsic {
+        "_mm256_hadd_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::F64x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.hadd.pd.256")
         },
-        "256_hsub_ps" => Intrinsic {
+        "_mm256_hsub_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.hsub.ps.256")
         },
-        "256_hsub_pd" => Intrinsic {
+        "_mm256_hsub_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::F64x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.hsub.pd.256")
         },
-        "256_max_ps" => Intrinsic {
+        "_mm256_max_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.max.ps.256")
         },
-        "256_max_pd" => Intrinsic {
+        "_mm256_max_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::F64x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.max.pd.256")
         },
-        "_maskload_ps" => Intrinsic {
+        "_mm_maskload_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I32x4_F32]; &INPUTS },
             output: &::F32x4,
             definition: Named("llvm.x86.avx.maskload.ps")
         },
-        "_maskload_pd" => Intrinsic {
+        "_mm_maskload_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I64x2_F64]; &INPUTS },
             output: &::F64x2,
             definition: Named("llvm.x86.avx.maskload.pd")
         },
-        "256_maskload_ps" => Intrinsic {
+        "_mm256_maskload_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I32x8_F32]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.maskload.ps.256")
         },
-        "256_maskload_pd" => Intrinsic {
+        "_mm256_maskload_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I64x4_F64]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.maskload.pd.256")
         },
-        "_maskstore_ps" => Intrinsic {
+        "_mm_maskstore_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::F32, Some(&::I8), false); &PTR }, &::I32x4_F32, &::F32x4]; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.maskstore.ps")
         },
-        "_maskstore_pd" => Intrinsic {
+        "_mm_maskstore_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::F64, Some(&::I8), false); &PTR }, &::I64x2_F64, &::F64x2]; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.maskstore.pd")
         },
-        "256_maskstore_ps" => Intrinsic {
+        "_mm256_maskstore_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::F32, Some(&::I8), false); &PTR }, &::I32x8_F32, &::F32x8]; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.maskstore.ps.256")
         },
-        "256_maskstore_pd" => Intrinsic {
+        "_mm256_maskstore_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::F64, Some(&::I8), false); &PTR }, &::I64x4_F64, &::F64x4]; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.maskstore.pd.256")
         },
-        "256_min_ps" => Intrinsic {
+        "_mm256_min_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.min.ps.256")
         },
-        "256_min_pd" => Intrinsic {
+        "_mm256_min_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::F64x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.min.pd.256")
         },
-        "256_movemask_ps" => Intrinsic {
+        "_mm256_movemask_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F32x8]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.movmsk.ps.256")
         },
-        "256_movemask_pd" => Intrinsic {
+        "_mm256_movemask_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F64x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.movmsk.pd.256")
         },
-        "_permutevar_ps" => Intrinsic {
+        "_mm_permutevar_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::I32x4]; &INPUTS },
             output: &::F32x4,
             definition: Named("llvm.x86.avx.vpermilvar.ps")
         },
-        "_permutevar_pd" => Intrinsic {
+        "_mm_permutevar_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::I64x2]; &INPUTS },
             output: &::F64x2,
             definition: Named("llvm.x86.avx.vpermilvar.pd")
         },
-        "256_permutevar_ps" => Intrinsic {
+        "_mm256_permutevar_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::I32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.vpermilvar.ps.256")
         },
-        "256_permutevar_pd" => Intrinsic {
+        "_mm256_permutevar_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::I64x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.x86.avx.vpermilvar.pd.256")
         },
-        "256_rcp_ps" => Intrinsic {
+        "_mm256_rcp_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.rcp.ps.256")
         },
-        "256_rsqrt_ps" => Intrinsic {
+        "_mm256_rsqrt_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.x86.avx.rsqrt.ps.256")
         },
-        "256_storeu_ps" => Intrinsic {
+        "_mm256_storeu_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F32x8, Some(&::U8), false); &PTR }, &::F32x8]; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.storeu.ps.256")
         },
-        "256_storeu_pd" => Intrinsic {
+        "_mm256_storeu_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F64x4, Some(&::U8), false); &PTR }, &::F64x4]; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.storeu.ps.256")
         },
-        "256_storeu_si256" => Intrinsic {
+        "_mm256_storeu_si256" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::U8x32, Some(&::U8), false); &PTR }, &::U8x32]; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.storeu.dq.256")
         },
-        "256_sqrt_ps" => Intrinsic {
+        "_mm256_sqrt_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F32x8]; &INPUTS },
             output: &::F32x8,
             definition: Named("llvm.sqrt.v8f32")
         },
-        "256_sqrt_pd" => Intrinsic {
+        "_mm256_sqrt_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 1] = [&::F64x4]; &INPUTS },
             output: &::F64x4,
             definition: Named("llvm.sqrt.v4f64")
         },
-        "_testc_ps" => Intrinsic {
+        "_mm_testc_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestc.ps")
         },
-        "256_testc_ps" => Intrinsic {
+        "_mm256_testc_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::F32x8]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestc.ps.256")
         },
-        "_testc_pd" => Intrinsic {
+        "_mm_testc_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestc.pd")
         },
-        "256_testc_pd" => Intrinsic {
+        "_mm256_testc_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::F64x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestc.pd.256")
         },
-        "256_testc_si256" => Intrinsic {
+        "_mm256_testc_si256" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::U64x4, &::U64x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.ptestc.256")
         },
-        "_testnzc_ps" => Intrinsic {
+        "_mm_testnzc_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestnzc.ps")
         },
-        "256_testnzc_ps" => Intrinsic {
+        "_mm256_testnzc_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::F32x8]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestnzc.ps.256")
         },
-        "_testnzc_pd" => Intrinsic {
+        "_mm_testnzc_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestnzc.pd")
         },
-        "256_testnzc_pd" => Intrinsic {
+        "_mm256_testnzc_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::F64x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestnzc.pd.256")
         },
-        "256_testnzc_si256" => Intrinsic {
+        "_mm256_testnzc_si256" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::U64x4, &::U64x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.ptestnzc.256")
         },
-        "_testz_ps" => Intrinsic {
+        "_mm_testz_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestz.ps")
         },
-        "256_testz_ps" => Intrinsic {
+        "_mm256_testz_ps" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::F32x8]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestz.ps.256")
         },
-        "_testz_pd" => Intrinsic {
+        "_mm_testz_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestz.pd")
         },
-        "256_testz_pd" => Intrinsic {
+        "_mm256_testz_pd" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::F64x4, &::F64x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.vtestz.pd.256")
         },
-        "256_testz_si256" => Intrinsic {
+        "_mm256_testz_si256" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 2] = [&::U64x4, &::U64x4]; &INPUTS },
             output: &::I32,
             definition: Named("llvm.x86.avx.ptestz.256")
         },
-        "256_zeroall" => Intrinsic {
+        "_mm256_zeroall" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 0] = []; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.vzeroall")
         },
-        "256_zeroupper" => Intrinsic {
+        "_mm256_zeroupper" => Intrinsic {
             inputs: { static INPUTS: [&'static Type; 0] = []; &INPUTS },
             output: &::VOID,
             definition: Named("llvm.x86.avx.vzeroupper")
         },
-        "256_abs_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::I8x32]; &INPUTS },
-            output: &::I8x32,
-            definition: Named("llvm.x86.avx2.pabs.b")
-        },
-        "256_abs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.pabs.w")
-        },
-        "256_abs_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::I32x8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.pabs.d")
+        "_bmi2_bzhi_32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32, &::U32]; &INPUTS },
+            output: &::U32,
+            definition: Named("llvm.x86.bmi.bzhi.32")
+        },
+        "_bmi2_bzhi_64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U64, &::U64]; &INPUTS },
+            output: &::U64,
+            definition: Named("llvm.x86.bmi.bzhi.64")
+        },
+        "_bmi2_pdep_32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32, &::U32]; &INPUTS },
+            output: &::U32,
+            definition: Named("llvm.x86.bmi.pdep.32")
+        },
+        "_bmi2_pdep_64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U64, &::U64]; &INPUTS },
+            output: &::U64,
+            definition: Named("llvm.x86.bmi.pdep.64")
+        },
+        "_bmi2_pext_32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32, &::U32]; &INPUTS },
+            output: &::U32,
+            definition: Named("llvm.x86.bmi.pext.32")
+        },
+        "_bmi2_pext_64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U64, &::U64]; &INPUTS },
+            output: &::U64,
+            definition: Named("llvm.x86.bmi.pext.64")
+        },
+        "_bmi_bextr_32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32, &::U32]; &INPUTS },
+            output: &::U32,
+            definition: Named("llvm.x86.bmi.bextr.32")
+        },
+        "_bmi_bextr_64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U64, &::U64]; &INPUTS },
+            output: &::U64,
+            definition: Named("llvm.x86.bmi.bextr.64")
+        },
+        "_mm_fmadd_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.fma.vfmadd.ps")
         },
-        "256_adds_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
-            output: &::I8x32,
-            definition: Named("llvm.x86.avx2.padds.b")
+        "_mm_fmadd_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.fma.vfmadd.pd")
         },
-        "256_adds_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
-            output: &::U8x32,
-            definition: Named("llvm.x86.avx2.paddus.b")
+        "_mm256_fmadd_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
+            output: &::F32x8,
+            definition: Named("llvm.x86.fma.vfmadd.ps.256")
         },
-        "256_adds_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.padds.w")
+        "_mm256_fmadd_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
+            output: &::F64x4,
+            definition: Named("llvm.x86.fma.vfmadd.pd.256")
         },
-        "256_adds_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
-            output: &::U16x16,
-            definition: Named("llvm.x86.avx2.paddus.w")
+        "_mm_fmaddsub_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.fma.vfmaddsub.ps")
         },
-        "256_avg_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
-            output: &::U8x32,
-            definition: Named("llvm.x86.avx2.pavg.b")
+        "_mm_fmaddsub_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.fma.vfmaddsub.pd")
         },
-        "256_avg_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
-            output: &::U16x16,
-            definition: Named("llvm.x86.avx2.pavg.w")
+        "_mm256_fmaddsub_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
+            output: &::F32x8,
+            definition: Named("llvm.x86.fma.vfmaddsub.ps.256")
         },
-        "256_hadd_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.phadd.w")
+        "_mm256_fmaddsub_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
+            output: &::F64x4,
+            definition: Named("llvm.x86.fma.vfmaddsub.pd.256")
         },
-        "256_hadd_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.phadd.d")
+        "_mm_fmsub_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.fma.vfmsub.ps")
         },
-        "256_hadds_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.phadd.sw")
+        "_mm_fmsub_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.fma.vfmsub.pd")
         },
-        "256_hsub_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.phsub.w")
+        "_mm256_fmsub_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
+            output: &::F32x8,
+            definition: Named("llvm.x86.fma.vfmsub.ps.256")
         },
-        "256_hsub_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.phsub.d")
+        "_mm256_fmsub_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
+            output: &::F64x4,
+            definition: Named("llvm.x86.fma.vfmsub.pd.256")
         },
-        "256_hsubs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.phsub.sw")
+        "_mm_fmsubadd_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.fma.vfmsubadd.ps")
         },
-        "256_madd_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.pmadd.wd")
+        "_mm_fmsubadd_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.fma.vfmsubadd.pd")
         },
-        "256_maddubs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.pmadd.ub.sw")
+        "_mm256_fmsubadd_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
+            output: &::F32x8,
+            definition: Named("llvm.x86.fma.vfmsubadd.ps.256")
         },
-        "_mask_i32gather_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I32x4, { static PTR: Type = Type::Pointer(&::I32, Some(&::I8), true); &PTR }, &::I32x4, &::I32x4, &::I32_8]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.avx2.gather.d.d")
+        "_mm256_fmsubadd_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
+            output: &::F64x4,
+            definition: Named("llvm.x86.fma.vfmsubadd.pd.256")
         },
-        "_mask_i32gather_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::F32x4, { static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I32x4, &::I32x4_F32, &::I32_8]; &INPUTS },
+        "_mm_fnmadd_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
             output: &::F32x4,
-            definition: Named("llvm.x86.avx2.gather.d.ps")
+            definition: Named("llvm.x86.fma.vfnmadd.ps")
         },
-        "256_mask_i32gather_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I32x8, { static PTR: Type = Type::Pointer(&::I32, Some(&::I8), true); &PTR }, &::I32x8, &::I32x8, &::I32_8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.gather.d.d.256")
+        "_mm_fnmadd_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.fma.vfnmadd.pd")
         },
-        "256_mask_i32gather_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::F32x8, { static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I32x8, &::I32x8_F32, &::I32_8]; &INPUTS },
+        "_mm256_fnmadd_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
             output: &::F32x8,
-            definition: Named("llvm.x86.avx2.gather.d.ps.256")
+            definition: Named("llvm.x86.fma.vfnmadd.ps.256")
         },
-        "_mask_i32gather_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I64x2, { static PTR: Type = Type::Pointer(&::I64, Some(&::I8), true); &PTR }, &::I32x4, &::I64x2, &::I32_8]; &INPUTS },
-            output: &::I64x2,
-            definition: Named("llvm.x86.avx2.gather.d.q")
+        "_mm256_fnmadd_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
+            output: &::F64x4,
+            definition: Named("llvm.x86.fma.vfnmadd.pd.256")
         },
-        "_mask_i32gather_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::F64x2, { static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I32x4, &::I64x2_F64, &::I32_8]; &INPUTS },
+        "_mm_fnmsub_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.fma.vfnmsub.ps")
+        },
+        "_mm_fnmsub_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
             output: &::F64x2,
-            definition: Named("llvm.x86.avx2.gather.d.pd")
+            definition: Named("llvm.x86.fma.vfnmsub.pd")
         },
-        "256_mask_i32gather_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I64x4, { static PTR: Type = Type::Pointer(&::I64, Some(&::I8), true); &PTR }, &::I32x4, &::I64x4, &::I32_8]; &INPUTS },
-            output: &::I64x4,
-            definition: Named("llvm.x86.avx2.gather.d.q.256")
+        "_mm256_fnmsub_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
+            output: &::F32x8,
+            definition: Named("llvm.x86.fma.vfnmsub.ps.256")
         },
-        "256_mask_i32gather_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::F64x4, { static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I32x4, &::I64x4_F64, &::I32_8]; &INPUTS },
+        "_mm256_fnmsub_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
             output: &::F64x4,
-            definition: Named("llvm.x86.avx2.gather.d.pd.256")
+            definition: Named("llvm.x86.fma.vfnmsub.pd.256")
         },
-        "_mask_i64gather_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I32x4, { static PTR: Type = Type::Pointer(&::I32, Some(&::I8), true); &PTR }, &::I64x2, &::I32x4, &::I32_8]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.avx2.gather.q.d")
+        "_mm_adds_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.sse2.padds.b")
         },
-        "_mask_i64gather_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::F32x4, { static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I64x2, &::I32x4_F32, &::I32_8]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.avx2.gather.q.ps")
+        "_mm_adds_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
+            output: &::U8x16,
+            definition: Named("llvm.x86.sse2.paddus.b")
         },
-        "256_mask_i64gather_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I32x4, { static PTR: Type = Type::Pointer(&::I32, Some(&::I8), true); &PTR }, &::I64x4, &::I32x4, &::I32_8]; &INPUTS },
+        "_mm_adds_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.sse2.padds.w")
+        },
+        "_mm_adds_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse2.paddus.w")
+        },
+        "_mm_avg_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
+            output: &::U8x16,
+            definition: Named("llvm.x86.sse2.pavg.b")
+        },
+        "_mm_avg_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse2.pavg.w")
+        },
+        "_mm_lfence" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 0] = []; &INPUTS },
+            output: &::VOID,
+            definition: Named("llvm.x86.sse2.lfence")
+        },
+        "_mm_madd_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
             output: &::I32x4,
-            definition: Named("llvm.x86.avx2.gather.q.d")
+            definition: Named("llvm.x86.sse2.pmadd.wd")
         },
-        "256_mask_i64gather_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::F32x4, { static PTR: Type = Type::Pointer(&::F32, Some(&::I8), true); &PTR }, &::I64x4, &::I32x4_F32, &::I32_8]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.avx2.gather.q.ps")
+        "_mm_maskmoveu_si128" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::U8x16, &::U8x16, { static PTR: Type = Type::Pointer(&::U8, None, false); &PTR }]; &INPUTS },
+            output: &::VOID,
+            definition: Named("llvm.x86.sse2.maskmov.dqu")
         },
-        "_mask_i64gather_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I64x2, { static PTR: Type = Type::Pointer(&::I64, Some(&::I8), true); &PTR }, &::I64x2, &::I64x2, &::I32_8]; &INPUTS },
-            output: &::I64x2,
-            definition: Named("llvm.x86.avx2.gather.q.q")
+        "_mm_max_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.sse2.pmaxs.w")
         },
-        "_mask_i64gather_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::F64x2, { static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I64x2, &::I64x2_F64, &::I32_8]; &INPUTS },
+        "_mm_max_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
+            output: &::U8x16,
+            definition: Named("llvm.x86.sse2.pmaxu.b")
+        },
+        "_mm_max_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
             output: &::F64x2,
-            definition: Named("llvm.x86.avx2.gather.q.pd")
+            definition: Named("llvm.x86.sse2.max.pd")
         },
-        "256_mask_i64gather_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::I64x4, { static PTR: Type = Type::Pointer(&::I64, Some(&::I8), true); &PTR }, &::I64x4, &::I64x4, &::I32_8]; &INPUTS },
-            output: &::I64x4,
-            definition: Named("llvm.x86.avx2.gather.q.q.256")
+        "_mm_mfence" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 0] = []; &INPUTS },
+            output: &::VOID,
+            definition: Named("llvm.x86.sse2.fence")
         },
-        "256_mask_i64gather_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 5] = [&::F64x4, { static PTR: Type = Type::Pointer(&::F64, Some(&::I8), true); &PTR }, &::I64x4, &::I64x4_F64, &::I32_8]; &INPUTS },
-            output: &::F64x4,
-            definition: Named("llvm.x86.avx2.gather.q.pd.256")
+        "_mm_min_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.sse2.pmins.w")
         },
-        "_maskload_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::I32x4, Some(&::I8), true); &PTR }, &::I32x4]; &INPUTS },
-            output: &::I32x4,
-            definition: Named("llvm.x86.avx2.maskload.d")
+        "_mm_min_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
+            output: &::U8x16,
+            definition: Named("llvm.x86.sse2.pminu.b")
         },
-        "_maskload_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::I64x2, Some(&::I8), true); &PTR }, &::I64x2]; &INPUTS },
-            output: &::I64x2,
-            definition: Named("llvm.x86.avx2.maskload.q")
+        "_mm_min_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.sse2.min.pd")
         },
-        "256_maskload_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::I32x8, Some(&::I8), true); &PTR }, &::I32x8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.maskload.d.256")
+        "_mm_movemask_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::F64x2]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse2.movmsk.pd")
         },
-        "256_maskload_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::I64x4, Some(&::I8), true); &PTR }, &::I64x4]; &INPUTS },
-            output: &::I64x4,
-            definition: Named("llvm.x86.avx2.maskload.q.256")
+        "_mm_movemask_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse2.pmovmskb.128")
         },
-        "_maskstore_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::I32, Some(&::I8), false); &PTR }, &::I32x4, &::I32x4]; &INPUTS },
-            output: &::VOID,
-            definition: Named("llvm.x86.avx2.maskstore.d")
+        "_mm_mul_epu32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
+            output: &::U64x2,
+            definition: Named("llvm.x86.sse2.pmulu.dq")
         },
-        "_maskstore_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::I64, Some(&::I8), false); &PTR }, &::I64x2, &::I64x2]; &INPUTS },
+        "_mm_mulhi_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.sse2.pmulh.w")
+        },
+        "_mm_mulhi_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse2.pmulhu.w")
+        },
+        "_mm_packs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.sse2.packsswb.128")
+        },
+        "_mm_packs_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.sse2.packssdw.128")
+        },
+        "_mm_packus_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::U8x16,
+            definition: Named("llvm.x86.sse2.packuswb.128")
+        },
+        "_mm_sad_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
+            output: &::U64x2,
+            definition: Named("llvm.x86.sse2.psad.bw")
+        },
+        "_mm_sfence" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 0] = []; &INPUTS },
             output: &::VOID,
-            definition: Named("llvm.x86.avx2.maskstore.q")
+            definition: Named("llvm.x86.sse2.sfence")
         },
-        "256_maskstore_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::I32, Some(&::I8), false); &PTR }, &::I32x8, &::I32x8]; &INPUTS },
+        "_mm_sqrt_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.sqrt.v2f64")
+        },
+        "_mm_storeu_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F64, Some(&::U8), false); &PTR }, &::F64x2]; &INPUTS },
             output: &::VOID,
-            definition: Named("llvm.x86.avx2.maskstore.d.256")
+            definition: Named("llvm.x86.sse2.storeu.pd")
         },
-        "256_maskstore_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [{ static PTR: Type = Type::Pointer(&::I64, Some(&::I8), false); &PTR }, &::I64x4, &::I64x4]; &INPUTS },
+        "_mm_storeu_si128" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::U8x16, Some(&::U8), false); &PTR }, &::U8x16]; &INPUTS },
             output: &::VOID,
-            definition: Named("llvm.x86.avx2.maskstore.q.256")
+            definition: Named("llvm.x86.sse2.storeu.dq")
         },
-        "256_max_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
-            output: &::I8x32,
-            definition: Named("llvm.x86.avx2.pmaxs.b")
+        "_mm_subs_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.sse2.psubs.b")
         },
-        "256_max_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
-            output: &::U8x32,
-            definition: Named("llvm.x86.avx2.pmaxu.b")
+        "_mm_subs_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::U8x16]; &INPUTS },
+            output: &::U8x16,
+            definition: Named("llvm.x86.sse2.psubus.b")
         },
-        "256_max_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.pmaxs.w")
+        "_mm_subs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.sse2.psubs.w")
         },
-        "256_max_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
-            output: &::U16x16,
-            definition: Named("llvm.x86.avx2.pmaxu.w")
+        "_mm_subs_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse2.psubus.w")
         },
-        "256_max_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.pmaxs.d")
+        "_mm_addsub_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.sse3.addsub.ps")
         },
-        "256_max_epu32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x8, &::U32x8]; &INPUTS },
-            output: &::U32x8,
-            definition: Named("llvm.x86.avx2.pmaxu.d")
+        "_mm_addsub_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.sse3.addsub.pd")
         },
-        "256_min_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
-            output: &::I8x32,
-            definition: Named("llvm.x86.avx2.pmins.b")
+        "_mm_hadd_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.sse3.hadd.ps")
         },
-        "256_min_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
-            output: &::U8x32,
-            definition: Named("llvm.x86.avx2.pminu.b")
+        "_mm_hadd_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.sse3.hadd.pd")
         },
-        "256_min_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.pmins.w")
+        "_mm_hsub_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.sse3.hsub.ps")
         },
-        "256_min_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
-            output: &::U16x16,
-            definition: Named("llvm.x86.avx2.pminu.w")
+        "_mm_hsub_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F64x2, &::F64x2]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.sse3.hsub.pd")
         },
-        "256_min_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.pmins.d")
+        "_mm_lddqu_si128" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [{ static PTR: Type = Type::Pointer(&::U8x16, Some(&::I8), true); &PTR }]; &INPUTS },
+            output: &::U8x16,
+            definition: Named("llvm.x86.sse3.ldu.dq")
         },
-        "256_min_epu32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x8, &::U32x8]; &INPUTS },
-            output: &::U32x8,
-            definition: Named("llvm.x86.avx2.pminu.d")
+        "_mm_dp_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::I32_8]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.sse41.dpps")
         },
-        "256_movemask_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 1] = [&::I8x32]; &INPUTS },
-            output: &::I32,
-            definition: Named("llvm.x86.avx2.pmovmskb")
+        "_mm_dp_pd" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::I32_8]; &INPUTS },
+            output: &::F64x2,
+            definition: Named("llvm.x86.sse41.dppd")
         },
-        "256_mpsadbw_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::U8x32, &::U8x32, &::I32_8]; &INPUTS },
-            output: &::U16x16,
-            definition: Named("llvm.x86.avx2.mpsadbw")
+        "_mm_max_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.sse41.pmaxsb")
         },
-        "256_mul_epi64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::I64x4,
-            definition: Named("llvm.x86.avx2.pmulq.dq")
+        "_mm_max_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse41.pmaxuw")
         },
-        "256_mul_epu64" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x8, &::U32x8]; &INPUTS },
-            output: &::U64x4,
-            definition: Named("llvm.x86.avx2.pmulq.dq")
+        "_mm_max_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.sse41.pmaxsd")
         },
-        "256_mulhi_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.pmulhw.w")
+        "_mm_max_epu32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
+            output: &::U32x4,
+            definition: Named("llvm.x86.sse41.pmaxud")
         },
-        "256_mulhi_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
-            output: &::U16x16,
-            definition: Named("llvm.x86.avx2.pmulhw.w")
+        "_mm_min_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.sse41.pminsb")
         },
-        "256_mulhrs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.pmul.hr.sw")
+        "_mm_min_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x8, &::U16x8]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse41.pminuw")
         },
-        "256_packs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I8x32,
-            definition: Named("llvm.x86.avx2.packsswb")
+        "_mm_min_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.sse41.pminsd")
         },
-        "256_packus_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::U8x32,
-            definition: Named("llvm.x86.avx2.packuswb")
+        "_mm_min_epu32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32x4, &::U32x4]; &INPUTS },
+            output: &::U32x4,
+            definition: Named("llvm.x86.sse41.pminud")
         },
-        "256_packs_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.packssdw")
+        "_mm_minpos_epu16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::U16x8]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse41.phminposuw")
         },
-        "256_packus_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::U16x16,
-            definition: Named("llvm.x86.avx2.packusdw")
+        "_mm_mpsadbw_epu8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::U8x16, &::U8x16, &::I32_8]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse41.mpsadbw")
         },
-        "256_permutevar8x32_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.permd")
+        "_mm_mul_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+            output: &::I64x2,
+            definition: Named("llvm.x86.sse41.pmuldq")
         },
-        "256_permutevar8x32_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x8, &::I32x8]; &INPUTS },
-            output: &::F32x8,
-            definition: Named("llvm.x86.avx2.permps")
+        "_mm_packus_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+            output: &::U16x8,
+            definition: Named("llvm.x86.sse41.packusdw")
         },
-        "256_sad_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
-            output: &::U8x32,
-            definition: Named("llvm.x86.avx2.psad.bw")
+        "_mm_testc_si128" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse41.ptestc")
         },
-        "256_shuffle_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
-            output: &::I8x32,
-            definition: Named("llvm.x86.avx2.pshuf.b")
+        "_mm_testnzc_si128" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse41.ptestnzc")
         },
-        "256_sign_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
-            output: &::I8x32,
-            definition: Named("llvm.x86.avx2.psign.b")
+        "_mm_testz_si128" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U64x2, &::U64x2]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse41.ptestz")
         },
-        "256_sign_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.psign.w")
+        "_mm_cmpestra" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpestria128")
         },
-        "256_sign_epi32" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x8, &::I32x8]; &INPUTS },
-            output: &::I32x8,
-            definition: Named("llvm.x86.avx2.psign.d")
+        "_mm_cmpestrc" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpestric128")
         },
-        "256_subs_epi8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x32, &::I8x32]; &INPUTS },
-            output: &::I8x32,
-            definition: Named("llvm.x86.avx2.psubs.b")
+        "_mm_cmpestri" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpestri128")
         },
-        "256_subs_epu8" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x32, &::U8x32]; &INPUTS },
-            output: &::U8x32,
-            definition: Named("llvm.x86.avx2.psubus.b")
+        "_mm_cmpestrm" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.sse42.pcmpestrm128")
         },
-        "256_subs_epi16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x16, &::I16x16]; &INPUTS },
-            output: &::I16x16,
-            definition: Named("llvm.x86.avx2.psubs.w")
+        "_mm_cmpestro" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpestrio128")
         },
-        "256_subs_epu16" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 2] = [&::U16x16, &::U16x16]; &INPUTS },
-            output: &::U16x16,
-            definition: Named("llvm.x86.avx2.psubus.w")
+        "_mm_cmpestrs" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpestris128")
         },
-        "_fmadd_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.fma.vfmadd.ps")
+        "_mm_cmpestrz" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 5] = [&::I8x16, &::I32, &::I8x16, &::I32, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpestriz128")
         },
-        "_fmadd_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.fma.vfmadd.pd")
+        "_mm_cmpistra" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpistria128")
         },
-        "256_fmadd_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
-            output: &::F32x8,
-            definition: Named("llvm.x86.fma.vfmadd.ps.256")
+        "_mm_cmpistrc" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpistric128")
         },
-        "256_fmadd_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
-            output: &::F64x4,
-            definition: Named("llvm.x86.fma.vfmadd.pd.256")
+        "_mm_cmpistri" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpistri128")
         },
-        "_fmaddsub_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.fma.vfmaddsub.ps")
+        "_mm_cmpistrm" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.sse42.pcmpistrm128")
         },
-        "_fmaddsub_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.fma.vfmaddsub.pd")
+        "_mm_cmpistro" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpistrio128")
         },
-        "256_fmaddsub_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
-            output: &::F32x8,
-            definition: Named("llvm.x86.fma.vfmaddsub.ps.256")
+        "_mm_cmpistrs" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpistris128")
         },
-        "256_fmaddsub_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
-            output: &::F64x4,
-            definition: Named("llvm.x86.fma.vfmaddsub.pd.256")
+        "_mm_cmpistrz" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 3] = [&::I8x16, &::I8x16, &::I32_8]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse42.pcmpistriz128")
         },
-        "_fmsub_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
+        "_mm_movemask_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
+            output: &::I32,
+            definition: Named("llvm.x86.sse.movmsk.ps")
+        },
+        "_mm_max_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
             output: &::F32x4,
-            definition: Named("llvm.x86.fma.vfmsub.ps")
+            definition: Named("llvm.x86.sse.max.ps")
         },
-        "_fmsub_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.fma.vfmsub.pd")
+        "_mm_min_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::F32x4, &::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.sse.min.ps")
         },
-        "256_fmsub_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
-            output: &::F32x8,
-            definition: Named("llvm.x86.fma.vfmsub.ps.256")
+        "_mm_rsqrt_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.sse.rsqrt.ps")
         },
-        "256_fmsub_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
-            output: &::F64x4,
-            definition: Named("llvm.x86.fma.vfmsub.pd.256")
+        "_mm_rcp_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
+            output: &::F32x4,
+            definition: Named("llvm.x86.sse.rcp.ps")
         },
-        "_fmsubadd_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
+        "_mm_sqrt_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::F32x4]; &INPUTS },
             output: &::F32x4,
-            definition: Named("llvm.x86.fma.vfmsubadd.ps")
+            definition: Named("llvm.sqrt.v4f32")
         },
-        "_fmsubadd_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.fma.vfmsubadd.pd")
+        "_mm_storeu_ps" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [{ static PTR: Type = Type::Pointer(&::F32, Some(&::I8), false); &PTR }, &::F32x4]; &INPUTS },
+            output: &::VOID,
+            definition: Named("llvm.x86.sse.storeu.ps")
         },
-        "256_fmsubadd_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
-            output: &::F32x8,
-            definition: Named("llvm.x86.fma.vfmsubadd.ps.256")
+        "_mm_abs_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::I8x16]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.ssse3.pabs.b.128")
         },
-        "256_fmsubadd_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
-            output: &::F64x4,
-            definition: Named("llvm.x86.fma.vfmsubadd.pd.256")
+        "_mm_abs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.ssse3.pabs.w.128")
         },
-        "_fnmadd_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.fma.vfnmadd.ps")
+        "_mm_abs_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 1] = [&::I32x4]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.ssse3.pabs.d.128")
         },
-        "_fnmadd_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.fma.vfnmadd.pd")
+        "_mm_hadd_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.ssse3.phadd.w.128")
         },
-        "256_fnmadd_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
-            output: &::F32x8,
-            definition: Named("llvm.x86.fma.vfnmadd.ps.256")
+        "_mm_hadd_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.ssse3.phadd.d.128")
         },
-        "256_fnmadd_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
-            output: &::F64x4,
-            definition: Named("llvm.x86.fma.vfnmadd.pd.256")
+        "_mm_hadds_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.ssse3.phadd.sw.128")
         },
-        "_fnmsub_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x4, &::F32x4, &::F32x4]; &INPUTS },
-            output: &::F32x4,
-            definition: Named("llvm.x86.fma.vfnmsub.ps")
+        "_mm_hsub_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.ssse3.phsub.w.128")
         },
-        "_fnmsub_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x2, &::F64x2, &::F64x2]; &INPUTS },
-            output: &::F64x2,
-            definition: Named("llvm.x86.fma.vfnmsub.pd")
+        "_mm_hsub_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.ssse3.phsub.d.128")
         },
-        "256_fnmsub_ps" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F32x8, &::F32x8, &::F32x8]; &INPUTS },
-            output: &::F32x8,
-            definition: Named("llvm.x86.fma.vfnmsub.ps.256")
+        "_mm_hsubs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.ssse3.phsub.sw.128")
         },
-        "256_fnmsub_pd" => Intrinsic {
-            inputs: { static INPUTS: [&'static Type; 3] = [&::F64x4, &::F64x4, &::F64x4]; &INPUTS },
-            output: &::F64x4,
-            definition: Named("llvm.x86.fma.vfnmsub.pd.256")
+        "_mm_maddubs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U8x16, &::I8x16]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.ssse3.pmadd.ub.sw.128")
+        },
+        "_mm_mulhrs_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.ssse3.pmul.hr.sw.128")
+        },
+        "_mm_shuffle_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.ssse3.pshuf.b.128")
+        },
+        "_mm_sign_epi8" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I8x16, &::I8x16]; &INPUTS },
+            output: &::I8x16,
+            definition: Named("llvm.x86.ssse3.psign.b.128")
+        },
+        "_mm_sign_epi16" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I16x8, &::I16x8]; &INPUTS },
+            output: &::I16x8,
+            definition: Named("llvm.x86.ssse3.psign.w.128")
+        },
+        "_mm_sign_epi32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::I32x4, &::I32x4]; &INPUTS },
+            output: &::I32x4,
+            definition: Named("llvm.x86.ssse3.psign.d.128")
+        },
+        "_tbm_bextri_u32" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U32, &::U32]; &INPUTS },
+            output: &::U32,
+            definition: Named("llvm.x86.tbm.bextri.u32")
+        },
+        "_tbm_bextri_u64" => Intrinsic {
+            inputs: { static INPUTS: [&'static Type; 2] = [&::U64, &::U64]; &INPUTS },
+            output: &::U64,
+            definition: Named("llvm.x86.tbm.bextri.u64")
         },
         _ => return None,
     })