【ARMv8 SIMD和浮点指令编程】NEON 减法指令——减法也好几种

向量减法包括常见的普通加指令，还包括长减、宽减、半减、饱和减、按对减、按对加并累加、选择高半部分结果加、全部元素加等。

1 SUB

减法（向量），该指令从第一个源 SIMD&FP 寄存器中的相应向量元素中减去第二个源 SIMD&FP 寄存器中的每个向量元素，将结果放入一个向量中，并将该向量写入目标 SIMD&FP 寄存器。

标量

SUB <V><d>, <V><n>, <V><m>

向量

SUB <Vd>.<T>, <Vn>.<T>, <Vm>.<T>

<V> 是宽度说明符，以“size”编码：

size	<V>
0x	RESERVED
10	RESERVED
11	D

<d> 是 SIMD&FP 目标寄存器的编号，在“Rd”字段中。

<n> 是第一个 SIMD&FP 源寄存器的编号，编码在“Rn”字段中。

<m> 是第二个 SIMD&FP 源寄存器的编号，编码在“Rm”字段中。

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<T> 是排列说明符，编码为“size:Q”：

size	Q	<T>
00	0	8B
00	1	16B
01	0	4H
01	1	8H
10	0	2S
10	1	4S
11	0	RESERVED
11	1	2D

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 SUB 指令的例子。

    auto *srcArr = new int[4];

    for (int i = 0; i < 4; i++) {
    
    
        srcArr[i] = 100 * (i + 1);
    }

    char *src = (char *) srcArr;
    LOGD("in srcArr: %d %d %d %d", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);

    asm volatile(
        "LD1 {v0.4S}, [%[src]]\n"
        "SUB v1.4S, v0.4S, v0.4S\n"
        "ST1 {v1.4S}, [%[src]]\n"
    :[src] "+r"(src)
    :
    : "cc", "memory", "v0");

    LOGD("-----------------------------");
    LOGD("out srcArr: %d %d %d %d", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);

    delete[] srcArr;

SUB v1.4S, v0.4S, v0.4S 将 v0 寄存器 S 通道的值减去 v0 寄存器 S 通道的值的结果写入 v1 的 S 通道，不难知道最终结果均为 0。

运行结果：

2023-05-25 07:42:14.624 13572-13639/com.demo.myapplication D/NativeCore: in srcArr: 100 200 300 400
2023-05-25 07:42:14.624 13572-13639/com.demo.myapplication D/NativeCore: -----------------------------
2023-05-25 07:42:14.624 13572-13639/com.demo.myapplication D/NativeCore: out srcArr: 0 0 0 0

2 SUBHN/SUBHN2

减法返回高窄，该指令从第一个源 SIMD&FP 寄存器中的相应向量元素中减去第二个源 SIMD&FP 寄存器中的每个向量元素，将结果的最高有效一半放入向量中，并将该向量写入目标 SIMD&FP 寄存器的下半部分或上半部分。 该指令中的所有值都是有符号整数值。

结果被截断。有关四舍五入的结果，请使用 RSUBHN。

SUBHN 指令将向量写入目标寄存器的下半部分并清除上半部分，而 SUBHN2 指令将向量写入目标寄存器的上半部分而不影响寄存器的其他位。

SUBHN{2} <Vd>.<Tb>, <Vn>.<Ta>, <Vm>.<Ta>

2 是第二个和上半部分说明符。如果存在，它会导致对保存较窄元素的寄存器的高 64 位执行操作，并以“Q”编码：

Q	2
0	[absent]
1	[present]

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，以“size”编码：

size	<Ta>
00	8H
01	4S
10	2D
11	RESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

<Tb> 是排列说明符，编码为“size:Q”：

size	Q	<T>
00	0	8B
00	1	16B
01	0	4H
01	1	8H
10	0	2S
10	1	4S
11	x	RESERVED

