r202703 - AArch64: convert NEON tests to use CHECK-LABEL.

Tim Northover tnorthover at apple.com
Mon Mar 3 03:34:37 PST 2014


Author: tnorthover
Date: Mon Mar  3 05:34:36 2014
New Revision: 202703

URL: http://llvm.org/viewvc/llvm-project?rev=202703&view=rev
Log:
AArch64: convert NEON tests to use CHECK-LABEL.

Modified:
    cfe/trunk/test/CodeGen/aarch64-neon-2velem.c
    cfe/trunk/test/CodeGen/aarch64-neon-across.c
    cfe/trunk/test/CodeGen/aarch64-neon-copy.c
    cfe/trunk/test/CodeGen/aarch64-neon-extract.c
    cfe/trunk/test/CodeGen/aarch64-neon-fcvt-intrinsics.c
    cfe/trunk/test/CodeGen/aarch64-neon-intrinsics.c
    cfe/trunk/test/CodeGen/aarch64-neon-misc.c
    cfe/trunk/test/CodeGen/aarch64-neon-perm.c
    cfe/trunk/test/CodeGen/aarch64-neon-scalar-copy.c
    cfe/trunk/test/CodeGen/aarch64-neon-scalar-x-indexed-elem.c
    cfe/trunk/test/CodeGen/aarch64-neon-tbl.c
    cfe/trunk/test/CodeGen/aarch64-poly128.c
    cfe/trunk/test/CodeGen/aarch64-poly64.c

Modified: cfe/trunk/test/CodeGen/aarch64-neon-2velem.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-2velem.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-2velem.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-2velem.c Mon Mar  3 05:34:36 2014
@@ -9,265 +9,265 @@
 #include <arm_neon.h>
 
 int16x4_t test_vmla_lane_s16(int16x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmla_lane_s16
+  // CHECK-LABEL: test_vmla_lane_s16
   return vmla_lane_s16(a, b, v, 3);
   // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int16x8_t test_vmlaq_lane_s16(int16x8_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlaq_lane_s16
+  // CHECK-LABEL: test_vmlaq_lane_s16
   return vmlaq_lane_s16(a, b, v, 3);
   // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int32x2_t test_vmla_lane_s32(int32x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmla_lane_s32
+  // CHECK-LABEL: test_vmla_lane_s32
   return vmla_lane_s32(a, b, v, 1);
   // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlaq_lane_s32(int32x4_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlaq_lane_s32
+  // CHECK-LABEL: test_vmlaq_lane_s32
   return vmlaq_lane_s32(a, b, v, 1);
   // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int16x4_t test_vmla_laneq_s16(int16x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmla_laneq_s16
+  // CHECK-LABEL: test_vmla_laneq_s16
   return vmla_laneq_s16(a, b, v, 7);
   // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 int16x8_t test_vmlaq_laneq_s16(int16x8_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlaq_laneq_s16
+  // CHECK-LABEL: test_vmlaq_laneq_s16
   return vmlaq_laneq_s16(a, b, v, 7);
   // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int32x2_t test_vmla_laneq_s32(int32x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmla_laneq_s32
+  // CHECK-LABEL: test_vmla_laneq_s32
   return vmla_laneq_s32(a, b, v, 3);
   // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlaq_laneq_s32(int32x4_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlaq_laneq_s32
+  // CHECK-LABEL: test_vmlaq_laneq_s32
   return vmlaq_laneq_s32(a, b, v, 3);
   // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 int16x4_t test_vmls_lane_s16(int16x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmls_lane_s16
+  // CHECK-LABEL: test_vmls_lane_s16
   return vmls_lane_s16(a, b, v, 3);
   // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int16x8_t test_vmlsq_lane_s16(int16x8_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlsq_lane_s16
+  // CHECK-LABEL: test_vmlsq_lane_s16
   return vmlsq_lane_s16(a, b, v, 3);
   // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int32x2_t test_vmls_lane_s32(int32x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmls_lane_s32
+  // CHECK-LABEL: test_vmls_lane_s32
   return vmls_lane_s32(a, b, v, 1);
   // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlsq_lane_s32(int32x4_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlsq_lane_s32
+  // CHECK-LABEL: test_vmlsq_lane_s32
   return vmlsq_lane_s32(a, b, v, 1);
   // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int16x4_t test_vmls_laneq_s16(int16x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmls_laneq_s16
+  // CHECK-LABEL: test_vmls_laneq_s16
   return vmls_laneq_s16(a, b, v, 7);
   // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 int16x8_t test_vmlsq_laneq_s16(int16x8_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlsq_laneq_s16
+  // CHECK-LABEL: test_vmlsq_laneq_s16
   return vmlsq_laneq_s16(a, b, v, 7);
   // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int32x2_t test_vmls_laneq_s32(int32x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmls_laneq_s32
+  // CHECK-LABEL: test_vmls_laneq_s32
   return vmls_laneq_s32(a, b, v, 3);
   // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlsq_laneq_s32(int32x4_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlsq_laneq_s32
+  // CHECK-LABEL: test_vmlsq_laneq_s32
   return vmlsq_laneq_s32(a, b, v, 3);
   // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 int16x4_t test_vmul_lane_s16(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vmul_lane_s16
+  // CHECK-LABEL: test_vmul_lane_s16
   return vmul_lane_s16(a, v, 3);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int16x8_t test_vmulq_lane_s16(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vmulq_lane_s16
+  // CHECK-LABEL: test_vmulq_lane_s16
   return vmulq_lane_s16(a, v, 3);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int32x2_t test_vmul_lane_s32(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vmul_lane_s32
+  // CHECK-LABEL: test_vmul_lane_s32
   return vmul_lane_s32(a, v, 1);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmulq_lane_s32(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vmulq_lane_s32
+  // CHECK-LABEL: test_vmulq_lane_s32
   return vmulq_lane_s32(a, v, 1);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 uint16x4_t test_vmul_lane_u16(uint16x4_t a, uint16x4_t v) {
-  // CHECK: test_vmul_lane_u16
+  // CHECK-LABEL: test_vmul_lane_u16
   return vmul_lane_u16(a, v, 3);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 uint16x8_t test_vmulq_lane_u16(uint16x8_t a, uint16x4_t v) {
-  // CHECK: test_vmulq_lane_u16
+  // CHECK-LABEL: test_vmulq_lane_u16
   return vmulq_lane_u16(a, v, 3);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 uint32x2_t test_vmul_lane_u32(uint32x2_t a, uint32x2_t v) {
-  // CHECK: test_vmul_lane_u32
+  // CHECK-LABEL: test_vmul_lane_u32
   return vmul_lane_u32(a, v, 1);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 uint32x4_t test_vmulq_lane_u32(uint32x4_t a, uint32x2_t v) {
-  // CHECK: test_vmulq_lane_u32
+  // CHECK-LABEL: test_vmulq_lane_u32
   return vmulq_lane_u32(a, v, 1);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int16x4_t test_vmul_laneq_s16(int16x4_t a, int16x8_t v) {
-  // CHECK: test_vmul_laneq_s16
+  // CHECK-LABEL: test_vmul_laneq_s16
   return vmul_laneq_s16(a, v, 7);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 int16x8_t test_vmulq_laneq_s16(int16x8_t a, int16x8_t v) {
-  // CHECK: test_vmulq_laneq_s16
+  // CHECK-LABEL: test_vmulq_laneq_s16
   return vmulq_laneq_s16(a, v, 7);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int32x2_t test_vmul_laneq_s32(int32x2_t a, int32x4_t v) {
-  // CHECK: test_vmul_laneq_s32
+  // CHECK-LABEL: test_vmul_laneq_s32
   return vmul_laneq_s32(a, v, 3);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmulq_laneq_s32(int32x4_t a, int32x4_t v) {
-  // CHECK: test_vmulq_laneq_s32
+  // CHECK-LABEL: test_vmulq_laneq_s32
   return vmulq_laneq_s32(a, v, 3);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 uint16x4_t test_vmul_laneq_u16(uint16x4_t a, uint16x8_t v) {
-  // CHECK: test_vmul_laneq_u16
+  // CHECK-LABEL: test_vmul_laneq_u16
   return vmul_laneq_u16(a, v, 7);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 uint16x8_t test_vmulq_laneq_u16(uint16x8_t a, uint16x8_t v) {
-  // CHECK: test_vmulq_laneq_u16
+  // CHECK-LABEL: test_vmulq_laneq_u16
   return vmulq_laneq_u16(a, v, 7);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 uint32x2_t test_vmul_laneq_u32(uint32x2_t a, uint32x4_t v) {
-  // CHECK: test_vmul_laneq_u32
+  // CHECK-LABEL: test_vmul_laneq_u32
   return vmul_laneq_u32(a, v, 3);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 uint32x4_t test_vmulq_laneq_u32(uint32x4_t a, uint32x4_t v) {
-  // CHECK: test_vmulq_laneq_u32
+  // CHECK-LABEL: test_vmulq_laneq_u32
   return vmulq_laneq_u32(a, v, 3);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 float32x2_t test_vfma_lane_f32(float32x2_t a, float32x2_t b, float32x2_t v) {
-  // CHECK: test_vfma_lane_f32
+  // CHECK-LABEL: test_vfma_lane_f32
   return vfma_lane_f32(a, b, v, 1);
   // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 float32x4_t test_vfmaq_lane_f32(float32x4_t a, float32x4_t b, float32x2_t v) {
-  // CHECK: test_vfmaq_lane_f32
+  // CHECK-LABEL: test_vfmaq_lane_f32
   return vfmaq_lane_f32(a, b, v, 1);
   // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 float32x2_t test_vfma_laneq_f32(float32x2_t a, float32x2_t b, float32x4_t v) {
-  // CHECK: test_vfma_laneq_f32
+  // CHECK-LABEL: test_vfma_laneq_f32
   return vfma_laneq_f32(a, b, v, 3);
   // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 float32x4_t test_vfmaq_laneq_f32(float32x4_t a, float32x4_t b, float32x4_t v) {
-  // CHECK: test_vfmaq_laneq_f32
+  // CHECK-LABEL: test_vfmaq_laneq_f32
   return vfmaq_laneq_f32(a, b, v, 3);
   // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 float32x2_t test_vfms_lane_f32(float32x2_t a, float32x2_t b, float32x2_t v) {
-  // CHECK: test_vfms_lane_f32
+  // CHECK-LABEL: test_vfms_lane_f32
   return vfms_lane_f32(a, b, v, 1);
   // CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 float32x4_t test_vfmsq_lane_f32(float32x4_t a, float32x4_t b, float32x2_t v) {
-  // CHECK: test_vfmsq_lane_f32
+  // CHECK-LABEL: test_vfmsq_lane_f32
   return vfmsq_lane_f32(a, b, v, 1);
   // CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 float32x2_t test_vfms_laneq_f32(float32x2_t a, float32x2_t b, float32x4_t v) {
-  // CHECK: test_vfms_laneq_f32
+  // CHECK-LABEL: test_vfms_laneq_f32
   return vfms_laneq_f32(a, b, v, 3);
   // CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 float32x4_t test_vfmsq_laneq_f32(float32x4_t a, float32x4_t b, float32x4_t v) {
-  // CHECK: test_vfmsq_laneq_f32
+  // CHECK-LABEL: test_vfmsq_laneq_f32
   return vfmsq_laneq_f32(a, b, v, 3);
   // CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 float64x2_t test_vfmaq_lane_f64(float64x2_t a, float64x2_t b, float64x1_t v) {
-  // CHECK: test_vfmaq_lane_f64
+  // CHECK-LABEL: test_vfmaq_lane_f64
   return vfmaq_lane_f64(a, b, v, 0);
   // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float64x2_t test_vfmaq_laneq_f64(float64x2_t a, float64x2_t b, float64x2_t v) {
-  // CHECK: test_vfmaq_laneq_f64
+  // CHECK-LABEL: test_vfmaq_laneq_f64
   return vfmaq_laneq_f64(a, b, v, 1);
   // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
 }
 
 float64x2_t test_vfmsq_lane_f64(float64x2_t a, float64x2_t b, float64x1_t v) {
-  // CHECK: test_vfmsq_lane_f64
+  // CHECK-LABEL: test_vfmsq_lane_f64
   return vfmsq_lane_f64(a, b, v, 0);
   // CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float64x2_t test_vfmsq_laneq_f64(float64x2_t a, float64x2_t b, float64x2_t v) {
-  // CHECK: test_vfmsq_laneq_f64
+  // CHECK-LABEL: test_vfmsq_laneq_f64
   return vfmsq_laneq_f64(a, b, v, 1);
   // CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
 }
@@ -297,1426 +297,1426 @@ float64_t test_vfmsd_laneq_f64(float64_t
 }
 
 int32x4_t test_vmlal_lane_s16(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmlal_lane_s16
+  // CHECK-LABEL: test_vmlal_lane_s16
   return vmlal_lane_s16(a, b, v, 3);
   // CHECK: smlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmlal_lane_s32(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmlal_lane_s32
+  // CHECK-LABEL: test_vmlal_lane_s32
   return vmlal_lane_s32(a, b, v, 1);
   // CHECK: smlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlal_laneq_s16(int32x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmlal_laneq_s16
+  // CHECK-LABEL: test_vmlal_laneq_s16
   return vmlal_laneq_s16(a, b, v, 7);
   // CHECK: smlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmlal_laneq_s32(int64x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmlal_laneq_s32
+  // CHECK-LABEL: test_vmlal_laneq_s32
   return vmlal_laneq_s32(a, b, v, 3);
   // CHECK: smlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlal_high_lane_s16(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlal_high_lane_s16
+  // CHECK-LABEL: test_vmlal_high_lane_s16
   return vmlal_high_lane_s16(a, b, v, 3);
   // CHECK: smlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmlal_high_lane_s32(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlal_high_lane_s32
+  // CHECK-LABEL: test_vmlal_high_lane_s32
   return vmlal_high_lane_s32(a, b, v, 1);
   // CHECK: smlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlal_high_laneq_s16(int32x4_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlal_high_laneq_s16
+  // CHECK-LABEL: test_vmlal_high_laneq_s16
   return vmlal_high_laneq_s16(a, b, v, 7);
   // CHECK: smlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmlal_high_laneq_s32(int64x2_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlal_high_laneq_s32
+  // CHECK-LABEL: test_vmlal_high_laneq_s32
   return vmlal_high_laneq_s32(a, b, v, 3);
   // CHECK: smlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlsl_lane_s16(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmlsl_lane_s16
+  // CHECK-LABEL: test_vmlsl_lane_s16
   return vmlsl_lane_s16(a, b, v, 3);
   // CHECK: smlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmlsl_lane_s32(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmlsl_lane_s32
+  // CHECK-LABEL: test_vmlsl_lane_s32
   return vmlsl_lane_s32(a, b, v, 1);
   // CHECK: smlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlsl_laneq_s16(int32x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmlsl_laneq_s16
+  // CHECK-LABEL: test_vmlsl_laneq_s16
   return vmlsl_laneq_s16(a, b, v, 7);
   // CHECK: smlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmlsl_laneq_s32(int64x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmlsl_laneq_s32
+  // CHECK-LABEL: test_vmlsl_laneq_s32
   return vmlsl_laneq_s32(a, b, v, 3);
   // CHECK: smlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlsl_high_lane_s16(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlsl_high_lane_s16
+  // CHECK-LABEL: test_vmlsl_high_lane_s16
   return vmlsl_high_lane_s16(a, b, v, 3);
   // CHECK: smlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmlsl_high_lane_s32(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlsl_high_lane_s32
+  // CHECK-LABEL: test_vmlsl_high_lane_s32
   return vmlsl_high_lane_s32(a, b, v, 1);
   // CHECK: smlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlsl_high_laneq_s16(int32x4_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlsl_high_laneq_s16
+  // CHECK-LABEL: test_vmlsl_high_laneq_s16
   return vmlsl_high_laneq_s16(a, b, v, 7);
   // CHECK: smlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmlsl_high_laneq_s32(int64x2_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlsl_high_laneq_s32
+  // CHECK-LABEL: test_vmlsl_high_laneq_s32
   return vmlsl_high_laneq_s32(a, b, v, 3);
   // CHECK: smlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlal_lane_u16(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmlal_lane_u16
+  // CHECK-LABEL: test_vmlal_lane_u16
   return vmlal_lane_u16(a, b, v, 3);
   // CHECK: umlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmlal_lane_u32(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmlal_lane_u32
+  // CHECK-LABEL: test_vmlal_lane_u32
   return vmlal_lane_u32(a, b, v, 1);
   // CHECK: umlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlal_laneq_u16(int32x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmlal_laneq_u16
+  // CHECK-LABEL: test_vmlal_laneq_u16
   return vmlal_laneq_u16(a, b, v, 7);
   // CHECK: umlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmlal_laneq_u32(int64x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmlal_laneq_u32
+  // CHECK-LABEL: test_vmlal_laneq_u32
   return vmlal_laneq_u32(a, b, v, 3);
   // CHECK: umlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlal_high_lane_u16(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlal_high_lane_u16
+  // CHECK-LABEL: test_vmlal_high_lane_u16
   return vmlal_high_lane_u16(a, b, v, 3);
   // CHECK: umlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmlal_high_lane_u32(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlal_high_lane_u32
+  // CHECK-LABEL: test_vmlal_high_lane_u32
   return vmlal_high_lane_u32(a, b, v, 1);
   // CHECK: umlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlal_high_laneq_u16(int32x4_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlal_high_laneq_u16
+  // CHECK-LABEL: test_vmlal_high_laneq_u16
   return vmlal_high_laneq_u16(a, b, v, 7);
   // CHECK: umlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmlal_high_laneq_u32(int64x2_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlal_high_laneq_u32
+  // CHECK-LABEL: test_vmlal_high_laneq_u32
   return vmlal_high_laneq_u32(a, b, v, 3);
   // CHECK: umlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlsl_lane_u16(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmlsl_lane_u16
+  // CHECK-LABEL: test_vmlsl_lane_u16
   return vmlsl_lane_u16(a, b, v, 3);
   // CHECK: umlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmlsl_lane_u32(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmlsl_lane_u32
+  // CHECK-LABEL: test_vmlsl_lane_u32
   return vmlsl_lane_u32(a, b, v, 1);
   // CHECK: umlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlsl_laneq_u16(int32x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmlsl_laneq_u16
+  // CHECK-LABEL: test_vmlsl_laneq_u16
   return vmlsl_laneq_u16(a, b, v, 7);
   // CHECK: umlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmlsl_laneq_u32(int64x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmlsl_laneq_u32
+  // CHECK-LABEL: test_vmlsl_laneq_u32
   return vmlsl_laneq_u32(a, b, v, 3);
   // CHECK: umlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmlsl_high_lane_u16(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlsl_high_lane_u16
+  // CHECK-LABEL: test_vmlsl_high_lane_u16
   return vmlsl_high_lane_u16(a, b, v, 3);
   // CHECK: umlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmlsl_high_lane_u32(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlsl_high_lane_u32
+  // CHECK-LABEL: test_vmlsl_high_lane_u32
   return vmlsl_high_lane_u32(a, b, v, 1);
   // CHECK: umlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmlsl_high_laneq_u16(int32x4_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlsl_high_laneq_u16
+  // CHECK-LABEL: test_vmlsl_high_laneq_u16
   return vmlsl_high_laneq_u16(a, b, v, 7);
   // CHECK: umlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmlsl_high_laneq_u32(int64x2_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlsl_high_laneq_u32
+  // CHECK-LABEL: test_vmlsl_high_laneq_u32
   return vmlsl_high_laneq_u32(a, b, v, 3);
   // CHECK: umlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmull_lane_s16(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vmull_lane_s16
+  // CHECK-LABEL: test_vmull_lane_s16
   return vmull_lane_s16(a, v, 3);
   // CHECK: smull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmull_lane_s32(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vmull_lane_s32
+  // CHECK-LABEL: test_vmull_lane_s32
   return vmull_lane_s32(a, v, 1);
   // CHECK: smull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 uint32x4_t test_vmull_lane_u16(uint16x4_t a, uint16x4_t v) {
-  // CHECK: test_vmull_lane_u16
+  // CHECK-LABEL: test_vmull_lane_u16
   return vmull_lane_u16(a, v, 3);
   // CHECK: umull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 uint64x2_t test_vmull_lane_u32(uint32x2_t a, uint32x2_t v) {
-  // CHECK: test_vmull_lane_u32
+  // CHECK-LABEL: test_vmull_lane_u32
   return vmull_lane_u32(a, v, 1);
   // CHECK: umull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmull_high_lane_s16(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vmull_high_lane_s16
+  // CHECK-LABEL: test_vmull_high_lane_s16
   return vmull_high_lane_s16(a, v, 3);
   // CHECK: smull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vmull_high_lane_s32(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vmull_high_lane_s32
+  // CHECK-LABEL: test_vmull_high_lane_s32
   return vmull_high_lane_s32(a, v, 1);
   // CHECK: smull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 uint32x4_t test_vmull_high_lane_u16(uint16x8_t a, uint16x4_t v) {
-  // CHECK: test_vmull_high_lane_u16
+  // CHECK-LABEL: test_vmull_high_lane_u16
   return vmull_high_lane_u16(a, v, 3);
   // CHECK: umull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 uint64x2_t test_vmull_high_lane_u32(uint32x4_t a, uint32x2_t v) {
-  // CHECK: test_vmull_high_lane_u32
+  // CHECK-LABEL: test_vmull_high_lane_u32
   return vmull_high_lane_u32(a, v, 1);
   // CHECK: umull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vmull_laneq_s16(int16x4_t a, int16x8_t v) {
-  // CHECK: test_vmull_laneq_s16
+  // CHECK-LABEL: test_vmull_laneq_s16
   return vmull_laneq_s16(a, v, 7);
   // CHECK: smull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmull_laneq_s32(int32x2_t a, int32x4_t v) {
-  // CHECK: test_vmull_laneq_s32
+  // CHECK-LABEL: test_vmull_laneq_s32
   return vmull_laneq_s32(a, v, 3);
   // CHECK: smull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 uint32x4_t test_vmull_laneq_u16(uint16x4_t a, uint16x8_t v) {
-  // CHECK: test_vmull_laneq_u16
+  // CHECK-LABEL: test_vmull_laneq_u16
   return vmull_laneq_u16(a, v, 7);
   // CHECK: umull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 }
 
 uint64x2_t test_vmull_laneq_u32(uint32x2_t a, uint32x4_t v) {
-  // CHECK: test_vmull_laneq_u32
+  // CHECK-LABEL: test_vmull_laneq_u32
   return vmull_laneq_u32(a, v, 3);
   // CHECK: umull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vmull_high_laneq_s16(int16x8_t a, int16x8_t v) {
-  // CHECK: test_vmull_high_laneq_s16
+  // CHECK-LABEL: test_vmull_high_laneq_s16
   return vmull_high_laneq_s16(a, v, 7);
   // CHECK: smull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vmull_high_laneq_s32(int32x4_t a, int32x4_t v) {
-  // CHECK: test_vmull_high_laneq_s32
+  // CHECK-LABEL: test_vmull_high_laneq_s32
   return vmull_high_laneq_s32(a, v, 3);
   // CHECK: smull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 uint32x4_t test_vmull_high_laneq_u16(uint16x8_t a, uint16x8_t v) {
-  // CHECK: test_vmull_high_laneq_u16
+  // CHECK-LABEL: test_vmull_high_laneq_u16
   return vmull_high_laneq_u16(a, v, 7);
   // CHECK: umull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 uint64x2_t test_vmull_high_laneq_u32(uint32x4_t a, uint32x4_t v) {
-  // CHECK: test_vmull_high_laneq_u32
+  // CHECK-LABEL: test_vmull_high_laneq_u32
   return vmull_high_laneq_u32(a, v, 3);
   // CHECK: umull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vqdmlal_lane_s16(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vqdmlal_lane_s16
+  // CHECK-LABEL: test_vqdmlal_lane_s16
   return vqdmlal_lane_s16(a, b, v, 3);
   // CHECK: sqdmlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vqdmlal_lane_s32(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vqdmlal_lane_s32
+  // CHECK-LABEL: test_vqdmlal_lane_s32
   return vqdmlal_lane_s32(a, b, v, 1);
   // CHECK: sqdmlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vqdmlal_high_lane_s16(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vqdmlal_high_lane_s16
+  // CHECK-LABEL: test_vqdmlal_high_lane_s16
   return vqdmlal_high_lane_s16(a, b, v, 3);
   // CHECK: sqdmlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vqdmlal_high_lane_s32(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vqdmlal_high_lane_s32
+  // CHECK-LABEL: test_vqdmlal_high_lane_s32
   return vqdmlal_high_lane_s32(a, b, v, 1);
   // CHECK: sqdmlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vqdmlsl_lane_s16(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vqdmlsl_lane_s16
+  // CHECK-LABEL: test_vqdmlsl_lane_s16
   return vqdmlsl_lane_s16(a, b, v, 3);
   // CHECK: sqdmlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vqdmlsl_lane_s32(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vqdmlsl_lane_s32
+  // CHECK-LABEL: test_vqdmlsl_lane_s32
   return vqdmlsl_lane_s32(a, b, v, 1);
   // CHECK: sqdmlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vqdmlsl_high_lane_s16(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vqdmlsl_high_lane_s16
+  // CHECK-LABEL: test_vqdmlsl_high_lane_s16
   return vqdmlsl_high_lane_s16(a, b, v, 3);
   // CHECK: sqdmlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vqdmlsl_high_lane_s32(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vqdmlsl_high_lane_s32
+  // CHECK-LABEL: test_vqdmlsl_high_lane_s32
   return vqdmlsl_high_lane_s32(a, b, v, 1);
   // CHECK: sqdmlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vqdmull_lane_s16(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vqdmull_lane_s16
+  // CHECK-LABEL: test_vqdmull_lane_s16
   return vqdmull_lane_s16(a, v, 3);
   // CHECK: sqdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vqdmull_lane_s32(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vqdmull_lane_s32
+  // CHECK-LABEL: test_vqdmull_lane_s32
   return vqdmull_lane_s32(a, v, 1);
   // CHECK: sqdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vqdmull_laneq_s16(int16x4_t a, int16x8_t v) {
-  // CHECK: test_vqdmull_laneq_s16
+  // CHECK-LABEL: test_vqdmull_laneq_s16
   return vqdmull_laneq_s16(a, v, 3);
   // CHECK: sqdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vqdmull_laneq_s32(int32x2_t a, int32x4_t v) {
-  // CHECK: test_vqdmull_laneq_s32
+  // CHECK-LABEL: test_vqdmull_laneq_s32
   return vqdmull_laneq_s32(a, v, 3);
   // CHECK: sqdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 int32x4_t test_vqdmull_high_lane_s16(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vqdmull_high_lane_s16
+  // CHECK-LABEL: test_vqdmull_high_lane_s16
   return vqdmull_high_lane_s16(a, v, 3);
   // CHECK: sqdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int64x2_t test_vqdmull_high_lane_s32(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vqdmull_high_lane_s32
+  // CHECK-LABEL: test_vqdmull_high_lane_s32
   return vqdmull_high_lane_s32(a, v, 1);
   // CHECK: sqdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vqdmull_high_laneq_s16(int16x8_t a, int16x8_t v) {
-  // CHECK: test_vqdmull_high_laneq_s16
+  // CHECK-LABEL: test_vqdmull_high_laneq_s16
   return vqdmull_high_laneq_s16(a, v, 7);
   // CHECK: sqdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 }
 
 int64x2_t test_vqdmull_high_laneq_s32(int32x4_t a, int32x4_t v) {
-  // CHECK: test_vqdmull_high_laneq_s32
+  // CHECK-LABEL: test_vqdmull_high_laneq_s32
   return vqdmull_high_laneq_s32(a, v, 3);
   // CHECK: sqdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 int16x4_t test_vqdmulh_lane_s16(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vqdmulh_lane_s16
+  // CHECK-LABEL: test_vqdmulh_lane_s16
   return vqdmulh_lane_s16(a, v, 3);
   // CHECK: sqdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int16x8_t test_vqdmulhq_lane_s16(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vqdmulhq_lane_s16
+  // CHECK-LABEL: test_vqdmulhq_lane_s16
   return vqdmulhq_lane_s16(a, v, 3);
   // CHECK: sqdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int32x2_t test_vqdmulh_lane_s32(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vqdmulh_lane_s32
+  // CHECK-LABEL: test_vqdmulh_lane_s32
   return vqdmulh_lane_s32(a, v, 1);
   // CHECK: sqdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vqdmulhq_lane_s32(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vqdmulhq_lane_s32
+  // CHECK-LABEL: test_vqdmulhq_lane_s32
   return vqdmulhq_lane_s32(a, v, 1);
   // CHECK: sqdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int16x4_t test_vqrdmulh_lane_s16(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vqrdmulh_lane_s16
+  // CHECK-LABEL: test_vqrdmulh_lane_s16
   return vqrdmulh_lane_s16(a, v, 3);
   // CHECK: sqrdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 }
 
 int16x8_t test_vqrdmulhq_lane_s16(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vqrdmulhq_lane_s16
+  // CHECK-LABEL: test_vqrdmulhq_lane_s16
   return vqrdmulhq_lane_s16(a, v, 3);
   // CHECK: sqrdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 }
 
 int32x2_t test_vqrdmulh_lane_s32(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vqrdmulh_lane_s32
+  // CHECK-LABEL: test_vqrdmulh_lane_s32
   return vqrdmulh_lane_s32(a, v, 1);
   // CHECK: sqrdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vqrdmulhq_lane_s32(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vqrdmulhq_lane_s32
+  // CHECK-LABEL: test_vqrdmulhq_lane_s32
   return vqrdmulhq_lane_s32(a, v, 1);
   // CHECK: sqrdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 float32x2_t test_vmul_lane_f32(float32x2_t a, float32x2_t v) {
-  // CHECK: test_vmul_lane_f32
+  // CHECK-LABEL: test_vmul_lane_f32
   return vmul_lane_f32(a, v, 1);
   // CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 
 float64x1_t test_vmul_lane_f64(float64x1_t a, float64x1_t v) {
-  // CHECK: test_vmul_lane_f64
+  // CHECK-LABEL: test_vmul_lane_f64
   return vmul_lane_f64(a, v, 0);
   // CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
 
 float32x4_t test_vmulq_lane_f32(float32x4_t a, float32x2_t v) {
-  // CHECK: test_vmulq_lane_f32
+  // CHECK-LABEL: test_vmulq_lane_f32
   return vmulq_lane_f32(a, v, 1);
   // CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 float64x2_t test_vmulq_lane_f64(float64x2_t a, float64x1_t v) {
-  // CHECK: test_vmulq_lane_f64
+  // CHECK-LABEL: test_vmulq_lane_f64
   return vmulq_lane_f64(a, v, 0);
   // CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float32x2_t test_vmul_laneq_f32(float32x2_t a, float32x4_t v) {
-  // CHECK: test_vmul_laneq_f32
+  // CHECK-LABEL: test_vmul_laneq_f32
   return vmul_laneq_f32(a, v, 3);
   // CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 float64x1_t test_vmul_laneq_f64(float64x1_t a, float64x2_t v) {
-  // CHECK: test_vmul_laneq_f64
+  // CHECK-LABEL: test_vmul_laneq_f64
   return vmul_laneq_f64(a, v, 1);
   // CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
 
 float32x4_t test_vmulq_laneq_f32(float32x4_t a, float32x4_t v) {
-  // CHECK: test_vmulq_laneq_f32
+  // CHECK-LABEL: test_vmulq_laneq_f32
   return vmulq_laneq_f32(a, v, 3);
   // CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 float64x2_t test_vmulq_laneq_f64(float64x2_t a, float64x2_t v) {
-  // CHECK: test_vmulq_laneq_f64
+  // CHECK-LABEL: test_vmulq_laneq_f64
   return vmulq_laneq_f64(a, v, 1);
   // CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
 }
 
 float32x2_t test_vmulx_lane_f32(float32x2_t a, float32x2_t v) {
-  // CHECK: test_vmulx_lane_f32
+  // CHECK-LABEL: test_vmulx_lane_f32
   return vmulx_lane_f32(a, v, 1);
   // CHECK: fmulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 float32x4_t test_vmulxq_lane_f32(float32x4_t a, float32x2_t v) {
-  // CHECK: test_vmulxq_lane_f32
+  // CHECK-LABEL: test_vmulxq_lane_f32
   return vmulxq_lane_f32(a, v, 1);
   // CHECK: fmulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 float64x2_t test_vmulxq_lane_f64(float64x2_t a, float64x1_t v) {
-  // CHECK: test_vmulxq_lane_f64
+  // CHECK-LABEL: test_vmulxq_lane_f64
   return vmulxq_lane_f64(a, v, 0);
   // CHECK: fmulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float32x2_t test_vmulx_laneq_f32(float32x2_t a, float32x4_t v) {
-  // CHECK: test_vmulx_laneq_f32
+  // CHECK-LABEL: test_vmulx_laneq_f32
   return vmulx_laneq_f32(a, v, 3);
   // CHECK: fmulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 }
 
 float32x4_t test_vmulxq_laneq_f32(float32x4_t a, float32x4_t v) {
-  // CHECK: test_vmulxq_laneq_f32
+  // CHECK-LABEL: test_vmulxq_laneq_f32
   return vmulxq_laneq_f32(a, v, 3);
   // CHECK: fmulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 }
 
 float64x2_t test_vmulxq_laneq_f64(float64x2_t a, float64x2_t v) {
-  // CHECK: test_vmulxq_laneq_f64
+  // CHECK-LABEL: test_vmulxq_laneq_f64
   return vmulxq_laneq_f64(a, v, 1);
   // CHECK: fmulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
 }
 
 int16x4_t test_vmla_lane_s16_0(int16x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmla_lane_s16_0
+  // CHECK-LABEL: test_vmla_lane_s16_0
   return vmla_lane_s16(a, b, v, 0);
   // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int16x8_t test_vmlaq_lane_s16_0(int16x8_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlaq_lane_s16_0
+  // CHECK-LABEL: test_vmlaq_lane_s16_0
   return vmlaq_lane_s16(a, b, v, 0);
   // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int32x2_t test_vmla_lane_s32_0(int32x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmla_lane_s32_0
+  // CHECK-LABEL: test_vmla_lane_s32_0
   return vmla_lane_s32(a, b, v, 0);
   // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlaq_lane_s32_0(int32x4_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlaq_lane_s32_0
+  // CHECK-LABEL: test_vmlaq_lane_s32_0
   return vmlaq_lane_s32(a, b, v, 0);
   // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int16x4_t test_vmla_laneq_s16_0(int16x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmla_laneq_s16_0
+  // CHECK-LABEL: test_vmla_laneq_s16_0
   return vmla_laneq_s16(a, b, v, 0);
   // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int16x8_t test_vmlaq_laneq_s16_0(int16x8_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlaq_laneq_s16_0
+  // CHECK-LABEL: test_vmlaq_laneq_s16_0
   return vmlaq_laneq_s16(a, b, v, 0);
   // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int32x2_t test_vmla_laneq_s32_0(int32x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmla_laneq_s32_0
+  // CHECK-LABEL: test_vmla_laneq_s32_0
   return vmla_laneq_s32(a, b, v, 0);
   // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlaq_laneq_s32_0(int32x4_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlaq_laneq_s32_0
+  // CHECK-LABEL: test_vmlaq_laneq_s32_0
   return vmlaq_laneq_s32(a, b, v, 0);
   // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int16x4_t test_vmls_lane_s16_0(int16x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmls_lane_s16_0
+  // CHECK-LABEL: test_vmls_lane_s16_0
   return vmls_lane_s16(a, b, v, 0);
   // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int16x8_t test_vmlsq_lane_s16_0(int16x8_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlsq_lane_s16_0
+  // CHECK-LABEL: test_vmlsq_lane_s16_0
   return vmlsq_lane_s16(a, b, v, 0);
   // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int32x2_t test_vmls_lane_s32_0(int32x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmls_lane_s32_0
+  // CHECK-LABEL: test_vmls_lane_s32_0
   return vmls_lane_s32(a, b, v, 0);
   // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsq_lane_s32_0(int32x4_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlsq_lane_s32_0
+  // CHECK-LABEL: test_vmlsq_lane_s32_0
   return vmlsq_lane_s32(a, b, v, 0);
   // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int16x4_t test_vmls_laneq_s16_0(int16x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmls_laneq_s16_0
+  // CHECK-LABEL: test_vmls_laneq_s16_0
   return vmls_laneq_s16(a, b, v, 0);
   // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int16x8_t test_vmlsq_laneq_s16_0(int16x8_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlsq_laneq_s16_0
+  // CHECK-LABEL: test_vmlsq_laneq_s16_0
   return vmlsq_laneq_s16(a, b, v, 0);
   // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int32x2_t test_vmls_laneq_s32_0(int32x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmls_laneq_s32_0
+  // CHECK-LABEL: test_vmls_laneq_s32_0
   return vmls_laneq_s32(a, b, v, 0);
   // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsq_laneq_s32_0(int32x4_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlsq_laneq_s32_0
+  // CHECK-LABEL: test_vmlsq_laneq_s32_0
   return vmlsq_laneq_s32(a, b, v, 0);
   // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int16x4_t test_vmul_lane_s16_0(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vmul_lane_s16_0
+  // CHECK-LABEL: test_vmul_lane_s16_0
   return vmul_lane_s16(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int16x8_t test_vmulq_lane_s16_0(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vmulq_lane_s16_0
+  // CHECK-LABEL: test_vmulq_lane_s16_0
   return vmulq_lane_s16(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int32x2_t test_vmul_lane_s32_0(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vmul_lane_s32_0
+  // CHECK-LABEL: test_vmul_lane_s32_0
   return vmul_lane_s32(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmulq_lane_s32_0(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vmulq_lane_s32_0
+  // CHECK-LABEL: test_vmulq_lane_s32_0
   return vmulq_lane_s32(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 uint16x4_t test_vmul_lane_u16_0(uint16x4_t a, uint16x4_t v) {
-  // CHECK: test_vmul_lane_u16_0
+  // CHECK-LABEL: test_vmul_lane_u16_0
   return vmul_lane_u16(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 uint16x8_t test_vmulq_lane_u16_0(uint16x8_t a, uint16x4_t v) {
-  // CHECK: test_vmulq_lane_u16_0
+  // CHECK-LABEL: test_vmulq_lane_u16_0
   return vmulq_lane_u16(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 uint32x2_t test_vmul_lane_u32_0(uint32x2_t a, uint32x2_t v) {
-  // CHECK: test_vmul_lane_u32_0
+  // CHECK-LABEL: test_vmul_lane_u32_0
   return vmul_lane_u32(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmulq_lane_u32_0(uint32x4_t a, uint32x2_t v) {
-  // CHECK: test_vmulq_lane_u32_0
+  // CHECK-LABEL: test_vmulq_lane_u32_0
   return vmulq_lane_u32(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int16x4_t test_vmul_laneq_s16_0(int16x4_t a, int16x8_t v) {
-  // CHECK: test_vmul_laneq_s16_0
+  // CHECK-LABEL: test_vmul_laneq_s16_0
   return vmul_laneq_s16(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int16x8_t test_vmulq_laneq_s16_0(int16x8_t a, int16x8_t v) {
-  // CHECK: test_vmulq_laneq_s16_0
+  // CHECK-LABEL: test_vmulq_laneq_s16_0
   return vmulq_laneq_s16(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int32x2_t test_vmul_laneq_s32_0(int32x2_t a, int32x4_t v) {
-  // CHECK: test_vmul_laneq_s32_0
+  // CHECK-LABEL: test_vmul_laneq_s32_0
   return vmul_laneq_s32(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmulq_laneq_s32_0(int32x4_t a, int32x4_t v) {
-  // CHECK: test_vmulq_laneq_s32_0
+  // CHECK-LABEL: test_vmulq_laneq_s32_0
   return vmulq_laneq_s32(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 uint16x4_t test_vmul_laneq_u16_0(uint16x4_t a, uint16x8_t v) {
-  // CHECK: test_vmul_laneq_u16_0
+  // CHECK-LABEL: test_vmul_laneq_u16_0
   return vmul_laneq_u16(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 uint16x8_t test_vmulq_laneq_u16_0(uint16x8_t a, uint16x8_t v) {
-  // CHECK: test_vmulq_laneq_u16_0
+  // CHECK-LABEL: test_vmulq_laneq_u16_0
   return vmulq_laneq_u16(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 uint32x2_t test_vmul_laneq_u32_0(uint32x2_t a, uint32x4_t v) {
-  // CHECK: test_vmul_laneq_u32_0
+  // CHECK-LABEL: test_vmul_laneq_u32_0
   return vmul_laneq_u32(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmulq_laneq_u32_0(uint32x4_t a, uint32x4_t v) {
-  // CHECK: test_vmulq_laneq_u32_0
+  // CHECK-LABEL: test_vmulq_laneq_u32_0
   return vmulq_laneq_u32(a, v, 0);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float32x2_t test_vfma_lane_f32_0(float32x2_t a, float32x2_t b, float32x2_t v) {
-  // CHECK: test_vfma_lane_f32_0
+  // CHECK-LABEL: test_vfma_lane_f32_0
   return vfma_lane_f32(a, b, v, 0);
   // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vfmaq_lane_f32_0(float32x4_t a, float32x4_t b, float32x2_t v) {
-  // CHECK: test_vfmaq_lane_f32_0
+  // CHECK-LABEL: test_vfmaq_lane_f32_0
   return vfmaq_lane_f32(a, b, v, 0);
   // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float32x2_t test_vfma_laneq_f32_0(float32x2_t a, float32x2_t b, float32x4_t v) {
-  // CHECK: test_vfma_laneq_f32_0
+  // CHECK-LABEL: test_vfma_laneq_f32_0
   return vfma_laneq_f32(a, b, v, 0);
   // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vfmaq_laneq_f32_0(float32x4_t a, float32x4_t b, float32x4_t v) {
-  // CHECK: test_vfmaq_laneq_f32_0
+  // CHECK-LABEL: test_vfmaq_laneq_f32_0
   return vfmaq_laneq_f32(a, b, v, 0);
   // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float32x2_t test_vfms_lane_f32_0(float32x2_t a, float32x2_t b, float32x2_t v) {
-  // CHECK: test_vfms_lane_f32_0
+  // CHECK-LABEL: test_vfms_lane_f32_0
   return vfms_lane_f32(a, b, v, 0);
   // CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vfmsq_lane_f32_0(float32x4_t a, float32x4_t b, float32x2_t v) {
-  // CHECK: test_vfmsq_lane_f32_0
+  // CHECK-LABEL: test_vfmsq_lane_f32_0
   return vfmsq_lane_f32(a, b, v, 0);
   // CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float32x2_t test_vfms_laneq_f32_0(float32x2_t a, float32x2_t b, float32x4_t v) {
-  // CHECK: test_vfms_laneq_f32_0
+  // CHECK-LABEL: test_vfms_laneq_f32_0
   return vfms_laneq_f32(a, b, v, 0);
   // CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vfmsq_laneq_f32_0(float32x4_t a, float32x4_t b, float32x4_t v) {
-  // CHECK: test_vfmsq_laneq_f32_0
+  // CHECK-LABEL: test_vfmsq_laneq_f32_0
   return vfmsq_laneq_f32(a, b, v, 0);
   // CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float64x2_t test_vfmaq_laneq_f64_0(float64x2_t a, float64x2_t b, float64x2_t v) {
-  // CHECK: test_vfmaq_laneq_f64_0
+  // CHECK-LABEL: test_vfmaq_laneq_f64_0
   return vfmaq_laneq_f64(a, b, v, 0);
   // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float64x2_t test_vfmsq_laneq_f64_0(float64x2_t a, float64x2_t b, float64x2_t v) {
-  // CHECK: test_vfmsq_laneq_f64_0
+  // CHECK-LABEL: test_vfmsq_laneq_f64_0
   return vfmsq_laneq_f64(a, b, v, 0);
   // CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 int32x4_t test_vmlal_lane_s16_0(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmlal_lane_s16_0
+  // CHECK-LABEL: test_vmlal_lane_s16_0
   return vmlal_lane_s16(a, b, v, 0);
   // CHECK: smlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_lane_s32_0(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmlal_lane_s32_0
+  // CHECK-LABEL: test_vmlal_lane_s32_0
   return vmlal_lane_s32(a, b, v, 0);
   // CHECK: smlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlal_laneq_s16_0(int32x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmlal_laneq_s16_0
+  // CHECK-LABEL: test_vmlal_laneq_s16_0
   return vmlal_laneq_s16(a, b, v, 0);
   // CHECK: smlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_laneq_s32_0(int64x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmlal_laneq_s32_0
+  // CHECK-LABEL: test_vmlal_laneq_s32_0
   return vmlal_laneq_s32(a, b, v, 0);
   // CHECK: smlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlal_high_lane_s16_0(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlal_high_lane_s16_0
+  // CHECK-LABEL: test_vmlal_high_lane_s16_0
   return vmlal_high_lane_s16(a, b, v, 0);
   // CHECK: smlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_high_lane_s32_0(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlal_high_lane_s32_0
+  // CHECK-LABEL: test_vmlal_high_lane_s32_0
   return vmlal_high_lane_s32(a, b, v, 0);
   // CHECK: smlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlal_high_laneq_s16_0(int32x4_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlal_high_laneq_s16_0
+  // CHECK-LABEL: test_vmlal_high_laneq_s16_0
   return vmlal_high_laneq_s16(a, b, v, 0);
   // CHECK: smlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_high_laneq_s32_0(int64x2_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlal_high_laneq_s32_0
+  // CHECK-LABEL: test_vmlal_high_laneq_s32_0
   return vmlal_high_laneq_s32(a, b, v, 0);
   // CHECK: smlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_lane_s16_0(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmlsl_lane_s16_0
+  // CHECK-LABEL: test_vmlsl_lane_s16_0
   return vmlsl_lane_s16(a, b, v, 0);
   // CHECK: smlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_lane_s32_0(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmlsl_lane_s32_0
+  // CHECK-LABEL: test_vmlsl_lane_s32_0
   return vmlsl_lane_s32(a, b, v, 0);
   // CHECK: smlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_laneq_s16_0(int32x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmlsl_laneq_s16_0
+  // CHECK-LABEL: test_vmlsl_laneq_s16_0
   return vmlsl_laneq_s16(a, b, v, 0);
   // CHECK: smlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_laneq_s32_0(int64x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmlsl_laneq_s32_0
+  // CHECK-LABEL: test_vmlsl_laneq_s32_0
   return vmlsl_laneq_s32(a, b, v, 0);
   // CHECK: smlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_high_lane_s16_0(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlsl_high_lane_s16_0
+  // CHECK-LABEL: test_vmlsl_high_lane_s16_0
   return vmlsl_high_lane_s16(a, b, v, 0);
   // CHECK: smlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_high_lane_s32_0(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlsl_high_lane_s32_0
+  // CHECK-LABEL: test_vmlsl_high_lane_s32_0
   return vmlsl_high_lane_s32(a, b, v, 0);
   // CHECK: smlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_high_laneq_s16_0(int32x4_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlsl_high_laneq_s16_0
+  // CHECK-LABEL: test_vmlsl_high_laneq_s16_0
   return vmlsl_high_laneq_s16(a, b, v, 0);
   // CHECK: smlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_high_laneq_s32_0(int64x2_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlsl_high_laneq_s32_0
+  // CHECK-LABEL: test_vmlsl_high_laneq_s32_0
   return vmlsl_high_laneq_s32(a, b, v, 0);
   // CHECK: smlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlal_lane_u16_0(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmlal_lane_u16_0
+  // CHECK-LABEL: test_vmlal_lane_u16_0
   return vmlal_lane_u16(a, b, v, 0);
   // CHECK: umlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_lane_u32_0(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmlal_lane_u32_0
+  // CHECK-LABEL: test_vmlal_lane_u32_0
   return vmlal_lane_u32(a, b, v, 0);
   // CHECK: umlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlal_laneq_u16_0(int32x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmlal_laneq_u16_0
+  // CHECK-LABEL: test_vmlal_laneq_u16_0
   return vmlal_laneq_u16(a, b, v, 0);
   // CHECK: umlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_laneq_u32_0(int64x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmlal_laneq_u32_0
+  // CHECK-LABEL: test_vmlal_laneq_u32_0
   return vmlal_laneq_u32(a, b, v, 0);
   // CHECK: umlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlal_high_lane_u16_0(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlal_high_lane_u16_0
+  // CHECK-LABEL: test_vmlal_high_lane_u16_0
   return vmlal_high_lane_u16(a, b, v, 0);
   // CHECK: umlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_high_lane_u32_0(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlal_high_lane_u32_0
+  // CHECK-LABEL: test_vmlal_high_lane_u32_0
   return vmlal_high_lane_u32(a, b, v, 0);
   // CHECK: umlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlal_high_laneq_u16_0(int32x4_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlal_high_laneq_u16_0
+  // CHECK-LABEL: test_vmlal_high_laneq_u16_0
   return vmlal_high_laneq_u16(a, b, v, 0);
   // CHECK: umlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_high_laneq_u32_0(int64x2_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlal_high_laneq_u32_0
+  // CHECK-LABEL: test_vmlal_high_laneq_u32_0
   return vmlal_high_laneq_u32(a, b, v, 0);
   // CHECK: umlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_lane_u16_0(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vmlsl_lane_u16_0
+  // CHECK-LABEL: test_vmlsl_lane_u16_0
   return vmlsl_lane_u16(a, b, v, 0);
   // CHECK: umlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_lane_u32_0(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vmlsl_lane_u32_0
+  // CHECK-LABEL: test_vmlsl_lane_u32_0
   return vmlsl_lane_u32(a, b, v, 0);
   // CHECK: umlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_laneq_u16_0(int32x4_t a, int16x4_t b, int16x8_t v) {
-  // CHECK: test_vmlsl_laneq_u16_0
+  // CHECK-LABEL: test_vmlsl_laneq_u16_0
   return vmlsl_laneq_u16(a, b, v, 0);
   // CHECK: umlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_laneq_u32_0(int64x2_t a, int32x2_t b, int32x4_t v) {
-  // CHECK: test_vmlsl_laneq_u32_0
+  // CHECK-LABEL: test_vmlsl_laneq_u32_0
   return vmlsl_laneq_u32(a, b, v, 0);
   // CHECK: umlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_high_lane_u16_0(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vmlsl_high_lane_u16_0
+  // CHECK-LABEL: test_vmlsl_high_lane_u16_0
   return vmlsl_high_lane_u16(a, b, v, 0);
   // CHECK: umlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_high_lane_u32_0(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vmlsl_high_lane_u32_0
+  // CHECK-LABEL: test_vmlsl_high_lane_u32_0
   return vmlsl_high_lane_u32(a, b, v, 0);
   // CHECK: umlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_high_laneq_u16_0(int32x4_t a, int16x8_t b, int16x8_t v) {
-  // CHECK: test_vmlsl_high_laneq_u16_0
+  // CHECK-LABEL: test_vmlsl_high_laneq_u16_0
   return vmlsl_high_laneq_u16(a, b, v, 0);
   // CHECK: umlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_high_laneq_u32_0(int64x2_t a, int32x4_t b, int32x4_t v) {
-  // CHECK: test_vmlsl_high_laneq_u32_0
+  // CHECK-LABEL: test_vmlsl_high_laneq_u32_0
   return vmlsl_high_laneq_u32(a, b, v, 0);
   // CHECK: umlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmull_lane_s16_0(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vmull_lane_s16_0
+  // CHECK-LABEL: test_vmull_lane_s16_0
   return vmull_lane_s16(a, v, 0);
   // CHECK: smull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmull_lane_s32_0(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vmull_lane_s32_0
+  // CHECK-LABEL: test_vmull_lane_s32_0
   return vmull_lane_s32(a, v, 0);
   // CHECK: smull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmull_lane_u16_0(uint16x4_t a, uint16x4_t v) {
-  // CHECK: test_vmull_lane_u16_0
+  // CHECK-LABEL: test_vmull_lane_u16_0
   return vmull_lane_u16(a, v, 0);
   // CHECK: umull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 uint64x2_t test_vmull_lane_u32_0(uint32x2_t a, uint32x2_t v) {
-  // CHECK: test_vmull_lane_u32_0
+  // CHECK-LABEL: test_vmull_lane_u32_0
   return vmull_lane_u32(a, v, 0);
   // CHECK: umull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmull_high_lane_s16_0(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vmull_high_lane_s16_0
+  // CHECK-LABEL: test_vmull_high_lane_s16_0
   return vmull_high_lane_s16(a, v, 0);
   // CHECK: smull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmull_high_lane_s32_0(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vmull_high_lane_s32_0
+  // CHECK-LABEL: test_vmull_high_lane_s32_0
   return vmull_high_lane_s32(a, v, 0);
   // CHECK: smull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmull_high_lane_u16_0(uint16x8_t a, uint16x4_t v) {
-  // CHECK: test_vmull_high_lane_u16_0
+  // CHECK-LABEL: test_vmull_high_lane_u16_0
   return vmull_high_lane_u16(a, v, 0);
   // CHECK: umull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 uint64x2_t test_vmull_high_lane_u32_0(uint32x4_t a, uint32x2_t v) {
-  // CHECK: test_vmull_high_lane_u32_0
+  // CHECK-LABEL: test_vmull_high_lane_u32_0
   return vmull_high_lane_u32(a, v, 0);
   // CHECK: umull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmull_laneq_s16_0(int16x4_t a, int16x8_t v) {
-  // CHECK: test_vmull_laneq_s16_0
+  // CHECK-LABEL: test_vmull_laneq_s16_0
   return vmull_laneq_s16(a, v, 0);
   // CHECK: smull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmull_laneq_s32_0(int32x2_t a, int32x4_t v) {
-  // CHECK: test_vmull_laneq_s32_0
+  // CHECK-LABEL: test_vmull_laneq_s32_0
   return vmull_laneq_s32(a, v, 0);
   // CHECK: smull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmull_laneq_u16_0(uint16x4_t a, uint16x8_t v) {
-  // CHECK: test_vmull_laneq_u16_0
+  // CHECK-LABEL: test_vmull_laneq_u16_0
   return vmull_laneq_u16(a, v, 0);
   // CHECK: umull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 uint64x2_t test_vmull_laneq_u32_0(uint32x2_t a, uint32x4_t v) {
-  // CHECK: test_vmull_laneq_u32_0
+  // CHECK-LABEL: test_vmull_laneq_u32_0
   return vmull_laneq_u32(a, v, 0);
   // CHECK: umull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmull_high_laneq_s16_0(int16x8_t a, int16x8_t v) {
-  // CHECK: test_vmull_high_laneq_s16_0
+  // CHECK-LABEL: test_vmull_high_laneq_s16_0
   return vmull_high_laneq_s16(a, v, 0);
   // CHECK: smull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmull_high_laneq_s32_0(int32x4_t a, int32x4_t v) {
-  // CHECK: test_vmull_high_laneq_s32_0
+  // CHECK-LABEL: test_vmull_high_laneq_s32_0
   return vmull_high_laneq_s32(a, v, 0);
   // CHECK: smull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmull_high_laneq_u16_0(uint16x8_t a, uint16x8_t v) {
-  // CHECK: test_vmull_high_laneq_u16_0
+  // CHECK-LABEL: test_vmull_high_laneq_u16_0
   return vmull_high_laneq_u16(a, v, 0);
   // CHECK: umull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 uint64x2_t test_vmull_high_laneq_u32_0(uint32x4_t a, uint32x4_t v) {
-  // CHECK: test_vmull_high_laneq_u32_0
+  // CHECK-LABEL: test_vmull_high_laneq_u32_0
   return vmull_high_laneq_u32(a, v, 0);
   // CHECK: umull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmlal_lane_s16_0(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vqdmlal_lane_s16_0
+  // CHECK-LABEL: test_vqdmlal_lane_s16_0
   return vqdmlal_lane_s16(a, b, v, 0);
   // CHECK: sqdmlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmlal_lane_s32_0(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vqdmlal_lane_s32_0
+  // CHECK-LABEL: test_vqdmlal_lane_s32_0
   return vqdmlal_lane_s32(a, b, v, 0);
   // CHECK: sqdmlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmlal_high_lane_s16_0(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vqdmlal_high_lane_s16_0
+  // CHECK-LABEL: test_vqdmlal_high_lane_s16_0
   return vqdmlal_high_lane_s16(a, b, v, 0);
   // CHECK: sqdmlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmlal_high_lane_s32_0(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vqdmlal_high_lane_s32_0
+  // CHECK-LABEL: test_vqdmlal_high_lane_s32_0
   return vqdmlal_high_lane_s32(a, b, v, 0);
   // CHECK: sqdmlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmlsl_lane_s16_0(int32x4_t a, int16x4_t b, int16x4_t v) {
-  // CHECK: test_vqdmlsl_lane_s16_0
+  // CHECK-LABEL: test_vqdmlsl_lane_s16_0
   return vqdmlsl_lane_s16(a, b, v, 0);
   // CHECK: sqdmlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmlsl_lane_s32_0(int64x2_t a, int32x2_t b, int32x2_t v) {
-  // CHECK: test_vqdmlsl_lane_s32_0
+  // CHECK-LABEL: test_vqdmlsl_lane_s32_0
   return vqdmlsl_lane_s32(a, b, v, 0);
   // CHECK: sqdmlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmlsl_high_lane_s16_0(int32x4_t a, int16x8_t b, int16x4_t v) {
-  // CHECK: test_vqdmlsl_high_lane_s16_0
+  // CHECK-LABEL: test_vqdmlsl_high_lane_s16_0
   return vqdmlsl_high_lane_s16(a, b, v, 0);
   // CHECK: sqdmlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmlsl_high_lane_s32_0(int64x2_t a, int32x4_t b, int32x2_t v) {
-  // CHECK: test_vqdmlsl_high_lane_s32_0
+  // CHECK-LABEL: test_vqdmlsl_high_lane_s32_0
   return vqdmlsl_high_lane_s32(a, b, v, 0);
   // CHECK: sqdmlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmull_lane_s16_0(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vqdmull_lane_s16_0
+  // CHECK-LABEL: test_vqdmull_lane_s16_0
   return vqdmull_lane_s16(a, v, 0);
   // CHECK: sqdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmull_lane_s32_0(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vqdmull_lane_s32_0
+  // CHECK-LABEL: test_vqdmull_lane_s32_0
   return vqdmull_lane_s32(a, v, 0);
   // CHECK: sqdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmull_laneq_s16_0(int16x4_t a, int16x8_t v) {
-  // CHECK: test_vqdmull_laneq_s16_0
+  // CHECK-LABEL: test_vqdmull_laneq_s16_0
   return vqdmull_laneq_s16(a, v, 0);
   // CHECK: sqdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmull_laneq_s32_0(int32x2_t a, int32x4_t v) {
-  // CHECK: test_vqdmull_laneq_s32_0
+  // CHECK-LABEL: test_vqdmull_laneq_s32_0
   return vqdmull_laneq_s32(a, v, 0);
   // CHECK: sqdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmull_high_lane_s16_0(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vqdmull_high_lane_s16_0
+  // CHECK-LABEL: test_vqdmull_high_lane_s16_0
   return vqdmull_high_lane_s16(a, v, 0);
   // CHECK: sqdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmull_high_lane_s32_0(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vqdmull_high_lane_s32_0
+  // CHECK-LABEL: test_vqdmull_high_lane_s32_0
   return vqdmull_high_lane_s32(a, v, 0);
   // CHECK: sqdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmull_high_laneq_s16_0(int16x8_t a, int16x8_t v) {
-  // CHECK: test_vqdmull_high_laneq_s16_0
+  // CHECK-LABEL: test_vqdmull_high_laneq_s16_0
   return vqdmull_high_laneq_s16(a, v, 0);
   // CHECK: sqdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmull_high_laneq_s32_0(int32x4_t a, int32x4_t v) {
-  // CHECK: test_vqdmull_high_laneq_s32_0
+  // CHECK-LABEL: test_vqdmull_high_laneq_s32_0
   return vqdmull_high_laneq_s32(a, v, 0);
   // CHECK: sqdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int16x4_t test_vqdmulh_lane_s16_0(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vqdmulh_lane_s16_0
+  // CHECK-LABEL: test_vqdmulh_lane_s16_0
   return vqdmulh_lane_s16(a, v, 0);
   // CHECK: sqdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int16x8_t test_vqdmulhq_lane_s16_0(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vqdmulhq_lane_s16_0
+  // CHECK-LABEL: test_vqdmulhq_lane_s16_0
   return vqdmulhq_lane_s16(a, v, 0);
   // CHECK: sqdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int32x2_t test_vqdmulh_lane_s32_0(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vqdmulh_lane_s32_0
+  // CHECK-LABEL: test_vqdmulh_lane_s32_0
   return vqdmulh_lane_s32(a, v, 0);
   // CHECK: sqdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmulhq_lane_s32_0(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vqdmulhq_lane_s32_0
+  // CHECK-LABEL: test_vqdmulhq_lane_s32_0
   return vqdmulhq_lane_s32(a, v, 0);
   // CHECK: sqdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int16x4_t test_vqrdmulh_lane_s16_0(int16x4_t a, int16x4_t v) {
-  // CHECK: test_vqrdmulh_lane_s16_0
+  // CHECK-LABEL: test_vqrdmulh_lane_s16_0
   return vqrdmulh_lane_s16(a, v, 0);
   // CHECK: sqrdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
 }
 
 int16x8_t test_vqrdmulhq_lane_s16_0(int16x8_t a, int16x4_t v) {
-  // CHECK: test_vqrdmulhq_lane_s16_0
+  // CHECK-LABEL: test_vqrdmulhq_lane_s16_0
   return vqrdmulhq_lane_s16(a, v, 0);
   // CHECK: sqrdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int32x2_t test_vqrdmulh_lane_s32_0(int32x2_t a, int32x2_t v) {
-  // CHECK: test_vqrdmulh_lane_s32_0
+  // CHECK-LABEL: test_vqrdmulh_lane_s32_0
   return vqrdmulh_lane_s32(a, v, 0);
   // CHECK: sqrdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqrdmulhq_lane_s32_0(int32x4_t a, int32x2_t v) {
-  // CHECK: test_vqrdmulhq_lane_s32_0
+  // CHECK-LABEL: test_vqrdmulhq_lane_s32_0
   return vqrdmulhq_lane_s32(a, v, 0);
   // CHECK: sqrdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float32x2_t test_vmul_lane_f32_0(float32x2_t a, float32x2_t v) {
-  // CHECK: test_vmul_lane_f32_0
+  // CHECK-LABEL: test_vmul_lane_f32_0
   return vmul_lane_f32(a, v, 0);
   // CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vmulq_lane_f32_0(float32x4_t a, float32x2_t v) {
-  // CHECK: test_vmulq_lane_f32_0
+  // CHECK-LABEL: test_vmulq_lane_f32_0
   return vmulq_lane_f32(a, v, 0);
   // CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float32x2_t test_vmul_laneq_f32_0(float32x2_t a, float32x4_t v) {
-  // CHECK: test_vmul_laneq_f32_0
+  // CHECK-LABEL: test_vmul_laneq_f32_0
   return vmul_laneq_f32(a, v, 0);
   // CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float64x1_t test_vmul_laneq_f64_0(float64x1_t a, float64x2_t v) {
-  // CHECK: test_vmul_laneq_f64_0
+  // CHECK-LABEL: test_vmul_laneq_f64_0
   return vmul_laneq_f64(a, v, 0);
   // CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
 float32x4_t test_vmulq_laneq_f32_0(float32x4_t a, float32x4_t v) {
-  // CHECK: test_vmulq_laneq_f32_0
+  // CHECK-LABEL: test_vmulq_laneq_f32_0
   return vmulq_laneq_f32(a, v, 0);
   // CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float64x2_t test_vmulq_laneq_f64_0(float64x2_t a, float64x2_t v) {
-  // CHECK: test_vmulq_laneq_f64_0
+  // CHECK-LABEL: test_vmulq_laneq_f64_0
   return vmulq_laneq_f64(a, v, 0);
   // CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float32x2_t test_vmulx_lane_f32_0(float32x2_t a, float32x2_t v) {
-  // CHECK: test_vmulx_lane_f32_0
+  // CHECK-LABEL: test_vmulx_lane_f32_0
   return vmulx_lane_f32(a, v, 0);
   // CHECK: fmulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vmulxq_lane_f32_0(float32x4_t a, float32x2_t v) {
-  // CHECK: test_vmulxq_lane_f32_0
+  // CHECK-LABEL: test_vmulxq_lane_f32_0
   return vmulxq_lane_f32(a, v, 0);
   // CHECK: fmulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float64x2_t test_vmulxq_lane_f64_0(float64x2_t a, float64x1_t v) {
-  // CHECK: test_vmulxq_lane_f64_0
+  // CHECK-LABEL: test_vmulxq_lane_f64_0
   return vmulxq_lane_f64(a, v, 0);
   // CHECK: fmulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float32x2_t test_vmulx_laneq_f32_0(float32x2_t a, float32x4_t v) {
-  // CHECK: test_vmulx_laneq_f32_0
+  // CHECK-LABEL: test_vmulx_laneq_f32_0
   return vmulx_laneq_f32(a, v, 0);
   // CHECK: fmulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vmulxq_laneq_f32_0(float32x4_t a, float32x4_t v) {
-  // CHECK: test_vmulxq_laneq_f32_0
+  // CHECK-LABEL: test_vmulxq_laneq_f32_0
   return vmulxq_laneq_f32(a, v, 0);
   // CHECK: fmulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float64x2_t test_vmulxq_laneq_f64_0(float64x2_t a, float64x2_t v) {
-  // CHECK: test_vmulxq_laneq_f64_0
+  // CHECK-LABEL: test_vmulxq_laneq_f64_0
   return vmulxq_laneq_f64(a, v, 0);
   // CHECK: fmulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 int32x4_t test_vmull_high_n_s16(int16x8_t a, int16_t b) {
-  // CHECK: test_vmull_high_n_s16
+  // CHECK-LABEL: test_vmull_high_n_s16
   return vmull_high_n_s16(a, b);
   // CHECK: smull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmull_high_n_s32(int32x4_t a, int32_t b) {
-  // CHECK: test_vmull_high_n_s32
+  // CHECK-LABEL: test_vmull_high_n_s32
   return vmull_high_n_s32(a, b);
   // CHECK: smull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmull_high_n_u16(uint16x8_t a, uint16_t b) {
-  // CHECK: test_vmull_high_n_u16
+  // CHECK-LABEL: test_vmull_high_n_u16
   return vmull_high_n_u16(a, b);
   // CHECK: umull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 uint64x2_t test_vmull_high_n_u32(uint32x4_t a, uint32_t b) {
-  // CHECK: test_vmull_high_n_u32
+  // CHECK-LABEL: test_vmull_high_n_u32
   return vmull_high_n_u32(a, b);
   // CHECK: umull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmull_high_n_s16(int16x8_t a, int16_t b) {
-  // CHECK: test_vqdmull_high_n_s16
+  // CHECK-LABEL: test_vqdmull_high_n_s16
   return vqdmull_high_n_s16(a, b);
   // CHECK: sqdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmull_high_n_s32(int32x4_t a, int32_t b) {
-  // CHECK: test_vqdmull_high_n_s32
+  // CHECK-LABEL: test_vqdmull_high_n_s32
   return vqdmull_high_n_s32(a, b);
   // CHECK: sqdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlal_high_n_s16(int32x4_t a, int16x8_t b, int16_t c) {
-  // CHECK: test_vmlal_high_n_s16
+  // CHECK-LABEL: test_vmlal_high_n_s16
   return vmlal_high_n_s16(a, b, c);
   // CHECK: smlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlal_high_n_s32(int64x2_t a, int32x4_t b, int32_t c) {
-  // CHECK: test_vmlal_high_n_s32
+  // CHECK-LABEL: test_vmlal_high_n_s32
   return vmlal_high_n_s32(a, b, c);
   // CHECK: smlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmlal_high_n_u16(uint32x4_t a, uint16x8_t b, uint16_t c) {
-  // CHECK: test_vmlal_high_n_u16
+  // CHECK-LABEL: test_vmlal_high_n_u16
   return vmlal_high_n_u16(a, b, c);
   // CHECK: umlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 uint64x2_t test_vmlal_high_n_u32(uint64x2_t a, uint32x4_t b, uint32_t c) {
-  // CHECK: test_vmlal_high_n_u32
+  // CHECK-LABEL: test_vmlal_high_n_u32
   return vmlal_high_n_u32(a, b, c);
   // CHECK: umlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmlal_high_n_s16(int32x4_t a, int16x8_t b, int16_t c) {
-  // CHECK: test_vqdmlal_high_n_s16
+  // CHECK-LABEL: test_vqdmlal_high_n_s16
   return vqdmlal_high_n_s16(a, b, c);
   // CHECK: sqdmlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmlal_high_n_s32(int64x2_t a, int32x4_t b, int32_t c) {
-  // CHECK: test_vqdmlal_high_n_s32
+  // CHECK-LABEL: test_vqdmlal_high_n_s32
   return vqdmlal_high_n_s32(a, b, c);
   // CHECK: sqdmlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vmlsl_high_n_s16(int32x4_t a, int16x8_t b, int16_t c) {
-  // CHECK: test_vmlsl_high_n_s16
+  // CHECK-LABEL: test_vmlsl_high_n_s16
   return vmlsl_high_n_s16(a, b, c);
   // CHECK: smlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vmlsl_high_n_s32(int64x2_t a, int32x4_t b, int32_t c) {
-  // CHECK: test_vmlsl_high_n_s32
+  // CHECK-LABEL: test_vmlsl_high_n_s32
   return vmlsl_high_n_s32(a, b, c);
   // CHECK: smlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vmlsl_high_n_u16(uint32x4_t a, uint16x8_t b, uint16_t c) {
-  // CHECK: test_vmlsl_high_n_u16
+  // CHECK-LABEL: test_vmlsl_high_n_u16
   return vmlsl_high_n_u16(a, b, c);
   // CHECK: umlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 uint64x2_t test_vmlsl_high_n_u32(uint64x2_t a, uint32x4_t b, uint32_t c) {
-  // CHECK: test_vmlsl_high_n_u32
+  // CHECK-LABEL: test_vmlsl_high_n_u32
   return vmlsl_high_n_u32(a, b, c);
   // CHECK: umlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vqdmlsl_high_n_s16(int32x4_t a, int16x8_t b, int16_t c) {
-  // CHECK: test_vqdmlsl_high_n_s16
+  // CHECK-LABEL: test_vqdmlsl_high_n_s16
   return vqdmlsl_high_n_s16(a, b, c);
   // CHECK: sqdmlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
 }
 
 int64x2_t test_vqdmlsl_high_n_s32(int64x2_t a, int32x4_t b, int32_t c) {
-  // CHECK: test_vqdmlsl_high_n_s32
+  // CHECK-LABEL: test_vqdmlsl_high_n_s32
   return vqdmlsl_high_n_s32(a, b, c);
   // CHECK: sqdmlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float32x2_t test_vmul_n_f32(float32x2_t a, float32_t b) {
-  // CHECK: test_vmul_n_f32
+  // CHECK-LABEL: test_vmul_n_f32
   return vmul_n_f32(a, b);
   // CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vmulq_n_f32(float32x4_t a, float32_t b) {
-  // CHECK: test_vmulq_n_f32
+  // CHECK-LABEL: test_vmulq_n_f32
   return vmulq_n_f32(a, b);
   // CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float64x2_t test_vmulq_n_f64(float64x2_t a, float64_t b) {
-  // CHECK: test_vmulq_n_f64
+  // CHECK-LABEL: test_vmulq_n_f64
   return vmulq_n_f64(a, b);
   // CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float32x2_t test_vfma_n_f32(float32x2_t a, float32x2_t b, float32_t n) {
-  // CHECK: test_vfma_n_f32
+  // CHECK-LABEL: test_vfma_n_f32
   return vfma_n_f32(a, b, n);
   // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vfmaq_n_f32(float32x4_t a, float32x4_t b, float32_t n) {
-  // CHECK: test_vfmaq_n_f32
+  // CHECK-LABEL: test_vfmaq_n_f32
   return vfmaq_n_f32(a, b, n);
   // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float32x2_t test_vfms_n_f32(float32x2_t a, float32x2_t b, float32_t n) {
-  // CHECK: test_vfms_n_f32
+  // CHECK-LABEL: test_vfms_n_f32
   return vfms_n_f32(a, b, n);
   // CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vfmsq_n_f32(float32x4_t a, float32x4_t b, float32_t n) {
-  // CHECK: test_vfmsq_n_f32
+  // CHECK-LABEL: test_vfmsq_n_f32
   return vfmsq_n_f32(a, b, n);
   // CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }

Modified: cfe/trunk/test/CodeGen/aarch64-neon-across.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-across.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-across.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-across.c Mon Mar  3 05:34:36 2014
@@ -7,265 +7,265 @@
 #include <arm_neon.h>
 
 int16_t test_vaddlv_s8(int8x8_t a) {
-  // CHECK: test_vaddlv_s8
+  // CHECK-LABEL: test_vaddlv_s8
   return vaddlv_s8(a);
   // CHECK: saddlv {{h[0-9]+}}, {{v[0-9]+}}.8b
 }
 
 int32_t test_vaddlv_s16(int16x4_t a) {
-  // CHECK: test_vaddlv_s16
+  // CHECK-LABEL: test_vaddlv_s16
   return vaddlv_s16(a);
   // CHECK: saddlv {{s[0-9]+}}, {{v[0-9]+}}.4h
 }
 
 uint16_t test_vaddlv_u8(uint8x8_t a) {
-  // CHECK: test_vaddlv_u8
+  // CHECK-LABEL: test_vaddlv_u8
   return vaddlv_u8(a);
   // CHECK: uaddlv {{h[0-9]+}}, {{v[0-9]+}}.8b
 }
 
 uint32_t test_vaddlv_u16(uint16x4_t a) {
-  // CHECK: test_vaddlv_u16
+  // CHECK-LABEL: test_vaddlv_u16
   return vaddlv_u16(a);
   // CHECK: uaddlv {{s[0-9]+}}, {{v[0-9]+}}.4h
 }
 
 int16_t test_vaddlvq_s8(int8x16_t a) {
-  // CHECK: test_vaddlvq_s8
+  // CHECK-LABEL: test_vaddlvq_s8
   return vaddlvq_s8(a);
   // CHECK: saddlv {{h[0-9]+}}, {{v[0-9]+}}.16b
 }
 
 int32_t test_vaddlvq_s16(int16x8_t a) {
-  // CHECK: test_vaddlvq_s16
+  // CHECK-LABEL: test_vaddlvq_s16
   return vaddlvq_s16(a);
   // CHECK: saddlv {{s[0-9]+}}, {{v[0-9]+}}.8h
 }
 
 int64_t test_vaddlvq_s32(int32x4_t a) {
-  // CHECK: test_vaddlvq_s32
+  // CHECK-LABEL: test_vaddlvq_s32
   return vaddlvq_s32(a);
   // CHECK: saddlv {{d[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 uint16_t test_vaddlvq_u8(uint8x16_t a) {
-  // CHECK: test_vaddlvq_u8
+  // CHECK-LABEL: test_vaddlvq_u8
   return vaddlvq_u8(a);
   // CHECK: uaddlv {{h[0-9]+}}, {{v[0-9]+}}.16b
 }
 
 uint32_t test_vaddlvq_u16(uint16x8_t a) {
-  // CHECK: test_vaddlvq_u16
+  // CHECK-LABEL: test_vaddlvq_u16
   return vaddlvq_u16(a);
   // CHECK: uaddlv {{s[0-9]+}}, {{v[0-9]+}}.8h
 }
 
 uint64_t test_vaddlvq_u32(uint32x4_t a) {
-  // CHECK: test_vaddlvq_u32
+  // CHECK-LABEL: test_vaddlvq_u32
   return vaddlvq_u32(a);
   // CHECK: uaddlv {{d[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 int8_t test_vmaxv_s8(int8x8_t a) {
-  // CHECK: test_vmaxv_s8
+  // CHECK-LABEL: test_vmaxv_s8
   return vmaxv_s8(a);
   // CHECK: smaxv {{b[0-9]+}}, {{v[0-9]+}}.8b
 }
 
 int16_t test_vmaxv_s16(int16x4_t a) {
-  // CHECK: test_vmaxv_s16
+  // CHECK-LABEL: test_vmaxv_s16
   return vmaxv_s16(a);
   // CHECK: smaxv {{h[0-9]+}}, {{v[0-9]+}}.4h
 }
 
 uint8_t test_vmaxv_u8(uint8x8_t a) {
-  // CHECK: test_vmaxv_u8
+  // CHECK-LABEL: test_vmaxv_u8
   return vmaxv_u8(a);
   // CHECK: umaxv {{b[0-9]+}}, {{v[0-9]+}}.8b
 }
 
 uint16_t test_vmaxv_u16(uint16x4_t a) {
-  // CHECK: test_vmaxv_u16
+  // CHECK-LABEL: test_vmaxv_u16
   return vmaxv_u16(a);
   // CHECK: umaxv {{h[0-9]+}}, {{v[0-9]+}}.4h
 }
 
 int8_t test_vmaxvq_s8(int8x16_t a) {
-  // CHECK: test_vmaxvq_s8
+  // CHECK-LABEL: test_vmaxvq_s8
   return vmaxvq_s8(a);
   // CHECK: smaxv {{b[0-9]+}}, {{v[0-9]+}}.16b
 }
 
 int16_t test_vmaxvq_s16(int16x8_t a) {
-  // CHECK: test_vmaxvq_s16
+  // CHECK-LABEL: test_vmaxvq_s16
   return vmaxvq_s16(a);
   // CHECK: smaxv {{h[0-9]+}}, {{v[0-9]+}}.8h
 }
 
 int32_t test_vmaxvq_s32(int32x4_t a) {
-  // CHECK: test_vmaxvq_s32
+  // CHECK-LABEL: test_vmaxvq_s32
   return vmaxvq_s32(a);
   // CHECK: smaxv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 uint8_t test_vmaxvq_u8(uint8x16_t a) {
-  // CHECK: test_vmaxvq_u8
+  // CHECK-LABEL: test_vmaxvq_u8
   return vmaxvq_u8(a);
   // CHECK: umaxv {{b[0-9]+}}, {{v[0-9]+}}.16b
 }
 
 uint16_t test_vmaxvq_u16(uint16x8_t a) {
-  // CHECK: test_vmaxvq_u16
+  // CHECK-LABEL: test_vmaxvq_u16
   return vmaxvq_u16(a);
   // CHECK: umaxv {{h[0-9]+}}, {{v[0-9]+}}.8h
 }
 
 uint32_t test_vmaxvq_u32(uint32x4_t a) {
-  // CHECK: test_vmaxvq_u32
+  // CHECK-LABEL: test_vmaxvq_u32
   return vmaxvq_u32(a);
   // CHECK: umaxv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 int8_t test_vminv_s8(int8x8_t a) {
-  // CHECK: test_vminv_s8
+  // CHECK-LABEL: test_vminv_s8
   return vminv_s8(a);
   // CHECK: sminv {{b[0-9]+}}, {{v[0-9]+}}.8b
 }
 
 int16_t test_vminv_s16(int16x4_t a) {
-  // CHECK: test_vminv_s16
+  // CHECK-LABEL: test_vminv_s16
   return vminv_s16(a);
   // CHECK: sminv {{h[0-9]+}}, {{v[0-9]+}}.4h
 }
 
 uint8_t test_vminv_u8(uint8x8_t a) {
-  // CHECK: test_vminv_u8
+  // CHECK-LABEL: test_vminv_u8
   return vminv_u8(a);
   // CHECK: uminv {{b[0-9]+}}, {{v[0-9]+}}.8b
 }
 
 uint16_t test_vminv_u16(uint16x4_t a) {
-  // CHECK: test_vminv_u16
+  // CHECK-LABEL: test_vminv_u16
   return vminv_u16(a);
   // CHECK: uminv {{h[0-9]+}}, {{v[0-9]+}}.4h
 }
 
 int8_t test_vminvq_s8(int8x16_t a) {
-  // CHECK: test_vminvq_s8
+  // CHECK-LABEL: test_vminvq_s8
   return vminvq_s8(a);
   // CHECK: sminv {{b[0-9]+}}, {{v[0-9]+}}.16b
 }
 
 int16_t test_vminvq_s16(int16x8_t a) {
-  // CHECK: test_vminvq_s16
+  // CHECK-LABEL: test_vminvq_s16
   return vminvq_s16(a);
   // CHECK: sminv {{h[0-9]+}}, {{v[0-9]+}}.8h
 }
 
 int32_t test_vminvq_s32(int32x4_t a) {
-  // CHECK: test_vminvq_s32
+  // CHECK-LABEL: test_vminvq_s32
   return vminvq_s32(a);
   // CHECK: sminv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 uint8_t test_vminvq_u8(uint8x16_t a) {
-  // CHECK: test_vminvq_u8
+  // CHECK-LABEL: test_vminvq_u8
   return vminvq_u8(a);
   // CHECK: uminv {{b[0-9]+}}, {{v[0-9]+}}.16b
 }
 
 uint16_t test_vminvq_u16(uint16x8_t a) {
-  // CHECK: test_vminvq_u16
+  // CHECK-LABEL: test_vminvq_u16
   return vminvq_u16(a);
   // CHECK: uminv {{h[0-9]+}}, {{v[0-9]+}}.8h
 }
 
 uint32_t test_vminvq_u32(uint32x4_t a) {
-  // CHECK: test_vminvq_u32
+  // CHECK-LABEL: test_vminvq_u32
   return vminvq_u32(a);
   // CHECK: uminv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 int8_t test_vaddv_s8(int8x8_t a) {
-  // CHECK: test_vaddv_s8
+  // CHECK-LABEL: test_vaddv_s8
   return vaddv_s8(a);
   // CHECK: addv {{b[0-9]+}}, {{v[0-9]+}}.8b
 }
 
 int16_t test_vaddv_s16(int16x4_t a) {
-  // CHECK: test_vaddv_s16
+  // CHECK-LABEL: test_vaddv_s16
   return vaddv_s16(a);
   // CHECK: addv {{h[0-9]+}}, {{v[0-9]+}}.4h
 }
 
 uint8_t test_vaddv_u8(uint8x8_t a) {
-  // CHECK: test_vaddv_u8
+  // CHECK-LABEL: test_vaddv_u8
   return vaddv_u8(a);
   // CHECK: addv {{b[0-9]+}}, {{v[0-9]+}}.8b
 }
 
 uint16_t test_vaddv_u16(uint16x4_t a) {
-  // CHECK: test_vaddv_u16
+  // CHECK-LABEL: test_vaddv_u16
   return vaddv_u16(a);
   // CHECK: addv {{h[0-9]+}}, {{v[0-9]+}}.4h
 }
 
 int8_t test_vaddvq_s8(int8x16_t a) {
-  // CHECK: test_vaddvq_s8
+  // CHECK-LABEL: test_vaddvq_s8
   return vaddvq_s8(a);
   // CHECK: addv {{b[0-9]+}}, {{v[0-9]+}}.16b
 }
 
 int16_t test_vaddvq_s16(int16x8_t a) {
-  // CHECK: test_vaddvq_s16
+  // CHECK-LABEL: test_vaddvq_s16
   return vaddvq_s16(a);
   // CHECK: addv {{h[0-9]+}}, {{v[0-9]+}}.8h
 }
 
 int32_t test_vaddvq_s32(int32x4_t a) {
-  // CHECK: test_vaddvq_s32
+  // CHECK-LABEL: test_vaddvq_s32
   return vaddvq_s32(a);
   // CHECK: addv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 uint8_t test_vaddvq_u8(uint8x16_t a) {
-  // CHECK: test_vaddvq_u8
+  // CHECK-LABEL: test_vaddvq_u8
   return vaddvq_u8(a);
   // CHECK: addv {{b[0-9]+}}, {{v[0-9]+}}.16b
 }
 
 uint16_t test_vaddvq_u16(uint16x8_t a) {
-  // CHECK: test_vaddvq_u16
+  // CHECK-LABEL: test_vaddvq_u16
   return vaddvq_u16(a);
   // CHECK: addv {{h[0-9]+}}, {{v[0-9]+}}.8h
 }
 
 uint32_t test_vaddvq_u32(uint32x4_t a) {
-  // CHECK: test_vaddvq_u32
+  // CHECK-LABEL: test_vaddvq_u32
   return vaddvq_u32(a);
   // CHECK: addv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 float32_t test_vmaxvq_f32(float32x4_t a) {
-  // CHECK: test_vmaxvq_f32
+  // CHECK-LABEL: test_vmaxvq_f32
   return vmaxvq_f32(a);
   // CHECK: fmaxv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 float32_t test_vminvq_f32(float32x4_t a) {
-  // CHECK: test_vminvq_f32
+  // CHECK-LABEL: test_vminvq_f32
   return vminvq_f32(a);
   // CHECK: fminv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 float32_t test_vmaxnmvq_f32(float32x4_t a) {
-  // CHECK: test_vmaxnmvq_f32
+  // CHECK-LABEL: test_vmaxnmvq_f32
   return vmaxnmvq_f32(a);
   // CHECK: fmaxnmv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }
 
 float32_t test_vminnmvq_f32(float32x4_t a) {
-  // CHECK: test_vminnmvq_f32
+  // CHECK-LABEL: test_vminnmvq_f32
   return vminnmvq_f32(a);
   // CHECK: fminnmv {{s[0-9]+}}, {{v[0-9]+}}.4s
 }

Modified: cfe/trunk/test/CodeGen/aarch64-neon-copy.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-copy.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-copy.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-copy.c Mon Mar  3 05:34:36 2014
@@ -7,1238 +7,1238 @@
 #include <arm_neon.h>
 
 uint8x8_t test_vset_lane_u8(uint8_t v1, uint8x8_t v2) {
-   // CHECK: test_vset_lane_u8
+   // CHECK-LABEL: test_vset_lane_u8
   return vset_lane_u8(v1, v2, 6);
   // CHECK: ins {{v[0-9]+}}.b[6], {{w[0-9]+}}
 }
 
 uint16x4_t test_vset_lane_u16(uint16_t v1, uint16x4_t v2) {
-   // CHECK: test_vset_lane_u16
+   // CHECK-LABEL: test_vset_lane_u16
   return vset_lane_u16(v1, v2, 2);
   // CHECK: ins {{v[0-9]+}}.h[2], {{w[0-9]+}}
 }
 
 uint32x2_t test_vset_lane_u32(uint32_t v1, uint32x2_t v2) {
-   // CHECK: test_vset_lane_u32
+   // CHECK-LABEL: test_vset_lane_u32
   return vset_lane_u32(v1, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[1], {{w[0-9]+}}
 }
 uint64x1_t test_vset_lane_u64(uint64_t v1, uint64x1_t v2) {
-   // CHECK: test_vset_lane_u64
+   // CHECK-LABEL: test_vset_lane_u64
   return vset_lane_u64(v1, v2, 0);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 int8x8_t test_vset_lane_s8(int8_t v1, int8x8_t v2) {
-   // CHECK: test_vset_lane_s8
+   // CHECK-LABEL: test_vset_lane_s8
   return vset_lane_s8(v1, v2, 6);
   // CHECK: ins {{v[0-9]+}}.b[6], {{w[0-9]+}}
 }
 
 int16x4_t test_vset_lane_s16(int16_t v1, int16x4_t v2) {
-   // CHECK: test_vset_lane_s16
+   // CHECK-LABEL: test_vset_lane_s16
   return vset_lane_s16(v1, v2, 2);
   // CHECK: ins {{v[0-9]+}}.h[2], {{w[0-9]+}}
 }
 
 int32x2_t test_vset_lane_s32(int32_t v1, int32x2_t v2) {
-   // CHECK: test_vset_lane_s32
+   // CHECK-LABEL: test_vset_lane_s32
   return vset_lane_s32(v1, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[1], {{w[0-9]+}}
 }
 
   int64x1_t test_vset_lane_s64(int64_t v1, int64x1_t v2) {
-   // CHECK: test_vset_lane_s64
+   // CHECK-LABEL: test_vset_lane_s64
   return vset_lane_s64(v1, v2, 0);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 uint8x16_t test_vsetq_lane_u8(uint8_t v1, uint8x16_t v2) {
-   // CHECK: test_vsetq_lane_u8
+   // CHECK-LABEL: test_vsetq_lane_u8
   return vsetq_lane_u8(v1, v2, 6);
   // CHECK: ins {{v[0-9]+}}.b[6], {{w[0-9]+}}
 }
 
 uint16x8_t test_vsetq_lane_u16(uint16_t v1, uint16x8_t v2) {
-   // CHECK: test_vsetq_lane_u16
+   // CHECK-LABEL: test_vsetq_lane_u16
   return vsetq_lane_u16(v1, v2, 2);
   // CHECK: ins {{v[0-9]+}}.h[2], {{w[0-9]+}}
 }
 
 uint32x4_t test_vsetq_lane_u32(uint32_t v1, uint32x4_t v2) {
-   // CHECK: test_vsetq_lane_u32
+   // CHECK-LABEL: test_vsetq_lane_u32
   return vsetq_lane_u32(v1, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[1], {{w[0-9]+}}
 }
 
   uint64x2_t test_vsetq_lane_u64(uint64_t v1, uint64x2_t v2) {
-   // CHECK: test_vsetq_lane_u64
+   // CHECK-LABEL: test_vsetq_lane_u64
   return vsetq_lane_u64(v1, v2, 1);
   // CHECK: ins {{v[0-9]+}}.d[1], {{x[0-9]+}}
 }
 
 int8x16_t test_vsetq_lane_s8(int8_t v1, int8x16_t v2) {
-   // CHECK: test_vsetq_lane_s8
+   // CHECK-LABEL: test_vsetq_lane_s8
   return vsetq_lane_s8(v1, v2, 6);
   // CHECK: ins {{v[0-9]+}}.b[6], {{w[0-9]+}}
 }
 
 int16x8_t test_vsetq_lane_s16(int16_t v1, int16x8_t v2) {
-   // CHECK: test_vsetq_lane_s16
+   // CHECK-LABEL: test_vsetq_lane_s16
   return vsetq_lane_s16(v1, v2, 2);
   // CHECK: ins {{v[0-9]+}}.h[2], {{w[0-9]+}}
 }
 
 int32x4_t test_vsetq_lane_s32(int32_t v1, int32x4_t v2) {
-   // CHECK: test_vsetq_lane_s32
+   // CHECK-LABEL: test_vsetq_lane_s32
   return vsetq_lane_s32(v1, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[1], {{w[0-9]+}}
 }
 
 int64x2_t test_vsetq_lane_s64(int64_t v1, int64x2_t v2) {
-   // CHECK: test_vsetq_lane_s64
+   // CHECK-LABEL: test_vsetq_lane_s64
   return vsetq_lane_s64(v1, v2, 0);
   // CHECK: ins {{v[0-9]+}}.d[0], {{x[0-9]+}}
 }
 
 poly8x8_t test_vset_lane_p8(poly8_t v1, poly8x8_t v2) {
-   // CHECK: test_vset_lane_p8
+   // CHECK-LABEL: test_vset_lane_p8
   return vset_lane_p8(v1, v2, 6);
   // CHECK: ins {{v[0-9]+}}.b[6], {{w[0-9]+}}
 }
 
 poly16x4_t test_vset_lane_p16(poly16_t v1, poly16x4_t v2) {
-   // CHECK: test_vset_lane_p16
+   // CHECK-LABEL: test_vset_lane_p16
   return vset_lane_p16(v1, v2, 2);
   // CHECK: ins {{v[0-9]+}}.h[2], {{w[0-9]+}}
 }
 
 poly8x16_t test_vsetq_lane_p8(poly8_t v1, poly8x16_t v2) {
-   // CHECK: test_vsetq_lane_p8
+   // CHECK-LABEL: test_vsetq_lane_p8
   return vsetq_lane_p8(v1, v2, 6);
   // CHECK: ins {{v[0-9]+}}.b[6], {{w[0-9]+}}
 }
 
 poly16x8_t test_vsetq_lane_p16(poly16_t v1, poly16x8_t v2) {
-   // CHECK: test_vsetq_lane_p16
+   // CHECK-LABEL: test_vsetq_lane_p16
   return vsetq_lane_p16(v1, v2, 2);
   // CHECK: ins {{v[0-9]+}}.h[2], {{w[0-9]+}}
 }
 
 float32x2_t test_vset_lane_f32(float32_t v1, float32x2_t v2) {
-   // CHECK: test_vset_lane_f32
+   // CHECK-LABEL: test_vset_lane_f32
   return vset_lane_f32(v1, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vsetq_lane_f32(float32_t v1, float32x4_t v2) {
-   // CHECK: test_vsetq_lane_f32
+   // CHECK-LABEL: test_vsetq_lane_f32
   return vsetq_lane_f32(v1, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 float64x1_t test_vset_lane_f64(float64_t v1, float64x1_t v2) {
-   // CHECK: test_vset_lane_f64
+   // CHECK-LABEL: test_vset_lane_f64
   return vset_lane_f64(v1, v2, 0);
   // CHECK: ret
 }
 
 float64x2_t test_vsetq_lane_f64(float64_t v1, float64x2_t v2) {
-   // CHECK: test_vsetq_lane_f64
+   // CHECK-LABEL: test_vsetq_lane_f64
   return vsetq_lane_f64(v1, v2, 0);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[0]
 }
 
 uint8_t test_vget_lane_u8(uint8x8_t v1) {
-  // CHECK: test_vget_lane_u8
+  // CHECK-LABEL: test_vget_lane_u8
   return vget_lane_u8(v1, 7);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[7]
 }
 
 uint16_t test_vget_lane_u16(uint16x4_t v1) {
-  // CHECK: test_vget_lane_u16
+  // CHECK-LABEL: test_vget_lane_u16
   return vget_lane_u16(v1, 3);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
 uint32_t test_vget_lane_u32(uint32x2_t v1) {
-  // CHECK: test_vget_lane_u32
+  // CHECK-LABEL: test_vget_lane_u32
   return vget_lane_u32(v1, 1);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
 uint64_t test_vget_lane_u64(uint64x1_t v1) {
-  // CHECK: test_vget_lane_u64
+  // CHECK-LABEL: test_vget_lane_u64
   return vget_lane_u64(v1, 0);
   // CHECK: fmov {{x[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8_t test_vgetq_lane_u8(uint8x16_t v1) {
-  // CHECK: test_vgetq_lane_u8
+  // CHECK-LABEL: test_vgetq_lane_u8
   return vgetq_lane_u8(v1, 15);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[15]
 }
 
 uint16_t test_vgetq_lane_u16(uint16x8_t v1) {
-  // CHECK: test_vgetq_lane_u16
+  // CHECK-LABEL: test_vgetq_lane_u16
   return vgetq_lane_u16(v1, 6);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[6]
 }
 
 uint32_t test_vgetq_lane_u32(uint32x4_t v1) {
-  // CHECK: test_vgetq_lane_u32
+  // CHECK-LABEL: test_vgetq_lane_u32
   return vgetq_lane_u32(v1, 2);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.s[2]
 }
 
 uint64_t test_vgetq_lane_u64(uint64x2_t v1) {
-  // CHECK: test_vgetq_lane_u64
+  // CHECK-LABEL: test_vgetq_lane_u64
   return vgetq_lane_u64(v1, 1);
   // CHECK: umov {{x[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
 poly8_t test_vget_lane_p8(poly8x8_t v1) {
-  // CHECK: test_vget_lane_p8
+  // CHECK-LABEL: test_vget_lane_p8
   return vget_lane_p8(v1, 7);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[7]
 }
 
 poly16_t test_vget_lane_p16(poly16x4_t v1) {
-  // CHECK: test_vget_lane_p16
+  // CHECK-LABEL: test_vget_lane_p16
   return vget_lane_p16(v1, 3);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
 poly8_t test_vgetq_lane_p8(poly8x16_t v1) {
-  // CHECK: test_vgetq_lane_p8
+  // CHECK-LABEL: test_vgetq_lane_p8
   return vgetq_lane_p8(v1, 14);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[14]
 }
 
 poly16_t test_vgetq_lane_p16(poly16x8_t v1) {
-  // CHECK: test_vgetq_lane_p16
+  // CHECK-LABEL: test_vgetq_lane_p16
   return vgetq_lane_p16(v1, 6);
   // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[6]
 }
 
 int32_t test_vget_lane_s8(int8x8_t v1) {
-  // CHECK: test_vget_lane_s8
+  // CHECK-LABEL: test_vget_lane_s8
   return vget_lane_s8(v1, 7)+1;
   // CHECK: smov {{w[0-9]+}}, {{v[0-9]+}}.b[7]
 }
 
 int32_t test_vget_lane_s16(int16x4_t v1) {
-  // CHECK: test_vget_lane_s16
+  // CHECK-LABEL: test_vget_lane_s16
   return vget_lane_s16(v1, 3)+1;
   // CHECK: smov {{w[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
 int64_t test_vget_lane_s32(int32x2_t v1) {
-  // CHECK: test_vget_lane_s32
+  // CHECK-LABEL: test_vget_lane_s32
   return vget_lane_s32(v1, 1);
   // CHECK: smov {{x[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
 int64_t test_vget_lane_s64(int64x1_t v1) {
-  // CHECK: test_vget_lane_s64
+  // CHECK-LABEL: test_vget_lane_s64
   return vget_lane_s64(v1, 0);
   // CHECK: fmov {{x[0-9]+}}, {{d[0-9]+}}
 }
 
 int32_t test_vgetq_lane_s8(int8x16_t v1) {
-  // CHECK: test_vgetq_lane_s8
+  // CHECK-LABEL: test_vgetq_lane_s8
   return vgetq_lane_s8(v1, 15)+1;
   // CHECK: smov {{w[0-9]+}}, {{v[0-9]+}}.b[15]
 }
 
 int32_t test_vgetq_lane_s16(int16x8_t v1) {
-  // CHECK: test_vgetq_lane_s16
+  // CHECK-LABEL: test_vgetq_lane_s16
   return vgetq_lane_s16(v1, 6)+1;
   // CHECK: smov {{w[0-9]+}}, {{v[0-9]+}}.h[6]
 }
 
 int64_t test_vgetq_lane_s32(int32x4_t v1) {
-  // CHECK: test_vgetq_lane_s32
+  // CHECK-LABEL: test_vgetq_lane_s32
   return vgetq_lane_s32(v1, 2);
   // CHECK: smov {{x[0-9]+}}, {{v[0-9]+}}.s[2]
 }
 
 int64_t test_vgetq_lane_s64(int64x2_t v1) {
-  // CHECK: test_vgetq_lane_s64
+  // CHECK-LABEL: test_vgetq_lane_s64
   return vgetq_lane_s64(v1, 1);
   // CHECK: umov {{x[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
 int8x8_t test_vcopy_lane_s8(int8x8_t v1, int8x8_t v2) {
-  // CHECK: test_vcopy_lane_s8
+  // CHECK-LABEL: test_vcopy_lane_s8
   return vcopy_lane_s8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 int16x4_t test_vcopy_lane_s16(int16x4_t v1, int16x4_t v2) {
-  // CHECK: test_vcopy_lane_s16
+  // CHECK-LABEL: test_vcopy_lane_s16
   return vcopy_lane_s16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 poly8x8_t test_vcopy_lane_p8(poly8x8_t v1, poly8x8_t v2) {
-  // CHECK: test_vcopy_lane_p8
+  // CHECK-LABEL: test_vcopy_lane_p8
   return vcopy_lane_p8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 poly16x4_t test_vcopy_lane_p16(poly16x4_t v1, poly16x4_t v2) {
-  // CHECK: test_vcopy_lane_p16
+  // CHECK-LABEL: test_vcopy_lane_p16
   return vcopy_lane_p16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 int32x2_t test_vcopy_lane_s32(int32x2_t v1, int32x2_t v2) {
-  // CHECK: test_vcopy_lane_s32
+  // CHECK-LABEL: test_vcopy_lane_s32
   return vcopy_lane_s32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 float32x2_t test_vcopy_lane_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vcopy_lane_f32
+  // CHECK-LABEL: test_vcopy_lane_f32
   return vcopy_lane_f32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 uint8x8_t test_vcopy_lane_u8(uint8x8_t v1, uint8x8_t v2) {
-  // CHECK: test_vcopy_lane_u8
+  // CHECK-LABEL: test_vcopy_lane_u8
   return vcopy_lane_u8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 uint16x4_t test_vcopy_lane_u16(uint16x4_t v1, uint16x4_t v2) {
-  // CHECK: test_vcopy_lane_u16
+  // CHECK-LABEL: test_vcopy_lane_u16
   return vcopy_lane_u16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 uint32x2_t test_vcopy_lane_u32(uint32x2_t v1, uint32x2_t v2) {
-  // CHECK: test_vcopy_lane_u32
+  // CHECK-LABEL: test_vcopy_lane_u32
   return vcopy_lane_u32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 int8x8_t test_vcopy_laneq_s8(int8x8_t v1, int8x16_t v2) {
-  // CHECK: test_vcopy_laneq_s8
+  // CHECK-LABEL: test_vcopy_laneq_s8
   return vcopy_laneq_s8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 int16x4_t test_vcopy_laneq_s16(int16x4_t v1, int16x8_t v2) {
-  // CHECK: test_vcopy_laneq_s16
+  // CHECK-LABEL: test_vcopy_laneq_s16
   return vcopy_laneq_s16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 poly8x8_t test_vcopy_laneq_p8(poly8x8_t v1, poly8x16_t v2) {
-  // CHECK: test_vcopy_laneq_p8
+  // CHECK-LABEL: test_vcopy_laneq_p8
   return vcopy_laneq_p8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 poly16x4_t test_vcopy_laneq_p16(poly16x4_t v1, poly16x8_t v2) {
-  // CHECK: test_vcopy_laneq_p16
+  // CHECK-LABEL: test_vcopy_laneq_p16
   return vcopy_laneq_p16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 int32x2_t test_vcopy_laneq_s32(int32x2_t v1, int32x4_t v2) {
-  // CHECK: test_vcopy_laneq_s32
+  // CHECK-LABEL: test_vcopy_laneq_s32
   return vcopy_laneq_s32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 float32x2_t test_vcopy_laneq_f32(float32x2_t v1, float32x4_t v2) {
-  // CHECK: test_vcopy_laneq_f32
+  // CHECK-LABEL: test_vcopy_laneq_f32
   return vcopy_laneq_f32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 uint8x8_t test_vcopy_laneq_u8(uint8x8_t v1, uint8x16_t v2) {
-  // CHECK: test_vcopy_laneq_u8
+  // CHECK-LABEL: test_vcopy_laneq_u8
   return vcopy_laneq_u8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 uint16x4_t test_vcopy_laneq_u16(uint16x4_t v1, uint16x8_t v2) {
-  // CHECK: test_vcopy_laneq_u16
+  // CHECK-LABEL: test_vcopy_laneq_u16
   return vcopy_laneq_u16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 uint32x2_t test_vcopy_laneq_u32(uint32x2_t v1, uint32x4_t v2) {
-  // CHECK: test_vcopy_laneq_u32
+  // CHECK-LABEL: test_vcopy_laneq_u32
   return vcopy_laneq_u32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 int8x16_t test_vcopyq_lane_s8(int8x16_t v1, int8x8_t v2) {
-  // CHECK: test_vcopyq_lane_s8
+  // CHECK-LABEL: test_vcopyq_lane_s8
   return vcopyq_lane_s8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 int16x8_t test_vcopyq_lane_s16(int16x8_t v1, int16x4_t v2) {
-  // CHECK: test_vcopyq_lane_s16
+  // CHECK-LABEL: test_vcopyq_lane_s16
   return vcopyq_lane_s16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 poly8x16_t test_vcopyq_lane_p8(poly8x16_t v1, poly8x8_t v2) {
-  // CHECK: test_vcopyq_lane_p8
+  // CHECK-LABEL: test_vcopyq_lane_p8
   return vcopyq_lane_p8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 poly16x8_t test_vcopyq_lane_p16(poly16x8_t v1, poly16x4_t v2) {
-  // CHECK: test_vcopyq_lane_p16
+  // CHECK-LABEL: test_vcopyq_lane_p16
   return vcopyq_lane_p16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 int32x4_t test_vcopyq_lane_s32(int32x4_t v1, int32x2_t v2) {
-  // CHECK: test_vcopyq_lane_s32
+  // CHECK-LABEL: test_vcopyq_lane_s32
   return vcopyq_lane_s32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 int64x2_t test_vcopyq_lane_s64(int64x2_t v1, int64x1_t v2) {
-  // CHECK: test_vcopyq_lane_s64
+  // CHECK-LABEL: test_vcopyq_lane_s64
   return vcopyq_lane_s64(v1, 1, v2, 0);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 float32x4_t test_vcopyq_lane_f32(float32x4_t v1, float32x2_t v2) {
-  // CHECK: test_vcopyq_lane_f32
+  // CHECK-LABEL: test_vcopyq_lane_f32
   return vcopyq_lane_f32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 float64x2_t test_vcopyq_lane_f64(float64x2_t v1, float64x1_t v2) {
-  // CHECK: test_vcopyq_lane_f64
+  // CHECK-LABEL: test_vcopyq_lane_f64
   return vcopyq_lane_f64(v1, 1, v2, 0);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 uint8x16_t test_vcopyq_lane_u8(uint8x16_t v1, uint8x8_t v2) {
-  // CHECK: test_vcopyq_lane_u8
+  // CHECK-LABEL: test_vcopyq_lane_u8
   return vcopyq_lane_u8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 uint16x8_t test_vcopyq_lane_u16(uint16x8_t v1, uint16x4_t v2) {
-  // CHECK: test_vcopyq_lane_u16
+  // CHECK-LABEL: test_vcopyq_lane_u16
   return vcopyq_lane_u16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 uint32x4_t test_vcopyq_lane_u32(uint32x4_t v1, uint32x2_t v2) {
-  // CHECK: test_vcopyq_lane_u32
+  // CHECK-LABEL: test_vcopyq_lane_u32
   return vcopyq_lane_u32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 uint64x2_t test_vcopyq_lane_u64(uint64x2_t v1, uint64x1_t v2) {
-  // CHECK: test_vcopyq_lane_u64
+  // CHECK-LABEL: test_vcopyq_lane_u64
   return vcopyq_lane_u64(v1, 1, v2, 0);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 int8x16_t test_vcopyq_laneq_s8(int8x16_t v1, int8x16_t v2) {
-  // CHECK: test_vcopyq_laneq_s8
+  // CHECK-LABEL: test_vcopyq_laneq_s8
   return vcopyq_laneq_s8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 int16x8_t test_vcopyq_laneq_s16(int16x8_t v1, int16x8_t v2) {
-  // CHECK: test_vcopyq_laneq_s16
+  // CHECK-LABEL: test_vcopyq_laneq_s16
   return vcopyq_laneq_s16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 poly8x16_t test_vcopyq_laneq_p8(poly8x16_t v1, poly8x16_t v2) {
-  // CHECK: test_vcopyq_laneq_p8
+  // CHECK-LABEL: test_vcopyq_laneq_p8
   return vcopyq_laneq_p8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 poly16x8_t test_vcopyq_laneq_p16(poly16x8_t v1, poly16x8_t v2) {
-  // CHECK: test_vcopyq_laneq_p16
+  // CHECK-LABEL: test_vcopyq_laneq_p16
   return vcopyq_laneq_p16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 int32x4_t test_vcopyq_laneq_s32(int32x4_t v1, int32x4_t v2) {
-  // CHECK: test_vcopyq_laneq_s32
+  // CHECK-LABEL: test_vcopyq_laneq_s32
   return vcopyq_laneq_s32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 float32x4_t test_vcopyq_laneq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vcopyq_laneq_f32
+  // CHECK-LABEL: test_vcopyq_laneq_f32
   return vcopyq_laneq_f32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 int64x2_t test_vcopyq_laneq_s64(int64x2_t v1, int64x2_t v2) {
-  // CHECK: test_vcopyq_laneq_s64
+  // CHECK-LABEL: test_vcopyq_laneq_s64
   return vcopyq_laneq_s64(v1, 1, v2, 1);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[1]
 }
 
 uint8x16_t test_vcopyq_laneq_u8(uint8x16_t v1, uint8x16_t v2) {
-  // CHECK: test_vcopyq_laneq_u8
+  // CHECK-LABEL: test_vcopyq_laneq_u8
   return vcopyq_laneq_u8(v1, 5, v2, 3);
   // CHECK: ins {{v[0-9]+}}.b[5], {{v[0-9]+}}.b[3]
 }
 
 uint16x8_t test_vcopyq_laneq_u16(uint16x8_t v1, uint16x8_t v2) {
-  // CHECK: test_vcopyq_laneq_u16
+  // CHECK-LABEL: test_vcopyq_laneq_u16
   return vcopyq_laneq_u16(v1, 2, v2, 3);
   // CHECK: ins {{v[0-9]+}}.h[2], {{v[0-9]+}}.h[3]
 }
 
 uint32x4_t test_vcopyq_laneq_u32(uint32x4_t v1, uint32x4_t v2) {
-  // CHECK: test_vcopyq_laneq_u32
+  // CHECK-LABEL: test_vcopyq_laneq_u32
   return vcopyq_laneq_u32(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 uint64x2_t test_vcopyq_laneq_u64(uint64x2_t v1, uint64x2_t v2) {
-  // CHECK: test_vcopyq_laneq_u64
+  // CHECK-LABEL: test_vcopyq_laneq_u64
   return vcopyq_laneq_u64(v1, 0, v2, 1);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 int8x8_t test_vcreate_s8(uint64_t v1) {
-  // CHECK: test_vcreate_s8
+  // CHECK-LABEL: test_vcreate_s8
   return vcreate_s8(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 int16x4_t test_vcreate_s16(uint64_t v1) {
-  // CHECK: test_vcreate_s16
+  // CHECK-LABEL: test_vcreate_s16
   return vcreate_s16(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 int32x2_t test_vcreate_s32(uint64_t v1) {
-  // CHECK: test_vcreate_s32
+  // CHECK-LABEL: test_vcreate_s32
   return vcreate_s32(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 int64x1_t test_vcreate_s64(uint64_t v1) {
-  // CHECK: test_vcreate_s64
+  // CHECK-LABEL: test_vcreate_s64
   return vcreate_s64(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 uint8x8_t test_vcreate_u8(uint64_t v1) {
-  // CHECK: test_vcreate_u8
+  // CHECK-LABEL: test_vcreate_u8
   return vcreate_u8(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 uint16x4_t test_vcreate_u16(uint64_t v1) {
-  // CHECK: test_vcreate_u16
+  // CHECK-LABEL: test_vcreate_u16
   return vcreate_u16(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 uint32x2_t test_vcreate_u32(uint64_t v1) {
-  // CHECK: test_vcreate_u32
+  // CHECK-LABEL: test_vcreate_u32
   return vcreate_u32(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 uint64x1_t test_vcreate_u64(uint64_t v1) {
-  // CHECK: test_vcreate_u64
+  // CHECK-LABEL: test_vcreate_u64
   return vcreate_u64(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 poly8x8_t test_vcreate_p8(uint64_t v1) {
-  // CHECK: test_vcreate_p8
+  // CHECK-LABEL: test_vcreate_p8
   return vcreate_p8(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 poly16x4_t test_vcreate_p16(uint64_t v1) {
-  // CHECK: test_vcreate_p16
+  // CHECK-LABEL: test_vcreate_p16
   return vcreate_p16(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 float16x4_t test_vcreate_f16(uint64_t v1) {
-  // CHECK: test_vcreate_f16
+  // CHECK-LABEL: test_vcreate_f16
   return vcreate_f16(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 float32x2_t test_vcreate_f32(uint64_t v1) {
-  // CHECK: test_vcreate_f32
+  // CHECK-LABEL: test_vcreate_f32
   return vcreate_f32(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 float64x1_t test_vcreate_f64(uint64_t v1) {
-  // CHECK: test_vcreate_f64
+  // CHECK-LABEL: test_vcreate_f64
   return vcreate_f64(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 uint8x8_t test_vdup_n_u8(uint8_t v1) {
-  // CHECK: test_vdup_n_u8
+  // CHECK-LABEL: test_vdup_n_u8
   return vdup_n_u8(v1);
   // CHECK: dup {{v[0-9]+}}.8b, {{w[0-9]+}}
 }
 
 uint16x4_t test_vdup_n_u16(uint16_t v1) {
-  // CHECK: test_vdup_n_u16
+  // CHECK-LABEL: test_vdup_n_u16
   return vdup_n_u16(v1);
   // CHECK: dup {{v[0-9]+}}.4h, {{w[0-9]+}}
 }
 
 uint32x2_t test_vdup_n_u32(uint32_t v1) {
-  // CHECK: test_vdup_n_u32
+  // CHECK-LABEL: test_vdup_n_u32
   return vdup_n_u32(v1);
   // CHECK: dup {{v[0-9]+}}.2s, {{w[0-9]+}}
 }
 
 uint64x1_t test_vdup_n_u64(uint64_t v1) {
-  // CHECK: test_vdup_n_u64
+  // CHECK-LABEL: test_vdup_n_u64
   return vdup_n_u64(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 uint8x16_t test_vdupq_n_u8(uint8_t v1) {
-  // CHECK: test_vdupq_n_u8
+  // CHECK-LABEL: test_vdupq_n_u8
   return vdupq_n_u8(v1);
   // CHECK: dup {{v[0-9]+}}.16b, {{w[0-9]+}}
 }
 
 uint16x8_t test_vdupq_n_u16(uint16_t v1) {
-  // CHECK: test_vdupq_n_u16
+  // CHECK-LABEL: test_vdupq_n_u16
   return vdupq_n_u16(v1);
   // CHECK: dup {{v[0-9]+}}.8h, {{w[0-9]+}}
 }
 
 uint32x4_t test_vdupq_n_u32(uint32_t v1) {
-  // CHECK: test_vdupq_n_u32
+  // CHECK-LABEL: test_vdupq_n_u32
   return vdupq_n_u32(v1);
   // CHECK: dup {{v[0-9]+}}.4s, {{w[0-9]+}}
 }
 
 uint64x2_t test_vdupq_n_u64(uint64_t v1) {
-  // CHECK: test_vdupq_n_u64
+  // CHECK-LABEL: test_vdupq_n_u64
   return vdupq_n_u64(v1);
   // CHECK: dup {{v[0-9]+}}.2d, {{x[0-9]+}}
 }
 
 int8x8_t test_vdup_n_s8(int8_t v1) {
-  // CHECK: test_vdup_n_s8
+  // CHECK-LABEL: test_vdup_n_s8
   return vdup_n_s8(v1);
   // CHECK: dup {{v[0-9]+}}.8b, {{w[0-9]+}}
 }
 
 int16x4_t test_vdup_n_s16(int16_t v1) {
-  // CHECK: test_vdup_n_s16
+  // CHECK-LABEL: test_vdup_n_s16
   return vdup_n_s16(v1);
   // CHECK: dup {{v[0-9]+}}.4h, {{w[0-9]+}}
 }
 
 int32x2_t test_vdup_n_s32(int32_t v1) {
-  // CHECK: test_vdup_n_s32
+  // CHECK-LABEL: test_vdup_n_s32
   return vdup_n_s32(v1);
   // CHECK: dup {{v[0-9]+}}.2s, {{w[0-9]+}}
 }
 
 int64x1_t test_vdup_n_s64(int64_t v1) {
-  // CHECK: test_vdup_n_s64
+  // CHECK-LABEL: test_vdup_n_s64
   return vdup_n_s64(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 int8x16_t test_vdupq_n_s8(int8_t v1) {
-  // CHECK: test_vdupq_n_s8
+  // CHECK-LABEL: test_vdupq_n_s8
   return vdupq_n_s8(v1);
   // CHECK: dup {{v[0-9]+}}.16b, {{w[0-9]+}}
 }
 
 int16x8_t test_vdupq_n_s16(int16_t v1) {
-  // CHECK: test_vdupq_n_s16
+  // CHECK-LABEL: test_vdupq_n_s16
   return vdupq_n_s16(v1);
   // CHECK: dup {{v[0-9]+}}.8h, {{w[0-9]+}}
 }
 
 int32x4_t test_vdupq_n_s32(int32_t v1) {
-  // CHECK: test_vdupq_n_s32
+  // CHECK-LABEL: test_vdupq_n_s32
   return vdupq_n_s32(v1);
   // CHECK: dup {{v[0-9]+}}.4s, {{w[0-9]+}}
 }
 
 int64x2_t test_vdupq_n_s64(int64_t v1) {
-  // CHECK: test_vdupq_n_s64
+  // CHECK-LABEL: test_vdupq_n_s64
   return vdupq_n_s64(v1);
   // CHECK: dup {{v[0-9]+}}.2d, {{x[0-9]+}}
 }
 
 poly8x8_t test_vdup_n_p8(poly8_t v1) {
-  // CHECK: test_vdup_n_p8
+  // CHECK-LABEL: test_vdup_n_p8
   return vdup_n_p8(v1);
   // CHECK: dup {{v[0-9]+}}.8b, {{w[0-9]+}}
 }
 
 poly16x4_t test_vdup_n_p16(poly16_t v1) {
-  // CHECK: test_vdup_n_p16
+  // CHECK-LABEL: test_vdup_n_p16
   return vdup_n_p16(v1);
   // CHECK: dup {{v[0-9]+}}.4h, {{w[0-9]+}}
 }
 
 poly8x16_t test_vdupq_n_p8(poly8_t v1) {
-  // CHECK: test_vdupq_n_p8
+  // CHECK-LABEL: test_vdupq_n_p8
   return vdupq_n_p8(v1);
   // CHECK: dup {{v[0-9]+}}.16b, {{w[0-9]+}}
 }
 
 poly16x8_t test_vdupq_n_p16(poly16_t v1) {
-  // CHECK: test_vdupq_n_p16
+  // CHECK-LABEL: test_vdupq_n_p16
   return vdupq_n_p16(v1);
   // CHECK: dup {{v[0-9]+}}.8h, {{w[0-9]+}}
 }
 
 float32x2_t test_vdup_n_f32(float32_t v1) {
-  // CHECK: test_vdup_n_f32
+  // CHECK-LABEL: test_vdup_n_f32
   return vdup_n_f32(v1);
   // CHECK: dup {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float64x1_t test_vdup_n_f64(float64_t v1) {
-  // CHECK: test_vdup_n_f64
+  // CHECK-LABEL: test_vdup_n_f64
   return vdup_n_f64(v1);
   // CHECK: ret
 }
 
 float32x4_t test_vdupq_n_f32(float32_t v1) {
-  // CHECK: test_vdupq_n_f32
+  // CHECK-LABEL: test_vdupq_n_f32
   return vdupq_n_f32(v1);
   // CHECK: dup {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float64x2_t test_vdupq_n_f64(float64_t v1) {
-  // CHECK: test_vdupq_n_f64
+  // CHECK-LABEL: test_vdupq_n_f64
   return vdupq_n_f64(v1);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 int8x8_t test_vdup_lane_s8(int8x8_t v1) {
-  // CHECK: test_vdup_lane_s8
+  // CHECK-LABEL: test_vdup_lane_s8
   return vdup_lane_s8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.8b, {{v[0-9]+}}.b[5]
 }
 
 int16x4_t test_vdup_lane_s16(int16x4_t v1) {
-  // CHECK: test_vdup_lane_s16
+  // CHECK-LABEL: test_vdup_lane_s16
   return vdup_lane_s16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.4h, {{v[0-9]+}}.h[2]
 }
 
 int32x2_t test_vdup_lane_s32(int32x2_t v1) {
-  // CHECK: test_vdup_lane_s32
+  // CHECK-LABEL: test_vdup_lane_s32
   return vdup_lane_s32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int64x1_t test_vdup_lane_s64(int64x1_t v1) {
-  // CHECK: test_vdup_lane_s64
+  // CHECK-LABEL: test_vdup_lane_s64
   return vdup_lane_s64(v1, 0);
   // CHECK: ret
 }
 
 int8x16_t test_vdupq_lane_s8(int8x8_t v1) {
-  // CHECK: test_vdupq_lane_s8
+  // CHECK-LABEL: test_vdupq_lane_s8
   return vdupq_lane_s8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.16b, {{v[0-9]+}}.b[5]
 }
 
 int16x8_t test_vdupq_lane_s16(int16x4_t v1) {
-  // CHECK: test_vdupq_lane_s16
+  // CHECK-LABEL: test_vdupq_lane_s16
   return vdupq_lane_s16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.8h, {{v[0-9]+}}.h[2]
 }
 
 int32x4_t test_vdupq_lane_s32(int32x2_t v1) {
-  // CHECK: test_vdupq_lane_s32
+  // CHECK-LABEL: test_vdupq_lane_s32
   return vdupq_lane_s32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int64x2_t test_vdupq_lane_s64(int64x1_t v1) {
-  // CHECK: test_vdupq_lane_s64
+  // CHECK-LABEL: test_vdupq_lane_s64
   return vdupq_lane_s64(v1, 0);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 uint8x8_t test_vdup_lane_u8(uint8x8_t v1) {
-  // CHECK: test_vdup_lane_u8
+  // CHECK-LABEL: test_vdup_lane_u8
   return vdup_lane_u8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.8b, {{v[0-9]+}}.b[5]
 }
 
 uint16x4_t test_vdup_lane_u16(uint16x4_t v1) {
-  // CHECK: test_vdup_lane_u16
+  // CHECK-LABEL: test_vdup_lane_u16
   return vdup_lane_u16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.4h, {{v[0-9]+}}.h[2]
 }
 
 uint32x2_t test_vdup_lane_u32(uint32x2_t v1) {
-  // CHECK: test_vdup_lane_u32
+  // CHECK-LABEL: test_vdup_lane_u32
   return vdup_lane_u32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 uint64x1_t test_vdup_lane_u64(uint64x1_t v1) {
-  // CHECK: test_vdup_lane_u64
+  // CHECK-LABEL: test_vdup_lane_u64
   return vdup_lane_u64(v1, 0);
   // CHECK: ret
 }
 
 uint8x16_t test_vdupq_lane_u8(uint8x8_t v1) {
-  // CHECK: test_vdupq_lane_u8
+  // CHECK-LABEL: test_vdupq_lane_u8
   return vdupq_lane_u8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.16b, {{v[0-9]+}}.b[5]
 }
 
 uint16x8_t test_vdupq_lane_u16(uint16x4_t v1) {
-  // CHECK: test_vdupq_lane_u16
+  // CHECK-LABEL: test_vdupq_lane_u16
   return vdupq_lane_u16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.8h, {{v[0-9]+}}.h[2]
 }
 
 uint32x4_t test_vdupq_lane_u32(uint32x2_t v1) {
-  // CHECK: test_vdupq_lane_u32
+  // CHECK-LABEL: test_vdupq_lane_u32
   return vdupq_lane_u32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 uint64x2_t test_vdupq_lane_u64(uint64x1_t v1) {
-  // CHECK: test_vdupq_lane_u64
+  // CHECK-LABEL: test_vdupq_lane_u64
   return vdupq_lane_u64(v1, 0);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 int8x8_t test_vdup_laneq_s8(int8x16_t v1) {
-  // CHECK: test_vdup_laneq_s8
+  // CHECK-LABEL: test_vdup_laneq_s8
   return vdup_laneq_s8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.8b, {{v[0-9]+}}.b[5]
 }
 
 int16x4_t test_vdup_laneq_s16(int16x8_t v1) {
-  // CHECK: test_vdup_laneq_s16
+  // CHECK-LABEL: test_vdup_laneq_s16
   return vdup_laneq_s16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.4h, {{v[0-9]+}}.h[2]
 }
 
 int32x2_t test_vdup_laneq_s32(int32x4_t v1) {
-  // CHECK: test_vdup_laneq_s32
+  // CHECK-LABEL: test_vdup_laneq_s32
   return vdup_laneq_s32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 int64x1_t test_vdup_laneq_s64(int64x2_t v1) {
-  // CHECK: test_vdup_laneq_s64
+  // CHECK-LABEL: test_vdup_laneq_s64
   return vdup_laneq_s64(v1, 0);
   // CHECK: ret
 }
 
 int8x16_t test_vdupq_laneq_s8(int8x16_t v1) {
-  // CHECK: test_vdupq_laneq_s8
+  // CHECK-LABEL: test_vdupq_laneq_s8
   return vdupq_laneq_s8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.16b, {{v[0-9]+}}.b[5]
 }
 
 int16x8_t test_vdupq_laneq_s16(int16x8_t v1) {
-  // CHECK: test_vdupq_laneq_s16
+  // CHECK-LABEL: test_vdupq_laneq_s16
   return vdupq_laneq_s16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.8h, {{v[0-9]+}}.h[2]
 }
 
 int32x4_t test_vdupq_laneq_s32(int32x4_t v1) {
-  // CHECK: test_vdupq_laneq_s32
+  // CHECK-LABEL: test_vdupq_laneq_s32
   return vdupq_laneq_s32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 int64x2_t test_vdupq_laneq_s64(int64x2_t v1) {
-  // CHECK: test_vdupq_laneq_s64
+  // CHECK-LABEL: test_vdupq_laneq_s64
   return vdupq_laneq_s64(v1, 0);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 uint8x8_t test_vdup_laneq_u8(uint8x16_t v1) {
-  // CHECK: test_vdup_laneq_u8
+  // CHECK-LABEL: test_vdup_laneq_u8
   return vdup_laneq_u8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.8b, {{v[0-9]+}}.b[5]
 }
 
 uint16x4_t test_vdup_laneq_u16(uint16x8_t v1) {
-  // CHECK: test_vdup_laneq_u16
+  // CHECK-LABEL: test_vdup_laneq_u16
   return vdup_laneq_u16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.4h, {{v[0-9]+}}.h[2]
 }
 
 uint32x2_t test_vdup_laneq_u32(uint32x4_t v1) {
-  // CHECK: test_vdup_laneq_u32
+  // CHECK-LABEL: test_vdup_laneq_u32
   return vdup_laneq_u32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 uint64x1_t test_vdup_laneq_u64(uint64x2_t v1) {
-  // CHECK: test_vdup_laneq_u64
+  // CHECK-LABEL: test_vdup_laneq_u64
   return vdup_laneq_u64(v1, 0);
   // CHECK: ret
 }
 
 uint8x16_t test_vdupq_laneq_u8(uint8x16_t v1) {
-  // CHECK: test_vdupq_laneq_u8
+  // CHECK-LABEL: test_vdupq_laneq_u8
   return vdupq_laneq_u8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.16b, {{v[0-9]+}}.b[5]
 }
 
 uint16x8_t test_vdupq_laneq_u16(uint16x8_t v1) {
-  // CHECK: test_vdupq_laneq_u16
+  // CHECK-LABEL: test_vdupq_laneq_u16
   return vdupq_laneq_u16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.8h, {{v[0-9]+}}.h[2]
 }
 
 uint32x4_t test_vdupq_laneq_u32(uint32x4_t v1) {
-  // CHECK: test_vdupq_laneq_u32
+  // CHECK-LABEL: test_vdupq_laneq_u32
   return vdupq_laneq_u32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 uint64x2_t test_vdupq_laneq_u64(uint64x2_t v1) {
-  // CHECK: test_vdupq_laneq_u64
+  // CHECK-LABEL: test_vdupq_laneq_u64
   return vdupq_laneq_u64(v1, 0);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 poly8x8_t test_vdup_lane_p8(poly8x8_t v1) {
-  // CHECK: test_vdup_lane_p8
+  // CHECK-LABEL: test_vdup_lane_p8
   return vdup_lane_p8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.8b, {{v[0-9]+}}.b[5]
 }
 
 poly16x4_t test_vdup_lane_p16(poly16x4_t v1) {
-  // CHECK: test_vdup_lane_p16
+  // CHECK-LABEL: test_vdup_lane_p16
   return vdup_lane_p16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.4h, {{v[0-9]+}}.h[2]
 }
 
 poly8x16_t test_vdupq_lane_p8(poly8x8_t v1) {
-  // CHECK: test_vdupq_lane_p8
+  // CHECK-LABEL: test_vdupq_lane_p8
   return vdupq_lane_p8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.16b, {{v[0-9]+}}.b[5]
 }
 
 poly16x8_t test_vdupq_lane_p16(poly16x4_t v1) {
-  // CHECK: test_vdupq_lane_p16
+  // CHECK-LABEL: test_vdupq_lane_p16
   return vdupq_lane_p16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.8h, {{v[0-9]+}}.h[2]
 }
 
 poly8x8_t test_vdup_laneq_p8(poly8x16_t v1) {
-  // CHECK: test_vdup_laneq_p8
+  // CHECK-LABEL: test_vdup_laneq_p8
   return vdup_laneq_p8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.8b, {{v[0-9]+}}.b[5]
 }
 
 poly16x4_t test_vdup_laneq_p16(poly16x8_t v1) {
-  // CHECK: test_vdup_laneq_p16
+  // CHECK-LABEL: test_vdup_laneq_p16
   return vdup_laneq_p16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.4h, {{v[0-9]+}}.h[2]
 }
 
 poly8x16_t test_vdupq_laneq_p8(poly8x16_t v1) {
-  // CHECK: test_vdupq_laneq_p8
+  // CHECK-LABEL: test_vdupq_laneq_p8
   return vdupq_laneq_p8(v1, 5);
   // CHECK: dup {{v[0-9]+}}.16b, {{v[0-9]+}}.b[5]
 }
 
 poly16x8_t test_vdupq_laneq_p16(poly16x8_t v1) {
-  // CHECK: test_vdupq_laneq_p16
+  // CHECK-LABEL: test_vdupq_laneq_p16
   return vdupq_laneq_p16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.8h, {{v[0-9]+}}.h[2]
 }
 
 float16x4_t test_vdup_lane_f16(float16x4_t v1) {
-  // CHECK: test_vdup_lane_f16
+  // CHECK-LABEL: test_vdup_lane_f16
   return vdup_lane_f16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.4h, {{v[0-9]+}}.h[2]
 }
 
 float32x2_t test_vdup_lane_f32(float32x2_t v1) {
-  // CHECK: test_vdup_lane_f32
+  // CHECK-LABEL: test_vdup_lane_f32
   return vdup_lane_f32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 float64x1_t test_vdup_lane_f64(float64x1_t v1) {
-  // CHECK: test_vdup_lane_f64
+  // CHECK-LABEL: test_vdup_lane_f64
   return vdup_lane_f64(v1, 0);
   // CHECK: ret
 }
 
 float16x4_t test_vdup_laneq_f16(float16x8_t v1) {
-  // CHECK: test_vdup_laneq_f16
+  // CHECK-LABEL: test_vdup_laneq_f16
   return vdup_laneq_f16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.4h, {{v[0-9]+}}.h[2]
 }
 
 float32x2_t test_vdup_laneq_f32(float32x4_t v1) {
-  // CHECK: test_vdup_laneq_f32
+  // CHECK-LABEL: test_vdup_laneq_f32
   return vdup_laneq_f32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 }
 
 float64x1_t test_vdup_laneq_f64(float64x2_t v1) {
-  // CHECK: test_vdup_laneq_f64
+  // CHECK-LABEL: test_vdup_laneq_f64
   return vdup_laneq_f64(v1, 0);
   // CHECK: ret
 }
 
 float16x8_t test_vdupq_lane_f16(float16x4_t v1) {
-  // CHECK: test_vdupq_lane_f16
+  // CHECK-LABEL: test_vdupq_lane_f16
   return vdupq_lane_f16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.8h, {{v[0-9]+}}.h[2]
 }
 
 float32x4_t test_vdupq_lane_f32(float32x2_t v1) {
-  // CHECK: test_vdupq_lane_f32
+  // CHECK-LABEL: test_vdupq_lane_f32
   return vdupq_lane_f32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 float64x2_t test_vdupq_lane_f64(float64x1_t v1) {
-  // CHECK: test_vdupq_lane_f64
+  // CHECK-LABEL: test_vdupq_lane_f64
   return vdupq_lane_f64(v1, 0);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 float16x8_t test_vdupq_laneq_f16(float16x8_t v1) {
-  // CHECK: test_vdupq_laneq_f16
+  // CHECK-LABEL: test_vdupq_laneq_f16
   return vdupq_laneq_f16(v1, 2);
   // CHECK: dup {{v[0-9]+}}.8h, {{v[0-9]+}}.h[2]
 }
 
 float32x4_t test_vdupq_laneq_f32(float32x4_t v1) {
-  // CHECK: test_vdupq_laneq_f32
+  // CHECK-LABEL: test_vdupq_laneq_f32
   return vdupq_laneq_f32(v1, 1);
   // CHECK: dup {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 }
 
 float64x2_t test_vdupq_laneq_f64(float64x2_t v1) {
-  // CHECK: test_vdupq_laneq_f64
+  // CHECK-LABEL: test_vdupq_laneq_f64
   return vdupq_laneq_f64(v1, 0);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 int8x8_t test_vmov_n_s8(int8_t v1) {
-  // CHECK: test_vmov_n_s8
+  // CHECK-LABEL: test_vmov_n_s8
   return vmov_n_s8(v1);
   // CHECK: dup {{v[0-9]+}}.8b, {{w[0-9]+}}
 }
 
 int16x4_t test_vmov_n_s16(int16_t v1) {
-  // CHECK: test_vmov_n_s16
+  // CHECK-LABEL: test_vmov_n_s16
   return vmov_n_s16(v1);
   // CHECK: dup {{v[0-9]+}}.4h, {{w[0-9]+}}
 }
 
 int32x2_t test_vmov_n_s32(int32_t v1) {
-  // CHECK: test_vmov_n_s32
+  // CHECK-LABEL: test_vmov_n_s32
   return vmov_n_s32(v1);
   // CHECK: dup {{v[0-9]+}}.2s, {{w[0-9]+}}
 }
 
 int64x1_t test_vmov_n_s64(int64_t v1) {
-  // CHECK: test_vmov_n_s64
+  // CHECK-LABEL: test_vmov_n_s64
   return vmov_n_s64(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 int8x16_t test_vmovq_n_s8(int8_t v1) {
-  // CHECK: test_vmovq_n_s8
+  // CHECK-LABEL: test_vmovq_n_s8
   return vmovq_n_s8(v1);
   // CHECK: dup {{v[0-9]+}}.16b, {{w[0-9]+}}
 }
 
 int16x8_t test_vmovq_n_s16(int16_t v1) {
-  // CHECK: test_vmovq_n_s16
+  // CHECK-LABEL: test_vmovq_n_s16
   return vmovq_n_s16(v1);
   // CHECK: dup {{v[0-9]+}}.8h, {{w[0-9]+}}
 }
 
 int32x4_t test_vmovq_n_s32(int32_t v1) {
-  // CHECK: test_vmovq_n_s32
+  // CHECK-LABEL: test_vmovq_n_s32
   return vmovq_n_s32(v1);
   // CHECK: dup {{v[0-9]+}}.4s, {{w[0-9]+}}
 }
 
 int64x2_t test_vmovq_n_s64(int64_t v1) {
-  // CHECK: test_vmovq_n_s64
+  // CHECK-LABEL: test_vmovq_n_s64
   return vmovq_n_s64(v1);
   // CHECK: dup {{v[0-9]+}}.2d, {{x[0-9]+}}
 }
 
 uint8x8_t test_vmov_n_u8(uint8_t v1) {
-  // CHECK: test_vmov_n_u8
+  // CHECK-LABEL: test_vmov_n_u8
   return vmov_n_u8(v1);
   // CHECK: dup {{v[0-9]+}}.8b, {{w[0-9]+}}
 }
 
 uint16x4_t test_vmov_n_u16(uint16_t v1) {
-  // CHECK: test_vmov_n_u16
+  // CHECK-LABEL: test_vmov_n_u16
   return vmov_n_u16(v1);
   // CHECK: dup {{v[0-9]+}}.4h, {{w[0-9]+}}
 }
 
 uint32x2_t test_vmov_n_u32(uint32_t v1) {
-  // CHECK: test_vmov_n_u32
+  // CHECK-LABEL: test_vmov_n_u32
   return vmov_n_u32(v1);
   // CHECK: dup {{v[0-9]+}}.2s, {{w[0-9]+}}
 }
 
 uint64x1_t test_vmov_n_u64(uint64_t v1) {
-  // CHECK: test_vmov_n_u64
+  // CHECK-LABEL: test_vmov_n_u64
   return vmov_n_u64(v1);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 uint8x16_t test_vmovq_n_u8(uint8_t v1) {
-  // CHECK: test_vmovq_n_u8
+  // CHECK-LABEL: test_vmovq_n_u8
   return vmovq_n_u8(v1);
   // CHECK: dup {{v[0-9]+}}.16b, {{w[0-9]+}}
 }
 
 uint16x8_t test_vmovq_n_u16(uint16_t v1) {
-  // CHECK: test_vmovq_n_u16
+  // CHECK-LABEL: test_vmovq_n_u16
   return vmovq_n_u16(v1);
   // CHECK: dup {{v[0-9]+}}.8h, {{w[0-9]+}}
 }
 
 uint32x4_t test_vmovq_n_u32(uint32_t v1) {
-  // CHECK: test_vmovq_n_u32
+  // CHECK-LABEL: test_vmovq_n_u32
   return vmovq_n_u32(v1);
   // CHECK: dup {{v[0-9]+}}.4s, {{w[0-9]+}}
 }
 
 uint64x2_t test_vmovq_n_u64(uint64_t v1) {
-  // CHECK: test_vmovq_n_u64
+  // CHECK-LABEL: test_vmovq_n_u64
   return vmovq_n_u64(v1);
   // CHECK: dup {{v[0-9]+}}.2d, {{x[0-9]+}}
 }
 
 poly8x8_t test_vmov_n_p8(poly8_t v1) {
-  // CHECK: test_vmov_n_p8
+  // CHECK-LABEL: test_vmov_n_p8
   return vmov_n_p8(v1);
   // CHECK: dup {{v[0-9]+}}.8b, {{w[0-9]+}}
 }
 
 poly16x4_t test_vmov_n_p16(poly16_t v1) {
-  // CHECK: test_vmov_n_p16
+  // CHECK-LABEL: test_vmov_n_p16
   return vmov_n_p16(v1);
   // CHECK: dup {{v[0-9]+}}.4h, {{w[0-9]+}}
 }
 
 poly8x16_t test_vmovq_n_p8(poly8_t v1) {
-  // CHECK: test_vmovq_n_p8
+  // CHECK-LABEL: test_vmovq_n_p8
   return vmovq_n_p8(v1);
   // CHECK: dup {{v[0-9]+}}.16b, {{w[0-9]+}}
 }
 
 poly16x8_t test_vmovq_n_p16(poly16_t v1) {
-  // CHECK: test_vmovq_n_p16
+  // CHECK-LABEL: test_vmovq_n_p16
   return vmovq_n_p16(v1);
   // CHECK: dup {{v[0-9]+}}.8h, {{w[0-9]+}}
 }
 
 float32x2_t test_vmov_n_f32(float32_t v1) {
-  // CHECK: test_vmov_n_f32
+  // CHECK-LABEL: test_vmov_n_f32
   return vmov_n_f32(v1);
   // CHECK: dup {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
 }
 
 float64x1_t test_vmov_n_f64(float64_t v1) {
-  // CHECK: test_vmov_n_f64
+  // CHECK-LABEL: test_vmov_n_f64
   return vmov_n_f64(v1);
   // CHECK: ret
 }
 
 float32x4_t test_vmovq_n_f32(float32_t v1) {
-  // CHECK: test_vmovq_n_f32
+  // CHECK-LABEL: test_vmovq_n_f32
   return vmovq_n_f32(v1);
   // CHECK: dup {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
 }
 
 float64x2_t test_vmovq_n_f64(float64_t v1) {
-  // CHECK: test_vmovq_n_f64
+  // CHECK-LABEL: test_vmovq_n_f64
   return vmovq_n_f64(v1);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vcopy_lane_s64
+// CHECK-LABEL: test_vcopy_lane_s64
 int64x1_t test_vcopy_lane_s64(int64x1_t a, int64x1_t c) {
   return vcopy_lane_s64(a, 0, c, 0);
 // CHECK: fmov {{d[0-9]+}}, {{d[0-9]+}}
 // CHECK-NOT: dup {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vcopy_lane_u64
+// CHECK-LABEL: test_vcopy_lane_u64
 uint64x1_t test_vcopy_lane_u64(uint64x1_t a, uint64x1_t c) {
   return vcopy_lane_u64(a, 0, c, 0);
 // CHECK: fmov {{d[0-9]+}}, {{d[0-9]+}}
 // CHECK-NOT: dup {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vcopy_lane_f64
+// CHECK-LABEL: test_vcopy_lane_f64
 float64x1_t test_vcopy_lane_f64(float64x1_t a, float64x1_t c) {
   return vcopy_lane_f64(a, 0, c, 0);
 // CHECK: fmov {{d[0-9]+}}, {{d[0-9]+}}
 // CHECK-NOT: dup {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vcopy_laneq_s64
+// CHECK-LABEL: test_vcopy_laneq_s64
 int64x1_t test_vcopy_laneq_s64(int64x1_t a, int64x2_t c) {
   return vcopy_laneq_s64(a, 0, c, 1);
 // CHECK: dup {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
-// CHECK: test_vcopy_laneq_u64
+// CHECK-LABEL: test_vcopy_laneq_u64
 uint64x1_t test_vcopy_laneq_u64(uint64x1_t a, uint64x2_t c) {
   return vcopy_laneq_u64(a, 0, c, 1);
 // CHECK: dup {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
-// CHECK: test_vcopy_laneq_f64
+// CHECK-LABEL: test_vcopy_laneq_f64
 float64x1_t test_vcopy_laneq_f64(float64x1_t a, float64x2_t c) {
   return vcopy_laneq_f64(a, 0, c, 1);
 // CHECK: dup {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
-// CHECK: test_vcopy_laneq_p64
+// CHECK-LABEL: test_vcopy_laneq_p64
 poly64x1_t test_vcopy_laneq_p64(poly64x1_t a, poly64x2_t c) {
   return vcopy_laneq_p64(a, 0, c, 1);
 // CHECK: dup {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
-// CHECK: test_vcopyq_laneq_f64
+// CHECK-LABEL: test_vcopyq_laneq_f64
 float64x2_t test_vcopyq_laneq_f64(float64x2_t a, float64x2_t c) {
 // CHECK: ins  {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[1]
   return vcopyq_laneq_f64(a, 1, c, 1);

Modified: cfe/trunk/test/CodeGen/aarch64-neon-extract.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-extract.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-extract.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-extract.c Mon Mar  3 05:34:36 2014
@@ -7,142 +7,142 @@
 #include <arm_neon.h>
 
 int8x8_t test_vext_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vext_s8
+  // CHECK-LABEL: test_vext_s8
   return vext_s8(a, b, 2);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x2
 }
 
 int16x4_t test_vext_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vext_s16
+  // CHECK-LABEL: test_vext_s16
   return vext_s16(a, b, 3);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x6
 }
 
 int32x2_t test_vext_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vext_s32
+  // CHECK-LABEL: test_vext_s32
   return vext_s32(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x4
 }
 
 int64x1_t test_vext_s64(int64x1_t a, int64x1_t b) {
-  // CHECK: test_vext_s64
+  // CHECK-LABEL: test_vext_s64
   return vext_s64(a, b, 0);
 }
 
 int8x16_t test_vextq_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vextq_s8
+  // CHECK-LABEL: test_vextq_s8
   return vextq_s8(a, b, 2);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x2
 }
 
 int16x8_t test_vextq_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vextq_s16
+  // CHECK-LABEL: test_vextq_s16
   return vextq_s16(a, b, 3);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x6
 }
 
 int32x4_t test_vextq_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vextq_s32
+  // CHECK-LABEL: test_vextq_s32
   return vextq_s32(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x4
 }
 
 int64x2_t test_vextq_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vextq_s64
+  // CHECK-LABEL: test_vextq_s64
   return vextq_s64(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x8
 }
 
 uint8x8_t test_vext_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vext_u8
+  // CHECK-LABEL: test_vext_u8
   return vext_u8(a, b, 2);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x2
 }
 
 uint16x4_t test_vext_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vext_u16
+  // CHECK-LABEL: test_vext_u16
   return vext_u16(a, b, 3);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x6
 }
 
 uint32x2_t test_vext_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vext_u32
+  // CHECK-LABEL: test_vext_u32
   return vext_u32(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x4
 }
 
 uint64x1_t test_vext_u64(uint64x1_t a, uint64x1_t b) {
-  // CHECK: test_vext_u64
+  // CHECK-LABEL: test_vext_u64
   return vext_u64(a, b, 0);
 }
 
 uint8x16_t test_vextq_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vextq_u8
+  // CHECK-LABEL: test_vextq_u8
   return vextq_u8(a, b, 2);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x2
 }
 
 uint16x8_t test_vextq_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vextq_u16
+  // CHECK-LABEL: test_vextq_u16
   return vextq_u16(a, b, 3);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x6
 }
 
 uint32x4_t test_vextq_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vextq_u32
+  // CHECK-LABEL: test_vextq_u32
   return vextq_u32(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x4
 }
 
 uint64x2_t test_vextq_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vextq_u64
+  // CHECK-LABEL: test_vextq_u64
   return vextq_u64(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x8
 }
 
 float32x2_t test_vext_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vext_f32
+  // CHECK-LABEL: test_vext_f32
   return vext_f32(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x4
 }
 
 float64x1_t test_vext_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vext_f64
+  // CHECK-LABEL: test_vext_f64
   return vext_f64(a, b, 0);
 }
 
 float32x4_t test_vextq_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vextq_f32
+  // CHECK-LABEL: test_vextq_f32
   return vextq_f32(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x4
 }
 
 float64x2_t test_vextq_f64(float64x2_t a, float64x2_t b) {
-  // CHECK: test_vextq_f64
+  // CHECK-LABEL: test_vextq_f64
   return vextq_f64(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x8
 }
 
 poly8x8_t test_vext_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vext_p8
+  // CHECK-LABEL: test_vext_p8
   return vext_p8(a, b, 2);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x2
 }
 
 poly16x4_t test_vext_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vext_p16
+  // CHECK-LABEL: test_vext_p16
   return vext_p16(a, b, 3);
   // CHECK: ext {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x6
 }
 
 poly8x16_t test_vextq_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vextq_p8
+  // CHECK-LABEL: test_vextq_p8
   return vextq_p8(a, b, 2);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x2
 }
 
 poly16x8_t test_vextq_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vextq_p16
+  // CHECK-LABEL: test_vextq_p16
   return vextq_p16(a, b, 3);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x6
 }

Modified: cfe/trunk/test/CodeGen/aarch64-neon-fcvt-intrinsics.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-fcvt-intrinsics.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-fcvt-intrinsics.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-fcvt-intrinsics.c Mon Mar  3 05:34:36 2014
@@ -7,127 +7,127 @@
 #include <arm_neon.h>
 
 float32_t test_vcvtxd_f32_f64(float64_t a) {
-// CHECK: test_vcvtxd_f32_f64
+// CHECK-LABEL: test_vcvtxd_f32_f64
 // CHECK: fcvtxn {{s[0-9]+}}, {{d[0-9]+}}
   return (float32_t)vcvtxd_f32_f64(a);
 }
 
 int32_t test_vcvtas_s32_f32(float32_t a) {
-// CHECK: test_vcvtas_s32_f32
+// CHECK-LABEL: test_vcvtas_s32_f32
 // CHECK: fcvtas {{s[0-9]+}}, {{s[0-9]+}}
   return (int32_t)vcvtas_s32_f32(a);
 }
 
 int64_t test_test_vcvtad_s64_f64(float64_t a) {
-// CHECK: test_test_vcvtad_s64_f64
+// CHECK-LABEL: test_test_vcvtad_s64_f64
 // CHECK: fcvtas {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcvtad_s64_f64(a);
 }
 
 uint32_t test_vcvtas_u32_f32(float32_t a) {
-// CHECK: test_vcvtas_u32_f32
+// CHECK-LABEL: test_vcvtas_u32_f32
 // CHECK: fcvtau {{s[0-9]+}}, {{s[0-9]+}}
   return (uint32_t)vcvtas_u32_f32(a);
 }
 
 uint64_t test_vcvtad_u64_f64(float64_t a) {
-// CHECK: test_vcvtad_u64_f64
+// CHECK-LABEL: test_vcvtad_u64_f64
 // CHECK: fcvtau {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vcvtad_u64_f64(a);
 }
 
 int32_t test_vcvtms_s32_f32(float32_t a) {
-// CHECK: test_vcvtms_s32_f32
+// CHECK-LABEL: test_vcvtms_s32_f32
 // CHECK: fcvtms {{s[0-9]+}}, {{s[0-9]+}}
   return (int32_t)vcvtms_s32_f32(a);
 }
 
 int64_t test_vcvtmd_s64_f64(float64_t a) {
-// CHECK: test_vcvtmd_s64_f64
+// CHECK-LABEL: test_vcvtmd_s64_f64
 // CHECK: fcvtms {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcvtmd_s64_f64(a);
 }
 
 uint32_t test_vcvtms_u32_f32(float32_t a) {
-// CHECK: test_vcvtms_u32_f32
+// CHECK-LABEL: test_vcvtms_u32_f32
 // CHECK: fcvtmu {{s[0-9]+}}, {{s[0-9]+}}
   return (uint32_t)vcvtms_u32_f32(a);
 }
 
 uint64_t test_vcvtmd_u64_f64(float64_t a) {
-// CHECK: test_vcvtmd_u64_f64
+// CHECK-LABEL: test_vcvtmd_u64_f64
 // CHECK: fcvtmu {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vcvtmd_u64_f64(a);
 }
 
 int32_t test_vcvtns_s32_f32(float32_t a) {
-// CHECK: test_vcvtns_s32_f32
+// CHECK-LABEL: test_vcvtns_s32_f32
 // CHECK: fcvtns {{s[0-9]+}}, {{s[0-9]+}}
   return (int32_t)vcvtns_s32_f32(a);
 }
 
 int64_t test_vcvtnd_s64_f64(float64_t a) {
-// CHECK: test_vcvtnd_s64_f64
+// CHECK-LABEL: test_vcvtnd_s64_f64
 // CHECK: fcvtns {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcvtnd_s64_f64(a);
 }
 
 uint32_t test_vcvtns_u32_f32(float32_t a) {
-// CHECK: test_vcvtns_u32_f32
+// CHECK-LABEL: test_vcvtns_u32_f32
 // CHECK: fcvtnu {{s[0-9]+}}, {{s[0-9]+}}
   return (uint32_t)vcvtns_u32_f32(a);
 }
 
 uint64_t test_vcvtnd_u64_f64(float64_t a) {
-// CHECK: test_vcvtnd_u64_f64
+// CHECK-LABEL: test_vcvtnd_u64_f64
 // CHECK: fcvtnu {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vcvtnd_u64_f64(a);
 }
 
 int32_t test_vcvtps_s32_f32(float32_t a) {
-// CHECK: test_vcvtps_s32_f32
+// CHECK-LABEL: test_vcvtps_s32_f32
 // CHECK: fcvtps {{s[0-9]+}}, {{s[0-9]+}}
   return (int32_t)vcvtps_s32_f32(a);
 }
 
 int64_t test_vcvtpd_s64_f64(float64_t a) {
-// CHECK: test_vcvtpd_s64_f64
+// CHECK-LABEL: test_vcvtpd_s64_f64
 // CHECK: fcvtps {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcvtpd_s64_f64(a);
 }
 
 uint32_t test_vcvtps_u32_f32(float32_t a) {
-// CHECK: test_vcvtps_u32_f32
+// CHECK-LABEL: test_vcvtps_u32_f32
 // CHECK: fcvtpu {{s[0-9]+}}, {{s[0-9]+}}
   return (uint32_t)vcvtps_u32_f32(a);
 }
 
 uint64_t test_vcvtpd_u64_f64(float64_t a) {
-// CHECK: test_vcvtpd_u64_f64
+// CHECK-LABEL: test_vcvtpd_u64_f64
 // CHECK: fcvtpu {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vcvtpd_u64_f64(a);
 }
 
 int32_t test_vcvts_s32_f32(float32_t a) {
-// CHECK: test_vcvts_s32_f32
+// CHECK-LABEL: test_vcvts_s32_f32
 // CHECK: fcvtzs {{s[0-9]+}}, {{s[0-9]+}}
   return (int32_t)vcvts_s32_f32(a);
 }
 
 int64_t test_vcvtd_s64_f64(float64_t a) {
-// CHECK: test_vcvtd_s64_f64
+// CHECK-LABEL: test_vcvtd_s64_f64
 // CHECK: fcvtzs {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcvtd_s64_f64(a);
 }
 
 uint32_t test_vcvts_u32_f32(float32_t a) {
-// CHECK: test_vcvts_u32_f32
+// CHECK-LABEL: test_vcvts_u32_f32
 // CHECK: fcvtzu {{s[0-9]+}}, {{s[0-9]+}}
   return (uint32_t)vcvts_u32_f32(a);
 }
 
 uint64_t test_vcvtd_u64_f64(float64_t a) {
-// CHECK: test_vcvtd_u64_f64
+// CHECK-LABEL: test_vcvtd_u64_f64
 // CHECK: fcvtzu {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vcvtd_u64_f64(a);
 }

Modified: cfe/trunk/test/CodeGen/aarch64-neon-intrinsics.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-intrinsics.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-intrinsics.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-intrinsics.c Mon Mar  3 05:34:36 2014
@@ -7,103 +7,103 @@
 #include <arm_neon.h>
 
 int8x8_t test_vadd_s8(int8x8_t v1, int8x8_t v2) {
-   // CHECK: test_vadd_s8
+   // CHECK-LABEL: test_vadd_s8
   return vadd_s8(v1, v2);
   // CHECK: add {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vadd_s16(int16x4_t v1, int16x4_t v2) {
-   // CHECK: test_vadd_s16
+   // CHECK-LABEL: test_vadd_s16
   return vadd_s16(v1, v2);
   // CHECK: add {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vadd_s32(int32x2_t v1, int32x2_t v2) {
-   // CHECK: test_vadd_s32
+   // CHECK-LABEL: test_vadd_s32
   return vadd_s32(v1, v2);
   // CHECK: add {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int64x1_t test_vadd_s64(int64x1_t v1, int64x1_t v2) {
-  // CHECK: test_vadd_s64
+  // CHECK-LABEL: test_vadd_s64
   return vadd_s64(v1, v2);
   // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 float32x2_t test_vadd_f32(float32x2_t v1, float32x2_t v2) {
-   // CHECK: test_vadd_f32
+   // CHECK-LABEL: test_vadd_f32
   return vadd_f32(v1, v2);
   // CHECK: fadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vadd_u8(uint8x8_t v1, uint8x8_t v2) {
-   // CHECK: test_vadd_u8
+   // CHECK-LABEL: test_vadd_u8
   return vadd_u8(v1, v2);
   // CHECK: add {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vadd_u16(uint16x4_t v1, uint16x4_t v2) {
-   // CHECK: test_vadd_u16
+   // CHECK-LABEL: test_vadd_u16
   return vadd_u16(v1, v2);
   // CHECK: add {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vadd_u32(uint32x2_t v1, uint32x2_t v2) {
-   // CHECK: test_vadd_u32
+   // CHECK-LABEL: test_vadd_u32
   return vadd_u32(v1, v2);
   // CHECK: add {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vadd_u64(uint64x1_t v1, uint64x1_t v2) {
-   // CHECK: test_vadd_u64
+   // CHECK-LABEL: test_vadd_u64
   return vadd_u64(v1, v2);
   // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8x16_t test_vaddq_s8(int8x16_t v1, int8x16_t v2) {
-   // CHECK: test_vaddq_s8
+   // CHECK-LABEL: test_vaddq_s8
   return vaddq_s8(v1, v2);
   // CHECK: add {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vaddq_s16(int16x8_t v1, int16x8_t v2) {
-   // CHECK: test_vaddq_s16
+   // CHECK-LABEL: test_vaddq_s16
   return vaddq_s16(v1, v2);
   // CHECK: add {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vaddq_s32(int32x4_t v1,int32x4_t  v2) {
-   // CHECK: test_vaddq_s32
+   // CHECK-LABEL: test_vaddq_s32
   return vaddq_s32(v1, v2);
   // CHECK: add {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vaddq_s64(int64x2_t v1, int64x2_t v2) {
-   // CHECK: test_vaddq_s64
+   // CHECK-LABEL: test_vaddq_s64
   return vaddq_s64(v1, v2);
   // CHECK: add {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 float32x4_t test_vaddq_f32(float32x4_t v1, float32x4_t v2) {
-   // CHECK: test_vaddq_f32
+   // CHECK-LABEL: test_vaddq_f32
   return vaddq_f32(v1, v2);
   // CHECK: fadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vaddq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vaddq_f64
+  // CHECK-LABEL: test_vaddq_f64
   return vaddq_f64(v1, v2);
   // CHECK: fadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vaddq_u8(uint8x16_t v1, uint8x16_t v2) {
-   // CHECK: test_vaddq_u8
+   // CHECK-LABEL: test_vaddq_u8
   return vaddq_u8(v1, v2);
   // CHECK: add {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vaddq_u16(uint16x8_t v1, uint16x8_t v2) {
-   // CHECK: test_vaddq_u16
+   // CHECK-LABEL: test_vaddq_u16
   return vaddq_u16(v1, v2);
   // CHECK: add {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
@@ -115,107 +115,107 @@ uint32x4_t test_vaddq_u32(uint32x4_t v1,
 }
 
 uint64x2_t test_vaddq_u64(uint64x2_t v1, uint64x2_t v2) {
-   // CHECK: test_vaddq_u64
+   // CHECK-LABEL: test_vaddq_u64
   return vaddq_u64(v1, v2);
   // CHECK: add {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vsub_s8(int8x8_t v1, int8x8_t v2) {
-   // CHECK: test_vsub_s8
+   // CHECK-LABEL: test_vsub_s8
   return vsub_s8(v1, v2);
   // CHECK: sub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 int16x4_t test_vsub_s16(int16x4_t v1, int16x4_t v2) {
-   // CHECK: test_vsub_s16
+   // CHECK-LABEL: test_vsub_s16
   return vsub_s16(v1, v2);
   // CHECK: sub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int32x2_t test_vsub_s32(int32x2_t v1, int32x2_t v2) {
-   // CHECK: test_vsub_s32
+   // CHECK-LABEL: test_vsub_s32
   return vsub_s32(v1, v2);
   // CHECK: sub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int64x1_t test_vsub_s64(int64x1_t v1, int64x1_t v2) {
-   // CHECK: test_vsub_s64
+   // CHECK-LABEL: test_vsub_s64
   return vsub_s64(v1, v2);
   // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 float32x2_t test_vsub_f32(float32x2_t v1, float32x2_t v2) {
-   // CHECK: test_vsub_f32
+   // CHECK-LABEL: test_vsub_f32
   return vsub_f32(v1, v2);
   // CHECK: fsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vsub_u8(uint8x8_t v1, uint8x8_t v2) {
-   // CHECK: test_vsub_u8
+   // CHECK-LABEL: test_vsub_u8
   return vsub_u8(v1, v2);
   // CHECK: sub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vsub_u16(uint16x4_t v1, uint16x4_t v2) {
-   // CHECK: test_vsub_u16
+   // CHECK-LABEL: test_vsub_u16
   return vsub_u16(v1, v2);
   // CHECK: sub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vsub_u32(uint32x2_t v1, uint32x2_t v2) {
-   // CHECK: test_vsub_u32
+   // CHECK-LABEL: test_vsub_u32
   return vsub_u32(v1, v2);
   // CHECK: sub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vsub_u64(uint64x1_t v1, uint64x1_t v2) {
-   // CHECK: test_vsub_u64
+   // CHECK-LABEL: test_vsub_u64
   return vsub_u64(v1, v2);
   // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8x16_t test_vsubq_s8(int8x16_t v1, int8x16_t v2) {
-   // CHECK: test_vsubq_s8
+   // CHECK-LABEL: test_vsubq_s8
   return vsubq_s8(v1, v2);
   // CHECK: sub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vsubq_s16(int16x8_t v1, int16x8_t v2) {
-   // CHECK: test_vsubq_s16
+   // CHECK-LABEL: test_vsubq_s16
   return vsubq_s16(v1, v2);
   // CHECK: sub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vsubq_s32(int32x4_t v1,int32x4_t  v2) {
-   // CHECK: test_vsubq_s32
+   // CHECK-LABEL: test_vsubq_s32
   return vsubq_s32(v1, v2);
   // CHECK: sub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vsubq_s64(int64x2_t v1, int64x2_t v2) {
-   // CHECK: test_vsubq_s64
+   // CHECK-LABEL: test_vsubq_s64
   return vsubq_s64(v1, v2);
   // CHECK: sub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 float32x4_t test_vsubq_f32(float32x4_t v1, float32x4_t v2) {
-   // CHECK: test_vsubq_f32
+   // CHECK-LABEL: test_vsubq_f32
   return vsubq_f32(v1, v2);
   // CHECK: fsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vsubq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vsubq_f64
+  // CHECK-LABEL: test_vsubq_f64
   return vsubq_f64(v1, v2);
   // CHECK: fsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vsubq_u8(uint8x16_t v1, uint8x16_t v2) {
-   // CHECK: test_vsubq_u8
+   // CHECK-LABEL: test_vsubq_u8
   return vsubq_u8(v1, v2);
   // CHECK: sub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vsubq_u16(uint16x8_t v1, uint16x8_t v2) {
-   // CHECK: test_vsubq_u16
+   // CHECK-LABEL: test_vsubq_u16
   return vsubq_u16(v1, v2);
   // CHECK: sub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
@@ -227,98 +227,98 @@ uint32x4_t test_vsubq_u32(uint32x4_t v1,
 }
 
 uint64x2_t test_vsubq_u64(uint64x2_t v1, uint64x2_t v2) {
-   // CHECK: test_vsubq_u64
+   // CHECK-LABEL: test_vsubq_u64
   return vsubq_u64(v1, v2);
   // CHECK: sub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vmul_s8(int8x8_t v1, int8x8_t v2) {
-  // CHECK: test_vmul_s8
+  // CHECK-LABEL: test_vmul_s8
   return vmul_s8(v1, v2);
   // CHECK: mul {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vmul_s16(int16x4_t v1, int16x4_t v2) {
-  // CHECK: test_vmul_s16
+  // CHECK-LABEL: test_vmul_s16
   return vmul_s16(v1, v2);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vmul_s32(int32x2_t v1, int32x2_t v2) {
-  // CHECK: test_vmul_s32
+  // CHECK-LABEL: test_vmul_s32
   return vmul_s32(v1, v2);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vmul_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vmul_f32
+  // CHECK-LABEL: test_vmul_f32
   return vmul_f32(v1, v2);
   // CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 
 uint8x8_t test_vmul_u8(uint8x8_t v1, uint8x8_t v2) {
-  // CHECK: test_vmul_u8
+  // CHECK-LABEL: test_vmul_u8
   return vmul_u8(v1, v2);
   // CHECK: mul {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vmul_u16(uint16x4_t v1, uint16x4_t v2) {
-  // CHECK: test_vmul_u16
+  // CHECK-LABEL: test_vmul_u16
   return vmul_u16(v1, v2);
   // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vmul_u32(uint32x2_t v1, uint32x2_t v2) {
-  // CHECK: test_vmul_u32
+  // CHECK-LABEL: test_vmul_u32
   return vmul_u32(v1, v2);
   // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vmulq_s8(int8x16_t v1, int8x16_t v2) {
-  // CHECK: test_vmulq_s8
+  // CHECK-LABEL: test_vmulq_s8
   return vmulq_s8(v1, v2);
   // CHECK: mul {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vmulq_s16(int16x8_t v1, int16x8_t v2) {
-  // CHECK: test_vmulq_s16
+  // CHECK-LABEL: test_vmulq_s16
   return vmulq_s16(v1, v2);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vmulq_s32(int32x4_t v1, int32x4_t v2) {
-  // CHECK: test_vmulq_s32
+  // CHECK-LABEL: test_vmulq_s32
   return vmulq_s32(v1, v2);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
     
 uint8x16_t test_vmulq_u8(uint8x16_t v1, uint8x16_t v2) {
-  // CHECK: test_vmulq_u8
+  // CHECK-LABEL: test_vmulq_u8
   return vmulq_u8(v1, v2);
   // CHECK: mul {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vmulq_u16(uint16x8_t v1, uint16x8_t v2) {
-  // CHECK: test_vmulq_u16
+  // CHECK-LABEL: test_vmulq_u16
   return vmulq_u16(v1, v2);
   // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vmulq_u32(uint32x4_t v1, uint32x4_t v2) {
-  // CHECK: test_vmulq_u32
+  // CHECK-LABEL: test_vmulq_u32
   return vmulq_u32(v1, v2);
   // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x4_t test_vmulq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vmulq_f32
+  // CHECK-LABEL: test_vmulq_f32
   return vmulq_f32(v1, v2);
   // CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vmulq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vmulq_f64
+  // CHECK-LABEL: test_vmulq_f64
   return vmulq_f64(v1, v2);
   // CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
@@ -337,207 +337,207 @@ poly8x16_t test_vmulq_p8(poly8x16_t v1,
 
 
 int8x8_t test_vmla_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) {
-  // CHECK: test_vmla_s8
+  // CHECK-LABEL: test_vmla_s8
   return vmla_s8(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vmla_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) {
-  // CHECK: test_vmla_s16
+  // CHECK-LABEL: test_vmla_s16
   return vmla_s16(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vmla_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) {
-  // CHECK: test_vmla_s32
+  // CHECK-LABEL: test_vmla_s32
   return vmla_s32(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vmla_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
-  // CHECK: test_vmla_f32
+  // CHECK-LABEL: test_vmla_f32
   return vmla_f32(v1, v2, v3);
   // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vmla_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) {
-  // CHECK: test_vmla_u8
+  // CHECK-LABEL: test_vmla_u8
   return vmla_u8(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vmla_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) {
-  // CHECK: test_vmla_u16
+  // CHECK-LABEL: test_vmla_u16
   return vmla_u16(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vmla_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) {
-  // CHECK: test_vmla_u32
+  // CHECK-LABEL: test_vmla_u32
   return vmla_u32(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vmlaq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) {
-  // CHECK: test_vmlaq_s8
+  // CHECK-LABEL: test_vmlaq_s8
   return vmlaq_s8(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vmlaq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) {
-  // CHECK: test_vmlaq_s16
+  // CHECK-LABEL: test_vmlaq_s16
   return vmlaq_s16(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vmlaq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) {
-  // CHECK: test_vmlaq_s32
+  // CHECK-LABEL: test_vmlaq_s32
   return vmlaq_s32(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 } 
 
 float32x4_t test_vmlaq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) {
-  // CHECK: test_vmlaq_f32
+  // CHECK-LABEL: test_vmlaq_f32
   return vmlaq_f32(v1, v2, v3);
   // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vmlaq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) {
-   // CHECK: test_vmlaq_u8
+   // CHECK-LABEL: test_vmlaq_u8
   return vmlaq_u8(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vmlaq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) {
-  // CHECK: test_vmlaq_u16
+  // CHECK-LABEL: test_vmlaq_u16
   return vmlaq_u16(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vmlaq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) {
-  // CHECK: test_vmlaq_u32
+  // CHECK-LABEL: test_vmlaq_u32
   return vmlaq_u32(v1, v2, v3);
   // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vmlaq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) {
-  // CHECK: test_vmlaq_f64
+  // CHECK-LABEL: test_vmlaq_f64
   return vmlaq_f64(v1, v2, v3);
   // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vmls_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) {
-  // CHECK: test_vmls_s8
+  // CHECK-LABEL: test_vmls_s8
   return vmls_s8(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vmls_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) {
-  // CHECK: test_vmls_s16
+  // CHECK-LABEL: test_vmls_s16
   return vmls_s16(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vmls_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) {
-  // CHECK: test_vmls_s32
+  // CHECK-LABEL: test_vmls_s32
   return vmls_s32(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vmls_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
-  // CHECK: test_vmls_f32
+  // CHECK-LABEL: test_vmls_f32
   return vmls_f32(v1, v2, v3);
   // CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vmls_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) {
-  // CHECK: test_vmls_u8
+  // CHECK-LABEL: test_vmls_u8
   return vmls_u8(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vmls_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) {
-  // CHECK: test_vmls_u16
+  // CHECK-LABEL: test_vmls_u16
   return vmls_u16(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vmls_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) {
-  // CHECK: test_vmls_u32
+  // CHECK-LABEL: test_vmls_u32
   return vmls_u32(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 int8x16_t test_vmlsq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) {
-  // CHECK: test_vmlsq_s8
+  // CHECK-LABEL: test_vmlsq_s8
   return vmlsq_s8(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vmlsq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) {
-  // CHECK: test_vmlsq_s16
+  // CHECK-LABEL: test_vmlsq_s16
   return vmlsq_s16(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vmlsq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) {
-  // CHECK: test_vmlsq_s32
+  // CHECK-LABEL: test_vmlsq_s32
   return vmlsq_s32(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x4_t test_vmlsq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) {
-  // CHECK: test_vmlsq_f32
+  // CHECK-LABEL: test_vmlsq_f32
   return vmlsq_f32(v1, v2, v3);
   // CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint8x16_t test_vmlsq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) {
-  // CHECK: test_vmlsq_u8
+  // CHECK-LABEL: test_vmlsq_u8
   return vmlsq_u8(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vmlsq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) {
-  // CHECK: test_vmlsq_u16
+  // CHECK-LABEL: test_vmlsq_u16
   return vmlsq_u16(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vmlsq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) {
-  // CHECK: test_vmlsq_u32
+  // CHECK-LABEL: test_vmlsq_u32
   return vmlsq_u32(v1, v2, v3);
   // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vmlsq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) {
-  // CHECK: test_vmlsq_f64
+  // CHECK-LABEL: test_vmlsq_f64
   return vmlsq_f64(v1, v2, v3);
   // CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 float32x2_t test_vfma_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
-  // CHECK: test_vfma_f32
+  // CHECK-LABEL: test_vfma_f32
   return vfma_f32(v1, v2, v3);
   // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x4_t test_vfmaq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) {
-  // CHECK: test_vfmaq_f32
+  // CHECK-LABEL: test_vfmaq_f32
   return vfmaq_f32(v1, v2, v3);
   // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vfmaq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) {
-  // CHECK: test_vfmaq_f64
+  // CHECK-LABEL: test_vfmaq_f64
   return vfmaq_f64(v1, v2, v3);
   // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 float32x2_t test_vfms_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
-  // CHECK: test_vfms_f32
+  // CHECK-LABEL: test_vfms_f32
   return vfms_f32(v1, v2, v3);
   // CHECK: fmls v0.2s, v1.2s, v2.2s
 }
 
 float32x4_t test_vfmsq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) {
-  // CHECK: test_vfmsq_f32
+  // CHECK-LABEL: test_vfmsq_f32
   return vfmsq_f32(v1, v2, v3);
   // CHECK: fmls v0.4s, v1.4s, v2.4s
 }
@@ -549,572 +549,572 @@ float64x2_t test_vfmsq_f64(float64x2_t v
 }
 
 float64x2_t test_vdivq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vdivq_f64
+  // CHECK-LABEL: test_vdivq_f64
   return vdivq_f64(v1, v2);
   // CHECK: fdiv {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 float32x4_t test_vdivq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vdivq_f32
+  // CHECK-LABEL: test_vdivq_f32
   return vdivq_f32(v1, v2);
   // CHECK: fdiv {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x2_t test_vdiv_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vdiv_f32
+  // CHECK-LABEL: test_vdiv_f32
   return vdiv_f32(v1, v2);
   // CHECK: fdiv {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x8_t test_vaba_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) {
-  // CHECK: test_vaba_s8
+  // CHECK-LABEL: test_vaba_s8
   return vaba_s8(v1, v2, v3);
   // CHECK: saba {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vaba_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) {
-  // CHECK: test_vaba_s16
+  // CHECK-LABEL: test_vaba_s16
   return vaba_s16(v1, v2, v3);
   // CHECK: saba {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vaba_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) {
-  // CHECK: test_vaba_s32
+  // CHECK-LABEL: test_vaba_s32
   return vaba_s32(v1, v2, v3);
   // CHECK: saba {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vaba_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) {
-  // CHECK: test_vaba_u8
+  // CHECK-LABEL: test_vaba_u8
   return vaba_u8(v1, v2, v3);
   // CHECK: uaba {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vaba_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) {
-  // CHECK: test_vaba_u16
+  // CHECK-LABEL: test_vaba_u16
   return vaba_u16(v1, v2, v3);
   // CHECK: uaba {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vaba_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) {
-  // CHECK: test_vaba_u32
+  // CHECK-LABEL: test_vaba_u32
   return vaba_u32(v1, v2, v3);
   // CHECK: uaba {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vabaq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) {
-  // CHECK: test_vabaq_s8
+  // CHECK-LABEL: test_vabaq_s8
   return vabaq_s8(v1, v2, v3);
   // CHECK: saba {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vabaq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) {
-  // CHECK: test_vabaq_s16
+  // CHECK-LABEL: test_vabaq_s16
   return vabaq_s16(v1, v2, v3);
   // CHECK: saba {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vabaq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) {
-  // CHECK: test_vabaq_s32
+  // CHECK-LABEL: test_vabaq_s32
   return vabaq_s32(v1, v2, v3);
   // CHECK: saba {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vabaq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) {
-  // CHECK: test_vabaq_u8
+  // CHECK-LABEL: test_vabaq_u8
   return vabaq_u8(v1, v2, v3);
   // CHECK: uaba {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vabaq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) {
-  // CHECK: test_vabaq_u16
+  // CHECK-LABEL: test_vabaq_u16
   return vabaq_u16(v1, v2, v3);
   // CHECK: uaba {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vabaq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) {
-  // CHECK: test_vabaq_u32
+  // CHECK-LABEL: test_vabaq_u32
   return vabaq_u32(v1, v2, v3);
   // CHECK: uaba {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int8x8_t test_vabd_s8(int8x8_t v1, int8x8_t v2) {
-  // CHECK: test_vabd_s8
+  // CHECK-LABEL: test_vabd_s8
   return vabd_s8(v1, v2);
   // CHECK: sabd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vabd_s16(int16x4_t v1, int16x4_t v2) {
-  // CHECK: test_vabd_s16
+  // CHECK-LABEL: test_vabd_s16
   return vabd_s16(v1, v2);
   // CHECK: sabd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vabd_s32(int32x2_t v1, int32x2_t v2) {
-  // CHECK: test_vabd_s32
+  // CHECK-LABEL: test_vabd_s32
   return vabd_s32(v1, v2);
   // CHECK: sabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vabd_u8(uint8x8_t v1, uint8x8_t v2) {
-  // CHECK: test_vabd_u8
+  // CHECK-LABEL: test_vabd_u8
   return vabd_u8(v1, v2);
   // CHECK: uabd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vabd_u16(uint16x4_t v1, uint16x4_t v2) {
-  // CHECK: test_vabd_u16
+  // CHECK-LABEL: test_vabd_u16
   return vabd_u16(v1, v2);
   // CHECK: uabd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vabd_u32(uint32x2_t v1, uint32x2_t v2) {
-  // CHECK: test_vabd_u32
+  // CHECK-LABEL: test_vabd_u32
   return vabd_u32(v1, v2);
   // CHECK: uabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vabd_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vabd_f32
+  // CHECK-LABEL: test_vabd_f32
   return vabd_f32(v1, v2);
   // CHECK: fabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vabdq_s8(int8x16_t v1, int8x16_t v2) {
-  // CHECK: test_vabdq_s8
+  // CHECK-LABEL: test_vabdq_s8
   return vabdq_s8(v1, v2);
   // CHECK: sabd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vabdq_s16(int16x8_t v1, int16x8_t v2) {
-  // CHECK: test_vabdq_s16
+  // CHECK-LABEL: test_vabdq_s16
   return vabdq_s16(v1, v2);
   // CHECK: sabd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vabdq_s32(int32x4_t v1, int32x4_t v2) {
-  // CHECK: test_vabdq_s32
+  // CHECK-LABEL: test_vabdq_s32
   return vabdq_s32(v1, v2);
   // CHECK: sabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vabdq_u8(uint8x16_t v1, uint8x16_t v2) {
-  // CHECK: test_vabdq_u8
+  // CHECK-LABEL: test_vabdq_u8
   return vabdq_u8(v1, v2);
   // CHECK: uabd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vabdq_u16(uint16x8_t v1, uint16x8_t v2) {
-  // CHECK: test_vabdq_u16
+  // CHECK-LABEL: test_vabdq_u16
   return vabdq_u16(v1, v2);
   // CHECK: uabd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vabdq_u32(uint32x4_t v1, uint32x4_t v2) {
-  // CHECK: test_vabdq_u32
+  // CHECK-LABEL: test_vabdq_u32
   return vabdq_u32(v1, v2);
   // CHECK: uabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x4_t test_vabdq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vabdq_f32
+  // CHECK-LABEL: test_vabdq_f32
   return vabdq_f32(v1, v2);
   // CHECK: fabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vabdq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vabdq_f64
+  // CHECK-LABEL: test_vabdq_f64
   return vabdq_f64(v1, v2);
   // CHECK: fabd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 
 int8x8_t test_vbsl_s8(uint8x8_t v1, int8x8_t v2, int8x8_t v3) {
-  // CHECK: test_vbsl_s8
+  // CHECK-LABEL: test_vbsl_s8
   return vbsl_s8(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vbsl_s16(uint16x4_t v1, int16x4_t v2, int16x4_t v3) {
-  // CHECK: test_vbsl_s16
+  // CHECK-LABEL: test_vbsl_s16
   return vbsl_s16(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int32x2_t test_vbsl_s32(uint32x2_t v1, int32x2_t v2, int32x2_t v3) {
-  // CHECK: test_vbsl_s32
+  // CHECK-LABEL: test_vbsl_s32
   return vbsl_s32(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint64x1_t test_vbsl_s64(uint64x1_t v1, uint64x1_t v2, uint64x1_t v3) {
-  // CHECK: test_vbsl_s64
+  // CHECK-LABEL: test_vbsl_s64
   return vbsl_s64(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vbsl_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) {
-  // CHECK: test_vbsl_u8
+  // CHECK-LABEL: test_vbsl_u8
   return vbsl_u8(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vbsl_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) {
-  // CHECK: test_vbsl_u16
+  // CHECK-LABEL: test_vbsl_u16
   return vbsl_u16(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint32x2_t test_vbsl_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) {
-  // CHECK: test_vbsl_u32
+  // CHECK-LABEL: test_vbsl_u32
   return vbsl_u32(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint64x1_t test_vbsl_u64(uint64x1_t v1, uint64x1_t v2, uint64x1_t v3) {
-  // CHECK: test_vbsl_u64
+  // CHECK-LABEL: test_vbsl_u64
   return vbsl_u64(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 float32x2_t test_vbsl_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) {
-  // CHECK: test_vbsl_f32
+  // CHECK-LABEL: test_vbsl_f32
   return vbsl_f32(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 float64x1_t test_vbsl_f64(uint64x1_t v1, float64x1_t v2, float64x1_t v3) {
-  // CHECK: test_vbsl_f64
+  // CHECK-LABEL: test_vbsl_f64
   return vbsl_f64(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vbsl_p8(uint8x8_t v1, poly8x8_t v2, poly8x8_t v3) {
-  // CHECK: test_vbsl_p8
+  // CHECK-LABEL: test_vbsl_p8
   return vbsl_p8(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly16x4_t test_vbsl_p16(uint16x4_t v1, poly16x4_t v2, poly16x4_t v3) {
-  // CHECK: test_vbsl_p16
+  // CHECK-LABEL: test_vbsl_p16
   return vbsl_p16(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vbslq_s8(uint8x16_t v1, int8x16_t v2, int8x16_t v3) {
-  // CHECK: test_vbslq_s8
+  // CHECK-LABEL: test_vbslq_s8
   return vbslq_s8(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vbslq_s16(uint16x8_t v1, int16x8_t v2, int16x8_t v3) {
-  // CHECK: test_vbslq_s16
+  // CHECK-LABEL: test_vbslq_s16
   return vbslq_s16(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int32x4_t test_vbslq_s32(uint32x4_t v1, int32x4_t v2, int32x4_t v3) {
-  // CHECK: test_vbslq_s32
+  // CHECK-LABEL: test_vbslq_s32
   return vbslq_s32(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int64x2_t test_vbslq_s64(uint64x2_t v1, int64x2_t v2, int64x2_t v3) {
-  // CHECK: test_vbslq_s64
+  // CHECK-LABEL: test_vbslq_s64
   return vbslq_s64(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint8x16_t test_vbslq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) {
-  // CHECK: test_vbslq_u8
+  // CHECK-LABEL: test_vbslq_u8
   return vbslq_u8(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vbslq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) {
-  // CHECK: test_vbslq_u16
+  // CHECK-LABEL: test_vbslq_u16
   return vbslq_u16(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int32x4_t test_vbslq_u32(uint32x4_t v1, int32x4_t v2, int32x4_t v3) {
-  // CHECK: test_vbslq_u32
+  // CHECK-LABEL: test_vbslq_u32
   return vbslq_s32(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint64x2_t test_vbslq_u64(uint64x2_t v1, uint64x2_t v2, uint64x2_t v3) {
-  // CHECK: test_vbslq_u64
+  // CHECK-LABEL: test_vbslq_u64
   return vbslq_u64(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 float32x4_t test_vbslq_f32(uint32x4_t v1, float32x4_t v2, float32x4_t v3) {
-  // CHECK: test_vbslq_f32
+  // CHECK-LABEL: test_vbslq_f32
   return vbslq_f32(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly8x16_t test_vbslq_p8(uint8x16_t v1, poly8x16_t v2, poly8x16_t v3) {
-  // CHECK: test_vbslq_p8
+  // CHECK-LABEL: test_vbslq_p8
   return vbslq_p8(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly16x8_t test_vbslq_p16(uint16x8_t v1, poly16x8_t v2, poly16x8_t v3) {
-  // CHECK: test_vbslq_p16
+  // CHECK-LABEL: test_vbslq_p16
   return vbslq_p16(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 float64x2_t test_vbslq_f64(uint64x2_t v1, float64x2_t v2, float64x2_t v3) {
-  // CHECK: test_vbslq_f64
+  // CHECK-LABEL: test_vbslq_f64
   return vbslq_f64(v1, v2, v3);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 float32x2_t test_vrecps_f32(float32x2_t v1, float32x2_t v2) {
-   // CHECK: test_vrecps_f32
+   // CHECK-LABEL: test_vrecps_f32
    return vrecps_f32(v1, v2);
    // CHECK: frecps {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x4_t test_vrecpsq_f32(float32x4_t v1, float32x4_t v2) {
-   // CHECK: test_vrecpsq_f32
+   // CHECK-LABEL: test_vrecpsq_f32
    return vrecpsq_f32(v1, v2);
    // CHECK: frecps {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vrecpsq_f64(float64x2_t v1, float64x2_t v2) {
-   // CHECK: test_vrecpsq_f64
+   // CHECK-LABEL: test_vrecpsq_f64
   return vrecpsq_f64(v1, v2);
   // CHECK: frecps {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 float32x2_t test_vrsqrts_f32(float32x2_t v1, float32x2_t v2) {
-   // CHECK: test_vrsqrts_f32
+   // CHECK-LABEL: test_vrsqrts_f32
   return vrsqrts_f32(v1, v2);
   // CHECK: frsqrts {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x4_t test_vrsqrtsq_f32(float32x4_t v1, float32x4_t v2) {
-   // CHECK: test_vrsqrtsq_f32
+   // CHECK-LABEL: test_vrsqrtsq_f32
   return vrsqrtsq_f32(v1, v2);
   // CHECK: frsqrts {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vrsqrtsq_f64(float64x2_t v1, float64x2_t v2) {
-   // CHECK: test_vrsqrtsq_f64
+   // CHECK-LABEL: test_vrsqrtsq_f64
   return vrsqrtsq_f64(v1, v2);
   // CHECK: frsqrts {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint32x2_t test_vcage_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vcage_f32
+  // CHECK-LABEL: test_vcage_f32
   return vcage_f32(v1, v2);
   // CHECK: facge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vcage_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vcage_f64
+  // CHECK-LABEL: test_vcage_f64
   return vcage_f64(a, b);
   // CHECK: facge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x4_t test_vcageq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vcageq_f32
+  // CHECK-LABEL: test_vcageq_f32
   return vcageq_f32(v1, v2);
   // CHECK: facge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vcageq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vcageq_f64
+  // CHECK-LABEL: test_vcageq_f64
   return vcageq_f64(v1, v2);
   // CHECK: facge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint32x2_t test_vcagt_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vcagt_f32
+  // CHECK-LABEL: test_vcagt_f32
   return vcagt_f32(v1, v2);
   // CHECK: facgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vcagt_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vcagt_f64
+  // CHECK-LABEL: test_vcagt_f64
   return vcagt_f64(a, b);
   // CHECK: facgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x4_t test_vcagtq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vcagtq_f32
+  // CHECK-LABEL: test_vcagtq_f32
   return vcagtq_f32(v1, v2);
   // CHECK: facgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vcagtq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vcagtq_f64
+  // CHECK-LABEL: test_vcagtq_f64
   return vcagtq_f64(v1, v2);
   // CHECK: facgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint32x2_t test_vcale_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vcale_f32
+  // CHECK-LABEL: test_vcale_f32
   return vcale_f32(v1, v2);
   // Using registers other than v0, v1 are possible, but would be odd.
   // CHECK: facge {{v[0-9]+}}.2s, v1.2s, v0.2s
 }
 
 uint64x1_t test_vcale_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vcale_f64
+  // CHECK-LABEL: test_vcale_f64
   return vcale_f64(a, b);
   // CHECK: facge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x4_t test_vcaleq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vcaleq_f32
+  // CHECK-LABEL: test_vcaleq_f32
   return vcaleq_f32(v1, v2);
   // Using registers other than v0, v1 are possible, but would be odd.
   // CHECK: facge {{v[0-9]+}}.4s, v1.4s, v0.4s
 }
 
 uint64x2_t test_vcaleq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vcaleq_f64
+  // CHECK-LABEL: test_vcaleq_f64
   return vcaleq_f64(v1, v2);
   // Using registers other than v0, v1 are possible, but would be odd.
   // CHECK: facge {{v[0-9]+}}.2d, v1.2d, v0.2d
 }
 
 uint32x2_t test_vcalt_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vcalt_f32
+  // CHECK-LABEL: test_vcalt_f32
   return vcalt_f32(v1, v2);
   // Using registers other than v0, v1 are possible, but would be odd.
   // CHECK: facgt {{v[0-9]+}}.2s, v1.2s, v0.2s
 }
 
 uint64x1_t test_vcalt_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vcalt_f64
+  // CHECK-LABEL: test_vcalt_f64
   return vcalt_f64(a, b);
   // CHECK: facgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x4_t test_vcaltq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vcaltq_f32
+  // CHECK-LABEL: test_vcaltq_f32
   return vcaltq_f32(v1, v2);
   // Using registers other than v0, v1 are possible, but would be odd.
   // CHECK: facgt {{v[0-9]+}}.4s, v1.4s, v0.4s
 }
 
 uint64x2_t test_vcaltq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vcaltq_f64
+  // CHECK-LABEL: test_vcaltq_f64
   return vcaltq_f64(v1, v2);
   // Using registers other than v0, v1 are possible, but would be odd.
   // CHECK: facgt {{v[0-9]+}}.2d, v1.2d, v0.2d
 }
 
 uint8x8_t test_vtst_s8(int8x8_t v1, int8x8_t v2) {
-   // CHECK: test_vtst_s8
+   // CHECK-LABEL: test_vtst_s8
   return vtst_s8(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vtst_s16(int16x4_t v1, int16x4_t v2) {
-   // CHECK: test_vtst_s16
+   // CHECK-LABEL: test_vtst_s16
   return vtst_s16(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vtst_s32(int32x2_t v1, int32x2_t v2) {
-   // CHECK: test_vtst_s32
+   // CHECK-LABEL: test_vtst_s32
   return vtst_s32(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vtst_u8(uint8x8_t v1, uint8x8_t v2) {
-   // CHECK: test_vtst_u8
+   // CHECK-LABEL: test_vtst_u8
   return vtst_u8(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vtst_u16(uint16x4_t v1, uint16x4_t v2) {
-   // CHECK: test_vtst_u16
+   // CHECK-LABEL: test_vtst_u16
   return vtst_u16(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vtst_u32(uint32x2_t v1, uint32x2_t v2) {
-   // CHECK: test_vtst_u32
+   // CHECK-LABEL: test_vtst_u32
   return vtst_u32(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x16_t test_vtstq_s8(int8x16_t v1, int8x16_t v2) {
-   // CHECK: test_vtstq_s8
+   // CHECK-LABEL: test_vtstq_s8
   return vtstq_s8(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vtstq_s16(int16x8_t v1, int16x8_t v2) {
-   // CHECK: test_vtstq_s16
+   // CHECK-LABEL: test_vtstq_s16
   return vtstq_s16(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vtstq_s32(int32x4_t v1, int32x4_t v2) {
-   // CHECK: test_vtstq_s32
+   // CHECK-LABEL: test_vtstq_s32
   return vtstq_s32(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vtstq_u8(uint8x16_t v1, uint8x16_t v2) {
-   // CHECK: test_vtstq_u8
+   // CHECK-LABEL: test_vtstq_u8
   return vtstq_u8(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vtstq_u16(uint16x8_t v1, uint16x8_t v2) {
-   // CHECK: test_vtstq_u16
+   // CHECK-LABEL: test_vtstq_u16
   return vtstq_u16(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vtstq_u32(uint32x4_t v1, uint32x4_t v2) {
-   // CHECK: test_vtstq_u32
+   // CHECK-LABEL: test_vtstq_u32
   return vtstq_u32(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vtstq_s64(int64x2_t v1, int64x2_t v2) {
-   // CHECK: test_vtstq_s64
+   // CHECK-LABEL: test_vtstq_s64
   return vtstq_s64(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint64x2_t test_vtstq_u64(uint64x2_t v1, uint64x2_t v2) {
-   // CHECK: test_vtstq_u64
+   // CHECK-LABEL: test_vtstq_u64
   return vtstq_u64(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x8_t test_vtst_p8(poly8x8_t v1, poly8x8_t v2) {
-   // CHECK: test_vtst_p8
+   // CHECK-LABEL: test_vtst_p8
   return vtst_p8(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vtst_p16(poly16x4_t v1, poly16x4_t v2) {
-   // CHECK: test_vtst_p16
+   // CHECK-LABEL: test_vtst_p16
   return vtst_p16(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint8x16_t test_vtstq_p8(poly8x16_t v1, poly8x16_t v2) {
-   // CHECK: test_vtstq_p8
+   // CHECK-LABEL: test_vtstq_p8
   return vtstq_p8(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vtstq_p16(poly16x8_t v1, poly16x8_t v2) {
-   // CHECK: test_vtstq_p16
+   // CHECK-LABEL: test_vtstq_p16
   return vtstq_p16(v1, v2);
   // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
@@ -1132,253 +1132,253 @@ uint64x1_t test_vtst_u64(uint64x1_t a, u
 }
 
 uint8x8_t test_vceq_s8(int8x8_t v1, int8x8_t v2) {
-  // CHECK: test_vceq_s8
+  // CHECK-LABEL: test_vceq_s8
   return vceq_s8(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vceq_s16(int16x4_t v1, int16x4_t v2) {
-  // CHECK: test_vceq_s16
+  // CHECK-LABEL: test_vceq_s16
   return vceq_s16(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vceq_s32(int32x2_t v1, int32x2_t v2) {
-  // CHECK: test_vceq_s32
+  // CHECK-LABEL: test_vceq_s32
   return vceq_s32(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vceq_s64(int64x1_t a, int64x1_t b) {
-  // CHECK: test_vceq_s64
+  // CHECK-LABEL: test_vceq_s64
   return vceq_s64(a, b);
   // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64x1_t test_vceq_u64(uint64x1_t a, uint64x1_t b) {
-  // CHECK: test_vceq_u64
+  // CHECK-LABEL: test_vceq_u64
   return vceq_u64(a, b);
   // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x2_t test_vceq_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vceq_f32
+  // CHECK-LABEL: test_vceq_f32
   return vceq_f32(v1, v2);
   // CHECK: fcmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vceq_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vceq_f64
+  // CHECK-LABEL: test_vceq_f64
   return vceq_f64(a, b);
   // CHECK: fcmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vceq_u8(uint8x8_t v1, uint8x8_t v2) {
-  // CHECK: test_vceq_u8
+  // CHECK-LABEL: test_vceq_u8
   return vceq_u8(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vceq_u16(uint16x4_t v1, uint16x4_t v2) {
-  // CHECK: test_vceq_u16
+  // CHECK-LABEL: test_vceq_u16
   return vceq_u16(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vceq_u32(uint32x2_t v1, uint32x2_t v2) {
-  // CHECK: test_vceq_u32
+  // CHECK-LABEL: test_vceq_u32
   return vceq_u32(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vceq_p8(poly8x8_t v1, poly8x8_t v2) {
-  // CHECK: test_vceq_p8
+  // CHECK-LABEL: test_vceq_p8
   return vceq_p8(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vceqq_s8(int8x16_t v1, int8x16_t v2) {
-  // CHECK: test_vceqq_s8
+  // CHECK-LABEL: test_vceqq_s8
   return vceqq_s8(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vceqq_s16(int16x8_t v1, int16x8_t v2) {
-  // CHECK: test_vceqq_s16
+  // CHECK-LABEL: test_vceqq_s16
   return vceqq_s16(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vceqq_s32(int32x4_t v1, int32x4_t v2) {
-  // CHECK: test_vceqq_s32
+  // CHECK-LABEL: test_vceqq_s32
   return vceqq_s32(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x4_t test_vceqq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vceqq_f32
+  // CHECK-LABEL: test_vceqq_f32
   return vceqq_f32(v1, v2);
   // CHECK: fcmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vceqq_u8(uint8x16_t v1, uint8x16_t v2) {
-  // CHECK: test_vceqq_u8
+  // CHECK-LABEL: test_vceqq_u8
   return vceqq_u8(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vceqq_u16(uint16x8_t v1, uint16x8_t v2) {
-  // CHECK: test_vceqq_u16
+  // CHECK-LABEL: test_vceqq_u16
   return vceqq_u16(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vceqq_u32(uint32x4_t v1, uint32x4_t v2) {
-  // CHECK: test_vceqq_u32
+  // CHECK-LABEL: test_vceqq_u32
   return vceqq_u32(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vceqq_p8(poly8x16_t v1, poly8x16_t v2) {
-  // CHECK: test_vceqq_p8
+  // CHECK-LABEL: test_vceqq_p8
   return vceqq_p8(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 
 uint64x2_t test_vceqq_s64(int64x2_t v1, int64x2_t v2) {
-  // CHECK: test_vceqq_s64
+  // CHECK-LABEL: test_vceqq_s64
   return vceqq_s64(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint64x2_t test_vceqq_u64(uint64x2_t v1, uint64x2_t v2) {
-  // CHECK: test_vceqq_u64
+  // CHECK-LABEL: test_vceqq_u64
   return vceqq_u64(v1, v2);
   // CHECK: cmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint64x2_t test_vceqq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vceqq_f64
+  // CHECK-LABEL: test_vceqq_f64
   return vceqq_f64(v1, v2);
   // CHECK: fcmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 uint8x8_t test_vcge_s8(int8x8_t v1, int8x8_t v2) {
-// CHECK: test_vcge_s8
+// CHECK-LABEL: test_vcge_s8
   return vcge_s8(v1, v2);
 // CHECK: cmge {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vcge_s16(int16x4_t v1, int16x4_t v2) {
-// CHECK: test_vcge_s16
+// CHECK-LABEL: test_vcge_s16
   return vcge_s16(v1, v2);
 // CHECK: cmge {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vcge_s32(int32x2_t v1, int32x2_t v2) {
-// CHECK: test_vcge_s32
+// CHECK-LABEL: test_vcge_s32
   return vcge_s32(v1, v2);
 // CHECK: cmge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vcge_s64(int64x1_t a, int64x1_t b) {
-  // CHECK: test_vcge_s64
+  // CHECK-LABEL: test_vcge_s64
   return vcge_s64(a, b);
   // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64x1_t test_vcge_u64(uint64x1_t a, uint64x1_t b) {
-  // CHECK: test_vcge_u64
+  // CHECK-LABEL: test_vcge_u64
   return vcge_u64(a, b);
   // CHECK: cmhs {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x2_t test_vcge_f32(float32x2_t v1, float32x2_t v2) {
-// CHECK: test_vcge_f32
+// CHECK-LABEL: test_vcge_f32
   return vcge_f32(v1, v2);
 // CHECK: fcmge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vcge_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vcge_f64
+  // CHECK-LABEL: test_vcge_f64
   return vcge_f64(a, b);
   // CHECK: fcmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vcge_u8(uint8x8_t v1, uint8x8_t v2) {
-// CHECK: test_vcge_u8
+// CHECK-LABEL: test_vcge_u8
   return vcge_u8(v1, v2);
 // CHECK: cmhs {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vcge_u16(uint16x4_t v1, uint16x4_t v2) {
-// CHECK: test_vcge_u16
+// CHECK-LABEL: test_vcge_u16
   return vcge_u16(v1, v2);
 // CHECK: cmhs {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vcge_u32(uint32x2_t v1, uint32x2_t v2) {
-// CHECK: test_vcge_u32
+// CHECK-LABEL: test_vcge_u32
   return vcge_u32(v1, v2);
 // CHECK: cmhs {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x16_t test_vcgeq_s8(int8x16_t v1, int8x16_t v2) {
-// CHECK: test_vcgeq_s8
+// CHECK-LABEL: test_vcgeq_s8
   return vcgeq_s8(v1, v2);
 // CHECK: cmge {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vcgeq_s16(int16x8_t v1, int16x8_t v2) {
-// CHECK: test_vcgeq_s16
+// CHECK-LABEL: test_vcgeq_s16
   return vcgeq_s16(v1, v2);
 // CHECK: cmge {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vcgeq_s32(int32x4_t v1, int32x4_t v2) {
-// CHECK: test_vcgeq_s32
+// CHECK-LABEL: test_vcgeq_s32
   return vcgeq_s32(v1, v2);
 // CHECK: cmge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x4_t test_vcgeq_f32(float32x4_t v1, float32x4_t v2) {
-// CHECK: test_vcgeq_f32
+// CHECK-LABEL: test_vcgeq_f32
   return vcgeq_f32(v1, v2);
 // CHECK: fcmge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vcgeq_u8(uint8x16_t v1, uint8x16_t v2) {
-// CHECK: test_vcgeq_u8
+// CHECK-LABEL: test_vcgeq_u8
   return vcgeq_u8(v1, v2);
 // CHECK: cmhs {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vcgeq_u16(uint16x8_t v1, uint16x8_t v2) {
-// CHECK: test_vcgeq_u16
+// CHECK-LABEL: test_vcgeq_u16
   return vcgeq_u16(v1, v2);
 // CHECK: cmhs {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vcgeq_u32(uint32x4_t v1, uint32x4_t v2) {
-// CHECK: test_vcgeq_u32
+// CHECK-LABEL: test_vcgeq_u32
   return vcgeq_u32(v1, v2);
 // CHECK: cmhs {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vcgeq_s64(int64x2_t v1, int64x2_t v2) {
-// CHECK: test_vcgeq_s64
+// CHECK-LABEL: test_vcgeq_s64
   return vcgeq_s64(v1, v2);
 // CHECK: cmge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint64x2_t test_vcgeq_u64(uint64x2_t v1, uint64x2_t v2) {
-// CHECK: test_vcgeq_u64
+// CHECK-LABEL: test_vcgeq_u64
   return vcgeq_u64(v1, v2);
 // CHECK: cmhs {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint64x2_t test_vcgeq_f64(float64x2_t v1, float64x2_t v2) {
-// CHECK: test_vcgeq_f64
+// CHECK-LABEL: test_vcgeq_f64
   return vcgeq_f64(v1, v2);
 // CHECK: fcmge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
@@ -1387,242 +1387,242 @@ uint64x2_t test_vcgeq_f64(float64x2_t v1
 // LE condition predicate implemented as GE, so check reversed operands.
 // Using registers other than v0, v1 are possible, but would be odd.
 uint8x8_t test_vcle_s8(int8x8_t v1, int8x8_t v2) {
-  // CHECK: test_vcle_s8
+  // CHECK-LABEL: test_vcle_s8
   return vcle_s8(v1, v2);
   // CHECK: cmge {{v[0-9]+}}.8b, v1.8b, v0.8b
 }
 
 uint16x4_t test_vcle_s16(int16x4_t v1, int16x4_t v2) {
-  // CHECK: test_vcle_s16
+  // CHECK-LABEL: test_vcle_s16
   return vcle_s16(v1, v2);
   // CHECK: cmge {{v[0-9]+}}.4h, v1.4h, v0.4h
 }
 
 uint32x2_t test_vcle_s32(int32x2_t v1, int32x2_t v2) {
-  // CHECK: test_vcle_s32
+  // CHECK-LABEL: test_vcle_s32
   return vcle_s32(v1, v2);
   // CHECK: cmge {{v[0-9]+}}.2s, v1.2s, v0.2s
 }
 
 uint64x1_t test_vcle_s64(int64x1_t a, int64x1_t b) {
-  // CHECK: test_vcle_s64
+  // CHECK-LABEL: test_vcle_s64
   return vcle_s64(a, b);
   // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64x1_t test_vcle_u64(uint64x1_t a, uint64x1_t b) {
-  // CHECK: test_vcle_u64
+  // CHECK-LABEL: test_vcle_u64
   return vcle_u64(a, b);
   // CHECK: cmhs {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x2_t test_vcle_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vcle_f32
+  // CHECK-LABEL: test_vcle_f32
   return vcle_f32(v1, v2);
   // CHECK: fcmge {{v[0-9]+}}.2s, v1.2s, v0.2s
 }
 
 uint64x1_t test_vcle_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vcle_f64
+  // CHECK-LABEL: test_vcle_f64
   return vcle_f64(a, b);
   // CHECK: fcmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vcle_u8(uint8x8_t v1, uint8x8_t v2) {
-  // CHECK: test_vcle_u8
+  // CHECK-LABEL: test_vcle_u8
   return vcle_u8(v1, v2);
   // CHECK: cmhs {{v[0-9]+}}.8b, v1.8b, v0.8b
 }
 
 uint16x4_t test_vcle_u16(uint16x4_t v1, uint16x4_t v2) {
-  // CHECK: test_vcle_u16
+  // CHECK-LABEL: test_vcle_u16
   return vcle_u16(v1, v2);
   // CHECK: cmhs {{v[0-9]+}}.4h, v1.4h, v0.4h
 }
 
 uint32x2_t test_vcle_u32(uint32x2_t v1, uint32x2_t v2) {
-  // CHECK: test_vcle_u32
+  // CHECK-LABEL: test_vcle_u32
   return vcle_u32(v1, v2);
   // CHECK: cmhs {{v[0-9]+}}.2s, v1.2s, v0.2s
 }
 
 uint8x16_t test_vcleq_s8(int8x16_t v1, int8x16_t v2) {
-  // CHECK: test_vcleq_s8
+  // CHECK-LABEL: test_vcleq_s8
   return vcleq_s8(v1, v2);
   // CHECK: cmge {{v[0-9]+}}.16b, v1.16b, v0.16b
 }
 
 uint16x8_t test_vcleq_s16(int16x8_t v1, int16x8_t v2) {
-  // CHECK: test_vcleq_s16
+  // CHECK-LABEL: test_vcleq_s16
   return vcleq_s16(v1, v2);
   // CHECK: cmge {{v[0-9]+}}.8h, v1.8h, v0.8h
 }
 
 uint32x4_t test_vcleq_s32(int32x4_t v1, int32x4_t v2) {
-  // CHECK: test_vcleq_s32
+  // CHECK-LABEL: test_vcleq_s32
   return vcleq_s32(v1, v2);
   // CHECK: cmge {{v[0-9]+}}.4s, v1.4s, v0.4s
 }
 
 uint32x4_t test_vcleq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vcleq_f32
+  // CHECK-LABEL: test_vcleq_f32
   return vcleq_f32(v1, v2);
   // CHECK: fcmge {{v[0-9]+}}.4s, v1.4s, v0.4s
 }
 
 uint8x16_t test_vcleq_u8(uint8x16_t v1, uint8x16_t v2) {
-  // CHECK: test_vcleq_u8
+  // CHECK-LABEL: test_vcleq_u8
   return vcleq_u8(v1, v2);
   // CHECK: cmhs {{v[0-9]+}}.16b, v1.16b, v0.16b
 }
 
 uint16x8_t test_vcleq_u16(uint16x8_t v1, uint16x8_t v2) {
-  // CHECK: test_vcleq_u16
+  // CHECK-LABEL: test_vcleq_u16
   return vcleq_u16(v1, v2);
   // CHECK: cmhs {{v[0-9]+}}.8h, v1.8h, v0.8h
 }
 
 uint32x4_t test_vcleq_u32(uint32x4_t v1, uint32x4_t v2) {
-  // CHECK: test_vcleq_u32
+  // CHECK-LABEL: test_vcleq_u32
   return vcleq_u32(v1, v2);
   // CHECK: cmhs {{v[0-9]+}}.4s, v1.4s, v0.4s
 }
 
 uint64x2_t test_vcleq_s64(int64x2_t v1, int64x2_t v2) {
-  // CHECK: test_vcleq_s64
+  // CHECK-LABEL: test_vcleq_s64
   return vcleq_s64(v1, v2);
   // CHECK: cmge {{v[0-9]+}}.2d, v1.2d, v0.2d
 }
 
 uint64x2_t test_vcleq_u64(uint64x2_t v1, uint64x2_t v2) {
-  // CHECK: test_vcleq_u64
+  // CHECK-LABEL: test_vcleq_u64
   return vcleq_u64(v1, v2);
   // CHECK: cmhs {{v[0-9]+}}.2d, v1.2d, v0.2d
 }
 
 uint64x2_t test_vcleq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vcleq_f64
+  // CHECK-LABEL: test_vcleq_f64
   return vcleq_f64(v1, v2);
   // CHECK: fcmge {{v[0-9]+}}.2d, v1.2d, v0.2d
 }
 
 
 uint8x8_t test_vcgt_s8(int8x8_t v1, int8x8_t v2) {
-  // CHECK: test_vcgt_s8
+  // CHECK-LABEL: test_vcgt_s8
   return vcgt_s8(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vcgt_s16(int16x4_t v1, int16x4_t v2) {
-  // CHECK: test_vcgt_s16
+  // CHECK-LABEL: test_vcgt_s16
   return vcgt_s16(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vcgt_s32(int32x2_t v1, int32x2_t v2) {
-  // CHECK: test_vcgt_s32
+  // CHECK-LABEL: test_vcgt_s32
   return vcgt_s32(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vcgt_s64(int64x1_t a, int64x1_t b) {
-  // CHECK: test_vcgt_s64
+  // CHECK-LABEL: test_vcgt_s64
   return vcgt_s64(a, b);
   // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64x1_t test_vcgt_u64(uint64x1_t a, uint64x1_t b) {
-  // CHECK: test_vcgt_u64
+  // CHECK-LABEL: test_vcgt_u64
   return vcgt_u64(a, b);
   // CHECK: cmhi {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x2_t test_vcgt_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vcgt_f32
+  // CHECK-LABEL: test_vcgt_f32
   return vcgt_f32(v1, v2);
   // CHECK: fcmgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vcgt_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vcgt_f64
+  // CHECK-LABEL: test_vcgt_f64
   return vcgt_f64(a, b);
   // CHECK: fcmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vcgt_u8(uint8x8_t v1, uint8x8_t v2) {
-  // CHECK: test_vcgt_u8
+  // CHECK-LABEL: test_vcgt_u8
   return vcgt_u8(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vcgt_u16(uint16x4_t v1, uint16x4_t v2) {
-  // CHECK: test_vcgt_u16
+  // CHECK-LABEL: test_vcgt_u16
   return vcgt_u16(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vcgt_u32(uint32x2_t v1, uint32x2_t v2) {
-  // CHECK: test_vcgt_u32
+  // CHECK-LABEL: test_vcgt_u32
   return vcgt_u32(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x16_t test_vcgtq_s8(int8x16_t v1, int8x16_t v2) {
-  // CHECK: test_vcgtq_s8
+  // CHECK-LABEL: test_vcgtq_s8
   return vcgtq_s8(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vcgtq_s16(int16x8_t v1, int16x8_t v2) {
-  // CHECK: test_vcgtq_s16
+  // CHECK-LABEL: test_vcgtq_s16
   return vcgtq_s16(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vcgtq_s32(int32x4_t v1, int32x4_t v2) {
-  // CHECK: test_vcgtq_s32
+  // CHECK-LABEL: test_vcgtq_s32
   return vcgtq_s32(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x4_t test_vcgtq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vcgtq_f32
+  // CHECK-LABEL: test_vcgtq_f32
   return vcgtq_f32(v1, v2);
   // CHECK: fcmgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vcgtq_u8(uint8x16_t v1, uint8x16_t v2) {
-  // CHECK: test_vcgtq_u8
+  // CHECK-LABEL: test_vcgtq_u8
   return vcgtq_u8(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vcgtq_u16(uint16x8_t v1, uint16x8_t v2) {
-  // CHECK: test_vcgtq_u16
+  // CHECK-LABEL: test_vcgtq_u16
   return vcgtq_u16(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vcgtq_u32(uint32x4_t v1, uint32x4_t v2) {
-  // CHECK: test_vcgtq_u32
+  // CHECK-LABEL: test_vcgtq_u32
   return vcgtq_u32(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vcgtq_s64(int64x2_t v1, int64x2_t v2) {
-  // CHECK: test_vcgtq_s64
+  // CHECK-LABEL: test_vcgtq_s64
   return vcgtq_s64(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint64x2_t test_vcgtq_u64(uint64x2_t v1, uint64x2_t v2) {
-  // CHECK: test_vcgtq_u64
+  // CHECK-LABEL: test_vcgtq_u64
   return vcgtq_u64(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint64x2_t test_vcgtq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vcgtq_f64
+  // CHECK-LABEL: test_vcgtq_f64
   return vcgtq_f64(v1, v2);
   // CHECK: fcmgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
@@ -1633,381 +1633,381 @@ uint64x2_t test_vcgtq_f64(float64x2_t v1
 // Using registers other than v0, v1 are possible, but would be odd.
 
 uint8x8_t test_vclt_s8(int8x8_t v1, int8x8_t v2) {
-  // CHECK: test_vclt_s8
+  // CHECK-LABEL: test_vclt_s8
   return vclt_s8(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.8b, v1.8b, v0.8b
 }
 
 uint16x4_t test_vclt_s16(int16x4_t v1, int16x4_t v2) {
-  // CHECK: test_vclt_s16
+  // CHECK-LABEL: test_vclt_s16
   return vclt_s16(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.4h, v1.4h, v0.4h
 }
 
 uint32x2_t test_vclt_s32(int32x2_t v1, int32x2_t v2) {
-  // CHECK: test_vclt_s32
+  // CHECK-LABEL: test_vclt_s32
   return vclt_s32(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.2s, v1.2s, v0.2s
 }
 
 uint64x1_t test_vclt_s64(int64x1_t a, int64x1_t b) {
-  // CHECK: test_vclt_s64
+  // CHECK-LABEL: test_vclt_s64
   return vclt_s64(a, b);
   // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64x1_t test_vclt_u64(uint64x1_t a, uint64x1_t b) {
-  // CHECK: test_vclt_u64
+  // CHECK-LABEL: test_vclt_u64
   return vclt_u64(a, b);
   // CHECK: cmhi {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint32x2_t test_vclt_f32(float32x2_t v1, float32x2_t v2) {
-  // CHECK: test_vclt_f32
+  // CHECK-LABEL: test_vclt_f32
   return vclt_f32(v1, v2);
   // CHECK: fcmgt {{v[0-9]+}}.2s, v1.2s, v0.2s
 }
 
 uint64x1_t test_vclt_f64(float64x1_t a, float64x1_t b) {
-  // CHECK: test_vclt_f64
+  // CHECK-LABEL: test_vclt_f64
   return vclt_f64(a, b);
   // CHECK: fcmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vclt_u8(uint8x8_t v1, uint8x8_t v2) {
-  // CHECK: test_vclt_u8
+  // CHECK-LABEL: test_vclt_u8
   return vclt_u8(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.8b, v1.8b, v0.8b
 }
 
 uint16x4_t test_vclt_u16(uint16x4_t v1, uint16x4_t v2) {
-  // CHECK: test_vclt_u16
+  // CHECK-LABEL: test_vclt_u16
   return vclt_u16(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.4h, v1.4h, v0.4h
 }
 
 uint32x2_t test_vclt_u32(uint32x2_t v1, uint32x2_t v2) {
-  // CHECK: test_vclt_u32
+  // CHECK-LABEL: test_vclt_u32
   return vclt_u32(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.2s, v1.2s, v0.2s
 }
 
 uint8x16_t test_vcltq_s8(int8x16_t v1, int8x16_t v2) {
-  // CHECK: test_vcltq_s8
+  // CHECK-LABEL: test_vcltq_s8
   return vcltq_s8(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.16b, v1.16b, v0.16b
 }
 
 uint16x8_t test_vcltq_s16(int16x8_t v1, int16x8_t v2) {
-  // CHECK: test_vcltq_s16
+  // CHECK-LABEL: test_vcltq_s16
   return vcltq_s16(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.8h, v1.8h, v0.8h
 }
 
 uint32x4_t test_vcltq_s32(int32x4_t v1, int32x4_t v2) {
-  // CHECK: test_vcltq_s32
+  // CHECK-LABEL: test_vcltq_s32
   return vcltq_s32(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.4s, v1.4s, v0.4s
 }
 
 uint32x4_t test_vcltq_f32(float32x4_t v1, float32x4_t v2) {
-  // CHECK: test_vcltq_f32
+  // CHECK-LABEL: test_vcltq_f32
   return vcltq_f32(v1, v2);
   // CHECK: fcmgt {{v[0-9]+}}.4s, v1.4s, v0.4s
 }
 
 uint8x16_t test_vcltq_u8(uint8x16_t v1, uint8x16_t v2) {
-  // CHECK: test_vcltq_u8
+  // CHECK-LABEL: test_vcltq_u8
   return vcltq_u8(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.16b, v1.16b, v0.16b
 }
 
 uint16x8_t test_vcltq_u16(uint16x8_t v1, uint16x8_t v2) {
-  // CHECK: test_vcltq_u16
+  // CHECK-LABEL: test_vcltq_u16
   return vcltq_u16(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.8h, v1.8h, v0.8h
 }
 
 uint32x4_t test_vcltq_u32(uint32x4_t v1, uint32x4_t v2) {
-  // CHECK: test_vcltq_u32
+  // CHECK-LABEL: test_vcltq_u32
   return vcltq_u32(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.4s, v1.4s, v0.4s
 }
 
 uint64x2_t test_vcltq_s64(int64x2_t v1, int64x2_t v2) {
-  // CHECK: test_vcltq_s64
+  // CHECK-LABEL: test_vcltq_s64
   return vcltq_s64(v1, v2);
   // CHECK: cmgt {{v[0-9]+}}.2d, v1.2d, v0.2d
 }
 
 uint64x2_t test_vcltq_u64(uint64x2_t v1, uint64x2_t v2) {
-  // CHECK: test_vcltq_u64
+  // CHECK-LABEL: test_vcltq_u64
   return vcltq_u64(v1, v2);
   // CHECK: cmhi {{v[0-9]+}}.2d, v1.2d, v0.2d
 }
 
 uint64x2_t test_vcltq_f64(float64x2_t v1, float64x2_t v2) {
-  // CHECK: test_vcltq_f64
+  // CHECK-LABEL: test_vcltq_f64
   return vcltq_f64(v1, v2);
   // CHECK: fcmgt {{v[0-9]+}}.2d, v1.2d, v0.2d
 }
 
 
 int8x8_t test_vhadd_s8(int8x8_t v1, int8x8_t v2) {
-// CHECK: test_vhadd_s8
+// CHECK-LABEL: test_vhadd_s8
   return vhadd_s8(v1, v2);
   // CHECK: shadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vhadd_s16(int16x4_t v1, int16x4_t v2) {
-// CHECK: test_vhadd_s16
+// CHECK-LABEL: test_vhadd_s16
   return vhadd_s16(v1, v2);
   // CHECK: shadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vhadd_s32(int32x2_t v1, int32x2_t v2) {
-// CHECK: test_vhadd_s32
+// CHECK-LABEL: test_vhadd_s32
   return vhadd_s32(v1, v2);
   // CHECK: shadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vhadd_u8(uint8x8_t v1, uint8x8_t v2) {
-// CHECK: test_vhadd_u8
+// CHECK-LABEL: test_vhadd_u8
   return vhadd_u8(v1, v2);
   // CHECK: uhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vhadd_u16(uint16x4_t v1, uint16x4_t v2) {
-// CHECK: test_vhadd_u16
+// CHECK-LABEL: test_vhadd_u16
   return vhadd_u16(v1, v2);
   // CHECK: uhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vhadd_u32(uint32x2_t v1, uint32x2_t v2) {
-// CHECK: test_vhadd_u32
+// CHECK-LABEL: test_vhadd_u32
   return vhadd_u32(v1, v2);
   // CHECK: uhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vhaddq_s8(int8x16_t v1, int8x16_t v2) {
-// CHECK: test_vhaddq_s8
+// CHECK-LABEL: test_vhaddq_s8
   return vhaddq_s8(v1, v2);
   // CHECK: shadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vhaddq_s16(int16x8_t v1, int16x8_t v2) {
-// CHECK: test_vhaddq_s16
+// CHECK-LABEL: test_vhaddq_s16
   return vhaddq_s16(v1, v2);
   // CHECK: shadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vhaddq_s32(int32x4_t v1, int32x4_t v2) {
-// CHECK: test_vhaddq_s32
+// CHECK-LABEL: test_vhaddq_s32
   return vhaddq_s32(v1, v2);
   // CHECK: shadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vhaddq_u8(uint8x16_t v1, uint8x16_t v2) {
-// CHECK: test_vhaddq_u8
+// CHECK-LABEL: test_vhaddq_u8
   return vhaddq_u8(v1, v2);
   // CHECK: uhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vhaddq_u16(uint16x8_t v1, uint16x8_t v2) {
-// CHECK: test_vhaddq_u16
+// CHECK-LABEL: test_vhaddq_u16
   return vhaddq_u16(v1, v2);
   // CHECK: uhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vhaddq_u32(uint32x4_t v1, uint32x4_t v2) {
-// CHECK: test_vhaddq_u32
+// CHECK-LABEL: test_vhaddq_u32
   return vhaddq_u32(v1, v2);
   // CHECK: uhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 
 int8x8_t test_vhsub_s8(int8x8_t v1, int8x8_t v2) {
-// CHECK: test_vhsub_s8
+// CHECK-LABEL: test_vhsub_s8
   return vhsub_s8(v1, v2);
   // CHECK: shsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vhsub_s16(int16x4_t v1, int16x4_t v2) {
-// CHECK: test_vhsub_s16
+// CHECK-LABEL: test_vhsub_s16
   return vhsub_s16(v1, v2);
   // CHECK: shsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vhsub_s32(int32x2_t v1, int32x2_t v2) {
-// CHECK: test_vhsub_s32
+// CHECK-LABEL: test_vhsub_s32
   return vhsub_s32(v1, v2);
   // CHECK: shsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vhsub_u8(uint8x8_t v1, uint8x8_t v2) {
-// CHECK: test_vhsub_u8
+// CHECK-LABEL: test_vhsub_u8
   return vhsub_u8(v1, v2);
   // CHECK: uhsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vhsub_u16(uint16x4_t v1, uint16x4_t v2) {
-// CHECK: test_vhsub_u16
+// CHECK-LABEL: test_vhsub_u16
   return vhsub_u16(v1, v2);
   // CHECK: uhsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vhsub_u32(uint32x2_t v1, uint32x2_t v2) {
-// CHECK: test_vhsub_u32
+// CHECK-LABEL: test_vhsub_u32
   return vhsub_u32(v1, v2);
   // CHECK: uhsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vhsubq_s8(int8x16_t v1, int8x16_t v2) {
-// CHECK: test_vhsubq_s8
+// CHECK-LABEL: test_vhsubq_s8
   return vhsubq_s8(v1, v2);
   // CHECK: shsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vhsubq_s16(int16x8_t v1, int16x8_t v2) {
-// CHECK: test_vhsubq_s16
+// CHECK-LABEL: test_vhsubq_s16
   return vhsubq_s16(v1, v2);
   // CHECK: shsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vhsubq_s32(int32x4_t v1, int32x4_t v2) {
-// CHECK: test_vhsubq_s32
+// CHECK-LABEL: test_vhsubq_s32
   return vhsubq_s32(v1, v2);
   // CHECK: shsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vhsubq_u8(uint8x16_t v1, uint8x16_t v2) {
-// CHECK: test_vhsubq_u8
+// CHECK-LABEL: test_vhsubq_u8
   return vhsubq_u8(v1, v2);
   // CHECK: uhsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vhsubq_u16(uint16x8_t v1, uint16x8_t v2) {
-// CHECK: test_vhsubq_u16
+// CHECK-LABEL: test_vhsubq_u16
   return vhsubq_u16(v1, v2);
   // CHECK: uhsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vhsubq_u32(uint32x4_t v1, uint32x4_t v2) {
-// CHECK: test_vhsubq_u32
+// CHECK-LABEL: test_vhsubq_u32
   return vhsubq_u32(v1, v2);
   // CHECK: uhsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 
 int8x8_t test_vrhadd_s8(int8x8_t v1, int8x8_t v2) {
-// CHECK: test_vrhadd_s8
+// CHECK-LABEL: test_vrhadd_s8
   return vrhadd_s8(v1, v2);
 // CHECK: srhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vrhadd_s16(int16x4_t v1, int16x4_t v2) {
-// CHECK: test_vrhadd_s16
+// CHECK-LABEL: test_vrhadd_s16
   return vrhadd_s16(v1, v2);
 // CHECK: srhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vrhadd_s32(int32x2_t v1, int32x2_t v2) {
-// CHECK: test_vrhadd_s32
+// CHECK-LABEL: test_vrhadd_s32
   return vrhadd_s32(v1, v2);
 // CHECK: srhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vrhadd_u8(uint8x8_t v1, uint8x8_t v2) {
-// CHECK: test_vrhadd_u8
+// CHECK-LABEL: test_vrhadd_u8
   return vrhadd_u8(v1, v2);
 // CHECK: urhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vrhadd_u16(uint16x4_t v1, uint16x4_t v2) {
-// CHECK: test_vrhadd_u16
+// CHECK-LABEL: test_vrhadd_u16
   return vrhadd_u16(v1, v2);
 // CHECK: urhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vrhadd_u32(uint32x2_t v1, uint32x2_t v2) {
-// CHECK: test_vrhadd_u32
+// CHECK-LABEL: test_vrhadd_u32
   return vrhadd_u32(v1, v2);
 // CHECK: urhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vrhaddq_s8(int8x16_t v1, int8x16_t v2) {
-// CHECK: test_vrhaddq_s8
+// CHECK-LABEL: test_vrhaddq_s8
   return vrhaddq_s8(v1, v2);
 // CHECK: srhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vrhaddq_s16(int16x8_t v1, int16x8_t v2) {
-// CHECK: test_vrhaddq_s16
+// CHECK-LABEL: test_vrhaddq_s16
   return vrhaddq_s16(v1, v2);
 // CHECK: srhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vrhaddq_s32(int32x4_t v1, int32x4_t v2) {
-// CHECK: test_vrhaddq_s32
+// CHECK-LABEL: test_vrhaddq_s32
   return vrhaddq_s32(v1, v2);
 // CHECK: srhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vrhaddq_u8(uint8x16_t v1, uint8x16_t v2) {
-// CHECK: test_vrhaddq_u8
+// CHECK-LABEL: test_vrhaddq_u8
   return vrhaddq_u8(v1, v2);
 // CHECK: urhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vrhaddq_u16(uint16x8_t v1, uint16x8_t v2) {
-// CHECK: test_vrhaddq_u16
+// CHECK-LABEL: test_vrhaddq_u16
   return vrhaddq_u16(v1, v2);
 // CHECK: urhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vrhaddq_u32(uint32x4_t v1, uint32x4_t v2) {
-// CHECK: test_vrhaddq_u32
+// CHECK-LABEL: test_vrhaddq_u32
   return vrhaddq_u32(v1, v2);
 // CHECK: urhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 int8x8_t test_vqadd_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vqadd_s8
+// CHECK-LABEL: test_vqadd_s8
   return vqadd_s8(a, b);
   // CHECK: sqadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vqadd_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vqadd_s16
+// CHECK-LABEL: test_vqadd_s16
   return vqadd_s16(a, b);
   // CHECK: sqadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vqadd_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vqadd_s32
+// CHECK-LABEL: test_vqadd_s32
   return vqadd_s32(a, b);
   // CHECK: sqadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int64x1_t test_vqadd_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vqadd_s64
+// CHECK-LABEL: test_vqadd_s64
   return vqadd_s64(a, b);
 // CHECK:  sqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vqadd_u8(uint8x8_t a, uint8x8_t b) {
-// CHECK: test_vqadd_u8
+// CHECK-LABEL: test_vqadd_u8
   return vqadd_u8(a, b);
   // CHECK: uqadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vqadd_u16(uint16x4_t a, uint16x4_t b) {
-// CHECK: test_vqadd_u16
+// CHECK-LABEL: test_vqadd_u16
   return vqadd_u16(a, b);
   // CHECK: uqadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vqadd_u32(uint32x2_t a, uint32x2_t b) {
-// CHECK: test_vqadd_u32
+// CHECK-LABEL: test_vqadd_u32
   return vqadd_u32(a, b);
   // CHECK: uqadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
@@ -2019,533 +2019,533 @@ uint64x1_t test_vqadd_u64(uint64x1_t a,
 }
 
 int8x16_t test_vqaddq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vqaddq_s8
+// CHECK-LABEL: test_vqaddq_s8
   return vqaddq_s8(a, b);
   // CHECK: sqadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vqaddq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vqaddq_s16
+// CHECK-LABEL: test_vqaddq_s16
   return vqaddq_s16(a, b);
   // CHECK: sqadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vqaddq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vqaddq_s32
+// CHECK-LABEL: test_vqaddq_s32
   return vqaddq_s32(a, b);
   // CHECK: sqadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vqaddq_s64(int64x2_t a, int64x2_t b) {
-// CHECK: test_vqaddq_s64
+// CHECK-LABEL: test_vqaddq_s64
   return vqaddq_s64(a, b);
 // CHECK: sqadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vqaddq_u8(uint8x16_t a, uint8x16_t b) {
-// CHECK: test_vqaddq_u8
+// CHECK-LABEL: test_vqaddq_u8
   return vqaddq_u8(a, b);
   // CHECK: uqadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vqaddq_u16(uint16x8_t a, uint16x8_t b) {
-// CHECK: test_vqaddq_u16
+// CHECK-LABEL: test_vqaddq_u16
   return vqaddq_u16(a, b);
   // CHECK: uqadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vqaddq_u32(uint32x4_t a, uint32x4_t b) {
-// CHECK: test_vqaddq_u32
+// CHECK-LABEL: test_vqaddq_u32
   return vqaddq_u32(a, b);
   // CHECK: uqadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vqaddq_u64(uint64x2_t a, uint64x2_t b) {
-// CHECK: test_vqaddq_u64
+// CHECK-LABEL: test_vqaddq_u64
   return vqaddq_u64(a, b);
 // CHECK: uqadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 
 int8x8_t test_vqsub_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vqsub_s8
+// CHECK-LABEL: test_vqsub_s8
   return vqsub_s8(a, b);
   // CHECK: sqsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vqsub_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vqsub_s16
+// CHECK-LABEL: test_vqsub_s16
   return vqsub_s16(a, b);
   // CHECK: sqsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vqsub_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vqsub_s32
+// CHECK-LABEL: test_vqsub_s32
   return vqsub_s32(a, b);
   // CHECK: sqsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int64x1_t test_vqsub_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vqsub_s64
+// CHECK-LABEL: test_vqsub_s64
   return vqsub_s64(a, b);
 // CHECK: sqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vqsub_u8(uint8x8_t a, uint8x8_t b) {
-// CHECK: test_vqsub_u8
+// CHECK-LABEL: test_vqsub_u8
   return vqsub_u8(a, b);
   // CHECK: uqsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vqsub_u16(uint16x4_t a, uint16x4_t b) {
-// CHECK: test_vqsub_u16
+// CHECK-LABEL: test_vqsub_u16
   return vqsub_u16(a, b);
   // CHECK: uqsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vqsub_u32(uint32x2_t a, uint32x2_t b) {
-// CHECK: test_vqsub_u32
+// CHECK-LABEL: test_vqsub_u32
   return vqsub_u32(a, b);
   // CHECK: uqsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vqsub_u64(uint64x1_t a, uint64x1_t b) {
-// CHECK: test_vqsub_u64
+// CHECK-LABEL: test_vqsub_u64
   return vqsub_u64(a, b);
 // CHECK:  uqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8x16_t test_vqsubq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vqsubq_s8
+// CHECK-LABEL: test_vqsubq_s8
   return vqsubq_s8(a, b);
   // CHECK: sqsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vqsubq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vqsubq_s16
+// CHECK-LABEL: test_vqsubq_s16
   return vqsubq_s16(a, b);
   // CHECK: sqsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vqsubq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vqsubq_s32
+// CHECK-LABEL: test_vqsubq_s32
   return vqsubq_s32(a, b);
   // CHECK: sqsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vqsubq_s64(int64x2_t a, int64x2_t b) {
-// CHECK: test_vqsubq_s64
+// CHECK-LABEL: test_vqsubq_s64
   return vqsubq_s64(a, b);
 // CHECK: sqsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vqsubq_u8(uint8x16_t a, uint8x16_t b) {
-// CHECK: test_vqsubq_u8
+// CHECK-LABEL: test_vqsubq_u8
   return vqsubq_u8(a, b);
   // CHECK: uqsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vqsubq_u16(uint16x8_t a, uint16x8_t b) {
-// CHECK: test_vqsubq_u16
+// CHECK-LABEL: test_vqsubq_u16
   return vqsubq_u16(a, b);
   // CHECK: uqsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vqsubq_u32(uint32x4_t a, uint32x4_t b) {
-// CHECK: test_vqsubq_u32
+// CHECK-LABEL: test_vqsubq_u32
   return vqsubq_u32(a, b);
   // CHECK: uqsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vqsubq_u64(uint64x2_t a, uint64x2_t b) {
-// CHECK: test_vqsubq_u64
+// CHECK-LABEL: test_vqsubq_u64
   return vqsubq_u64(a, b);
   // CHECK: uqsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 
 int8x8_t test_vshl_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vshl_s8
+// CHECK-LABEL: test_vshl_s8
   return vshl_s8(a, b);
 // CHECK: sshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vshl_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vshl_s16
+// CHECK-LABEL: test_vshl_s16
   return vshl_s16(a, b);
 // CHECK: sshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vshl_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vshl_s32
+// CHECK-LABEL: test_vshl_s32
   return vshl_s32(a, b);
 // CHECK: sshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int64x1_t test_vshl_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vshl_s64
+// CHECK-LABEL: test_vshl_s64
   return vshl_s64(a, b);
 // CHECK: sshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vshl_u8(uint8x8_t a, int8x8_t b) {
-// CHECK: test_vshl_u8
+// CHECK-LABEL: test_vshl_u8
   return vshl_u8(a, b);
 // CHECK: ushl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vshl_u16(uint16x4_t a, int16x4_t b) {
-// CHECK: test_vshl_u16
+// CHECK-LABEL: test_vshl_u16
   return vshl_u16(a, b);
 // CHECK: ushl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vshl_u32(uint32x2_t a, int32x2_t b) {
-// CHECK: test_vshl_u32
+// CHECK-LABEL: test_vshl_u32
   return vshl_u32(a, b);
 // CHECK: ushl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vshl_u64(uint64x1_t a, int64x1_t b) {
-// CHECK: test_vshl_u64
+// CHECK-LABEL: test_vshl_u64
   return vshl_u64(a, b);
 // CHECK: ushl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8x16_t test_vshlq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vshlq_s8
+// CHECK-LABEL: test_vshlq_s8
   return vshlq_s8(a, b);
 // CHECK: sshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vshlq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vshlq_s16
+// CHECK-LABEL: test_vshlq_s16
   return vshlq_s16(a, b);
 // CHECK: sshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vshlq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vshlq_s32
+// CHECK-LABEL: test_vshlq_s32
   return vshlq_s32(a, b);
 // CHECK: sshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vshlq_s64(int64x2_t a, int64x2_t b) {
-// CHECK: test_vshlq_s64
+// CHECK-LABEL: test_vshlq_s64
   return vshlq_s64(a, b);
 // CHECK: sshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vshlq_u8(uint8x16_t a, int8x16_t b) {
-// CHECK: test_vshlq_u8
+// CHECK-LABEL: test_vshlq_u8
   return vshlq_u8(a, b);
 // CHECK: ushl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vshlq_u16(uint16x8_t a, int16x8_t b) {
-// CHECK: test_vshlq_u16
+// CHECK-LABEL: test_vshlq_u16
   return vshlq_u16(a, b);
 // CHECK: ushl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vshlq_u32(uint32x4_t a, int32x4_t b) {
-// CHECK: test_vshlq_u32
+// CHECK-LABEL: test_vshlq_u32
   return vshlq_u32(a, b);
 // CHECK: ushl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vshlq_u64(uint64x2_t a, int64x2_t b) {
-// CHECK: test_vshlq_u64
+// CHECK-LABEL: test_vshlq_u64
   return vshlq_u64(a, b);
 // CHECK: ushl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 
 int8x8_t test_vqshl_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vqshl_s8
+// CHECK-LABEL: test_vqshl_s8
   return vqshl_s8(a, b);
 // CHECK: sqshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vqshl_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vqshl_s16
+// CHECK-LABEL: test_vqshl_s16
   return vqshl_s16(a, b);
 // CHECK: sqshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vqshl_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vqshl_s32
+// CHECK-LABEL: test_vqshl_s32
   return vqshl_s32(a, b);
 // CHECK: sqshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int64x1_t test_vqshl_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vqshl_s64
+// CHECK-LABEL: test_vqshl_s64
   return vqshl_s64(a, b);
 // CHECK: sqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vqshl_u8(uint8x8_t a, int8x8_t b) {
-// CHECK: test_vqshl_u8
+// CHECK-LABEL: test_vqshl_u8
   return vqshl_u8(a, b);
 // CHECK: uqshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vqshl_u16(uint16x4_t a, int16x4_t b) {
-// CHECK: test_vqshl_u16
+// CHECK-LABEL: test_vqshl_u16
   return vqshl_u16(a, b);
 // CHECK: uqshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vqshl_u32(uint32x2_t a, int32x2_t b) {
-// CHECK: test_vqshl_u32
+// CHECK-LABEL: test_vqshl_u32
   return vqshl_u32(a, b);
 // CHECK: uqshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vqshl_u64(uint64x1_t a, int64x1_t b) {
-// CHECK: test_vqshl_u64
+// CHECK-LABEL: test_vqshl_u64
   return vqshl_u64(a, b);
 // CHECK: uqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8x16_t test_vqshlq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vqshlq_s8
+// CHECK-LABEL: test_vqshlq_s8
   return vqshlq_s8(a, b);
 // CHECK: sqshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vqshlq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vqshlq_s16
+// CHECK-LABEL: test_vqshlq_s16
   return vqshlq_s16(a, b);
 // CHECK: sqshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vqshlq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vqshlq_s32
+// CHECK-LABEL: test_vqshlq_s32
   return vqshlq_s32(a, b);
 // CHECK: sqshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vqshlq_s64(int64x2_t a, int64x2_t b) {
-// CHECK: test_vqshlq_s64
+// CHECK-LABEL: test_vqshlq_s64
   return vqshlq_s64(a, b);
 // CHECK: sqshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vqshlq_u8(uint8x16_t a, int8x16_t b) {
-// CHECK: test_vqshlq_u8
+// CHECK-LABEL: test_vqshlq_u8
   return vqshlq_u8(a, b);
 // CHECK: uqshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vqshlq_u16(uint16x8_t a, int16x8_t b) {
-// CHECK: test_vqshlq_u16
+// CHECK-LABEL: test_vqshlq_u16
   return vqshlq_u16(a, b);
 // CHECK: uqshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vqshlq_u32(uint32x4_t a, int32x4_t b) {
-// CHECK: test_vqshlq_u32
+// CHECK-LABEL: test_vqshlq_u32
   return vqshlq_u32(a, b);
 // CHECK: uqshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vqshlq_u64(uint64x2_t a, int64x2_t b) {
-// CHECK: test_vqshlq_u32
+// CHECK-LABEL: test_vqshlq_u64
   return vqshlq_u64(a, b);
 // CHECK: uqshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vrshl_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vrshl_s8
+// CHECK-LABEL: test_vrshl_s8
   return vrshl_s8(a, b);
 // CHECK: srshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vrshl_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vrshl_s16
+// CHECK-LABEL: test_vrshl_s16
   return vrshl_s16(a, b);
 // CHECK: srshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vrshl_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vrshl_s32
+// CHECK-LABEL: test_vrshl_s32
   return vrshl_s32(a, b);
 // CHECK: srshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int64x1_t test_vrshl_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vrshl_s64
+// CHECK-LABEL: test_vrshl_s64
   return vrshl_s64(a, b);
 // CHECK: srshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vrshl_u8(uint8x8_t a, int8x8_t b) {
-// CHECK: test_vrshl_u8
+// CHECK-LABEL: test_vrshl_u8
   return vrshl_u8(a, b);
 // CHECK: urshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vrshl_u16(uint16x4_t a, int16x4_t b) {
-// CHECK: test_vrshl_u16
+// CHECK-LABEL: test_vrshl_u16
   return vrshl_u16(a, b);
 // CHECK: urshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vrshl_u32(uint32x2_t a, int32x2_t b) {
-// CHECK: test_vrshl_u32
+// CHECK-LABEL: test_vrshl_u32
   return vrshl_u32(a, b);
 // CHECK: urshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vrshl_u64(uint64x1_t a, int64x1_t b) {
-// CHECK: test_vrshl_u64
+// CHECK-LABEL: test_vrshl_u64
   return vrshl_u64(a, b);
 // CHECK: urshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8x16_t test_vrshlq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vrshlq_s8
+// CHECK-LABEL: test_vrshlq_s8
   return vrshlq_s8(a, b);
 // CHECK: srshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vrshlq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vrshlq_s16
+// CHECK-LABEL: test_vrshlq_s16
   return vrshlq_s16(a, b);
 // CHECK: srshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vrshlq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vrshlq_s32
+// CHECK-LABEL: test_vrshlq_s32
   return vrshlq_s32(a, b);
 // CHECK: srshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vrshlq_s64(int64x2_t a, int64x2_t b) {
-// CHECK: test_vrshlq_s64
+// CHECK-LABEL: test_vrshlq_s64
   return vrshlq_s64(a, b);
 // CHECK: srshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vrshlq_u8(uint8x16_t a, int8x16_t b) {
-// CHECK: test_vrshlq_u8
+// CHECK-LABEL: test_vrshlq_u8
   return vrshlq_u8(a, b);
 // CHECK: urshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vrshlq_u16(uint16x8_t a, int16x8_t b) {
-// CHECK: test_vrshlq_u16
+// CHECK-LABEL: test_vrshlq_u16
   return vrshlq_u16(a, b);
 // CHECK: urshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vrshlq_u32(uint32x4_t a, int32x4_t b) {
-// CHECK: test_vrshlq_u32
+// CHECK-LABEL: test_vrshlq_u32
   return vrshlq_u32(a, b);
 // CHECK: urshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vrshlq_u64(uint64x2_t a, int64x2_t b) {
-// CHECK: test_vrshlq_u64
+// CHECK-LABEL: test_vrshlq_u64
   return vrshlq_u64(a, b);
 // CHECK: urshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 
 int8x8_t test_vqrshl_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vqrshl_s8
+// CHECK-LABEL: test_vqrshl_s8
   return vqrshl_s8(a, b);
 // CHECK: sqrshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vqrshl_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vqrshl_s16
+// CHECK-LABEL: test_vqrshl_s16
   return vqrshl_s16(a, b);
 // CHECK: sqrshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vqrshl_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vqrshl_s32
+// CHECK-LABEL: test_vqrshl_s32
   return vqrshl_s32(a, b);
 // CHECK: sqrshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int64x1_t test_vqrshl_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vqrshl_s64
+// CHECK-LABEL: test_vqrshl_s64
   return vqrshl_s64(a, b);
 // CHECK: sqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8x8_t test_vqrshl_u8(uint8x8_t a, int8x8_t b) {
-// CHECK: test_vqrshl_u8
+// CHECK-LABEL: test_vqrshl_u8
   return vqrshl_u8(a, b);
 // CHECK: uqrshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vqrshl_u16(uint16x4_t a, int16x4_t b) {
-// CHECK: test_vqrshl_u16
+// CHECK-LABEL: test_vqrshl_u16
   return vqrshl_u16(a, b);
 // CHECK: uqrshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vqrshl_u32(uint32x2_t a, int32x2_t b) {
-// CHECK: test_vqrshl_u32
+// CHECK-LABEL: test_vqrshl_u32
   return vqrshl_u32(a, b);
 // CHECK: uqrshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint64x1_t test_vqrshl_u64(uint64x1_t a, int64x1_t b) {
-// CHECK: test_vqrshl_u64
+// CHECK-LABEL: test_vqrshl_u64
   return vqrshl_u64(a, b);
 // CHECK: uqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8x16_t test_vqrshlq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vqrshlq_s8
+// CHECK-LABEL: test_vqrshlq_s8
   return vqrshlq_s8(a, b);
 // CHECK: sqrshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vqrshlq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vqrshlq_s16
+// CHECK-LABEL: test_vqrshlq_s16
   return vqrshlq_s16(a, b);
 // CHECK: sqrshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vqrshlq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vqrshlq_s32
+// CHECK-LABEL: test_vqrshlq_s32
   return vqrshlq_s32(a, b);
 // CHECK: sqrshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vqrshlq_s64(int64x2_t a, int64x2_t b) {
-// CHECK: test_vqrshlq_s64
+// CHECK-LABEL: test_vqrshlq_s64
   return vqrshlq_s64(a, b);
 // CHECK: sqrshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
-// CHECK: test_vqrshlq_u8
+// CHECK-LABEL: test_vqrshlq_u8
 uint8x16_t test_vqrshlq_u8(uint8x16_t a, int8x16_t b) {
   return vqrshlq_u8(a, b);
 // CHECK: uqrshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vqrshlq_u16(uint16x8_t a, int16x8_t b) {
-// CHECK: test_vqrshlq_u16
+// CHECK-LABEL: test_vqrshlq_u16
   return vqrshlq_u16(a, b);
 // CHECK: uqrshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vqrshlq_u32(uint32x4_t a, int32x4_t b) {
-// CHECK: test_vqrshlq_u32
+// CHECK-LABEL: test_vqrshlq_u32
   return vqrshlq_u32(a, b);
 // CHECK: uqrshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vqrshlq_u64(uint64x2_t a, int64x2_t b) {
-// CHECK: test_vqrshlq_u64
+// CHECK-LABEL: test_vqrshlq_u64
   return vqrshlq_u64(a, b);
 // CHECK: uqrshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
@@ -2563,3233 +2563,3233 @@ poly64x2_t test_vsliq_n_p64(poly64x2_t a
 }
 
 int8x8_t test_vmax_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vmax_s8
+// CHECK-LABEL: test_vmax_s8
   return vmax_s8(a, b);
 // CHECK: smax {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vmax_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vmax_s16
+// CHECK-LABEL: test_vmax_s16
   return vmax_s16(a, b);
 // CHECK: smax {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vmax_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vmax_s32
+// CHECK-LABEL: test_vmax_s32
   return vmax_s32(a, b);
 // CHECK: smax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vmax_u8(uint8x8_t a, uint8x8_t b) {
-// CHECK: test_vmax_u8
+// CHECK-LABEL: test_vmax_u8
   return vmax_u8(a, b);
 // CHECK: umax {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vmax_u16(uint16x4_t a, uint16x4_t b) {
-// CHECK: test_vmax_u16
+// CHECK-LABEL: test_vmax_u16
   return vmax_u16(a, b);
 // CHECK: umax {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vmax_u32(uint32x2_t a, uint32x2_t b) {
-// CHECK: test_vmax_u32
+// CHECK-LABEL: test_vmax_u32
   return vmax_u32(a, b);
 // CHECK: umax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vmax_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vmax_f32
+// CHECK-LABEL: test_vmax_f32
   return vmax_f32(a, b);
 // CHECK: fmax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vmaxq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vmaxq_s8
+// CHECK-LABEL: test_vmaxq_s8
   return vmaxq_s8(a, b);
 // CHECK: smax {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vmaxq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vmaxq_s16
+// CHECK-LABEL: test_vmaxq_s16
   return vmaxq_s16(a, b);
 // CHECK: smax {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vmaxq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vmaxq_s32
+// CHECK-LABEL: test_vmaxq_s32
   return vmaxq_s32(a, b);
 // CHECK: smax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vmaxq_u8(uint8x16_t a, uint8x16_t b) {
-// CHECK: test_vmaxq_u8
+// CHECK-LABEL: test_vmaxq_u8
   return vmaxq_u8(a, b);
 // CHECK: umax {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vmaxq_u16(uint16x8_t a, uint16x8_t b) {
-// CHECK: test_vmaxq_u16
+// CHECK-LABEL: test_vmaxq_u16
   return vmaxq_u16(a, b);
 // CHECK: umax {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vmaxq_u32(uint32x4_t a, uint32x4_t b) {
-// CHECK: test_vmaxq_u32
+// CHECK-LABEL: test_vmaxq_u32
   return vmaxq_u32(a, b);
 // CHECK: umax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x4_t test_vmaxq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vmaxq_f32
+// CHECK-LABEL: test_vmaxq_f32
   return vmaxq_f32(a, b);
 // CHECK: fmax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vmaxq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vmaxq_f64
+// CHECK-LABEL: test_vmaxq_f64
   return vmaxq_f64(a, b);
 // CHECK: fmax {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 
 int8x8_t test_vmin_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vmin_s8
+// CHECK-LABEL: test_vmin_s8
   return vmin_s8(a, b);
 // CHECK: smin {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vmin_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vmin_s16
+// CHECK-LABEL: test_vmin_s16
   return vmin_s16(a, b);
 // CHECK: smin {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vmin_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vmin_s32
+// CHECK-LABEL: test_vmin_s32
   return vmin_s32(a, b);
 // CHECK: smin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vmin_u8(uint8x8_t a, uint8x8_t b) {
-// CHECK: test_vmin_u8
+// CHECK-LABEL: test_vmin_u8
   return vmin_u8(a, b);
 // CHECK: umin {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vmin_u16(uint16x4_t a, uint16x4_t b) {
-// CHECK: test_vmin_u16
+// CHECK-LABEL: test_vmin_u16
   return vmin_u16(a, b);
 // CHECK: umin {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vmin_u32(uint32x2_t a, uint32x2_t b) {
-// CHECK: test_vmin_u32
+// CHECK-LABEL: test_vmin_u32
   return vmin_u32(a, b);
 // CHECK: umin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vmin_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vmin_f32
+// CHECK-LABEL: test_vmin_f32
   return vmin_f32(a, b);
 // CHECK: fmin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vminq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vminq_s8
+// CHECK-LABEL: test_vminq_s8
   return vminq_s8(a, b);
 // CHECK: smin {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vminq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vminq_s16
+// CHECK-LABEL: test_vminq_s16
   return vminq_s16(a, b);
 // CHECK: smin {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vminq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vminq_s32
+// CHECK-LABEL: test_vminq_s32
   return vminq_s32(a, b);
 // CHECK: smin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vminq_u8(uint8x16_t a, uint8x16_t b) {
-// CHECK: test_vminq_u8
+// CHECK-LABEL: test_vminq_u8
   return vminq_u8(a, b);
 // CHECK: umin {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vminq_u16(uint16x8_t a, uint16x8_t b) {
-// CHECK: test_vminq_u16
+// CHECK-LABEL: test_vminq_u16
   return vminq_u16(a, b);
 // CHECK: umin {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vminq_u32(uint32x4_t a, uint32x4_t b) {
-// CHECK: test_vminq_u32
+// CHECK-LABEL: test_vminq_u32
   return vminq_u32(a, b);
 // CHECK: umin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x4_t test_vminq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vminq_f32
+// CHECK-LABEL: test_vminq_f32
   return vminq_f32(a, b);
 // CHECK: fmin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vminq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vminq_f64
+// CHECK-LABEL: test_vminq_f64
   return vminq_f64(a, b);
 // CHECK: fmin {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 float32x2_t test_vmaxnm_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vmaxnm_f32
+// CHECK-LABEL: test_vmaxnm_f32
   return vmaxnm_f32(a, b);
 // CHECK: fmaxnm {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x4_t test_vmaxnmq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vmaxnmq_f32
+// CHECK-LABEL: test_vmaxnmq_f32
   return vmaxnmq_f32(a, b);
 // CHECK: fmaxnm {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vmaxnmq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vmaxnmq_f64
+// CHECK-LABEL: test_vmaxnmq_f64
   return vmaxnmq_f64(a, b);
 // CHECK: fmaxnm {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 float32x2_t test_vminnm_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vminnm_f32
+// CHECK-LABEL: test_vminnm_f32
   return vminnm_f32(a, b);
 // CHECK: fminnm {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x4_t test_vminnmq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vminnmq_f32
+// CHECK-LABEL: test_vminnmq_f32
   return vminnmq_f32(a, b);
 // CHECK: fminnm {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vminnmq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vminnmq_f64
+// CHECK-LABEL: test_vminnmq_f64
   return vminnmq_f64(a, b);
 // CHECK: fminnm {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vpmax_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vpmax_s8
+// CHECK-LABEL: test_vpmax_s8
   return vpmax_s8(a, b);
 // CHECK: smaxp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vpmax_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vpmax_s16
+// CHECK-LABEL: test_vpmax_s16
   return vpmax_s16(a, b);
 // CHECK: smaxp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vpmax_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vpmax_s32
+// CHECK-LABEL: test_vpmax_s32
   return vpmax_s32(a, b);
 // CHECK: smaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vpmax_u8(uint8x8_t a, uint8x8_t b) {
-// CHECK: test_vpmax_u8
+// CHECK-LABEL: test_vpmax_u8
   return vpmax_u8(a, b);
 // CHECK: umaxp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vpmax_u16(uint16x4_t a, uint16x4_t b) {
-// CHECK: test_vpmax_u16
+// CHECK-LABEL: test_vpmax_u16
   return vpmax_u16(a, b);
 // CHECK: umaxp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vpmax_u32(uint32x2_t a, uint32x2_t b) {
-// CHECK: test_vpmax_u32
+// CHECK-LABEL: test_vpmax_u32
   return vpmax_u32(a, b);
 // CHECK: umaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vpmax_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vpmax_f32
+// CHECK-LABEL: test_vpmax_f32
   return vpmax_f32(a, b);
 // CHECK: fmaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vpmaxq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vpmaxq_s8
+// CHECK-LABEL: test_vpmaxq_s8
   return vpmaxq_s8(a, b);
 // CHECK: smaxp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vpmaxq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vpmaxq_s16
+// CHECK-LABEL: test_vpmaxq_s16
   return vpmaxq_s16(a, b);
 // CHECK: smaxp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vpmaxq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vpmaxq_s32
+// CHECK-LABEL: test_vpmaxq_s32
   return vpmaxq_s32(a, b);
 // CHECK: smaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vpmaxq_u8(uint8x16_t a, uint8x16_t b) {
-// CHECK: test_vpmaxq_u8
+// CHECK-LABEL: test_vpmaxq_u8
   return vpmaxq_u8(a, b);
 // CHECK: umaxp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vpmaxq_u16(uint16x8_t a, uint16x8_t b) {
-// CHECK: test_vpmaxq_u16
+// CHECK-LABEL: test_vpmaxq_u16
   return vpmaxq_u16(a, b);
 // CHECK: umaxp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vpmaxq_u32(uint32x4_t a, uint32x4_t b) {
-// CHECK: test_vpmaxq_u32
+// CHECK-LABEL: test_vpmaxq_u32
   return vpmaxq_u32(a, b);
 // CHECK: umaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x4_t test_vpmaxq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vpmaxq_f32
+// CHECK-LABEL: test_vpmaxq_f32
   return vpmaxq_f32(a, b);
 // CHECK: fmaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vpmaxq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vpmaxq_f64
+// CHECK-LABEL: test_vpmaxq_f64
   return vpmaxq_f64(a, b);
 // CHECK: fmaxp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vpmin_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vpmin_s8
+// CHECK-LABEL: test_vpmin_s8
   return vpmin_s8(a, b);
 // CHECK: sminp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vpmin_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vpmin_s16
+// CHECK-LABEL: test_vpmin_s16
   return vpmin_s16(a, b);
 // CHECK: sminp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vpmin_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vpmin_s32
+// CHECK-LABEL: test_vpmin_s32
   return vpmin_s32(a, b);
 // CHECK: sminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vpmin_u8(uint8x8_t a, uint8x8_t b) {
-// CHECK: test_vpmin_u8
+// CHECK-LABEL: test_vpmin_u8
   return vpmin_u8(a, b);
 // CHECK: uminp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vpmin_u16(uint16x4_t a, uint16x4_t b) {
-// CHECK: test_vpmin_u16
+// CHECK-LABEL: test_vpmin_u16
   return vpmin_u16(a, b);
 // CHECK: uminp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vpmin_u32(uint32x2_t a, uint32x2_t b) {
-// CHECK: test_vpmin_u32
+// CHECK-LABEL: test_vpmin_u32
   return vpmin_u32(a, b);
 // CHECK: uminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vpmin_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vpmin_f32
+// CHECK-LABEL: test_vpmin_f32
   return vpmin_f32(a, b);
 // CHECK: fminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vpminq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vpminq_s8
+// CHECK-LABEL: test_vpminq_s8
   return vpminq_s8(a, b);
 // CHECK: sminp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vpminq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vpminq_s16
+// CHECK-LABEL: test_vpminq_s16
   return vpminq_s16(a, b);
 // CHECK: sminp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vpminq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vpminq_s32
+// CHECK-LABEL: test_vpminq_s32
   return vpminq_s32(a, b);
 // CHECK: sminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vpminq_u8(uint8x16_t a, uint8x16_t b) {
-// CHECK: test_vpminq_u8
+// CHECK-LABEL: test_vpminq_u8
   return vpminq_u8(a, b);
 // CHECK: uminp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vpminq_u16(uint16x8_t a, uint16x8_t b) {
-// CHECK: test_vpminq_u16
+// CHECK-LABEL: test_vpminq_u16
   return vpminq_u16(a, b);
 // CHECK: uminp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vpminq_u32(uint32x4_t a, uint32x4_t b) {
-// CHECK: test_vpminq_u32
+// CHECK-LABEL: test_vpminq_u32
   return vpminq_u32(a, b);
 // CHECK: uminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x4_t test_vpminq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vpminq_f32
+// CHECK-LABEL: test_vpminq_f32
   return vpminq_f32(a, b);
 // CHECK: fminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vpminq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vpminq_f64
+// CHECK-LABEL: test_vpminq_f64
   return vpminq_f64(a, b);
 // CHECK: fminp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 float32x2_t test_vpmaxnm_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vpmaxnm_f32
+// CHECK-LABEL: test_vpmaxnm_f32
   return vpmaxnm_f32(a, b);
 // CHECK: fmaxnmp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x4_t test_vpmaxnmq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vpmaxnmq_f32
+// CHECK-LABEL: test_vpmaxnmq_f32
   return vpmaxnmq_f32(a, b);
 // CHECK: fmaxnmp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vpmaxnmq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vpmaxnmq_f64
+// CHECK-LABEL: test_vpmaxnmq_f64
   return vpmaxnmq_f64(a, b);
 // CHECK: fmaxnmp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 float32x2_t test_vpminnm_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vpminnm_f32
+// CHECK-LABEL: test_vpminnm_f32
   return vpminnm_f32(a, b);
 // CHECK: fminnmp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x4_t test_vpminnmq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vpminnmq_f32
+// CHECK-LABEL: test_vpminnmq_f32
   return vpminnmq_f32(a, b);
 // CHECK: fminnmp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vpminnmq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vpminnmq_f64
+// CHECK-LABEL: test_vpminnmq_f64
   return vpminnmq_f64(a, b);
 // CHECK: fminnmp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vpadd_s8(int8x8_t a, int8x8_t b) {
-// CHECK: test_vpadd_s8
+// CHECK-LABEL: test_vpadd_s8
   return vpadd_s8(a, b);
 // CHECK: addp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4_t test_vpadd_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vpadd_s16
+// CHECK-LABEL: test_vpadd_s16
   return vpadd_s16(a, b);
 // CHECK: addp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vpadd_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vpadd_s32
+// CHECK-LABEL: test_vpadd_s32
   return vpadd_s32(a, b);
 // CHECK: addp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint8x8_t test_vpadd_u8(uint8x8_t a, uint8x8_t b) {
-// CHECK: test_vpadd_u8
+// CHECK-LABEL: test_vpadd_u8
   return vpadd_u8(a, b);
 // CHECK: addp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint16x4_t test_vpadd_u16(uint16x4_t a, uint16x4_t b) {
-// CHECK: test_vpadd_u16
+// CHECK-LABEL: test_vpadd_u16
   return vpadd_u16(a, b);
 // CHECK: addp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint32x2_t test_vpadd_u32(uint32x2_t a, uint32x2_t b) {
-// CHECK: test_vpadd_u32
+// CHECK-LABEL: test_vpadd_u32
   return vpadd_u32(a, b);
 // CHECK: addp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x2_t test_vpadd_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vpadd_f32
+// CHECK-LABEL: test_vpadd_f32
   return vpadd_f32(a, b);
 // CHECK: faddp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int8x16_t test_vpaddq_s8(int8x16_t a, int8x16_t b) {
-// CHECK: test_vpaddq_s8
+// CHECK-LABEL: test_vpaddq_s8
   return vpaddq_s8(a, b);
 // CHECK: addp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x8_t test_vpaddq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vpaddq_s16
+// CHECK-LABEL: test_vpaddq_s16
   return vpaddq_s16(a, b);
 // CHECK: addp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vpaddq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vpaddq_s32
+// CHECK-LABEL: test_vpaddq_s32
   return vpaddq_s32(a, b);
 // CHECK: addp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint8x16_t test_vpaddq_u8(uint8x16_t a, uint8x16_t b) {
-// CHECK: test_vpaddq_u8
+// CHECK-LABEL: test_vpaddq_u8
   return vpaddq_u8(a, b);
 // CHECK: addp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x8_t test_vpaddq_u16(uint16x8_t a, uint16x8_t b) {
-// CHECK: test_vpaddq_u16
+// CHECK-LABEL: test_vpaddq_u16
   return vpaddq_u16(a, b);
 // CHECK: addp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x4_t test_vpaddq_u32(uint32x4_t a, uint32x4_t b) {
-// CHECK: test_vpaddq_u32
+// CHECK-LABEL: test_vpaddq_u32
   return vpaddq_u32(a, b);
 // CHECK: addp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x4_t test_vpaddq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vpaddq_f32
+// CHECK-LABEL: test_vpaddq_f32
   return vpaddq_f32(a, b);
 // CHECK: faddp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vpaddq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vpaddq_f64
+// CHECK-LABEL: test_vpaddq_f64
   return vpaddq_f64(a, b);
 // CHECK: faddp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int16x4_t test_vqdmulh_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vqdmulh_s16
+// CHECK-LABEL: test_vqdmulh_s16
   return vqdmulh_s16(a, b);
 // CHECK: sqdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vqdmulh_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vqdmulh_s32
+// CHECK-LABEL: test_vqdmulh_s32
   return vqdmulh_s32(a, b);
 // CHECK: sqdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vqdmulhq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vqdmulhq_s16
+// CHECK-LABEL: test_vqdmulhq_s16
   return vqdmulhq_s16(a, b);
 // CHECK: sqdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vqdmulhq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vqdmulhq_s32
+// CHECK-LABEL: test_vqdmulhq_s32
   return vqdmulhq_s32(a, b);
 // CHECK: sqdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int16x4_t test_vqrdmulh_s16(int16x4_t a, int16x4_t b) {
-// CHECK: test_vqrdmulh_s16
+// CHECK-LABEL: test_vqrdmulh_s16
   return vqrdmulh_s16(a, b);
 // CHECK: sqrdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int32x2_t test_vqrdmulh_s32(int32x2_t a, int32x2_t b) {
-// CHECK: test_vqrdmulh_s32
+// CHECK-LABEL: test_vqrdmulh_s32
   return vqrdmulh_s32(a, b);
 // CHECK: sqrdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vqrdmulhq_s16(int16x8_t a, int16x8_t b) {
-// CHECK: test_vqrdmulhq_s16
+// CHECK-LABEL: test_vqrdmulhq_s16
   return vqrdmulhq_s16(a, b);
 // CHECK: sqrdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x4_t test_vqrdmulhq_s32(int32x4_t a, int32x4_t b) {
-// CHECK: test_vqrdmulhq_s32
+// CHECK-LABEL: test_vqrdmulhq_s32
   return vqrdmulhq_s32(a, b);
 // CHECK: sqrdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float32x2_t test_vmulx_f32(float32x2_t a, float32x2_t b) {
-// CHECK: test_vmulx_f32
+// CHECK-LABEL: test_vmulx_f32
   return vmulx_f32(a, b);
 // CHECK: fmulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 float32x4_t test_vmulxq_f32(float32x4_t a, float32x4_t b) {
-// CHECK: test_vmulxq_f32
+// CHECK-LABEL: test_vmulxq_f32
   return vmulxq_f32(a, b);
 // CHECK: fmulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vmulxq_f64(float64x2_t a, float64x2_t b) {
-// CHECK: test_vmulxq_f64
+// CHECK-LABEL: test_vmulxq_f64
   return vmulxq_f64(a, b);
 // CHECK: fmulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vshl_n_s8(int8x8_t a) {
-// CHECK: test_vshl_n_s8
+// CHECK-LABEL: test_vshl_n_s8
   return vshl_n_s8(a, 3);
 // CHECK: shl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vshl_n_s16(int16x4_t a) {
-// CHECK: test_vshl_n_s16
+// CHECK-LABEL: test_vshl_n_s16
   return vshl_n_s16(a, 3);
 // CHECK: shl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vshl_n_s32(int32x2_t a) {
-// CHECK: test_vshl_n_s32
+// CHECK-LABEL: test_vshl_n_s32
   return vshl_n_s32(a, 3);
 // CHECK: shl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vshlq_n_s8(int8x16_t a) {
-// CHECK: test_vshlq_n_s8
+// CHECK-LABEL: test_vshlq_n_s8
   return vshlq_n_s8(a, 3);
 // CHECK: shl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vshlq_n_s16(int16x8_t a) {
-// CHECK: test_vshlq_n_s16
+// CHECK-LABEL: test_vshlq_n_s16
   return vshlq_n_s16(a, 3);
 // CHECK: shl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vshlq_n_s32(int32x4_t a) {
-// CHECK: test_vshlq_n_s32
+// CHECK-LABEL: test_vshlq_n_s32
   return vshlq_n_s32(a, 3);
 // CHECK: shl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vshlq_n_s64(int64x2_t a) {
-// CHECK: test_vshlq_n_s64
+// CHECK-LABEL: test_vshlq_n_s64
   return vshlq_n_s64(a, 3);
 // CHECK: shl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vshl_n_u8(int8x8_t a) {
-// CHECK: test_vshl_n_u8
+// CHECK-LABEL: test_vshl_n_u8
   return vshl_n_u8(a, 3);
 // CHECK: shl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vshl_n_u16(int16x4_t a) {
-// CHECK: test_vshl_n_u16
+// CHECK-LABEL: test_vshl_n_u16
   return vshl_n_u16(a, 3);
 // CHECK: shl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vshl_n_u32(int32x2_t a) {
-// CHECK: test_vshl_n_u32
+// CHECK-LABEL: test_vshl_n_u32
   return vshl_n_u32(a, 3);
 // CHECK: shl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vshlq_n_u8(int8x16_t a) {
-// CHECK: test_vshlq_n_u8
+// CHECK-LABEL: test_vshlq_n_u8
   return vshlq_n_u8(a, 3);
 // CHECK: shl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vshlq_n_u16(int16x8_t a) {
-// CHECK: test_vshlq_n_u16
+// CHECK-LABEL: test_vshlq_n_u16
   return vshlq_n_u16(a, 3);
 // CHECK: shl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vshlq_n_u32(int32x4_t a) {
-// CHECK: test_vshlq_n_u32
+// CHECK-LABEL: test_vshlq_n_u32
   return vshlq_n_u32(a, 3);
 // CHECK: shl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vshlq_n_u64(int64x2_t a) {
-// CHECK: test_vshlq_n_u64
+// CHECK-LABEL: test_vshlq_n_u64
   return vshlq_n_u64(a, 3);
 // CHECK: shl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vshr_n_s8(int8x8_t a) {
-  // CHECK: test_vshr_n_s8
+  // CHECK-LABEL: test_vshr_n_s8
   return vshr_n_s8(a, 3);
   // CHECK: sshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vshr_n_s16(int16x4_t a) {
-  // CHECK: test_vshr_n_s16
+  // CHECK-LABEL: test_vshr_n_s16
   return vshr_n_s16(a, 3);
   // CHECK: sshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vshr_n_s32(int32x2_t a) {
-  // CHECK: test_vshr_n_s32
+  // CHECK-LABEL: test_vshr_n_s32
   return vshr_n_s32(a, 3);
   // CHECK: sshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vshrq_n_s8(int8x16_t a) {
-  // CHECK: test_vshrq_n_s8
+  // CHECK-LABEL: test_vshrq_n_s8
   return vshrq_n_s8(a, 3);
   // CHECK: sshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vshrq_n_s16(int16x8_t a) {
-  // CHECK: test_vshrq_n_s16
+  // CHECK-LABEL: test_vshrq_n_s16
   return vshrq_n_s16(a, 3);
   // CHECK: sshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vshrq_n_s32(int32x4_t a) {
-  // CHECK: test_vshrq_n_s32
+  // CHECK-LABEL: test_vshrq_n_s32
   return vshrq_n_s32(a, 3);
   // CHECK: sshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vshrq_n_s64(int64x2_t a) {
-  // CHECK: test_vshrq_n_s64
+  // CHECK-LABEL: test_vshrq_n_s64
   return vshrq_n_s64(a, 3);
   // CHECK: sshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vshr_n_u8(int8x8_t a) {
-  // CHECK: test_vshr_n_u8
+  // CHECK-LABEL: test_vshr_n_u8
   return vshr_n_u8(a, 3);
   // CHECK: ushr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vshr_n_u16(int16x4_t a) {
-  // CHECK: test_vshr_n_u16
+  // CHECK-LABEL: test_vshr_n_u16
   return vshr_n_u16(a, 3);
   // CHECK: ushr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vshr_n_u32(int32x2_t a) {
-  // CHECK: test_vshr_n_u32
+  // CHECK-LABEL: test_vshr_n_u32
   return vshr_n_u32(a, 3);
   // CHECK: ushr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vshrq_n_u8(int8x16_t a) {
-  // CHECK: test_vshrq_n_u8
+  // CHECK-LABEL: test_vshrq_n_u8
   return vshrq_n_u8(a, 3);
   // CHECK: ushr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vshrq_n_u16(int16x8_t a) {
-  // CHECK: test_vshrq_n_u16
+  // CHECK-LABEL: test_vshrq_n_u16
   return vshrq_n_u16(a, 3);
   // CHECK: ushr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vshrq_n_u32(int32x4_t a) {
-  // CHECK: test_vshrq_n_u32
+  // CHECK-LABEL: test_vshrq_n_u32
   return vshrq_n_u32(a, 3);
   // CHECK: ushr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vshrq_n_u64(int64x2_t a) {
-  // CHECK: test_vshrq_n_u64
+  // CHECK-LABEL: test_vshrq_n_u64
   return vshrq_n_u64(a, 3);
   // CHECK: ushr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vsra_n_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vsra_n_s8
+  // CHECK-LABEL: test_vsra_n_s8
   return vsra_n_s8(a, b, 3);
   // CHECK: ssra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vsra_n_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vsra_n_s16
+  // CHECK-LABEL: test_vsra_n_s16
   return vsra_n_s16(a, b, 3);
   // CHECK: ssra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vsra_n_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vsra_n_s32
+  // CHECK-LABEL: test_vsra_n_s32
   return vsra_n_s32(a, b, 3);
   // CHECK: ssra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vsraq_n_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vsraq_n_s8
+  // CHECK-LABEL: test_vsraq_n_s8
   return vsraq_n_s8(a, b, 3);
   // CHECK: ssra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vsraq_n_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vsraq_n_s16
+  // CHECK-LABEL: test_vsraq_n_s16
   return vsraq_n_s16(a, b, 3);
   // CHECK: ssra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vsraq_n_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vsraq_n_s32
+  // CHECK-LABEL: test_vsraq_n_s32
   return vsraq_n_s32(a, b, 3);
   // CHECK: ssra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vsraq_n_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vsraq_n_s64
+  // CHECK-LABEL: test_vsraq_n_s64
   return vsraq_n_s64(a, b, 3);
   // CHECK: ssra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vsra_n_u8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vsra_n_u8
+  // CHECK-LABEL: test_vsra_n_u8
   return vsra_n_u8(a, b, 3);
   // CHECK: usra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vsra_n_u16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vsra_n_u16
+  // CHECK-LABEL: test_vsra_n_u16
   return vsra_n_u16(a, b, 3);
   // CHECK: usra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vsra_n_u32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vsra_n_u32
+  // CHECK-LABEL: test_vsra_n_u32
   return vsra_n_u32(a, b, 3);
   // CHECK: usra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vsraq_n_u8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vsraq_n_u8
+  // CHECK-LABEL: test_vsraq_n_u8
   return vsraq_n_u8(a, b, 3);
   // CHECK: usra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vsraq_n_u16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vsraq_n_u16
+  // CHECK-LABEL: test_vsraq_n_u16
   return vsraq_n_u16(a, b, 3);
   // CHECK: usra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vsraq_n_u32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vsraq_n_u32
+  // CHECK-LABEL: test_vsraq_n_u32
   return vsraq_n_u32(a, b, 3);
   // CHECK: usra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vsraq_n_u64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vsraq_n_u64
+  // CHECK-LABEL: test_vsraq_n_u64
   return vsraq_n_u64(a, b, 3);
   // CHECK: usra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vrshr_n_s8(int8x8_t a) {
-  // CHECK: test_vrshr_n_s8
+  // CHECK-LABEL: test_vrshr_n_s8
   return vrshr_n_s8(a, 3);
   // CHECK: srshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vrshr_n_s16(int16x4_t a) {
-  // CHECK: test_vrshr_n_s16
+  // CHECK-LABEL: test_vrshr_n_s16
   return vrshr_n_s16(a, 3);
   // CHECK: srshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vrshr_n_s32(int32x2_t a) {
-  // CHECK: test_vrshr_n_s32
+  // CHECK-LABEL: test_vrshr_n_s32
   return vrshr_n_s32(a, 3);
   // CHECK: srshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vrshrq_n_s8(int8x16_t a) {
-  // CHECK: test_vrshrq_n_s8
+  // CHECK-LABEL: test_vrshrq_n_s8
   return vrshrq_n_s8(a, 3);
   // CHECK: srshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vrshrq_n_s16(int16x8_t a) {
-  // CHECK: test_vrshrq_n_s16
+  // CHECK-LABEL: test_vrshrq_n_s16
   return vrshrq_n_s16(a, 3);
   // CHECK: srshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vrshrq_n_s32(int32x4_t a) {
-  // CHECK: test_vrshrq_n_s32
+  // CHECK-LABEL: test_vrshrq_n_s32
   return vrshrq_n_s32(a, 3);
   // CHECK: srshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vrshrq_n_s64(int64x2_t a) {
-  // CHECK: test_vrshrq_n_s64
+  // CHECK-LABEL: test_vrshrq_n_s64
   return vrshrq_n_s64(a, 3);
   // CHECK: srshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vrshr_n_u8(int8x8_t a) {
-  // CHECK: test_vrshr_n_u8
+  // CHECK-LABEL: test_vrshr_n_u8
   return vrshr_n_u8(a, 3);
   // CHECK: urshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vrshr_n_u16(int16x4_t a) {
-  // CHECK: test_vrshr_n_u16
+  // CHECK-LABEL: test_vrshr_n_u16
   return vrshr_n_u16(a, 3);
   // CHECK: urshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vrshr_n_u32(int32x2_t a) {
-  // CHECK: test_vrshr_n_u32
+  // CHECK-LABEL: test_vrshr_n_u32
   return vrshr_n_u32(a, 3);
   // CHECK: urshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vrshrq_n_u8(int8x16_t a) {
-  // CHECK: test_vrshrq_n_u8
+  // CHECK-LABEL: test_vrshrq_n_u8
   return vrshrq_n_u8(a, 3);
   // CHECK: urshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vrshrq_n_u16(int16x8_t a) {
-  // CHECK: test_vrshrq_n_u16
+  // CHECK-LABEL: test_vrshrq_n_u16
   return vrshrq_n_u16(a, 3);
   // CHECK: urshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vrshrq_n_u32(int32x4_t a) {
-  // CHECK: test_vrshrq_n_u32
+  // CHECK-LABEL: test_vrshrq_n_u32
   return vrshrq_n_u32(a, 3);
   // CHECK: urshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vrshrq_n_u64(int64x2_t a) {
-  // CHECK: test_vrshrq_n_u64
+  // CHECK-LABEL: test_vrshrq_n_u64
   return vrshrq_n_u64(a, 3);
   // CHECK: urshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vrsra_n_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vrsra_n_s8
+  // CHECK-LABEL: test_vrsra_n_s8
   return vrsra_n_s8(a, b, 3);
   // CHECK: srsra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vrsra_n_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vrsra_n_s16
+  // CHECK-LABEL: test_vrsra_n_s16
   return vrsra_n_s16(a, b, 3);
   // CHECK: srsra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vrsra_n_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vrsra_n_s32
+  // CHECK-LABEL: test_vrsra_n_s32
   return vrsra_n_s32(a, b, 3);
   // CHECK: srsra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vrsraq_n_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vrsraq_n_s8
+  // CHECK-LABEL: test_vrsraq_n_s8
   return vrsraq_n_s8(a, b, 3);
   // CHECK: srsra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vrsraq_n_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vrsraq_n_s16
+  // CHECK-LABEL: test_vrsraq_n_s16
   return vrsraq_n_s16(a, b, 3);
   // CHECK: srsra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vrsraq_n_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vrsraq_n_s32
+  // CHECK-LABEL: test_vrsraq_n_s32
   return vrsraq_n_s32(a, b, 3);
   // CHECK: srsra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vrsraq_n_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vrsraq_n_s64
+  // CHECK-LABEL: test_vrsraq_n_s64
   return vrsraq_n_s64(a, b, 3);
   // CHECK: srsra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vrsra_n_u8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vrsra_n_u8
+  // CHECK-LABEL: test_vrsra_n_u8
   return vrsra_n_u8(a, b, 3);
   // CHECK: ursra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vrsra_n_u16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vrsra_n_u16
+  // CHECK-LABEL: test_vrsra_n_u16
   return vrsra_n_u16(a, b, 3);
   // CHECK: ursra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vrsra_n_u32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vrsra_n_u32
+  // CHECK-LABEL: test_vrsra_n_u32
   return vrsra_n_u32(a, b, 3);
   // CHECK: ursra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vrsraq_n_u8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vrsraq_n_u8
+  // CHECK-LABEL: test_vrsraq_n_u8
   return vrsraq_n_u8(a, b, 3);
   // CHECK: ursra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vrsraq_n_u16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vrsraq_n_u16
+  // CHECK-LABEL: test_vrsraq_n_u16
   return vrsraq_n_u16(a, b, 3);
   // CHECK: ursra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vrsraq_n_u32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vrsraq_n_u32
+  // CHECK-LABEL: test_vrsraq_n_u32
   return vrsraq_n_u32(a, b, 3);
   // CHECK: ursra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vrsraq_n_u64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vrsraq_n_u64
+  // CHECK-LABEL: test_vrsraq_n_u64
   return vrsraq_n_u64(a, b, 3);
   // CHECK: ursra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vsri_n_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vsri_n_s8
+  // CHECK-LABEL: test_vsri_n_s8
   return vsri_n_s8(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vsri_n_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vsri_n_s16
+  // CHECK-LABEL: test_vsri_n_s16
   return vsri_n_s16(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vsri_n_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vsri_n_s32
+  // CHECK-LABEL: test_vsri_n_s32
   return vsri_n_s32(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vsriq_n_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vsriq_n_s8
+  // CHECK-LABEL: test_vsriq_n_s8
   return vsriq_n_s8(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vsriq_n_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vsriq_n_s16
+  // CHECK-LABEL: test_vsriq_n_s16
   return vsriq_n_s16(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vsriq_n_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vsriq_n_s32
+  // CHECK-LABEL: test_vsriq_n_s32
   return vsriq_n_s32(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vsriq_n_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vsriq_n_s64
+  // CHECK-LABEL: test_vsriq_n_s64
   return vsriq_n_s64(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vsri_n_u8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vsri_n_u8
+  // CHECK-LABEL: test_vsri_n_u8
   return vsri_n_u8(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vsri_n_u16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vsri_n_u16
+  // CHECK-LABEL: test_vsri_n_u16
   return vsri_n_u16(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vsri_n_u32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vsri_n_u32
+  // CHECK-LABEL: test_vsri_n_u32
   return vsri_n_u32(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vsriq_n_u8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vsriq_n_u8
+  // CHECK-LABEL: test_vsriq_n_u8
   return vsriq_n_u8(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vsriq_n_u16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vsriq_n_u16
+  // CHECK-LABEL: test_vsriq_n_u16
   return vsriq_n_u16(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vsriq_n_u32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vsriq_n_u32
+  // CHECK-LABEL: test_vsriq_n_u32
   return vsriq_n_u32(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vsriq_n_u64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vsriq_n_u64
+  // CHECK-LABEL: test_vsriq_n_u64
   return vsriq_n_u64(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 poly8x8_t test_vsri_n_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vsri_n_p8
+  // CHECK-LABEL: test_vsri_n_p8
   return vsri_n_p8(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 poly16x4_t test_vsri_n_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vsri_n_p16
+  // CHECK-LABEL: test_vsri_n_p16
   return vsri_n_p16(a, b, 15);
   // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #15
 }
 
 poly8x16_t test_vsriq_n_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vsriq_n_p8
+  // CHECK-LABEL: test_vsriq_n_p8
   return vsriq_n_p8(a, b, 3);
   // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 poly16x8_t test_vsriq_n_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vsriq_n_p16
+  // CHECK-LABEL: test_vsriq_n_p16
   return vsriq_n_p16(a, b, 15);
   // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #15
 }
 
 int8x8_t test_vsli_n_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vsli_n_s8
+  // CHECK-LABEL: test_vsli_n_s8
   return vsli_n_s8(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vsli_n_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vsli_n_s16
+  // CHECK-LABEL: test_vsli_n_s16
   return vsli_n_s16(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vsli_n_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vsli_n_s32
+  // CHECK-LABEL: test_vsli_n_s32
   return vsli_n_s32(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vsliq_n_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vsliq_n_s8
+  // CHECK-LABEL: test_vsliq_n_s8
   return vsliq_n_s8(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vsliq_n_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vsliq_n_s16
+  // CHECK-LABEL: test_vsliq_n_s16
   return vsliq_n_s16(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vsliq_n_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vsliq_n_s32
+  // CHECK-LABEL: test_vsliq_n_s32
   return vsliq_n_s32(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vsliq_n_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vsliq_n_s64
+  // CHECK-LABEL: test_vsliq_n_s64
   return vsliq_n_s64(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 uint8x8_t test_vsli_n_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vsli_n_u8
+  // CHECK-LABEL: test_vsli_n_u8
   return vsli_n_u8(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 uint16x4_t test_vsli_n_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vsli_n_u16
+  // CHECK-LABEL: test_vsli_n_u16
   return vsli_n_u16(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 uint32x2_t test_vsli_n_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vsli_n_u32
+  // CHECK-LABEL: test_vsli_n_u32
   return vsli_n_u32(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 uint8x16_t test_vsliq_n_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vsliq_n_u8
+  // CHECK-LABEL: test_vsliq_n_u8
   return vsliq_n_u8(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 uint16x8_t test_vsliq_n_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vsliq_n_u16
+  // CHECK-LABEL: test_vsliq_n_u16
   return vsliq_n_u16(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 uint32x4_t test_vsliq_n_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vsliq_n_u32
+  // CHECK-LABEL: test_vsliq_n_u32
   return vsliq_n_u32(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 uint64x2_t test_vsliq_n_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vsliq_n_u64
+  // CHECK-LABEL: test_vsliq_n_u64
   return vsliq_n_u64(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 poly8x8_t test_vsli_n_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vsli_n_p8
+  // CHECK-LABEL: test_vsli_n_p8
   return vsli_n_p8(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 poly16x4_t test_vsli_n_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vsli_n_p16
+  // CHECK-LABEL: test_vsli_n_p16
   return vsli_n_p16(a, b, 15);
   // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #15
 }
 
 poly8x16_t test_vsliq_n_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vsliq_n_p8
+  // CHECK-LABEL: test_vsliq_n_p8
   return vsliq_n_p8(a, b, 3);
   // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 poly16x8_t test_vsliq_n_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vsliq_n_p16
+  // CHECK-LABEL: test_vsliq_n_p16
   return vsliq_n_p16(a, b, 15);
   // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #15
 }
 
 int8x8_t test_vqshlu_n_s8(int8x8_t a) {
-  // CHECK: test_vqshlu_n_s8
+  // CHECK-LABEL: test_vqshlu_n_s8
   return vqshlu_n_s8(a, 3);
   // CHECK: sqshlu {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3
 }
 
 int16x4_t test_vqshlu_n_s16(int16x4_t a) {
-  // CHECK: test_vqshlu_n_s16
+  // CHECK-LABEL: test_vqshlu_n_s16
   return vqshlu_n_s16(a, 3);
   // CHECK: sqshlu {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3
 }
 
 int32x2_t test_vqshlu_n_s32(int32x2_t a) {
-  // CHECK: test_vqshlu_n_s32
+  // CHECK-LABEL: test_vqshlu_n_s32
   return vqshlu_n_s32(a, 3);
   // CHECK: sqshlu {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3
 }
 
 int8x16_t test_vqshluq_n_s8(int8x16_t a) {
-  // CHECK: test_vqshluq_n_s8
+  // CHECK-LABEL: test_vqshluq_n_s8
   return vqshluq_n_s8(a, 3);
   // CHECK: sqshlu {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3
 }
 
 int16x8_t test_vqshluq_n_s16(int16x8_t a) {
-  // CHECK: test_vqshluq_n_s16
+  // CHECK-LABEL: test_vqshluq_n_s16
   return vqshluq_n_s16(a, 3);
   // CHECK: sqshlu {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3
 }
 
 int32x4_t test_vqshluq_n_s32(int32x4_t a) {
-  // CHECK: test_vqshluq_n_s32
+  // CHECK-LABEL: test_vqshluq_n_s32
   return vqshluq_n_s32(a, 3);
   // CHECK: sqshlu {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3
 }
 
 int64x2_t test_vqshluq_n_s64(int64x2_t a) {
-  // CHECK: test_vqshluq_n_s64
+  // CHECK-LABEL: test_vqshluq_n_s64
   return vqshluq_n_s64(a, 3);
   // CHECK: sqshlu {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3
 }
 
 int8x8_t test_vshrn_n_s16(int16x8_t a) {
-  // CHECK: test_vshrn_n_s16
+  // CHECK-LABEL: test_vshrn_n_s16
   return vshrn_n_s16(a, 3);
   // CHECK: shrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 int16x4_t test_vshrn_n_s32(int32x4_t a) {
-  // CHECK: test_vshrn_n_s32
+  // CHECK-LABEL: test_vshrn_n_s32
   return vshrn_n_s32(a, 9);
   // CHECK: shrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 int32x2_t test_vshrn_n_s64(int64x2_t a) {
-  // CHECK: test_vshrn_n_s64
+  // CHECK-LABEL: test_vshrn_n_s64
   return vshrn_n_s64(a, 19);
   // CHECK: shrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 uint8x8_t test_vshrn_n_u16(uint16x8_t a) {
-  // CHECK: test_vshrn_n_u16
+  // CHECK-LABEL: test_vshrn_n_u16
   return vshrn_n_u16(a, 3);
   // CHECK: shrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 uint16x4_t test_vshrn_n_u32(uint32x4_t a) {
-  // CHECK: test_vshrn_n_u32
+  // CHECK-LABEL: test_vshrn_n_u32
   return vshrn_n_u32(a, 9);
   // CHECK: shrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 uint32x2_t test_vshrn_n_u64(uint64x2_t a) {
-  // CHECK: test_vshrn_n_u64
+  // CHECK-LABEL: test_vshrn_n_u64
   return vshrn_n_u64(a, 19);
   // CHECK: shrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 int8x16_t test_vshrn_high_n_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vshrn_high_n_s16
+  // CHECK-LABEL: test_vshrn_high_n_s16
   return vshrn_high_n_s16(a, b, 3);
   // CHECK: shrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 int16x8_t test_vshrn_high_n_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vshrn_high_n_s32
+  // CHECK-LABEL: test_vshrn_high_n_s32
   return vshrn_high_n_s32(a, b, 9);
   // CHECK: shrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 int32x4_t test_vshrn_high_n_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vshrn_high_n_s64
+  // CHECK-LABEL: test_vshrn_high_n_s64
   return vshrn_high_n_s64(a, b, 19);
   // CHECK: shrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 uint8x16_t test_vshrn_high_n_u16(uint8x8_t a, uint16x8_t b) {
-  // CHECK: test_vshrn_high_n_u16
+  // CHECK-LABEL: test_vshrn_high_n_u16
   return vshrn_high_n_u16(a, b, 3);
   // CHECK: shrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 uint16x8_t test_vshrn_high_n_u32(uint16x4_t a, uint32x4_t b) {
-  // CHECK: test_vshrn_high_n_u32
+  // CHECK-LABEL: test_vshrn_high_n_u32
   return vshrn_high_n_u32(a, b, 9);
   // CHECK: shrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 uint32x4_t test_vshrn_high_n_u64(uint32x2_t a, uint64x2_t b) {
-  // CHECK: test_vshrn_high_n_u64
+  // CHECK-LABEL: test_vshrn_high_n_u64
   return vshrn_high_n_u64(a, b, 19);
   // CHECK: shrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 int8x8_t test_vqshrun_n_s16(int16x8_t a) {
-  // CHECK: test_vqshrun_n_s16
+  // CHECK-LABEL: test_vqshrun_n_s16
   return vqshrun_n_s16(a, 3);
   // CHECK: sqshrun {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 int16x4_t test_vqshrun_n_s32(int32x4_t a) {
-  // CHECK: test_vqshrun_n_s32
+  // CHECK-LABEL: test_vqshrun_n_s32
   return vqshrun_n_s32(a, 9);
   // CHECK: sqshrun {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 int32x2_t test_vqshrun_n_s64(int64x2_t a) {
-  // CHECK: test_vqshrun_n_s64
+  // CHECK-LABEL: test_vqshrun_n_s64
   return vqshrun_n_s64(a, 19);
   // CHECK: sqshrun {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 int8x16_t test_vqshrun_high_n_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vqshrun_high_n_s16
+  // CHECK-LABEL: test_vqshrun_high_n_s16
   return vqshrun_high_n_s16(a, b, 3);
   // CHECK: sqshrun2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 int16x8_t test_vqshrun_high_n_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vqshrun_high_n_s32
+  // CHECK-LABEL: test_vqshrun_high_n_s32
   return vqshrun_high_n_s32(a, b, 9);
   // CHECK: sqshrun2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 int32x4_t test_vqshrun_high_n_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vqshrun_high_n_s64
+  // CHECK-LABEL: test_vqshrun_high_n_s64
   return vqshrun_high_n_s64(a, b, 19);
   // CHECK: sqshrun2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 int8x8_t test_vrshrn_n_s16(int16x8_t a) {
-  // CHECK: test_vrshrn_n_s16
+  // CHECK-LABEL: test_vrshrn_n_s16
   return vrshrn_n_s16(a, 3);
   // CHECK: rshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 int16x4_t test_vrshrn_n_s32(int32x4_t a) {
-  // CHECK: test_vrshrn_n_s32
+  // CHECK-LABEL: test_vrshrn_n_s32
   return vrshrn_n_s32(a, 9);
   // CHECK: rshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 int32x2_t test_vrshrn_n_s64(int64x2_t a) {
-  // CHECK: test_vrshrn_n_s64
+  // CHECK-LABEL: test_vrshrn_n_s64
   return vrshrn_n_s64(a, 19);
   // CHECK: rshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 uint8x8_t test_vrshrn_n_u16(uint16x8_t a) {
-  // CHECK: test_vrshrn_n_u16
+  // CHECK-LABEL: test_vrshrn_n_u16
   return vrshrn_n_u16(a, 3);
   // CHECK: rshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 uint16x4_t test_vrshrn_n_u32(uint32x4_t a) {
-  // CHECK: test_vrshrn_n_u32
+  // CHECK-LABEL: test_vrshrn_n_u32
   return vrshrn_n_u32(a, 9);
   // CHECK: rshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 uint32x2_t test_vrshrn_n_u64(uint64x2_t a) {
-  // CHECK: test_vrshrn_n_u64
+  // CHECK-LABEL: test_vrshrn_n_u64
   return vrshrn_n_u64(a, 19);
   // CHECK: rshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 int8x16_t test_vrshrn_high_n_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vrshrn_high_n_s16
+  // CHECK-LABEL: test_vrshrn_high_n_s16
   return vrshrn_high_n_s16(a, b, 3);
   // CHECK: rshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 int16x8_t test_vrshrn_high_n_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vrshrn_high_n_s32
+  // CHECK-LABEL: test_vrshrn_high_n_s32
   return vrshrn_high_n_s32(a, b, 9);
   // CHECK: rshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 int32x4_t test_vrshrn_high_n_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vrshrn_high_n_s64
+  // CHECK-LABEL: test_vrshrn_high_n_s64
   return vrshrn_high_n_s64(a, b, 19);
   // CHECK: rshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 uint8x16_t test_vrshrn_high_n_u16(uint8x8_t a, uint16x8_t b) {
-  // CHECK: test_vrshrn_high_n_u16
+  // CHECK-LABEL: test_vrshrn_high_n_u16
   return vrshrn_high_n_u16(a, b, 3);
   // CHECK: rshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 uint16x8_t test_vrshrn_high_n_u32(uint16x4_t a, uint32x4_t b) {
-  // CHECK: test_vrshrn_high_n_u32
+  // CHECK-LABEL: test_vrshrn_high_n_u32
   return vrshrn_high_n_u32(a, b, 9);
   // CHECK: rshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 uint32x4_t test_vrshrn_high_n_u64(uint32x2_t a, uint64x2_t b) {
-  // CHECK: test_vrshrn_high_n_u64
+  // CHECK-LABEL: test_vrshrn_high_n_u64
   return vrshrn_high_n_u64(a, b, 19);
   // CHECK: rshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 int8x8_t test_vqrshrun_n_s16(int16x8_t a) {
-  // CHECK: test_vqrshrun_n_s16
+  // CHECK-LABEL: test_vqrshrun_n_s16
   return vqrshrun_n_s16(a, 3);
   // CHECK: sqrshrun {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 int16x4_t test_vqrshrun_n_s32(int32x4_t a) {
-  // CHECK: test_vqrshrun_n_s32
+  // CHECK-LABEL: test_vqrshrun_n_s32
   return vqrshrun_n_s32(a, 9);
   // CHECK: sqrshrun {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 int32x2_t test_vqrshrun_n_s64(int64x2_t a) {
-  // CHECK: test_vqrshrun_n_s64
+  // CHECK-LABEL: test_vqrshrun_n_s64
   return vqrshrun_n_s64(a, 19);
   // CHECK: sqrshrun {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 int8x16_t test_vqrshrun_high_n_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vqrshrun_high_n_s16
+  // CHECK-LABEL: test_vqrshrun_high_n_s16
   return vqrshrun_high_n_s16(a, b, 3);
   // CHECK: sqrshrun2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 int16x8_t test_vqrshrun_high_n_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vqrshrun_high_n_s32
+  // CHECK-LABEL: test_vqrshrun_high_n_s32
   return vqrshrun_high_n_s32(a, b, 9);
   // CHECK: sqrshrun2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 int32x4_t test_vqrshrun_high_n_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vqrshrun_high_n_s64
+  // CHECK-LABEL: test_vqrshrun_high_n_s64
   return vqrshrun_high_n_s64(a, b, 19);
   // CHECK: sqrshrun2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 int8x8_t test_vqshrn_n_s16(int16x8_t a) {
-  // CHECK: test_vqshrn_n_s16
+  // CHECK-LABEL: test_vqshrn_n_s16
   return vqshrn_n_s16(a, 3);
   // CHECK: sqshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 int16x4_t test_vqshrn_n_s32(int32x4_t a) {
-  // CHECK: test_vqshrn_n_s32
+  // CHECK-LABEL: test_vqshrn_n_s32
   return vqshrn_n_s32(a, 9);
   // CHECK: sqshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 int32x2_t test_vqshrn_n_s64(int64x2_t a) {
-  // CHECK: test_vqshrn_n_s64
+  // CHECK-LABEL: test_vqshrn_n_s64
   return vqshrn_n_s64(a, 19);
   // CHECK: sqshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 uint8x8_t test_vqshrn_n_u16(uint16x8_t a) {
-  // CHECK: test_vqshrn_n_u16
+  // CHECK-LABEL: test_vqshrn_n_u16
   return vqshrn_n_u16(a, 3);
   // CHECK: uqshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 uint16x4_t test_vqshrn_n_u32(uint32x4_t a) {
-  // CHECK: test_vqshrn_n_u32
+  // CHECK-LABEL: test_vqshrn_n_u32
   return vqshrn_n_u32(a, 9);
   // CHECK: uqshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 uint32x2_t test_vqshrn_n_u64(uint64x2_t a) {
-  // CHECK: test_vqshrn_n_u64
+  // CHECK-LABEL: test_vqshrn_n_u64
   return vqshrn_n_u64(a, 19);
   // CHECK: uqshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 int8x16_t test_vqshrn_high_n_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vqshrn_high_n_s16
+  // CHECK-LABEL: test_vqshrn_high_n_s16
   return vqshrn_high_n_s16(a, b, 3);
   // CHECK: sqshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 int16x8_t test_vqshrn_high_n_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vqshrn_high_n_s32
+  // CHECK-LABEL: test_vqshrn_high_n_s32
   return vqshrn_high_n_s32(a, b, 9);
   // CHECK: sqshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 int32x4_t test_vqshrn_high_n_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vqshrn_high_n_s64
+  // CHECK-LABEL: test_vqshrn_high_n_s64
   return vqshrn_high_n_s64(a, b, 19);
   // CHECK: sqshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 uint8x16_t test_vqshrn_high_n_u16(uint8x8_t a, uint16x8_t b) {
-  // CHECK: test_vqshrn_high_n_u16
+  // CHECK-LABEL: test_vqshrn_high_n_u16
   return vqshrn_high_n_u16(a, b, 3);
   // CHECK: uqshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 uint16x8_t test_vqshrn_high_n_u32(uint16x4_t a, uint32x4_t b) {
-  // CHECK: test_vqshrn_high_n_u32
+  // CHECK-LABEL: test_vqshrn_high_n_u32
   return vqshrn_high_n_u32(a, b, 9);
   // CHECK: uqshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 uint32x4_t test_vqshrn_high_n_u64(uint32x2_t a, uint64x2_t b) {
-  // CHECK: test_vqshrn_high_n_u64
+  // CHECK-LABEL: test_vqshrn_high_n_u64
   return vqshrn_high_n_u64(a, b, 19);
   // CHECK: uqshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 int8x8_t test_vqrshrn_n_s16(int16x8_t a) {
-  // CHECK: test_vqrshrn_n_s16
+  // CHECK-LABEL: test_vqrshrn_n_s16
   return vqrshrn_n_s16(a, 3);
   // CHECK: sqrshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 int16x4_t test_vqrshrn_n_s32(int32x4_t a) {
-  // CHECK: test_vqrshrn_n_s32
+  // CHECK-LABEL: test_vqrshrn_n_s32
   return vqrshrn_n_s32(a, 9);
   // CHECK: sqrshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 int32x2_t test_vqrshrn_n_s64(int64x2_t a) {
-  // CHECK: test_vqrshrn_n_s64
+  // CHECK-LABEL: test_vqrshrn_n_s64
   return vqrshrn_n_s64(a, 19);
   // CHECK: sqrshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 uint8x8_t test_vqrshrn_n_u16(uint16x8_t a) {
-  // CHECK: test_vqrshrn_n_u16
+  // CHECK-LABEL: test_vqrshrn_n_u16
   return vqrshrn_n_u16(a, 3);
   // CHECK: uqrshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3
 }
 
 uint16x4_t test_vqrshrn_n_u32(uint32x4_t a) {
-  // CHECK: test_vqrshrn_n_u32
+  // CHECK-LABEL: test_vqrshrn_n_u32
   return vqrshrn_n_u32(a, 9);
   // CHECK: uqrshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9
 }
 
 uint32x2_t test_vqrshrn_n_u64(uint64x2_t a) {
-  // CHECK: test_vqrshrn_n_u64
+  // CHECK-LABEL: test_vqrshrn_n_u64
   return vqrshrn_n_u64(a, 19);
   // CHECK: uqrshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19
 }
 
 int8x16_t test_vqrshrn_high_n_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vqrshrn_high_n_s16
+  // CHECK-LABEL: test_vqrshrn_high_n_s16
   return vqrshrn_high_n_s16(a, b, 3);
   // CHECK: sqrshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 int16x8_t test_vqrshrn_high_n_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vqrshrn_high_n_s32
+  // CHECK-LABEL: test_vqrshrn_high_n_s32
   return vqrshrn_high_n_s32(a, b, 9);
   // CHECK: sqrshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 int32x4_t test_vqrshrn_high_n_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vqrshrn_high_n_s64
+  // CHECK-LABEL: test_vqrshrn_high_n_s64
   return vqrshrn_high_n_s64(a, b, 19);
   // CHECK: sqrshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 uint8x16_t test_vqrshrn_high_n_u16(uint8x8_t a, uint16x8_t b) {
-  // CHECK: test_vqrshrn_high_n_u16
+  // CHECK-LABEL: test_vqrshrn_high_n_u16
   return vqrshrn_high_n_u16(a, b, 3);
   // CHECK: uqrshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3
 }
 
 uint16x8_t test_vqrshrn_high_n_u32(uint16x4_t a, uint32x4_t b) {
-  // CHECK: test_vqrshrn_high_n_u32
+  // CHECK-LABEL: test_vqrshrn_high_n_u32
   return vqrshrn_high_n_u32(a, b, 9);
   // CHECK: uqrshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9
 }
 
 uint32x4_t test_vqrshrn_high_n_u64(uint32x2_t a, uint64x2_t b) {
-  // CHECK: test_vqrshrn_high_n_u64
+  // CHECK-LABEL: test_vqrshrn_high_n_u64
   return vqrshrn_high_n_u64(a, b, 19);
   // CHECK: uqrshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19
 }
 
 int16x8_t test_vshll_n_s8(int8x8_t a) {
-// CHECK: test_vshll_n_s8
+// CHECK-LABEL: test_vshll_n_s8
   return vshll_n_s8(a, 3);
 // CHECK: sshll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #3
 }
 
 int32x4_t test_vshll_n_s16(int16x4_t a) {
-// CHECK: test_vshll_n_s16
+// CHECK-LABEL: test_vshll_n_s16
   return vshll_n_s16(a, 9);
 // CHECK: sshll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #9
 }
 
 int64x2_t test_vshll_n_s32(int32x2_t a) {
-// CHECK: test_vshll_n_s32
+// CHECK-LABEL: test_vshll_n_s32
   return vshll_n_s32(a, 19);
 // CHECK: sshll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #19
 }
 
 uint16x8_t test_vshll_n_u8(uint8x8_t a) {
-// CHECK: test_vshll_n_u8
+// CHECK-LABEL: test_vshll_n_u8
   return vshll_n_u8(a, 3);
 // CHECK: ushll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #3
 }
 
 uint32x4_t test_vshll_n_u16(uint16x4_t a) {
-// CHECK: test_vshll_n_u16
+// CHECK-LABEL: test_vshll_n_u16
   return vshll_n_u16(a, 9);
 // CHECK: ushll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #9
 }
 
 uint64x2_t test_vshll_n_u32(uint32x2_t a) {
-// CHECK: test_vshll_n_u32
+// CHECK-LABEL: test_vshll_n_u32
   return vshll_n_u32(a, 19);
 // CHECK: ushll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #19
 }
 
 int16x8_t test_vshll_high_n_s8(int8x16_t a) {
-// CHECK: test_vshll_high_n_s8
+// CHECK-LABEL: test_vshll_high_n_s8
   return vshll_high_n_s8(a, 3);
 // CHECK: sshll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #3
 }
 
 int32x4_t test_vshll_high_n_s16(int16x8_t a) {
-// CHECK: test_vshll_high_n_s16
+// CHECK-LABEL: test_vshll_high_n_s16
   return vshll_high_n_s16(a, 9);
 // CHECK: sshll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #9
 }
 
 int64x2_t test_vshll_high_n_s32(int32x4_t a) {
-// CHECK: test_vshll_high_n_s32
+// CHECK-LABEL: test_vshll_high_n_s32
   return vshll_high_n_s32(a, 19);
 // CHECK: sshll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #19
 }
 
 uint16x8_t test_vshll_high_n_u8(uint8x16_t a) {
-// CHECK: test_vshll_high_n_u8
+// CHECK-LABEL: test_vshll_high_n_u8
   return vshll_high_n_u8(a, 3);
 // CHECK: ushll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #3
 }
 
 uint32x4_t test_vshll_high_n_u16(uint16x8_t a) {
-// CHECK: test_vshll_high_n_u16
+// CHECK-LABEL: test_vshll_high_n_u16
   return vshll_high_n_u16(a, 9);
 // CHECK: ushll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #9
 }
 
 uint64x2_t test_vshll_high_n_u32(uint32x4_t a) {
-// CHECK: test_vshll_high_n_u32
+// CHECK-LABEL: test_vshll_high_n_u32
   return vshll_high_n_u32(a, 19);
 // CHECK: ushll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #19
 }
 
 int16x8_t test_vmovl_s8(int8x8_t a) {
-// CHECK: test_vmovl_s8
+// CHECK-LABEL: test_vmovl_s8
   return vmovl_s8(a);
 // CHECK: sshll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #0
 }
 
 int32x4_t test_vmovl_s16(int16x4_t a) {
-// CHECK: test_vmovl_s16
+// CHECK-LABEL: test_vmovl_s16
   return vmovl_s16(a);
 // CHECK: sshll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #0
 }
 
 int64x2_t test_vmovl_s32(int32x2_t a) {
-// CHECK: test_vmovl_s32
+// CHECK-LABEL: test_vmovl_s32
   return vmovl_s32(a);
 // CHECK: sshll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #0
 }
 
 uint16x8_t test_vmovl_u8(uint8x8_t a) {
-// CHECK: test_vmovl_u8
+// CHECK-LABEL: test_vmovl_u8
   return vmovl_u8(a);
 // CHECK: ushll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #0
 }
 
 uint32x4_t test_vmovl_u16(uint16x4_t a) {
-// CHECK: test_vmovl_u16
+// CHECK-LABEL: test_vmovl_u16
   return vmovl_u16(a);
 // CHECK: ushll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #0
 }
 
 uint64x2_t test_vmovl_u32(uint32x2_t a) {
-// CHECK: test_vmovl_u32
+// CHECK-LABEL: test_vmovl_u32
   return vmovl_u32(a);
 // CHECK: ushll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #0
 }
 
 int16x8_t test_vmovl_high_s8(int8x16_t a) {
-// CHECK: test_vmovl_high_s8
+// CHECK-LABEL: test_vmovl_high_s8
   return vmovl_high_s8(a);
 // CHECK: sshll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #0
 }
 
 int32x4_t test_vmovl_high_s16(int16x8_t a) {
-// CHECK: test_vmovl_high_s16
+// CHECK-LABEL: test_vmovl_high_s16
   return vmovl_high_s16(a);
 // CHECK: sshll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #0
 }
 
 int64x2_t test_vmovl_high_s32(int32x4_t a) {
-// CHECK: test_vmovl_high_s32
+// CHECK-LABEL: test_vmovl_high_s32
   return vmovl_high_s32(a);
 // CHECK: sshll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #0
 }
 
 uint16x8_t test_vmovl_high_u8(uint8x16_t a) {
-// CHECK: test_vmovl_high_u8
+// CHECK-LABEL: test_vmovl_high_u8
   return vmovl_high_u8(a);
 // CHECK: ushll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #0
 }
 
 uint32x4_t test_vmovl_high_u16(uint16x8_t a) {
-// CHECK: test_vmovl_high_u16
+// CHECK-LABEL: test_vmovl_high_u16
   return vmovl_high_u16(a);
 // CHECK: ushll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #0
 }
 
 uint64x2_t test_vmovl_high_u32(uint32x4_t a) {
-// CHECK: test_vmovl_high_u32
+// CHECK-LABEL: test_vmovl_high_u32
   return vmovl_high_u32(a);
 // CHECK: ushll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #0
 }
 
 float32x2_t test_vcvt_n_f32_s32(int32x2_t a) {
-  // CHECK: test_vcvt_n_f32_s32
+  // CHECK-LABEL: test_vcvt_n_f32_s32
   return vcvt_n_f32_s32(a, 31);
   // CHECK: scvtf {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
 }
 
 float32x4_t test_vcvtq_n_f32_s32(int32x4_t a) {
-  // CHECK: test_vcvtq_n_f32_s32
+  // CHECK-LABEL: test_vcvtq_n_f32_s32
   return vcvtq_n_f32_s32(a, 31);
   // CHECK: scvtf {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
 }
 
 float64x2_t test_vcvtq_n_f64_s64(int64x2_t a) {
-  // CHECK: test_vcvtq_n_f64_s64
+  // CHECK-LABEL: test_vcvtq_n_f64_s64
   return vcvtq_n_f64_s64(a, 50);
   // CHECK: scvtf {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50
 }
 
 float32x2_t test_vcvt_n_f32_u32(uint32x2_t a) {
-  // CHECK: test_vcvt_n_f32_u32
+  // CHECK-LABEL: test_vcvt_n_f32_u32
   return vcvt_n_f32_u32(a, 31);
   // CHECK: ucvtf {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
 }
 
 float32x4_t test_vcvtq_n_f32_u32(uint32x4_t a) {
-  // CHECK: test_vcvtq_n_f32_u32
+  // CHECK-LABEL: test_vcvtq_n_f32_u32
   return vcvtq_n_f32_u32(a, 31);
   // CHECK: ucvtf {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
 }
 
 float64x2_t test_vcvtq_n_f64_u64(uint64x2_t a) {
-  // CHECK: test_vcvtq_n_f64_u64
+  // CHECK-LABEL: test_vcvtq_n_f64_u64
   return vcvtq_n_f64_u64(a, 50);
   // CHECK: ucvtf {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50
 }
 
 int32x2_t test_vcvt_n_s32_f32(float32x2_t a) {
-  // CHECK: test_vcvt_n_s32_f32
+  // CHECK-LABEL: test_vcvt_n_s32_f32
   return vcvt_n_s32_f32(a, 31);
   // CHECK: fcvtzs {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
 }
 
 int32x4_t test_vcvtq_n_s32_f32(float32x4_t a) {
-  // CHECK: test_vcvtq_n_s32_f32
+  // CHECK-LABEL: test_vcvtq_n_s32_f32
   return vcvtq_n_s32_f32(a, 31);
   // CHECK: fcvtzs {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
 }
 
 int64x2_t test_vcvtq_n_s64_f64(float64x2_t a) {
-  // CHECK: test_vcvtq_n_s64_f64
+  // CHECK-LABEL: test_vcvtq_n_s64_f64
   return vcvtq_n_s64_f64(a, 50);
   // CHECK: fcvtzs {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50
 }
 
 uint32x2_t test_vcvt_n_u32_f32(float32x2_t a) {
-  // CHECK: test_vcvt_n_u32_f32
+  // CHECK-LABEL: test_vcvt_n_u32_f32
   return vcvt_n_u32_f32(a, 31);
   // CHECK: fcvtzu {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
 }
 
 uint32x4_t test_vcvtq_n_u32_f32(float32x4_t a) {
-  // CHECK: test_vcvt_n_u32_f32
+  // CHECK-LABEL: test_vcvtq_n_u32_f32
   return vcvtq_n_u32_f32(a, 31);
   // CHECK: fcvtzu {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
 }
 
 uint64x2_t test_vcvtq_n_u64_f64(float64x2_t a) {
-  // CHECK: test_vcvtq_n_u64_f64
+  // CHECK-LABEL: test_vcvtq_n_u64_f64
   return vcvtq_n_u64_f64(a, 50);
   // CHECK: fcvtzu {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50
 }
 
 int16x8_t test_vaddl_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vaddl_s8
+  // CHECK-LABEL: test_vaddl_s8
   return vaddl_s8(a, b);
   // CHECK: saddl {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int32x4_t test_vaddl_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vaddl_s16
+  // CHECK-LABEL: test_vaddl_s16
   return vaddl_s16(a, b);
   // CHECK: saddl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int64x2_t test_vaddl_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vaddl_s32
+  // CHECK-LABEL: test_vaddl_s32
   return vaddl_s32(a, b);
   // CHECK: saddl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint16x8_t test_vaddl_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vaddl_u8
+  // CHECK-LABEL: test_vaddl_u8
   return vaddl_u8(a, b);
   // CHECK: uaddl {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint32x4_t test_vaddl_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vaddl_u16
+  // CHECK-LABEL: test_vaddl_u16
   return vaddl_u16(a, b);
   // CHECK: uaddl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint64x2_t test_vaddl_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vaddl_u32
+  // CHECK-LABEL: test_vaddl_u32
   return vaddl_u32(a, b);
   // CHECK: uaddl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vaddl_high_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vaddl_high_s8
+  // CHECK-LABEL: test_vaddl_high_s8
   return vaddl_high_s8(a, b);
   // CHECK: saddl2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int32x4_t test_vaddl_high_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vaddl_high_s16
+  // CHECK-LABEL: test_vaddl_high_s16
   return vaddl_high_s16(a, b);
   // CHECK: saddl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int64x2_t test_vaddl_high_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vaddl_high_s32
+  // CHECK-LABEL: test_vaddl_high_s32
   return vaddl_high_s32(a, b);
   // CHECK: saddl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint16x8_t test_vaddl_high_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vaddl_high_u8
+  // CHECK-LABEL: test_vaddl_high_u8
   return vaddl_high_u8(a, b);
   // CHECK: uaddl2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint32x4_t test_vaddl_high_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vaddl_high_u16
+  // CHECK-LABEL: test_vaddl_high_u16
   return vaddl_high_u16(a, b);
   // CHECK: uaddl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint64x2_t test_vaddl_high_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vaddl_high_u32
+  // CHECK-LABEL: test_vaddl_high_u32
   return vaddl_high_u32(a, b);
   // CHECK: uaddl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int16x8_t test_vaddw_s8(int16x8_t a, int8x8_t b) {
-  // CHECK: test_vaddw_s8
+  // CHECK-LABEL: test_vaddw_s8
   return vaddw_s8(a, b);
   // CHECK: saddw {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8b
 }
 
 int32x4_t test_vaddw_s16(int32x4_t a, int16x4_t b) {
-  // CHECK: test_vaddw_s16
+  // CHECK-LABEL: test_vaddw_s16
   return vaddw_s16(a, b);
   // CHECK: saddw {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4h
 }
 
 int64x2_t test_vaddw_s32(int64x2_t a, int32x2_t b) {
-  // CHECK: test_vaddw_s32
+  // CHECK-LABEL: test_vaddw_s32
   return vaddw_s32(a, b);
   // CHECK: saddw {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2s
 }
 
 uint16x8_t test_vaddw_u8(uint16x8_t a, uint8x8_t b) {
-  // CHECK: test_vaddw_u8
+  // CHECK-LABEL: test_vaddw_u8
   return vaddw_u8(a, b);
   // CHECK: uaddw {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8b
 }
 
 uint32x4_t test_vaddw_u16(uint32x4_t a, uint16x4_t b) {
-  // CHECK: test_vaddw_u16
+  // CHECK-LABEL: test_vaddw_u16
   return vaddw_u16(a, b);
   // CHECK: uaddw {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4h
 }
 
 uint64x2_t test_vaddw_u32(uint64x2_t a, uint32x2_t b) {
-  // CHECK: test_vaddw_u32
+  // CHECK-LABEL: test_vaddw_u32
   return vaddw_u32(a, b);
   // CHECK: uaddw {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vaddw_high_s8(int16x8_t a, int8x16_t b) {
-  // CHECK: test_vaddw_high_s8
+  // CHECK-LABEL: test_vaddw_high_s8
   return vaddw_high_s8(a, b);
   // CHECK: saddw2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.16b
 }
 
 int32x4_t test_vaddw_high_s16(int32x4_t a, int16x8_t b) {
-  // CHECK: test_vaddw_high_s16
+  // CHECK-LABEL: test_vaddw_high_s16
   return vaddw_high_s16(a, b);
   // CHECK: saddw2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.8h
 }
 
 int64x2_t test_vaddw_high_s32(int64x2_t a, int32x4_t b) {
-  // CHECK: test_vaddw_high_s32
+  // CHECK-LABEL: test_vaddw_high_s32
   return vaddw_high_s32(a, b);
   // CHECK: saddw2 {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.4s
 }
 
 uint16x8_t test_vaddw_high_u8(uint16x8_t a, uint8x16_t b) {
-  // CHECK: test_vaddw_high_u8
+  // CHECK-LABEL: test_vaddw_high_u8
   return vaddw_high_u8(a, b);
   // CHECK: uaddw2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.16b
 }
 
 uint32x4_t test_vaddw_high_u16(uint32x4_t a, uint16x8_t b) {
-  // CHECK: test_vaddw_high_u16
+  // CHECK-LABEL: test_vaddw_high_u16
   return vaddw_high_u16(a, b);
   // CHECK: uaddw2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.8h
 }
 
 uint64x2_t test_vaddw_high_u32(uint64x2_t a, uint32x4_t b) {
-  // CHECK: test_vaddw_high_u32
+  // CHECK-LABEL: test_vaddw_high_u32
   return vaddw_high_u32(a, b);
   // CHECK: uaddw2 {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.4s
 }
 
 int16x8_t test_vsubl_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vsubl_s8
+  // CHECK-LABEL: test_vsubl_s8
   return vsubl_s8(a, b);
   // CHECK: ssubl {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int32x4_t test_vsubl_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vsubl_s16
+  // CHECK-LABEL: test_vsubl_s16
   return vsubl_s16(a, b);
   // CHECK: ssubl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int64x2_t test_vsubl_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vsubl_s32
+  // CHECK-LABEL: test_vsubl_s32
   return vsubl_s32(a, b);
   // CHECK: ssubl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 uint16x8_t test_vsubl_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vsubl_u8
+  // CHECK-LABEL: test_vsubl_u8
   return vsubl_u8(a, b);
   // CHECK: usubl {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint32x4_t test_vsubl_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vsubl_u16
+  // CHECK-LABEL: test_vsubl_u16
   return vsubl_u16(a, b);
   // CHECK: usubl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint64x2_t test_vsubl_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vsubl_u32
+  // CHECK-LABEL: test_vsubl_u32
   return vsubl_u32(a, b);
   // CHECK: usubl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vsubl_high_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vsubl_high_s8
+  // CHECK-LABEL: test_vsubl_high_s8
   return vsubl_high_s8(a, b);
   // CHECK: ssubl2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int32x4_t test_vsubl_high_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vsubl_high_s16
+  // CHECK-LABEL: test_vsubl_high_s16
   return vsubl_high_s16(a, b);
   // CHECK: ssubl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int64x2_t test_vsubl_high_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vsubl_high_s32
+  // CHECK-LABEL: test_vsubl_high_s32
   return vsubl_high_s32(a, b);
   // CHECK: ssubl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint16x8_t test_vsubl_high_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vsubl_high_u8
+  // CHECK-LABEL: test_vsubl_high_u8
   return vsubl_high_u8(a, b);
   // CHECK: usubl2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint32x4_t test_vsubl_high_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vsubl_high_u16
+  // CHECK-LABEL: test_vsubl_high_u16
   return vsubl_high_u16(a, b);
   // CHECK: usubl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint64x2_t test_vsubl_high_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vsubl_high_u32
+  // CHECK-LABEL: test_vsubl_high_u32
   return vsubl_high_u32(a, b);
   // CHECK: usubl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int16x8_t test_vsubw_s8(int16x8_t a, int8x8_t b) {
-  // CHECK: test_vsubw_s8
+  // CHECK-LABEL: test_vsubw_s8
   return vsubw_s8(a, b);
   // CHECK: ssubw {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8b
 }
 
 int32x4_t test_vsubw_s16(int32x4_t a, int16x4_t b) {
-  // CHECK: test_vsubw_s16
+  // CHECK-LABEL: test_vsubw_s16
   return vsubw_s16(a, b);
   // CHECK: ssubw {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4h
 }
 
 int64x2_t test_vsubw_s32(int64x2_t a, int32x2_t b) {
-  // CHECK: test_vsubw_s32
+  // CHECK-LABEL: test_vsubw_s32
   return vsubw_s32(a, b);
   // CHECK: ssubw {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2s
 }
 
 uint16x8_t test_vsubw_u8(uint16x8_t a, uint8x8_t b) {
-  // CHECK: test_vsubw_u8
+  // CHECK-LABEL: test_vsubw_u8
   return vsubw_u8(a, b);
   // CHECK: usubw {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8b
 }
 
 uint32x4_t test_vsubw_u16(uint32x4_t a, uint16x4_t b) {
-  // CHECK: test_vsubw_u16
+  // CHECK-LABEL: test_vsubw_u16
   return vsubw_u16(a, b);
   // CHECK: usubw {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4h
 }
 
 uint64x2_t test_vsubw_u32(uint64x2_t a, uint32x2_t b) {
-  // CHECK: test_vsubw_u32
+  // CHECK-LABEL: test_vsubw_u32
   return vsubw_u32(a, b);
   // CHECK: usubw {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vsubw_high_s8(int16x8_t a, int8x16_t b) {
-  // CHECK: test_vsubw_high_s8
+  // CHECK-LABEL: test_vsubw_high_s8
   return vsubw_high_s8(a, b);
   // CHECK: ssubw2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.16b
 }
 
 int32x4_t test_vsubw_high_s16(int32x4_t a, int16x8_t b) {
-  // CHECK: test_vsubw_high_s16
+  // CHECK-LABEL: test_vsubw_high_s16
   return vsubw_high_s16(a, b);
   // CHECK: ssubw2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.8h
 }
 
 int64x2_t test_vsubw_high_s32(int64x2_t a, int32x4_t b) {
-  // CHECK: test_vsubw_high_s32
+  // CHECK-LABEL: test_vsubw_high_s32
   return vsubw_high_s32(a, b);
   // CHECK: ssubw2 {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.4s
 }
 
 uint16x8_t test_vsubw_high_u8(uint16x8_t a, uint8x16_t b) {
-  // CHECK: test_vsubw_high_u8
+  // CHECK-LABEL: test_vsubw_high_u8
   return vsubw_high_u8(a, b);
   // CHECK: usubw2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.16b
 }
 
 uint32x4_t test_vsubw_high_u16(uint32x4_t a, uint16x8_t b) {
-  // CHECK: test_vsubw_high_u16
+  // CHECK-LABEL: test_vsubw_high_u16
   return vsubw_high_u16(a, b);
   // CHECK: usubw2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.8h
 }
 
 uint64x2_t test_vsubw_high_u32(uint64x2_t a, uint32x4_t b) {
-  // CHECK: test_vsubw_high_u32
+  // CHECK-LABEL: test_vsubw_high_u32
   return vsubw_high_u32(a, b);
   // CHECK: usubw2 {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.4s
 }
 
 int8x8_t test_vaddhn_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vaddhn_s16
+  // CHECK-LABEL: test_vaddhn_s16
   return vaddhn_s16(a, b);
   // CHECK: addhn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int16x4_t test_vaddhn_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vaddhn_s32
+  // CHECK-LABEL: test_vaddhn_s32
   return vaddhn_s32(a, b);
   // CHECK: addhn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x2_t test_vaddhn_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vaddhn_s64
+  // CHECK-LABEL: test_vaddhn_s64
   return vaddhn_s64(a, b);
   // CHECK: addhn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x8_t test_vaddhn_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vaddhn_u16
+  // CHECK-LABEL: test_vaddhn_u16
   return vaddhn_u16(a, b);
   // CHECK: addhn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint16x4_t test_vaddhn_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vaddhn_u32
+  // CHECK-LABEL: test_vaddhn_u32
   return vaddhn_u32(a, b);
   // CHECK: addhn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x2_t test_vaddhn_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vaddhn_u64
+  // CHECK-LABEL: test_vaddhn_u64
   return vaddhn_u64(a, b);
   // CHECK: addhn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x16_t test_vaddhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) {
-  // CHECK: test_vaddhn_high_s16
+  // CHECK-LABEL: test_vaddhn_high_s16
   return vaddhn_high_s16(r, a, b);
   // CHECK: addhn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int16x8_t test_vaddhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) {
-  // CHECK: test_vaddhn_high_s32
+  // CHECK-LABEL: test_vaddhn_high_s32
   return vaddhn_high_s32(r, a, b);
   // CHECK: addhn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x4_t test_vaddhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) {
-  // CHECK: test_vaddhn_high_s64
+  // CHECK-LABEL: test_vaddhn_high_s64
   return vaddhn_high_s64(r, a, b);
   // CHECK: addhn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vaddhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vaddhn_high_u16
+  // CHECK-LABEL: test_vaddhn_high_u16
   return vaddhn_high_u16(r, a, b);
   // CHECK: addhn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint16x8_t test_vaddhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vaddhn_high_u32
+  // CHECK-LABEL: test_vaddhn_high_u32
   return vaddhn_high_u32(r, a, b);
   // CHECK: addhn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x4_t test_vaddhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vaddhn_high_u64
+  // CHECK-LABEL: test_vaddhn_high_u64
   return vaddhn_high_u64(r, a, b);
   // CHECK: addhn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vraddhn_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vraddhn_s16
+  // CHECK-LABEL: test_vraddhn_s16
   return vraddhn_s16(a, b);
   // CHECK: raddhn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int16x4_t test_vraddhn_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vraddhn_s32
+  // CHECK-LABEL: test_vraddhn_s32
   return vraddhn_s32(a, b);
   // CHECK: raddhn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x2_t test_vraddhn_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vraddhn_s64
+  // CHECK-LABEL: test_vraddhn_s64
   return vraddhn_s64(a, b);
   // CHECK: raddhn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x8_t test_vraddhn_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vraddhn_u16
+  // CHECK-LABEL: test_vraddhn_u16
   return vraddhn_u16(a, b);
   // CHECK: raddhn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint16x4_t test_vraddhn_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vraddhn_u32
+  // CHECK-LABEL: test_vraddhn_u32
   return vraddhn_u32(a, b);
   // CHECK: raddhn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x2_t test_vraddhn_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vraddhn_u64
+  // CHECK-LABEL: test_vraddhn_u64
   return vraddhn_u64(a, b);
   // CHECK: raddhn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x16_t test_vraddhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) {
-  // CHECK: test_vraddhn_high_s16
+  // CHECK-LABEL: test_vraddhn_high_s16
   return vraddhn_high_s16(r, a, b);
   // CHECK: raddhn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int16x8_t test_vraddhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) {
-  // CHECK: test_vraddhn_high_s32
+  // CHECK-LABEL: test_vraddhn_high_s32
   return vraddhn_high_s32(r, a, b);
   // CHECK: raddhn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x4_t test_vraddhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) {
-  // CHECK: test_vraddhn_high_s64
+  // CHECK-LABEL: test_vraddhn_high_s64
   return vraddhn_high_s64(r, a, b);
   // CHECK: raddhn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vraddhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vraddhn_high_u16
+  // CHECK-LABEL: test_vraddhn_high_u16
   return vraddhn_high_u16(r, a, b);
   // CHECK: raddhn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint16x8_t test_vraddhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vraddhn_high_u32
+  // CHECK-LABEL: test_vraddhn_high_u32
   return vraddhn_high_u32(r, a, b);
   // CHECK: raddhn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x4_t test_vraddhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vraddhn_high_u64
+  // CHECK-LABEL: test_vraddhn_high_u64
   return vraddhn_high_u64(r, a, b);
   // CHECK: raddhn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vsubhn_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vsubhn_s16
+  // CHECK-LABEL: test_vsubhn_s16
   return vsubhn_s16(a, b);
   // CHECK: subhn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int16x4_t test_vsubhn_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vsubhn_s32
+  // CHECK-LABEL: test_vsubhn_s32
   return vsubhn_s32(a, b);
   // CHECK: subhn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x2_t test_vsubhn_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vsubhn_s64
+  // CHECK-LABEL: test_vsubhn_s64
   return vsubhn_s64(a, b);
   // CHECK: subhn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x8_t test_vsubhn_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vsubhn_u16
+  // CHECK-LABEL: test_vsubhn_u16
   return vsubhn_u16(a, b);
   // CHECK: subhn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint16x4_t test_vsubhn_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vsubhn_u32
+  // CHECK-LABEL: test_vsubhn_u32
   return vsubhn_u32(a, b);
   // CHECK: subhn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x2_t test_vsubhn_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vsubhn_u64
+  // CHECK-LABEL: test_vsubhn_u64
   return vsubhn_u64(a, b);
   // CHECK: subhn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x16_t test_vsubhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) {
-  // CHECK: test_vsubhn_high_s16
+  // CHECK-LABEL: test_vsubhn_high_s16
   return vsubhn_high_s16(r, a, b);
   // CHECK: subhn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int16x8_t test_vsubhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) {
-  // CHECK: test_vsubhn_high_s32
+  // CHECK-LABEL: test_vsubhn_high_s32
   return vsubhn_high_s32(r, a, b);
   // CHECK: subhn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x4_t test_vsubhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) {
-  // CHECK: test_vsubhn_high_s64
+  // CHECK-LABEL: test_vsubhn_high_s64
   return vsubhn_high_s64(r, a, b);
   // CHECK: subhn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vsubhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vsubhn_high_u16
+  // CHECK-LABEL: test_vsubhn_high_u16
   return vsubhn_high_u16(r, a, b);
   // CHECK: subhn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint16x8_t test_vsubhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vsubhn_high_u32
+  // CHECK-LABEL: test_vsubhn_high_u32
   return vsubhn_high_u32(r, a, b);
   // CHECK: subhn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x4_t test_vsubhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vsubhn_high_u64
+  // CHECK-LABEL: test_vsubhn_high_u64
   return vsubhn_high_u64(r, a, b);
   // CHECK: subhn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x8_t test_vrsubhn_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vrsubhn_s16
+  // CHECK-LABEL: test_vrsubhn_s16
   return vrsubhn_s16(a, b);
   // CHECK: rsubhn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int16x4_t test_vrsubhn_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vrsubhn_s32
+  // CHECK-LABEL: test_vrsubhn_s32
   return vrsubhn_s32(a, b);
   // CHECK: rsubhn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x2_t test_vrsubhn_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vrsubhn_s64
+  // CHECK-LABEL: test_vrsubhn_s64
   return vrsubhn_s64(a, b);
   // CHECK: rsubhn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x8_t test_vrsubhn_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vrsubhn_u16
+  // CHECK-LABEL: test_vrsubhn_u16
   return vrsubhn_u16(a, b);
   // CHECK: rsubhn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint16x4_t test_vrsubhn_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vrsubhn_u32
+  // CHECK-LABEL: test_vrsubhn_u32
   return vrsubhn_u32(a, b);
   // CHECK: rsubhn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x2_t test_vrsubhn_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vrsubhn_u64
+  // CHECK-LABEL: test_vrsubhn_u64
   return vrsubhn_u64(a, b);
   // CHECK: rsubhn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int8x16_t test_vrsubhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) {
-  // CHECK: test_vrsubhn_high_s16
+  // CHECK-LABEL: test_vrsubhn_high_s16
   return vrsubhn_high_s16(r, a, b);
   // CHECK: rsubhn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int16x8_t test_vrsubhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) {
-  // CHECK: test_vrsubhn_high_s32
+  // CHECK-LABEL: test_vrsubhn_high_s32
   return vrsubhn_high_s32(r, a, b);
   // CHECK: rsubhn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x4_t test_vrsubhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) {
-  // CHECK: test_vrsubhn_high_s64
+  // CHECK-LABEL: test_vrsubhn_high_s64
   return vrsubhn_high_s64(r, a, b);
   // CHECK: rsubhn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint8x16_t test_vrsubhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vrsubhn_high_u16
+  // CHECK-LABEL: test_vrsubhn_high_u16
   return vrsubhn_high_u16(r, a, b);
   // CHECK: rsubhn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint16x8_t test_vrsubhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vrsubhn_high_u32
+  // CHECK-LABEL: test_vrsubhn_high_u32
   return vrsubhn_high_u32(r, a, b);
   // CHECK: rsubhn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint32x4_t test_vrsubhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vrsubhn_high_u64
+  // CHECK-LABEL: test_vrsubhn_high_u64
   return vrsubhn_high_u64(r, a, b);
   // CHECK: rsubhn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 int16x8_t test_vabdl_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vabdl_s8
+  // CHECK-LABEL: test_vabdl_s8
   return vabdl_s8(a, b);
   // CHECK: sabdl {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 int32x4_t test_vabdl_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vabdl_s16
+  // CHECK-LABEL: test_vabdl_s16
   return vabdl_s16(a, b);
   // CHECK: sabdl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int64x2_t test_vabdl_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vabdl_s32
+  // CHECK-LABEL: test_vabdl_s32
   return vabdl_s32(a, b);
   // CHECK: sabdl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 uint16x8_t test_vabdl_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vabdl_u8
+  // CHECK-LABEL: test_vabdl_u8
   return vabdl_u8(a, b);
   // CHECK: uabdl {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 uint32x4_t test_vabdl_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vabdl_u16
+  // CHECK-LABEL: test_vabdl_u16
   return vabdl_u16(a, b);
   // CHECK: uabdl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 uint64x2_t test_vabdl_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vabdl_u32
+  // CHECK-LABEL: test_vabdl_u32
   return vabdl_u32(a, b);
   // CHECK: uabdl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vabal_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
-  // CHECK: test_vabal_s8
+  // CHECK-LABEL: test_vabal_s8
   return vabal_s8(a, b, c);
   // CHECK: sabal {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 int32x4_t test_vabal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
-  // CHECK: test_vabal_s16
+  // CHECK-LABEL: test_vabal_s16
   return vabal_s16(a, b, c);
   // CHECK: sabal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int64x2_t test_vabal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
-  // CHECK: test_vabal_s32
+  // CHECK-LABEL: test_vabal_s32
   return vabal_s32(a, b, c);
   // CHECK: sabal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 uint16x8_t test_vabal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
-  // CHECK: test_vabal_u8
+  // CHECK-LABEL: test_vabal_u8
   return vabal_u8(a, b, c);
   // CHECK: uabal {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 uint32x4_t test_vabal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
-  // CHECK: test_vabal_u16
+  // CHECK-LABEL: test_vabal_u16
   return vabal_u16(a, b, c);
   // CHECK: uabal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 uint64x2_t test_vabal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
-  // CHECK: test_vabal_u32
+  // CHECK-LABEL: test_vabal_u32
   return vabal_u32(a, b, c);
   // CHECK: uabal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vabdl_high_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vabdl_high_s8
+  // CHECK-LABEL: test_vabdl_high_s8
   return vabdl_high_s8(a, b);
   // CHECK: sabdl2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 int32x4_t test_vabdl_high_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vabdl_high_s16
+  // CHECK-LABEL: test_vabdl_high_s16
   return vabdl_high_s16(a, b);
   // CHECK: sabdl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int64x2_t test_vabdl_high_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vabdl_high_s32
+  // CHECK-LABEL: test_vabdl_high_s32
   return vabdl_high_s32(a, b);
   // CHECK: sabdl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint16x8_t test_vabdl_high_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vabdl_high_u8
+  // CHECK-LABEL: test_vabdl_high_u8
   return vabdl_high_u8(a, b);
   // CHECK: uabdl2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 uint32x4_t test_vabdl_high_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vabdl_high_u16
+  // CHECK-LABEL: test_vabdl_high_u16
   return vabdl_high_u16(a, b);
   // CHECK: uabdl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 uint64x2_t test_vabdl_high_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vabdl_high_u32
+  // CHECK-LABEL: test_vabdl_high_u32
   return vabdl_high_u32(a, b);
   // CHECK: uabdl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int16x8_t test_vabal_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) {
-  // CHECK: test_vabal_high_s8
+  // CHECK-LABEL: test_vabal_high_s8
   return vabal_high_s8(a, b, c);
   // CHECK: sabal2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 int32x4_t test_vabal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
-  // CHECK: test_vabal_high_s16
+  // CHECK-LABEL: test_vabal_high_s16
   return vabal_high_s16(a, b, c);
   // CHECK: sabal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int64x2_t test_vabal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
-  // CHECK: test_vabal_high_s32
+  // CHECK-LABEL: test_vabal_high_s32
   return vabal_high_s32(a, b, c);
   // CHECK: sabal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint16x8_t test_vabal_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) {
-  // CHECK: test_vabal_high_u8
+  // CHECK-LABEL: test_vabal_high_u8
   return vabal_high_u8(a, b, c);
   // CHECK: uabal2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 uint32x4_t test_vabal_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) {
-  // CHECK: test_vabal_high_u16
+  // CHECK-LABEL: test_vabal_high_u16
   return vabal_high_u16(a, b, c);
   // CHECK: uabal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 uint64x2_t test_vabal_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) {
-  // CHECK: test_vabal_high_u32
+  // CHECK-LABEL: test_vabal_high_u32
   return vabal_high_u32(a, b, c);
   // CHECK: uabal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int16x8_t test_vmull_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vmull_s8
+  // CHECK-LABEL: test_vmull_s8
   return vmull_s8(a, b);
   // CHECK: smull {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 int32x4_t test_vmull_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vmull_s16
+  // CHECK-LABEL: test_vmull_s16
   return vmull_s16(a, b);
   // CHECK: smull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int64x2_t test_vmull_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vmull_s32
+  // CHECK-LABEL: test_vmull_s32
   return vmull_s32(a, b);
   // CHECK: smull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 uint16x8_t test_vmull_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vmull_u8
+  // CHECK-LABEL: test_vmull_u8
   return vmull_u8(a, b);
   // CHECK: umull {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 uint32x4_t test_vmull_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vmull_u16
+  // CHECK-LABEL: test_vmull_u16
   return vmull_u16(a, b);
   // CHECK: umull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 uint64x2_t test_vmull_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vmull_u32
+  // CHECK-LABEL: test_vmull_u32
   return vmull_u32(a, b);
   // CHECK: umull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vmull_high_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vmull_high_s8
+  // CHECK-LABEL: test_vmull_high_s8
   return vmull_high_s8(a, b);
   // CHECK: smull2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 int32x4_t test_vmull_high_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vmull_high_s16
+  // CHECK-LABEL: test_vmull_high_s16
   return vmull_high_s16(a, b);
   // CHECK: smull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int64x2_t test_vmull_high_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vmull_high_s32
+  // CHECK-LABEL: test_vmull_high_s32
   return vmull_high_s32(a, b);
   // CHECK: smull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint16x8_t test_vmull_high_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vmull_high_u8
+  // CHECK-LABEL: test_vmull_high_u8
   return vmull_high_u8(a, b);
   // CHECK: umull2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 uint32x4_t test_vmull_high_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vmull_high_u16
+  // CHECK-LABEL: test_vmull_high_u16
   return vmull_high_u16(a, b);
   // CHECK: umull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 uint64x2_t test_vmull_high_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vmull_high_u32
+  // CHECK-LABEL: test_vmull_high_u32
   return vmull_high_u32(a, b);
   // CHECK: umull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int16x8_t test_vmlal_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
-  // CHECK: test_vmlal_s8
+  // CHECK-LABEL: test_vmlal_s8
   return vmlal_s8(a, b, c);
   // CHECK: smlal {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 int32x4_t test_vmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
-  // CHECK: test_vmlal_s16
+  // CHECK-LABEL: test_vmlal_s16
   return vmlal_s16(a, b, c);
   // CHECK: smlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int64x2_t test_vmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
-  // CHECK: test_vmlal_s32
+  // CHECK-LABEL: test_vmlal_s32
   return vmlal_s32(a, b, c);
   // CHECK: smlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 uint16x8_t test_vmlal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
-  // CHECK: test_vmlal_u8
+  // CHECK-LABEL: test_vmlal_u8
   return vmlal_u8(a, b, c);
   // CHECK: umlal {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 uint32x4_t test_vmlal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
-  // CHECK: test_vmlal_u16
+  // CHECK-LABEL: test_vmlal_u16
   return vmlal_u16(a, b, c);
   // CHECK: umlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 uint64x2_t test_vmlal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
-  // CHECK: test_vmlal_u32
+  // CHECK-LABEL: test_vmlal_u32
   return vmlal_u32(a, b, c);
   // CHECK: umlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vmlal_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) {
-  // CHECK: test_vmlal_high_s8
+  // CHECK-LABEL: test_vmlal_high_s8
   return vmlal_high_s8(a, b, c);
   // CHECK: smlal2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 int32x4_t test_vmlal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
-  // CHECK: test_vmlal_high_s16
+  // CHECK-LABEL: test_vmlal_high_s16
   return vmlal_high_s16(a, b, c);
   // CHECK: smlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int64x2_t test_vmlal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
-  // CHECK: test_vmlal_high_s32
+  // CHECK-LABEL: test_vmlal_high_s32
   return vmlal_high_s32(a, b, c);
   // CHECK: smlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint16x8_t test_vmlal_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) {
-  // CHECK: test_vmlal_high_u8
+  // CHECK-LABEL: test_vmlal_high_u8
   return vmlal_high_u8(a, b, c);
   // CHECK: umlal2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 uint32x4_t test_vmlal_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) {
-  // CHECK: test_vmlal_high_u16
+  // CHECK-LABEL: test_vmlal_high_u16
   return vmlal_high_u16(a, b, c);
   // CHECK: umlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 uint64x2_t test_vmlal_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) {
-  // CHECK: test_vmlal_high_u32
+  // CHECK-LABEL: test_vmlal_high_u32
   return vmlal_high_u32(a, b, c);
   // CHECK: umlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int16x8_t test_vmlsl_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
-  // CHECK: test_vmlsl_s8
+  // CHECK-LABEL: test_vmlsl_s8
   return vmlsl_s8(a, b, c);
   // CHECK: smlsl {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 int32x4_t test_vmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
-  // CHECK: test_vmlsl_s16
+  // CHECK-LABEL: test_vmlsl_s16
   return vmlsl_s16(a, b, c);
   // CHECK: smlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int64x2_t test_vmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
-  // CHECK: test_vmlsl_s32
+  // CHECK-LABEL: test_vmlsl_s32
   return vmlsl_s32(a, b, c);
   // CHECK: smlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 uint16x8_t test_vmlsl_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
-  // CHECK: test_vmlsl_u8
+  // CHECK-LABEL: test_vmlsl_u8
   return vmlsl_u8(a, b, c);
   // CHECK: umlsl {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 uint32x4_t test_vmlsl_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
-  // CHECK: test_vmlsl_u16
+  // CHECK-LABEL: test_vmlsl_u16
   return vmlsl_u16(a, b, c);
   // CHECK: umlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 uint64x2_t test_vmlsl_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
-  // CHECK: test_vmlsl_u32
+  // CHECK-LABEL: test_vmlsl_u32
   return vmlsl_u32(a, b, c);
   // CHECK: umlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int16x8_t test_vmlsl_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) {
-  // CHECK: test_vmlsl_high_s8
+  // CHECK-LABEL: test_vmlsl_high_s8
   return vmlsl_high_s8(a, b, c);
   // CHECK: smlsl2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 int32x4_t test_vmlsl_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
-  // CHECK: test_vmlsl_high_s16
+  // CHECK-LABEL: test_vmlsl_high_s16
   return vmlsl_high_s16(a, b, c);
   // CHECK: smlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int64x2_t test_vmlsl_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
-  // CHECK: test_vmlsl_high_s32
+  // CHECK-LABEL: test_vmlsl_high_s32
   return vmlsl_high_s32(a, b, c);
   // CHECK: smlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint16x8_t test_vmlsl_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) {
-  // CHECK: test_vmlsl_high_u8
+  // CHECK-LABEL: test_vmlsl_high_u8
   return vmlsl_high_u8(a, b, c);
   // CHECK: umlsl2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 uint32x4_t test_vmlsl_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) {
-  // CHECK: test_vmlsl_high_u16
+  // CHECK-LABEL: test_vmlsl_high_u16
   return vmlsl_high_u16(a, b, c);
   // CHECK: umlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 uint64x2_t test_vmlsl_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) {
-  // CHECK: test_vmlsl_high_u32
+  // CHECK-LABEL: test_vmlsl_high_u32
   return vmlsl_high_u32(a, b, c);
   // CHECK: umlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x4_t test_vqdmull_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vqdmull_s16
+  // CHECK-LABEL: test_vqdmull_s16
   return vqdmull_s16(a, b);
   // CHECK: sqdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int64x2_t test_vqdmull_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vqdmull_s32
+  // CHECK-LABEL: test_vqdmull_s32
   return vqdmull_s32(a, b);
   // CHECK: sqdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int32x4_t test_vqdmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
-  // CHECK: test_vqdmlal_s16
+  // CHECK-LABEL: test_vqdmlal_s16
   return vqdmlal_s16(a, b, c);
   // CHECK: sqdmlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int64x2_t test_vqdmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
-  // CHECK: test_vqdmlal_s32
+  // CHECK-LABEL: test_vqdmlal_s32
   return vqdmlal_s32(a, b, c);
   // CHECK: sqdmlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int32x4_t test_vqdmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
-  // CHECK: test_vqdmlsl_s16
+  // CHECK-LABEL: test_vqdmlsl_s16
   return vqdmlsl_s16(a, b, c);
   // CHECK: sqdmlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int64x2_t test_vqdmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
-  // CHECK: test_vqdmlsl_s32
+  // CHECK-LABEL: test_vqdmlsl_s32
   return vqdmlsl_s32(a, b, c);
   // CHECK: sqdmlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s
 }
 
 int32x4_t test_vqdmull_high_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vqdmull_high_s16
+  // CHECK-LABEL: test_vqdmull_high_s16
   return vqdmull_high_s16(a, b);
   // CHECK: sqdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int64x2_t test_vqdmull_high_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vqdmull_high_s32
+  // CHECK-LABEL: test_vqdmull_high_s32
   return vqdmull_high_s32(a, b);
   // CHECK: sqdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x4_t test_vqdmlal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
-  // CHECK: test_vqdmlal_high_s16
+  // CHECK-LABEL: test_vqdmlal_high_s16
   return vqdmlal_high_s16(a, b, c);
   // CHECK: sqdmlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int64x2_t test_vqdmlal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
-  // CHECK: test_vqdmlal_high_s32
+  // CHECK-LABEL: test_vqdmlal_high_s32
   return vqdmlal_high_s32(a, b, c);
   // CHECK: sqdmlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int32x4_t test_vqdmlsl_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) {
-  // CHECK: test_vqdmlsl_high_s16
+  // CHECK-LABEL: test_vqdmlsl_high_s16
   return vqdmlsl_high_s16(a, b, c);
   // CHECK: sqdmlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int64x2_t test_vqdmlsl_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) {
-  // CHECK: test_vqdmlsl_high_s32
+  // CHECK-LABEL: test_vqdmlsl_high_s32
   return vqdmlsl_high_s32(a, b, c);
   // CHECK: sqdmlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 poly16x8_t test_vmull_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vmull_p8
+  // CHECK-LABEL: test_vmull_p8
   return vmull_p8(a, b);
   // CHECK: pmull {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly16x8_t test_vmull_high_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vmull_high_p8
+  // CHECK-LABEL: test_vmull_high_p8
   return vmull_high_p8(a, b);
   // CHECK: pmull2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int64_t test_vaddd_s64(int64_t a, int64_t b) {
-// CHECK: test_vaddd_s64
+// CHECK-LABEL: test_vaddd_s64
   return vaddd_s64(a, b);
 // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64_t test_vaddd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vaddd_u64
+// CHECK-LABEL: test_vaddd_u64
   return vaddd_u64(a, b);
 // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int64_t test_vsubd_s64(int64_t a, int64_t b) {
-// CHECK: test_vsubd_s64
+// CHECK-LABEL: test_vsubd_s64
   return vsubd_s64(a, b);
 // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64_t test_vsubd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vsubd_u64
+// CHECK-LABEL: test_vsubd_u64
   return vsubd_u64(a, b);
 // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8_t test_vqaddb_s8(int8_t a, int8_t b) {
-// CHECK: test_vqaddb_s8
+// CHECK-LABEL: test_vqaddb_s8
   return vqaddb_s8(a, b);
 // CHECK: sqadd {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
 }
 
 int16_t test_vqaddh_s16(int16_t a, int16_t b) {
-// CHECK: test_vqaddh_s16
+// CHECK-LABEL: test_vqaddh_s16
   return vqaddh_s16(a, b);
 // CHECK: sqadd {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
 int32_t test_vqadds_s32(int32_t a, int32_t b) {
-// CHECK: test_vqadds_s32
+// CHECK-LABEL: test_vqadds_s32
   return vqadds_s32(a, b);
 // CHECK: sqadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 int64_t test_vqaddd_s64(int64_t a, int64_t b) {
-// CHECK: test_vqaddd_s64
+// CHECK-LABEL: test_vqaddd_s64
   return vqaddd_s64(a, b);
 // CHECK: sqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8_t test_vqaddb_u8(uint8_t a, uint8_t b) {
-// CHECK: test_vqaddb_u8
+// CHECK-LABEL: test_vqaddb_u8
   return vqaddb_u8(a, b);
 // CHECK: uqadd {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
 }
 
 uint16_t test_vqaddh_u16(uint16_t a, uint16_t b) {
-// CHECK: test_vqaddh_u16
+// CHECK-LABEL: test_vqaddh_u16
   return vqaddh_u16(a, b);
 // CHECK: uqadd {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
 uint32_t test_vqadds_u32(uint32_t a, uint32_t b) {
-// CHECK: test_vqadds_u32
+// CHECK-LABEL: test_vqadds_u32
   return vqadds_u32(a, b);
 // CHECK: uqadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 uint64_t test_vqaddd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vqaddd_u64
+// CHECK-LABEL: test_vqaddd_u64
   return vqaddd_u64(a, b);
 // CHECK: uqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int8_t test_vqsubb_s8(int8_t a, int8_t b) {
-// CHECK: test_vqsubb_s8
+// CHECK-LABEL: test_vqsubb_s8
   return vqsubb_s8(a, b);
 // CHECK: sqsub {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
 }
 
 int16_t test_vqsubh_s16(int16_t a, int16_t b) {
-// CHECK: test_vqsubh_s16
+// CHECK-LABEL: test_vqsubh_s16
   return vqsubh_s16(a, b);
 // CHECK: sqsub {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
 int32_t test_vqsubs_s32(int32_t a, int32_t b) {
-  // CHECK: test_vqsubs_s32
+  // CHECK-LABEL: test_vqsubs_s32
   return vqsubs_s32(a, b);
 // CHECK: sqsub {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 int64_t test_vqsubd_s64(int64_t a, int64_t b) {
-// CHECK: test_vqsubd_s64
+// CHECK-LABEL: test_vqsubd_s64
   return vqsubd_s64(a, b);
 // CHECK: sqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint8_t test_vqsubb_u8(uint8_t a, uint8_t b) {
-// CHECK: test_vqsubb_u8
+// CHECK-LABEL: test_vqsubb_u8
   return vqsubb_u8(a, b);
 // CHECK: uqsub {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
 }
 
 uint16_t test_vqsubh_u16(uint16_t a, uint16_t b) {
-// CHECK: test_vqsubh_u16
+// CHECK-LABEL: test_vqsubh_u16
   return vqsubh_u16(a, b);
 // CHECK: uqsub {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
 uint32_t test_vqsubs_u32(uint32_t a, uint32_t b) {
-// CHECK: test_vqsubs_u32
+// CHECK-LABEL: test_vqsubs_u32
   return vqsubs_u32(a, b);
 // CHECK: uqsub {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 uint64_t test_vqsubd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vqsubd_u64
+// CHECK-LABEL: test_vqsubd_u64
   return vqsubd_u64(a, b);
 // CHECK: uqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 int64_t test_vshld_s64(int64_t a, int64_t b) {
-// CHECK: test_vshld_s64
+// CHECK-LABEL: test_vshld_s64
   return vshld_s64(a, b);
 // CHECK: sshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64_t test_vshld_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vshld_u64
+// CHECK-LABEL: test_vshld_u64
   return vshld_u64(a, b);
 // CHECK: ushl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
-// CHECK: test_vqshlb_s8
+// CHECK-LABEL: test_vqshlb_s8
 int8_t test_vqshlb_s8(int8_t a, int8_t b) {
   return vqshlb_s8(a, b);
 // CHECK: sqshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
 }
 
-// CHECK: test_vqshlh_s16
+// CHECK-LABEL: test_vqshlh_s16
 int16_t test_vqshlh_s16(int16_t a, int16_t b) {
   return vqshlh_s16(a, b);
 // CHECK: sqshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
-// CHECK: test_vqshls_s32
+// CHECK-LABEL: test_vqshls_s32
 int32_t test_vqshls_s32(int32_t a, int32_t b) {
   return vqshls_s32(a, b);
 // CHECK: sqshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
-// CHECK: test_vqshld_s64
+// CHECK-LABEL: test_vqshld_s64
 int64_t test_vqshld_s64(int64_t a, int64_t b) {
   return vqshld_s64(a, b);
 // CHECK: sqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
-// CHECK: test_vqshlb_u8
+// CHECK-LABEL: test_vqshlb_u8
 uint8_t test_vqshlb_u8(uint8_t a, uint8_t b) {
   return vqshlb_u8(a, b);
 // CHECK: uqshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
 }
 
-// CHECK: test_vqshlh_u16
+// CHECK-LABEL: test_vqshlh_u16
 uint16_t test_vqshlh_u16(uint16_t a, uint16_t b) {
   return vqshlh_u16(a, b);
 // CHECK: uqshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
-// CHECK: test_vqshls_u32
+// CHECK-LABEL: test_vqshls_u32
 uint32_t test_vqshls_u32(uint32_t a, uint32_t b) {
   return vqshls_u32(a, b);
 // CHECK: uqshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
-// CHECK: test_vqshld_u64
+// CHECK-LABEL: test_vqshld_u64
 uint64_t test_vqshld_u64(uint64_t a, uint64_t b) {
   return vqshld_u64(a, b);
 // CHECK: uqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
-// CHECK: test_vrshld_s64
+// CHECK-LABEL: test_vrshld_s64
 int64_t test_vrshld_s64(int64_t a, int64_t b) {
   return vrshld_s64(a, b);
 // CHECK: srshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 
-// CHECK: test_vrshld_u64
+// CHECK-LABEL: test_vrshld_u64
 uint64_t test_vrshld_u64(uint64_t a, uint64_t b) {
   return vrshld_u64(a, b);
 // CHECK: urshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
-// CHECK: test_vqrshlb_s8
+// CHECK-LABEL: test_vqrshlb_s8
 int8_t test_vqrshlb_s8(int8_t a, int8_t b) {
   return vqrshlb_s8(a, b);
 // CHECK: sqrshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
 }
 
-// CHECK: test_vqrshlh_s16
+// CHECK-LABEL: test_vqrshlh_s16
 int16_t test_vqrshlh_s16(int16_t a, int16_t b) {
   return vqrshlh_s16(a, b);
 // CHECK: sqrshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
-// CHECK: test_vqrshls_s32
+// CHECK-LABEL: test_vqrshls_s32
 int32_t test_vqrshls_s32(int32_t a, int32_t b) {
   return vqrshls_s32(a, b);
 // CHECK: sqrshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
-// CHECK: test_vqrshld_s64
+// CHECK-LABEL: test_vqrshld_s64
 int64_t test_vqrshld_s64(int64_t a, int64_t b) {
   return vqrshld_s64(a, b);
 // CHECK: sqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
-// CHECK: test_vqrshlb_u8
+// CHECK-LABEL: test_vqrshlb_u8
 uint8_t test_vqrshlb_u8(uint8_t a, uint8_t b) {
   return vqrshlb_u8(a, b);
 // CHECK: uqrshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}}
 }
 
-// CHECK: test_vqrshlh_u16
+// CHECK-LABEL: test_vqrshlh_u16
 uint16_t test_vqrshlh_u16(uint16_t a, uint16_t b) {
   return vqrshlh_u16(a, b);
 // CHECK: uqrshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
-// CHECK: test_vqrshls_u32
+// CHECK-LABEL: test_vqrshls_u32
 uint32_t test_vqrshls_u32(uint32_t a, uint32_t b) {
   return vqrshls_u32(a, b);
 // CHECK: uqrshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
-// CHECK: test_vqrshld_u64
+// CHECK-LABEL: test_vqrshld_u64
 uint64_t test_vqrshld_u64(uint64_t a, uint64_t b) {
   return vqrshld_u64(a, b);
 // CHECK: uqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
-// CHECK: test_vpaddd_s64
+// CHECK-LABEL: test_vpaddd_s64
 int64_t test_vpaddd_s64(int64x2_t a) {
   return vpaddd_s64(a);
 // CHECK: addp {{d[0-9]+}}, {{v[0-9]+}}.2d
 }
 
-// CHECK: test_vpadds_f32
+// CHECK-LABEL: test_vpadds_f32
 float32_t test_vpadds_f32(float32x2_t a) {
   return vpadds_f32(a);
 // CHECK: faddp {{s[0-9]+}}, {{v[0-9]+}}.2s
 }
 
-// CHECK: test_vpaddd_f64
+// CHECK-LABEL: test_vpaddd_f64
 float64_t test_vpaddd_f64(float64x2_t a) {
   return vpaddd_f64(a);
 // CHECK: faddp {{d[0-9]+}}, {{v[0-9]+}}.2d
 }
 
-// CHECK: test_vpmaxnms_f32
+// CHECK-LABEL: test_vpmaxnms_f32
 float32_t test_vpmaxnms_f32(float32x2_t a) {
   return vpmaxnms_f32(a);
 // CHECK: fmaxnmp {{s[0-9]+}}, {{v[0-9]+}}.2s
 }
 
-// CHECK: test_vpmaxnmqd_f64
+// CHECK-LABEL: test_vpmaxnmqd_f64
 float64_t test_vpmaxnmqd_f64(float64x2_t a) {
   return vpmaxnmqd_f64(a);
 // CHECK: fmaxnmp {{d[0-9]+}}, {{v[0-9]+}}.2d
 }
 
-// CHECK: test_vpmaxs_f32
+// CHECK-LABEL: test_vpmaxs_f32
 float32_t test_vpmaxs_f32(float32x2_t a) {
   return vpmaxs_f32(a);
 // CHECK: fmaxp {{s[0-9]+}}, {{v[0-9]+}}.2s
 }
 
-// CHECK: test_vpmaxqd_f64
+// CHECK-LABEL: test_vpmaxqd_f64
 float64_t test_vpmaxqd_f64(float64x2_t a) {
   return vpmaxqd_f64(a);
 // CHECK: fmaxp {{d[0-9]+}}, {{v[0-9]+}}.2d
 }
 
-// CHECK: test_vpminnms_f32
+// CHECK-LABEL: test_vpminnms_f32
 float32_t test_vpminnms_f32(float32x2_t a) {
   return vpminnms_f32(a);
 // CHECK: fminnmp {{s[0-9]+}}, {{v[0-9]+}}.2s
 }
 
-// CHECK: test_vpminnmqd_f64
+// CHECK-LABEL: test_vpminnmqd_f64
 float64_t test_vpminnmqd_f64(float64x2_t a) {
   return vpminnmqd_f64(a);
 // CHECK: fminnmp {{d[0-9]+}}, {{v[0-9]+}}.2d
 }
 
-// CHECK: test_vpmins_f32
+// CHECK-LABEL: test_vpmins_f32
 float32_t test_vpmins_f32(float32x2_t a) {
   return vpmins_f32(a);
 // CHECK: fminp {{s[0-9]+}}, {{v[0-9]+}}.2s
 }
 
-// CHECK: test_vpminqd_f64
+// CHECK-LABEL: test_vpminqd_f64
 float64_t test_vpminqd_f64(float64x2_t a) {
   return vpminqd_f64(a);
 // CHECK: fminp {{d[0-9]+}}, {{v[0-9]+}}.2d
 }
 
 int16_t test_vqdmulhh_s16(int16_t a, int16_t b) {
-// CHECK: test_vqdmulhh_s16
+// CHECK-LABEL: test_vqdmulhh_s16
   return vqdmulhh_s16(a, b);
 // CHECK: sqdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
 int32_t test_vqdmulhs_s32(int32_t a, int32_t b) {
-// CHECK: test_vqdmulhs_s32
+// CHECK-LABEL: test_vqdmulhs_s32
   return vqdmulhs_s32(a, b);
 // CHECK: sqdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 int16_t test_vqrdmulhh_s16(int16_t a, int16_t b) {
-// CHECK: test_vqrdmulhh_s16
+// CHECK-LABEL: test_vqrdmulhh_s16
   return vqrdmulhh_s16(a, b);
 // CHECK: sqrdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
 }
 
 int32_t test_vqrdmulhs_s32(int32_t a, int32_t b) {
-// CHECK: test_vqrdmulhs_s32
+// CHECK-LABEL: test_vqrdmulhs_s32
   return vqrdmulhs_s32(a, b);
 // CHECK: sqrdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 float32_t test_vmulxs_f32(float32_t a, float32_t b) {
-// CHECK: test_vmulxs_f32
+// CHECK-LABEL: test_vmulxs_f32
   return vmulxs_f32(a, b);
 // CHECK: fmulx {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 float64_t test_vmulxd_f64(float64_t a, float64_t b) {
-// CHECK: test_vmulxd_f64
+// CHECK-LABEL: test_vmulxd_f64
   return vmulxd_f64(a, b);
 // CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 float64x1_t test_vmulx_f64(float64x1_t a, float64x1_t b) {
-// CHECK: test_vmulx_f64
+// CHECK-LABEL: test_vmulx_f64
   return vmulx_f64(a, b);
 // CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 float32_t test_vrecpss_f32(float32_t a, float32_t b) {
-// CHECK: test_vrecpss_f32
+// CHECK-LABEL: test_vrecpss_f32
   return vrecpss_f32(a, b);
 // CHECK: frecps {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 float64_t test_vrecpsd_f64(float64_t a, float64_t b) {
-// CHECK: test_vrecpsd_f64
+// CHECK-LABEL: test_vrecpsd_f64
   return vrecpsd_f64(a, b);
 // CHECK: frecps {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 float32_t test_vrsqrtss_f32(float32_t a, float32_t b) {
-// CHECK: test_vrsqrtss_f32
+// CHECK-LABEL: test_vrsqrtss_f32
   return vrsqrtss_f32(a, b);
 // CHECK: frsqrts {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
 }
 
 float64_t test_vrsqrtsd_f64(float64_t a, float64_t b) {
-// CHECK: test_vrsqrtsd_f64
+// CHECK-LABEL: test_vrsqrtsd_f64
   return vrsqrtsd_f64(a, b);
 // CHECK: frsqrts {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 float32_t test_vcvts_f32_s32(int32_t a) {
-// CHECK: test_vcvts_f32_s32
+// CHECK-LABEL: test_vcvts_f32_s32
 // CHECK: scvtf {{s[0-9]+}}, {{s[0-9]+}}
   return vcvts_f32_s32(a);
 }
 
 float64_t test_vcvtd_f64_s64(int64_t a) {
-// CHECK: test_vcvtd_f64_s64
+// CHECK-LABEL: test_vcvtd_f64_s64
 // CHECK: scvtf {{d[0-9]+}}, {{d[0-9]+}}
   return vcvtd_f64_s64(a);
 }
 
 float32_t test_vcvts_f32_u32(uint32_t a) {
-// CHECK: test_vcvts_f32_u32
+// CHECK-LABEL: test_vcvts_f32_u32
 // CHECK: ucvtf {{s[0-9]+}}, {{s[0-9]+}}
   return vcvts_f32_u32(a);
 }
 
 float64_t test_vcvtd_f64_u64(uint64_t a) {
-// CHECK: test_vcvtd_f64_u64
+// CHECK-LABEL: test_vcvtd_f64_u64
 // CHECK: ucvtf {{d[0-9]+}}, {{d[0-9]+}}
   return vcvtd_f64_u64(a);
 }
 
 float32_t test_vrecpes_f32(float32_t a) {
-// CHECK: test_vrecpes_f32
+// CHECK-LABEL: test_vrecpes_f32
 // CHECK: frecpe {{s[0-9]+}}, {{s[0-9]+}}
   return vrecpes_f32(a);
 }
  
 float64_t test_vrecped_f64(float64_t a) {
-// CHECK: test_vrecped_f64
+// CHECK-LABEL: test_vrecped_f64
 // CHECK: frecpe {{d[0-9]+}}, {{d[0-9]+}}
   return vrecped_f64(a);
 }
  
 float32_t test_vrecpxs_f32(float32_t a) {
-// CHECK: test_vrecpxs_f32
+// CHECK-LABEL: test_vrecpxs_f32
 // CHECK: frecpx {{s[0-9]+}}, {{s[0-9]+}}
   return vrecpxs_f32(a);
  }
  
 float64_t test_vrecpxd_f64(float64_t a) {
-// CHECK: test_vrecpxd_f64
+// CHECK-LABEL: test_vrecpxd_f64
 // CHECK: frecpx {{d[0-9]+}}, {{d[0-9]+}}
   return vrecpxd_f64(a);
 }
@@ -5819,1352 +5819,1352 @@ float64_t test_vrsqrted_f64(float64_t a)
 }
 
 uint8x16_t test_vld1q_u8(uint8_t const *a) {
-  // CHECK: test_vld1q_u8
+  // CHECK-LABEL: test_vld1q_u8
   return vld1q_u8(a);
   // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 uint16x8_t test_vld1q_u16(uint16_t const *a) {
-  // CHECK: test_vld1q_u16
+  // CHECK-LABEL: test_vld1q_u16
   return vld1q_u16(a);
   // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 uint32x4_t test_vld1q_u32(uint32_t const *a) {
-  // CHECK: test_vld1q_u32
+  // CHECK-LABEL: test_vld1q_u32
   return vld1q_u32(a);
   // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 uint64x2_t test_vld1q_u64(uint64_t const *a) {
-  // CHECK: test_vld1q_u64
+  // CHECK-LABEL: test_vld1q_u64
   return vld1q_u64(a);
   // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 int8x16_t test_vld1q_s8(int8_t const *a) {
-  // CHECK: test_vld1q_s8
+  // CHECK-LABEL: test_vld1q_s8
   return vld1q_s8(a);
   // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 int16x8_t test_vld1q_s16(int16_t const *a) {
-  // CHECK: test_vld1q_s16
+  // CHECK-LABEL: test_vld1q_s16
   return vld1q_s16(a);
   // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 int32x4_t test_vld1q_s32(int32_t const *a) {
-  // CHECK: test_vld1q_s32
+  // CHECK-LABEL: test_vld1q_s32
   return vld1q_s32(a);
   // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 int64x2_t test_vld1q_s64(int64_t const *a) {
-  // CHECK: test_vld1q_s64
+  // CHECK-LABEL: test_vld1q_s64
   return vld1q_s64(a);
   // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 float16x8_t test_vld1q_f16(float16_t const *a) {
-  // CHECK: test_vld1q_f16
+  // CHECK-LABEL: test_vld1q_f16
   return vld1q_f16(a);
   // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 float32x4_t test_vld1q_f32(float32_t const *a) {
-  // CHECK: test_vld1q_f32
+  // CHECK-LABEL: test_vld1q_f32
   return vld1q_f32(a);
   // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 float64x2_t test_vld1q_f64(float64_t const *a) {
-  // CHECK: test_vld1q_f64
+  // CHECK-LABEL: test_vld1q_f64
   return vld1q_f64(a);
   // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 poly8x16_t test_vld1q_p8(poly8_t const *a) {
-  // CHECK: test_vld1q_p8
+  // CHECK-LABEL: test_vld1q_p8
   return vld1q_p8(a);
   // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 poly16x8_t test_vld1q_p16(poly16_t const *a) {
-  // CHECK: test_vld1q_p16
+  // CHECK-LABEL: test_vld1q_p16
   return vld1q_p16(a);
   // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 uint8x8_t test_vld1_u8(uint8_t const *a) {
-  // CHECK: test_vld1_u8
+  // CHECK-LABEL: test_vld1_u8
   return vld1_u8(a);
   // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 uint16x4_t test_vld1_u16(uint16_t const *a) {
-  // CHECK: test_vld1_u16
+  // CHECK-LABEL: test_vld1_u16
   return vld1_u16(a);
   // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 uint32x2_t test_vld1_u32(uint32_t const *a) {
-  // CHECK: test_vld1_u32
+  // CHECK-LABEL: test_vld1_u32
   return vld1_u32(a);
   // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 uint64x1_t test_vld1_u64(uint64_t const *a) {
-  // CHECK: test_vld1_u64
+  // CHECK-LABEL: test_vld1_u64
   return vld1_u64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 int8x8_t test_vld1_s8(int8_t const *a) {
-  // CHECK: test_vld1_s8
+  // CHECK-LABEL: test_vld1_s8
   return vld1_s8(a);
   // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 int16x4_t test_vld1_s16(int16_t const *a) {
-  // CHECK: test_vld1_s16
+  // CHECK-LABEL: test_vld1_s16
   return vld1_s16(a);
   // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 int32x2_t test_vld1_s32(int32_t const *a) {
-  // CHECK: test_vld1_s32
+  // CHECK-LABEL: test_vld1_s32
   return vld1_s32(a);
   // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 int64x1_t test_vld1_s64(int64_t const *a) {
-  // CHECK: test_vld1_s64
+  // CHECK-LABEL: test_vld1_s64
   return vld1_s64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 float16x4_t test_vld1_f16(float16_t const *a) {
-  // CHECK: test_vld1_f16
+  // CHECK-LABEL: test_vld1_f16
   return vld1_f16(a);
   // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 float32x2_t test_vld1_f32(float32_t const *a) {
-  // CHECK: test_vld1_f32
+  // CHECK-LABEL: test_vld1_f32
   return vld1_f32(a);
   // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 float64x1_t test_vld1_f64(float64_t const *a) {
-  // CHECK: test_vld1_f64
+  // CHECK-LABEL: test_vld1_f64
   return vld1_f64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 poly8x8_t test_vld1_p8(poly8_t const *a) {
-  // CHECK: test_vld1_p8
+  // CHECK-LABEL: test_vld1_p8
   return vld1_p8(a);
   // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 poly16x4_t test_vld1_p16(poly16_t const *a) {
-  // CHECK: test_vld1_p16
+  // CHECK-LABEL: test_vld1_p16
   return vld1_p16(a);
   // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 uint8x16x2_t test_vld2q_u8(uint8_t const *a) {
-  // CHECK: test_vld2q_u8
+  // CHECK-LABEL: test_vld2q_u8
   return vld2q_u8(a);
   // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 uint16x8x2_t test_vld2q_u16(uint16_t const *a) {
-  // CHECK: test_vld2q_u16
+  // CHECK-LABEL: test_vld2q_u16
   return vld2q_u16(a);
   // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 uint32x4x2_t test_vld2q_u32(uint32_t const *a) {
-  // CHECK: test_vld2q_u32
+  // CHECK-LABEL: test_vld2q_u32
   return vld2q_u32(a);
   // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 uint64x2x2_t test_vld2q_u64(uint64_t const *a) {
-  // CHECK: test_vld2q_u64
+  // CHECK-LABEL: test_vld2q_u64
   return vld2q_u64(a);
   // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 int8x16x2_t test_vld2q_s8(int8_t const *a) {
-  // CHECK: test_vld2q_s8
+  // CHECK-LABEL: test_vld2q_s8
   return vld2q_s8(a);
   // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 int16x8x2_t test_vld2q_s16(int16_t const *a) {
-  // CHECK: test_vld2q_s16
+  // CHECK-LABEL: test_vld2q_s16
   return vld2q_s16(a);
   // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 int32x4x2_t test_vld2q_s32(int32_t const *a) {
-  // CHECK: test_vld2q_s32
+  // CHECK-LABEL: test_vld2q_s32
   return vld2q_s32(a);
   // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 int64x2x2_t test_vld2q_s64(int64_t const *a) {
-  // CHECK: test_vld2q_s64
+  // CHECK-LABEL: test_vld2q_s64
   return vld2q_s64(a);
   // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 float16x8x2_t test_vld2q_f16(float16_t const *a) {
-  // CHECK: test_vld2q_f16
+  // CHECK-LABEL: test_vld2q_f16
   return vld2q_f16(a);
   // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 float32x4x2_t test_vld2q_f32(float32_t const *a) {
-  // CHECK: test_vld2q_f32
+  // CHECK-LABEL: test_vld2q_f32
   return vld2q_f32(a);
   // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 float64x2x2_t test_vld2q_f64(float64_t const *a) {
-  // CHECK: test_vld2q_f64
+  // CHECK-LABEL: test_vld2q_f64
   return vld2q_f64(a);
   // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 poly8x16x2_t test_vld2q_p8(poly8_t const *a) {
-  // CHECK: test_vld2q_p8
+  // CHECK-LABEL: test_vld2q_p8
   return vld2q_p8(a);
   // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 poly16x8x2_t test_vld2q_p16(poly16_t const *a) {
-  // CHECK: test_vld2q_p16
+  // CHECK-LABEL: test_vld2q_p16
   return vld2q_p16(a);
   // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 uint8x8x2_t test_vld2_u8(uint8_t const *a) {
-  // CHECK: test_vld2_u8
+  // CHECK-LABEL: test_vld2_u8
   return vld2_u8(a);
   // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 uint16x4x2_t test_vld2_u16(uint16_t const *a) {
-  // CHECK: test_vld2_u16
+  // CHECK-LABEL: test_vld2_u16
   return vld2_u16(a);
   // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 uint32x2x2_t test_vld2_u32(uint32_t const *a) {
-  // CHECK: test_vld2_u32
+  // CHECK-LABEL: test_vld2_u32
   return vld2_u32(a);
   // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 uint64x1x2_t test_vld2_u64(uint64_t const *a) {
-  // CHECK: test_vld2_u64
+  // CHECK-LABEL: test_vld2_u64
   return vld2_u64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 int8x8x2_t test_vld2_s8(int8_t const *a) {
-  // CHECK: test_vld2_s8
+  // CHECK-LABEL: test_vld2_s8
   return vld2_s8(a);
   // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 int16x4x2_t test_vld2_s16(int16_t const *a) {
-  // CHECK: test_vld2_s16
+  // CHECK-LABEL: test_vld2_s16
   return vld2_s16(a);
   // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 int32x2x2_t test_vld2_s32(int32_t const *a) {
-  // CHECK: test_vld2_s32
+  // CHECK-LABEL: test_vld2_s32
   return vld2_s32(a);
   // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 int64x1x2_t test_vld2_s64(int64_t const *a) {
-  // CHECK: test_vld2_s64
+  // CHECK-LABEL: test_vld2_s64
   return vld2_s64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 float16x4x2_t test_vld2_f16(float16_t const *a) {
-  // CHECK: test_vld2_f16
+  // CHECK-LABEL: test_vld2_f16
   return vld2_f16(a);
   // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 float32x2x2_t test_vld2_f32(float32_t const *a) {
-  // CHECK: test_vld2_f32
+  // CHECK-LABEL: test_vld2_f32
   return vld2_f32(a);
   // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 float64x1x2_t test_vld2_f64(float64_t const *a) {
-  // CHECK: test_vld2_f64
+  // CHECK-LABEL: test_vld2_f64
   return vld2_f64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 poly8x8x2_t test_vld2_p8(poly8_t const *a) {
-  // CHECK: test_vld2_p8
+  // CHECK-LABEL: test_vld2_p8
   return vld2_p8(a);
   // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 poly16x4x2_t test_vld2_p16(poly16_t const *a) {
-  // CHECK: test_vld2_p16
+  // CHECK-LABEL: test_vld2_p16
   return vld2_p16(a);
   // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 uint8x16x3_t test_vld3q_u8(uint8_t const *a) {
-  // CHECK: test_vld3q_u8
+  // CHECK-LABEL: test_vld3q_u8
   return vld3q_u8(a);
   // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 uint16x8x3_t test_vld3q_u16(uint16_t const *a) {
-  // CHECK: test_vld3q_u16
+  // CHECK-LABEL: test_vld3q_u16
   return vld3q_u16(a);
   // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 uint32x4x3_t test_vld3q_u32(uint32_t const *a) {
-  // CHECK: test_vld3q_u32
+  // CHECK-LABEL: test_vld3q_u32
   return vld3q_u32(a);
   // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 uint64x2x3_t test_vld3q_u64(uint64_t const *a) {
-  // CHECK: test_vld3q_u64
+  // CHECK-LABEL: test_vld3q_u64
   return vld3q_u64(a);
   // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 int8x16x3_t test_vld3q_s8(int8_t const *a) {
-  // CHECK: test_vld3q_s8
+  // CHECK-LABEL: test_vld3q_s8
   return vld3q_s8(a);
   // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 int16x8x3_t test_vld3q_s16(int16_t const *a) {
-  // CHECK: test_vld3q_s16
+  // CHECK-LABEL: test_vld3q_s16
   return vld3q_s16(a);
   // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 int32x4x3_t test_vld3q_s32(int32_t const *a) {
-  // CHECK: test_vld3q_s32
+  // CHECK-LABEL: test_vld3q_s32
   return vld3q_s32(a);
   // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 int64x2x3_t test_vld3q_s64(int64_t const *a) {
-  // CHECK: test_vld3q_s64
+  // CHECK-LABEL: test_vld3q_s64
   return vld3q_s64(a);
   // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 float16x8x3_t test_vld3q_f16(float16_t const *a) {
-  // CHECK: test_vld3q_f16
+  // CHECK-LABEL: test_vld3q_f16
   return vld3q_f16(a);
   // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 float32x4x3_t test_vld3q_f32(float32_t const *a) {
-  // CHECK: test_vld3q_f32
+  // CHECK-LABEL: test_vld3q_f32
   return vld3q_f32(a);
   // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 float64x2x3_t test_vld3q_f64(float64_t const *a) {
-  // CHECK: test_vld3q_f64
+  // CHECK-LABEL: test_vld3q_f64
   return vld3q_f64(a);
   // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 poly8x16x3_t test_vld3q_p8(poly8_t const *a) {
-  // CHECK: test_vld3q_p8
+  // CHECK-LABEL: test_vld3q_p8
   return vld3q_p8(a);
   // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 poly16x8x3_t test_vld3q_p16(poly16_t const *a) {
-  // CHECK: test_vld3q_p16
+  // CHECK-LABEL: test_vld3q_p16
   return vld3q_p16(a);
   // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 uint8x8x3_t test_vld3_u8(uint8_t const *a) {
-  // CHECK: test_vld3_u8
+  // CHECK-LABEL: test_vld3_u8
   return vld3_u8(a);
   // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 uint16x4x3_t test_vld3_u16(uint16_t const *a) {
-  // CHECK: test_vld3_u16
+  // CHECK-LABEL: test_vld3_u16
   return vld3_u16(a);
   // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 uint32x2x3_t test_vld3_u32(uint32_t const *a) {
-  // CHECK: test_vld3_u32
+  // CHECK-LABEL: test_vld3_u32
   return vld3_u32(a);
   // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 uint64x1x3_t test_vld3_u64(uint64_t const *a) {
-  // CHECK: test_vld3_u64
+  // CHECK-LABEL: test_vld3_u64
   return vld3_u64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 int8x8x3_t test_vld3_s8(int8_t const *a) {
-  // CHECK: test_vld3_s8
+  // CHECK-LABEL: test_vld3_s8
   return vld3_s8(a);
   // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 int16x4x3_t test_vld3_s16(int16_t const *a) {
-  // CHECK: test_vld3_s16
+  // CHECK-LABEL: test_vld3_s16
   return vld3_s16(a);
   // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 int32x2x3_t test_vld3_s32(int32_t const *a) {
-  // CHECK: test_vld3_s32
+  // CHECK-LABEL: test_vld3_s32
   return vld3_s32(a);
   // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 int64x1x3_t test_vld3_s64(int64_t const *a) {
-  // CHECK: test_vld3_s64
+  // CHECK-LABEL: test_vld3_s64
   return vld3_s64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 float16x4x3_t test_vld3_f16(float16_t const *a) {
-  // CHECK: test_vld3_f16
+  // CHECK-LABEL: test_vld3_f16
   return vld3_f16(a);
   // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 float32x2x3_t test_vld3_f32(float32_t const *a) {
-  // CHECK: test_vld3_f32
+  // CHECK-LABEL: test_vld3_f32
   return vld3_f32(a);
   // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 float64x1x3_t test_vld3_f64(float64_t const *a) {
-  // CHECK: test_vld3_f64
+  // CHECK-LABEL: test_vld3_f64
   return vld3_f64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 poly8x8x3_t test_vld3_p8(poly8_t const *a) {
-  // CHECK: test_vld3_p8
+  // CHECK-LABEL: test_vld3_p8
   return vld3_p8(a);
   // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 poly16x4x3_t test_vld3_p16(poly16_t const *a) {
-  // CHECK: test_vld3_p16
+  // CHECK-LABEL: test_vld3_p16
   return vld3_p16(a);
   // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 uint8x16x4_t test_vld4q_u8(uint8_t const *a) {
-  // CHECK: test_vld4q_u8
+  // CHECK-LABEL: test_vld4q_u8
   return vld4q_u8(a);
   // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 uint16x8x4_t test_vld4q_u16(uint16_t const *a) {
-  // CHECK: test_vld4q_u16
+  // CHECK-LABEL: test_vld4q_u16
   return vld4q_u16(a);
   // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 uint32x4x4_t test_vld4q_u32(uint32_t const *a) {
-  // CHECK: test_vld4q_u32
+  // CHECK-LABEL: test_vld4q_u32
   return vld4q_u32(a);
   // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 uint64x2x4_t test_vld4q_u64(uint64_t const *a) {
-  // CHECK: test_vld4q_u64
+  // CHECK-LABEL: test_vld4q_u64
   return vld4q_u64(a);
   // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 int8x16x4_t test_vld4q_s8(int8_t const *a) {
-  // CHECK: test_vld4q_s8
+  // CHECK-LABEL: test_vld4q_s8
   return vld4q_s8(a);
   // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 int16x8x4_t test_vld4q_s16(int16_t const *a) {
-  // CHECK: test_vld4q_s16
+  // CHECK-LABEL: test_vld4q_s16
   return vld4q_s16(a);
   // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 int32x4x4_t test_vld4q_s32(int32_t const *a) {
-  // CHECK: test_vld4q_s32
+  // CHECK-LABEL: test_vld4q_s32
   return vld4q_s32(a);
   // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 int64x2x4_t test_vld4q_s64(int64_t const *a) {
-  // CHECK: test_vld4q_s64
+  // CHECK-LABEL: test_vld4q_s64
   return vld4q_s64(a);
   // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 float16x8x4_t test_vld4q_f16(float16_t const *a) {
-  // CHECK: test_vld4q_f16
+  // CHECK-LABEL: test_vld4q_f16
   return vld4q_f16(a);
   // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 float32x4x4_t test_vld4q_f32(float32_t const *a) {
-  // CHECK: test_vld4q_f32
+  // CHECK-LABEL: test_vld4q_f32
   return vld4q_f32(a);
   // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 float64x2x4_t test_vld4q_f64(float64_t const *a) {
-  // CHECK: test_vld4q_f64
+  // CHECK-LABEL: test_vld4q_f64
   return vld4q_f64(a);
   // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 poly8x16x4_t test_vld4q_p8(poly8_t const *a) {
-  // CHECK: test_vld4q_p8
+  // CHECK-LABEL: test_vld4q_p8
   return vld4q_p8(a);
   // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 poly16x8x4_t test_vld4q_p16(poly16_t const *a) {
-  // CHECK: test_vld4q_p16
+  // CHECK-LABEL: test_vld4q_p16
   return vld4q_p16(a);
   // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 uint8x8x4_t test_vld4_u8(uint8_t const *a) {
-  // CHECK: test_vld4_u8
+  // CHECK-LABEL: test_vld4_u8
   return vld4_u8(a);
   // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 uint16x4x4_t test_vld4_u16(uint16_t const *a) {
-  // CHECK: test_vld4_u16
+  // CHECK-LABEL: test_vld4_u16
   return vld4_u16(a);
   // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 uint32x2x4_t test_vld4_u32(uint32_t const *a) {
-  // CHECK: test_vld4_u32
+  // CHECK-LABEL: test_vld4_u32
   return vld4_u32(a);
   // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 uint64x1x4_t test_vld4_u64(uint64_t const *a) {
-  // CHECK: test_vld4_u64
+  // CHECK-LABEL: test_vld4_u64
   return vld4_u64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 int8x8x4_t test_vld4_s8(int8_t const *a) {
-  // CHECK: test_vld4_s8
+  // CHECK-LABEL: test_vld4_s8
   return vld4_s8(a);
   // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 int16x4x4_t test_vld4_s16(int16_t const *a) {
-  // CHECK: test_vld4_s16
+  // CHECK-LABEL: test_vld4_s16
   return vld4_s16(a);
   // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 int32x2x4_t test_vld4_s32(int32_t const *a) {
-  // CHECK: test_vld4_s32
+  // CHECK-LABEL: test_vld4_s32
   return vld4_s32(a);
   // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 int64x1x4_t test_vld4_s64(int64_t const *a) {
-  // CHECK: test_vld4_s64
+  // CHECK-LABEL: test_vld4_s64
   return vld4_s64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 float16x4x4_t test_vld4_f16(float16_t const *a) {
-  // CHECK: test_vld4_f16
+  // CHECK-LABEL: test_vld4_f16
   return vld4_f16(a);
   // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 float32x2x4_t test_vld4_f32(float32_t const *a) {
-  // CHECK: test_vld4_f32
+  // CHECK-LABEL: test_vld4_f32
   return vld4_f32(a);
   // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 float64x1x4_t test_vld4_f64(float64_t const *a) {
-  // CHECK: test_vld4_f64
+  // CHECK-LABEL: test_vld4_f64
   return vld4_f64(a);
   // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 poly8x8x4_t test_vld4_p8(poly8_t const *a) {
-  // CHECK: test_vld4_p8
+  // CHECK-LABEL: test_vld4_p8
   return vld4_p8(a);
   // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 poly16x4x4_t test_vld4_p16(poly16_t const *a) {
-  // CHECK: test_vld4_p16
+  // CHECK-LABEL: test_vld4_p16
   return vld4_p16(a);
   // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u8(uint8_t *a, uint8x16_t b) {
-  // CHECK: test_vst1q_u8
+  // CHECK-LABEL: test_vst1q_u8
   vst1q_u8(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u16(uint16_t *a, uint16x8_t b) {
-  // CHECK: test_vst1q_u16
+  // CHECK-LABEL: test_vst1q_u16
   vst1q_u16(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u32(uint32_t *a, uint32x4_t b) {
-  // CHECK: test_vst1q_u32
+  // CHECK-LABEL: test_vst1q_u32
   vst1q_u32(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u64(uint64_t *a, uint64x2_t b) {
-  // CHECK: test_vst1q_u64
+  // CHECK-LABEL: test_vst1q_u64
   vst1q_u64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s8(int8_t *a, int8x16_t b) {
-  // CHECK: test_vst1q_s8
+  // CHECK-LABEL: test_vst1q_s8
   vst1q_s8(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s16(int16_t *a, int16x8_t b) {
-  // CHECK: test_vst1q_s16
+  // CHECK-LABEL: test_vst1q_s16
   vst1q_s16(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s32(int32_t *a, int32x4_t b) {
-  // CHECK: test_vst1q_s32
+  // CHECK-LABEL: test_vst1q_s32
   vst1q_s32(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s64(int64_t *a, int64x2_t b) {
-  // CHECK: test_vst1q_s64
+  // CHECK-LABEL: test_vst1q_s64
   vst1q_s64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f16(float16_t *a, float16x8_t b) {
-  // CHECK: test_vst1q_f16
+  // CHECK-LABEL: test_vst1q_f16
   vst1q_f16(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f32(float32_t *a, float32x4_t b) {
-  // CHECK: test_vst1q_f32
+  // CHECK-LABEL: test_vst1q_f32
   vst1q_f32(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f64(float64_t *a, float64x2_t b) {
-  // CHECK: test_vst1q_f64
+  // CHECK-LABEL: test_vst1q_f64
   vst1q_f64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p8(poly8_t *a, poly8x16_t b) {
-  // CHECK: test_vst1q_p8
+  // CHECK-LABEL: test_vst1q_p8
   vst1q_p8(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p16(poly16_t *a, poly16x8_t b) {
-  // CHECK: test_vst1q_p16
+  // CHECK-LABEL: test_vst1q_p16
   vst1q_p16(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u8(uint8_t *a, uint8x8_t b) {
-  // CHECK: test_vst1_u8
+  // CHECK-LABEL: test_vst1_u8
   vst1_u8(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u16(uint16_t *a, uint16x4_t b) {
-  // CHECK: test_vst1_u16
+  // CHECK-LABEL: test_vst1_u16
   vst1_u16(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u32(uint32_t *a, uint32x2_t b) {
-  // CHECK: test_vst1_u32
+  // CHECK-LABEL: test_vst1_u32
   vst1_u32(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u64(uint64_t *a, uint64x1_t b) {
-  // CHECK: test_vst1_u64
+  // CHECK-LABEL: test_vst1_u64
   vst1_u64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s8(int8_t *a, int8x8_t b) {
-  // CHECK: test_vst1_s8
+  // CHECK-LABEL: test_vst1_s8
   vst1_s8(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s16(int16_t *a, int16x4_t b) {
-  // CHECK: test_vst1_s16
+  // CHECK-LABEL: test_vst1_s16
   vst1_s16(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s32(int32_t *a, int32x2_t b) {
-  // CHECK: test_vst1_s32
+  // CHECK-LABEL: test_vst1_s32
   vst1_s32(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s64(int64_t *a, int64x1_t b) {
-  // CHECK: test_vst1_s64
+  // CHECK-LABEL: test_vst1_s64
   vst1_s64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f16(float16_t *a, float16x4_t b) {
-  // CHECK: test_vst1_f16
+  // CHECK-LABEL: test_vst1_f16
   vst1_f16(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f32(float32_t *a, float32x2_t b) {
-  // CHECK: test_vst1_f32
+  // CHECK-LABEL: test_vst1_f32
   vst1_f32(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f64(float64_t *a, float64x1_t b) {
-  // CHECK: test_vst1_f64
+  // CHECK-LABEL: test_vst1_f64
   vst1_f64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p8(poly8_t *a, poly8x8_t b) {
-  // CHECK: test_vst1_p8
+  // CHECK-LABEL: test_vst1_p8
   vst1_p8(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p16(poly16_t *a, poly16x4_t b) {
-  // CHECK: test_vst1_p16
+  // CHECK-LABEL: test_vst1_p16
   vst1_p16(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_u8(uint8_t *a, uint8x16x2_t b) {
-  // CHECK: test_vst2q_u8
+  // CHECK-LABEL: test_vst2q_u8
   vst2q_u8(a, b);
   // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_u16(uint16_t *a, uint16x8x2_t b) {
-  // CHECK: test_vst2q_u16
+  // CHECK-LABEL: test_vst2q_u16
   vst2q_u16(a, b);
   // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_u32(uint32_t *a, uint32x4x2_t b) {
-  // CHECK: test_vst2q_u32
+  // CHECK-LABEL: test_vst2q_u32
   vst2q_u32(a, b);
   // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_u64(uint64_t *a, uint64x2x2_t b) {
-  // CHECK: test_vst2q_u64
+  // CHECK-LABEL: test_vst2q_u64
   vst2q_u64(a, b);
   // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_s8(int8_t *a, int8x16x2_t b) {
-  // CHECK: test_vst2q_s8
+  // CHECK-LABEL: test_vst2q_s8
   vst2q_s8(a, b);
   // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_s16(int16_t *a, int16x8x2_t b) {
-  // CHECK: test_vst2q_s16
+  // CHECK-LABEL: test_vst2q_s16
   vst2q_s16(a, b);
   // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_s32(int32_t *a, int32x4x2_t b) {
-  // CHECK: test_vst2q_s32
+  // CHECK-LABEL: test_vst2q_s32
   vst2q_s32(a, b);
   // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_s64(int64_t *a, int64x2x2_t b) {
-  // CHECK: test_vst2q_s64
+  // CHECK-LABEL: test_vst2q_s64
   vst2q_s64(a, b);
   // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_f16(float16_t *a, float16x8x2_t b) {
-  // CHECK: test_vst2q_f16
+  // CHECK-LABEL: test_vst2q_f16
   vst2q_f16(a, b);
   // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_f32(float32_t *a, float32x4x2_t b) {
-  // CHECK: test_vst2q_f32
+  // CHECK-LABEL: test_vst2q_f32
   vst2q_f32(a, b);
   // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_f64(float64_t *a, float64x2x2_t b) {
-  // CHECK: test_vst2q_f64
+  // CHECK-LABEL: test_vst2q_f64
   vst2q_f64(a, b);
   // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_p8(poly8_t *a, poly8x16x2_t b) {
-  // CHECK: test_vst2q_p8
+  // CHECK-LABEL: test_vst2q_p8
   vst2q_p8(a, b);
   // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_p16(poly16_t *a, poly16x8x2_t b) {
-  // CHECK: test_vst2q_p16
+  // CHECK-LABEL: test_vst2q_p16
   vst2q_p16(a, b);
   // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_u8(uint8_t *a, uint8x8x2_t b) {
-  // CHECK: test_vst2_u8
+  // CHECK-LABEL: test_vst2_u8
   vst2_u8(a, b);
   // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_u16(uint16_t *a, uint16x4x2_t b) {
-  // CHECK: test_vst2_u16
+  // CHECK-LABEL: test_vst2_u16
   vst2_u16(a, b);
   // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_u32(uint32_t *a, uint32x2x2_t b) {
-  // CHECK: test_vst2_u32
+  // CHECK-LABEL: test_vst2_u32
   vst2_u32(a, b);
   // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_u64(uint64_t *a, uint64x1x2_t b) {
-  // CHECK: test_vst2_u64
+  // CHECK-LABEL: test_vst2_u64
   vst2_u64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_s8(int8_t *a, int8x8x2_t b) {
-  // CHECK: test_vst2_s8
+  // CHECK-LABEL: test_vst2_s8
   vst2_s8(a, b);
   // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_s16(int16_t *a, int16x4x2_t b) {
-  // CHECK: test_vst2_s16
+  // CHECK-LABEL: test_vst2_s16
   vst2_s16(a, b);
   // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_s32(int32_t *a, int32x2x2_t b) {
-  // CHECK: test_vst2_s32
+  // CHECK-LABEL: test_vst2_s32
   vst2_s32(a, b);
   // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_s64(int64_t *a, int64x1x2_t b) {
-  // CHECK: test_vst2_s64
+  // CHECK-LABEL: test_vst2_s64
   vst2_s64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_f16(float16_t *a, float16x4x2_t b) {
-  // CHECK: test_vst2_f16
+  // CHECK-LABEL: test_vst2_f16
   vst2_f16(a, b);
   // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_f32(float32_t *a, float32x2x2_t b) {
-  // CHECK: test_vst2_f32
+  // CHECK-LABEL: test_vst2_f32
   vst2_f32(a, b);
   // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_f64(float64_t *a, float64x1x2_t b) {
-  // CHECK: test_vst2_f64
+  // CHECK-LABEL: test_vst2_f64
   vst2_f64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_p8(poly8_t *a, poly8x8x2_t b) {
-  // CHECK: test_vst2_p8
+  // CHECK-LABEL: test_vst2_p8
   vst2_p8(a, b);
   // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_p16(poly16_t *a, poly16x4x2_t b) {
-  // CHECK: test_vst2_p16
+  // CHECK-LABEL: test_vst2_p16
   vst2_p16(a, b);
   // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_u8(uint8_t *a, uint8x16x3_t b) {
-  // CHECK: test_vst3q_u8
+  // CHECK-LABEL: test_vst3q_u8
   vst3q_u8(a, b);
   // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_u16(uint16_t *a, uint16x8x3_t b) {
-  // CHECK: test_vst3q_u16
+  // CHECK-LABEL: test_vst3q_u16
   vst3q_u16(a, b);
   // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_u32(uint32_t *a, uint32x4x3_t b) {
-  // CHECK: test_vst3q_u32
+  // CHECK-LABEL: test_vst3q_u32
   vst3q_u32(a, b);
   // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_u64(uint64_t *a, uint64x2x3_t b) {
-  // CHECK: test_vst3q_u64
+  // CHECK-LABEL: test_vst3q_u64
   vst3q_u64(a, b);
   // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_s8(int8_t *a, int8x16x3_t b) {
-  // CHECK: test_vst3q_s8
+  // CHECK-LABEL: test_vst3q_s8
   vst3q_s8(a, b);
   // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_s16(int16_t *a, int16x8x3_t b) {
-  // CHECK: test_vst3q_s16
+  // CHECK-LABEL: test_vst3q_s16
   vst3q_s16(a, b);
   // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_s32(int32_t *a, int32x4x3_t b) {
-  // CHECK: test_vst3q_s32
+  // CHECK-LABEL: test_vst3q_s32
   vst3q_s32(a, b);
   // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_s64(int64_t *a, int64x2x3_t b) {
-  // CHECK: test_vst3q_s64
+  // CHECK-LABEL: test_vst3q_s64
   vst3q_s64(a, b);
   // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_f16(float16_t *a, float16x8x3_t b) {
-  // CHECK: test_vst3q_f16
+  // CHECK-LABEL: test_vst3q_f16
   vst3q_f16(a, b);
   // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_f32(float32_t *a, float32x4x3_t b) {
-  // CHECK: test_vst3q_f32
+  // CHECK-LABEL: test_vst3q_f32
   vst3q_f32(a, b);
   // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_f64(float64_t *a, float64x2x3_t b) {
-  // CHECK: test_vst3q_f64
+  // CHECK-LABEL: test_vst3q_f64
   vst3q_f64(a, b);
   // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_p8(poly8_t *a, poly8x16x3_t b) {
-  // CHECK: test_vst3q_p8
+  // CHECK-LABEL: test_vst3q_p8
   vst3q_p8(a, b);
   // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_p16(poly16_t *a, poly16x8x3_t b) {
-  // CHECK: test_vst3q_p16
+  // CHECK-LABEL: test_vst3q_p16
   vst3q_p16(a, b);
   // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_u8(uint8_t *a, uint8x8x3_t b) {
-  // CHECK: test_vst3_u8
+  // CHECK-LABEL: test_vst3_u8
   vst3_u8(a, b);
   // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_u16(uint16_t *a, uint16x4x3_t b) {
-  // CHECK: test_vst3_u16
+  // CHECK-LABEL: test_vst3_u16
   vst3_u16(a, b);
   // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_u32(uint32_t *a, uint32x2x3_t b) {
-  // CHECK: test_vst3_u32
+  // CHECK-LABEL: test_vst3_u32
   vst3_u32(a, b);
   // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_u64(uint64_t *a, uint64x1x3_t b) {
-  // CHECK: test_vst3_u64
+  // CHECK-LABEL: test_vst3_u64
   vst3_u64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_s8(int8_t *a, int8x8x3_t b) {
-  // CHECK: test_vst3_s8
+  // CHECK-LABEL: test_vst3_s8
   vst3_s8(a, b);
   // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_s16(int16_t *a, int16x4x3_t b) {
-  // CHECK: test_vst3_s16
+  // CHECK-LABEL: test_vst3_s16
   vst3_s16(a, b);
   // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_s32(int32_t *a, int32x2x3_t b) {
-  // CHECK: test_vst3_s32
+  // CHECK-LABEL: test_vst3_s32
   vst3_s32(a, b);
   // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_s64(int64_t *a, int64x1x3_t b) {
-  // CHECK: test_vst3_s64
+  // CHECK-LABEL: test_vst3_s64
   vst3_s64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_f16(float16_t *a, float16x4x3_t b) {
-  // CHECK: test_vst3_f16
+  // CHECK-LABEL: test_vst3_f16
   vst3_f16(a, b);
   // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_f32(float32_t *a, float32x2x3_t b) {
-  // CHECK: test_vst3_f32
+  // CHECK-LABEL: test_vst3_f32
   vst3_f32(a, b);
   // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_f64(float64_t *a, float64x1x3_t b) {
-  // CHECK: test_vst3_f64
+  // CHECK-LABEL: test_vst3_f64
   vst3_f64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_p8(poly8_t *a, poly8x8x3_t b) {
-  // CHECK: test_vst3_p8
+  // CHECK-LABEL: test_vst3_p8
   vst3_p8(a, b);
   // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_p16(poly16_t *a, poly16x4x3_t b) {
-  // CHECK: test_vst3_p16
+  // CHECK-LABEL: test_vst3_p16
   vst3_p16(a, b);
   // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_u8(uint8_t *a, uint8x16x4_t b) {
-  // CHECK: test_vst4q_u8
+  // CHECK-LABEL: test_vst4q_u8
   vst4q_u8(a, b);
   // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_u16(uint16_t *a, uint16x8x4_t b) {
-  // CHECK: test_vst4q_u16
+  // CHECK-LABEL: test_vst4q_u16
   vst4q_u16(a, b);
   // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_u32(uint32_t *a, uint32x4x4_t b) {
-  // CHECK: test_vst4q_u32
+  // CHECK-LABEL: test_vst4q_u32
   vst4q_u32(a, b);
   // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_u64(uint64_t *a, uint64x2x4_t b) {
-  // CHECK: test_vst4q_u64
+  // CHECK-LABEL: test_vst4q_u64
   vst4q_u64(a, b);
   // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_s8(int8_t *a, int8x16x4_t b) {
-  // CHECK: test_vst4q_s8
+  // CHECK-LABEL: test_vst4q_s8
   vst4q_s8(a, b);
   // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_s16(int16_t *a, int16x8x4_t b) {
-  // CHECK: test_vst4q_s16
+  // CHECK-LABEL: test_vst4q_s16
   vst4q_s16(a, b);
   // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_s32(int32_t *a, int32x4x4_t b) {
-  // CHECK: test_vst4q_s32
+  // CHECK-LABEL: test_vst4q_s32
   vst4q_s32(a, b);
   // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_s64(int64_t *a, int64x2x4_t b) {
-  // CHECK: test_vst4q_s64
+  // CHECK-LABEL: test_vst4q_s64
   vst4q_s64(a, b);
   // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_f16(float16_t *a, float16x8x4_t b) {
-  // CHECK: test_vst4q_f16
+  // CHECK-LABEL: test_vst4q_f16
   vst4q_f16(a, b);
   // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_f32(float32_t *a, float32x4x4_t b) {
-  // CHECK: test_vst4q_f32
+  // CHECK-LABEL: test_vst4q_f32
   vst4q_f32(a, b);
   // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_f64(float64_t *a, float64x2x4_t b) {
-  // CHECK: test_vst4q_f64
+  // CHECK-LABEL: test_vst4q_f64
   vst4q_f64(a, b);
   // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_p8(poly8_t *a, poly8x16x4_t b) {
-  // CHECK: test_vst4q_p8
+  // CHECK-LABEL: test_vst4q_p8
   vst4q_p8(a, b);
   // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_p16(poly16_t *a, poly16x8x4_t b) {
-  // CHECK: test_vst4q_p16
+  // CHECK-LABEL: test_vst4q_p16
   vst4q_p16(a, b);
   // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_u8(uint8_t *a, uint8x8x4_t b) {
-  // CHECK: test_vst4_u8
+  // CHECK-LABEL: test_vst4_u8
   vst4_u8(a, b);
   // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_u16(uint16_t *a, uint16x4x4_t b) {
-  // CHECK: test_vst4_u16
+  // CHECK-LABEL: test_vst4_u16
   vst4_u16(a, b);
   // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_u32(uint32_t *a, uint32x2x4_t b) {
-  // CHECK: test_vst4_u32
+  // CHECK-LABEL: test_vst4_u32
   vst4_u32(a, b);
   // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_u64(uint64_t *a, uint64x1x4_t b) {
-  // CHECK: test_vst4_u64
+  // CHECK-LABEL: test_vst4_u64
   vst4_u64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_s8(int8_t *a, int8x8x4_t b) {
-  // CHECK: test_vst4_s8
+  // CHECK-LABEL: test_vst4_s8
   vst4_s8(a, b);
   // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_s16(int16_t *a, int16x4x4_t b) {
-  // CHECK: test_vst4_s16
+  // CHECK-LABEL: test_vst4_s16
   vst4_s16(a, b);
   // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_s32(int32_t *a, int32x2x4_t b) {
-  // CHECK: test_vst4_s32
+  // CHECK-LABEL: test_vst4_s32
   vst4_s32(a, b);
   // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_s64(int64_t *a, int64x1x4_t b) {
-  // CHECK: test_vst4_s64
+  // CHECK-LABEL: test_vst4_s64
   vst4_s64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_f16(float16_t *a, float16x4x4_t b) {
-  // CHECK: test_vst4_f16
+  // CHECK-LABEL: test_vst4_f16
   vst4_f16(a, b);
   // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_f32(float32_t *a, float32x2x4_t b) {
-  // CHECK: test_vst4_f32
+  // CHECK-LABEL: test_vst4_f32
   vst4_f32(a, b);
   // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_f64(float64_t *a, float64x1x4_t b) {
-  // CHECK: test_vst4_f64
+  // CHECK-LABEL: test_vst4_f64
   vst4_f64(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_p8(poly8_t *a, poly8x8x4_t b) {
-  // CHECK: test_vst4_p8
+  // CHECK-LABEL: test_vst4_p8
   vst4_p8(a, b);
   // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_p16(poly16_t *a, poly16x4x4_t b) {
-  // CHECK: test_vst4_p16
+  // CHECK-LABEL: test_vst4_p16
   vst4_p16(a, b);
   // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
@@ -7731,1035 +7731,1035 @@ poly64x1x4_t test_vld1_p64_x4(poly64_t c
 }
 
 void test_vst1q_u8_x2(uint8_t *a, uint8x16x2_t b) {
-  // CHECK: test_vst1q_u8_x2
+  // CHECK-LABEL: test_vst1q_u8_x2
   vst1q_u8_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u16_x2(uint16_t *a, uint16x8x2_t b) {
-  // CHECK: test_vst1q_u16_x2
+  // CHECK-LABEL: test_vst1q_u16_x2
   vst1q_u16_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u32_x2(uint32_t *a, uint32x4x2_t b) {
-  // CHECK: test_vst1q_u32_x2
+  // CHECK-LABEL: test_vst1q_u32_x2
   vst1q_u32_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u64_x2(uint64_t *a, uint64x2x2_t b) {
-  // CHECK: test_vst1q_u64_x2
+  // CHECK-LABEL: test_vst1q_u64_x2
   vst1q_u64_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s8_x2(int8_t *a, int8x16x2_t b) {
-  // CHECK: test_vst1q_s8_x2
+  // CHECK-LABEL: test_vst1q_s8_x2
   vst1q_s8_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s16_x2(int16_t *a, int16x8x2_t b) {
-  // CHECK: test_vst1q_s16_x2
+  // CHECK-LABEL: test_vst1q_s16_x2
   vst1q_s16_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s32_x2(int32_t *a, int32x4x2_t b) {
-  // CHECK: test_vst1q_s32_x2
+  // CHECK-LABEL: test_vst1q_s32_x2
   vst1q_s32_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s64_x2(int64_t *a, int64x2x2_t b) {
-  // CHECK: test_vst1q_s64_x2
+  // CHECK-LABEL: test_vst1q_s64_x2
   vst1q_s64_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f16_x2(float16_t *a, float16x8x2_t b) {
-  // CHECK: test_vst1q_f16_x2
+  // CHECK-LABEL: test_vst1q_f16_x2
   vst1q_f16_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f32_x2(float32_t *a, float32x4x2_t b) {
-  // CHECK: test_vst1q_f32_x2
+  // CHECK-LABEL: test_vst1q_f32_x2
   vst1q_f32_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f64_x2(float64_t *a, float64x2x2_t b) {
-  // CHECK: test_vst1q_f64_x2
+  // CHECK-LABEL: test_vst1q_f64_x2
   vst1q_f64_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p8_x2(poly8_t *a, poly8x16x2_t b) {
-  // CHECK: test_vst1q_p8_x2
+  // CHECK-LABEL: test_vst1q_p8_x2
   vst1q_p8_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p16_x2(poly16_t *a, poly16x8x2_t b) {
-  // CHECK: test_vst1q_p16_x2
+  // CHECK-LABEL: test_vst1q_p16_x2
   vst1q_p16_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p64_x2(poly64_t *a, poly64x2x2_t b) {
-  // CHECK: test_vst1q_p64_x2
+  // CHECK-LABEL: test_vst1q_p64_x2
   vst1q_p64_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u8_x2(uint8_t *a, uint8x8x2_t b) {
-  // CHECK: test_vst1_u8_x2
+  // CHECK-LABEL: test_vst1_u8_x2
   vst1_u8_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u16_x2(uint16_t *a, uint16x4x2_t b) {
-  // CHECK: test_vst1_u16_x2
+  // CHECK-LABEL: test_vst1_u16_x2
   vst1_u16_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u32_x2(uint32_t *a, uint32x2x2_t b) {
-  // CHECK: test_vst1_u32_x2
+  // CHECK-LABEL: test_vst1_u32_x2
   vst1_u32_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u64_x2(uint64_t *a, uint64x1x2_t b) {
-  // CHECK: test_vst1_u64_x2
+  // CHECK-LABEL: test_vst1_u64_x2
   vst1_u64_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s8_x2(int8_t *a, int8x8x2_t b) {
-  // CHECK: test_vst1_s8_x2
+  // CHECK-LABEL: test_vst1_s8_x2
   vst1_s8_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s16_x2(int16_t *a, int16x4x2_t b) {
-  // CHECK: test_vst1_s16_x2
+  // CHECK-LABEL: test_vst1_s16_x2
   vst1_s16_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s32_x2(int32_t *a, int32x2x2_t b) {
-  // CHECK: test_vst1_s32_x2
+  // CHECK-LABEL: test_vst1_s32_x2
   vst1_s32_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s64_x2(int64_t *a, int64x1x2_t b) {
-  // CHECK: test_vst1_s64_x2
+  // CHECK-LABEL: test_vst1_s64_x2
   vst1_s64_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f16_x2(float16_t *a, float16x4x2_t b) {
-  // CHECK: test_vst1_f16_x2
+  // CHECK-LABEL: test_vst1_f16_x2
   vst1_f16_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f32_x2(float32_t *a, float32x2x2_t b) {
-  // CHECK: test_vst1_f32_x2
+  // CHECK-LABEL: test_vst1_f32_x2
   vst1_f32_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f64_x2(float64_t *a, float64x1x2_t b) {
-  // CHECK: test_vst1_f64_x2
+  // CHECK-LABEL: test_vst1_f64_x2
   vst1_f64_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p8_x2(poly8_t *a, poly8x8x2_t b) {
-  // CHECK: test_vst1_p8_x2
+  // CHECK-LABEL: test_vst1_p8_x2
   vst1_p8_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p16_x2(poly16_t *a, poly16x4x2_t b) {
-  // CHECK: test_vst1_p16_x2
+  // CHECK-LABEL: test_vst1_p16_x2
   vst1_p16_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p64_x2(poly64_t *a, poly64x1x2_t b) {
-  // CHECK: test_vst1_p64_x2
+  // CHECK-LABEL: test_vst1_p64_x2
   vst1_p64_x2(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u8_x3(uint8_t *a, uint8x16x3_t b) {
-  // CHECK: test_vst1q_u8_x3
+  // CHECK-LABEL: test_vst1q_u8_x3
   vst1q_u8_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u16_x3(uint16_t *a, uint16x8x3_t b) {
-  // CHECK: test_vst1q_u16_x3
+  // CHECK-LABEL: test_vst1q_u16_x3
   vst1q_u16_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u32_x3(uint32_t *a, uint32x4x3_t b) {
-  // CHECK: test_vst1q_u32_x3
+  // CHECK-LABEL: test_vst1q_u32_x3
   vst1q_u32_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u64_x3(uint64_t *a, uint64x2x3_t b) {
-  // CHECK: test_vst1q_u64_x3
+  // CHECK-LABEL: test_vst1q_u64_x3
   vst1q_u64_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s8_x3(int8_t *a, int8x16x3_t b) {
-  // CHECK: test_vst1q_s8_x3
+  // CHECK-LABEL: test_vst1q_s8_x3
   vst1q_s8_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s16_x3(int16_t *a, int16x8x3_t b) {
-  // CHECK: test_vst1q_s16_x3
+  // CHECK-LABEL: test_vst1q_s16_x3
   vst1q_s16_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s32_x3(int32_t *a, int32x4x3_t b) {
-  // CHECK: test_vst1q_s32_x3
+  // CHECK-LABEL: test_vst1q_s32_x3
   vst1q_s32_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s64_x3(int64_t *a, int64x2x3_t b) {
-  // CHECK: test_vst1q_s64_x3
+  // CHECK-LABEL: test_vst1q_s64_x3
   vst1q_s64_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f16_x3(float16_t *a, float16x8x3_t b) {
-  // CHECK: test_vst1q_f16_x3
+  // CHECK-LABEL: test_vst1q_f16_x3
   vst1q_f16_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f32_x3(float32_t *a, float32x4x3_t b) {
-  // CHECK: test_vst1q_f32_x3
+  // CHECK-LABEL: test_vst1q_f32_x3
   vst1q_f32_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f64_x3(float64_t *a, float64x2x3_t b) {
-  // CHECK: test_vst1q_f64_x3
+  // CHECK-LABEL: test_vst1q_f64_x3
   vst1q_f64_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p8_x3(poly8_t *a, poly8x16x3_t b) {
-  // CHECK: test_vst1q_p8_x3
+  // CHECK-LABEL: test_vst1q_p8_x3
   vst1q_p8_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p16_x3(poly16_t *a, poly16x8x3_t b) {
-  // CHECK: test_vst1q_p16_x3
+  // CHECK-LABEL: test_vst1q_p16_x3
   vst1q_p16_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p64_x3(poly64_t *a, poly64x2x3_t b) {
-  // CHECK: test_vst1q_p64_x3
+  // CHECK-LABEL: test_vst1q_p64_x3
   vst1q_p64_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u8_x3(uint8_t *a, uint8x8x3_t b) {
-  // CHECK: test_vst1_u8_x3
+  // CHECK-LABEL: test_vst1_u8_x3
   vst1_u8_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u16_x3(uint16_t *a, uint16x4x3_t b) {
-  // CHECK: test_vst1_u16_x3
+  // CHECK-LABEL: test_vst1_u16_x3
   vst1_u16_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u32_x3(uint32_t *a, uint32x2x3_t b) {
-  // CHECK: test_vst1_u32_x3
+  // CHECK-LABEL: test_vst1_u32_x3
   vst1_u32_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u64_x3(uint64_t *a, uint64x1x3_t b) {
-  // CHECK: test_vst1_u64_x3
+  // CHECK-LABEL: test_vst1_u64_x3
   vst1_u64_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s8_x3(int8_t *a, int8x8x3_t b) {
-  // CHECK: test_vst1_s8_x3
+  // CHECK-LABEL: test_vst1_s8_x3
   vst1_s8_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s16_x3(int16_t *a, int16x4x3_t b) {
-  // CHECK: test_vst1_s16_x3
+  // CHECK-LABEL: test_vst1_s16_x3
   vst1_s16_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s32_x3(int32_t *a, int32x2x3_t b) {
-  // CHECK: test_vst1_s32_x3
+  // CHECK-LABEL: test_vst1_s32_x3
   vst1_s32_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s64_x3(int64_t *a, int64x1x3_t b) {
-  // CHECK: test_vst1_s64_x3
+  // CHECK-LABEL: test_vst1_s64_x3
   vst1_s64_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f16_x3(float16_t *a, float16x4x3_t b) {
-  // CHECK: test_vst1_f16_x3
+  // CHECK-LABEL: test_vst1_f16_x3
   vst1_f16_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f32_x3(float32_t *a, float32x2x3_t b) {
-  // CHECK: test_vst1_f32_x3
+  // CHECK-LABEL: test_vst1_f32_x3
   vst1_f32_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f64_x3(float64_t *a, float64x1x3_t b) {
-  // CHECK: test_vst1_f64_x3
+  // CHECK-LABEL: test_vst1_f64_x3
   vst1_f64_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p8_x3(poly8_t *a, poly8x8x3_t b) {
-  // CHECK: test_vst1_p8_x3
+  // CHECK-LABEL: test_vst1_p8_x3
   vst1_p8_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p16_x3(poly16_t *a, poly16x4x3_t b) {
-  // CHECK: test_vst1_p16_x3
+  // CHECK-LABEL: test_vst1_p16_x3
   vst1_p16_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p64_x3(poly64_t *a, poly64x1x3_t b) {
-  // CHECK: test_vst1_p64_x3
+  // CHECK-LABEL: test_vst1_p64_x3
   vst1_p64_x3(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d},
   // [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u8_x4(uint8_t *a, uint8x16x4_t b) {
-  // CHECK: test_vst1q_u8_x4
+  // CHECK-LABEL: test_vst1q_u8_x4
   vst1q_u8_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u16_x4(uint16_t *a, uint16x8x4_t b) {
-  // CHECK: test_vst1q_u16_x4
+  // CHECK-LABEL: test_vst1q_u16_x4
   vst1q_u16_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u32_x4(uint32_t *a, uint32x4x4_t b) {
-  // CHECK: test_vst1q_u32_x4
+  // CHECK-LABEL: test_vst1q_u32_x4
   vst1q_u32_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_u64_x4(uint64_t *a, uint64x2x4_t b) {
-  // CHECK: test_vst1q_u64_x4
+  // CHECK-LABEL: test_vst1q_u64_x4
   vst1q_u64_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s8_x4(int8_t *a, int8x16x4_t b) {
-  // CHECK: test_vst1q_s8_x4
+  // CHECK-LABEL: test_vst1q_s8_x4
   vst1q_s8_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s16_x4(int16_t *a, int16x8x4_t b) {
-  // CHECK: test_vst1q_s16_x4
+  // CHECK-LABEL: test_vst1q_s16_x4
   vst1q_s16_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s32_x4(int32_t *a, int32x4x4_t b) {
-  // CHECK: test_vst1q_s32_x4
+  // CHECK-LABEL: test_vst1q_s32_x4
   vst1q_s32_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_s64_x4(int64_t *a, int64x2x4_t b) {
-  // CHECK: test_vst1q_s64_x4
+  // CHECK-LABEL: test_vst1q_s64_x4
   vst1q_s64_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f16_x4(float16_t *a, float16x8x4_t b) {
-  // CHECK: test_vst1q_f16_x4
+  // CHECK-LABEL: test_vst1q_f16_x4
   vst1q_f16_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f32_x4(float32_t *a, float32x4x4_t b) {
-  // CHECK: test_vst1q_f32_x4
+  // CHECK-LABEL: test_vst1q_f32_x4
   vst1q_f32_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s,
   // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_f64_x4(float64_t *a, float64x2x4_t b) {
-  // CHECK: test_vst1q_f64_x4
+  // CHECK-LABEL: test_vst1q_f64_x4
   vst1q_f64_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p8_x4(poly8_t *a, poly8x16x4_t b) {
-  // CHECK: test_vst1q_p8_x4
+  // CHECK-LABEL: test_vst1q_p8_x4
   vst1q_p8_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b,
   // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p16_x4(poly16_t *a, poly16x8x4_t b) {
-  // CHECK: test_vst1q_p16_x4
+  // CHECK-LABEL: test_vst1q_p16_x4
   vst1q_p16_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h,
   // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p64_x4(poly64_t *a, poly64x2x4_t b) {
-  // CHECK: test_vst1q_p64_x4
+  // CHECK-LABEL: test_vst1q_p64_x4
   vst1q_p64_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d,
   // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u8_x4(uint8_t *a, uint8x8x4_t b) {
-  // CHECK: test_vst1_u8_x4
+  // CHECK-LABEL: test_vst1_u8_x4
   vst1_u8_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u16_x4(uint16_t *a, uint16x4x4_t b) {
-  // CHECK: test_vst1_u16_x4
+  // CHECK-LABEL: test_vst1_u16_x4
   vst1_u16_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u32_x4(uint32_t *a, uint32x2x4_t b) {
-  // CHECK: test_vst1_u32_x4
+  // CHECK-LABEL: test_vst1_u32_x4
   vst1_u32_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_u64_x4(uint64_t *a, uint64x1x4_t b) {
-  // CHECK: test_vst1_u64_x4
+  // CHECK-LABEL: test_vst1_u64_x4
   vst1_u64_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s8_x4(int8_t *a, int8x8x4_t b) {
-  // CHECK: test_vst1_s8_x4
+  // CHECK-LABEL: test_vst1_s8_x4
   vst1_s8_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s16_x4(int16_t *a, int16x4x4_t b) {
-  // CHECK: test_vst1_s16_x4
+  // CHECK-LABEL: test_vst1_s16_x4
   vst1_s16_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s32_x4(int32_t *a, int32x2x4_t b) {
-  // CHECK: test_vst1_s32_x4
+  // CHECK-LABEL: test_vst1_s32_x4
   vst1_s32_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_s64_x4(int64_t *a, int64x1x4_t b) {
-  // CHECK: test_vst1_s64_x4
+  // CHECK-LABEL: test_vst1_s64_x4
   vst1_s64_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f16_x4(float16_t *a, float16x4x4_t b) {
-  // CHECK: test_vst1_f16_x4
+  // CHECK-LABEL: test_vst1_f16_x4
   vst1_f16_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f32_x4(float32_t *a, float32x2x4_t b) {
-  // CHECK: test_vst1_f32_x4
+  // CHECK-LABEL: test_vst1_f32_x4
   vst1_f32_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s,
   // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_f64_x4(float64_t *a, float64x1x4_t b) {
-  // CHECK: test_vst1_f64_x4
+  // CHECK-LABEL: test_vst1_f64_x4
   vst1_f64_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p8_x4(poly8_t *a, poly8x8x4_t b) {
-  // CHECK: test_vst1_p8_x4
+  // CHECK-LABEL: test_vst1_p8_x4
   vst1_p8_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b,
   // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p16_x4(poly16_t *a, poly16x4x4_t b) {
-  // CHECK: test_vst1_p16_x4
+  // CHECK-LABEL: test_vst1_p16_x4
   vst1_p16_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h,
   // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p64_x4(poly64_t *a, poly64x1x4_t b) {
-  // CHECK: test_vst1_p64_x4
+  // CHECK-LABEL: test_vst1_p64_x4
   vst1_p64_x4(a, b);
   // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d,
   // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 int64_t test_vceqd_s64(int64_t a, int64_t b) {
-// CHECK: test_vceqd_s64
+// CHECK-LABEL: test_vceqd_s64
 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vceqd_s64(a, b);
 }
 
 uint64_t test_vceqd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vceqd_u64
+// CHECK-LABEL: test_vceqd_u64
 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vceqd_u64(a, b);
 } 
 
 int64_t test_vceqzd_s64(int64_t a) {
-// CHECK: test_vceqzd_s64
+// CHECK-LABEL: test_vceqzd_s64
 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, #0x0
   return (int64_t)vceqzd_s64(a);
 }
 
 int64_t test_vceqzd_u64(int64_t a) {
-// CHECK: test_vceqzd_u64
+// CHECK-LABEL: test_vceqzd_u64
 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, #0x0
   return (int64_t)vceqzd_u64(a);
 }
 
 int64_t test_vcged_s64(int64_t a, int64_t b) {
-// CHECK: test_vcged_s64
+// CHECK-LABEL: test_vcged_s64
 // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcged_s64(a, b);
 }
 
 uint64_t test_vcged_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vcged_u64
+// CHECK-LABEL: test_vcged_u64
 // CHECK: cmhs {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
     return (uint64_t)vcged_u64(a, b);
 }
 
 int64_t test_vcgezd_s64(int64_t a) {
-// CHECK: test_vcgezd_s64
+// CHECK-LABEL: test_vcgezd_s64
 // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, #0x0
   return (int64_t)vcgezd_s64(a);
 }
 
 int64_t test_vcgtd_s64(int64_t a, int64_t b) {
-// CHECK: test_vcgtd_s64
+// CHECK-LABEL: test_vcgtd_s64
 // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcgtd_s64(a, b);
 }
 
 uint64_t test_vcgtd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vcgtd_u64
+// CHECK-LABEL: test_vcgtd_u64
 // CHECK: cmhi {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vcgtd_u64(a, b);
 }
 
 int64_t test_vcgtzd_s64(int64_t a) {
-// CHECK: test_vcgtzd_s64
+// CHECK-LABEL: test_vcgtzd_s64
 // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, #0x0
   return (int64_t)vcgtzd_s64(a);
 }
 
 int64_t test_vcled_s64(int64_t a, int64_t b) {
-// CHECK: test_vcled_s64
+// CHECK-LABEL: test_vcled_s64
 // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcled_s64(a, b);
 }
 
 uint64_t test_vcled_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vcled_u64
+// CHECK-LABEL: test_vcled_u64
 // CHECK: cmhs {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vcled_u64(a, 0);
 }
 
 int64_t test_vclezd_s64(int64_t a) {
-// CHECK: test_vclezd_s64
+// CHECK-LABEL: test_vclezd_s64
 // CHECK: cmle {{d[0-9]+}}, {{d[0-9]+}}, #0x0
   return (int64_t)vclezd_s64(a);
 }
 
 int64_t test_vcltd_s64(int64_t a, int64_t b) {
-// CHECK: test_vcltd_s64
+// CHECK-LABEL: test_vcltd_s64
 // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vcltd_s64(a, b);
 }
 
 uint64_t test_vcltd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vcltd_u64
+// CHECK-LABEL: test_vcltd_u64
 // CHECK: cmhi {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vcltd_u64(a, b);
 }
 
 int64_t test_vcltzd_s64(int64_t a) {
-// CHECK: test_vcltzd_s64
+// CHECK-LABEL: test_vcltzd_s64
 // CHECK: cmlt {{d[0-9]+}}, {{d[0-9]+}}, #0x0
   return (int64_t)vcltzd_s64(a);
 }
 
 int64_t test_vtstd_s64(int64_t a, int64_t b) {
-// CHECK: test_vtstd_s64
+// CHECK-LABEL: test_vtstd_s64
 // CHECK: cmtst {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vtstd_s64(a, b);
 }
 
 uint64_t test_vtstd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vtstd_u64
+// CHECK-LABEL: test_vtstd_u64
 // CHECK: cmtst {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vtstd_u64(a, b);
 }
 
 int64_t test_vabsd_s64(int64_t a) {
-// CHECK: test_vabsd_s64
+// CHECK-LABEL: test_vabsd_s64
 // CHECK: abs {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vabsd_s64(a);
 }
 
 int8_t test_vqabsb_s8(int8_t a) {
-// CHECK: test_vqabsb_s8
+// CHECK-LABEL: test_vqabsb_s8
 // CHECK: sqabs {{b[0-9]+}}, {{b[0-9]+}}
   return (int8_t)vqabsb_s8(a);
 }
 
 int16_t test_vqabsh_s16(int16_t a) {
-// CHECK: test_vqabsh_s16
+// CHECK-LABEL: test_vqabsh_s16
 // CHECK: sqabs {{h[0-9]+}}, {{h[0-9]+}}
   return (int16_t)vqabsh_s16(a);
 }
 
 int32_t test_vqabss_s32(int32_t a) {
-// CHECK: test_vqabss_s32
+// CHECK-LABEL: test_vqabss_s32
 // CHECK: sqabs {{s[0-9]+}}, {{s[0-9]+}}
   return (int32_t)vqabss_s32(a);
 }
 
 int64_t test_vqabsd_s64(int64_t a) {
-// CHECK: test_vqabsd_s64
+// CHECK-LABEL: test_vqabsd_s64
 // CHECK: sqabs {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vqabsd_s64(a);
 }
 
 int64_t test_vnegd_s64(int64_t a) {
-// CHECK: test_vnegd_s64
+// CHECK-LABEL: test_vnegd_s64
 // CHECK: neg {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vnegd_s64(a);
 }
 
 int8_t test_vqnegb_s8(int8_t a) {
-// CHECK: test_vqnegb_s8
+// CHECK-LABEL: test_vqnegb_s8
 // CHECK: sqneg {{b[0-9]+}}, {{b[0-9]+}}
   return (int8_t)vqnegb_s8(a);
 }
 
 int16_t test_vqnegh_s16(int16_t a) {
-// CHECK: test_vqnegh_s16
+// CHECK-LABEL: test_vqnegh_s16
 // CHECK: sqneg {{h[0-9]+}}, {{h[0-9]+}}
   return (int16_t)vqnegh_s16(a);
 }
 
 int32_t test_vqnegs_s32(int32_t a) {
-// CHECK: test_vqnegs_s32
+// CHECK-LABEL: test_vqnegs_s32
 // CHECK: sqneg {{s[0-9]+}}, {{s[0-9]+}}
   return (int32_t)vqnegs_s32(a);
 }
 
 int64_t test_vqnegd_s64(int64_t a) {
-// CHECK: test_vqnegd_s64
+// CHECK-LABEL: test_vqnegd_s64
 // CHECK: sqneg {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vqnegd_s64(a);
 }
 
 int8_t test_vuqaddb_s8(int8_t a, int8_t b) {
-// CHECK: test_vuqaddb_s8
+// CHECK-LABEL: test_vuqaddb_s8
 // CHECK: suqadd {{b[0-9]+}}, {{b[0-9]+}}
   return (int8_t)vuqaddb_s8(a, b);
 }
 
 int16_t test_vuqaddh_s16(int16_t a, int16_t b) {
-// CHECK: test_vuqaddh_s16
+// CHECK-LABEL: test_vuqaddh_s16
 // CHECK: suqadd {{h[0-9]+}}, {{h[0-9]+}}
   return (int16_t)vuqaddh_s16(a, b);
 }
 
 int32_t test_vuqadds_s32(int32_t a, int32_t b) {
-// CHECK: test_vuqadds_s32
+// CHECK-LABEL: test_vuqadds_s32
 // CHECK: suqadd {{s[0-9]+}}, {{s[0-9]+}}
   return (int32_t)vuqadds_s32(a, b);
 }
 
 int64_t test_vuqaddd_s64(int64_t a, int64_t b) {
-// CHECK: test_vuqaddd_s64
+// CHECK-LABEL: test_vuqaddd_s64
 // CHECK: suqadd {{d[0-9]+}}, {{d[0-9]+}}
   return (int64_t)vuqaddd_s64(a, b);
 }
 
 uint8_t test_vsqaddb_u8(uint8_t a, uint8_t b) {
-// CHECK: test_vsqaddb_u8
+// CHECK-LABEL: test_vsqaddb_u8
 // CHECK: usqadd {{b[0-9]+}}, {{b[0-9]+}}
   return (uint8_t)vsqaddb_u8(a, b);
 }
 
 uint16_t test_vsqaddh_u16(uint16_t a, uint16_t b) {
-// CHECK: test_vsqaddh_u16
+// CHECK-LABEL: test_vsqaddh_u16
 // CHECK: usqadd {{h[0-9]+}}, {{h[0-9]+}}
   return (uint16_t)vsqaddh_u16(a, b);
 }
 
 uint32_t test_vsqadds_u32(uint32_t a, uint32_t b) {
-// CHECK: test_vsqadds_u32
+// CHECK-LABEL: test_vsqadds_u32
 // CHECK: usqadd {{s[0-9]+}}, {{s[0-9]+}}
   return (uint32_t)vsqadds_u32(a, b);
 }
 
 uint64_t test_vsqaddd_u64(uint64_t a, uint64_t b) {
-// CHECK: test_vsqaddd_u64
+// CHECK-LABEL: test_vsqaddd_u64
 // CHECK: usqadd {{d[0-9]+}}, {{d[0-9]+}}
   return (uint64_t)vsqaddd_u64(a, b);
 }
 
 int32_t test_vqdmlalh_s16(int32_t a, int16_t b, int16_t c) {
-// CHECK: test_vqdmlalh_s16
+// CHECK-LABEL: test_vqdmlalh_s16
 // CHECK: sqdmlal {{s[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
   return (int32_t)vqdmlalh_s16(a, b, c);
 }
 
 int64_t test_vqdmlals_s32(int64_t a, int32_t b, int32_t c) {
-// CHECK: test_vqdmlals_s32
+// CHECK-LABEL: test_vqdmlals_s32
 // CHECK: sqdmlal {{d[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
   return (int64_t)vqdmlals_s32(a, b, c);
 }
 
 int32_t test_vqdmlslh_s16(int32_t a, int16_t b, int16_t c) {
-// CHECK: test_vqdmlslh_s16
+// CHECK-LABEL: test_vqdmlslh_s16
 // CHECK: sqdmlsl {{s[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
   return (int32_t)vqdmlslh_s16(a, b, c);
 }
 
 int64_t test_vqdmlsls_s32(int64_t a, int32_t b, int32_t c) {
-// CHECK: test_vqdmlsls_s32
+// CHECK-LABEL: test_vqdmlsls_s32
 // CHECK: sqdmlsl {{d[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
   return (int64_t)vqdmlsls_s32(a, b, c);
 }
 
 int32_t test_vqdmullh_s16(int16_t a, int16_t b) {
-// CHECK: test_vqdmullh_s16
+// CHECK-LABEL: test_vqdmullh_s16
 // CHECK: sqdmull {{s[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
   return (int32_t)vqdmullh_s16(a, b);
 }
 
 int64_t test_vqdmulls_s32(int32_t a, int32_t b) {
-// CHECK: test_vqdmulls_s32
+// CHECK-LABEL: test_vqdmulls_s32
 // CHECK: sqdmull {{d[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}}
   return (int64_t)vqdmulls_s32(a, b);
 }
 
 int8_t test_vqmovunh_s16(int16_t a) {
-// CHECK: test_vqmovunh_s16
+// CHECK-LABEL: test_vqmovunh_s16
 // CHECK: sqxtun {{b[0-9]+}}, {{h[0-9]+}}
   return (int8_t)vqmovunh_s16(a);
 }
 
 int16_t test_vqmovuns_s32(int32_t a) {
-// CHECK: test_vqmovuns_s32
+// CHECK-LABEL: test_vqmovuns_s32
 // CHECK: sqxtun {{h[0-9]+}}, {{s[0-9]+}}
   return (int16_t)vqmovuns_s32(a);
 }
 
 int32_t test_vqmovund_s64(int64_t a) {
-// CHECK: test_vqmovund_s64
+// CHECK-LABEL: test_vqmovund_s64
 // CHECK: sqxtun {{s[0-9]+}}, {{d[0-9]+}}
   return (int32_t)vqmovund_s64(a);
 }
 
 int8_t test_vqmovnh_s16(int16_t a) {
-// CHECK: test_vqmovnh_s16
+// CHECK-LABEL: test_vqmovnh_s16
 // CHECK: sqxtn {{b[0-9]+}}, {{h[0-9]+}}
   return (int8_t)vqmovnh_s16(a);
 }
 
 int16_t test_vqmovns_s32(int32_t a) {
-// CHECK: test_vqmovns_s32
+// CHECK-LABEL: test_vqmovns_s32
 // CHECK: sqxtn {{h[0-9]+}}, {{s[0-9]+}}
   return (int16_t)vqmovns_s32(a);
 }
 
 int32_t test_vqmovnd_s64(int64_t a) {
-// CHECK: test_vqmovnd_s64
+// CHECK-LABEL: test_vqmovnd_s64
 // CHECK: sqxtn {{s[0-9]+}}, {{d[0-9]+}}
   return (int32_t)vqmovnd_s64(a);
 }
 
 int8_t test_vqmovnh_u16(int16_t a) {
-// CHECK: test_vqmovnh_u16
+// CHECK-LABEL: test_vqmovnh_u16
 // CHECK: uqxtn {{b[0-9]+}}, {{h[0-9]+}}
   return (int8_t)vqmovnh_u16(a);
 }
 
 int16_t test_vqmovns_u32(int32_t a) {
-// CHECK: test_vqmovns_u32
+// CHECK-LABEL: test_vqmovns_u32
 // CHECK: uqxtn {{h[0-9]+}}, {{s[0-9]+}}
   return (int16_t)vqmovns_u32(a);
 }
 
 int32_t test_vqmovnd_u64(int64_t a) {
-// CHECK: test_vqmovnd_u64
+// CHECK-LABEL: test_vqmovnd_u64
 // CHECK: uqxtn {{s[0-9]+}}, {{d[0-9]+}}
   return (int32_t)vqmovnd_u64(a);
 }
 
 uint32_t test_vceqs_f32(float32_t a, float32_t b) {
-// CHECK: test_vceqs_f32
+// CHECK-LABEL: test_vceqs_f32
 // CHECK: fcmeq s0, s0, s1
   return (uint32_t)vceqs_f32(a, b);
 }
 
 uint64_t test_vceqd_f64(float64_t a, float64_t b) {
-// CHECK: test_vceqd_f64
+// CHECK-LABEL: test_vceqd_f64
 // CHECK: fcmeq d0, d0, d1
   return (uint64_t)vceqd_f64(a, b);
 }
 
 uint32_t test_vceqzs_f32(float32_t a) {
-// CHECK: test_vceqzs_f32
+// CHECK-LABEL: test_vceqzs_f32
 // CHECK: fcmeq s0, s0, #0.0
   return (uint32_t)vceqzs_f32(a);
 }
 
 uint64_t test_vceqzd_f64(float64_t a) {
-// CHECK: test_vceqzd_f64
+// CHECK-LABEL: test_vceqzd_f64
 // CHECK: fcmeq d0, d0, #0.0
   return (uint64_t)vceqzd_f64(a);
 }
 
 uint32_t test_vcges_f32(float32_t a, float32_t b) {
-// CHECK: test_vcges_f32
+// CHECK-LABEL: test_vcges_f32
 // CHECK: fcmge s0, s0, s1
   return (uint32_t)vcges_f32(a, b);
 }
 
 uint64_t test_vcged_f64(float64_t a, float64_t b) {
-// CHECK: test_vcged_f64
+// CHECK-LABEL: test_vcged_f64
 // CHECK: fcmge d0, d0, d1
   return (uint64_t)vcged_f64(a, b);
 }
 
 uint32_t test_vcgezs_f32(float32_t a) {
-// CHECK: test_vcgezs_f32
+// CHECK-LABEL: test_vcgezs_f32
 // CHECK: fcmge s0, s0, #0.0
   return (uint32_t)vcgezs_f32(a);
 }
 
 uint64_t test_vcgezd_f64(float64_t a) {
-// CHECK: test_vcgezd_f64
+// CHECK-LABEL: test_vcgezd_f64
 // CHECK: fcmge d0, d0, #0.0
   return (uint64_t)vcgezd_f64(a);
 }
 
 uint32_t test_vcgts_f32(float32_t a, float32_t b) {
-// CHECK: test_vcgts_f32
+// CHECK-LABEL: test_vcgts_f32
 // CHECK: fcmgt s0, s0, s1
   return (uint32_t)vcgts_f32(a, b);
 }
 
 uint64_t test_vcgtd_f64(float64_t a, float64_t b) {
-// CHECK: test_vcgtd_f64
+// CHECK-LABEL: test_vcgtd_f64
 // CHECK: fcmgt d0, d0, d1
   return (uint64_t)vcgtd_f64(a, b);
 }
 
 uint32_t test_vcgtzs_f32(float32_t a) {
-// CHECK: test_vcgtzs_f32
+// CHECK-LABEL: test_vcgtzs_f32
 // CHECK: fcmgt s0, s0, #0.0
   return (uint32_t)vcgtzs_f32(a);
 }
 
 uint64_t test_vcgtzd_f64(float64_t a) {
-// CHECK: test_vcgtzd_f64
+// CHECK-LABEL: test_vcgtzd_f64
 // CHECK: fcmgt d0, d0, #0.0
   return (uint64_t)vcgtzd_f64(a);
 }
 
 uint32_t test_vcles_f32(float32_t a, float32_t b) {
-// CHECK: test_vcles_f32
+// CHECK-LABEL: test_vcles_f32
 // CHECK: fcmge s0, s1, s0
   return (uint32_t)vcles_f32(a, b);
 }
 
 uint64_t test_vcled_f64(float64_t a, float64_t b) {
-// CHECK: test_vcled_f64
+// CHECK-LABEL: test_vcled_f64
 // CHECK: fcmge d0, d1, d0
   return (uint64_t)vcled_f64(a, b);
 }
 
 uint32_t test_vclezs_f32(float32_t a) {
-// CHECK: test_vclezs_f32
+// CHECK-LABEL: test_vclezs_f32
 // CHECK: fcmle s0, s0, #0.0
   return (uint32_t)vclezs_f32(a);
 }
 
 uint64_t test_vclezd_f64(float64_t a) {
-// CHECK: test_vclezd_f64
+// CHECK-LABEL: test_vclezd_f64
 // CHECK: fcmle d0, d0, #0.0
   return (uint64_t)vclezd_f64(a);
 }
 
 uint32_t test_vclts_f32(float32_t a, float32_t b) {
-// CHECK: test_vclts_f32
+// CHECK-LABEL: test_vclts_f32
 // CHECK: fcmgt s0, s1, s0
   return (uint32_t)vclts_f32(a, b);
 }
 
 uint64_t test_vcltd_f64(float64_t a, float64_t b) {
-// CHECK: test_vcltd_f64
+// CHECK-LABEL: test_vcltd_f64
 // CHECK: fcmgt d0, d1, d0
   return (uint64_t)vcltd_f64(a, b);
 }
 
 uint32_t test_vcltzs_f32(float32_t a) {
-// CHECK: test_vcltzs_f32
+// CHECK-LABEL: test_vcltzs_f32
 // CHECK: fcmlt s0, s0, #0.0
   return (uint32_t)vcltzs_f32(a);
 }
 
 uint64_t test_vcltzd_f64(float64_t a) {
-// CHECK: test_vcltzd_f64
+// CHECK-LABEL: test_vcltzd_f64
 // CHECK: fcmlt d0, d0, #0.0
   return (uint64_t)vcltzd_f64(a);
 }
 
 uint32_t test_vcages_f32(float32_t a, float32_t b) {
-// CHECK: test_vcages_f32
+// CHECK-LABEL: test_vcages_f32
 // CHECK: facge s0, s0, s1
   return (uint32_t)vcages_f32(a, b);
 }
 
 uint64_t test_vcaged_f64(float64_t a, float64_t b) {
-// CHECK: test_vcaged_f64
+// CHECK-LABEL: test_vcaged_f64
 // CHECK: facge d0, d0, d1
   return (uint64_t)vcaged_f64(a, b);
 }
 
 uint32_t test_vcagts_f32(float32_t a, float32_t b) {
-// CHECK: test_vcagts_f32
+// CHECK-LABEL: test_vcagts_f32
 // CHECK: facgt s0, s0, s1
   return (uint32_t)vcagts_f32(a, b);
 }
 
 uint64_t test_vcagtd_f64(float64_t a, float64_t b) {
-// CHECK: test_vcagtd_f64
+// CHECK-LABEL: test_vcagtd_f64
 // CHECK: facgt d0, d0, d1
   return (uint64_t)vcagtd_f64(a, b);
 }
 
 uint32_t test_vcales_f32(float32_t a, float32_t b) {
-// CHECK: test_vcales_f32
+// CHECK-LABEL: test_vcales_f32
 // CHECK: facge s0, s1, s0
   return (uint32_t)vcales_f32(a, b);
 }
 
 uint64_t test_vcaled_f64(float64_t a, float64_t b) {
-// CHECK: test_vcaled_f64
+// CHECK-LABEL: test_vcaled_f64
 // CHECK: facge d0, d1, d0
   return (uint64_t)vcaled_f64(a, b);
 }
 
 uint32_t test_vcalts_f32(float32_t a, float32_t b) {
-// CHECK: test_vcalts_f32
+// CHECK-LABEL: test_vcalts_f32
 // CHECK: facgt s0, s1, s0
   return (uint32_t)vcalts_f32(a, b);
 }
 
 uint64_t test_vcaltd_f64(float64_t a, float64_t b) {
-// CHECK: test_vcaltd_f64
+// CHECK-LABEL: test_vcaltd_f64
 // CHECK: facgt d0, d1, d0
   return (uint64_t)vcaltd_f64(a, b);
 }
@@ -8795,7 +8795,7 @@ int64_t test_vrshrd_n_s64(int64_t a) {
 }
 
 int64x1_t test_vrshr_n_s64(int64x1_t a) {
-// CHECK: test_vrshr_n_s64
+// CHECK-LABEL: test_vrshr_n_s64
 // CHECK: srshr d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vrshr_n_s64(a, 1);
 }
@@ -8807,7 +8807,7 @@ uint64_t test_vrshrd_n_u64(uint64_t a) {
 }
 
 uint64x1_t test_vrshr_n_u64(uint64x1_t a) {
-// CHECK: test_vrshr_n_u64
+// CHECK-LABEL: test_vrshr_n_u64
 // CHECK: urshr d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vrshr_n_u64(a, 1);
 }
@@ -8819,7 +8819,7 @@ int64_t test_vsrad_n_s64(int64_t a, int6
 }
 
 int64x1_t test_vsra_n_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vsra_n_s64
+// CHECK-LABEL: test_vsra_n_s64
 // CHECK: ssra d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vsra_n_s64(a, b, 1);
 }
@@ -8831,7 +8831,7 @@ uint64_t test_vsrad_n_u64(uint64_t a, ui
 }
 
 uint64x1_t test_vsra_n_u64(uint64x1_t a, uint64x1_t b) {
-// CHECK: test_vsra_n_u64
+// CHECK-LABEL: test_vsra_n_u64
 // CHECK: usra d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vsra_n_u64(a, b, 1);
 }
@@ -8843,7 +8843,7 @@ int64_t test_vrsrad_n_s64(int64_t a, int
 }
 
 int64x1_t test_vrsra_n_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vrsra_n_s64
+// CHECK-LABEL: test_vrsra_n_s64
 // CHECK: srsra d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vrsra_n_s64(a, b, 1);
 }
@@ -8855,7 +8855,7 @@ uint64_t test_vrsrad_n_u64(uint64_t a, u
 }
 
 uint64x1_t test_vrsra_n_u64(uint64x1_t a, uint64x1_t b) {
-// CHECK: test_vrsra_n_u64
+// CHECK-LABEL: test_vrsra_n_u64
 // CHECK: ursra d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vrsra_n_u64(a, b, 1);
 }
@@ -8866,7 +8866,7 @@ int64_t test_vshld_n_s64(int64_t a) {
   return (int64_t)vshld_n_s64(a, 0);
 }
 int64x1_t test_vshl_n_s64(int64x1_t a) {
-// CHECK: test_vshl_n_s64
+// CHECK-LABEL: test_vshl_n_s64
 // CHECK: shl d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vshl_n_s64(a, 1);
 }
@@ -8878,7 +8878,7 @@ uint64_t test_vshld_n_u64(uint64_t a) {
 }
 
 uint64x1_t test_vshl_n_u64(uint64x1_t a) {
-// CHECK: test_vshl_n_u64
+// CHECK-LABEL: test_vshl_n_u64
 // CHECK: shl d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vshl_n_u64(a, 1);
 }
@@ -8992,7 +8992,7 @@ uint64x2_t test_vqshlq_n_u64(uint64x2_t
 }
 
 int64x1_t test_vqshl_n_s64(int64x1_t a) {
-// CHECK: test_vqshl_n_s64
+// CHECK-LABEL: test_vqshl_n_s64
 // CHECK: sqshl d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vqshl_n_s64(a, 1);
 }
@@ -9022,7 +9022,7 @@ uint64_t test_vqshld_n_u64(uint64_t a) {
 }
 
 uint64x1_t test_vqshl_n_u64(uint64x1_t a) {
-// CHECK: test_vqshl_n_u64
+// CHECK-LABEL: test_vqshl_n_u64
 // CHECK: uqshl d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vqshl_n_u64(a, 1);
 }
@@ -9052,7 +9052,7 @@ int64_t test_vqshlud_n_s64(int64_t a) {
 }
 
 uint64x1_t test_vqshlu_n_s64(int64x1_t a) {
-// CHECK: test_vqshlu_n_s64
+// CHECK-LABEL: test_vqshlu_n_s64
 // CHECK: sqshlu d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vqshlu_n_s64(a, 1);
 }
@@ -9064,7 +9064,7 @@ int64_t test_vsrid_n_s64(int64_t a, int6
 }
 
 int64x1_t test_vsri_n_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vsri_n_s64
+// CHECK-LABEL: test_vsri_n_s64
 // CHECK: sri d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vsri_n_s64(a, b, 1);
 }
@@ -9076,7 +9076,7 @@ uint64_t test_vsrid_n_u64(uint64_t a, ui
 }
 
 uint64x1_t test_vsri_n_u64(uint64x1_t a, uint64x1_t b) {
-// CHECK: test_vsri_n_u64
+// CHECK-LABEL: test_vsri_n_u64
 // CHECK: sri d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vsri_n_u64(a, b, 1);
 }
@@ -9088,7 +9088,7 @@ int64_t test_vslid_n_s64(int64_t a, int6
 }
 
 int64x1_t test_vsli_n_s64(int64x1_t a, int64x1_t b) {
-// CHECK: test_vsli_n_s64
+// CHECK-LABEL: test_vsli_n_s64
 // CHECK: sli d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vsli_n_s64(a, b, 1);
 }
@@ -9100,7 +9100,7 @@ uint64_t test_vslid_n_u64(uint64_t a, ui
 }
 
 uint64x1_t test_vsli_n_u64(uint64x1_t a, uint64x1_t b) {
-// CHECK: test_vsli_n_u64
+// CHECK-LABEL: test_vsli_n_u64
 // CHECK: sli d{{[0-9]+}}, d{{[0-9]+}}, #1
   return vsli_n_u64(a, b, 1);
 }
@@ -9214,49 +9214,49 @@ int32_t test_vqrshrund_n_s64(int64_t a)
 }
 
 float32_t test_vcvts_n_f32_s32(int32_t a) {
-// CHECK: test_vcvts_n_f32_s32
+// CHECK-LABEL: test_vcvts_n_f32_s32
 // CHECK: scvtf {{s[0-9]+}}, {{s[0-9]+}}, #1
   return vcvts_n_f32_s32(a, 1);
 }
 
 float64_t test_vcvtd_n_f64_s64(int64_t a) {
-// CHECK: test_vcvtd_n_f64_s64
+// CHECK-LABEL: test_vcvtd_n_f64_s64
 // CHECK: scvtf {{d[0-9]+}}, {{d[0-9]+}}, #1
   return vcvtd_n_f64_s64(a, 1);
 }
 
 float32_t test_vcvts_n_f32_u32(uint32_t a) {
-// CHECK: test_vcvts_n_f32_u32
+// CHECK-LABEL: test_vcvts_n_f32_u32
 // CHECK: ucvtf {{s[0-9]+}}, {{s[0-9]+}}, #32
   return vcvts_n_f32_u32(a, 32);
 }
 
 float64_t test_vcvtd_n_f64_u64(uint64_t a) {
-// CHECK: test_vcvtd_n_f64_u64
+// CHECK-LABEL: test_vcvtd_n_f64_u64
 // CHECK: ucvtf {{d[0-9]+}}, {{d[0-9]+}}, #64
   return vcvtd_n_f64_u64(a, 64);
 }
 
 int32_t test_vcvts_n_s32_f32(float32_t a) {
-// CHECK: test_vcvts_n_s32_f32
+// CHECK-LABEL: test_vcvts_n_s32_f32
 // CHECK: fcvtzs {{s[0-9]+}}, {{s[0-9]+}}, #1
   return (int32_t)vcvts_n_s32_f32(a, 1);
 }
 
 int64_t test_vcvtd_n_s64_f64(float64_t a) {
-// CHECK: test_vcvtd_n_s64_f64
+// CHECK-LABEL: test_vcvtd_n_s64_f64
 // CHECK: fcvtzs {{d[0-9]+}}, {{d[0-9]+}}, #1
   return (int64_t)vcvtd_n_s64_f64(a, 1);
 }
 
 uint32_t test_vcvts_n_u32_f32(float32_t a) {
-// CHECK: test_vcvts_n_u32_f32
+// CHECK-LABEL: test_vcvts_n_u32_f32
 // CHECK: fcvtzu {{s[0-9]+}}, {{s[0-9]+}}, #32
   return (uint32_t)vcvts_n_u32_f32(a, 32);
 }
 
 uint64_t test_vcvtd_n_u64_f64(float64_t a) {
-// CHECK: test_vcvtd_n_u64_f64
+// CHECK-LABEL: test_vcvtd_n_u64_f64
 // CHECK: fcvtzu {{d[0-9]+}}, {{d[0-9]+}}, #64
   return (uint64_t)vcvtd_n_u64_f64(a, 64);
 }

Modified: cfe/trunk/test/CodeGen/aarch64-neon-misc.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-misc.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-misc.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-misc.c Mon Mar  3 05:34:36 2014
@@ -6,2036 +6,2036 @@
 
 #include <arm_neon.h>
 
-// CHECK: test_vceqz_s8
+// CHECK-LABEL: test_vceqz_s8
 // CHECK: cmeq  {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x0
 uint8x8_t test_vceqz_s8(int8x8_t a) {
   return vceqz_s8(a);
 }
 
-// CHECK: test_vceqz_s16
+// CHECK-LABEL: test_vceqz_s16
 // CHECK: cmeq  {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #0x0
 uint16x4_t test_vceqz_s16(int16x4_t a) {
   return vceqz_s16(a);
 }
 
-// CHECK: test_vceqz_s32
+// CHECK-LABEL: test_vceqz_s32
 // CHECK: cmeq  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0x0
 uint32x2_t test_vceqz_s32(int32x2_t a) {
   return vceqz_s32(a);
 }
 
-// CHECK: test_vceqz_s64
+// CHECK-LABEL: test_vceqz_s64
 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, #0x0
 uint64x1_t test_vceqz_s64(int64x1_t a) {
   return vceqz_s64(a);
 }
 
-// CHECK: test_vceqz_u64
+// CHECK-LABEL: test_vceqz_u64
 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, #0x0
 uint64x1_t test_vceqz_u64(uint64x1_t a) {
   return vceqz_u64(a);
 }
 
-// CHECK: test_vceqz_p64
+// CHECK-LABEL: test_vceqz_p64
 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, #0x0
 uint64x1_t test_vceqz_p64(poly64x1_t a) {
   return vceqz_p64(a);
 }
 
-// CHECK: test_vceqzq_s8
+// CHECK-LABEL: test_vceqzq_s8
 // CHECK: cmeq  {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x0
 uint8x16_t test_vceqzq_s8(int8x16_t a) {
   return vceqzq_s8(a);
 }
 
-// CHECK: test_vceqzq_s16
+// CHECK-LABEL: test_vceqzq_s16
 // CHECK: cmeq  {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #0x0
 uint16x8_t test_vceqzq_s16(int16x8_t a) {
   return vceqzq_s16(a);
 }
 
-// CHECK: test_vceqzq_s32
+// CHECK-LABEL: test_vceqzq_s32
 // CHECK: cmeq  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0x0
 uint32x4_t test_vceqzq_s32(int32x4_t a) {
   return vceqzq_s32(a);
 }
 
-// CHECK: test_vceqzq_s64
+// CHECK-LABEL: test_vceqzq_s64
 // CHECK: cmeq  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0x0
 uint64x2_t test_vceqzq_s64(int64x2_t a) {
   return vceqzq_s64(a);
 }
 
-// CHECK: test_vceqz_u8
+// CHECK-LABEL: test_vceqz_u8
 // CHECK: cmeq  {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x0
 uint8x8_t test_vceqz_u8(uint8x8_t a) {
   return vceqz_u8(a);
 }
 
-// CHECK: test_vceqz_u16
+// CHECK-LABEL: test_vceqz_u16
 // CHECK: cmeq  {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #0x0
 uint16x4_t test_vceqz_u16(uint16x4_t a) {
   return vceqz_u16(a);
 }
 
-// CHECK: test_vceqz_u32
+// CHECK-LABEL: test_vceqz_u32
 // CHECK: cmeq  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0x0
 uint32x2_t test_vceqz_u32(uint32x2_t a) {
   return vceqz_u32(a);
 }
 
-// CHECK: test_vceqzq_u8
+// CHECK-LABEL: test_vceqzq_u8
 // CHECK: cmeq  {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x0
 uint8x16_t test_vceqzq_u8(uint8x16_t a) {
   return vceqzq_u8(a);
 }
 
-// CHECK: test_vceqzq_u16
+// CHECK-LABEL: test_vceqzq_u16
 // CHECK: cmeq  {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #0x0
 uint16x8_t test_vceqzq_u16(uint16x8_t a) {
   return vceqzq_u16(a);
 }
 
-// CHECK: test_vceqzq_u32
+// CHECK-LABEL: test_vceqzq_u32
 // CHECK: cmeq  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0x0
 uint32x4_t test_vceqzq_u32(uint32x4_t a) {
   return vceqzq_u32(a);
 }
 
-// CHECK: test_vceqzq_u64
+// CHECK-LABEL: test_vceqzq_u64
 // CHECK: cmeq  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0x0
 uint64x2_t test_vceqzq_u64(uint64x2_t a) {
   return vceqzq_u64(a);
 }
 
-// CHECK: test_vceqz_f32
+// CHECK-LABEL: test_vceqz_f32
 // CHECK: fcmeq  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0
 uint32x2_t test_vceqz_f32(float32x2_t a) {
   return vceqz_f32(a);
 }
 
-// CHECK: test_vceqz_f64
+// CHECK-LABEL: test_vceqz_f64
 // CHECK: fcmeq  {{d[0-9]+}}, {{d[0-9]+}}, #0
 uint64x1_t test_vceqz_f64(float64x1_t a) {
   return vceqz_f64(a);
 }
 
-// CHECK: test_vceqzq_f32
+// CHECK-LABEL: test_vceqzq_f32
 // CHECK: fcmeq  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0
 uint32x4_t test_vceqzq_f32(float32x4_t a) {
   return vceqzq_f32(a);
 }
 
-// CHECK: test_vceqz_p8
+// CHECK-LABEL: test_vceqz_p8
 // CHECK: cmeq  {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x0
 uint8x8_t test_vceqz_p8(poly8x8_t a) {
   return vceqz_p8(a);
 }
 
-// CHECK: test_vceqzq_p8
+// CHECK-LABEL: test_vceqzq_p8
 // CHECK: cmeq  {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x0
 uint8x16_t test_vceqzq_p8(poly8x16_t a) {
   return vceqzq_p8(a);
 }
 
-// CHECK: test_vceqz_p16
+// CHECK-LABEL: test_vceqz_p16
 // CHECK: cmeq  {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #0x0
 uint16x4_t test_vceqz_p16(poly16x4_t a) {
   return vceqz_p16(a);
 }
 
-// CHECK: test_vceqzq_p16
+// CHECK-LABEL: test_vceqzq_p16
 // CHECK: cmeq  {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #0x0
 uint16x8_t test_vceqzq_p16(poly16x8_t a) {
   return vceqzq_p16(a);
 }
 
-// CHECK: test_vceqzq_f64
+// CHECK-LABEL: test_vceqzq_f64
 // CHECK: fcmeq  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0
 uint64x2_t test_vceqzq_f64(float64x2_t a) {
   return vceqzq_f64(a);
 }
 
-// CHECK: test_vceqzq_p64
+// CHECK-LABEL: test_vceqzq_p64
 // CHECK: cmeq  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0
 uint64x2_t test_vceqzq_p64(poly64x2_t a) {
   return vceqzq_p64(a);
 }
 
-// CHECK: test_vcgez_s8
+// CHECK-LABEL: test_vcgez_s8
 // CHECK: cmge  {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x0
 uint8x8_t test_vcgez_s8(int8x8_t a) {
   return vcgez_s8(a);
 }
 
-// CHECK: test_vcgez_s16
+// CHECK-LABEL: test_vcgez_s16
 // CHECK: cmge  {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #0x0
 uint16x4_t test_vcgez_s16(int16x4_t a) {
   return vcgez_s16(a);
 }
 
-// CHECK: test_vcgez_s32
+// CHECK-LABEL: test_vcgez_s32
 // CHECK: cmge  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0x0
 uint32x2_t test_vcgez_s32(int32x2_t a) {
   return vcgez_s32(a);
 }
 
-// CHECK: test_vcgez_s64
+// CHECK-LABEL: test_vcgez_s64
 // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, #0x0
 uint64x1_t test_vcgez_s64(int64x1_t a) {
   return vcgez_s64(a);
 }
 
-// CHECK: test_vcgezq_s8
+// CHECK-LABEL: test_vcgezq_s8
 // CHECK: cmge  {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x0
 uint8x16_t test_vcgezq_s8(int8x16_t a) {
   return vcgezq_s8(a);
 }
 
-// CHECK: test_vcgezq_s16
+// CHECK-LABEL: test_vcgezq_s16
 // CHECK: cmge  {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #0x0
 uint16x8_t test_vcgezq_s16(int16x8_t a) {
   return vcgezq_s16(a);
 }
 
-// CHECK: test_vcgezq_s32
+// CHECK-LABEL: test_vcgezq_s32
 // CHECK: cmge  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0x0
 uint32x4_t test_vcgezq_s32(int32x4_t a) {
   return vcgezq_s32(a);
 }
 
-// CHECK: test_vcgezq_s64
+// CHECK-LABEL: test_vcgezq_s64
 // CHECK: cmge  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0x0
 uint64x2_t test_vcgezq_s64(int64x2_t a) {
   return vcgezq_s64(a);
 }
 
-// CHECK: test_vcgez_f32
+// CHECK-LABEL: test_vcgez_f32
 // CHECK: fcmge  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0
 uint32x2_t test_vcgez_f32(float32x2_t a) {
   return vcgez_f32(a);
 }
 
-// CHECK: test_vcgez_f64
+// CHECK-LABEL: test_vcgez_f64
 // CHECK: fcmge  {{d[0-9]+}}, {{d[0-9]+}}, #0
 uint64x1_t test_vcgez_f64(float64x1_t a) {
   return vcgez_f64(a);
 }
 
-// CHECK: test_vcgezq_f32
+// CHECK-LABEL: test_vcgezq_f32
 // CHECK: fcmge  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0
 uint32x4_t test_vcgezq_f32(float32x4_t a) {
   return vcgezq_f32(a);
 }
 
-// CHECK: test_vcgezq_f64
+// CHECK-LABEL: test_vcgezq_f64
 // CHECK: fcmge  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0
 uint64x2_t test_vcgezq_f64(float64x2_t a) {
   return vcgezq_f64(a);
 }
 
-// CHECK: test_vclez_s8
+// CHECK-LABEL: test_vclez_s8
 // CHECK: cmle  {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x0
 uint8x8_t test_vclez_s8(int8x8_t a) {
   return vclez_s8(a);
 }
 
-// CHECK: test_vclez_s16
+// CHECK-LABEL: test_vclez_s16
 // CHECK: cmle  {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #0x0
 uint16x4_t test_vclez_s16(int16x4_t a) {
   return vclez_s16(a);
 }
 
-// CHECK: test_vclez_s32
+// CHECK-LABEL: test_vclez_s32
 // CHECK: cmle  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0x0
 uint32x2_t test_vclez_s32(int32x2_t a) {
   return vclez_s32(a);
 }
 
-// CHECK: test_vclez_s64
+// CHECK-LABEL: test_vclez_s64
 // CHECK: cmle {{d[0-9]+}}, {{d[0-9]+}}, #0x0
 uint64x1_t test_vclez_s64(int64x1_t a) {
   return vclez_s64(a);
 }
 
-// CHECK: test_vclezq_s8
+// CHECK-LABEL: test_vclezq_s8
 // CHECK: cmle  {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x0
 uint8x16_t test_vclezq_s8(int8x16_t a) {
   return vclezq_s8(a);
 }
 
-// CHECK: test_vclezq_s16
+// CHECK-LABEL: test_vclezq_s16
 // CHECK: cmle  {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #0x0
 uint16x8_t test_vclezq_s16(int16x8_t a) {
   return vclezq_s16(a);
 }
 
-// CHECK: test_vclezq_s32
+// CHECK-LABEL: test_vclezq_s32
 // CHECK: cmle  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0x0
 uint32x4_t test_vclezq_s32(int32x4_t a) {
   return vclezq_s32(a);
 }
 
-// CHECK: test_vclezq_s64
+// CHECK-LABEL: test_vclezq_s64
 // CHECK: cmle  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0x0
 uint64x2_t test_vclezq_s64(int64x2_t a) {
   return vclezq_s64(a);
 }
 
-// CHECK: test_vclez_f32
+// CHECK-LABEL: test_vclez_f32
 // CHECK: fcmle  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0
 uint32x2_t test_vclez_f32(float32x2_t a) {
   return vclez_f32(a);
 }
 
-// CHECK: test_vclez_f64
+// CHECK-LABEL: test_vclez_f64
 // CHECK: fcmle  {{d[0-9]+}}, {{d[0-9]+}}, #0
 uint64x1_t test_vclez_f64(float64x1_t a) {
   return vclez_f64(a);
 }
 
-// CHECK: test_vclezq_f32
+// CHECK-LABEL: test_vclezq_f32
 // CHECK: fcmle  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0
 uint32x4_t test_vclezq_f32(float32x4_t a) {
   return vclezq_f32(a);
 }
 
-// CHECK: test_vclezq_f64
+// CHECK-LABEL: test_vclezq_f64
 // CHECK: fcmle  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0
 uint64x2_t test_vclezq_f64(float64x2_t a) {
   return vclezq_f64(a);
 }
 
-// CHECK: test_vcgtz_s8
+// CHECK-LABEL: test_vcgtz_s8
 // CHECK: cmgt  {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #0x0
 uint8x8_t test_vcgtz_s8(int8x8_t a) {
   return vcgtz_s8(a);
 }
 
-// CHECK: test_vcgtz_s16
+// CHECK-LABEL: test_vcgtz_s16
 // CHECK: cmgt  {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #0x0
 uint16x4_t test_vcgtz_s16(int16x4_t a) {
   return vcgtz_s16(a);
 }
 
-// CHECK: test_vcgtz_s32
+// CHECK-LABEL: test_vcgtz_s32
 // CHECK: cmgt  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0x0
 uint32x2_t test_vcgtz_s32(int32x2_t a) {
   return vcgtz_s32(a);
 }
 
-// CHECK: test_vcgtz_s64
+// CHECK-LABEL: test_vcgtz_s64
 // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, #0x0
 uint64x1_t test_vcgtz_s64(int64x1_t a) {
   return vcgtz_s64(a);
 }
 
-// CHECK: test_vcgtzq_s8
+// CHECK-LABEL: test_vcgtzq_s8
 // CHECK: cmgt  {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x0
 uint8x16_t test_vcgtzq_s8(int8x16_t a) {
   return vcgtzq_s8(a);
 }
 
-// CHECK: test_vcgtzq_s16
+// CHECK-LABEL: test_vcgtzq_s16
 // CHECK: cmgt  {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #0x0
 uint16x8_t test_vcgtzq_s16(int16x8_t a) {
   return vcgtzq_s16(a);
 }
 
-// CHECK: test_vcgtzq_s32
+// CHECK-LABEL: test_vcgtzq_s32
 // CHECK: cmgt  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0x0
 uint32x4_t test_vcgtzq_s32(int32x4_t a) {
   return vcgtzq_s32(a);
 }
 
-// CHECK: test_vcgtzq_s64
+// CHECK-LABEL: test_vcgtzq_s64
 // CHECK: cmgt  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0x0
 uint64x2_t test_vcgtzq_s64(int64x2_t a) {
   return vcgtzq_s64(a);
 }
 
-// CHECK: test_vcgtz_f32
+// CHECK-LABEL: test_vcgtz_f32
 // CHECK: fcmgt  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0
 uint32x2_t test_vcgtz_f32(float32x2_t a) {
   return vcgtz_f32(a);
 }
 
-// CHECK: test_vcgtz_f64
+// CHECK-LABEL: test_vcgtz_f64
 // CHECK: fcmgt  {{d[0-9]+}}, {{d[0-9]+}}, #0
 uint64x1_t test_vcgtz_f64(float64x1_t a) {
   return vcgtz_f64(a);
 }
 
-// CHECK: test_vcgtzq_f32
+// CHECK-LABEL: test_vcgtzq_f32
 // CHECK: fcmgt  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0
 uint32x4_t test_vcgtzq_f32(float32x4_t a) {
   return vcgtzq_f32(a);
 }
 
-// CHECK: test_vcgtzq_f64
+// CHECK-LABEL: test_vcgtzq_f64
 // CHECK: fcmgt  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0
 uint64x2_t test_vcgtzq_f64(float64x2_t a) {
   return vcgtzq_f64(a);
 }
 
-// CHECK: test_vcltz_s8
+// CHECK-LABEL: test_vcltz_s8
 // CHECK: sshr  {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #7
 uint8x8_t test_vcltz_s8(int8x8_t a) {
   return vcltz_s8(a);
 }
 
-// CHECK: test_vcltz_s16
+// CHECK-LABEL: test_vcltz_s16
 // CHECK: sshr  {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #15
 uint16x4_t test_vcltz_s16(int16x4_t a) {
   return vcltz_s16(a);
 }
 
-// CHECK: test_vcltz_s32
+// CHECK-LABEL: test_vcltz_s32
 // CHECK: sshr  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31
 uint32x2_t test_vcltz_s32(int32x2_t a) {
   return vcltz_s32(a);
 }
 
-// CHECK: test_vcltz_s64
+// CHECK-LABEL: test_vcltz_s64
 // CHECK: sshr {{d[0-9]+}}, {{d[0-9]+}}, #63
 uint64x1_t test_vcltz_s64(int64x1_t a) {
   return vcltz_s64(a);
 }
 
-// CHECK: test_vcltzq_s8
+// CHECK-LABEL: test_vcltzq_s8
 // CHECK: sshr  {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #7
 uint8x16_t test_vcltzq_s8(int8x16_t a) {
   return vcltzq_s8(a);
 }
 
-// CHECK: test_vcltzq_s16
+// CHECK-LABEL: test_vcltzq_s16
 // CHECK: sshr  {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #15
 uint16x8_t test_vcltzq_s16(int16x8_t a) {
   return vcltzq_s16(a);
 }
 
-// CHECK: test_vcltzq_s32
+// CHECK-LABEL: test_vcltzq_s32
 // CHECK: sshr  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31
 uint32x4_t test_vcltzq_s32(int32x4_t a) {
   return vcltzq_s32(a);
 }
 
-// CHECK: test_vcltzq_s64
+// CHECK-LABEL: test_vcltzq_s64
 // CHECK: sshr  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #63
 uint64x2_t test_vcltzq_s64(int64x2_t a) {
   return vcltzq_s64(a);
 }
 
-// CHECK: test_vcltz_f32
+// CHECK-LABEL: test_vcltz_f32
 // CHECK: fcmlt  {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #0
 uint32x2_t test_vcltz_f32(float32x2_t a) {
   return vcltz_f32(a);
 }
  
-// CHECK: test_vcltz_f64
+// CHECK-LABEL: test_vcltz_f64
 // CHECK: fcmlt  {{d[0-9]+}}, {{d[0-9]+}}, #0
 uint64x1_t test_vcltz_f64(float64x1_t a) {
   return vcltz_f64(a);
 }
 
-// CHECK: test_vcltzq_f32
+// CHECK-LABEL: test_vcltzq_f32
 // CHECK: fcmlt  {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #0
 uint32x4_t test_vcltzq_f32(float32x4_t a) {
   return vcltzq_f32(a);
 }
 
-// CHECK: test_vcltzq_f64
+// CHECK-LABEL: test_vcltzq_f64
 // CHECK: fcmlt  {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #0
 uint64x2_t test_vcltzq_f64(float64x2_t a) {
   return vcltzq_f64(a);
 }
 
-// CHECK: test_vrev16_s8
+// CHECK-LABEL: test_vrev16_s8
 // CHECK: rev16 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 int8x8_t test_vrev16_s8(int8x8_t a) {
   return vrev16_s8(a);
 }
 
-// CHECK: test_vrev16_u8
+// CHECK-LABEL: test_vrev16_u8
 // CHECK: rev16 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 uint8x8_t test_vrev16_u8(uint8x8_t a) {
   return vrev16_u8(a);
 }
 
-// CHECK: test_vrev16_p8
+// CHECK-LABEL: test_vrev16_p8
 // CHECK: rev16 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 poly8x8_t test_vrev16_p8(poly8x8_t a) {
   return vrev16_p8(a);
 }
 
-// CHECK: test_vrev16q_s8
+// CHECK-LABEL: test_vrev16q_s8
 // CHECK: rev16 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 int8x16_t test_vrev16q_s8(int8x16_t a) {
   return vrev16q_s8(a);
 }
 
-// CHECK: test_vrev16q_u8
+// CHECK-LABEL: test_vrev16q_u8
 // CHECK: rev16 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 uint8x16_t test_vrev16q_u8(uint8x16_t a) {
   return vrev16q_u8(a);
 }
 
-// CHECK: test_vrev16q_p8
+// CHECK-LABEL: test_vrev16q_p8
 // CHECK: rev16 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 poly8x16_t test_vrev16q_p8(poly8x16_t a) {
   return vrev16q_p8(a);
 }
 
-// CHECK: test_vrev32_s8
+// CHECK-LABEL: test_vrev32_s8
 // CHECK: rev32 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 int8x8_t test_vrev32_s8(int8x8_t a) {
   return vrev32_s8(a);
 }
 
-// CHECK: test_vrev32_s16
+// CHECK-LABEL: test_vrev32_s16
 // CHECK: rev32 v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 int16x4_t test_vrev32_s16(int16x4_t a) {
   return vrev32_s16(a);
 }
 
-// CHECK: test_vrev32_u8
+// CHECK-LABEL: test_vrev32_u8
 // CHECK: rev32 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 uint8x8_t test_vrev32_u8(uint8x8_t a) {
   return vrev32_u8(a);
 }
 
-// CHECK: test_vrev32_u16
+// CHECK-LABEL: test_vrev32_u16
 // CHECK: rev32 v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 uint16x4_t test_vrev32_u16(uint16x4_t a) {
   return vrev32_u16(a);
 }
 
-// CHECK: test_vrev32_p8
+// CHECK-LABEL: test_vrev32_p8
 // CHECK: rev32 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 poly8x8_t test_vrev32_p8(poly8x8_t a) {
   return vrev32_p8(a);
 }
 
-// CHECK: test_vrev32_p16
+// CHECK-LABEL: test_vrev32_p16
 // CHECK: rev32 v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 poly16x4_t test_vrev32_p16(poly16x4_t a) {
   return vrev32_p16(a);
 }
 
-// CHECK: test_vrev32q_s8
+// CHECK-LABEL: test_vrev32q_s8
 // CHECK: rev32 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 int8x16_t test_vrev32q_s8(int8x16_t a) {
   return vrev32q_s8(a);
 }
 
-// CHECK: test_vrev32q_s16
+// CHECK-LABEL: test_vrev32q_s16
 // CHECK: rev32 v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 int16x8_t test_vrev32q_s16(int16x8_t a) {
   return vrev32q_s16(a);
 }
 
-// CHECK: test_vrev32q_u8
+// CHECK-LABEL: test_vrev32q_u8
 // CHECK: rev32 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 uint8x16_t test_vrev32q_u8(uint8x16_t a) {
   return vrev32q_u8(a);
 }
 
-// CHECK: test_vrev32q_u16
+// CHECK-LABEL: test_vrev32q_u16
 // CHECK: rev32 v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 uint16x8_t test_vrev32q_u16(uint16x8_t a) {
   return vrev32q_u16(a);
 }
 
-// CHECK: test_vrev32q_p8
+// CHECK-LABEL: test_vrev32q_p8
 // CHECK: rev32 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 poly8x16_t test_vrev32q_p8(poly8x16_t a) {
   return vrev32q_p8(a);
 }
 
-// CHECK: test_vrev32q_p16
+// CHECK-LABEL: test_vrev32q_p16
 // CHECK: rev32 v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 poly16x8_t test_vrev32q_p16(poly16x8_t a) {
   return vrev32q_p16(a);
 }
 
-// CHECK: test_vrev64_s8
+// CHECK-LABEL: test_vrev64_s8
 // CHECK: rev64 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 int8x8_t test_vrev64_s8(int8x8_t a) {
   return vrev64_s8(a);
 }
 
-// CHECK: test_vrev64_s16
+// CHECK-LABEL: test_vrev64_s16
 // CHECK: rev64 v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 int16x4_t test_vrev64_s16(int16x4_t a) {
   return vrev64_s16(a);
 }
 
-// CHECK: test_vrev64_s32
+// CHECK-LABEL: test_vrev64_s32
 // CHECK: rev64 v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 int32x2_t test_vrev64_s32(int32x2_t a) {
   return vrev64_s32(a);
 }
 
-// CHECK: test_vrev64_u8
+// CHECK-LABEL: test_vrev64_u8
 // CHECK: rev64 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 uint8x8_t test_vrev64_u8(uint8x8_t a) {
   return vrev64_u8(a);
 }
 
-// CHECK: test_vrev64_u16
+// CHECK-LABEL: test_vrev64_u16
 // CHECK: rev64 v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 uint16x4_t test_vrev64_u16(uint16x4_t a) {
   return vrev64_u16(a);
 }
 
-// CHECK: test_vrev64_u32
+// CHECK-LABEL: test_vrev64_u32
 // CHECK: rev64 v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 uint32x2_t test_vrev64_u32(uint32x2_t a) {
   return vrev64_u32(a);
 }
 
-// CHECK: test_vrev64_p8
+// CHECK-LABEL: test_vrev64_p8
 // CHECK: rev64 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 poly8x8_t test_vrev64_p8(poly8x8_t a) {
   return vrev64_p8(a);
 }
 
-// CHECK: test_vrev64_p16
+// CHECK-LABEL: test_vrev64_p16
 // CHECK: rev64 v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 poly16x4_t test_vrev64_p16(poly16x4_t a) {
   return vrev64_p16(a);
 }
 
-// CHECK: test_vrev64_f32
+// CHECK-LABEL: test_vrev64_f32
 // CHECK: rev64 v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 float32x2_t test_vrev64_f32(float32x2_t a) {
   return vrev64_f32(a);
 }
 
-// CHECK: test_vrev64q_s8
+// CHECK-LABEL: test_vrev64q_s8
 // CHECK: rev64 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 int8x16_t test_vrev64q_s8(int8x16_t a) {
   return vrev64q_s8(a);
 }
 
-// CHECK: test_vrev64q_s16
+// CHECK-LABEL: test_vrev64q_s16
 // CHECK: rev64 v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 int16x8_t test_vrev64q_s16(int16x8_t a) {
   return vrev64q_s16(a);
 }
 
-// CHECK: test_vrev64q_s32
+// CHECK-LABEL: test_vrev64q_s32
 // CHECK: rev64 v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 int32x4_t test_vrev64q_s32(int32x4_t a) {
   return vrev64q_s32(a);
 }
 
-// CHECK: test_vrev64q_u8
+// CHECK-LABEL: test_vrev64q_u8
 // CHECK: rev64 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 uint8x16_t test_vrev64q_u8(uint8x16_t a) {
   return vrev64q_u8(a);
 }
 
-// CHECK: test_vrev64q_u16
+// CHECK-LABEL: test_vrev64q_u16
 // CHECK: rev64 v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 uint16x8_t test_vrev64q_u16(uint16x8_t a) {
   return vrev64q_u16(a);
 }
 
-// CHECK: test_vrev64q_u32
+// CHECK-LABEL: test_vrev64q_u32
 // CHECK: rev64 v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 uint32x4_t test_vrev64q_u32(uint32x4_t a) {
   return vrev64q_u32(a);
 }
 
-// CHECK: test_vrev64q_p8
+// CHECK-LABEL: test_vrev64q_p8
 // CHECK: rev64 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 poly8x16_t test_vrev64q_p8(poly8x16_t a) {
   return vrev64q_p8(a);
 }
 
-// CHECK: test_vrev64q_p16
+// CHECK-LABEL: test_vrev64q_p16
 // CHECK: rev64 v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 poly16x8_t test_vrev64q_p16(poly16x8_t a) {
   return vrev64q_p16(a);
 }
 
-// CHECK: test_vrev64q_f32
+// CHECK-LABEL: test_vrev64q_f32
 // CHECK: rev64 v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 float32x4_t test_vrev64q_f32(float32x4_t a) {
   return vrev64q_f32(a);
 }
 
 int16x4_t test_vpaddl_s8(int8x8_t a) {
-  // CHECK: test_vpaddl_s8
+  // CHECK-LABEL: test_vpaddl_s8
   return vpaddl_s8(a);
   // CHECK: saddlp v{{[0-9]+}}.4h, v{{[0-9]+}}.8b
 }
 
 int32x2_t test_vpaddl_s16(int16x4_t a) {
-  // CHECK: test_vpaddl_s16
+  // CHECK-LABEL: test_vpaddl_s16
   return vpaddl_s16(a);
   // CHECK: saddlp v{{[0-9]+}}.2s, v{{[0-9]+}}.4h
 }
 
 int64x1_t test_vpaddl_s32(int32x2_t a) {
-  // CHECK: test_vpaddl_s32
+  // CHECK-LABEL: test_vpaddl_s32
   return vpaddl_s32(a);
   // CHECK: saddlp v{{[0-9]+}}.1d, v{{[0-9]+}}.2s
 }
 
 uint16x4_t test_vpaddl_u8(uint8x8_t a) {
-  // CHECK: test_vpaddl_u8
+  // CHECK-LABEL: test_vpaddl_u8
   return vpaddl_u8(a);
   // CHECK: uaddlp v{{[0-9]+}}.4h, v{{[0-9]+}}.8b
 }
 
 uint32x2_t test_vpaddl_u16(uint16x4_t a) {
-  // CHECK: test_vpaddl_u16
+  // CHECK-LABEL: test_vpaddl_u16
   return vpaddl_u16(a);
   // CHECK: uaddlp v{{[0-9]+}}.2s, v{{[0-9]+}}.4h
 }
 
 uint64x1_t test_vpaddl_u32(uint32x2_t a) {
-  // CHECK: test_vpaddl_u32
+  // CHECK-LABEL: test_vpaddl_u32
   return vpaddl_u32(a);
   // CHECK: uaddlp v{{[0-9]+}}.1d, v{{[0-9]+}}.2s
 }
 
 int16x8_t test_vpaddlq_s8(int8x16_t a) {
-  // CHECK: test_vpaddlq_s8
+  // CHECK-LABEL: test_vpaddlq_s8
   return vpaddlq_s8(a);
   // CHECK: saddlp v{{[0-9]+}}.8h, v{{[0-9]+}}.16b
 }
 
 int32x4_t test_vpaddlq_s16(int16x8_t a) {
-  // CHECK: test_vpaddlq_s16
+  // CHECK-LABEL: test_vpaddlq_s16
   return vpaddlq_s16(a);
   // CHECK: saddlp v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 }
 
 int64x2_t test_vpaddlq_s32(int32x4_t a) {
-  // CHECK: test_vpaddlq_s32
+  // CHECK-LABEL: test_vpaddlq_s32
   return vpaddlq_s32(a);
   // CHECK: saddlp v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 }
 
 uint16x8_t test_vpaddlq_u8(uint8x16_t a) {
-  // CHECK: test_vpaddlq_u8
+  // CHECK-LABEL: test_vpaddlq_u8
   return vpaddlq_u8(a);
   // CHECK: uaddlp v{{[0-9]+}}.8h, v{{[0-9]+}}.16b
 }
 
 uint32x4_t test_vpaddlq_u16(uint16x8_t a) {
-  // CHECK: test_vpaddlq_u16
+  // CHECK-LABEL: test_vpaddlq_u16
   return vpaddlq_u16(a);
   // CHECK: uaddlp v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 }
 
 uint64x2_t test_vpaddlq_u32(uint32x4_t a) {
-  // CHECK: test_vpaddlq_u32
+  // CHECK-LABEL: test_vpaddlq_u32
   return vpaddlq_u32(a);
   // CHECK: uaddlp v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 }
 
 int16x4_t test_vpadal_s8(int16x4_t a, int8x8_t b) {
-  // CHECK: test_vpadal_s8
+  // CHECK-LABEL: test_vpadal_s8
   return vpadal_s8(a, b);
   // CHECK: sadalp v{{[0-9]+}}.4h, v{{[0-9]+}}.8b
 }
 
 int32x2_t test_vpadal_s16(int32x2_t a, int16x4_t b) {
-  // CHECK: test_vpadal_s16
+  // CHECK-LABEL: test_vpadal_s16
   return vpadal_s16(a, b);
   // CHECK: sadalp v{{[0-9]+}}.2s, v{{[0-9]+}}.4h
 }
 
 int64x1_t test_vpadal_s32(int64x1_t a, int32x2_t b) {
-  // CHECK: test_vpadal_s32
+  // CHECK-LABEL: test_vpadal_s32
   return vpadal_s32(a, b);
   // CHECK: sadalp v{{[0-9]+}}.1d, v{{[0-9]+}}.2s
 }
 
 uint16x4_t test_vpadal_u8(uint16x4_t a, uint8x8_t b) {
-  // CHECK: test_vpadal_u8
+  // CHECK-LABEL: test_vpadal_u8
   return vpadal_u8(a, b);
   // CHECK: uadalp v{{[0-9]+}}.4h, v{{[0-9]+}}.8b
 }
 
 uint32x2_t test_vpadal_u16(uint32x2_t a, uint16x4_t b) {
-  // CHECK: test_vpadal_u16
+  // CHECK-LABEL: test_vpadal_u16
   return vpadal_u16(a, b);
   // CHECK: uadalp v{{[0-9]+}}.2s, v{{[0-9]+}}.4h
 }
 
 uint64x1_t test_vpadal_u32(uint64x1_t a, uint32x2_t b) {
-  // CHECK: test_vpadal_u32
+  // CHECK-LABEL: test_vpadal_u32
   return vpadal_u32(a, b);
   // CHECK: uadalp v{{[0-9]+}}.1d, v{{[0-9]+}}.2s
 }
 
 int16x8_t test_vpadalq_s8(int16x8_t a, int8x16_t b) {
-  // CHECK: test_vpadalq_s8
+  // CHECK-LABEL: test_vpadalq_s8
   return vpadalq_s8(a, b);
   // CHECK: sadalp v{{[0-9]+}}.8h, v{{[0-9]+}}.16b
 }
 
 int32x4_t test_vpadalq_s16(int32x4_t a, int16x8_t b) {
-  // CHECK: test_vpadalq_s16
+  // CHECK-LABEL: test_vpadalq_s16
   return vpadalq_s16(a, b);
   // CHECK: sadalp v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 }
 
 int64x2_t test_vpadalq_s32(int64x2_t a, int32x4_t b) {
-  // CHECK: test_vpadalq_s32
+  // CHECK-LABEL: test_vpadalq_s32
   return vpadalq_s32(a, b);
   // CHECK: sadalp v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 }
 
 uint16x8_t test_vpadalq_u8(uint16x8_t a, uint8x16_t b) {
-  // CHECK: test_vpadalq_u8
+  // CHECK-LABEL: test_vpadalq_u8
   return vpadalq_u8(a, b);
   // CHECK: uadalp v{{[0-9]+}}.8h, v{{[0-9]+}}.16b
 }
 
 uint32x4_t test_vpadalq_u16(uint32x4_t a, uint16x8_t b) {
-  // CHECK: test_vpadalq_u16
+  // CHECK-LABEL: test_vpadalq_u16
   return vpadalq_u16(a, b);
   // CHECK: uadalp v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 }
 
 uint64x2_t test_vpadalq_u32(uint64x2_t a, uint32x4_t b) {
-  // CHECK: test_vpadalq_u32
+  // CHECK-LABEL: test_vpadalq_u32
   return vpadalq_u32(a, b);
   // CHECK: uadalp v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 }
 
 int8x8_t test_vqabs_s8(int8x8_t a) {
-  // CHECK: test_vqabs_s8
+  // CHECK-LABEL: test_vqabs_s8
   return vqabs_s8(a);
   // CHECK: sqabs v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vqabsq_s8(int8x16_t a) {
-  // CHECK: test_vqabsq_s8
+  // CHECK-LABEL: test_vqabsq_s8
   return vqabsq_s8(a);
   // CHECK: sqabs v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int16x4_t test_vqabs_s16(int16x4_t a) {
-  // CHECK: test_vqabs_s16
+  // CHECK-LABEL: test_vqabs_s16
   return vqabs_s16(a);
   // CHECK: sqabs v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 }
 
 int16x8_t test_vqabsq_s16(int16x8_t a) {
-  // CHECK: test_vqabsq_s16
+  // CHECK-LABEL: test_vqabsq_s16
   return vqabsq_s16(a);
   // CHECK: sqabs v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 }
 
 int32x2_t test_vqabs_s32(int32x2_t a) {
-  // CHECK: test_vqabs_s32
+  // CHECK-LABEL: test_vqabs_s32
   return vqabs_s32(a);
   // CHECK: sqabs v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vqabsq_s32(int32x4_t a) {
-  // CHECK: test_vqabsq_s32
+  // CHECK-LABEL: test_vqabsq_s32
   return vqabsq_s32(a);
   // CHECK: sqabs v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vqabsq_s64(int64x2_t a) {
-  // CHECK: test_vqabsq_s64
+  // CHECK-LABEL: test_vqabsq_s64
   return vqabsq_s64(a);
   // CHECK: sqabs v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int8x8_t test_vqneg_s8(int8x8_t a) {
-  // CHECK: test_vqneg_s8
+  // CHECK-LABEL: test_vqneg_s8
   return vqneg_s8(a);
   // CHECK: sqneg v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vqnegq_s8(int8x16_t a) {
-  // CHECK: test_vqnegq_s8
+  // CHECK-LABEL: test_vqnegq_s8
   return vqnegq_s8(a);
   // CHECK: sqneg v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int16x4_t test_vqneg_s16(int16x4_t a) {
-  // CHECK: test_vqneg_s16
+  // CHECK-LABEL: test_vqneg_s16
   return vqneg_s16(a);
   // CHECK: sqneg v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 }
 
 int16x8_t test_vqnegq_s16(int16x8_t a) {
-  // CHECK: test_vqnegq_s16
+  // CHECK-LABEL: test_vqnegq_s16
   return vqnegq_s16(a);
   // CHECK: sqneg v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 }
 
 int32x2_t test_vqneg_s32(int32x2_t a) {
-  // CHECK: test_vqneg_s32
+  // CHECK-LABEL: test_vqneg_s32
   return vqneg_s32(a);
   // CHECK: sqneg v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vqnegq_s32(int32x4_t a) {
-  // CHECK: test_vqnegq_s32
+  // CHECK-LABEL: test_vqnegq_s32
   return vqnegq_s32(a);
   // CHECK: sqneg v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vqnegq_s64(int64x2_t a) {
-  // CHECK: test_vqnegq_s64
+  // CHECK-LABEL: test_vqnegq_s64
   return vqnegq_s64(a);
   // CHECK: sqneg v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int8x8_t test_vneg_s8(int8x8_t a) {
-  // CHECK: test_vneg_s8
+  // CHECK-LABEL: test_vneg_s8
   return vneg_s8(a);
   // CHECK: neg v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vnegq_s8(int8x16_t a) {
-  // CHECK: test_vnegq_s8
+  // CHECK-LABEL: test_vnegq_s8
   return vnegq_s8(a);
   // CHECK: neg v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int16x4_t test_vneg_s16(int16x4_t a) {
-  // CHECK: test_vneg_s16
+  // CHECK-LABEL: test_vneg_s16
   return vneg_s16(a);
   // CHECK: neg v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 }
 
 int16x8_t test_vnegq_s16(int16x8_t a) {
-  // CHECK: test_vnegq_s16
+  // CHECK-LABEL: test_vnegq_s16
   return vnegq_s16(a);
   // CHECK: neg v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 }
 
 int32x2_t test_vneg_s32(int32x2_t a) {
-  // CHECK: test_vneg_s32
+  // CHECK-LABEL: test_vneg_s32
   return vneg_s32(a);
   // CHECK: neg v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vnegq_s32(int32x4_t a) {
-  // CHECK: test_vnegq_s32
+  // CHECK-LABEL: test_vnegq_s32
   return vnegq_s32(a);
   // CHECK: neg v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vnegq_s64(int64x2_t a) {
-  // CHECK: test_vnegq_s64
+  // CHECK-LABEL: test_vnegq_s64
   return vnegq_s64(a);
   // CHECK: neg v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vneg_f32(float32x2_t a) {
-  // CHECK: test_vneg_f32
+  // CHECK-LABEL: test_vneg_f32
   return vneg_f32(a);
   // CHECK: fneg v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vnegq_f32(float32x4_t a) {
-  // CHECK: test_vnegq_f32
+  // CHECK-LABEL: test_vnegq_f32
   return vnegq_f32(a);
   // CHECK: fneg v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vnegq_f64(float64x2_t a) {
-  // CHECK: test_vnegq_f64
+  // CHECK-LABEL: test_vnegq_f64
   return vnegq_f64(a);
   // CHECK: fneg v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int8x8_t test_vabs_s8(int8x8_t a) {
-  // CHECK: test_vabs_s8
+  // CHECK-LABEL: test_vabs_s8
   return vabs_s8(a);
   // CHECK: abs v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vabsq_s8(int8x16_t a) {
-  // CHECK: test_vabsq_s8
+  // CHECK-LABEL: test_vabsq_s8
   return vabsq_s8(a);
   // CHECK: abs v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int16x4_t test_vabs_s16(int16x4_t a) {
-  // CHECK: test_vabs_s16
+  // CHECK-LABEL: test_vabs_s16
   return vabs_s16(a);
   // CHECK: abs v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 }
 
 int16x8_t test_vabsq_s16(int16x8_t a) {
-  // CHECK: test_vabsq_s16
+  // CHECK-LABEL: test_vabsq_s16
   return vabsq_s16(a);
   // CHECK: abs v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 }
 
 int32x2_t test_vabs_s32(int32x2_t a) {
-  // CHECK: test_vabs_s32
+  // CHECK-LABEL: test_vabs_s32
   return vabs_s32(a);
   // CHECK: abs v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vabsq_s32(int32x4_t a) {
-  // CHECK: test_vabsq_s32
+  // CHECK-LABEL: test_vabsq_s32
   return vabsq_s32(a);
   // CHECK: abs v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vabsq_s64(int64x2_t a) {
-  // CHECK: test_vabsq_s64
+  // CHECK-LABEL: test_vabsq_s64
   return vabsq_s64(a);
   // CHECK: abs v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vabs_f32(float32x2_t a) {
-  // CHECK: test_vabs_f32
+  // CHECK-LABEL: test_vabs_f32
   return vabs_f32(a);
   // CHECK: fabs v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vabsq_f32(float32x4_t a) {
-  // CHECK: test_vabsq_f32
+  // CHECK-LABEL: test_vabsq_f32
   return vabsq_f32(a);
   // CHECK: fabs v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vabsq_f64(float64x2_t a) {
-  // CHECK: test_vabsq_f64
+  // CHECK-LABEL: test_vabsq_f64
   return vabsq_f64(a);
   // CHECK: fabs v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int8x8_t test_vuqadd_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vuqadd_s8
+  // CHECK-LABEL: test_vuqadd_s8
   return vuqadd_s8(a, b);
   // CHECK: suqadd v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vuqaddq_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vuqaddq_s8
+  // CHECK-LABEL: test_vuqaddq_s8
   return vuqaddq_s8(a, b);
   // CHECK: suqadd v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int16x4_t test_vuqadd_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vuqadd_s16
+  // CHECK-LABEL: test_vuqadd_s16
   return vuqadd_s16(a, b);
   // CHECK: suqadd v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 }
 
 int16x8_t test_vuqaddq_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vuqaddq_s16
+  // CHECK-LABEL: test_vuqaddq_s16
   return vuqaddq_s16(a, b);
   // CHECK: suqadd v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 }
 
 int32x2_t test_vuqadd_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vuqadd_s32
+  // CHECK-LABEL: test_vuqadd_s32
   return vuqadd_s32(a, b);
   // CHECK: suqadd v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vuqaddq_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vuqaddq_s32
+  // CHECK-LABEL: test_vuqaddq_s32
   return vuqaddq_s32(a, b);
   // CHECK: suqadd v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vuqaddq_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vuqaddq_s64
+  // CHECK-LABEL: test_vuqaddq_s64
   return vuqaddq_s64(a, b);
   // CHECK: suqadd v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int8x8_t test_vcls_s8(int8x8_t a) {
-  // CHECK: test_vcls_s8
+  // CHECK-LABEL: test_vcls_s8
   return vcls_s8(a);
   // CHECK: cls v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vclsq_s8(int8x16_t a) {
-  // CHECK: test_vclsq_s8
+  // CHECK-LABEL: test_vclsq_s8
   return vclsq_s8(a);
   // CHECK: cls v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int16x4_t test_vcls_s16(int16x4_t a) {
-  // CHECK: test_vcls_s16
+  // CHECK-LABEL: test_vcls_s16
   return vcls_s16(a);
   // CHECK: cls v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 }
 
 int16x8_t test_vclsq_s16(int16x8_t a) {
-  // CHECK: test_vclsq_s16
+  // CHECK-LABEL: test_vclsq_s16
   return vclsq_s16(a);
   // CHECK: cls v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 }
 
 int32x2_t test_vcls_s32(int32x2_t a) {
-  // CHECK: test_vcls_s32
+  // CHECK-LABEL: test_vcls_s32
   return vcls_s32(a);
   // CHECK: cls v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vclsq_s32(int32x4_t a) {
-  // CHECK: test_vclsq_s32
+  // CHECK-LABEL: test_vclsq_s32
   return vclsq_s32(a);
   // CHECK: cls v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int8x8_t test_vclz_s8(int8x8_t a) {
-  // CHECK: test_vclz_s8
+  // CHECK-LABEL: test_vclz_s8
   return vclz_s8(a);
   // CHECK: clz v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vclzq_s8(int8x16_t a) {
-  // CHECK: test_vclzq_s8
+  // CHECK-LABEL: test_vclzq_s8
   return vclzq_s8(a);
   // CHECK: clz v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int16x4_t test_vclz_s16(int16x4_t a) {
-  // CHECK: test_vclz_s16
+  // CHECK-LABEL: test_vclz_s16
   return vclz_s16(a);
   // CHECK: clz v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 }
 
 int16x8_t test_vclzq_s16(int16x8_t a) {
-  // CHECK: test_vclzq_s16
+  // CHECK-LABEL: test_vclzq_s16
   return vclzq_s16(a);
   // CHECK: clz v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 }
 
 int32x2_t test_vclz_s32(int32x2_t a) {
-  // CHECK: test_vclz_s32
+  // CHECK-LABEL: test_vclz_s32
   return vclz_s32(a);
   // CHECK: clz v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vclzq_s32(int32x4_t a) {
-  // CHECK: test_vclzq_s32
+  // CHECK-LABEL: test_vclzq_s32
   return vclzq_s32(a);
   // CHECK: clz v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 uint8x8_t test_vclz_u8(uint8x8_t a) {
-  // CHECK: test_vclz_u8
+  // CHECK-LABEL: test_vclz_u8
   return vclz_u8(a);
   // CHECK: clz v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 uint8x16_t test_vclzq_u8(uint8x16_t a) {
-  // CHECK: test_vclzq_u8
+  // CHECK-LABEL: test_vclzq_u8
   return vclzq_u8(a);
   // CHECK: clz v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 uint16x4_t test_vclz_u16(uint16x4_t a) {
-  // CHECK: test_vclz_u16
+  // CHECK-LABEL: test_vclz_u16
   return vclz_u16(a);
   // CHECK: clz v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 }
 
 uint16x8_t test_vclzq_u16(uint16x8_t a) {
-  // CHECK: test_vclzq_u16
+  // CHECK-LABEL: test_vclzq_u16
   return vclzq_u16(a);
   // CHECK: clz v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 }
 
 uint32x2_t test_vclz_u32(uint32x2_t a) {
-  // CHECK: test_vclz_u32
+  // CHECK-LABEL: test_vclz_u32
   return vclz_u32(a);
   // CHECK: clz v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 uint32x4_t test_vclzq_u32(uint32x4_t a) {
-  // CHECK: test_vclzq_u32
+  // CHECK-LABEL: test_vclzq_u32
   return vclzq_u32(a);
   // CHECK: clz v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int8x8_t test_vcnt_s8(int8x8_t a) {
-  // CHECK: test_vcnt_s8
+  // CHECK-LABEL: test_vcnt_s8
   return vcnt_s8(a);
   // CHECK: cnt v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vcntq_s8(int8x16_t a) {
-  // CHECK: test_vcntq_s8
+  // CHECK-LABEL: test_vcntq_s8
   return vcntq_s8(a);
   // CHECK: cnt v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 uint8x8_t test_vcnt_u8(uint8x8_t a) {
-  // CHECK: test_vcnt_u8
+  // CHECK-LABEL: test_vcnt_u8
   return vcnt_u8(a);
   // CHECK: cnt v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 uint8x16_t test_vcntq_u8(uint8x16_t a) {
-  // CHECK: test_vcntq_u8
+  // CHECK-LABEL: test_vcntq_u8
   return vcntq_u8(a);
   // CHECK: cnt v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 poly8x8_t test_vcnt_p8(poly8x8_t a) {
-  // CHECK: test_vcnt_p8
+  // CHECK-LABEL: test_vcnt_p8
   return vcnt_p8(a);
   // CHECK: cnt v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 poly8x16_t test_vcntq_p8(poly8x16_t a) {
-  // CHECK: test_vcntq_p8
+  // CHECK-LABEL: test_vcntq_p8
   return vcntq_p8(a);
   // CHECK: cnt v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int8x8_t test_vmvn_s8(int8x8_t a) {
-  // CHECK: test_vmvn_s8
+  // CHECK-LABEL: test_vmvn_s8
   return vmvn_s8(a);
   // CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vmvnq_s8(int8x16_t a) {
-  // CHECK: test_vmvnq_s8
+  // CHECK-LABEL: test_vmvnq_s8
   return vmvnq_s8(a);
   // CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int16x4_t test_vmvn_s16(int16x4_t a) {
-  // CHECK: test_vmvn_s16
+  // CHECK-LABEL: test_vmvn_s16
   return vmvn_s16(a);
   // CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int16x8_t test_vmvnq_s16(int16x8_t a) {
-  // CHECK: test_vmvnq_s16
+  // CHECK-LABEL: test_vmvnq_s16
   return vmvnq_s16(a);
   // CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int32x2_t test_vmvn_s32(int32x2_t a) {
-  // CHECK: test_vmvn_s32
+  // CHECK-LABEL: test_vmvn_s32
   return vmvn_s32(a);
   // CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int32x4_t test_vmvnq_s32(int32x4_t a) {
-  // CHECK: test_vmvnq_s32
+  // CHECK-LABEL: test_vmvnq_s32
   return vmvnq_s32(a);
   // CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 uint8x8_t test_vmvn_u8(uint8x8_t a) {
-  // CHECK: test_vmvn_u8
+  // CHECK-LABEL: test_vmvn_u8
   return vmvn_u8(a);
   // CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 uint8x16_t test_vmvnq_u8(uint8x16_t a) {
-  // CHECK: test_vmvnq_u8
+  // CHECK-LABEL: test_vmvnq_u8
   return vmvnq_u8(a);
   // CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 uint16x4_t test_vmvn_u16(uint16x4_t a) {
-  // CHECK: test_vmvn_u16
+  // CHECK-LABEL: test_vmvn_u16
   return vmvn_u16(a);
   // CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 uint16x8_t test_vmvnq_u16(uint16x8_t a) {
-  // CHECK: test_vmvnq_u16
+  // CHECK-LABEL: test_vmvnq_u16
   return vmvnq_u16(a);
   // CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 uint32x2_t test_vmvn_u32(uint32x2_t a) {
-  // CHECK: test_vmvn_u32
+  // CHECK-LABEL: test_vmvn_u32
   return vmvn_u32(a);
   // CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 uint32x4_t test_vmvnq_u32(uint32x4_t a) {
-  // CHECK: test_vmvnq_u32
+  // CHECK-LABEL: test_vmvnq_u32
   return vmvnq_u32(a);
   // CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 poly8x8_t test_vmvn_p8(poly8x8_t a) {
-  // CHECK: test_vmvn_p8
+  // CHECK-LABEL: test_vmvn_p8
   return vmvn_p8(a);
   // CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 poly8x16_t test_vmvnq_p8(poly8x16_t a) {
-  // CHECK: test_vmvnq_p8
+  // CHECK-LABEL: test_vmvnq_p8
   return vmvnq_p8(a);
   // CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int8x8_t test_vrbit_s8(int8x8_t a) {
-  // CHECK: test_vrbit_s8
+  // CHECK-LABEL: test_vrbit_s8
   return vrbit_s8(a);
   // CHECK: rbit v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 int8x16_t test_vrbitq_s8(int8x16_t a) {
-  // CHECK: test_vrbitq_s8
+  // CHECK-LABEL: test_vrbitq_s8
   return vrbitq_s8(a);
   // CHECK: rbit v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 uint8x8_t test_vrbit_u8(uint8x8_t a) {
-  // CHECK: test_vrbit_u8
+  // CHECK-LABEL: test_vrbit_u8
   return vrbit_u8(a);
   // CHECK: rbit v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 uint8x16_t test_vrbitq_u8(uint8x16_t a) {
-  // CHECK: test_vrbitq_u8
+  // CHECK-LABEL: test_vrbitq_u8
   return vrbitq_u8(a);
   // CHECK: rbit v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 poly8x8_t test_vrbit_p8(poly8x8_t a) {
-  // CHECK: test_vrbit_p8
+  // CHECK-LABEL: test_vrbit_p8
   return vrbit_p8(a);
   // CHECK: rbit v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 }
 
 poly8x16_t test_vrbitq_p8(poly8x16_t a) {
-  // CHECK: test_vrbitq_p8
+  // CHECK-LABEL: test_vrbitq_p8
   return vrbitq_p8(a);
   // CHECK: rbit v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 }
 
 int8x8_t test_vmovn_s16(int16x8_t a) {
-  // CHECK: test_vmovn_s16
+  // CHECK-LABEL: test_vmovn_s16
   return vmovn_s16(a);
   // CHECK: xtn v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 }
 
 int16x4_t test_vmovn_s32(int32x4_t a) {
-  // CHECK: test_vmovn_s32
+  // CHECK-LABEL: test_vmovn_s32
   return vmovn_s32(a);
   // CHECK: xtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 }
 
 int32x2_t test_vmovn_s64(int64x2_t a) {
-  // CHECK: test_vmovn_s64
+  // CHECK-LABEL: test_vmovn_s64
   return vmovn_s64(a);
   // CHECK: xtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 }
 
 uint8x8_t test_vmovn_u16(uint16x8_t a) {
-  // CHECK: test_vmovn_u16
+  // CHECK-LABEL: test_vmovn_u16
   return vmovn_u16(a);
   // CHECK: xtn v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 }
 
 uint16x4_t test_vmovn_u32(uint32x4_t a) {
-  // CHECK: test_vmovn_u32
+  // CHECK-LABEL: test_vmovn_u32
   return vmovn_u32(a);
   // CHECK: xtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 }
 
 uint32x2_t test_vmovn_u64(uint64x2_t a) {
-  // CHECK: test_vmovn_u64
+  // CHECK-LABEL: test_vmovn_u64
   return vmovn_u64(a);
   // CHECK: xtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 }
 
 int8x16_t test_vmovn_high_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vmovn_high_s16
+  // CHECK-LABEL: test_vmovn_high_s16
   return vmovn_high_s16(a, b);
   // CHECK: xtn2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 }
 
 int16x8_t test_vmovn_high_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vmovn_high_s32
+  // CHECK-LABEL: test_vmovn_high_s32
   return vmovn_high_s32(a, b);
   // CHECK: xtn2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 }
 
 int32x4_t test_vmovn_high_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vmovn_high_s64
+  // CHECK-LABEL: test_vmovn_high_s64
   return vmovn_high_s64(a, b);
   // CHECK: xtn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 }
 
 int8x16_t test_vmovn_high_u16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vmovn_high_u16
+  // CHECK-LABEL: test_vmovn_high_u16
   return vmovn_high_u16(a, b);
   // CHECK: xtn2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 }
 
 int16x8_t test_vmovn_high_u32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vmovn_high_u32
+  // CHECK-LABEL: test_vmovn_high_u32
   return vmovn_high_u32(a, b);
   // CHECK: xtn2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 }
 
 int32x4_t test_vmovn_high_u64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vmovn_high_u64
+  // CHECK-LABEL: test_vmovn_high_u64
   return vmovn_high_u64(a, b);
   // CHECK: xtn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 }
 
 int8x8_t test_vqmovun_s16(int16x8_t a) {
-  // CHECK: test_vqmovun_s16
+  // CHECK-LABEL: test_vqmovun_s16
   return vqmovun_s16(a);
   // CHECK: sqxtun v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 }
 
 int16x4_t test_vqmovun_s32(int32x4_t a) {
-  // CHECK: test_vqmovun_s32
+  // CHECK-LABEL: test_vqmovun_s32
   return vqmovun_s32(a);
   // CHECK: sqxtun v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 }
 
 int32x2_t test_vqmovun_s64(int64x2_t a) {
-  // CHECK: test_vqmovun_s64
+  // CHECK-LABEL: test_vqmovun_s64
   return vqmovun_s64(a);
   // CHECK: sqxtun v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 }
 
 int8x16_t test_vqmovun_high_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vqmovun_high_s16
+  // CHECK-LABEL: test_vqmovun_high_s16
   return vqmovun_high_s16(a, b);
   // CHECK: sqxtun2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 }
 
 int16x8_t test_vqmovun_high_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vqmovun_high_s32
+  // CHECK-LABEL: test_vqmovun_high_s32
   return vqmovun_high_s32(a, b);
   // CHECK: sqxtun2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 }
 
 int32x4_t test_vqmovun_high_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vqmovun_high_s64
+  // CHECK-LABEL: test_vqmovun_high_s64
   return vqmovun_high_s64(a, b);
   // CHECK: sqxtun2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 }
 
 int8x8_t test_vqmovn_s16(int16x8_t a) {
-  // CHECK: test_vqmovn_s16
+  // CHECK-LABEL: test_vqmovn_s16
   return vqmovn_s16(a);
   // CHECK: sqxtn v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 }
 
 int16x4_t test_vqmovn_s32(int32x4_t a) {
-  // CHECK: test_vqmovn_s32
+  // CHECK-LABEL: test_vqmovn_s32
   return vqmovn_s32(a);
   // CHECK: sqxtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 }
 
 int32x2_t test_vqmovn_s64(int64x2_t a) {
-  // CHECK: test_vqmovn_s64
+  // CHECK-LABEL: test_vqmovn_s64
   return vqmovn_s64(a);
   // CHECK: sqxtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 }
 
 int8x16_t test_vqmovn_high_s16(int8x8_t a, int16x8_t b) {
-  // CHECK: test_vqmovn_high_s16
+  // CHECK-LABEL: test_vqmovn_high_s16
   return vqmovn_high_s16(a, b);
   // CHECK: sqxtn2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 }
 
 int16x8_t test_vqmovn_high_s32(int16x4_t a, int32x4_t b) {
-  // CHECK: test_vqmovn_high_s32
+  // CHECK-LABEL: test_vqmovn_high_s32
   return vqmovn_high_s32(a, b);
   // CHECK: sqxtn2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 }
 
 int32x4_t test_vqmovn_high_s64(int32x2_t a, int64x2_t b) {
-  // CHECK: test_vqmovn_high_s64
+  // CHECK-LABEL: test_vqmovn_high_s64
   return vqmovn_high_s64(a, b);
   // CHECK: sqxtn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 }
 
 uint8x8_t test_vqmovn_u16(uint16x8_t a) {
-  // CHECK: test_vqmovn_u16
+  // CHECK-LABEL: test_vqmovn_u16
   return vqmovn_u16(a);
   // CHECK: uqxtn v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 }
 
 uint16x4_t test_vqmovn_u32(uint32x4_t a) {
-  // CHECK: test_vqmovn_u32
+  // CHECK-LABEL: test_vqmovn_u32
   return vqmovn_u32(a);
   // CHECK: uqxtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 }
 
 uint32x2_t test_vqmovn_u64(uint64x2_t a) {
-  // CHECK: test_vqmovn_u64
+  // CHECK-LABEL: test_vqmovn_u64
   return vqmovn_u64(a);
   // CHECK: uqxtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 }
 
 uint8x16_t test_vqmovn_high_u16(uint8x8_t a, uint16x8_t b) {
-  // CHECK: test_vqmovn_high_u16
+  // CHECK-LABEL: test_vqmovn_high_u16
   return vqmovn_high_u16(a, b);
   // CHECK: uqxtn2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 }
 
 uint16x8_t test_vqmovn_high_u32(uint16x4_t a, uint32x4_t b) {
-  // CHECK: test_vqmovn_high_u32
+  // CHECK-LABEL: test_vqmovn_high_u32
   return vqmovn_high_u32(a, b);
   // CHECK: uqxtn2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 }
 
 uint32x4_t test_vqmovn_high_u64(uint32x2_t a, uint64x2_t b) {
-  // CHECK: test_vqmovn_high_u64
+  // CHECK-LABEL: test_vqmovn_high_u64
   return vqmovn_high_u64(a, b);
   // CHECK: uqxtn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 }
 
 int16x8_t test_vshll_n_s8(int8x8_t a) {
-  // CHECK: test_vshll_n_s8
+  // CHECK-LABEL: test_vshll_n_s8
   return vshll_n_s8(a, 8);
   // CHECK: shll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #8
 }
 
 int32x4_t test_vshll_n_s16(int16x4_t a) {
-  // CHECK: test_vshll_n_s16
+  // CHECK-LABEL: test_vshll_n_s16
   return vshll_n_s16(a, 16);
   // CHECK: shll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #16
 }
 
 int64x2_t test_vshll_n_s32(int32x2_t a) {
-  // CHECK: test_vshll_n_s32
+  // CHECK-LABEL: test_vshll_n_s32
   return vshll_n_s32(a, 32);
   // CHECK: shll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #32
 }
 
 uint16x8_t test_vshll_n_u8(uint8x8_t a) {
-  // CHECK: test_vshll_n_u8
+  // CHECK-LABEL: test_vshll_n_u8
   return vshll_n_u8(a, 8);
   // CHECK: shll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #8
 }
 
 uint32x4_t test_vshll_n_u16(uint16x4_t a) {
-  // CHECK: test_vshll_n_u16
+  // CHECK-LABEL: test_vshll_n_u16
   return vshll_n_u16(a, 16);
   // CHECK: shll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #16
 }
 
 uint64x2_t test_vshll_n_u32(uint32x2_t a) {
-  // CHECK: test_vshll_n_u32
+  // CHECK-LABEL: test_vshll_n_u32
   return vshll_n_u32(a, 32);
   // CHECK: shll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #32
 }
 
 int16x8_t test_vshll_high_n_s8(int8x16_t a) {
-  // CHECK: test_vshll_high_n_s8
+  // CHECK-LABEL: test_vshll_high_n_s8
   return vshll_high_n_s8(a, 8);
   // CHECK: shll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #8
 }
 
 int32x4_t test_vshll_high_n_s16(int16x8_t a) {
-  // CHECK: test_vshll_high_n_s16
+  // CHECK-LABEL: test_vshll_high_n_s16
   return vshll_high_n_s16(a, 16);
   // CHECK: shll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #16
 }
 
 int64x2_t test_vshll_high_n_s32(int32x4_t a) {
-  // CHECK: test_vshll_high_n_s32
+  // CHECK-LABEL: test_vshll_high_n_s32
   return vshll_high_n_s32(a, 32);
   // CHECK: shll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #32
 }
 
 uint16x8_t test_vshll_high_n_u8(uint8x16_t a) {
-  // CHECK: test_vshll_high_n_u8
+  // CHECK-LABEL: test_vshll_high_n_u8
   return vshll_high_n_u8(a, 8);
   // CHECK: shll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #8
 }
 
 uint32x4_t test_vshll_high_n_u16(uint16x8_t a) {
-  // CHECK: test_vshll_high_n_u16
+  // CHECK-LABEL: test_vshll_high_n_u16
   return vshll_high_n_u16(a, 16);
   // CHECK: shll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #16
 }
 
 uint64x2_t test_vshll_high_n_u32(uint32x4_t a) {
-  // CHECK: test_vshll_high_n_u32
+  // CHECK-LABEL: test_vshll_high_n_u32
   return vshll_high_n_u32(a, 32);
   // CHECK: shll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #32
 }
 
 float16x4_t test_vcvt_f16_f32(float32x4_t a) {
-  //CHECK: test_vcvt_f16_f32
+  //CHECK-LABEL: test_vcvt_f16_f32
   return vcvt_f16_f32(a);
   // CHECK: fcvtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 }
 
 float16x8_t test_vcvt_high_f16_f32(float16x4_t a, float32x4_t b) {
-  //CHECK: test_vcvt_high_f16_f32
+  //CHECK-LABEL: test_vcvt_high_f16_f32
   return vcvt_high_f16_f32(a, b);
   // CHECK: fcvtn2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 }
 
 float32x2_t test_vcvt_f32_f64(float64x2_t a) {
-  //CHECK: test_vcvt_f32_f64
+  //CHECK-LABEL: test_vcvt_f32_f64
   return vcvt_f32_f64(a);
   // CHECK: fcvtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 }
 
 float32x4_t test_vcvt_high_f32_f64(float32x2_t a, float64x2_t b) {
-  //CHECK: test_vcvt_high_f32_f64
+  //CHECK-LABEL: test_vcvt_high_f32_f64
   return vcvt_high_f32_f64(a, b);
   // CHECK: fcvtn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vcvtx_f32_f64(float64x2_t a) {
-  //CHECK: test_vcvtx_f32_f64
+  //CHECK-LABEL: test_vcvtx_f32_f64
   return vcvtx_f32_f64(a);
   // CHECK: fcvtxn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 }
 
 float32x4_t test_vcvtx_high_f32_f64(float32x2_t a, float64x2_t b) {
-  //CHECK: test_vcvtx_high_f32_f64
+  //CHECK-LABEL: test_vcvtx_high_f32_f64
   return vcvtx_high_f32_f64(a, b);
   // CHECK: fcvtxn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 }
 
 float32x4_t test_vcvt_f32_f16(float16x4_t a) {
-  //CHECK: test_vcvt_f32_f16
+  //CHECK-LABEL: test_vcvt_f32_f16
   return vcvt_f32_f16(a);
   // CHECK: fcvtl v{{[0-9]+}}.4s, v{{[0-9]+}}.4h
 }
 
 float32x4_t test_vcvt_high_f32_f16(float16x8_t a) {
-  //CHECK: test_vcvt_high_f32_f16
+  //CHECK-LABEL: test_vcvt_high_f32_f16
   return vcvt_high_f32_f16(a);
   // CHECK: fcvtl2 v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 }
 
 float64x2_t test_vcvt_f64_f32(float32x2_t a) {
-  //CHECK: test_vcvt_f64_f32
+  //CHECK-LABEL: test_vcvt_f64_f32
   return vcvt_f64_f32(a);
   // CHECK: fcvtl v{{[0-9]+}}.2d, v{{[0-9]+}}.2s
 }
 
 float64x2_t test_vcvt_high_f64_f32(float32x4_t a) {
-  //CHECK: test_vcvt_high_f64_f32
+  //CHECK-LABEL: test_vcvt_high_f64_f32
   return vcvt_high_f64_f32(a);
   // CHECK: fcvtl2 v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 }
 
 float32x2_t test_vrndn_f32(float32x2_t a) {
-  //CHECK: test_vrndn_f32
+  //CHECK-LABEL: test_vrndn_f32
   return vrndn_f32(a);
   // CHECK: frintn v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrndnq_f32(float32x4_t a) {
-  //CHECK: test_vrndnq_f32
+  //CHECK-LABEL: test_vrndnq_f32
   return vrndnq_f32(a);
   // CHECK: frintn v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrndnq_f64(float64x2_t a) {
-  //CHECK: test_vrndnq_f64
+  //CHECK-LABEL: test_vrndnq_f64
   return vrndnq_f64(a);
   // CHECK: frintn v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vrnda_f32(float32x2_t a) {
-  //CHECK: test_vrnda_f32
+  //CHECK-LABEL: test_vrnda_f32
   return vrnda_f32(a);
   // CHECK: frinta v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrndaq_f32(float32x4_t a) {
-  //CHECK: test_vrndaq_f32
+  //CHECK-LABEL: test_vrndaq_f32
   return vrndaq_f32(a);
   // CHECK: frinta v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrndaq_f64(float64x2_t a) {
-  //CHECK: test_vrndaq_f64
+  //CHECK-LABEL: test_vrndaq_f64
   return vrndaq_f64(a);
   // CHECK: frinta v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vrndp_f32(float32x2_t a) {
-  //CHECK: test_vrndp_f32
+  //CHECK-LABEL: test_vrndp_f32
   return vrndp_f32(a);
   // CHECK: frintp v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrndpq_f32(float32x4_t a) {
-  //CHECK: test_vrndpq_f32
+  //CHECK-LABEL: test_vrndpq_f32
   return vrndpq_f32(a);
   // CHECK: frintp v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrndpq_f64(float64x2_t a) {
-  //CHECK: test_vrndpq_f64
+  //CHECK-LABEL: test_vrndpq_f64
   return vrndpq_f64(a);
   // CHECK: frintp v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vrndm_f32(float32x2_t a) {
-  //CHECK: test_vrndm_f32
+  //CHECK-LABEL: test_vrndm_f32
   return vrndm_f32(a);
   // CHECK: frintm v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrndmq_f32(float32x4_t a) {
-  //CHECK: test_vrndmq_f32
+  //CHECK-LABEL: test_vrndmq_f32
   return vrndmq_f32(a);
   // CHECK: frintm v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrndmq_f64(float64x2_t a) {
-  //CHECK: test_vrndmq_f64
+  //CHECK-LABEL: test_vrndmq_f64
   return vrndmq_f64(a);
   // CHECK: frintm v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vrndx_f32(float32x2_t a) {
-  //CHECK: test_vrndx_f32
+  //CHECK-LABEL: test_vrndx_f32
   return vrndx_f32(a);
   // CHECK: frintx v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrndxq_f32(float32x4_t a) {
-  //CHECK: test_vrndxq_f32
+  //CHECK-LABEL: test_vrndxq_f32
   return vrndxq_f32(a);
   // CHECK: frintx v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrndxq_f64(float64x2_t a) {
-  //CHECK: test_vrndxq_f64
+  //CHECK-LABEL: test_vrndxq_f64
   return vrndxq_f64(a);
   // CHECK: frintx v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vrnd_f32(float32x2_t a) {
-  //CHECK: test_vrnd_f32
+  //CHECK-LABEL: test_vrnd_f32
   return vrnd_f32(a);
   // CHECK: frintz v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrndq_f32(float32x4_t a) {
-  //CHECK: test_vrndq_f32
+  //CHECK-LABEL: test_vrndq_f32
   return vrndq_f32(a);
   // CHECK: frintz v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrndq_f64(float64x2_t a) {
-  //CHECK: test_vrndq_f64
+  //CHECK-LABEL: test_vrndq_f64
   return vrndq_f64(a);
   // CHECK: frintz v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vrndi_f32(float32x2_t a) {
-  //CHECK: test_vrndi_f32
+  //CHECK-LABEL: test_vrndi_f32
   return vrndi_f32(a);
   // CHECK: frinti v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrndiq_f32(float32x4_t a) {
-  //CHECK: test_vrndiq_f32
+  //CHECK-LABEL: test_vrndiq_f32
   return vrndiq_f32(a);
   // CHECK: frinti v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrndiq_f64(float64x2_t a) {
-  //CHECK: test_vrndiq_f64
+  //CHECK-LABEL: test_vrndiq_f64
   return vrndiq_f64(a);
   // CHECK: frinti v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int32x2_t test_vcvt_s32_f32(float32x2_t a) {
-  //CHECK: test_vcvt_s32_f32
+  //CHECK-LABEL: test_vcvt_s32_f32
   return vcvt_s32_f32(a);
   // CHECK: fcvtzs v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vcvtq_s32_f32(float32x4_t a) {
-  //CHECK: test_vcvtq_s32_f32
+  //CHECK-LABEL: test_vcvtq_s32_f32
   return vcvtq_s32_f32(a);
   // CHECK: fcvtzs v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vcvtq_s64_f64(float64x2_t a) {
-  //CHECK: test_vcvtq_s64_f64
+  //CHECK-LABEL: test_vcvtq_s64_f64
   return vcvtq_s64_f64(a);
   // CHECK: fcvtzs v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 uint32x2_t test_vcvt_u32_f32(float32x2_t a) {
-  //CHECK: test_vcvt_u32_f32
+  //CHECK-LABEL: test_vcvt_u32_f32
   return vcvt_u32_f32(a);
   // CHECK: fcvtzu v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 uint32x4_t test_vcvtq_u32_f32(float32x4_t a) {
-  //CHECK: test_vcvtq_u32_f32
+  //CHECK-LABEL: test_vcvtq_u32_f32
   return vcvtq_u32_f32(a);
   // CHECK: fcvtzu v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 uint64x2_t test_vcvtq_u64_f64(float64x2_t a) {
-  //CHECK: test_vcvtq_u64_f64
+  //CHECK-LABEL: test_vcvtq_u64_f64
   return vcvtq_u64_f64(a);
   // CHECK: fcvtzu v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int32x2_t test_vcvtn_s32_f32(float32x2_t a) {
-  //CHECK: test_vcvtn_s32_f32
+  //CHECK-LABEL: test_vcvtn_s32_f32
   return vcvtn_s32_f32(a);
   // CHECK: fcvtns v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vcvtnq_s32_f32(float32x4_t a) {
-  //CHECK: test_vcvtnq_s32_f32
+  //CHECK-LABEL: test_vcvtnq_s32_f32
   return vcvtnq_s32_f32(a);
   // CHECK: fcvtns v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vcvtnq_s64_f64(float64x2_t a) {
-  //CHECK: test_vcvtnq_s64_f64
+  //CHECK-LABEL: test_vcvtnq_s64_f64
   return vcvtnq_s64_f64(a);
   // CHECK: fcvtns v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 uint32x2_t test_vcvtn_u32_f32(float32x2_t a) {
-  //CHECK: test_vcvtn_u32_f32
+  //CHECK-LABEL: test_vcvtn_u32_f32
   return vcvtn_u32_f32(a);
   // CHECK: fcvtnu v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 uint32x4_t test_vcvtnq_u32_f32(float32x4_t a) {
-  //CHECK: test_vcvtnq_u32_f32
+  //CHECK-LABEL: test_vcvtnq_u32_f32
   return vcvtnq_u32_f32(a);
   // CHECK: fcvtnu v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 uint64x2_t test_vcvtnq_u64_f64(float64x2_t a) {
-  //CHECK: test_vcvtnq_u64_f64
+  //CHECK-LABEL: test_vcvtnq_u64_f64
   return vcvtnq_u64_f64(a);
   // CHECK: fcvtnu v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int32x2_t test_vcvtp_s32_f32(float32x2_t a) {
-  //CHECK: test_vcvtp_s32_f32
+  //CHECK-LABEL: test_vcvtp_s32_f32
   return vcvtp_s32_f32(a);
   // CHECK: fcvtps v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vcvtpq_s32_f32(float32x4_t a) {
-  //CHECK: test_vcvtpq_s32_f32
+  //CHECK-LABEL: test_vcvtpq_s32_f32
   return vcvtpq_s32_f32(a);
   // CHECK: fcvtps v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vcvtpq_s64_f64(float64x2_t a) {
-  //CHECK: test_vcvtpq_s64_f64
+  //CHECK-LABEL: test_vcvtpq_s64_f64
   return vcvtpq_s64_f64(a);
   // CHECK: fcvtps v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 uint32x2_t test_vcvtp_u32_f32(float32x2_t a) {
-  //CHECK: test_vcvtp_u32_f32
+  //CHECK-LABEL: test_vcvtp_u32_f32
   return vcvtp_u32_f32(a);
   // CHECK: fcvtpu v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 uint32x4_t test_vcvtpq_u32_f32(float32x4_t a) {
-  //CHECK: test_vcvtpq_u32_f32
+  //CHECK-LABEL: test_vcvtpq_u32_f32
   return vcvtpq_u32_f32(a);
   // CHECK: fcvtpu v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 uint64x2_t test_vcvtpq_u64_f64(float64x2_t a) {
-  //CHECK: test_vcvtpq_u64_f64
+  //CHECK-LABEL: test_vcvtpq_u64_f64
   return vcvtpq_u64_f64(a);
   // CHECK: fcvtpu v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int32x2_t test_vcvtm_s32_f32(float32x2_t a) {
-  //CHECK: test_vcvtm_s32_f32
+  //CHECK-LABEL: test_vcvtm_s32_f32
   return vcvtm_s32_f32(a);
   // CHECK: fcvtms v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vcvtmq_s32_f32(float32x4_t a) {
-  //CHECK: test_vcvtmq_s32_f32
+  //CHECK-LABEL: test_vcvtmq_s32_f32
   return vcvtmq_s32_f32(a);
   // CHECK: fcvtms v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vcvtmq_s64_f64(float64x2_t a) {
-  //CHECK: test_vcvtmq_s64_f64
+  //CHECK-LABEL: test_vcvtmq_s64_f64
   return vcvtmq_s64_f64(a);
   // CHECK: fcvtms v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 uint32x2_t test_vcvtm_u32_f32(float32x2_t a) {
-  //CHECK: test_vcvtm_u32_f32
+  //CHECK-LABEL: test_vcvtm_u32_f32
   return vcvtm_u32_f32(a);
   // CHECK: fcvtmu v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 uint32x4_t test_vcvtmq_u32_f32(float32x4_t a) {
-  //CHECK: test_vcvtmq_u32_f32
+  //CHECK-LABEL: test_vcvtmq_u32_f32
   return vcvtmq_u32_f32(a);
   // CHECK: fcvtmu v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 uint64x2_t test_vcvtmq_u64_f64(float64x2_t a) {
-  //CHECK: test_vcvtmq_u64_f64
+  //CHECK-LABEL: test_vcvtmq_u64_f64
   return vcvtmq_u64_f64(a);
   // CHECK: fcvtmu v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 int32x2_t test_vcvta_s32_f32(float32x2_t a) {
-  //CHECK: test_vcvta_s32_f32
+  //CHECK-LABEL: test_vcvta_s32_f32
   return vcvta_s32_f32(a);
   // CHECK: fcvtas v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 int32x4_t test_vcvtaq_s32_f32(float32x4_t a) {
-  //CHECK: test_vcvtaq_s32_f32
+  //CHECK-LABEL: test_vcvtaq_s32_f32
   return vcvtaq_s32_f32(a);
   // CHECK: fcvtas v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 int64x2_t test_vcvtaq_s64_f64(float64x2_t a) {
-  //CHECK: test_vcvtaq_s64_f64
+  //CHECK-LABEL: test_vcvtaq_s64_f64
   return vcvtaq_s64_f64(a);
   // CHECK: fcvtas v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 uint32x2_t test_vcvta_u32_f32(float32x2_t a) {
-  //CHECK: test_vcvta_u32_f32
+  //CHECK-LABEL: test_vcvta_u32_f32
   return vcvta_u32_f32(a);
   // CHECK: fcvtau v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 uint32x4_t test_vcvtaq_u32_f32(float32x4_t a) {
-  //CHECK: test_vcvtaq_u32_f32
+  //CHECK-LABEL: test_vcvtaq_u32_f32
   return vcvtaq_u32_f32(a);
   // CHECK: fcvtau v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 uint64x2_t test_vcvtaq_u64_f64(float64x2_t a) {
-  //CHECK: test_vcvtaq_u64_f64
+  //CHECK-LABEL: test_vcvtaq_u64_f64
   return vcvtaq_u64_f64(a);
   // CHECK: fcvtau v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vrsqrte_f32(float32x2_t a) {
-  //CHECK: test_vrsqrte_f32
+  //CHECK-LABEL: test_vrsqrte_f32
   return vrsqrte_f32(a);
   // CHECK: frsqrte v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrsqrteq_f32(float32x4_t a) {
-  //CHECK: test_vrsqrteq_f32
+  //CHECK-LABEL: test_vrsqrteq_f32
   return vrsqrteq_f32(a);
   // CHECK: frsqrte v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrsqrteq_f64(float64x2_t a) {
-  //CHECK: test_vrsqrteq_f64
+  //CHECK-LABEL: test_vrsqrteq_f64
   return vrsqrteq_f64(a);
   // CHECK: frsqrte v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vrecpe_f32(float32x2_t a) {
-  //CHECK: test_vrecpe_f32
+  //CHECK-LABEL: test_vrecpe_f32
   return vrecpe_f32(a);
   // CHECK: frecpe v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vrecpeq_f32(float32x4_t a) {
-  //CHECK: test_vrecpeq_f32
+  //CHECK-LABEL: test_vrecpeq_f32
   return vrecpeq_f32(a);
   // CHECK: frecpe v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vrecpeq_f64(float64x2_t a) {
-  //CHECK: test_vrecpeq_f64
+  //CHECK-LABEL: test_vrecpeq_f64
   return vrecpeq_f64(a);
   // CHECK: frecpe v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 uint32x2_t test_vrecpe_u32(uint32x2_t a) {
-  //CHECK: test_vrecpe_u32
+  //CHECK-LABEL: test_vrecpe_u32
   return vrecpe_u32(a);
   // CHECK: urecpe v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 uint32x4_t test_vrecpeq_u32(uint32x4_t a) {
-  //CHECK: test_vrecpeq_u32
+  //CHECK-LABEL: test_vrecpeq_u32
   return vrecpeq_u32(a);
   // CHECK: urecpe v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float32x2_t test_vsqrt_f32(float32x2_t a) {
-  //CHECK: test_vsqrt_f32
+  //CHECK-LABEL: test_vsqrt_f32
   return vsqrt_f32(a);
   // CHECK: fsqrt v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vsqrtq_f32(float32x4_t a) {
-  //CHECK: test_vsqrtq_f32
+  //CHECK-LABEL: test_vsqrtq_f32
   return vsqrtq_f32(a);
   // CHECK: fsqrt v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vsqrtq_f64(float64x2_t a) {
-  //CHECK: test_vsqrtq_f64
+  //CHECK-LABEL: test_vsqrtq_f64
   return vsqrtq_f64(a);
   // CHECK: fsqrt v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float32x2_t test_vcvt_f32_s32(int32x2_t a) {
-  //CHECK: test_vcvt_f32_s32
+  //CHECK-LABEL: test_vcvt_f32_s32
   return vcvt_f32_s32(a);
   //CHECK: scvtf v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x2_t test_vcvt_f32_u32(uint32x2_t a) {
-  //CHECK: test_vcvt_f32_u32
+  //CHECK-LABEL: test_vcvt_f32_u32
   return vcvt_f32_u32(a);
   //CHECK: ucvtf v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 }
 
 float32x4_t test_vcvtq_f32_s32(int32x4_t a) {
-  //CHECK: test_vcvtq_f32_s32
+  //CHECK-LABEL: test_vcvtq_f32_s32
   return vcvtq_f32_s32(a);
   //CHECK: scvtf v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float32x4_t test_vcvtq_f32_u32(uint32x4_t a) {
-  //CHECK: test_vcvtq_f32_u32
+  //CHECK-LABEL: test_vcvtq_f32_u32
   return vcvtq_f32_u32(a);
   //CHECK: ucvtf v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 }
 
 float64x2_t test_vcvtq_f64_s64(int64x2_t a) {
-  //CHECK: test_vcvtq_f64_s64
+  //CHECK-LABEL: test_vcvtq_f64_s64
   return vcvtq_f64_s64(a);
   //CHECK: scvtf v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }
 
 float64x2_t test_vcvtq_f64_u64(uint64x2_t a) {
-  //CHECK: test_vcvtq_f64_u64
+  //CHECK-LABEL: test_vcvtq_f64_u64
   return vcvtq_f64_u64(a);
   //CHECK: ucvtf v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 }

Modified: cfe/trunk/test/CodeGen/aarch64-neon-perm.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-perm.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-perm.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-perm.c Mon Mar  3 05:34:36 2014
@@ -7,1086 +7,1086 @@
 #include <arm_neon.h>
 
 int8x8_t test_vuzp1_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vuzp1_s8
+  // CHECK-LABEL: test_vuzp1_s8
   return vuzp1_s8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vuzp1q_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vuzp1q_s8
+  // CHECK-LABEL: test_vuzp1q_s8
   return vuzp1q_s8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x4_t test_vuzp1_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vuzp1_s16
+  // CHECK-LABEL: test_vuzp1_s16
   return vuzp1_s16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int16x8_t test_vuzp1q_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vuzp1q_s16
+  // CHECK-LABEL: test_vuzp1q_s16
   return vuzp1q_s16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x2_t test_vuzp1_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vuzp1_s32
+  // CHECK-LABEL: test_vuzp1_s32
   return vuzp1_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vuzp1q_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vuzp1q_s32
+  // CHECK-LABEL: test_vuzp1q_s32
   return vuzp1q_s32(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vuzp1q_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vuzp1q_s64
+  // CHECK-LABEL: test_vuzp1q_s64
   return vuzp1q_s64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 uint8x8_t test_vuzp1_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vuzp1_u8
+  // CHECK-LABEL: test_vuzp1_u8
   return vuzp1_u8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vuzp1q_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vuzp1q_u8
+  // CHECK-LABEL: test_vuzp1q_u8
   return vuzp1q_u8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x4_t test_vuzp1_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vuzp1_u16
+  // CHECK-LABEL: test_vuzp1_u16
   return vuzp1_u16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint16x8_t test_vuzp1q_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vuzp1q_u16
+  // CHECK-LABEL: test_vuzp1q_u16
   return vuzp1q_u16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x2_t test_vuzp1_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vuzp1_u32
+  // CHECK-LABEL: test_vuzp1_u32
   return vuzp1_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vuzp1q_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vuzp1q_u32
+  // CHECK-LABEL: test_vuzp1q_u32
   return vuzp1q_u32(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vuzp1q_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vuzp1q_u64
+  // CHECK-LABEL: test_vuzp1q_u64
   return vuzp1q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 float32x2_t test_vuzp1_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vuzp1_f32
+  // CHECK-LABEL: test_vuzp1_f32
   return vuzp1_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vuzp1q_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vuzp1q_f32
+  // CHECK-LABEL: test_vuzp1q_f32
   return vuzp1q_f32(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vuzp1q_f64(float64x2_t a, float64x2_t b) {
-  // CHECK: test_vuzp1q_f64
+  // CHECK-LABEL: test_vuzp1q_f64
   return vuzp1q_f64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 poly8x8_t test_vuzp1_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vuzp1_p8
+  // CHECK-LABEL: test_vuzp1_p8
   return vuzp1_p8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly8x16_t test_vuzp1q_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vuzp1q_p8
+  // CHECK-LABEL: test_vuzp1q_p8
   return vuzp1q_p8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly16x4_t test_vuzp1_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vuzp1_p16
+  // CHECK-LABEL: test_vuzp1_p16
   return vuzp1_p16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 poly16x8_t test_vuzp1q_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vuzp1q_p16
+  // CHECK-LABEL: test_vuzp1q_p16
   return vuzp1q_p16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int8x8_t test_vuzp2_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vuzp2_s8
+  // CHECK-LABEL: test_vuzp2_s8
   return vuzp2_s8(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vuzp2q_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vuzp2q_s8
+  // CHECK-LABEL: test_vuzp2q_s8
   return vuzp2q_s8(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x4_t test_vuzp2_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vuzp2_s16
+  // CHECK-LABEL: test_vuzp2_s16
   return vuzp2_s16(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int16x8_t test_vuzp2q_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vuzp2q_s16
+  // CHECK-LABEL: test_vuzp2q_s16
   return vuzp2q_s16(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x2_t test_vuzp2_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vuzp2_s32
+  // CHECK-LABEL: test_vuzp2_s32
   return vuzp2_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vuzp2q_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vuzp2q_s32
+  // CHECK-LABEL: test_vuzp2q_s32
   return vuzp2q_s32(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vuzp2q_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vuzp2q_s64
+  // CHECK-LABEL: test_vuzp2q_s64
   return vuzp2q_s64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 uint8x8_t test_vuzp2_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vuzp2_u8
+  // CHECK-LABEL: test_vuzp2_u8
   return vuzp2_u8(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vuzp2q_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vuzp2q_u8
+  // CHECK-LABEL: test_vuzp2q_u8
   return vuzp2q_u8(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x4_t test_vuzp2_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vuzp2_u16
+  // CHECK-LABEL: test_vuzp2_u16
   return vuzp2_u16(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint16x8_t test_vuzp2q_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vuzp2q_u16
+  // CHECK-LABEL: test_vuzp2q_u16
   return vuzp2q_u16(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x2_t test_vuzp2_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vuzp2_u32
+  // CHECK-LABEL: test_vuzp2_u32
   return vuzp2_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 uint32x4_t test_vuzp2q_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vuzp2q_u32
+  // CHECK-LABEL: test_vuzp2q_u32
   return vuzp2q_u32(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vuzp2q_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vuzp2q_u64
+  // CHECK-LABEL: test_vuzp2q_u64
   return vuzp2q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 float32x2_t test_vuzp2_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vuzp2_f32
+  // CHECK-LABEL: test_vuzp2_f32
   return vuzp2_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 float32x4_t test_vuzp2q_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vuzp2q_f32
+  // CHECK-LABEL: test_vuzp2q_f32
   return vuzp2q_f32(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vuzp2q_f64(float64x2_t a, float64x2_t b) {
-  // CHECK: test_vuzp2q_f64
+  // CHECK-LABEL: test_vuzp2q_f64
   return vuzp2q_f64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 poly8x8_t test_vuzp2_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vuzp2_p8
+  // CHECK-LABEL: test_vuzp2_p8
   return vuzp2_p8(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly8x16_t test_vuzp2q_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vuzp2q_p8
+  // CHECK-LABEL: test_vuzp2q_p8
   return vuzp2q_p8(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly16x4_t test_vuzp2_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vuzp2_p16
+  // CHECK-LABEL: test_vuzp2_p16
   return vuzp2_p16(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 poly16x8_t test_vuzp2q_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vuzp2q_p16
+  // CHECK-LABEL: test_vuzp2q_p16
   return vuzp2q_p16(a, b);
   // CHECK: uzp2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int8x8_t test_vzip1_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vzip1_s8
+  // CHECK-LABEL: test_vzip1_s8
   return vzip1_s8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vzip1q_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vzip1q_s8
+  // CHECK-LABEL: test_vzip1q_s8
   return vzip1q_s8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x4_t test_vzip1_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vzip1_s16
+  // CHECK-LABEL: test_vzip1_s16
   return vzip1_s16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int16x8_t test_vzip1q_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vzip1q_s16
+  // CHECK-LABEL: test_vzip1q_s16
   return vzip1q_s16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x2_t test_vzip1_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vzip1_s32
+  // CHECK-LABEL: test_vzip1_s32
   return vzip1_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vzip1q_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vzip1q_s32
+  // CHECK-LABEL: test_vzip1q_s32
   return vzip1q_s32(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vzip1q_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vzip1q_s64
+  // CHECK-LABEL: test_vzip1q_s64
   return vzip1q_s64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 uint8x8_t test_vzip1_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vzip1_u8
+  // CHECK-LABEL: test_vzip1_u8
   return vzip1_u8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vzip1q_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vzip1q_u8
+  // CHECK-LABEL: test_vzip1q_u8
   return vzip1q_u8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x4_t test_vzip1_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vzip1_u16
+  // CHECK-LABEL: test_vzip1_u16
   return vzip1_u16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint16x8_t test_vzip1q_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vzip1q_u16
+  // CHECK-LABEL: test_vzip1q_u16
   return vzip1q_u16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x2_t test_vzip1_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vzip1_u32
+  // CHECK-LABEL: test_vzip1_u32
   return vzip1_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vzip1q_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vzip1q_u32
+  // CHECK-LABEL: test_vzip1q_u32
   return vzip1q_u32(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vzip1q_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vzip1q_u64
+  // CHECK-LABEL: test_vzip1q_u64
   return vzip1q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 float32x2_t test_vzip1_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vzip1_f32
+  // CHECK-LABEL: test_vzip1_f32
   return vzip1_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vzip1q_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vzip1q_f32
+  // CHECK-LABEL: test_vzip1q_f32
   return vzip1q_f32(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vzip1q_f64(float64x2_t a, float64x2_t b) {
-  // CHECK: test_vzip1q_f64
+  // CHECK-LABEL: test_vzip1q_f64
   return vzip1q_f64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 poly8x8_t test_vzip1_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vzip1_p8
+  // CHECK-LABEL: test_vzip1_p8
   return vzip1_p8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly8x16_t test_vzip1q_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vzip1q_p8
+  // CHECK-LABEL: test_vzip1q_p8
   return vzip1q_p8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly16x4_t test_vzip1_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vzip1_p16
+  // CHECK-LABEL: test_vzip1_p16
   return vzip1_p16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 poly16x8_t test_vzip1q_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vzip1q_p16
+  // CHECK-LABEL: test_vzip1q_p16
   return vzip1q_p16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int8x8_t test_vzip2_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vzip2_s8
+  // CHECK-LABEL: test_vzip2_s8
   return vzip2_s8(a, b);
   // CHECK: zip2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vzip2q_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vzip2q_s8
+  // CHECK-LABEL: test_vzip2q_s8
   return vzip2q_s8(a, b);
   // CHECK: zip2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x4_t test_vzip2_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vzip2_s16
+  // CHECK-LABEL: test_vzip2_s16
   return vzip2_s16(a, b);
   // CHECK: zip2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int16x8_t test_vzip2q_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vzip2q_s16
+  // CHECK-LABEL: test_vzip2q_s16
   return vzip2q_s16(a, b);
   // CHECK: zip2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x2_t test_vzip2_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vzip2_s32
+  // CHECK-LABEL: test_vzip2_s32
   return vzip2_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vzip2q_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vzip2q_s32
+  // CHECK-LABEL: test_vzip2q_s32
   return vzip2q_s32(a, b);
   // CHECK: zip2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vzip2q_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vzip2q_s64
+  // CHECK-LABEL: test_vzip2q_s64
   return vzip2q_s64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 uint8x8_t test_vzip2_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vzip2_u8
+  // CHECK-LABEL: test_vzip2_u8
   return vzip2_u8(a, b);
   // CHECK: zip2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vzip2q_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vzip2q_u8
+  // CHECK-LABEL: test_vzip2q_u8
   return vzip2q_u8(a, b);
   // CHECK: zip2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x4_t test_vzip2_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vzip2_u16
+  // CHECK-LABEL: test_vzip2_u16
   return vzip2_u16(a, b);
   // CHECK: zip2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint16x8_t test_vzip2q_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vzip2q_u16
+  // CHECK-LABEL: test_vzip2q_u16
   return vzip2q_u16(a, b);
   // CHECK: zip2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x2_t test_vzip2_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vzip2_u32
+  // CHECK-LABEL: test_vzip2_u32
   return vzip2_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 uint32x4_t test_vzip2q_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vzip2q_u32
+  // CHECK-LABEL: test_vzip2q_u32
   return vzip2q_u32(a, b);
   // CHECK: zip2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vzip2q_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vzip2q_u64
+  // CHECK-LABEL: test_vzip2q_u64
   return vzip2q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 float32x2_t test_vzip2_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vzip2_f32
+  // CHECK-LABEL: test_vzip2_f32
   return vzip2_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 float32x4_t test_vzip2q_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vzip2q_f32
+  // CHECK-LABEL: test_vzip2q_f32
   return vzip2q_f32(a, b);
   // CHECK: zip2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vzip2q_f64(float64x2_t a, float64x2_t b) {
-  // CHECK: test_vzip2q_f64
+  // CHECK-LABEL: test_vzip2q_f64
   return vzip2q_f64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 poly8x8_t test_vzip2_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vzip2_p8
+  // CHECK-LABEL: test_vzip2_p8
   return vzip2_p8(a, b);
   // CHECK: zip2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly8x16_t test_vzip2q_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vzip2q_p8
+  // CHECK-LABEL: test_vzip2q_p8
   return vzip2q_p8(a, b);
   // CHECK: zip2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly16x4_t test_vzip2_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vzip2_p16
+  // CHECK-LABEL: test_vzip2_p16
   return vzip2_p16(a, b);
   // CHECK: zip2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 poly16x8_t test_vzip2q_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vzip2q_p16
+  // CHECK-LABEL: test_vzip2q_p16
   return vzip2q_p16(a, b);
   // CHECK: zip2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int8x8_t test_vtrn1_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vtrn1_s8
+  // CHECK-LABEL: test_vtrn1_s8
   return vtrn1_s8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vtrn1q_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vtrn1q_s8
+  // CHECK-LABEL: test_vtrn1q_s8
   return vtrn1q_s8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x4_t test_vtrn1_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vtrn1_s16
+  // CHECK-LABEL: test_vtrn1_s16
   return vtrn1_s16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int16x8_t test_vtrn1q_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vtrn1q_s16
+  // CHECK-LABEL: test_vtrn1q_s16
   return vtrn1q_s16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x2_t test_vtrn1_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vtrn1_s32
+  // CHECK-LABEL: test_vtrn1_s32
   return vtrn1_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 int32x4_t test_vtrn1q_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vtrn1q_s32
+  // CHECK-LABEL: test_vtrn1q_s32
   return vtrn1q_s32(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vtrn1q_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vtrn1q_s64
+  // CHECK-LABEL: test_vtrn1q_s64
   return vtrn1q_s64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 uint8x8_t test_vtrn1_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vtrn1_u8
+  // CHECK-LABEL: test_vtrn1_u8
   return vtrn1_u8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vtrn1q_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vtrn1q_u8
+  // CHECK-LABEL: test_vtrn1q_u8
   return vtrn1q_u8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x4_t test_vtrn1_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vtrn1_u16
+  // CHECK-LABEL: test_vtrn1_u16
   return vtrn1_u16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint16x8_t test_vtrn1q_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vtrn1q_u16
+  // CHECK-LABEL: test_vtrn1q_u16
   return vtrn1q_u16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x2_t test_vtrn1_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vtrn1_u32
+  // CHECK-LABEL: test_vtrn1_u32
   return vtrn1_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 uint32x4_t test_vtrn1q_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vtrn1q_u32
+  // CHECK-LABEL: test_vtrn1q_u32
   return vtrn1q_u32(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vtrn1q_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vtrn1q_u64
+  // CHECK-LABEL: test_vtrn1q_u64
   return vtrn1q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 float32x2_t test_vtrn1_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vtrn1_f32
+  // CHECK-LABEL: test_vtrn1_f32
   return vtrn1_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
 }
 
 float32x4_t test_vtrn1q_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vtrn1q_f32
+  // CHECK-LABEL: test_vtrn1q_f32
   return vtrn1q_f32(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vtrn1q_f64(float64x2_t a, float64x2_t b) {
-  // CHECK: test_vtrn1q_f64
+  // CHECK-LABEL: test_vtrn1q_f64
   return vtrn1q_f64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 poly8x8_t test_vtrn1_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vtrn1_p8
+  // CHECK-LABEL: test_vtrn1_p8
   return vtrn1_p8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly8x16_t test_vtrn1q_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vtrn1q_p8
+  // CHECK-LABEL: test_vtrn1q_p8
   return vtrn1q_p8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly16x4_t test_vtrn1_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vtrn1_p16
+  // CHECK-LABEL: test_vtrn1_p16
   return vtrn1_p16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 poly16x8_t test_vtrn1q_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vtrn1q_p16
+  // CHECK-LABEL: test_vtrn1q_p16
   return vtrn1q_p16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int8x8_t test_vtrn2_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vtrn2_s8
+  // CHECK-LABEL: test_vtrn2_s8
   return vtrn2_s8(a, b);
   // CHECK: trn2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vtrn2q_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vtrn2q_s8
+  // CHECK-LABEL: test_vtrn2q_s8
   return vtrn2q_s8(a, b);
   // CHECK: trn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 int16x4_t test_vtrn2_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vtrn2_s16
+  // CHECK-LABEL: test_vtrn2_s16
   return vtrn2_s16(a, b);
   // CHECK: trn2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 int16x8_t test_vtrn2q_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vtrn2q_s16
+  // CHECK-LABEL: test_vtrn2q_s16
   return vtrn2q_s16(a, b);
   // CHECK: trn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int32x2_t test_vtrn2_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vtrn2_s32
+  // CHECK-LABEL: test_vtrn2_s32
   return vtrn2_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 int32x4_t test_vtrn2q_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vtrn2q_s32
+  // CHECK-LABEL: test_vtrn2q_s32
   return vtrn2q_s32(a, b);
   // CHECK: trn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 int64x2_t test_vtrn2q_s64(int64x2_t a, int64x2_t b) {
-  // CHECK: test_vtrn2q_s64
+  // CHECK-LABEL: test_vtrn2q_s64
   return vtrn2q_s64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 uint8x8_t test_vtrn2_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vtrn2_u8
+  // CHECK-LABEL: test_vtrn2_u8
   return vtrn2_u8(a, b);
   // CHECK: trn2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vtrn2q_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vtrn2q_u8
+  // CHECK-LABEL: test_vtrn2q_u8
   return vtrn2q_u8(a, b);
   // CHECK: trn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 uint16x4_t test_vtrn2_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vtrn2_u16
+  // CHECK-LABEL: test_vtrn2_u16
   return vtrn2_u16(a, b);
   // CHECK: trn2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 uint16x8_t test_vtrn2q_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vtrn2q_u16
+  // CHECK-LABEL: test_vtrn2q_u16
   return vtrn2q_u16(a, b);
   // CHECK: trn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 uint32x2_t test_vtrn2_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vtrn2_u32
+  // CHECK-LABEL: test_vtrn2_u32
   return vtrn2_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 uint32x4_t test_vtrn2q_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vtrn2q_u32
+  // CHECK-LABEL: test_vtrn2q_u32
   return vtrn2q_u32(a, b);
   // CHECK: trn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 uint64x2_t test_vtrn2q_u64(uint64x2_t a, uint64x2_t b) {
-  // CHECK: test_vtrn2q_u64
+  // CHECK-LABEL: test_vtrn2q_u64
   return vtrn2q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 float32x2_t test_vtrn2_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vtrn2_f32
+  // CHECK-LABEL: test_vtrn2_f32
   return vtrn2_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 
 float32x4_t test_vtrn2q_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vtrn2q_f32
+  // CHECK-LABEL: test_vtrn2q_f32
   return vtrn2q_f32(a, b);
   // CHECK: trn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 
 float64x2_t test_vtrn2q_f64(float64x2_t a, float64x2_t b) {
-  // CHECK: test_vtrn2q_f64
+  // CHECK-LABEL: test_vtrn2q_f64
   return vtrn2q_f64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 poly8x8_t test_vtrn2_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vtrn2_p8
+  // CHECK-LABEL: test_vtrn2_p8
   return vtrn2_p8(a, b);
   // CHECK: trn2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly8x16_t test_vtrn2q_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vtrn2q_p8
+  // CHECK-LABEL: test_vtrn2q_p8
   return vtrn2q_p8(a, b);
   // CHECK: trn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly16x4_t test_vtrn2_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vtrn2_p16
+  // CHECK-LABEL: test_vtrn2_p16
   return vtrn2_p16(a, b);
   // CHECK: trn2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 
 poly16x8_t test_vtrn2q_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vtrn2q_p16
+  // CHECK-LABEL: test_vtrn2q_p16
   return vtrn2q_p16(a, b);
   // CHECK: trn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int8x8x2_t test_vuzp_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vuzp_s8
+  // CHECK-LABEL: test_vuzp_s8
   return vuzp_s8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: uzp2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4x2_t test_vuzp_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vuzp_s16
+  // CHECK-LABEL: test_vuzp_s16
   return vuzp_s16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: uzp2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int32x2x2_t test_vuzp_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vuzp_s32
+  // CHECK-LABEL: test_vuzp_s32
   return vuzp_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 uint8x8x2_t test_vuzp_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vuzp_u8
+  // CHECK-LABEL: test_vuzp_u8
   return vuzp_u8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: uzp2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 uint16x4x2_t test_vuzp_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vuzp_u16
+  // CHECK-LABEL: test_vuzp_u16
   return vuzp_u16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: uzp2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 uint32x2x2_t test_vuzp_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vuzp_u32
+  // CHECK-LABEL: test_vuzp_u32
   return vuzp_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 float32x2x2_t test_vuzp_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vuzp_f32
+  // CHECK-LABEL: test_vuzp_f32
   return vuzp_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 poly8x8x2_t test_vuzp_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vuzp_p8
+  // CHECK-LABEL: test_vuzp_p8
   return vuzp_p8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: uzp2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 poly16x4x2_t test_vuzp_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vuzp_p16
+  // CHECK-LABEL: test_vuzp_p16
   return vuzp_p16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: uzp2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int8x16x2_t test_vuzpq_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vuzpq_s8
+  // CHECK-LABEL: test_vuzpq_s8
   return vuzpq_s8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: uzp2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 int16x8x2_t test_vuzpq_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vuzpq_s16
+  // CHECK-LABEL: test_vuzpq_s16
   return vuzpq_s16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: uzp2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int32x4x2_t test_vuzpq_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vuzpq_s32
+  // CHECK-LABEL: test_vuzpq_s32
   return vuzpq_s32(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: uzp2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint8x16x2_t test_vuzpq_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vuzpq_u8
+  // CHECK-LABEL: test_vuzpq_u8
   return vuzpq_u8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: uzp2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 uint16x8x2_t test_vuzpq_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vuzpq_u16
+  // CHECK-LABEL: test_vuzpq_u16
   return vuzpq_u16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: uzp2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 uint32x4x2_t test_vuzpq_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vuzpq_u32
+  // CHECK-LABEL: test_vuzpq_u32
   return vuzpq_u32(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: uzp2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 float32x4x2_t test_vuzpq_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vuzpq_f32
+  // CHECK-LABEL: test_vuzpq_f32
   return vuzpq_f32(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: uzp2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 poly8x16x2_t test_vuzpq_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vuzpq_p8
+  // CHECK-LABEL: test_vuzpq_p8
   return vuzpq_p8(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: uzp2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 poly16x8x2_t test_vuzpq_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vuzpq_p16
+  // CHECK-LABEL: test_vuzpq_p16
   return vuzpq_p16(a, b);
   // CHECK: uzp1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: uzp2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int8x8x2_t test_vzip_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vzip_s8
+  // CHECK-LABEL: test_vzip_s8
   return vzip_s8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: zip2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4x2_t test_vzip_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vzip_s16
+  // CHECK-LABEL: test_vzip_s16
   return vzip_s16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: zip2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int32x2x2_t test_vzip_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vzip_s32
+  // CHECK-LABEL: test_vzip_s32
   return vzip_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 uint8x8x2_t test_vzip_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vzip_u8
+  // CHECK-LABEL: test_vzip_u8
   return vzip_u8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: zip2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 uint16x4x2_t test_vzip_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vzip_u16
+  // CHECK-LABEL: test_vzip_u16
   return vzip_u16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: zip2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 uint32x2x2_t test_vzip_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vzip_u32
+  // CHECK-LABEL: test_vzip_u32
   return vzip_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 float32x2x2_t test_vzip_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vzip_f32
+  // CHECK-LABEL: test_vzip_f32
   return vzip_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 poly8x8x2_t test_vzip_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vzip_p8
+  // CHECK-LABEL: test_vzip_p8
   return vzip_p8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: zip2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 poly16x4x2_t test_vzip_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vzip_p16
+  // CHECK-LABEL: test_vzip_p16
   return vzip_p16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: zip2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int8x16x2_t test_vzipq_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vzipq_s8
+  // CHECK-LABEL: test_vzipq_s8
   return vzipq_s8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: zip2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 int16x8x2_t test_vzipq_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vzipq_s16
+  // CHECK-LABEL: test_vzipq_s16
   return vzipq_s16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: zip2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int32x4x2_t test_vzipq_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vzipq_s32
+  // CHECK-LABEL: test_vzipq_s32
   return vzipq_s32(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: zip2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint8x16x2_t test_vzipq_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vzipq_u8
+  // CHECK-LABEL: test_vzipq_u8
   return vzipq_u8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: zip2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 uint16x8x2_t test_vzipq_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vzipq_u16
+  // CHECK-LABEL: test_vzipq_u16
   return vzipq_u16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: zip2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 uint32x4x2_t test_vzipq_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vzipq_u32
+  // CHECK-LABEL: test_vzipq_u32
   return vzipq_u32(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: zip2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 float32x4x2_t test_vzipq_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vzipq_f32
+  // CHECK-LABEL: test_vzipq_f32
   return vzipq_f32(a, b);
   // CHECK: zip1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: zip2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 poly8x16x2_t test_vzipq_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vzipq_p8
+  // CHECK-LABEL: test_vzipq_p8
   return vzipq_p8(a, b);
   // CHECK: zip1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: zip2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 poly16x8x2_t test_vzipq_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vzipq_p16
+  // CHECK-LABEL: test_vzipq_p16
   return vzipq_p16(a, b);
   // CHECK: zip1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: zip2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 
 int8x8x2_t test_vtrn_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vtrn_s8
+  // CHECK-LABEL: test_vtrn_s8
   return vtrn_s8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: trn2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 int16x4x2_t test_vtrn_s16(int16x4_t a, int16x4_t b) {
-  // CHECK: test_vtrn_s16
+  // CHECK-LABEL: test_vtrn_s16
   return vtrn_s16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: trn2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int32x2x2_t test_vtrn_s32(int32x2_t a, int32x2_t b) {
-  // CHECK: test_vtrn_s32
+  // CHECK-LABEL: test_vtrn_s32
   return vtrn_s32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 uint8x8x2_t test_vtrn_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vtrn_u8
+  // CHECK-LABEL: test_vtrn_u8
   return vtrn_u8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: trn2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 uint16x4x2_t test_vtrn_u16(uint16x4_t a, uint16x4_t b) {
-  // CHECK: test_vtrn_u16
+  // CHECK-LABEL: test_vtrn_u16
   return vtrn_u16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: trn2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 uint32x2x2_t test_vtrn_u32(uint32x2_t a, uint32x2_t b) {
-  // CHECK: test_vtrn_u32
+  // CHECK-LABEL: test_vtrn_u32
   return vtrn_u32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 float32x2x2_t test_vtrn_f32(float32x2_t a, float32x2_t b) {
-  // CHECK: test_vtrn_f32
+  // CHECK-LABEL: test_vtrn_f32
   return vtrn_f32(a, b);
   // CHECK: ins {{v[0-9]+}}.s[1], {{v[0-9]+}}.s[0]
   // CHECK: ins {{v[0-9]+}}.s[0], {{v[0-9]+}}.s[1]
 }
 poly8x8x2_t test_vtrn_p8(poly8x8_t a, poly8x8_t b) {
-  // CHECK: test_vtrn_p8
+  // CHECK-LABEL: test_vtrn_p8
   return vtrn_p8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
   // CHECK: trn2 {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 poly16x4x2_t test_vtrn_p16(poly16x4_t a, poly16x4_t b) {
-  // CHECK: test_vtrn_p16
+  // CHECK-LABEL: test_vtrn_p16
   return vtrn_p16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
   // CHECK: trn2 {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 }
 int8x16x2_t test_vtrnq_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vtrnq_s8
+  // CHECK-LABEL: test_vtrnq_s8
   return vtrnq_s8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: trn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 int16x8x2_t test_vtrnq_s16(int16x8_t a, int16x8_t b) {
-  // CHECK: test_vtrnq_s16
+  // CHECK-LABEL: test_vtrnq_s16
   return vtrnq_s16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: trn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 int32x4x2_t test_vtrnq_s32(int32x4_t a, int32x4_t b) {
-  // CHECK: test_vtrnq_s32
+  // CHECK-LABEL: test_vtrnq_s32
   return vtrnq_s32(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: trn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 uint8x16x2_t test_vtrnq_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vtrnq_u8
+  // CHECK-LABEL: test_vtrnq_u8
   return vtrnq_u8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: trn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 uint16x8x2_t test_vtrnq_u16(uint16x8_t a, uint16x8_t b) {
-  // CHECK: test_vtrnq_u16
+  // CHECK-LABEL: test_vtrnq_u16
   return vtrnq_u16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: trn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 }
 uint32x4x2_t test_vtrnq_u32(uint32x4_t a, uint32x4_t b) {
-  // CHECK: test_vtrnq_u32
+  // CHECK-LABEL: test_vtrnq_u32
   return vtrnq_u32(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: trn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 float32x4x2_t test_vtrnq_f32(float32x4_t a, float32x4_t b) {
-  // CHECK: test_vtrnq_f32
+  // CHECK-LABEL: test_vtrnq_f32
   return vtrnq_f32(a, b);
   // CHECK: trn1 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
   // CHECK: trn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.4s
 }
 poly8x16x2_t test_vtrnq_p8(poly8x16_t a, poly8x16_t b) {
-  // CHECK: test_vtrnq_p8
+  // CHECK-LABEL: test_vtrnq_p8
   return vtrnq_p8(a, b);
   // CHECK: trn1 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
   // CHECK: trn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 poly16x8x2_t test_vtrnq_p16(poly16x8_t a, poly16x8_t b) {
-  // CHECK: test_vtrnq_p16
+  // CHECK-LABEL: test_vtrnq_p16
   return vtrnq_p16(a, b);
   // CHECK: trn1 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
   // CHECK: trn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.8h

Modified: cfe/trunk/test/CodeGen/aarch64-neon-scalar-copy.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-scalar-copy.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-scalar-copy.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-scalar-copy.c Mon Mar  3 05:34:36 2014
@@ -5,7 +5,7 @@
 
 #include <arm_neon.h>
 
-// CHECK: test_vdups_lane_f32
+// CHECK-LABEL: test_vdups_lane_f32
 float32_t test_vdups_lane_f32(float32x2_t a) {
   return vdups_lane_f32(a, 1);
 // CHECK: ret
@@ -13,7 +13,7 @@ float32_t test_vdups_lane_f32(float32x2_
 }
 
 
-// CHECK: test_vdupd_lane_f64
+// CHECK-LABEL: test_vdupd_lane_f64
 float64_t test_vdupd_lane_f64(float64x1_t a) {
   return vdupd_lane_f64(a, 0);
 // CHECK: ret
@@ -21,7 +21,7 @@ float64_t test_vdupd_lane_f64(float64x1_
 }
 
 
-// CHECK: test_vdups_laneq_f32
+// CHECK-LABEL: test_vdups_laneq_f32
 float32_t test_vdups_laneq_f32(float32x4_t a) {
   return vdups_laneq_f32(a, 3);
 // CHECK: ret
@@ -29,7 +29,7 @@ float32_t test_vdups_laneq_f32(float32x4
 }
 
 
-// CHECK: test_vdupd_laneq_f64
+// CHECK-LABEL: test_vdupd_laneq_f64
 float64_t test_vdupd_laneq_f64(float64x2_t a) {
   return vdupd_laneq_f64(a, 1);
 // CHECK: ret
@@ -37,135 +37,135 @@ float64_t test_vdupd_laneq_f64(float64x2
 }
 
 
-// CHECK: test_vdupb_lane_s8
+// CHECK-LABEL: test_vdupb_lane_s8
 int8_t test_vdupb_lane_s8(int8x8_t a) {
   return vdupb_lane_s8(a, 7);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[7]
 }
 
 
-// CHECK: test_vduph_lane_s16
+// CHECK-LABEL: test_vduph_lane_s16
 int16_t test_vduph_lane_s16(int16x4_t a) {
   return vduph_lane_s16(a, 3);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
 
-// CHECK: test_vdups_lane_s32
+// CHECK-LABEL: test_vdups_lane_s32
 int32_t test_vdups_lane_s32(int32x2_t a) {
   return vdups_lane_s32(a, 1);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
 
-// CHECK: test_vdupd_lane_s64
+// CHECK-LABEL: test_vdupd_lane_s64
 int64_t test_vdupd_lane_s64(int64x1_t a) {
   return vdupd_lane_s64(a, 0);
 // CHECK: fmov {{x[0-9]+}}, {{d[0-9]+}}
 }
 
 
-// CHECK: test_vdupb_lane_u8
+// CHECK-LABEL: test_vdupb_lane_u8
 uint8_t test_vdupb_lane_u8(uint8x8_t a) {
   return vdupb_lane_u8(a, 7);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[7]
 }
 
 
-// CHECK: test_vduph_lane_u16
+// CHECK-LABEL: test_vduph_lane_u16
 uint16_t test_vduph_lane_u16(uint16x4_t a) {
   return vduph_lane_u16(a, 3);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
 
-// CHECK: test_vdups_lane_u32
+// CHECK-LABEL: test_vdups_lane_u32
 uint32_t test_vdups_lane_u32(uint32x2_t a) {
   return vdups_lane_u32(a, 1);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
 
-// CHECK: test_vdupd_lane_u64
+// CHECK-LABEL: test_vdupd_lane_u64
 uint64_t test_vdupd_lane_u64(uint64x1_t a) {
   return vdupd_lane_u64(a, 0);
 // CHECK: fmov {{x[0-9]+}}, {{d[0-9]+}}
 }
 
-// CHECK: test_vdupb_laneq_s8
+// CHECK-LABEL: test_vdupb_laneq_s8
 int8_t test_vdupb_laneq_s8(int8x16_t a) {
   return vdupb_laneq_s8(a, 15);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[15]
 }
 
 
-// CHECK: test_vduph_laneq_s16
+// CHECK-LABEL: test_vduph_laneq_s16
 int16_t test_vduph_laneq_s16(int16x8_t a) {
   return vduph_laneq_s16(a, 7);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[7]
 }
 
 
-// CHECK: test_vdups_laneq_s32
+// CHECK-LABEL: test_vdups_laneq_s32
 int32_t test_vdups_laneq_s32(int32x4_t a) {
   return vdups_laneq_s32(a, 3);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.s[3]
 }
 
 
-// CHECK: test_vdupd_laneq_s64
+// CHECK-LABEL: test_vdupd_laneq_s64
 int64_t test_vdupd_laneq_s64(int64x2_t a) {
   return vdupd_laneq_s64(a, 1);
 // CHECK: umov {{x[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
 
-// CHECK: test_vdupb_laneq_u8
+// CHECK-LABEL: test_vdupb_laneq_u8
 uint8_t test_vdupb_laneq_u8(uint8x16_t a) {
   return vdupb_laneq_u8(a, 15);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[15]
 }
 
 
-// CHECK: test_vduph_laneq_u16
+// CHECK-LABEL: test_vduph_laneq_u16
 uint16_t test_vduph_laneq_u16(uint16x8_t a) {
   return vduph_laneq_u16(a, 7);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[7]
 }
 
 
-// CHECK: test_vdups_laneq_u32
+// CHECK-LABEL: test_vdups_laneq_u32
 uint32_t test_vdups_laneq_u32(uint32x4_t a) {
   return vdups_laneq_u32(a, 3);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.s[3]
 }
 
 
-// CHECK: test_vdupd_laneq_u64
+// CHECK-LABEL: test_vdupd_laneq_u64
 uint64_t test_vdupd_laneq_u64(uint64x2_t a) {
   return vdupd_laneq_u64(a, 1);
 // CHECK: umov {{x[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
-// CHECK: test_vdupb_lane_p8
+// CHECK-LABEL: test_vdupb_lane_p8
 poly8_t test_vdupb_lane_p8(poly8x8_t a) {
   return vdupb_lane_p8(a, 7);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[7]
 }
 
-// CHECK: test_vduph_lane_p16
+// CHECK-LABEL: test_vduph_lane_p16
 poly16_t test_vduph_lane_p16(poly16x4_t a) {
   return vduph_lane_p16(a, 3);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
-// CHECK: test_vdupb_laneq_p8
+// CHECK-LABEL: test_vdupb_laneq_p8
 poly8_t test_vdupb_laneq_p8(poly8x16_t a) {
   return vdupb_laneq_p8(a, 15);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.b[15]
 }
 
-// CHECK: test_vduph_laneq_p16
+// CHECK-LABEL: test_vduph_laneq_p16
 poly16_t test_vduph_laneq_p16(poly16x8_t a) {
   return vduph_laneq_p16(a, 7);
 // CHECK: umov {{w[0-9]+}}, {{v[0-9]+}}.h[7]

Modified: cfe/trunk/test/CodeGen/aarch64-neon-scalar-x-indexed-elem.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-scalar-x-indexed-elem.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-scalar-x-indexed-elem.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-scalar-x-indexed-elem.c Mon Mar  3 05:34:36 2014
@@ -8,246 +8,246 @@
 
 
 float32_t test_vmuls_lane_f32(float32_t a, float32x2_t b) {
-  // CHECK: test_vmuls_lane_f32
+  // CHECK-LABEL: test_vmuls_lane_f32
   return vmuls_lane_f32(a, b, 1);
   // CHECK: fmul {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
 float64_t test_vmuld_lane_f64(float64_t a, float64x1_t b) {
-  // CHECK: test_vmuld_lane_f64
+  // CHECK-LABEL: test_vmuld_lane_f64
   return vmuld_lane_f64(a, b, 0);
   // CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
 float32_t test_vmuls_laneq_f32(float32_t a, float32x4_t b) {
-  // CHECK: test_vmuls_laneq_f32
+  // CHECK-LABEL: test_vmuls_laneq_f32
   return vmuls_laneq_f32(a, b, 3);
   // CHECK: fmul {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]
 }
 
 float64_t test_vmuld_laneq_f64(float64_t a, float64x2_t b) {
-  // CHECK: test_vmuld_laneq_f64
+  // CHECK-LABEL: test_vmuld_laneq_f64
   return vmuld_laneq_f64(a, b, 1);
   // CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
 float64x1_t test_vmul_n_f64(float64x1_t a, float64_t b) {
-  // CHECK: test_vmul_n_f64
+  // CHECK-LABEL: test_vmul_n_f64
   return vmul_n_f64(a, b);
   // CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
 float32_t test_vmulxs_lane_f32(float32_t a, float32x2_t b) {
-// CHECK: test_vmulxs_lane_f32
+// CHECK-LABEL: test_vmulxs_lane_f32
   return vmulxs_lane_f32(a, b, 1);
 // CHECK: fmulx {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
 float32_t test_vmulxs_laneq_f32(float32_t a, float32x4_t b) {
-// CHECK: test_vmulxs_laneq_f32
+// CHECK-LABEL: test_vmulxs_laneq_f32
   return vmulxs_laneq_f32(a, b, 3);
 // CHECK: fmulx {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]
 }
 
 float64_t test_vmulxd_lane_f64(float64_t a, float64x1_t b) {
-// CHECK: test_vmulxd_lane_f64
+// CHECK-LABEL: test_vmulxd_lane_f64
   return vmulxd_lane_f64(a, b, 0);
 // CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
 float64_t test_vmulxd_laneq_f64(float64_t a, float64x2_t b) {
-// CHECK: test_vmulxd_laneq_f64
+// CHECK-LABEL: test_vmulxd_laneq_f64
   return vmulxd_laneq_f64(a, b, 1);
 // CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
-// CHECK: test_vmulx_lane_f64
+// CHECK-LABEL: test_vmulx_lane_f64
 float64x1_t test_vmulx_lane_f64(float64x1_t a, float64x1_t b) {
   return vmulx_lane_f64(a, b, 0);
   // CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
 
-// CHECK: test_vmulx_laneq_f64_0
+// CHECK-LABEL: test_vmulx_laneq_f64_0
 float64x1_t test_vmulx_laneq_f64_0(float64x1_t a, float64x2_t b) {
   return vmulx_laneq_f64(a, b, 0);
   // CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vmulx_laneq_f64_1
+// CHECK-LABEL: test_vmulx_laneq_f64_1
 float64x1_t test_vmulx_laneq_f64_1(float64x1_t a, float64x2_t b) {
   return vmulx_laneq_f64(a, b, 1);
   // CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
 
-// CHECK: test_vfmas_lane_f32
+// CHECK-LABEL: test_vfmas_lane_f32
 float32_t test_vfmas_lane_f32(float32_t a, float32_t b, float32x2_t c) {
   return vfmas_lane_f32(a, b, c, 1);
   // CHECK: fmla {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
-// CHECK: test_vfmad_lane_f64
+// CHECK-LABEL: test_vfmad_lane_f64
 float64_t test_vfmad_lane_f64(float64_t a, float64_t b, float64x1_t c) {
   return vfmad_lane_f64(a, b, c, 0);
   // CHECK: fmla {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vfmad_laneq_f64
+// CHECK-LABEL: test_vfmad_laneq_f64
 float64_t test_vfmad_laneq_f64(float64_t a, float64_t b, float64x2_t c) {
   return vfmad_laneq_f64(a, b, c, 1);
   // CHECK: fmla {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
-// CHECK: test_vfmss_lane_f32
+// CHECK-LABEL: test_vfmss_lane_f32
 float32_t test_vfmss_lane_f32(float32_t a, float32_t b, float32x2_t c) {
   return vfmss_lane_f32(a, b, c, 1);
   // CHECK: fmls {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
-// CHECK: test_vfma_lane_f64
+// CHECK-LABEL: test_vfma_lane_f64
 float64x1_t test_vfma_lane_f64(float64x1_t a, float64x1_t b, float64x1_t v) {
   return vfma_lane_f64(a, b, v, 0);
   // CHECK: fmla {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vfms_lane_f64
+// CHECK-LABEL: test_vfms_lane_f64
 float64x1_t test_vfms_lane_f64(float64x1_t a, float64x1_t b, float64x1_t v) {
   return vfms_lane_f64(a, b, v, 0);
   // CHECK: fmls {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vfma_laneq_f64
+// CHECK-LABEL: test_vfma_laneq_f64
 float64x1_t test_vfma_laneq_f64(float64x1_t a, float64x1_t b, float64x2_t v) {
   return vfma_laneq_f64(a, b, v, 0);
   // CHECK: fmla {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vfms_laneq_f64
+// CHECK-LABEL: test_vfms_laneq_f64
 float64x1_t test_vfms_laneq_f64(float64x1_t a, float64x1_t b, float64x2_t v) {
   return vfms_laneq_f64(a, b, v, 0);
   // CHECK: fmls {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 }
 
-// CHECK: test_vqdmullh_lane_s16
+// CHECK-LABEL: test_vqdmullh_lane_s16
 int32_t test_vqdmullh_lane_s16(int16_t a, int16x4_t b) {
   return vqdmullh_lane_s16(a, b, 3);
   // CHECK: sqdmull {{s[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
-// CHECK: test_vqdmulls_lane_s32
+// CHECK-LABEL: test_vqdmulls_lane_s32
 int64_t test_vqdmulls_lane_s32(int32_t a, int32x2_t b) {
   return vqdmulls_lane_s32(a, b, 1);
   // CHECK: sqdmull {{d[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
-// CHECK: test_vqdmullh_laneq_s16
+// CHECK-LABEL: test_vqdmullh_laneq_s16
 int32_t test_vqdmullh_laneq_s16(int16_t a, int16x8_t b) {
   return vqdmullh_laneq_s16(a, b, 7);
   // CHECK: sqdmull {{s[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[7]
 }
 
-// CHECK: test_vqdmulls_laneq_s32
+// CHECK-LABEL: test_vqdmulls_laneq_s32
 int64_t test_vqdmulls_laneq_s32(int32_t a, int32x4_t b) {
   return vqdmulls_laneq_s32(a, b, 3);
   // CHECK: sqdmull {{d[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]
 }
 
-// CHECK: test_vqdmulhh_lane_s16
+// CHECK-LABEL: test_vqdmulhh_lane_s16
 int16_t test_vqdmulhh_lane_s16(int16_t a, int16x4_t b) {
   return vqdmulhh_lane_s16(a, b, 3);
 // CHECK: sqdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
-// CHECK: test_vqdmulhs_lane_s32
+// CHECK-LABEL: test_vqdmulhs_lane_s32
 int32_t test_vqdmulhs_lane_s32(int32_t a, int32x2_t b) {
   return vqdmulhs_lane_s32(a, b, 1);
 // CHECK: sqdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
 
-// CHECK: test_vqdmulhh_laneq_s16
+// CHECK-LABEL: test_vqdmulhh_laneq_s16
 int16_t test_vqdmulhh_laneq_s16(int16_t a, int16x8_t b) {
   return vqdmulhh_laneq_s16(a, b, 7);
 // CHECK: sqdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[7]
 }
 
 
-// CHECK: test_vqdmulhs_laneq_s32
+// CHECK-LABEL: test_vqdmulhs_laneq_s32
 int32_t test_vqdmulhs_laneq_s32(int32_t a, int32x4_t b) {
   return vqdmulhs_laneq_s32(a, b, 3);
 // CHECK: sqdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]
 }
 
-// CHECK: test_vqrdmulhh_lane_s16
+// CHECK-LABEL: test_vqrdmulhh_lane_s16
 int16_t test_vqrdmulhh_lane_s16(int16_t a, int16x4_t b) {
   return vqrdmulhh_lane_s16(a, b, 3);
 // CHECK: sqrdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
-// CHECK: test_vqrdmulhs_lane_s32
+// CHECK-LABEL: test_vqrdmulhs_lane_s32
 int32_t test_vqrdmulhs_lane_s32(int32_t a, int32x2_t b) {
   return vqrdmulhs_lane_s32(a, b, 1);
 // CHECK: sqrdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
 
-// CHECK: test_vqrdmulhh_laneq_s16
+// CHECK-LABEL: test_vqrdmulhh_laneq_s16
 int16_t test_vqrdmulhh_laneq_s16(int16_t a, int16x8_t b) {
   return vqrdmulhh_laneq_s16(a, b, 7);
 // CHECK: sqrdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[7]
 }
 
 
-// CHECK: test_vqrdmulhs_laneq_s32
+// CHECK-LABEL: test_vqrdmulhs_laneq_s32
 int32_t test_vqrdmulhs_laneq_s32(int32_t a, int32x4_t b) {
   return vqrdmulhs_laneq_s32(a, b, 3);
 // CHECK: sqrdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]
 }
 
-// CHECK: test_vqdmlalh_lane_s16
+// CHECK-LABEL: test_vqdmlalh_lane_s16
 int32_t test_vqdmlalh_lane_s16(int32_t a, int16_t b, int16x4_t c) {
   return vqdmlalh_lane_s16(a, b, c, 3);
 // CHECK: sqdmlal {{s[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
-// CHECK: test_vqdmlals_lane_s32
+// CHECK-LABEL: test_vqdmlals_lane_s32
 int64_t test_vqdmlals_lane_s32(int64_t a, int32_t b, int32x2_t c) {
   return vqdmlals_lane_s32(a, b, c, 1);
 // CHECK: sqdmlal {{d[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
-// CHECK: test_vqdmlalh_laneq_s16
+// CHECK-LABEL: test_vqdmlalh_laneq_s16
 int32_t test_vqdmlalh_laneq_s16(int32_t a, int16_t b, int16x8_t c) {
   return vqdmlalh_laneq_s16(a, b, c, 7);
 // CHECK: sqdmlal {{s[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[7]
 }
 
-// CHECK: test_vqdmlals_laneq_s32
+// CHECK-LABEL: test_vqdmlals_laneq_s32
 int64_t test_vqdmlals_laneq_s32(int64_t a, int32_t b, int32x4_t c) {
   return vqdmlals_laneq_s32(a, b, c, 3);
 // CHECK: sqdmlal {{d[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]
 }
 
-// CHECK: test_vqdmlslh_lane_s16
+// CHECK-LABEL: test_vqdmlslh_lane_s16
 int32_t test_vqdmlslh_lane_s16(int32_t a, int16_t b, int16x4_t c) {
   return vqdmlslh_lane_s16(a, b, c, 3);
 // CHECK: sqdmlsl {{s[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[3]
 }
 
-// CHECK: test_vqdmlsls_lane_s32
+// CHECK-LABEL: test_vqdmlsls_lane_s32
 int64_t test_vqdmlsls_lane_s32(int64_t a, int32_t b, int32x2_t c) {
   return vqdmlsls_lane_s32(a, b, c, 1);
 // CHECK: sqdmlsl {{d[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[1]
 }
 
-// CHECK: test_vqdmlslh_laneq_s16
+// CHECK-LABEL: test_vqdmlslh_laneq_s16
 int32_t test_vqdmlslh_laneq_s16(int32_t a, int16_t b, int16x8_t c) {
   return vqdmlslh_laneq_s16(a, b, c, 7);
 // CHECK: sqdmlsl {{s[0-9]+}}, {{h[0-9]+}}, {{v[0-9]+}}.h[7]
 }
 
-// CHECK: test_vqdmlsls_laneq_s32
+// CHECK-LABEL: test_vqdmlsls_laneq_s32
 int64_t test_vqdmlsls_laneq_s32(int64_t a, int32_t b, int32x4_t c) {
   return vqdmlsls_laneq_s32(a, b, c, 3);
 // CHECK: sqdmlsl {{d[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]

Modified: cfe/trunk/test/CodeGen/aarch64-neon-tbl.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-neon-tbl.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-neon-tbl.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-neon-tbl.c Mon Mar  3 05:34:36 2014
@@ -7,79 +7,79 @@
 #include <arm_neon.h>
 
 int8x8_t test_vtbl1_s8(int8x8_t a, int8x8_t b) {
-  // CHECK: test_vtbl1_s8
+  // CHECK-LABEL: test_vtbl1_s8
   return vtbl1_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vqtbl1_s8(int8x16_t a, int8x8_t b) {
-  // CHECK: test_vqtbl1_s8
+  // CHECK-LABEL: test_vqtbl1_s8
   return vqtbl1_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vtbl2_s8(int8x8x2_t a, int8x8_t b) {
-  // CHECK: test_vtbl2_s8
+  // CHECK-LABEL: test_vtbl2_s8
   return vtbl2_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vqtbl2_s8(int8x16x2_t a, int8x8_t b) {
-  // CHECK: test_vqtbl2_s8
+  // CHECK-LABEL: test_vqtbl2_s8
   return vqtbl2_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vtbl3_s8(int8x8x3_t a, int8x8_t b) {
-  // CHECK: test_vtbl3_s8
+  // CHECK-LABEL: test_vtbl3_s8
   return vtbl3_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vqtbl3_s8(int8x16x3_t a, int8x8_t b) {
-  // CHECK: test_vqtbl3_s8
+  // CHECK-LABEL: test_vqtbl3_s8
   return vqtbl3_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vtbl4_s8(int8x8x4_t a, int8x8_t b) {
-  // CHECK: test_vtbl4_s8
+  // CHECK-LABEL: test_vtbl4_s8
   return vtbl4_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vqtbl4_s8(int8x16x4_t a, int8x8_t b) {
-  // CHECK: test_vqtbl4_s8
+  // CHECK-LABEL: test_vqtbl4_s8
   return vqtbl4_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vqtbl1q_s8(int8x16_t a, int8x16_t b) {
-  // CHECK: test_vqtbl1q_s8
+  // CHECK-LABEL: test_vqtbl1q_s8
   return vqtbl1q_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 int8x16_t test_vqtbl2q_s8(int8x16x2_t a, int8x16_t b) {
-  // CHECK: test_vqtbl2q_s8
+  // CHECK-LABEL: test_vqtbl2q_s8
   return vqtbl2q_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 int8x16_t test_vqtbl3q_s8(int8x16x3_t a, int8x16_t b) {
-  // CHECK: test_vqtbl3q_s8
+  // CHECK-LABEL: test_vqtbl3q_s8
   return vqtbl3q_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 int8x16_t test_vqtbl4q_s8(int8x16x4_t a, int8x16_t b) {
-  // CHECK: test_vqtbl4q_s8
+  // CHECK-LABEL: test_vqtbl4q_s8
   return vqtbl4q_s8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 int8x8_t test_vtbx1_s8(int8x8_t a, int8x8_t b, int8x8_t c) {
-  // CHECK: test_vtbx1_s8
+  // CHECK-LABEL: test_vtbx1_s8
   return vtbx1_s8(a, b, c);
   // CHECK: movi {{v[0-9]+}}.8b, #0
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
@@ -89,13 +89,13 @@ int8x8_t test_vtbx1_s8(int8x8_t a, int8x
 }
 
 int8x8_t test_vtbx2_s8(int8x8_t a, int8x8x2_t b, int8x8_t c) {
-  // CHECK: test_vtbx2_s8
+  // CHECK-LABEL: test_vtbx2_s8
   return vtbx2_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vtbx3_s8(int8x8_t a, int8x8x3_t b, int8x8_t c) {
-  // CHECK: test_vtbx3_s8
+  // CHECK-LABEL: test_vtbx3_s8
   return vtbx3_s8(a, b, c);
   // CHECK: movi {{v[0-9]+}}.8b, #0
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
@@ -105,133 +105,133 @@ int8x8_t test_vtbx3_s8(int8x8_t a, int8x
 }
 
 int8x8_t test_vtbx4_s8(int8x8_t a, int8x8x4_t b, int8x8_t c) {
-  // CHECK: test_vtbx4_s8
+  // CHECK-LABEL: test_vtbx4_s8
   return vtbx4_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vqtbx1_s8(int8x8_t a, int8x16_t b, int8x8_t c) {
-  // CHECK: test_vqtbx1_s8
+  // CHECK-LABEL: test_vqtbx1_s8
   return vqtbx1_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vqtbx2_s8(int8x8_t a, int8x16x2_t b, int8x8_t c) {
-  // CHECK: test_vqtbx2_s8
+  // CHECK-LABEL: test_vqtbx2_s8
   return vqtbx2_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vqtbx3_s8(int8x8_t a, int8x16x3_t b, int8x8_t c) {
-  // CHECK: test_vqtbx3_s8
+  // CHECK-LABEL: test_vqtbx3_s8
   return vqtbx3_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x8_t test_vqtbx4_s8(int8x8_t a, int8x16x4_t b, int8x8_t c) {
-  // CHECK: test_vqtbx4_s8
+  // CHECK-LABEL: test_vqtbx4_s8
   return vqtbx4_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 int8x16_t test_vqtbx1q_s8(int8x16_t a, int8x16_t b, int8x16_t c) {
-  // CHECK: test_vqtbx1q_s8
+  // CHECK-LABEL: test_vqtbx1q_s8
   return vqtbx1q_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 int8x16_t test_vqtbx2q_s8(int8x16_t a, int8x16x2_t b, int8x16_t c) {
-  // CHECK: test_vqtbx2q_s8
+  // CHECK-LABEL: test_vqtbx2q_s8
   return vqtbx2q_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 int8x16_t test_vqtbx3q_s8(int8x16_t a, int8x16x3_t b, int8x16_t c) {
-  // CHECK: test_vqtbx3q_s8
+  // CHECK-LABEL: test_vqtbx3q_s8
   return vqtbx3q_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 int8x16_t test_vqtbx4q_s8(int8x16_t a, int8x16x4_t b, int8x16_t c) {
-  // CHECK: test_vqtbx4q_s8
+  // CHECK-LABEL: test_vqtbx4q_s8
   return vqtbx4q_s8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 uint8x8_t test_vtbl1_u8(uint8x8_t a, uint8x8_t b) {
-  // CHECK: test_vtbl1_u8
+  // CHECK-LABEL: test_vtbl1_u8
   return vtbl1_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vqtbl1_u8(uint8x16_t a, uint8x8_t b) {
-  // CHECK: test_vqtbl1_u8
+  // CHECK-LABEL: test_vqtbl1_u8
   return vqtbl1_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vtbl2_u8(uint8x8x2_t a, uint8x8_t b) {
-  // CHECK: test_vtbl2_u8
+  // CHECK-LABEL: test_vtbl2_u8
   return vtbl2_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vqtbl2_u8(uint8x16x2_t a, uint8x8_t b) {
-  // CHECK: test_vqtbl2_u8
+  // CHECK-LABEL: test_vqtbl2_u8
   return vqtbl2_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vtbl3_u8(uint8x8x3_t a, uint8x8_t b) {
-  // CHECK: test_vtbl3_u8
+  // CHECK-LABEL: test_vtbl3_u8
   return vtbl3_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vqtbl3_u8(uint8x16x3_t a, uint8x8_t b) {
-  // CHECK: test_vqtbl3_u8
+  // CHECK-LABEL: test_vqtbl3_u8
   return vqtbl3_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vtbl4_u8(uint8x8x4_t a, uint8x8_t b) {
-  // CHECK: test_vtbl4_u8
+  // CHECK-LABEL: test_vtbl4_u8
   return vtbl4_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vqtbl4_u8(uint8x16x4_t a, uint8x8_t b) {
-  // CHECK: test_vqtbl4_u8
+  // CHECK-LABEL: test_vqtbl4_u8
   return vqtbl4_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vqtbl1q_u8(uint8x16_t a, uint8x16_t b) {
-  // CHECK: test_vqtbl1q_u8
+  // CHECK-LABEL: test_vqtbl1q_u8
   return vqtbl1q_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 uint8x16_t test_vqtbl2q_u8(uint8x16x2_t a, uint8x16_t b) {
-  // CHECK: test_vqtbl2q_u8
+  // CHECK-LABEL: test_vqtbl2q_u8
   return vqtbl2q_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 uint8x16_t test_vqtbl3q_u8(uint8x16x3_t a, uint8x16_t b) {
-  // CHECK: test_vqtbl3q_u8
+  // CHECK-LABEL: test_vqtbl3q_u8
   return vqtbl3q_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 uint8x16_t test_vqtbl4q_u8(uint8x16x4_t a, uint8x16_t b) {
-  // CHECK: test_vqtbl4q_u8
+  // CHECK-LABEL: test_vqtbl4q_u8
   return vqtbl4q_u8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 uint8x8_t test_vtbx1_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) {
-  // CHECK: test_vtbx1_u8
+  // CHECK-LABEL: test_vtbx1_u8
   return vtbx1_u8(a, b, c);
   // CHECK: movi {{v[0-9]+}}.8b, #0
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
@@ -241,13 +241,13 @@ uint8x8_t test_vtbx1_u8(uint8x8_t a, uin
 }
 
 uint8x8_t test_vtbx2_u8(uint8x8_t a, uint8x8x2_t b, uint8x8_t c) {
-  // CHECK: test_vtbx2_u8
+  // CHECK-LABEL: test_vtbx2_u8
   return vtbx2_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vtbx3_u8(uint8x8_t a, uint8x8x3_t b, uint8x8_t c) {
-  // CHECK: test_vtbx3_u8
+  // CHECK-LABEL: test_vtbx3_u8
   return vtbx3_u8(a, b, c);
   // CHECK: movi {{v[0-9]+}}.8b, #0
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
@@ -257,133 +257,133 @@ uint8x8_t test_vtbx3_u8(uint8x8_t a, uin
 }
 
 uint8x8_t test_vtbx4_u8(uint8x8_t a, uint8x8x4_t b, uint8x8_t c) {
-  // CHECK: test_vtbx4_u8
+  // CHECK-LABEL: test_vtbx4_u8
   return vtbx4_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vqtbx1_u8(uint8x8_t a, uint8x16_t b, uint8x8_t c) {
-  // CHECK: test_vqtbx1_u8
+  // CHECK-LABEL: test_vqtbx1_u8
   return vqtbx1_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vqtbx2_u8(uint8x8_t a, uint8x16x2_t b, uint8x8_t c) {
-  // CHECK: test_vqtbx2_u8
+  // CHECK-LABEL: test_vqtbx2_u8
   return vqtbx2_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vqtbx3_u8(uint8x8_t a, uint8x16x3_t b, uint8x8_t c) {
-  // CHECK: test_vqtbx3_u8
+  // CHECK-LABEL: test_vqtbx3_u8
   return vqtbx3_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x8_t test_vqtbx4_u8(uint8x8_t a, uint8x16x4_t b, uint8x8_t c) {
-  // CHECK: test_vqtbx4_u8
+  // CHECK-LABEL: test_vqtbx4_u8
   return vqtbx4_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 uint8x16_t test_vqtbx1q_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) {
-  // CHECK: test_vqtbx1q_u8
+  // CHECK-LABEL: test_vqtbx1q_u8
   return vqtbx1q_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 uint8x16_t test_vqtbx2q_u8(uint8x16_t a, uint8x16x2_t b, uint8x16_t c) {
-  // CHECK: test_vqtbx2q_u8
+  // CHECK-LABEL: test_vqtbx2q_u8
   return vqtbx2q_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 uint8x16_t test_vqtbx3q_u8(uint8x16_t a, uint8x16x3_t b, uint8x16_t c) {
-  // CHECK: test_vqtbx3q_u8
+  // CHECK-LABEL: test_vqtbx3q_u8
   return vqtbx3q_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 uint8x16_t test_vqtbx4q_u8(uint8x16_t a, uint8x16x4_t b, uint8x16_t c) {
-  // CHECK: test_vqtbx4q_u8
+  // CHECK-LABEL: test_vqtbx4q_u8
   return vqtbx4q_u8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 poly8x8_t test_vtbl1_p8(poly8x8_t a, uint8x8_t b) {
-  // CHECK: test_vtbl1_p8
+  // CHECK-LABEL: test_vtbl1_p8
   return vtbl1_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vqtbl1_p8(poly8x16_t a, uint8x8_t b) {
-  // CHECK: test_vqtbl1_p8
+  // CHECK-LABEL: test_vqtbl1_p8
   return vqtbl1_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vtbl2_p8(poly8x8x2_t a, uint8x8_t b) {
-  // CHECK: test_vtbl2_p8
+  // CHECK-LABEL: test_vtbl2_p8
   return vtbl2_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vqtbl2_p8(poly8x16x2_t a, uint8x8_t b) {
-  // CHECK: test_vqtbl2_p8
+  // CHECK-LABEL: test_vqtbl2_p8
   return vqtbl2_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vtbl3_p8(poly8x8x3_t a, uint8x8_t b) {
-  // CHECK: test_vtbl3_p8
+  // CHECK-LABEL: test_vtbl3_p8
   return vtbl3_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vqtbl3_p8(poly8x16x3_t a, uint8x8_t b) {
-  // CHECK: test_vqtbl3_p8
+  // CHECK-LABEL: test_vqtbl3_p8
   return vqtbl3_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vtbl4_p8(poly8x8x4_t a, uint8x8_t b) {
-  // CHECK: test_vtbl4_p8
+  // CHECK-LABEL: test_vtbl4_p8
   return vtbl4_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vqtbl4_p8(poly8x16x4_t a, uint8x8_t b) {
-  // CHECK: test_vqtbl4_p8
+  // CHECK-LABEL: test_vqtbl4_p8
   return vqtbl4_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x16_t test_vqtbl1q_p8(poly8x16_t a, uint8x16_t b) {
-  // CHECK: test_vqtbl1q_p8
+  // CHECK-LABEL: test_vqtbl1q_p8
   return vqtbl1q_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 poly8x16_t test_vqtbl2q_p8(poly8x16x2_t a, uint8x16_t b) {
-  // CHECK: test_vqtbl2q_p8
+  // CHECK-LABEL: test_vqtbl2q_p8
   return vqtbl2q_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 poly8x16_t test_vqtbl3q_p8(poly8x16x3_t a, uint8x16_t b) {
-  // CHECK: test_vqtbl3q_p8
+  // CHECK-LABEL: test_vqtbl3q_p8
   return vqtbl3q_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 poly8x16_t test_vqtbl4q_p8(poly8x16x4_t a, uint8x16_t b) {
-  // CHECK: test_vqtbl4q_p8
+  // CHECK-LABEL: test_vqtbl4q_p8
   return vqtbl4q_p8(a, b);
   // CHECK: tbl {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 poly8x8_t test_vtbx1_p8(poly8x8_t a, poly8x8_t b, uint8x8_t c) {
-  // CHECK: test_vtbx1_p8
+  // CHECK-LABEL: test_vtbx1_p8
   return vtbx1_p8(a, b, c);
   // CHECK: movi {{v[0-9]+}}.8b, #0
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
@@ -393,13 +393,13 @@ poly8x8_t test_vtbx1_p8(poly8x8_t a, pol
 }
 
 poly8x8_t test_vtbx2_p8(poly8x8_t a, poly8x8x2_t b, uint8x8_t c) {
-  // CHECK: test_vtbx2_p8
+  // CHECK-LABEL: test_vtbx2_p8
   return vtbx2_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vtbx3_p8(poly8x8_t a, poly8x8x3_t b, uint8x8_t c) {
-  // CHECK: test_vtbx3_p8
+  // CHECK-LABEL: test_vtbx3_p8
   return vtbx3_p8(a, b, c);
   // CHECK: movi {{v[0-9]+}}.8b, #0
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
@@ -409,55 +409,55 @@ poly8x8_t test_vtbx3_p8(poly8x8_t a, pol
 }
 
 poly8x8_t test_vtbx4_p8(poly8x8_t a, poly8x8x4_t b, uint8x8_t c) {
-  // CHECK: test_vtbx4_p8
+  // CHECK-LABEL: test_vtbx4_p8
   return vtbx4_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vqtbx1_p8(poly8x8_t a, uint8x16_t b, uint8x8_t c) {
-  // CHECK: test_vqtbx1_p8
+  // CHECK-LABEL: test_vqtbx1_p8
   return vqtbx1_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vqtbx2_p8(poly8x8_t a, poly8x16x2_t b, uint8x8_t c) {
-  // CHECK: test_vqtbx2_p8
+  // CHECK-LABEL: test_vqtbx2_p8
   return vqtbx2_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vqtbx3_p8(poly8x8_t a, poly8x16x3_t b, uint8x8_t c) {
-  // CHECK: test_vqtbx3_p8
+  // CHECK-LABEL: test_vqtbx3_p8
   return vqtbx3_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x8_t test_vqtbx4_p8(poly8x8_t a, poly8x16x4_t b, uint8x8_t c) {
-  // CHECK: test_vqtbx4_p8
+  // CHECK-LABEL: test_vqtbx4_p8
   return vqtbx4_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.8b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.8b
 }
 
 poly8x16_t test_vqtbx1q_p8(poly8x16_t a, uint8x16_t b, uint8x16_t c) {
-  // CHECK: test_vqtbx1q_p8
+  // CHECK-LABEL: test_vqtbx1q_p8
   return vqtbx1q_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 poly8x16_t test_vqtbx2q_p8(poly8x16_t a, poly8x16x2_t b, uint8x16_t c) {
-  // CHECK: test_vqtbx2q_p8
+  // CHECK-LABEL: test_vqtbx2q_p8
   return vqtbx2q_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 poly8x16_t test_vqtbx3q_p8(poly8x16_t a, poly8x16x3_t b, uint8x16_t c) {
-  // CHECK: test_vqtbx3q_p8
+  // CHECK-LABEL: test_vqtbx3q_p8
   return vqtbx3q_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }
 
 poly8x16_t test_vqtbx4q_p8(poly8x16_t a, poly8x16x4_t b, uint8x16_t c) {
-  // CHECK: test_vqtbx4q_p8
+  // CHECK-LABEL: test_vqtbx4q_p8
   return vqtbx4q_p8(a, b, c);
   // CHECK: tbx {{v[0-9]+}}.16b, {{{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b}, {{v[0-9]+}}.16b
 }

Modified: cfe/trunk/test/CodeGen/aarch64-poly128.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-poly128.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-poly128.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-poly128.c Mon Mar  3 05:34:36 2014
@@ -12,34 +12,34 @@
 #include <arm_neon.h>
 
 void test_vstrq_p128(poly128_t * ptr, poly128_t val) {
-  // CHECK: test_vstrq_p128
+  // CHECK-LABEL: test_vstrq_p128
   vstrq_p128(ptr, val);
 	// CHECK: str	{{x[0-9]+}}, [{{x[0-9]+}}, #8]
 	// CHECK-NEXT: str	 {{x[0-9]+}}, [{{x[0-9]+}}]
 }
 
 poly128_t test_vldrq_p128(poly128_t * ptr) {
-  // CHECK: test_vldrq_p128
+  // CHECK-LABEL: test_vldrq_p128
   return vldrq_p128(ptr);
 	// CHECK: ldr	{{x[0-9]+}}, [{{x[0-9]+}}]
 	// CHECK-NEXT: ldr	{{x[0-9]+}}, [{{x[0-9]+}}, #8]
 }
 
 void test_ld_st_p128(poly128_t * ptr) {
-  // CHECK: test_ld_st_p128
+  // CHECK-LABEL: test_ld_st_p128
    vstrq_p128(ptr+1, vldrq_p128(ptr));
 	// CHECK: ldr {{q[0-9]+}}, [{{x[0-9]+}}]
 	// CHECK-NEXT: str	{{q[0-9]+}}, [{{x[0-9]+}}, #16]
 }
 
 poly128_t test_vmull_p64(poly64_t a, poly64_t b) {
-  // CHECK: test_vmull_p64
+  // CHECK-LABEL: test_vmull_p64
   return vmull_p64(a, b);
   // CHECK: pmull {{v[0-9]+}}.1q, {{v[0-9]+}}.1d, {{v[0-9]+}}.1d
 }
 
 poly128_t test_vmull_high_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vmull_high_p64
+  // CHECK-LABEL: test_vmull_high_p64
   return vmull_high_p64(a, b);
   // CHECK: pmull2 {{v[0-9]+}}.1q, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }

Modified: cfe/trunk/test/CodeGen/aarch64-poly64.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/aarch64-poly64.c?rev=202703&r1=202702&r2=202703&view=diff
==============================================================================
--- cfe/trunk/test/CodeGen/aarch64-poly64.c (original)
+++ cfe/trunk/test/CodeGen/aarch64-poly64.c Mon Mar  3 05:34:36 2014
@@ -7,276 +7,276 @@
 #include <arm_neon.h>
 
 uint64x1_t test_vceq_p64(poly64x1_t a, poly64x1_t b) {
-  // CHECK: test_vceq_p64
+  // CHECK-LABEL: test_vceq_p64
   return vceq_p64(a, b);
   // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64x2_t test_vceqq_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vceqq_p64
+  // CHECK-LABEL: test_vceqq_p64
   return vceqq_p64(a, b);
   // CHECK: cmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 uint64x1_t test_vtst_p64(poly64x1_t a, poly64x1_t b) {
-  // CHECK: test_vtst_p64
+  // CHECK-LABEL: test_vtst_p64
   return vtst_p64(a, b);
   // CHECK: cmtst {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 uint64x2_t test_vtstq_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vtstq_p64
+  // CHECK-LABEL: test_vtstq_p64
   return vtstq_p64(a, b);
   // CHECK: cmtst {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d
 }
 
 poly64x1_t test_vbsl_p64(poly64x1_t a, poly64x1_t b, poly64x1_t c) {
-  // CHECK: test_vbsl_p64
+  // CHECK-LABEL: test_vbsl_p64
   return vbsl_p64(a, b, c);
   // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b
 }
 
 poly64x2_t test_vbslq_p64(poly64x2_t a, poly64x2_t b, poly64x2_t c) {
-  // CHECK: test_vbslq_p64
+  // CHECK-LABEL: test_vbslq_p64
   return vbslq_p64(a, b, c);
   // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b
 }
 
 poly64_t test_vget_lane_p64(poly64x1_t v) {
-  // CHECK: test_vget_lane_p64
+  // CHECK-LABEL: test_vget_lane_p64
   return vget_lane_p64(v, 0);
   // CHECK: fmov  {{x[0-9]+}}, {{d[0-9]+}}
 }
 
 poly64_t test_vgetq_lane_p64(poly64x2_t v) {
-  // CHECK: test_vgetq_lane_p64
+  // CHECK-LABEL: test_vgetq_lane_p64
   return vgetq_lane_p64(v, 1);
   // CHECK: umov  {{x[0-9]+}}, {{v[0-9]+}}.d[1]
 }
 
 poly64x1_t test_vset_lane_p64(poly64_t a, poly64x1_t v) {
-  // CHECK: test_vset_lane_p64
+  // CHECK-LABEL: test_vset_lane_p64
   return vset_lane_p64(a, v, 0);
   // CHECK: fmov  {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 poly64x2_t test_vsetq_lane_p64(poly64_t a, poly64x2_t v) {
-  // CHECK: test_vsetq_lane_p64
+  // CHECK-LABEL: test_vsetq_lane_p64
   return vsetq_lane_p64(a, v, 1);
   // CHECK: ins  {{v[0-9]+}}.d[1], {{x[0-9]+}}
 }
 
 poly64x1_t test_vcopy_lane_p64(poly64x1_t a, poly64x1_t b) {
-  // CHECK: test_vcopy_lane_p64
+  // CHECK-LABEL: test_vcopy_lane_p64
   return vcopy_lane_p64(a, 0, b, 0);
   // CHECK: fmov  {{d[0-9]+}}, {{d[0-9]+}}
 }
 
 poly64x2_t test_vcopyq_lane_p64(poly64x2_t a, poly64x1_t b) {
-  // CHECK: test_vcopyq_lane_p64
+  // CHECK-LABEL: test_vcopyq_lane_p64
   return vcopyq_lane_p64(a, 1, b, 0);
   // CHECK: ins  {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 poly64x2_t test_vcopyq_laneq_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vcopyq_laneq_p64
+  // CHECK-LABEL: test_vcopyq_laneq_p64
   return vcopyq_laneq_p64(a, 1, b, 1);
   // CHECK: ins  {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[1]
 }
 
 poly64x1_t test_vcreate_p64(uint64_t a) {
-  // CHECK: test_vcreate_p64
+  // CHECK-LABEL: test_vcreate_p64
   return vcreate_p64(a);
   // CHECK: fmov  {{d[0-9]+}}, {{x[0-9]+}}
 }
 
 poly64x1_t test_vdup_n_p64(poly64_t a) {
-  // CHECK: test_vdup_n_p64
+  // CHECK-LABEL: test_vdup_n_p64
   return vdup_n_p64(a);
   // CHECK: fmov {{d[0-9]+}}, {{x[0-9]+}}
 }
 poly64x2_t test_vdupq_n_p64(poly64_t a) {
-  // CHECK: test_vdup_n_p64
+  // CHECK-LABEL: test_vdupq_n_p64
   return vdupq_n_p64(a);
   // CHECK: dup {{v[0-9]+}}.2d, {{x[0-9]+}}
 }
 
 poly64x1_t test_vdup_lane_p64(poly64x1_t vec) {
-  // CHECK: test_vdup_lane_p64
+  // CHECK-LABEL: test_vdup_lane_p64
   return vdup_lane_p64(vec, 0);
   // CHECK: ret
 }
 
 poly64x2_t test_vdupq_lane_p64(poly64x1_t vec) {
-  // CHECK: test_vdupq_lane_p64
+  // CHECK-LABEL: test_vdupq_lane_p64
   return vdupq_lane_p64(vec, 0);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 }
 
 poly64x2_t test_vdupq_laneq_p64(poly64x2_t vec) {
-  // CHECK: test_vdupq_laneq_p64
+  // CHECK-LABEL: test_vdupq_laneq_p64
   return vdupq_laneq_p64(vec, 1);
   // CHECK: dup {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
 }
 
 poly64x2_t test_vcombine_p64(poly64x1_t low, poly64x1_t high) {
-  // CHECK: test_vcombine_p64
+  // CHECK-LABEL: test_vcombine_p64
   return vcombine_p64(low, high);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 poly64x1_t test_vld1_p64(poly64_t const * ptr) {
-  // CHECK: test_vld1_p64
+  // CHECK-LABEL: test_vld1_p64
   return vld1_p64(ptr);
   // CHECK:  ld1 {{{v[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 poly64x2_t test_vld1q_p64(poly64_t const * ptr) {
-  // CHECK: test_vld1q_p64
+  // CHECK-LABEL: test_vld1q_p64
   return vld1q_p64(ptr);
   // CHECK:  ld1 {{{v[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1_p64(poly64_t * ptr, poly64x1_t val) {
-  // CHECK: test_vst1_p64
+  // CHECK-LABEL: test_vst1_p64
   return vst1_p64(ptr, val);
   // CHECK:  st1 {{{v[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst1q_p64(poly64_t * ptr, poly64x2_t val) {
-  // CHECK: test_vst1q_p64
+  // CHECK-LABEL: test_vst1q_p64
   return vst1q_p64(ptr, val);
   // CHECK:  st1 {{{v[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 poly64x1x2_t test_vld2_p64(poly64_t const * ptr) {
-  // CHECK: test_vld2_p64
+  // CHECK-LABEL: test_vld2_p64
   return vld2_p64(ptr);
   // CHECK: ld1 {{{v[0-9]+}}.1d, {{v[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 poly64x2x2_t test_vld2q_p64(poly64_t const * ptr) {
-  // CHECK: test_vld2q_p64
+  // CHECK-LABEL: test_vld2q_p64
   return vld2q_p64(ptr);
   // CHECK: ld2 {{{v[0-9]+}}.2d, {{v[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 poly64x1x3_t test_vld3_p64(poly64_t const * ptr) {
-  // CHECK: test_vld3_p64
+  // CHECK-LABEL: test_vld3_p64
   return vld3_p64(ptr);
   // CHECK: ld1 {{{v[0-9]+}}.1d, {{v[0-9]+}}.1d, {{v[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 poly64x2x3_t test_vld3q_p64(poly64_t const * ptr) {
-  // CHECK: test_vld3q_p64
+  // CHECK-LABEL: test_vld3q_p64
   return vld3q_p64(ptr);
   // CHECK: ld3 {{{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 poly64x1x4_t test_vld4_p64(poly64_t const * ptr) {
-  // CHECK: test_vld4_p64
+  // CHECK-LABEL: test_vld4_p64
   return vld4_p64(ptr);
   // CHECK: ld1 {{{v[0-9]+}}.1d, {{v[0-9]+}}.1d, {{v[0-9]+}}.1d, {{v[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 poly64x2x4_t test_vld4q_p64(poly64_t const * ptr) {
-  // CHECK: test_vld4q_p64
+  // CHECK-LABEL: test_vld4q_p64
   return vld4q_p64(ptr);
   // CHECK: ld4 {{{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2_p64(poly64_t * ptr, poly64x1x2_t val) {
-  // CHECK: test_vst2_p64
+  // CHECK-LABEL: test_vst2_p64
   return vst2_p64(ptr, val);
   // CHECK:  st1 {{{v[0-9]+}}.1d, {{v[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst2q_p64(poly64_t * ptr, poly64x2x2_t val) {
-  // CHECK: test_vst2q_p64
+  // CHECK-LABEL: test_vst2q_p64
   return vst2q_p64(ptr, val);
   // CHECK:  st2 {{{v[0-9]+}}.2d, {{v[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst3_p64(poly64_t * ptr, poly64x1x3_t val) {
-  // CHECK: test_vst3_p64
+  // CHECK-LABEL: test_vst3_p64
   return vst3_p64(ptr, val);
   // CHECK:  st1 {{{v[0-9]+}}.1d, {{v[0-9]+}}.1d, {{v[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst3q_p64(poly64_t * ptr, poly64x2x3_t val) {
-  // CHECK: test_vst3q_p64
+  // CHECK-LABEL: test_vst3q_p64
   return vst3q_p64(ptr, val);
   // CHECK:  st3 {{{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4_p64(poly64_t * ptr, poly64x1x4_t val) {
-  // CHECK: test_vst4_p64
+  // CHECK-LABEL: test_vst4_p64
   return vst4_p64(ptr, val);
   // CHECK:  st1 {{{v[0-9]+}}.1d, {{v[0-9]+}}.1d, {{v[0-9]+}}.1d, {{v[0-9]+}}.1d}, [{{x[0-9]+|sp}}]
 }
 
 void test_vst4q_p64(poly64_t * ptr, poly64x2x4_t val) {
-  // CHECK: test_vst4q_p64
+  // CHECK-LABEL: test_vst4q_p64
   return vst4q_p64(ptr, val);
   // CHECK:  st4 {{{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d}, [{{x[0-9]+|sp}}]
 }
 
 poly64x1_t test_vext_p64(poly64x1_t a, poly64x1_t b) {
-  // CHECK: test_vext_p64
+  // CHECK-LABEL: test_vext_p64
   return vext_u64(a, b, 0);
 
 }
 
 poly64x2_t test_vextq_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vextq_p64
+  // CHECK-LABEL: test_vextq_p64
   return vextq_p64(a, b, 1);
   // CHECK: ext {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #0x8
 }
 
 poly64x2_t test_vzip1q_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vzip1q_p64
+  // CHECK-LABEL: test_vzip1q_p64
   return vzip1q_p64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 poly64x2_t test_vzip2q_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vzip2q_p64
+  // CHECK-LABEL: test_vzip2q_p64
   return vzip2q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 poly64x2_t test_vuzp1q_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vuzp1q_p64
+  // CHECK-LABEL: test_vuzp1q_p64
   return vuzp1q_p64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 poly64x2_t test_vuzp2q_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vuzp2q_p64
+  // CHECK-LABEL: test_vuzp2q_p64
   return vuzp2q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 poly64x2_t test_vtrn1q_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vtrn1q_p64
+  // CHECK-LABEL: test_vtrn1q_p64
   return vtrn1q_p64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[1], {{v[0-9]+}}.d[0]
 }
 
 poly64x2_t test_vtrn2q_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vtrn2q_p64
+  // CHECK-LABEL: test_vtrn2q_p64
   return vtrn2q_u64(a, b);
   // CHECK: ins {{v[0-9]+}}.d[0], {{v[0-9]+}}.d[1]
 }
 
 poly64x1_t test_vsri_n_p64(poly64x1_t a, poly64x1_t b) {
-  // CHECK: test_vsri_n_p64
+  // CHECK-LABEL: test_vsri_n_p64
   return vsri_n_p64(a, b, 33);
   // CHECK: sri {{d[0-9]+}}, {{d[0-9]+}}, #33
 }
 
 poly64x2_t test_vsriq_n_p64(poly64x2_t a, poly64x2_t b) {
-  // CHECK: test_vsriq_n_p64
+  // CHECK-LABEL: test_vsriq_n_p64
   return vsriq_n_p64(a, b, 64);
   // CHECK: sri {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #64
 }





More information about the cfe-commits mailing list