下面是使用 SUBHN/SUBHN2 指令的例子。

    auto *srcArr = new unsigned long long int[4];
    auto *outArr = new unsigned int[4]{
    
    0};

    for (int i = 0; i < 4; i++) {
    
    
        srcArr[i] = 0x10010000000 * (i + 1);
    }

    char *src = (char *) srcArr;
    char *dst = (char *) outArr;
    LOGD("in srcArr: 0x%llx 0x%llx 0x%llx 0x%llx", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);
    LOGD("in outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);

    asm volatile(
        "LD1 {v0.2D, v1.2D}, [%[src]]\n"
        "SUBHN v2.2S, v1.2D, v0.2D\n"
        "SUBHN2 v2.4S, v0.2D, v1.2D\n"
        "ST1 {v2.4S}, [%[dst]]\n"
    :[src] "+r"(src),
    [dst] "+r"(dst)
    :
    : "cc", "memory", "v0", "v1", "v2");

    LOGD("-----------------------------");
    LOGD("out outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);

    delete[] srcArr;
    delete[] outArr;

SUBHN v2.2S, v1.2D, v0.2D 将 v1 的两个 D 通道的值减去 v0 的两个 D 通道的值，接着取结果的高位（也就是 D 通道的高 S 通道部分）写入 v2 的两个低 S 通道，v2 寄存器高 S 通道全部清零。

SUBHN2 v2.4S, v0.2D, v1.2D 将 v0 的两个 D 通道的值减去 v1 的两个 D 通道的值，接着取结果的高位（也就是 D 通道的高 S 通道部分）写入 v2 的两个高 S 通道，并保持 v2 其它位不变。

0x10010000000 - 0x30030000000 = 0x20020000000 - 0x40040000000 = 0xFFFF FDFF E000 0000，截断的方式取高位即 0xFFFF FDFF。

运行结果：

2023-05-25 07:52:36.500 16479-16551/com.demo.myapplication D/NativeCore: in srcArr: 0x10010000000 0x20020000000 0x30030000000 0x40040000000
2023-05-25 07:52:36.500 16479-16551/com.demo.myapplication D/NativeCore: in outArr: 0x0 0x0 0x0 0x0
2023-05-25 07:52:36.500 16479-16551/com.demo.myapplication D/NativeCore: -----------------------------
2023-05-25 07:52:36.500 16479-16551/com.demo.myapplication D/NativeCore: out outArr: 0x200 0x200 0xfffffdff 0xfffffdff

3 USUBL/USUBL2

无符号长减，该指令从第一个源 SIMD&FP 寄存器的相应向量元素中减去第二个源 SIMD&FP 寄存器的下半部分或上半部分中的每个向量元素，将结果放入一个向量，并将该向量写入目标 SIMD&FP 寄存器。该指令中的所有值都是无符号整数值。目标向量元素的长度是源向量元素的两倍。

USUBL 指令从每个源寄存器的下半部分提取每个源向量。USUBL2 指令从每个源寄存器的上半部分提取每个源向量。

USUBL{2} <Vd>.<Ta>, <Vn>.<Tb>, <Vm>.<Tb>

2 是第二个和上半部分说明符。如果存在，它会导致对保存较窄元素的寄存器的高 64 位执行操作，并以“Q”编码：

Q	2
0	[absent]
1	[present]

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，以“size”编码：

size	<Ta>
00	8H
01	4S
10	2D
11	RESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Tb> 是排列说明符，编码为“size:Q”：

size	Q	<T>
00	0	8B
00	1	16B
01	0	4H
01	1	8H
10	0	2S
10	1	4S
11	x	RESERVED

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 USUBL/USUBL2 指令的例子。

    auto *srcArr = new unsigned int[8];
    auto *outArr = new unsigned long long int[4]{
    
    0};

    for (int i = 0; i < 8; i++) {
    
    
        srcArr[i] = 100 * (i + 1);
    }

    char *src = (char *) srcArr;
    char *dst = (char *) outArr;
    LOGD("in srcArr: %u %u %u %u %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3],
         srcArr[4], srcArr[5], srcArr[6], srcArr[7]);

    asm volatile(
        "LD1 {v0.4S, v1.4S}, [%[src]]\n"
        "USUBL v2.2D, v1.2S, v0.2S\n"
        "USUBL2 v3.2D, v1.4S, v0.4S\n"
    "ST1 {v2.2D, v3.2D}, [%[dst]]\n"
    :[src] "+r"(src),
    [dst] "+r"(dst)
    :
    : "cc", "memory", "v0", "v1", "v2", "v3");

    LOGD("-----------------------------");
    LOGD("out outArr: %llu %llu %llu %llu", outArr[0], outArr[1], outArr[2], outArr[3]);

    delete[] srcArr;
    delete[] outArr;

USUBL v2.2D, v1.2S, v0.2S 将 v1 寄存器低半部分两个 S 通道的值减去 v0 寄存器低半部分两个 S 通道的值，并将结果写入 v2 寄存器的两个 D 通道。

USUBL2 v3.2D, v1.4S, v0.4S 将 v1 寄存器高半部分两个 S 通道的值减去 v0 寄存器高半部分两个 S 通道的值，并将结果写入 v3 寄存器的两个 D 通道。

运行结果：

2023-05-26 07:56:51.966 28776-28866/com.demo.myapplication D/NativeCore: in srcArr: 100 200 300 400 500 600 700 800
2023-05-26 07:56:51.967 28776-28866/com.demo.myapplication D/NativeCore: -----------------------------
2023-05-26 07:56:51.967 28776-28866/com.demo.myapplication D/NativeCore: out outArr: 400 400 400 400

4 USUBW/USUBW2

无符号宽减，该指令从第一个源 SIMD&FP 寄存器的下半部分或上半部分中的相应向量元素中减去第二个源 SIMD&FP 寄存器的每个向量元素，将结果放入一个向量中，并将该向量写入 SIMD&FP 目标寄存器。该指令中的所有值都是无符号整数值。目标寄存器和第一个源寄存器的向量元素是第二个源寄存器的向量元素的两倍长。

USUBW 指令从第一个源寄存器的下半部分提取向量元素。USUBW2 指令从第一个源寄存器的上半部分提取向量元素。

USUBW{2} <Vd>.<Ta>, <Vn>.<Ta>, <Vm>.<Tb>

2 是第二个和上半部分说明符。如果存在，它会导致对保存较窄元素的寄存器的高 64 位执行操作，并以“Q”编码：

Q	2
0	[absent]
1	[present]

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，以“size”编码：

size	<Ta>
00	8H
01	4S
10	2D
11	RESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

<Tb> 是排列说明符，编码为“size:Q”：

size	Q	<T>
00	0	8B
00	1	16B
01	0	4H
01	1	8H
10	0	2S
10	1	4S
11	x	RESERVED

下面是使用 USUBW/USUBW2 指令的例子。

    auto *srcArr = new unsigned int[4];
    auto *outArr = new unsigned long long int[4]{
    
    0};

    for (int i = 0; i < 4; i++) {
    
    
        srcArr[i] = 100 * (i + 1);
        outArr[i] = 1000 * (i + 1);
    }

    char *src = (char *) srcArr;
    char *dst = (char *) outArr;
    LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);
    LOGD("in outArr: %llu %llu %llu %llu", outArr[0], outArr[1], outArr[2], outArr[3]);

    asm volatile(
        "LD1 {v0.4S}, [%[src]]\n"
        "LD1 {v1.2D, v2.2D}, [%[dst]]\n"
        "USUBW v3.2D, v1.2D, v0.2S\n"
        "USUBW2 v4.2D, v2.2D, v0.4S\n"
        "ST1 {v3.2D, v4.2D}, [%[dst]]\n"
    :[src] "+r"(src),
    [dst] "+r"(dst)
    :
    : "cc", "memory", "v0", "v1", "v2", "v3", "v4");

    LOGD("-----------------------------");
    LOGD("out outArr: %llu %llu %llu %llu", outArr[0], outArr[1], outArr[2], outArr[3]);

    delete[] srcArr;
    delete[] outArr;

USUBW v3.2D, v1.2D, v0.2S 将 v1 寄存器的两个 D 通道的值减去 v0 寄存器低半部分两个 S 通道的值 ，并将结果写入 v3 寄存器的两个 D 通道。

USUBW2 v4.2D, v2.2D, v0.4S 将 v2 寄存器的两个 D 通道的值减去 v0 寄存器高半部分两个 S 通道的值，并将结果写入 v4 寄存器的两个 D 通道。

运行结果：

2023-05-26 08:06:59.172 31685-31752/com.demo.myapplication D/NativeCore: in srcArr: 100 200 300 400
2023-05-26 08:06:59.172 31685-31752/com.demo.myapplication D/NativeCore: in outArr: 1000 2000 3000 4000
2023-05-26 08:06:59.172 31685-31752/com.demo.myapplication D/NativeCore: -----------------------------
2023-05-26 08:06:59.172 31685-31752/com.demo.myapplication D/NativeCore: out outArr: 900 1800 2700 3600

5 UQSUB

无符号饱和减法，该指令从第一个源 SIMD&FP 寄存器的相应元素值中减去第二个源 SIMD&FP 寄存器的元素值，将结果放入向量中，并将向量写入目标 SIMD&FP 寄存器。如果任何结果发生溢出，这些结果就会饱和。如果发生饱和，则设置累积饱和位 FPSR.QC。

标量

UQSUB <V><d>, <V><n>, <V><m>

向量

UQSUB <Vd>.<T>, <Vn>.<T>, <Vm>.<T>

<V> 是宽度说明符，以“size”编码：

size	<V>
00	B
01	H
10	S
11	D

<d> 是 SIMD&FP 目标寄存器的编号，在“Rd”字段中。

<n> 是第一个 SIMD&FP 源寄存器的编号，编码在“Rn”字段中。

<m> 是第二个 SIMD&FP 源寄存器的编号，编码在“Rm”字段中。

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<T> 是排列说明符，编码为“size:Q”：

size	Q	<T>
00	0	8B
00	1	16B
01	0	4H
01	1	8H
10	0	2S
10	1	4S
11	0	RESERVED
11	1	2D

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 UQSUB 指令的例子。

    auto *srcArr = new unsigned int[4];
    auto *outArr = new unsigned int[4];
    long long fpsrBefore = 0, fpsrAfter = 0;

    for (int i = 0; i < 4; i++) {
    
    
        srcArr[i] = 0xFFFFFFFF;
        outArr[i] = i;
    }

    char *src = (char *) srcArr;
    char *dst = (char *) outArr;
    LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);
    LOGD("in outArr: %u %u %u %u", outArr[0], outArr[1], outArr[2], outArr[3]);

    asm volatile(
        "LD1 {v0.4S}, [%[src]]\n"
        "LD1 {v1.4S}, [%[dst]]\n"
        "MRS %[fpsrBefore], FPSR\n"
        "UQSUB v2.4S, v1.4S, v0.4S\n"
        "MRS %[fpsrAfter], FPSR\n"
        "ST1 {v2.4S}, [%[dst]]\n"
    :[src] "+r"(src),
     [dst] "+r"(dst),
     [fpsrBefore] "+r"(fpsrBefore),
     [fpsrAfter] "+r"(fpsrAfter)
    :
    : "cc", "memory", "v0", "v1", "v2");

    LOGD("-----------------------------");
    LOGD("out outArr: %u %u %u %u", outArr[0], outArr[1], outArr[2], outArr[3]);
    LOGD("out fpsrBefore: 0x%llx fpsrAfter: 0x%llx", fpsrBefore, fpsrAfter);

    delete[] srcArr;
    delete[] outArr;

UQSUB v2.4S, v1.4S, v0.4S 将 v1 寄存器的 S 通道的值减去 v0 寄存器 S 通道的值，由于 v1 减去 v0 不够减，可以看到 FPSR.QC（fpsrAfter 内，即运行 UQSUB 指令后的 FPSR 寄存器值的副本）已经被置为 1（从低到高第 27 位（低位从 0 开始））。

运行结果：

2023-05-26 08:45:39.794 17458-17538/com.demo.myapplication D/NativeCore: in srcArr: 4294967295 4294967295 4294967295 4294967295
2023-05-26 08:45:39.794 17458-17538/com.demo.myapplication D/NativeCore: in outArr: 0 1 2 3
2023-05-26 08:45:39.794 17458-17538/com.demo.myapplication D/NativeCore: -----------------------------
2023-05-26 08:45:39.794 17458-17538/com.demo.myapplication D/NativeCore: out outArr: 0 0 0 0
2023-05-26 08:45:39.794 17458-17538/com.demo.myapplication D/NativeCore: out fpsrBefore: 0x10 fpsrAfter: 0x8000010

6 UHSUB

无符号半减，该指令从第一个源 SIMD&FP 寄存器中的相应向量元素中减去第二个源 SIMD&FP 寄存器中的向量元素，将每个结果右移一位，将每个结果放入向量中，并将向量写入目标 SIMD&FP 寄存器。

UHSUB <Vd>.<T>, <Vn>.<T>, <Vm>.<T>

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<T> 是排列说明符，编码在“size:Q”字段中。它可以具有以下值：

size	Q	<T>
00	0	8B
00	1	16B
01	0	4H
01	1	8H
10	0	2S
10	1	4S
11	x	RESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 UHSUB 指令的例子。

    auto *srcArr = new unsigned int[4];
    auto *outArr = new unsigned int[4];

    for (int i = 0; i < 4; i++) {
    
    
        srcArr[i] = 0x01020304 * (i + 1);
        outArr[i] = 0x10203040 * (i + 1);
    }

    char *src = (char *) srcArr;
    char *dst = (char *) outArr;
    LOGD("in srcArr: 0x%x 0x%x 0x%x 0x%x", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);
    LOGD("in outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);

    asm volatile(
        "LD1 {v0.4S}, [%[src]]\n"
        "LD1 {v1.4S}, [%[dst]]\n"
        "UHSUB v2.4S, v1.4S, v0.4S\n"
        "ST1 {v2.4S}, [%[dst]]\n"
    :[src] "+r"(src),
     [dst] "+r"(dst)
    :
    : "cc", "memory", "v0", "v1", "v2");

    LOGD("-----------------------------");
    LOGD("out outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);

    delete[] srcArr;
    delete[] outArr;

我们计算一组数值：0x10203040 - 0x1020304 = 0xF1E2D3C = 0b1111 00011110 00101101 00111100，右移一位后即 0b0111 10001111 00010110 10011110 = 0x78F169E。

运行结果：

2023-05-27 17:45:40.672 26560-26560/com.example.myapplication D/native-armv8a: in srcArr: 0x1020304 0x2040608 0x306090c 0x4080c10
2023-05-27 17:45:40.672 26560-26560/com.example.myapplication D/native-armv8a: in outArr: 0x10203040 0x20406080 0x306090c0 0x4080c100
2023-05-27 17:45:40.672 26560-26560/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-27 17:45:40.672 26560-26560/com.example.myapplication D/native-armv8a: out outArr: 0x78f169e 0xf1e2d3c 0x16ad43da 0x1e3c5a78

7 RSUBHN/RSUBHN2

四舍五入减法返回高窄。该指令从第一个源 SIMD&FP 寄存器的相应向量元素中减去第二个源 SIMD&FP 寄存器的每个向量元素，将结果的最高有效一半放入向量，并将向量写入目标 SIMD&FP 寄存器的下半部分或上半部分。结果四舍五入。有关截断结果，请使用 SUBHN、SUBHN2。

RSUBHN 指令将向量写入目标寄存器的下半部分并清除上半部分，而 RSUBHN2 指令将向量写入目标寄存器的上半部分而不影响寄存器的其他位。

RSUBHN{2} <Vd>.<Tb>, <Vn>.<Ta>, <Vm>.<Ta>

2 是第二个和上半部分说明符。如果存在，它会导致对保存较窄元素的寄存器的高 64 位执行操作，并以“Q”编码：

Q	2
0	[absent]
1	[present]

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，以“size”编码：

size	<Ta>
00	8H
01	4S
10	2D
11	RESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

<Tb> 是排列说明符，编码为“size:Q”：

size	Q	<T>
00	0	8B
00	1	16B
01	0	4H
01	1	8H
10	0	2S
10	1	4S
11	x	RESERVED

下面是使用 RSUBHN/RSUBHN2 指令的例子。

    auto *srcArr = new unsigned long long int[4];
    auto *outArr = new unsigned int[4]{
    
    0};

    for (int i = 0; i < 4; i++) {
    
    
        srcArr[i] = 0x10010000000 * (i + 1);
    }

    char *src = (char *) srcArr;
    char *dst = (char *) outArr;
    LOGD("in srcArr: 0x%llx 0x%llx 0x%llx 0x%llx", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);
    LOGD("in outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);

    asm volatile(
        "LD1 {v0.2D, v1.2D}, [%[src]]\n"
        "RSUBHN v2.2S, v1.2D, v0.2D\n"
        "RSUBHN2 v2.4S, v0.2D, v1.2D\n"
        "ST1 {v2.4S}, [%[dst]]\n"
    :[src] "+r"(src),
    [dst] "+r"(dst)
    :
    : "cc", "memory", "v0", "v1", "v2");

    LOGD("-----------------------------");
    LOGD("out outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);

    delete[] srcArr;
    delete[] outArr;

RSUBHN v2.2S, v1.2D, v0.2D 将 v1 的两个 D 通道的值减去 v0 的两个 D 通道的值，接着四舍五入取结果的高位（也就是 D 通道的高 S 通道部分）写入 v2 的两个低 S 通道，v2 寄存器高 S 通道全部清零。

RSUBHN2 v2.4S, v0.2D, v1.2D 将 v0 的两个 D 通道的值减去 v1 的两个 D 通道的值，接着四舍五入取结果的高位（也就是 D 通道的高 S 通道部分）写入 v2 的两个高 S 通道，并保持 v2 其它位不变。

0x10010000000 - 0x30030000000 = 0x20020000000 - 0x40040000000 = 0xFFFF FDFF E000 0000，四舍五入的方式取高位即 0xFFFF FE00。

运行结果：

2023-05-28 07:25:14.779 21437-21437/com.example.myapplication D/native-armv8a: in srcArr: 0x10010000000 0x20020000000 0x30030000000 0x40040000000
2023-05-28 07:25:14.779 21437-21437/com.example.myapplication D/native-armv8a: in outArr: 0x0 0x0 0x0 0x0
2023-05-28 07:25:14.779 21437-21437/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-28 07:25:14.779 21437-21437/com.example.myapplication D/native-armv8a: out outArr: 0x200 0x200 0xfffffe00 0xfffffe00

8 其他

SHSUB —— 有符号半减

SQSUB —— 有符号饱和减法

SSUBL/SSUBL2 —— 有符号长减

SSUBW/SSUBW2 —— 有符号宽减

参考资料

1.《ARMv8-A-Programmer-Guide》
2.《Arm® A64 Instruction Set Architecture Armv8, for Armv8-A architecture profile》