Kito's Lab

icecream / icecc: 分散式編譯系統簡介

2016-02-20T21:32:00.000+08:00

簡介

Icecream 是由 SUSE 基於 distcc 所開發出來的, icecream 與 distcc 要處理的問題類似, 都是想要將編譯工作分散到不同機器上平行處理, 但與 distcc 的不同在於 icecream 採用的是中央集權的主從式架構, 透過中央的 scheduler server 來動態分配編譯工作, 並且會優先分配到速度較快閒置機器進行編譯, 並且最重要的是對於 Cross Compilation, 與 distcc 相比 icecream有較佳的支援.

安裝

基本上應該透過系統內建的套件系統都可以安裝成功, 非不得已的話再自己編譯吧, 以下列幾個常見系統的安裝方法:

Debian/Ubuntu

$ sudo apt-get install icecream

Fedora

$ sudo dnf install icecream

CentOS

$ sudo yum install icecream

icecream scheduler server 設定

scheduler server 打起來後基本上什麼都不用設定, 整個網路環境中只要有一個 scheduler 即可, 打起來後會定期發送廣播封包告訴大家這邊有一個便宜好用的 icecream scheduler 快來連它!

如何啟動

Ubuntu/CentOS

service icecc-scheduler start

Fedora

systemctl start icecc-scheduler.service

icecream node 設定

Configure file 位置

Ubuntu

/etc/icecc/icecc.conf

Fedora/CentOS

/etc/sysconfig/icecream

Configure file 內容

ICECREAM_NETNAME : 這台機器的名稱, 預設值會去抓本機的 hostname

ICECREAM_SCHEDULER_HOST : 指定要使用哪個 Scheduler server, 不設定的話 iceccd 會自己去找區網上的其中一個, 在一般情況底下留白讓 iceccd 自行搜索即可

ICECREAM_ALLOW_REMOTE : 是否允許其他機器利用本機端來編譯, 預設值通常是 yes

ICECREAM_MAX_JOBS : 這台機器最多負載的編譯工作數目, 預設值會根據該機器上的處理器數量來決定

如何啟動

Ubuntu/CentOS

$ service iceccd start

Fedora

$ systemctl start iceccd

icecc 使用

基本使用

icecc 跟 distcc 或 ccache 使用方法相當類似, 都是透過 icecc 再呼叫 gcc/clang 的方式運作, 例如 ln -s /usr/bin/icecc gcc, 但通常 package system 裝來的會順便幫忙建立 symbol link, 例如 Fedora 22 放在 /usr/libexec/icecc/bin/gcc 以及 /usr/libexec/icecc/bin/g++, Ubuntu 14.04 則放在 /usr/lib/icecc/bin/gcc 以及 /usr/lib/icecc/bin/g++.

基本上最方便的使用方式就是將 icecc 的 wrapper 放到 path 裡面即可, 或著是手動指定 CC= CXX=

例如:

/usr/libexec/icecc/bin/gcc foo.c -c

或著是

export PATH=/usr/libexec/icecc/bin/:$PATH

gcc foo.c -c

都可以透過 icecc 來進行編譯

當然初期使用的時候會有點疑惑, 真的有使用到 icecc 來達到分散式編譯嗎? 這邊提供一個基本的測試方法, 就是設定 ICECC_DEBUG 這個環境變數, 讓 icecc 吐出一些 debug 訊息看一下運作情況如何:

$ ICECC_DEBUG=1 gcc hello.c -c

ICECC[27118] 17:17:34: connected to /var/run/icecc/iceccd.socket

ICECC[27118] 17:17:34: native /var/cache/icecream/native/3686f16c4bdce474f4c0445c4b27e08e.tar.gz

ICECC[27118] 17:17:34: env: x86_64 '/var/cache/icecream/native/3686f16c4bdce474f4c0445c4b27e08e.tar.gz'

ICECC[27118] 17:17:34: hello.c compiled 1 times on x86_64

ICECC[27118] 17:17:34: Have to use host 192.168.1.3:10245 - Job ID: 4361 - env: x86_64 - has env: true - match j: 0

ICECC[27118] 17:17:35: connected to 192.168.1.3

ICECC[27118] 17:17:35: <send compile_file>

ICECC[27118] 17:17:35: </send compile_file: 0ms>

ICECC[27118] 17:17:35: <write_server_cpp from cpp>

ICECC[27118] 17:17:35: sent 4963 bytes (29%)

ICECC[27118] 17:17:35: </write_server_cpp from cpp: 9ms>

ICECC[27118] 17:17:35: <wait for cpp>

ICECC[27118] 17:17:35: </wait for cpp: 0ms>

ICECC[27118] 17:17:35: <wait for cs>

ICECC[27118] 17:17:35: </wait for cs: 202ms>

ICECC[27118] 17:17:35: got 623 bytes (41%)

Cross Compilation

Cross compilation 部份請留意 icecream 版本新舊的問題, 版本在 1.x 以後這部份功能較為堪用, 試過 CentOS 6 上 0.9.x 版本的會遇見許多靈異現象, 所以請確定所有 icecream node 版本至少都是 1.x, 當然最好的情況是所有 node 上的環境都一樣是最理想的.

透過 icecc 來使用 cross compilation 最困難的一關就是剛開始建立 wrapper, 沒有辦法像使用 native/host gcc 一樣直接 ln -s /usr/bin/icecc gcc 就開工了, 必須透過較複雜的方式建立 wrapper 來以利後續使用, 而接下來的段落將會介紹如何製作 wrapper.

進階 icecc wrapper 製作

雖然 icecc 可以直接將編譯工作丟到其他台機器上編譯, 但若其他機器環境中的 gcc 與 binutils 版本不盡相同的話將會相當棘手, 會造成 A 檔案丟到 X 機器編譯與在本地編譯的結果不一樣, 而理論上 A 檔案不論在本機端或著是任何一台遠端機器上編譯的結果都要一模一樣才行, 否則將會造成編譯的不穩定性.

而解決這問題最直覺的方式便是將本地端的 Compiler 包含 Assembler 傳送到遠端的機器, icecream 在這邊則處理的更細緻, 除了 Compiler 以及 Assembler 外其所有相依的 Shared Library 也都會傳送到遠端, 避免 Library 版本不同進而造成 Compiler 本身行為不同(最常見的例子是 C Library 中的 qsort 可能在不同 libc 中實做不一樣, 造成排序結果相異).

Icecream 提供了一個小工具 icecc-create-env 來打包上述所提到的東西, 並且在運作 icecc 時透過設定 ICECC_VERSION 環境變數來指定使用的環境是哪一包, 接下來就來介紹 icecc-create-env 如何使用以及所造出來的那包環境如何使用, 並且使用 aarch64 的 linaro toolchain 作為範例來展示結合 icecc 編譯.

icecc-create-env

icecc-create-env 共有兩種模式 gcc 以及 clang 模式, 主要是針對目前主流的兩大 Open Source compiler 作不同的支援,

使用方式

/usr/bin/icecc-create-env --gcc

或著

/usr/bin/icecc-create-env --clang

範例輸出:

$ icecc-create-env --gcc bin/aarch64-linux-gnu-gcc bin/aarch64-linux-gnu-g++

adding file /bin/true

adding file /lib64/libc.so.6

adding file /lib64/ld-linux-x86-64.so.2

adding file /usr/bin/gcc=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/aarch64-linux-gnu-gcc

adding file /lib64/libm.so.6

adding file /usr/bin/g++=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/aarch64-linux-gnu-g++

adding file /usr/bin/cc1=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/../libexec/gcc/aarch64-linux-gnu/5.1.1/cc1

adding file /lib64/libdl.so.2

adding file /usr/bin/cc1plus=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/../libexec/gcc/aarch64-linux-gnu/5.1.1/cc1plus

adding file /usr/bin/as=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/../lib/gcc/aarch64-linux-gnu/5.1.1/../../../../aarch64-linux-gnu/bin/as

adding file /lib64/libz.so.1

adding file /usr/libexec/gcc/aarch64-linux-gnu/5.1.1/liblto_plugin.so=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/../libexec/gcc/aarch64-linux-gnu/5.1.1/liblto_plugin.so

adding file /etc/ld.so.conf=/tmp/icecc_ld_so_confJFqMdV

cp: omitting directory ‘/lib’

cp: omitting directory ‘/lib64’

creating 5a1f48aacc455db5ff0d0104a827651c.tar.gz

可以透過輸出大致看出其運作過程, 其中最後一行就是整個打包完的壓縮檔 5a1f48aacc455db5ff0d0104a827651c.tar.gz, 預設檔名是所有檔案的 md5 hash 出來的, 不過其實檔名不重要, 可以改名成人比較看得懂的檔名沒關係, 例如 aarch64-linux-gnu.icecc.tar.gz

ICECC_VERSION

透過 icecc-create-env 設定好後, 開一個文字檔, 內容如下:

# /usr/bin/bash

export ICECC_VERSION=/home/kito/arm-toolchain/aarch64-linux-gnu/aarch64-linux-gnu.icecc.tar.gz

export ICECC_CC=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/aarch64-linux-gnu-gcc

export ICECC_CXX=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/aarch64-linux-gnu-g++

icecc aarch64-linux-gnu-gcc "$@"

然後將檔名存成 aarch64-linux-gnu-gcc, 然後如法炮製作個 aarch64-linux-gnu-g++

# /usr/bin/bash

export ICECC_VERSION=/home/kito/arm-toolchain/aarch64-linux-gnu/aarch64-linux-gnu.icecc.tar.gz

export ICECC_CC=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/aarch64-linux-gnu-gcc

export ICECC_CXX=/home/kito/arm-toolchain/aarch64-linux-gnu/bin/aarch64-linux-gnu-g++

icecc aarch64-linux-gnu-g++ "$@"

然後記得開執行權限

$ chmod +x aarch64-linux-gnu-gcc aarch64-linux-gnu-g++

接著這兩個 wrapper 就能跟 native/host 的 icecc wrapper 一樣好用了!

icecream 運作原理

大致上的運作流程如下

gcc foo.c -c

其中 gcc 是個 icecc wrapper

將 foo.c 進 Pre-processor 處理掉 marco

將上一步的結果丟給本機的 iceccd

iceccd 聯絡 icecc-scheduler 問一下誰很閒

iceccd 將Pre-process 過的 source code 傳送過去

遠端的 iceccd 將收進來的 source code 進行編譯

將上一步所產出的 .o 檔傳回本機

icecream 使用限制

icecream 受限於架構限制會有一些使用上的限制, 主要是遇到某些編譯選項時會無法分散編譯工作出去:

沒有 -S 或 -c : 這代表編譯器順便也要完成鍊結的工作, 但 icecream 的架構鍊結只能在本地端完成

有下 -B 參數 : -B 參數是個少見的參數但在某些 Open source project 會使用到, 這個將會影響到 gcc/clang 的搜索路徑, 甚至可能不使用編譯器預設的 cc1/cc1plus, 因此保險起見 icecream 看到此參數會將編譯工作留在本地端

多個 input file : 沒啥原因, 單純就 icecc 沒支援

其它會造成編譯器在編譯過程中產生額外檔案的行為都會在 local 端執行, 例如 dump 編譯器內部相關 debug 資訊.

icecream 編譯農場建設指南

良好的區網, 基本配備是 100Mb 有 1Gb 則是最好, 不然會加速不成又把網路癱瘓

整體環境相似最好一樣, 例如 Linux kernel 版本及 Distribution 一樣,

Note 1: 測試環境有試過 Ubuntu 14.04, Fedora 22, Gentoo, CentOS 6 混在一起還是可以運作的不錯.

Note 2: 環境混搭的話請一定要設定 ICECC_VERSION, 否則容易遇到 GCC 版本不同問題, 造成不同 node 間 input 一樣但 output 的 object file 不一樣甚至是不相容的東西就 GG 了

官網上說可以跨系統, 例如 OSX 與 Linux, 但手邊都 Linux 沒環境測試, 可以參考官方文件設定試試看

效能觀察工具 - icemon

Ubuntu:

sudo apt-get install icemon

Fedora/CentOS:

Package system 沒提供, 需要自行編譯

實驗數據 : 透過 icecream 編譯 LLVM

實驗環境

硬體環境

CPU : E3-1230 v3 @ 3.30GHz (4 core with HT = 8 logic core)

RAM : 32GB

Network : 1 Gigabit Ethernet

軟體環境

OS : Fedora 22 / Gentoo

ICECC version : 1.0.90

GCC : 4.9.3

ICECREAM 組態

ICECREAM_MAX_JOBS=12

實驗目標

LLVM Version: r26441

編譯 LLVM Debug build

Configure as : -DCMAKE_BUILD_TYPE=Debug -DLLVM_OPTIMIZED_TABLEGEN=ON

time make -j48

編譯 LLVM Release build

Configure as : -DCMAKE_BUILD_TYPE=Release

time make -j12

Icecream build:

-DCMAKE_C_COMPILER=/usr/libexec/icecc/bin/gcc

-DCMAKE_CXX_COMPILER=/usr/libexec/icecc/bin/g++

GCC build:

-DCMAKE_C_COMPILER=/usr/bin/gcc

-DCMAKE_CXX_COMPILER=/usr/bin/g++

實驗數據

LLVM Build Type	icecc	gcc	Speed up	Total file size for build folder
Release	2m57.275s	10m34.657s	3.6x	919M
Debug	5m10.249s	12m2.120s	2.3x	12G

LLVM Build Type	icecc	gcc	Speed up	Totoal file size for build folder
Release	2m57.275s	10m34.657s	5.4x	919M
Debug	5m10.249s	12m2.120s	2.3x	12G

在實驗數據中可以觀察到 icecc 在有充足的機器資源下可以加速相當多, 與理想值四倍相差不遠.

但有趣的是在 Debug build 的時候 icecc 版本明顯比 Release 版本慢了接近一倍, 與普通情況相反, 通常 Release build 編譯器要進行最佳化應該會較 Debug build 慢上許多, 其中原因可以合理推測是因為 Debug build 出來的 object file 肥大許多, 可以看到上列表格中 build 的資料夾大小差了近 12 倍, 因此檔案傳輸時間也將整體效能往下拖了不少.

結語

整體而言 icecc 是相當好用的分散式編譯工作, 個人使用經驗上來說比 distcc 來說還好用, 尤其是工作環境上需要使用不同編譯器以及機器上沒有完全一致的環境以及同步的檔案系統的時候.

Reference

[1] Icecream : https://github.com/icecc/icecream

[2] Icemon : https://github.com/icecc/icemon

Target Triple

2015-08-08T18:35:00.002+08:00

剛好前鎮子有討論到 Target Triple 是啥鬼東西, 就順便整理一下,

在使用 Cross Compiler 的時候常常 gcc 前面會有一串名字,

例如 arm-none-linux-gnueabi-gcc 中的 arm-none-linux-gnueabi,

這東西其實真要說還真的沒啥正式的規則,

"通常"規則是 <target>[<endian>][-<vender>]-<os>[-<extra-info>]

然後這規則是自行歸納而來的並非啥正式規則

vendor 部份只是常見是可以塞 vendor 而已, 但沒有一定塞 vendor 的資訊
extra-info 部份大部份是在拿來描述用的 ABI 或著是 library 相關資訊

下面開使用一堆例子來用這規則來解讀
先以常見 x86 的平台為例子：
Fedora 22 上的 gcc (下 -v 可以看到)
Target: x86_64-redhat-linux
<target>-<vendor>-<os> 的形式

Ubuntu 14.04/i686 gcc
Target: i686-pc-linux-gnu
也是<target>-<vendor>-<os> 的形式

Android Toolchain:
Target: arm-linux-androideabi
<target>-<os>-<extra-info>
androideabi : 雖然 Android 本身是 Linux 但其 ABI 細節跟一般 linux 不太一樣

Linaro ELF toolchain:
Target: arm-none-eabi
<target>-<vender>-<extra-info>
vender = none
extra-info = eabi

Linaro Linux toolchain:
Target: arm-linux-gnueabihf
<target><endian>-<os>-<extra-info>
extra-info:
gnu: 沒啥特別意義
eabi: EABI
hf : Hard float, 預設有 FPU

Linaro big-endian Linux toolchain:
Target: armeb-linux-gnueabihf
<target><endian>-<vender>-<extra-info>
endian = be = big-endian

Buildroot 2015-02
Target: arm-buildroot-linux-uclibcgnueabi
<target>-<vender>-<os>-<extra-info>
extra-info:
uclibc 用 uclibc (通常預設是 glibc, uclibc 有些細節與 glibc 不同)
gnu : 無意義
eabi : 採用 EABI

NDS32 Toolchain:
Target: nds32le-elf
<target><endian>-<os>
Andes 家的，應該淺顯易懂不用解釋

由以上眾多 pattern 大概可以歸納出一些事情：
vender 那欄可以看上面的例子這部份完全可以亂填
os 那來可填可不填，不填"通常"代表 Non-OS (Bare-metal)

然後這鬼東西其實沒啥正式的規則
每個 target 可以按照自己開心的方式去處理
詳細部份可以參考 <gcc-src>/gcc/config.gcc _[1]裡面有各種神秘規則

Reference

[1] https://github.com/gcc-mirror/gcc/blob/master/gcc/config.gcc

GCC 5 Releas Note

2015-04-23T02:23:00.001+08:00

以下是 GCC 5 更新的部份, 主要整理自官方 Release 頁面, 但由於個人能力有限, target 相關僅翻譯 x86, arm, aarch64 以及 nds32, 語言相關方面則只翻譯 C/C++ 還有 Go 的部份：

提醒！

C 語言的預設模式將從 -std=gnu89 轉換為 -std=gnu11 (譯註1)
Graphite framework 不再使用 CLooG，而改用 ISL 0.14 或 0.12.2 版，詳情請參閱公開安裝說明。
未來的版本將會移除非標準的 type traits ： has_trivial_default_constructor，has_trivial_copy_constructor 以及 has_trivial_copy_assign，現階段不推薦使用，建議改成標準提供的 is_trivially_default_constructible, is_trivially_copy_constructible 以及 is_trivially_copy_assignable。

譯註1：如果手上的 code 升級後編不過的話可以加個 -std=gnu89，不過建議方式是去看 GCC 抱怨啥，然後去修正程式碼。

一般性的最佳化改善

連結時期最佳化(Link-time optimization LTO)的改善:

加入新的最佳化： Identical Code Folding (ICF，使用 -fipa-icf 開啟)，跟 gold linker 的 Identical Code Folding 相比這玩意兒不需要開啟 Function Section，ICF 會在 inlining 前執行，並且會跨函數分析來達到程式碼重用 (Code Re-use)，但某方面而言一些 gold 可以作 ICF 的函數， GCC 不一定可以作，主要是 GCC 必須考量正確的別名資訊(honor aliasing information)。在開啟 LTO 的情況下 Firefox 大約可以合併約 31000 個函數，佔整體的 14% (譯註2)。
Devirtualization 最佳化改善了 speculative devirtualization 以及動態型別偵測，在 FireFox 中在 LTO 階段大約 50% 的虛擬函數呼叫可以被 speculative devirtualization。
新的 comdat 在地化(localization) 最佳化讓 linker 可以消除更多的 Dead Code，尤其是 C++ 的那些 Inline function。
透過 Virtual tables (譯註3) 的最佳化，減少 Dynamic Linking 的時間。
新增 -fno-semantic-interposition 的選項，可以透過禁止 Export Symbol 被外部的 Shared Library 蓋掉 (interposition) 來進一步最佳化程式(譯註4)。
Write-only 的變數現在會自動偵測並且可以被最佳化掉(譯註5)。
Profile Feedback 的 Function Inliner 現在也可被 --param inline-insns-auto 以及 --param inline-insns-single 這兩個參數限制行為了。
IPA Reference 分析速度大幅提昇，使得 -fipa-reference 可以同時跟 -fprofile-generate 一起使用變得可能了，這也解決了 Chromium 用 LTO 建置的瓶頸。
Symbol Table 跟 Call-Graph 的 API 用 C++ 重寫並且大幅簡化！
跨函數常數傳遞 (Interprocedural Constants Propagation) 現在也會順便傳遞指標的 Alignment 資訊，如果有此資訊的話，迴圈自動向量化的最佳化可以少產生處理 Misalignments 的程式。

譯註2：相關數據可參考 Mailing list 上的討論，大致上可以省 2% 左右的 Code size，跟 gold 的 ICF 一起用的話約可省 6.8%。

譯註3：拿來放 Virtual function 的表

譯註4：保證呼叫的函數如果本地端有定義的話，一定會採用本地的，效果類似 Linker 的 -Bsymbolic，不同的地方在於這可以讓 GCC 有在分析時有更多的資訊。

譯註5：例如有一個程式如下

static int foo;

void bar(){
  foo = 20;
}

在 GCC 5 中會產生，不做任何事就直接 return：

bar:
 rep ret

但在 GCC 5 前，則會很老實的把 20 放到 foo 去：

bar:
 movl $20, foo(%rip)
 ret

連結時期最佳化(Link-time optimization LTO)的改善:

實做 One Definition Rule based 的 C++ 型別合併機制，型別合併可以大幅改善 devirtualization 以及別名分析(alias analysis)的效果，輸出 ODR 的額外資訊大約會需要額外的 2-6% 的記憶體空間以及 Object File 小幅增加，可由 -flto-odr-type-merging 這個選項控制要不要用。
命令列最佳化選項以及平台相依選項現在會根據每個函數輸出，這項改變將使得在 LTO 可以允許 Translation Units 間使用不同得最佳化選項 (例如 -ffast-math, -mavx 或 -finline 等)，相對於之前版本的 GCC ，在 Link 階段給的命令列最佳化選項以及平台相依選項都會直接被忽略掉。要特別注意的是這項規則只適用於那些最佳化以及平台相依的屬性，一些影響整體 Code Gen 的選項例如 -fPIC，警告類的選項，會影響靜態變數的最佳化(例如 -fcommon)，除錯資訊輸出或著是 --param 的參數，將會影響整個 LTO 最佳化，而不是適用於部份 Translation Units，這類選項建議在編譯以及鍊結時期都採用一致的選項。
GCC bootstrap 現在預設產生用 Slim LTO 的 Object File
記憶體使用以及鍊結時間大幅改善：Tree Merge 的速度提昇，以及改善 GIMPLE 層的記憶體使用量，並且支援 on-demand 的串流化。

回饋導向最佳化(Feedback directed optimization) 的改善:

新的 auto-FDO 模式將可以使用較低成本的 Profiling 工具 (perf)，來取代傳統又慢又貴的侵入式的 Profiling 方式 (-fprofile-generate)，在 x86-64 上 SPEC2006 用新的 auto-FDO 可改善約 4.7%，比傳統的 FDO 方式多改善了約 7.3%。
改善 C++ 的 Inline 以及 Extern Inline 函數的 Profile 的精準度，。
增加新的 gcov-tool ，可用來操作 Profile 輸出(譯註6)。
Profile 現在更能容忍原始碼的小幅度更動(可透過 --param profile-func-internal-id 來控制)。

譯註6：主要是可以合併不同次輸出的 Profile

暫存器分配 (Register allocation) 的改善:

新增一個 Control-flow sensitive 的全域暫存器重現化 (Rematerialization) 的最佳化到 LRA 中，可由 -flra-remat 控制開關，LRA 會在有利可圖的情況下嘗試去重新計算該值，而不是直接 Spill 跟 Restore，這個最佳化在 SPEC2000 上，ARM 可改善約 1%，x86-64 則改善約 0.5%。
重用 PIC 暫存器，而不是將該暫存器鎖死不用，目前實做在 x86/x86-64 平台上，這將改善 PIC 程式的效能，共享程式庫(Shared Library) 的程式可大幅改善，目前只有 x86/x86-64 有開啟，不過此項基礎設施已經內建在暫存器分配器裡面，未來其它平台也可使用。
新的簡易跨函數暫存器分配，當暫存器分配器知道呼叫的函數不會使用到 Caller-saved 暫存器時，將不會產生 Save/Restore 的指令在函數呼叫前後，可由 -fipa-ra 選項控制開關。
LRA 現在在有利可圖的情況下更有效的利用向量暫存器 (Vector Register) 來暫存 (Spill) 一般暫存器的值，而不是直接暫存到記憶體中，這在現代的 Intel 處理器中大部份是會賺的。

UndefinedBehaviorSanitizer 新增選項:

-fsanitize=float-divide-by-zero: 偵測浮點數除以零的情況。
-fsanitize=float-cast-overflow: 偵測浮點數轉到整數有無溢位 (Overflow)。
-fsanitize=bounds: 偵測所有的陣列存取有無越界存取。
-fsanitize=alignment: 偵測 Alignment 資訊，檢查有無 Misalignment 的物件。
-fsanitize=object-size: 物件大小的檢查，檢查有無越界存取。
-fsanitize=vptr: 檢查所有的 C++ 函數呼叫，成員變數存取以及父子間轉型的時候型別是否正確。

指標邊界檢查器 (Pointer Bounds Checker):

新的越界指標檢查器，可透過 -fcheck-pointer-bounds 開啟，透過執行時期的檢查來偵測是否越界，目前只在有 Intel MPX 指令集的 x86/x86-64 GNU/Linux 平台上可以用，詳情請參閱 Wiki 頁面。

新語言以及語言相關的改善:

OpenMP 4.0 規格中的 offloading 功能目前支援 C, C++, and Fortran:

基礎建設 (適合任何 Vendor)
OpenMP 4.0 Example 所提供的 Offloading 的皆有包含在測試裡面。

針對未來的 Intel Xeon Phi 系列產品：

執行時期函數庫 (Run-time library)
模擬器 (Emulator)

C 家族

-fdiagnostics-color= 的預設值現在可以在建置 GCC 的時候可透過 --with-diagnostics-color= 設定，可用的值為 never, always, auto 以及 auto-if-env，新的預設值 auto 只有在輸出是 stderr 以及 stderr 是終端機輸出的情況下會上色。 GCC 4.9 的預設值是 auto-if-env，在 GCC_COLORS 這個環境變數非空字串的時候等價於 auto 模式，GCC 4.9 在 GCC_COLORS 這個環境變數沒設定的情況下將會預設關閉彩色輸出。
加入新選項 -Wswitch-bool：若 switch 內的值是布林值的話 GCC 就會抱怨。(譯註7)
加入新選項 -Wlogical-not-parentheses：當左邊的運算元 (left hand side operand) 旁邊有 Logical Not 而且沒有用括號包起來的話就會噴警告。(譯註8)
加入新選項 -Wsizeof-array-argument：當把 sizeof 運算子用在宣告為陣列的參數時，就會噴警告。(譯註9)
加入新選項 -Wbool-compare：當布林表示式 (Boolean Expressions) 拿去跟非 True/False 的整數值比較時會噴警告。(譯註10)
完整的 Cilk Plus 支援， Cilk Plus 是 C/C++ 資料/任務平行化的語言擴充。
新的屬性 (attribute) no_reorder 來避免 GCC 重排選定符號的順序，例如特定的符號 (Symbol) 或內嵌組合語言 (inline assembler)，這可以讓 Linux kernel 在開 LTO 時避免因開啟 -fno-toplevel-reorder 而關掉許多最佳化。
新的前置處理器指令 __has_include 以及 __has_include_next ，可以測試是否該標頭檔 (Header File) 是否可用。例如我們要測試
這個標頭檔是否可用：
```
#ifdef __has_include
#  if __has_include(<optional>)
#    include <optional>
#    define have_optional 1
#  elif __has_include(<experimental/optional>)
#    include <experimental/optional>
#    define have_optional 1
#    define experimental_optional
#  else
#    define have_optional 0
#  endif
#endif
```
其中 __has_include 以及 __has_include_next 的搜索路徑等價於 #include 以及 #include_next 的搜索路徑規則。
新的內建巨集 (Macro) __has_attribute 可以用來判斷是否支援某個屬性 (Attribute)，等價於 C++ 中的 __has_cpp_attribute，但 __has_attribute 適用於所有 C 語言家族的語言。
```
int
#ifdef __has_attribute
#  if __has_attribute(__noinline__)
  __attribute__((__noinline__))
#  endif
#endif
foo(int x);
```
如果該屬性存在的話，會回傳一個非零的值，標準的 C++ 屬性則會回傳一個日期，其它則會回傳 1，__has_attribute 以及 __has_cpp_attribute 都會試著在前後加上雙底線去解析看看，C++11 及其後代中的屬性將可能會有作用域 (Scoped) 。
新增一組新的內建函數 __builtin_add_overflow, __builtin_sub_overflow 以及 __builtin_mul_overflow，可用來檢查是否運算結果是否溢位，並且與 Clang 相容。這組內建函數會吃兩個整數 (兩個不需要同型別) ，然後會被延展成無限精確度的有號 +，- 或著 *，並且將期結果存回最後一個的參數，如果存進去的值與無限精準度運算的結果相等的話就會回傳 False (代表沒有溢位)，否則回傳 True (代表發生溢位)，最後一個參數的型別也可跟前兩個參數的型別不一樣，下面這個例子將展示 calloc 中用 __builtin_mul_overflow 來計算其大小：
```
void *
calloc (size_t x, size_t y)
{
  size_t sz;
  if (__builtin_mul_overflow (x, y, &sz))
    return NULL;
  void *ret = malloc (sz);
  if (ret) memset (res, 0, sz);
  return ret;
}
```
在 i?86 或 x86-64 以上會被展開成一個乘法指令以及一個 jo (Jump On Overflow) 的指令
-fextended-identifiers 預設在 C++ 以及 C99 之後開啟，已修正許多 Extended Identifiers 的問題。(譯註11)

譯註7: -Wswitch-bool 的範例： $ cat switch.cpp

int foo (bool v){
  switch (v) {
    case true:
      return 10;
    case false:
      return 20;
  }
}

$ gcc switch.cpp

switch.cpp: In function 'int foo(bool)':
switch.cpp:2:12: warning: switch condition has type bool [-Wswitch-bool]
   switch (v) {
            ^

譯註8: -Wlogical-not-parentheses 的範例：

$ cat lnp.cpp
int lnp(int a)
{
  return !a > 0;
}

$ gcc lnp.cpp -Wlogical-not-parentheses -c

lnp.cpp: In function 'int lnp(int)':
lnp.cpp:3:13: warning: logical not is only applied to the left hand side of comparison [-Wlogical-not-parentheses]
   return !a > 0;
             ^

譯註9: -Wsizeof-array-argument 的範例： $ cat sz-of-array.c

int foo(int a[])
{
  return (int) sizeof (a);
}

$ gcc sz-of-array.c -c

sz-of-array.c: In function 'foo':
sz-of-array.c:3:23: warning: 'sizeof' on array function parameter 'a' will return size of 'int *' [-Wsizeof-array-argument]
   return (int) sizeof (a);
                       ^
sz-of-array.c:1:13: note: declared here
 int foo(int a[])
             ^

譯註10: -Wbool-compare 的範例： $ cat bool-cmp.cpp

bool bool_cmp(int a, int b)
{
  return (a > b) != 2;
}

$ g++ bool-cmp.cpp -c -Wall

bool-cmp.cpp: In function 'bool bool_cmp(int, int)':
bool-cmp.cpp:3:18: warning: comparison of constant '2' with boolean expression is always true [-Wbool-compare]
   return (a > b) != 2;
                  ^

值得注意的是如果如果值是 1 的話就不會發出警告： $ cat bool-cmp.cpp

bool bool_cmp(int a, int b)
{
  return (a > b) != 1;
}

$ g++ bool-cmp.cpp -c -Wall

譯註11: 以為是可以用中文當變數名稱了嗎，不，目前 GCC 的支援情況絕對比想像中破爛： FAQ#utf8_identifiers

C

預設模式改為 -std=gnu11
加入新選項 -Wc90-c99-compat ，當你使用到 C99 有但 C90 沒有的功能的時候會噴出警告。
加入新選項 -Wc99-c11-compat ，當你使用到 C11 有但 C99 沒有的功能的時候會噴出警告。
加入新選項 -Wno-incompatible-pointer-types ，此選項可關閉不同型別的指標間互轉的警告
加入新選項 -Wno-int-conversion ，此選項可關閉整數與指標間互轉的警告。
加入新選項 -Wno-discarded-qualifiers ，此選項可關閉不同 qualifiers 間互轉的警告 (譯註12)。
加入新選項 -Wno-discarded-array-qualifiers ，此選項可關閉多維陣列間有無 const 轉換的警告。
現在 C 語言前端產生更精確更可讀的診斷訊息。
在 LTO 模式下，-pg 選項僅影響有下該選項編譯的檔案。

譯註12: 例如將 const int * 轉到 int *

C++

G++ 現在支援 C++14 的 variable template。
-Wnon-virtual-dtor 不會對標上 final 的 class 抱怨了。
過深的 template 具現化現在列為錯誤，避免過多的診斷訊息，通常這類訊息對找出問題沒有幫助。
G++ 以及 libstdc++ 目前實做了在 C++ 標準中建議的功能測試巨集 (Feature-testing Macro)。

G++ 現在允許 typename 當作 template 的參數了

template<template<typename> typename X> struct D; // OK

G++ 現在支援 C++ 針對非靜態資料成員 (Non-static Data Member) Aggregates 式的初始化。
```
struct A { int i, j = i; };
A a = { 42 }; // a.j is also 42
```

G++ 現在支援 C++14 的 extended constexpr。

constexpr int f (int i)
{
  int j = 0;
  for (; i > 0; --i)
    ++j;
  return j;
}

constexpr int i = f(42); // i is 42

G++ 現在支援 C++14 的 sized deallocation 函數。

void operator delete (void *, std::size_t) noexcept;
void operator delete[] (void *, std::size_t) noexcept;

新增對於違反 One Definition Rule 的警告提示，在 LTO 的時候會偵測是否有不批配的型別定義以及 Virtual Table，可由 -Wodr 控制開關。
新增新的警告提示 -Wsuggest-final-types 以及 -Wsuggest-final-methods，可用來提示開發者要在哪邊加 final 以增進程式效率，可以用在編譯時期使用，但在 LTO 下會更有用。
G++ 不再之支援 N3639 的可變長度陣列，那玩意兒已經從 C++14 中移除，但 GNU 的 VLA 一樣有支援，所以要用的話記得用 -std=gnu++14， -std=gnu++11 或 -std=gnu++98 模式。
G++ 支援在 C 的可變長度參數中傳遞 Non-Trivially-Copyable 的類別，不過要切記這在標準中是實做相依 (Implementation-Defined) 的，Calling Convention 方面比照一般參數方式。

Runtime Library (libstdc++)

預設使用新的 std::string 實做，使用短字串最佳化，捨棄 copy-on-write 的參考計數 (Reference Counting) 機制。
預設使用新的 std::list 實做，size() 的時間複雜度變為 O(1) 。
完整的 C++11 支援，包含以下新功能： - std::deque 以及 std::vector 符合 allocator-aware container 的要求了。 - iostream 類別現在可移動 (movable) 以及可交換 (swappable) 了。 - 支援 std::align 以及 std::aligned_union。 - 支援 type traits ： std::is_trivially_copyable, std::is_trivially_constructible 及 std::is_trivially_assignable 等等。 - 支援 I/O 操作子 (I/O manipulator)：std::put_time, std::get_time, std::hexfloat 和 std::defaultfloat。 - 區域設定感知能力 (Generic Locale-aware) 的 std::isblank。 - Unicode 轉換支援 locale facets。 - std::shared_ptr 一律採用 Atomic Operation。 - std::notify_all_at_thread_exit() 以及其它 future 的相關函數實做完成。
支援 C++11 在 ios_base::fixed|ios_base::scientific 已經設定的情況下 hexfloat 操作子 (manipulator) 的行為。這項改變影響所有的模式例如 C++98，要避免顯示十六進位的浮點數的話可透過 str.unsetf(std::ios_base::floatfield) 來清除相關的 str.flags()。
完整的 C++14 實驗性支援，包含以下功能：
- std::is_final type trait。
- heterogeneous comparison lookup in associative containers.
- 新增全域函數 cbegin, cend, rbegin, rend, crbegin, 以及 crend 來方便存取容器，陣列或著是初始化列表。
改善一些實驗性的函數庫包含：
- class std::experimental::any;
- function template std::experimental::apply;
- function template std::experimental::sample;
- function template std::experimental::search and related searcher types;
- variable templates for type traits;
- function template std::experimental::not_fn.
新的亂數產生器：logistic_distribution 以及 uniform_on_sphere_distribution。
新增容器以及 std::unique_ptr 的 GDB Xmethods

Go

GCC 5 完整實做 Go 1.4.2了。
建置 GCC 5 時如果開啟 Go 支援的話會多安裝兩個程式：go 跟 gofmt。

libgccjit

GCC 5 可以把整個 GCC 建置成一個共享程式庫讓開發者可以將 GCC 嵌入至其它的程式中 (例如直譯器)，可以拿來 Just-In-Time 的編譯成機械碼。

目前共享程式庫提供 C 的 API 並且有提供包裝過後的 C++ API，另外也有第三方支援 Python 及 D 的 binding。

舉例來說這項新功能可以讓直譯器編譯一個函數從 Byetcode 變成機械碼。

另外也可以來來當作 Ahead-Of-Time 編譯技術的一部分，讓 GCC 可以跟其它現有的語言前端組合起來，例如官方的 Wiki 頁面提供一個 brainfuck 的範例。

libgccjit 目前採用 GPLv3 (或著任何後繼版本)。

目前這部份屬於實驗性質的玩意兒。

新的 Target 以及 Target 相關改善：

AArch64

針對 Cortex-A57 處理器的 Code Gen 大幅改善，可使用 -mcpu=cortex-a57 或 -mtune=cortex-a57 來啟用相關最佳化，有更精準的指令排程 (Instruction Scheduling)，以及許多內部編譯器的參數調整調整。
針對 Cortex-A53 erratum 835769 的 Workaround 可用 -mfix-cortex-a53-835769 來啟動，另外在建置 GCC 的時候也可下 --enable-fix-cortex-a53-835769 來預設開啟此 Workaround。
當使用 -mcpu=cortex-a53, -mcpu=cortex-a57 or -mcpu=cortex-a57.cortex-a53 時，加密指令集不再預設開啟，要啟用的話就要在 -mcpu 或 -march 後面在加個 +crypto ，例如 -mcpu=cortex-a53+crypto。
支援 Cortex-A72 及其與 Cortex-A53 的 big.LITTLE 組合 (cortex-a72.cortex-a53)，以及 Cavium ThunderX (thunderx), Applied Micro X-Gene 1 (xgene1), 還有 Samsung Exynos M1 (exynos-m1)，可透過 -mcpu=cortex-a72，-mcpu=cortex-a72.cortex-a53，-mcpu=thunderx，-mcpu=xgene1 以及 -mcpu=exynos-m1 來開啟相關支援。
移除過渡期選項 -mlra 以及 -mno-lra ，AArch64 現在使用 Local Register Allocator (LRA)。

ARM

Thumb-1 的組合語言現在使用 Unified Syntax，並且加入一個新選項 -masm-syntax-unified ，來指定 Inline Assembly 是使用 Unified Syntax，預設這個選項是關閉的，不過未來將會改變這項預設值。
當在組態時 (Configure-Time) 指定了 --with-cpu 又指定 --with-tune 或 --with-arch。
針對 Cortex-A57 處理器的 Code Gen 大幅改善，可使用 -mcpu=cortex-a57 或 -mtune=cortex-a57 來啟用相關最佳化，有更精準的指令排程 (Instruction Scheduling)，以及許多內部編譯器的參數調整調整。
支援 Cortex-A72 及其與 Cortex-A53 的 big.LITTLE 組合 (cortex-a72.cortex-a53)，以及 Cavium ThunderX (thunderx), Applied Micro X-Gene 1 (xgene1), 還有 Samsung Exynos M1 (exynos-m1)，可透過 -mcpu=cortex-a72，-mcpu=cortex-a72.cortex-a53，-mcpu=thunderx，-mcpu=xgene1 以及 -mcpu=exynos-m1 來開啟相關支援。
移除 -mwords-little-endian 選項。
-mapcs, -mapcs-frame, -mtpcs-frame 以及 -mtpcs-leaf-frame 這幾個適用於 OABI 的選項，將不建議使用 (Deprecated)。
移除過渡期選項 -mlra 以及 -mno-lra ，ARM 現在使用 Local Register Allocator (LRA)。

IA-32/x86-64

支援 Intel 處理器 Skylake 的新指令集 AVX-512{BW,DQ,VL,IFMA,VBMI} ，包含 Inline Assembly，以及 Intrinsics 還有基礎的自動向量化支援，可透過 -mavx512vl， -mavx512bw， -mavx512dq， -mavx512ifma 以及 -mavx512vbmi 來開啟.
支援新的 MPX 指令集，可透過 -mmpx 開啟，這套指令集需要編譯器，執行時期函數庫以及 OS 的支援，透過執行時期的指標邊界檢查可有效增強軟體的可靠度，在 GCC 中透過 Pointer Checker 以及 libmpx 來支援其功能。
加入新選項 -mrecord-mcount 來針對 -pg 選項來產生 Linux Kernel Style 的 mcount 或 __fentry__ 呼叫，以及新選項 -mnop-mcount 會產生 nop 放在函數的開頭來，以利之後更改，這項功能可以拿來當作低成本追蹤 (Low Overhead Tracing) 或 Hot Code Patching。
加入新選項 -malign-data 來控制 GCC 如何 align 變數，-malign-data=compat 用來與 GCC 4.8 及之前的版本相容，-malign-data=abi 則是會根據 psABI 來對齊，-malign-data=cacheline 則會試著對齊 cache line，目前 -malign-data=compat 是預設值。
加入新選項 -mskip-rax-setup，可以用在當關閉 SSE 時，不需要設定 RAX 暫存器的狀態，這個選項可以用來最佳化 Linux Kernel。

NDS32

更動可變動參數傳遞的 ABI，偏好會先放在暫存器裡面而不是 Stack 上。
移除選項 -mforce-fp-as-gp， -mforbid-fp-as-gp，以及 -mex9 ，因為在 binutils 的 nds32 port 上相關支援還沒上…
加入新選項 -mcmodel=[small|medium|large] 來控制 Code Models， -mgp-direct 這個選項則不建議使用。

其它改善

gcc-ar, gcc-nm, gcc-ranlib 的 Wrapper 現在支援 -B 相關的選項，並且會傳遞給編譯器作為參考.
新增選項 -freport-bug 來產生編譯器開發者友善的錯誤回報訊息。

GCC 4.9 Release Note

2014-04-23T00:38:00.001+08:00

以下是 4.9 更新的部份, 主要整理自官方 Release 頁面, 但由於個人能力有限, target 相關僅翻譯 x86, arm, aarch64 以及 nds32, 語言相關方面則只翻譯 C/C++ 部份：

提醒！

移除 mudflap run time checker, mudflap 相關的選項還會留著但不會有任何作用.
許多老舊系統以及年久沒維護或測試的 target 在 GCC 4.9 將會被宣佈為過時的 (obsolete), 除非有善心人士幫忙不然在下個 Release 的時候就會直接砍掉.

下列的系統將將被列為 obsoleted:
- Solaris 9 (*-*-solaris2.9). 詳情請洽公告
更多 Porting 到 GCC 4.9 的相關資訊請洽 porting guide.

一般性的最佳化改善

AddressSanitizer, 快速記憶體錯誤偵測器, 在 ARM 上面可以動了!!
UndefinedBehaviorSanitizer (ubsan), 快速未定義行為偵測器, 可以透過 -fsanitize=undefined 這個 flag 開啟. 許多計算(computations) 都會被塞入(instrumented)偵測未定義行為的東西, 目前這個東東可以在 C/C++ 上運作.

連結時期最佳化(Link-time optimization LTO)的改善:

型態合併的部份砍掉重練. 新的實作更快更好更省記憶體!
更好的切割演算法, 連結時期使用更少的 streaming.
透過即早砍掉 Vritual Method 來減少 Object File Size, 以及改善連結時間跟編譯時間.
函數內容 (Function bodies) 需要時才載入 (loaded on-demand), 以及即早釋放來改善連結時期所消耗的記憶體.
C++ 隱藏(hidden) 函數們現在可以被最佳化掉.
當使用 linker plugin 時, 開 -flto 會產生只放 GCC IR 的苗條 (slim) Object File (.o), 使用 -ffat-lto-objects 的時候才會產生肥大 (Fat) Object File, 裡面就會裝 IR 以及 machine code. 要產生可以餵給 LTO 的 static library 時, 請使用 gcc-ar 以及 gcc-ranlib; 要看 symbol 時則請用 gcc-nm. (需要 ar, ranlib 以及 nm 有開啟 plugin 支援).
以 LTO build FireFox 為例, 記憶體使用量從 15G 變 3.5G, 連結時間由 1700 秒變 350 秒.

跨函數最佳化(Inter-procedural optimization) 的改善:

新的型別繼承分析模組使得 devirtualization 有所改善!
Devirtualization 現在會把匿名命名空間以及 C++11 的 final 關鍵字一併考慮進去分析.
新的 speculative devirtualization pass (可透過 -fdevirtualize-speculatively 開啟).
Function Call 被 speculation 後若太貴的話也可能會變回 indierct call.
Local aliases are introduced for symbols that are known to be semantically equivalent across shared libraries improving dynamic linking times. 引入 Local Alias, 讓 gcc 可以判斷 symbol 穿越過 shared librrary 後是否還是否語意等價 (譯註:沒理解錯的話應該是指 Escape analysis XD).

回饋導向最佳化(Feedback directed optimization) 的改善:

C++ inline function 的 Profiling 資訊現在變得更可靠.
新的 time profiling 會吐一個 Function 執行時間的排序.
新的 Function Reorder pass (可透過 -freorder-functions 開啟) 可以大幅的減少大型應用程式的起始時間, 這項功能目前只對於 LTO 有效, 非 LTO 須等到 binutils 全面支援,
即日起開啟 LTO 即可享有回饋導向的 Inderct Call 移除以及跨模組的 devirtualization.

新語言以及語言相關的改善:

gcc/g++ 現在支援 OpenMP 4.0, 加入新的編譯選項 -fopenmp-simd 來開啟 OpenMP 的 SIMD directive. 另外也加入了新的選項 -fsimd-cost-model= 來選擇迴圈中的 annotatation 以及 Cilk Plus simd directive 來作為向量化的 Cost Model; 若只有下 -Wopenmp-simd 則會提醒使用者 Cost Model 被 simd directive 給覆蓋.
新的警告選項 -Wdate-time, 主要針對 C, C++ 以及 Fortan Compiler, 這個選項開啟時, 若使用到 __DATE__, __TIME__ 或 __TIMESTAMP__ Marco 則會發出警告, 提醒使用者會無法生出完全一模一樣 (bit-wise-identical) 的編譯結果.

C 家族

GCC 現在也支援多采多姿的診斷訊息, -fdiagnostics-color=auto 時會會自動偵測是否書出到終端機, 是的話就會多采多姿. -fdiagnostics-color=always 則會強迫多采多姿輸出, 另外 GCC_COLORS 這個環境變數也可以客製化顏色或關閉多采多姿輸出, 如果 GCC_COLORS 有設定的話, 會採用 -fdiagnostics-color=auto 為預設值, 否則預設值是 -fdiagnostics-color=never. 範例診斷訊息輸出

    $ g++ -fdiagnostics-color=always -S -Wall test.C
    test.C: In function ‘int foo()’:
    test.C:1:14: warning: no return statement in function returning non-void [-Wreturn-type]
     int foo () { }
                  ^
    test.C:2:46: error: template instantiation depth exceeds maximum of 900 (use -ftemplate-depth= to increase the maximum) instantiating ‘struct X<100>’
     template <int N> struct X { static const int value = X<N-1>::value; }; template struct X<1000>;
                                                  ^
    test.C:2:46:   recursively required from ‘const int X<999>::value’
    test.C:2:46:   required from ‘const int X<1000>::value’
    test.C:2:88:   required from here

    test.C:2:46: error: incomplete type ‘X<100>’ used in nested name specifier

增加新的 pragma: #pragma GCC ivdep, 讓使用者告訴 GCC 迭代間無相依性, 來避免產生過度保守的 SIMD 指令.
支援 Cilk Plus 可透過 -fcilkplus 來使用, Cilk Plus 是一組 C/C++ 語言的語言延伸(extension) 讓其支援資料層級或任務層級的平行化, 目前的實作是遵照 ABI 1.2 版, 除了 _Cilk_for 外已經全數實作完成.

C

支援 ISO C11 的 Atomic (_Atomic type specifier, qualifier 以及 stdatomic.h).
支援 C11 _Generice 關鍵字.
支援 C11 thread-local storage (_Thread_local, 類似 GNU C 中的 __thread)
幾乎完全支援 C11, 完成度大概就跟 C99 的支援度差不多:
修正一堆 bug 以及新增 C11 相關的關鍵字 (除了一些 Corner Case 外幾乎全部支援, 可透過 fextended-identifiers 開啟), 浮點數相關運算 (大部分但不是完整的 C99 功能, 可參考 C99 的附錄 F 及 G) 以及一些選擇性功能 Annexes K (Bounds-checking interface) 以及 L (Analyzability).
增加新的 C extension: __auto_type, 可提供部份類似 C++11 中 auto 的功能.

C++

目前 G++ 實作 C++1y 中的 return type deduction 已經更新到 N3638, 這個提案目前已經被接受到 working paper 中. Most notably, 可透過 decltype(auto) 來取得 decltype semantics 的回傳型別, 相較之下一般的 auto 則是取得 template argument deduction semantics.
```
int& f();
         auto  i1 = f(); // int
decltype(auto) i2 = f(); // int&
```
G++ 支援 C++1y 的 lambda capture initializers:
```
[x = 42]{ ... };
```
事實上他已經在 GCC 4.5 中被支援了, 使用 -std=c++1y 的話 compiler 就不會抱怨, 目前支援 parenthesized 初始化以及 brace-enclosed 初始化的形式.

void f(int n) {
  int a[n] = { 1, 2, 3 }; // throws std::bad_array_length if n < 3
  [&a]{ for (int i : a) { cout << i << endl; } }();
  &a; // error, taking address of VLA
}

G++ 支援 C++1y 中的 [[deprecated]] 屬性, 就像 [[gnu::deprecated]] 屬性一樣, 類別或函數都可以套用:

class A;
int bar(int n);
#if __cplusplus > 201103
class [[deprecated("A is deprecated in C++14; Use B instead")]] A;
[[deprecated("bar is unsafe; use foo() instead")]]
int bar(int n);

int foo(int n);
class B;
#endif
A aa; // warning: 'A' is deprecated : A is deprecated in C++14; Use B instead
int j = bar(2); // warning: 'int bar(int)' is deprecated : bar is unsafe; use foo() instead

G++ 支援 C++1y 中的 digit separators. 長的數字常數可被 ' 來切開表示藉此提升可讀性:

int i = 1048576;
int j = 1'048'576;
int k = 0x10'0000;
int m = 0'004'000'000;
int n = 0b0001'0000'0000'0000'0000'0000;

double x = 1.602'176'565e-19;
double y = 1.602'176'565e-1'9;

G++ 支援 C++1y polymorphic(多型) lambda

// a functional object that will increment any type
auto incr = [](auto x) { return x++; };

Runtime Library (libstdc++)

改善 C++11 的支援, 其中包含:
- 支援 <regex>
- <map>, <set>, <unordered_map> 以及 <unordered_set> 現在都符合 allocator-aware 的需求了!
改善許多實驗性的 C++14 支援, 包含:
- 沒有 const 的 constexpr 成員函數.
- 實作 std::exchange()
- 支援透過型別取值的 tuple
- 實作 std::make_unique
- 實作 std::shared_lock
- 讓 std::result_of SFINAE-friendly;
- integral_constant 新增 operator()
- 新增標準函式庫中的使用者字定義字面常數 (user-defined literals), 例如 std::basic_string, std::chrono::duration, 以及 std::complex
- 為 std::equal 及 std::mismatch 新增 non-modifying sequence oprations 的版本 oprations
- 新增針對 quoted strings 的 IO manipulators.
- 新增 constexpr member 到 <utility>, <complex>, <chrono> 以及部份容器.
- 新增編譯時期的 std::integer_sequence
- 新增 cleaner transformation traits
- 讓 <functional> 中的 operator functors 更好用而且更一般化 (more generic).
- 實作 std::experimental::optional.
- 實作 std::experimental::string_view.
- std::copy_exception 這個非標準的函數被 deprecate , 在未來會移除, 請換使用 std::make_exception_ptr.

新的 Target 以及 Target 相關改善:

AArch64

新增 ARMv8-A 加密以及 CRC 的 intrinsic, 目前要透過 -march=armv8-a+crc 以及 -march=armv8-a+crypto 來開啟.
初步支援 ILP32, 目前可透過 -mabi=ilp32 來開啟, ILP32 目前是個實驗性質的 ABI, 尚在 beta 階段.
涵蓋更多的 ISA: 現在包含 SIMD extensions 以及相關的 intrinsic.
AArch64 目前預設使用 Local Register Allocator (LRA)!
在 AArch64 中 REE (Redundant extension elimination) Pass 預設開啟.
改善 Cortex-A53 以及 Cortex-A57 的微調(Tuning).
初步 big.LITTLE 微調可整合 Cortex-A57 以及 Cortex-A53, 可透過 -mcpu=cortex-a57.cortex-a53 來開啟.
大量的基礎建設改善使得 ARM 以及 AArch64 的 Code Gen 獲得不思議的改善.

ARM

目前不再預設 Advanced SIMD (Neon) 來操作 64-bit scalar, 這部份已經被證實只能改善小幅度的 case, 可透過 -mneon-for-64bits 來開啟.
更多的 ARMv8-A architecture 支援, 目前 Thumb32 指令的嚴格限制版的 IT block 可透過 -mrestrict-it 來開啟, 並且搭配 -march=armv7-a 或 -march=armv7ve 來產生對 ARMv8-A deprecated instructions 更佳的相容性.
支援一些 ARMv7ve 相關的架構, 可透過 -march=armv7ve 開啟.
新增 ARMv8-A 加密以及 CRC 的 intrinsic, 目前要透過 -march=armv8-a+crc 以及 -mfpu=crypto-neon-fp-armv8 來開啟.
ARM 現在預設開啟 LRA, 可以透過 -mno-lra 來關掉, 這個選項指示拿來方便發現 bug 或 performance regressions 用的, 未來會拔除.
加入新選項 -mslow-flash-data: 可改善在 ARMv7-M profile cores 上的程式效能.
加入新選項 -mpic-data-is-text-relative 來讓 text segment 可透過相對位址存取 data segment, 目前除了 VxWorks RTP 外預設開啟.
大量的基礎建設改善使得 ARM 以及 AArch64 的 Code Gen 獲得不思議的改善.
GCC 現在支援 Cortex-A12 以及 Cortex-R7: -mcpu=cortex-a12 及 -mcpu=cortex-r7 選項.
GCC 現在支援 Cortex-A57 以及 Cortex-A53: -mcpu=cortex-a57 及 -mcpu=cortex-a53 選項.
初步 big.LITTLE 微調可整合 Cortex-A57 以及 Cortex-A53, 可透過 -mcpu=cortex-a57.cortex-a53 來開啟.
新增更多針對 Cortex-A15 以及 the Cortex-M4 的效能改善
針對 M-profile processors 改善 Thumb2 的 Code Gen

IA-32/x86-64

支援 AVX-512 指令集, 支援 inline assembly, 新的 registers 以及延伸舊有的東西, 新的 intrinsics (包含相對應的 testsuite), 以及基本的自動向量化. AVX-512 指令目前可透過以下 GCC 選項開啟: AVX-512 foundation instructions: -mavx512f, AVX-512 prefetch instructions: -mavx512pf, AVX-512 exponential 以及 reciprocal instructions: -mavx512er, AVX-512 conflict detection instructions: -mavx512cd.
現在可以針對特定函數打上相對應的 target attribute 而不用整個檔案用 -mxxx 選項來使得整的檔案來指定特定 target, 這使得單一檔案中容易實作 Function Multiversioning.
GCC 現在支援 Silvermont: -march=silvermont.
GCC 現在支援 Broadwell: -march=broadwell.
-march 部份重新命名: -march=nehalem, westmere, sandybridge, ivybridge, haswell, bonnell
-march=generic 現在針對 Intel core and AMD Bulldozer architectures 提供更好的效能, AMD K7, K8, Intel Pentium-M, and Pentium4 based 的 CPU 效能不再重要.
-mtune=intel 可以針對大部分的 Intel cpu 產生更好的 Code.
支援將 32-bit assembly instructions encode 成 16-bit, 可透過 -m32 開啟.
更好的 memcpy 及 memset, 會針對長度以及內容物產生更短的 alignment prologues.
-mno-accumulate-outgoing-args 現在會產生更精確的 unwind 資訊. 針對 -Os, Argument accumulation 將預設關閉.
支援 AMD 家族的 15h processors (Excavator core): -march=bdver4 以及 -mtune=bdver4.

NDS32

新的 nds32 port, 一個來自台灣晶心科技的 32-bit 架構.
目前的 Porting 初步支援 V2, V3, V3m instruction set architectures.

GCC 4.8 Release Note

2013-03-23T11:39:00.001+08:00

隔了整整一年的 GCC 4.8_註1 終於 Release 了！

以下大略整理一下此次更新的部份, 主要整理自官方 Release 頁面[1], 但由於個人偏好, 非ARM, C/C++ 將不會出現在下面：

一般性

GCC 切換使用 C++ 實作, 回不去了, 但要注意 GCC 中目前政策是只使用 C++2003 的 subset, 禁止列表可參考 [3]
GCC 現在採用更激烈(aggressive)_註2的最佳化, 同時也增加 -fno-aggressive-loop-optimizations 這個選項來避免過激行為
DWARF4 為預設產生的 Debug Info
新的選項 -Og 可以產生有最佳化但又方便 Debug 的 Code, 以後可以不用下 -O0 -g3 可以換下 -Og -g3 了
新的最佳化選項 -ftree-partial-pre , 預設開啟於 -O3
Struct 及 Matrix 的 reorg 功能被拔掉了(-fipa-struct-reorg 及 -fipa-matrix-reorg), 因為有機率產生出爛掉的東西, 而且 lto 時會爛掉
LTO 大幅改善
AddressSanitizer 及 ThreadSanitize 正式加入, 分別使用 -fsanitize=address 及 -fsanitize=thread 來開啟, AddressSanitizer 功能簡介可參照[5]

語言相關

錯誤訊息會用 ^ 來標示出錯誤地點, 例如以下是少分號的範例

#include<stdio.h>
#include<stdlib.h>

int main(){
  return 0
}

GCC 4.8 的錯誤訊息

test.c: In function ‘main’:
test.c:6:1: error: expected ‘;’ before ‘}’ token
 }
 ^

但跟 clang 比起來似乎還是沒做的很好, clang 的輸出範例:

test.c:5:11: error: expected ';' after return statement
  return 0
          ^
          ;

更多比較可參考[6]

新的選項 -ftrack-macro-expansion= 可以在讓你在顯示錯誤訊息時展開 Marco N 層, 範例：

#define MARCO_(a, b) a b
#define MARCO(a, b) MARCO_(a, b)

void f(int a, int b) {
  MARCO(a, b);
}

GCC 4.7.2 的錯誤訊息

marco.c: In function ‘f’:
marco.c:5:3: error: expected ‘;’ before ‘b’

GCC 4.8 的錯誤訊息

marco.c: In function ‘f’:
marco.c:6:12: error: expected ‘;’ before ‘b’
   MARCO(a, b);
            ^
marco.c:2:24: note: in definition of macro 'MARCO_'
 #define MARCO_(a, b) a b
                        ^
marco.c:6:3: note: in expansion of macro 'MARCO'
   MARCO(a, b);
   ^

clang 的錯誤訊息

marco.c:6:12: error: expected ';' after expression
  MARCO(a, b);
           ^
marco.c:3:31: note: expanded from macro 'MARCO'
#define MARCO(a, b) MARCO_(a, b)
                              ^
marco.c:2:24: note: expanded from macro 'MARCO_'
#define MARCO_(a, b) a b
                       ^

新的警告 -Wsizeof-pointer-memaccess, 當該填 size 時你直接 sizeof(pointer) 就會跟你抱怨, 範例如下:

#include <string.h>

void f(int *p){
  memset(p, 1, sizeof(p));
}

然後開 -Wall 或 -Wsizeof-pointer-memaccess 會跟你抱怨

memset.c: In function ‘f’:
memset.c:4:22: warning: argument to ‘sizeof’ in ‘memset’ call is the same expression as the destination; did you mean to dereference it? [-Wsizeof-pointer-memaccess]
   memset(p, 1, sizeof(p));
                      ^

不過還是要說一下 clang 吐出來的資訊比較清楚

memset.c:4:23: warning: 'memset' call operates on objects of type 'int' while the size is based
      on a different type 'int *' [-Wsizeof-pointer-memaccess]
  memset(p, 1, sizeof(p));
         ~            ^
memset.c:4:23: note: did you mean to dereference the argument to 'sizeof' (and multiply it by the
      number of elements)?
  memset(p, 1, sizeof(p));
                      ^

C++11專區

thread_local 關鍵字實作了！

的 attribute 及 alignment 實作, 範例：

[[noreturn]] void f();

alignas(double) int i;

ARM

AArch 64 支援
ARM 的 AAPCS ABI 有稍微更動, 有關 vector types 部份的 ABI 將無法與舊的 GCC 產生的 Code 相容
現在 GCC 會想辦法產生 VFMA, VFMS, REVSH 及 REV16 指令
新的 Inst Scheduler 會考慮 Register Pressure, 不喜歡的話可透過 -fno-sched-pressure 關掉
支援 Marvell 的 iWMMX2 SIMD, 可透過指定 -mcpu=iwmmxt2 來開啟

註1: GCC 4.7 於 2012-03-22 Release 而 4.8 是 2013-03-22, 剛好一年
註2: Aggressive 這個字眼在 Compiler 領域中通常代表需要花較多時間分析及最佳化, 並且也有可能不會比較好(指 Code Size 或 Performance)

Reference

[1] GCC 4.8 Release 官方網頁
[2] C++ Conversion(GCC Wiki)
[3] http://gcc.gnu.org/wiki/CppConventions
[4] GCC and C vs C++ Speed, Measured
[5] Address-sanitizer : 新的 Android 快速記憶體錯誤偵測工具
[6] C++ Diagnostic Survey

Address-sanitizer : 新的 Android 快速記憶體錯誤偵測工具

2013-01-11T01:12:00.003+08:00

簡介

Android 在 Jerry Bean 的時候加入了 Address-sanitizer 的支援

這東西是什麼勒, 說白話一點就是個可以偵測一些記憶體使用錯誤的一個小工具,

有點類似 valgrind 中 memcheck 的功能但是更快更簡單(但相對的某些錯誤無法偵測)

偵測錯誤的類型

廢話不多說, 直接看範例程式跟範例輸出

越界存取(Out of bound)

Heap 越界存取

#include 
#include 
int main(int argc, char **argv) {
  char *x = (char*)malloc(10 * sizeof(char));
  memset(x, 0, 10);
  int res = x[argc * 10];  // BOOOM
  free(x);
  return res;
}

範例執行輸出：

=================================================================
==799== ERROR: AddressSanitizer heap-buffer-overflow on address 0x41255cca at pc 0x2a00055b bp 0xbeff6b0c sp 0xbeff6b08
READ of size 1 at 0x41255cca thread T0
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40023e77 (/system/lib/libasan_preload.so+0x9e77)
    #2 0x4001c947 (/system/lib/libasan_preload.so+0x2947)
    #3 0x2a000559 (/system/bin/heap-out-of-bounds+0x559)
    #4 0x4114371d (/system/lib/libc.so+0x1271d)
0x41255cca is located 0 bytes to the right of 10-byte region [0x41255cc0,0x41255cca)
allocated by thread T0 here:
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40022aff (/system/lib/libasan_preload.so+0x8aff)
    #2 0x2a0004e9 (/system/bin/heap-out-of-bounds+0x4e9)
    #3 0x4114371d (/system/lib/libc.so+0x1271d)
Shadow byte and word:
  0x0824ab99: 2
  0x0824ab98: 00 02 fb fb
More shadow bytes:
  0x0824ab88: 00 00 00 00
  0x0824ab8c: 04 fb fb fb
  0x0824ab90: fa fa fa fa
  0x0824ab94: fa fa fa fa
=>0x0824ab98: 00 02 fb fb
  0x0824ab9c: fb fb fb fb
  0x0824aba0: fa fa fa fa
  0x0824aba4: fa fa fa fa
  0x0824aba8: fa fa fa fa
Stats: 0M malloced (0M for red zones) by 36 calls
Stats: 0M realloced by 0 calls
Stats: 0M freed by 0 calls
Stats: 0M really freed by 0 calls
Stats: 2M (642 full pages) mmaped in 5 calls
  mmaps   by size class: 7:4095; 8:2047; 11:255; 12:128; 13:64; 
  mallocs by size class: 7:27; 8:4; 11:2; 12:2; 13:1; 
  frees   by size class: 
  rfrees  by size class: 
Stats: malloc large: 0 small slow: 5
==799== ABORTING

全域變數越界存取

int global_array[100] = {-1};
int main(int argc, char **argv) {
  return global_array[argc + 100];  // BOOM
}

範例執行輸出：

=================================================================
==7161== ERROR: AddressSanitizer global-buffer-overflow on address 0x2a002194 at pc 0x2a00051b bp 0xbeeafb0c sp 0xbeeafb08
READ of size 4 at 0x2a002194 thread T0
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40023e77 (/system/lib/libasan_preload.so+0x9e77)
    #2 0x4001c98f (/system/lib/libasan_preload.so+0x298f)
    #3 0x2a000519 (/system/bin/global-out-of-bounds+0x519)
    #4 0x4114371d (/system/lib/libc.so+0x1271d)
0x2a002194 is located 4 bytes to the right of global variable 'global_array (external/test/global-out-of-bounds.cpp)' (0x2a002000) of size 400
Shadow byte and word:
  0x05400432: f9
  0x05400430: 00 00 f9 f9
More shadow bytes:
  0x05400420: 00 00 00 00
  0x05400424: 00 00 00 00
  0x05400428: 00 00 00 00
  0x0540042c: 00 00 00 00
=>0x05400430: 00 00 f9 f9
  0x05400434: f9 f9 f9 f9
  0x05400438: 00 00 00 00
  0x0540043c: 00 00 00 00
  0x05400440: 00 00 00 00
Stats: 0M malloced (0M for red zones) by 35 calls
Stats: 0M realloced by 0 calls
Stats: 0M freed by 0 calls
Stats: 0M really freed by 0 calls
Stats: 2M (642 full pages) mmaped in 5 calls
  mmaps   by size class: 7:4095; 8:2047; 11:255; 12:128; 13:64; 
  mallocs by size class: 7:26; 8:4; 11:2; 12:2; 13:1; 
  frees   by size class: 
  rfrees  by size class: 
Stats: malloc large: 0 small slow: 5
==7161== ABORTING

區域變數越界存取

int main(int argc, char **argv) {
  int stack_array[100];
  stack_array[1] = 0;
  return stack_array[argc + 100];  // BOOM
}

範例執行輸出：

=================================================================
==7165== ERROR: AddressSanitizer stack-buffer-overflow on address 0xbed0bad4 at pc 0x2a000557 bp 0xbed0b914 sp 0xbed0b910
READ of size 4 at 0xbed0bad4 thread T0
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40023e77 (/system/lib/libasan_preload.so+0x9e77)
    #2 0x4001c98f (/system/lib/libasan_preload.so+0x298f)
    #3 0x2a000555 (/system/bin/stack-out-of-bounds+0x555)
    #4 0x4114371d (/system/lib/libc.so+0x1271d)
Address 0xbed0bad4 is located at offset 436 in frame  of T0's stack:
  This frame has 1 object(s):
    [32, 432) 'stack_array'
HINT: this may be a false positive if your program uses some custom stack unwind mechanism
      (longjmp and C++ exceptions *are* supported)
Shadow byte and word:
  0x17da175a: f4
  0x17da1758: 00 00 f4 f4
More shadow bytes:
  0x17da1748: 00 00 00 00
  0x17da174c: 00 00 00 00
  0x17da1750: 00 00 00 00
  0x17da1754: 00 00 00 00
=>0x17da1758: 00 00 f4 f4
  0x17da175c: f3 f3 f3 f3
  0x17da1760: 00 00 00 00
  0x17da1764: 00 00 00 00
  0x17da1768: 00 00 00 00
Stats: 0M malloced (0M for red zones) by 35 calls
Stats: 0M realloced by 0 calls
Stats: 0M freed by 0 calls
Stats: 0M really freed by 0 calls
Stats: 2M (642 full pages) mmaped in 5 calls
  mmaps   by size class: 7:4095; 8:2047; 11:255; 12:128; 13:64; 
  mallocs by size class: 7:26; 8:4; 11:2; 12:2; 13:1; 
  frees   by size class: 
  rfrees  by size class: 
Stats: malloc large: 0 small slow: 5
==7165== ABORTING

釋放後使用 (Use after free)

#include 
int main() {
  char *x = (char*)malloc(10 * sizeof(char*));
  free(x);
  return x[5];
}

範例執行輸出：

=================================================================
==7169== ERROR: AddressSanitizer heap-use-after-free on address 0x41255cc5 at pc 0x2a0004cd bp 0xbece1b1c sp 0xbece1b18
READ of size 1 at 0x41255cc5 thread T0
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40023e77 (/system/lib/libasan_preload.so+0x9e77)
    #2 0x4001c947 (/system/lib/libasan_preload.so+0x2947)
    #3 0x2a0004cb (/system/bin/use-after-free+0x4cb)
    #4 0x4114371d (/system/lib/libc.so+0x1271d)
0x41255cc5 is located 5 bytes inside of 40-byte region [0x41255cc0,0x41255ce8)
freed by thread T0 here:
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40022a97 (/system/lib/libasan_preload.so+0x8a97)
    #2 0x2a0004b1 (/system/bin/use-after-free+0x4b1)
    #3 0x4114371d (/system/lib/libc.so+0x1271d)
previously allocated by thread T0 here:
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40022aff (/system/lib/libasan_preload.so+0x8aff)
    #2 0x2a0004ab (/system/bin/use-after-free+0x4ab)
    #3 0x4114371d (/system/lib/libc.so+0x1271d)
Shadow byte and word:
  0x0824ab98: fd
  0x0824ab98: fd fd fd fd
More shadow bytes:
  0x0824ab88: 00 00 00 00
  0x0824ab8c: 04 fb fb fb
  0x0824ab90: fa fa fa fa
  0x0824ab94: fa fa fa fa
=>0x0824ab98: fd fd fd fd
  0x0824ab9c: fd fd fd fd
  0x0824aba0: fa fa fa fa
  0x0824aba4: fa fa fa fa
  0x0824aba8: fa fa fa fa
Stats: 0M malloced (0M for red zones) by 36 calls
Stats: 0M realloced by 0 calls
Stats: 0M freed by 1 calls
Stats: 0M really freed by 0 calls
Stats: 2M (642 full pages) mmaped in 5 calls
  mmaps   by size class: 7:4095; 8:2047; 11:255; 12:128; 13:64; 
  mallocs by size class: 7:27; 8:4; 11:2; 12:2; 13:1; 
  frees   by size class: 7:1; 
  rfrees  by size class: 
Stats: malloc large: 0 small slow: 5
==7169== ABORTING

使用方式

使用方式出乎意料的簡單
只要在你的 Android.mk 裡面加一行

LOCAL_ADDRESS_SANITIZER := true

主要原因在於 Address-sanitizer 也是 google 自家弄的東西, 所以整合的還算不錯

另外有開 Address-sanitizer 有個副作用就是會強迫開啟 clang 模式

什麼意思勒? 就是你的 code 變得不是使用 gcc 編譯而是 clang/llvm

若 code 有用到 gcc 特有的東西的話可能就會炸掉:P

另外 libasan_preload.so 也記得要推到 /system/lib 的地方, 這是 Address-sanitizer run-time library, 可以去 out/target/product/*/system/lib/ 裡面撈撈

如果找不到開了 LOCAL_ADDRESS_SANITIZER := true 但建置系統跟你抱怨 libasan_preload.so 或 libasan.a 的話,
就切到 external/compiler-rt/lib/asan/ 自行建置一下, 或著是用 mmm 讓建置系統自己拉相依關係

錯誤報告的解讀

接著這部份最重要的就是他吐出那團錯誤報告要怎麼讀
就直接從最複雜的釋放後使用 (Use after free)的報告來講解

=================================================================
==7169== ERROR: AddressSanitizer heap-use-after-free on address 0x41255cc5 at pc 0x2a0004cd bp 0xbece1b1c sp 0xbece1b18

首先第一個部份是會跟你報告什麼類型的錯誤, 如這邊是 heap-use-after-free, 另外還有 stack-buffer-overflow, global-buffer-overflow, heap-buffer-overflow 這幾種錯誤類型, 分別對到 stack, global 及 heap 的越界存取

on address 0x41255cc5 部份是你要存取的記憶體位置
at pc 0x2a0004cd bp 0xbece1b1c sp 0xbece1b18 部份則是說發生錯誤的 program counter 值是多少, 以及 frame pointer 跟 stack pointer 的內容

READ of size 1 at 0x41255cc5 thread T0
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40023e77 (/system/lib/libasan_preload.so+0x9e77)
    #2 0x4001c947 (/system/lib/libasan_preload.so+0x2947)
    #3 0x2a0004cb (/system/bin/use-after-free+0x4cb)
    #4 0x4114371d (/system/lib/libc.so+0x1271d)
0x41255cc5 is located 5 bytes inside of 40-byte region [0x41255cc0,0x41255ce8)

接著很貼心的也會將你炸掉的地方的 call stack 吐出來
只有 pc 值不知道在哪的話就呼叫 addr2line 這個工具來幫忙就可以了
例如你想查 /system/bin/use-after-free+0x4cb 對應的行號是多少則輸入以下指令即可
addr2line -e out/target/product/*/symbols/system/bin/use-after-free -a 0x4cb
* 自行帶入目前建置的 device name, -e 後面塞檔案, -a 後面塞位址, call stack 加號後面的東西

freed by thread T0 here:
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40022a97 (/system/lib/libasan_preload.so+0x8a97)
    #2 0x2a0004b1 (/system/bin/use-after-free+0x4b1)
    #3 0x4114371d (/system/lib/libc.so+0x1271d)

然後也會吐出 free 的 call stack, 解讀方式同上

previously allocated by thread T0 here:
    #0 0x40022a4b (/system/lib/libasan_preload.so+0x8a4b)
    #1 0x40022aff (/system/lib/libasan_preload.so+0x8aff)
    #2 0x2a0004ab (/system/bin/use-after-free+0x4ab)
    #3 0x4114371d (/system/lib/libc.so+0x1271d)

malloc 的地方也會有 call stack 吐出來

Shadow byte and word:
  0x0824ab98: fd
  0x0824ab98: fd fd fd fd
More shadow bytes:
  0x0824ab88: 00 00 00 00
  0x0824ab8c: 04 fb fb fb
  0x0824ab90: fa fa fa fa
  0x0824ab94: fa fa fa fa
=>0x0824ab98: fd fd fd fd
  0x0824ab9c: fd fd fd fd
  0x0824aba0: fa fa fa fa
  0x0824aba4: fa fa fa fa
  0x0824aba8: fa fa fa fa
Stats: 0M malloced (0M for red zones) by 36 calls
Stats: 0M realloced by 0 calls
Stats: 0M freed by 1 calls
Stats: 0M really freed by 0 calls
Stats: 2M (642 full pages) mmaped in 5 calls
  mmaps   by size class: 7:4095; 8:2047; 11:255; 12:128; 13:64; 
  mallocs by size class: 7:27; 8:4; 11:2; 12:2; 13:1; 
  frees   by size class: 7:1; 
  rfrees  by size class: 
Stats: malloc large: 0 small slow: 5
==7169== ABORTING

最後這團東西看不懂就算了, Address-sanitizer 的內部資訊, 有興趣去挖他們簡報出來就有詳細一點的範例加解釋了

副作用及使用限制

Address-sanitizer 使用時主要有一些額外的負擔：

每次 new/malloc 會多出額外的 128-255 byte 作為警戒區(Red Zone), 也就是越界時爆炸的引發器:P
Stack 則是每個區域變數會吃掉 32~63 byte 作為警戒區(Red Zone)
全域變數也是每個變數會吃掉 32~63 byte 作為警戒區(Red Zone)
一般而言會吃掉 2~4 倍的記憶體, 但最差情況也有可能高達 20 倍的記憶體消耗
Stack 會幾乎長三倍大以上
Address Space 會直接被吃掉八分之一, 32 位元情況下會吃掉 0.5 G, 64 位元則會吃掉 16T, 但僅消耗定址空間, 不會實際耗費掉記憶體 (該區域被設定為不可讀不可寫, 存取到會直接炸掉)

其最大的使用限制是當 Address-sanitizer 偵測到任何記憶體錯誤時就會馬上中斷程式的執行,

這是正常現象, 也因為這樣的設計使得此工具簡單快速又方便

與 Valgrind 的比較表格

	Valgrind	Address-sanitizer
Heap out-of-bounds Heap 越界存取	Yes	Yes
Stack out-of-bounds Stack 越界存取	No	Yes
Global out-of-bounds 全域變數越界存取	No	Yes
Use-after-free 釋放(free/delete)後使用	Yes	Yes
Use-after-return 回傳後使用 (例如回傳區域變數指標)	No	Sometimes/YES
Uninitialized reads 讀取未初始化的值	Yes	No(註1)
Overhead 對程式影響(變慢幾倍)	10x-30x	1.5x-3x
Platforms 可使用平台	Linux, Mac	Same as GCC/LLVM (註2)

註1: 這部份有 Address-sanitizer 的好兄弟 Memory-sanitizer 可以處理, 但尚未納入 Android 中
註2: GCC 部份於 2012/11/01 正式納入 Address-sanitizer[4], 可用度沒玩過不太確定, 在 Android 中要開 Address-sanitizer 就是要用 clang 就是了:P...

小結

Address-sanitizer 算是一個輕量級的好用小工具, 根據開發者所釋放出來的簡報 Google 內部自己也有使用此工具並且抓出了上千個 bug, 包含 llvm, gcc, vim, firefox 等大型 Open Source 軟體的記憶體使用 bug, 目前 Address-sanitizer 還有一些相關的兄弟如 Memory-sanitizer 及 Thread-sanitizer, 分別可以偵測 Uninitialized reads 及 Race condition, 不過在 Android 中目前還沒引進, 但都 Google 自家人弄的, 可以期待之後應該是會引進到 Android 中, 讓一些常見的記憶體錯誤可以早期發現:)

參考鍊結

[1] http://code.google.com/p/address-sanitizer
[2] http://llvm.org/devmtg/2011-11/Serebryany_FindingRacesMemoryErrors.pdf
[3] http://address-sanitizer.googlecode.com/files/address_sanity_checker.pdf
[4] http://gcc.gnu.org/ml/gcc/2012-11/msg00016.html

快快樂樂 Makefile 入門教學 Part.II 泛用規則/萬用字元應用

2013-01-08T19:01:00.001+08:00

這邊文章主要是快快樂樂 Makefile 入門教學的續集, 主要針對的對象依然初學者

要談的主題則是在 Makefile 中萬用字元跟泛用規則的應用, 可以讓整個 Makefile 盡量變得簡潔有力

並且一窺 Makefile 的內部推導邏輯

一堆 .o 一堆 rule

當使用 Makefile 一段時間後, 大致上會碰到的問題就是如果你有一堆 .c 要編譯成 .o 檔的話

手刻一堆 xxx.c -> xxx.o 的 rule 會讓人挺困擾的, 尤其是通常都是 gcc xxx.c -c -o xxx.o 之類的

但如果你是個懶惰牌的好 Programmer 那麼你可能會嘗試寫一些萬用字元的 rule

於是你寫下了以下的 rule

*.o: *.c
 gcc -o *.o  -c *.c

嗚呼！ Let's Make

然後你會發現如果有兩個 .c 以上的話就會發現：「幹！不能動」

gcc -o *.o  -c *.c
gcc: fatal error: cannot specify -o with -c, -S or -E with multiple files
compilation terminated.
make: *** [*.o] Error 4

錯誤訊息跟我們抱怨如果指定 -o 加上 -c, -S 或 -E 的話就不能輸入多個檔案

現在假設你還沒有任何的 .o 擋在該資料夾並且有 a.c b.c 要編譯

shell 真實看到的指令變成這樣

gcc -o  -c a.c b.c

然後就引發剛才的錯誤了XD

救命難道只能寫一堆 rule 了嗎？

萬用字元不能動的主要原因在於 Makefile 為了避免與 shell 使用的萬用字元 * 衝突而選擇了另一個

並且 *.c 跟 *.o 的 * 的部份哪知道會不會一樣, 所以 Makefile 有自己的萬用字元系統

*.o: *.c
 gcc -o *.o  -c *.c

所以在 Makefile 中是使用 % 作為萬用字元, 因此第一直覺會下出類似下面的建置規則

%.o: %.c
 gcc -o %.o  -c %.c

敲入 Make 後發現建置規則是有抓到了, 但是建置指令並沒有將 % 替換程式適當的字串

gcc -o %.o  -c %.c
gcc: error: %.c: No such file or directory
gcc: fatal error: no input files
compilation terminated.
make: *** [a.o] Error 4

主要原因在於建置規則中不是用 % 來表達該萬用字元是用 $@ 及 $^
(當然還有一堆其它 $ 開頭的神奇變數, 不過常用的大概就這些)

Makefile 萬用字元使用方式 %, $@, $^

$@, $^這幾個符號各代表不同意義, 但直接先看範例再來解說吧

%.o: %.c
 gcc -o $@  -c $^

其中 $@ 代表建置目標, 所以以要建置 a.o 來看的話 $@ 等於 a.o
接著 $^ 則代表相依目標, 建置 a.o 時會替換成 a.c

從此之後就只要寫一個 .c -> .o 的建置規則在加上一個 link 成執行檔的規則即可！

這些萬用規則也可以拿來作一些方便的應用, 例如有時候你會將 debug 版本跟一般版跟分開放置
則你寫兩個 rule 則可以建置出不同編譯參數且在不同資料夾生成

debug/%.o: %.c
 gcc -o $@  -c $^ -g

release/%.o: %.c
 gcc -o $@  -c $^ -O2

小結

Makefile 會了萬用字元後, 建置規則就可以寫的簡潔又好看

在加上 .c/.cpp 與 .h/.hpp 相依性自動建立就很完整了

預計會在弄一篇文章寫產生 .c/.cpp 與 .h/.hpp 相依性的:P

使用 buildroot 建置可用於 SimpleScalar 的 ARM toolchain

2012-11-03T11:40:00.002+08:00

0. 前言

剛好最近有人來信詢問，就順便整理先前的一些文件一下，雖然 SimpleScalar 相對於現階段 ARM 的發展而言還停留在 ARMv4 的指令集，但若是在學術用途方面的話，還算是個相當有用的工具。

但在研究初期最容易遇到的問題就是 toolchain 的問題，官方附贈的過舊，要自行建置則網路上資訊過於零散，建立出來也不見得能用...

而在這篇文章中會透過 buildroot 來建立一串基礎的 ARM toolchain ，來簡化整個建置的過程，若一般用途而言這樣的方式就夠了

另外此篇文章假設你已經有一個已經建立好的 SimpleScalar ARM 可以用了

1. 使用 buildroot 建置 ARM toolchain

buildroot 的官方網站是 http://buildroot.uclibc.org/download.html
以下操作以 2012.08 的版本為例子，其它版本操作上大同小異，但部份路徑可能會有不同，第一次建議使用相同版本操作較為保險

目前作過測試是到 gcc 4.6 都可以在 SimpleScalar ARM 上運作沒有問題

gcc 4.7 因為不支援 ARM oabi 的部份所以會有點問題 (需要對 SimpleScalar 作一些修改)

i. 抓取 buildroot

wget http://buildroot.uclibc.org/downloads/buildroot-2012.08.tar.bz2

ii. 解壓縮 buildroot

tar -jxf buildroot-2012.08.tar.bz2

iii. 組態 buildroot

打入 make menuconfig 進入選單，會有 console 版本的選單出現

make menuconfig

# 接著會進入選單
Target Architecture 按 enter 選 ARM (little endian)
Target Architecture Variant 保留 generic_arm ，simplescalar 只支援 arm v4
Target ABI 選 oabi <--這是大重點，eabi 會不能動
Toolchain 點進去可以選 gcc 跟 binutils 版本
  uClibc C library Version 選 uClibc 0.9.31.x ，太新會沒辦法用(需要用到 bx 指令， armv4 不支援)
  需要 g++ 的話在  Enable C++ support 那邊按空白打 *
  需要使用 hard floating point 則 Use software floating point by default 的 * 按空白拿掉

其它看無就不用動

選擇最下面 Save an Alternate Configuration File
你會看到有一串
/home/kito/xxxxxxx/buildroot-2012.08/.config 之類的路徑
不要改
直接按 enter
然後 exit (左右可以移動下面的按鈕)
接著 make
然後轉身去泡杯咖啡，需要一點時間下載跟建置

build 完後在 buildroot 資料夾底下的
./output/host/usr/
這個資料夾
裡面就有 arm toolchain 了

iii. 測試 buildroot

先弄一個 Hello World

echo "int main() {printf(\"hello world\");}" > hello.c

編譯 Hello World ，-static 一定要加, simplescalar 只支援 static link

./output/host/usr/bin/arm-linux-gcc hello.c -o hello -static

使用 SimpleScalar ARM 測試，前面的 path 記得自行替換成 simplescalar 的路徑

/<path-to-simplescalar>/sim-uop hello

看到下面那一沱就代表你成功了！


sim-uop: SimpleScalar/ARM Tool Set version 3.0 of November, 2000.
Copyright (c) 1994-2000 by Todd M. Austin.  All Rights Reserved.
This version of SimpleScalar is licensed for academic non-commercial use only.

sim: command line: /home/kito/simulators/simplesim-arm-v2/sim-uop hello

sim: simulation started @ Mon Oct 22 20:25:18 2012, options follow:

sim-safe: This simulator implements a functional simulator.  This
functional simulator is the simplest, most user-friendly simulator in the
simplescalar tool set.  Unlike sim-fast, this functional simulator checks
for all instruction errors, and the implementation is crafted for clarity
rather than speed.

# -config                     # load configuration from a file
# -dumpconfig                 # dump configuration to a file
# -h                    false # print help message
# -v                    false # verbose operation
# -i                    false # start in Dlite debugger
-seed                       1 # random number generator seed (0 for timer seed)
# -q                    false # initialize and terminate immediately
# -chkpt               <null> # restore EIO trace execution from <fname>
# -redir:sim           <null> # redirect simulator output to file
(non-interactive only)
# -redir:prog          <null> # redirect simulated program output to file
-nice                       0 # simulator scheduling priority
-max:inst                   0 # maximum number of inst's to execute
-trigger:inst               0 # trigger instruction

sim: ** starting functional simulation **
warning: unsupported ioctl call: ioctl(21505, ...)
warning: unsupported ioctl call: ioctl(21505, ...)
hello world
sim: ** simulation statistics **
sim_num_insn                   5276 # total number of instructions executed
sim_num_uops                   7095 # total number of UOPs executed
sim_avg_flowlen              1.3448 # uops per instruction
sim_num_refs                   1259 # total number of loads and stores executed
sim_elapsed_time                  1 # total simulation time in seconds
sim_inst_rate             5276.0000 # simulation speed (in insts/sec)
ld_text_base           0x00008094 # program text (code) segment base
ld_text_bound          0x0000c54c # program text (code) segment bound
ld_text_size                  17592 # program text (code) size in bytes
ld_data_base           0x0000c54c # program initialized data segment base
ld_data_bound          0x000177d0 # program initialized data segment bound
ld_data_size                  45700 # program init'ed `.data' and
uninit'ed `.bss' size in bytes
ld_stack_base          0xc0000000 # program stack segment base
(highest address in stack)
ld_stack_size                 16384 # program initial stack size
ld_prog_entry          0x000080b0 # program entry point (initial PC)
ld_environ_base        0xbfffc000 # program environment base address address
ld_target_big_endian              0 # target executable endian-ness,
non-zero if big endian
mem.page_count                   11 # total number of pages allocated
mem.page_mem                    44k # total size of memory pages allocated
mem.ptab_misses                  11 # total first level page table misses
mem.ptab_accesses             63794 # total page table accesses
mem.ptab_miss_rate           0.0002 # first level page table miss rate

2. 將 GCC, Bintuils 及 uClibc 拉出來重新建置

這個段落主要是給需要修改到編譯器的屠龍人士看的，如果你只是要 ARM Toolchain 或著是要修改 Simulator 的話這段可以直接略過。

i. 建立一個要放等一下所有東西的資料夾

mkdir ~/arm-linux-gcc

ii. 把整串 toolchain 拉出來

cp -a buildroot-2012.08/output/host/usr ~/arm-linux-gcc/

iii. 資料夾重新命名為 arm-linux-gcc

mv ~/arm-linux-gcc/usr ~/arm-linux-gcc/arm-linux-gcc

iv. gcc, binutils, uclibc 等 source code 拉出來

cp -a buildroot-2012.08/output/toolchain/gcc-4.5.4 ~/arm-linux-gcc/
cp -a buildroot-2012.08/output/toolchain/uClibc-0.9.31.1/ ~/arm-linux-gcc/
tar -jxf buildroot-2012.08/dl/binutils-2.21.tar.bz2 -C ~/arm-linux-gcc

v. 建立 bulid-* 資料夾準備

cd ~/arm-linux-gcc
mkdir build-gcc
mkdir build-binutils

vi. 重新 build bintuils

cd build-binutils

vii. 開啟bintuils 的 config log 看一下怎麼下

vim ~/buildroot-2012.08/output/build/host-binutils-2.21/config.log

大約在第七行會有類似的東西

  $ ./configure --prefix=/home/kito/buildroot-2012.08/output/host/usr
--sysconfdir=/home/kito/buildroot-2012.08/output/host/etc
--enable-shared --disable-static --disable-multilib --disable-werror
--target=arm-unknown-linux-uclibc --disable-shared --enable-static
--with-sysroot=/home/kito/buildroot-2012.08/output/host/usr/arm-unknown-linux-uclibc/sysroot

viii. 產生新的 configure 參數

接著把 configure 中所有路徑更新一下, 然後 --sysconfdir 可以拿掉
note : 這邊路徑用我家示範，--prefix 跟 --with-sysroot 都要改

../binutils-2.21/configure
--prefix=/home/kito/arm-linux-gcc/arm-linux-gcc --enable-shared
--disable-static --disable-multilib --disable-werror
--target=arm-unknown-linux-uclibc --disable-shared --enable-static
--with-sysroot=/home/kito/arm-linux-gcc/arm-linux-gcc
/arm-unknown-linux-uclibc/sysroot

ix. 建置並安裝 buildroot

make -j8
make install

x. 重新 build gcc

cd build-gcc

xi. 偷看 buildroot config 怎麼下

~/arm-linux-gcc/arm-linux-gcc/bin/arm-linux-gcc -v

應該會吐出下面訊息，看到 Configured with: 那一段，抄過來修改

Using built-in specs.
COLLECT_GCC=/home/kito/buildroots/buildroot-2012.08/output/host/usr/bin/arm-linux-gcc
COLLECT_LTO_WRAPPER=/home/kito/buildroots/buildroot-2012.08/output/host/usr/libexec/gcc/arm-unknown-linux-uclibc/4.5.4/lto-wrapper
Target: arm-unknown-linux-uclibc
Configured with:
/home/kito/buildroots/buildroot-2012.08/output/toolchain/gcc-4.5.4/configure
--prefix=/home/kito/buildroots/buildroot-2012.08/output/host/usr
--build=x86_64-unknown-linux-gnu --host=x86_64-unknown-linux-gnu
--target=arm-unknown-linux-uclibc --enable-languages=c
--with-sysroot=/home/kito/buildroots/buildroot-2012.08/output/host/usr/arm-unknown-linux-uclibc/sysroot
--with-build-time-tools=/home/kito/buildroots/buildroot-2012.08/output/host/usr/arm-unknown-linux-uclibc/bin
--disable-__cxa_atexit --enable-target-optspace --disable-libquadmath
--disable-libgomp --with-gnu-ld --disable-libssp --disable-multilib
--disable-tls --enable-shared
--with-gmp=/home/kito/buildroots/buildroot-2012.08/output/host/usr
--with-mpfr=/home/kito/buildroots/buildroot-2012.08/output/host/usr
--with-mpc=/home/kito/buildroots/buildroot-2012.08/output/host/usr
--disable-nls --enable-threads --disable-decimal-float
--with-float=soft --with-abi=apcs-gnu --disable-largefile
--with-pkgversion='Buildroot 2012.08'
--with-bugurl=http://bugs.buildroot.net/
Thread model: posix
gcc version 4.5.4 (Buildroot 2012.08)

xii. 產生新的 gcc 的 configure 參數

接著把 configure 中所有路徑更新一下, 然後 --with-bugurl, --with-pkgversion 可以拿掉 build 跟 host 也可以拔掉，它會自己抓，這樣整串指令就不會太長
note1 : mpfr, gmp, mpc 如果你系統有裝的話可以使用系統的就好, 如果使用系統的話--with-gmp --with-mpfr --with-mpc 這三個可以拔掉
note2 : 這邊路徑用我家示範，--prefix --with-sysroot 跟 --with-build-time-tools= 都要改
note3 : 需要 g++ 的話，把--enable-languages=c 改成 --enable-languages=c,c++

../gcc-4.5.4/configure --prefix=/home/kito/arm-linux-gcc/arm-linux-gcc
--target=arm-unknown-linux-uclibc --enable-languages=c
--with-sysroot=/home/kito/arm-linux-gcc/arm-linux-gcc/arm-unknown-linux-uclibc/sysroot
--with-build-time-tools=/home/kito/arm-linux-gcc/arm-linux-gcc/arm-unknown-linux-uclibc/bin
--disable-__cxa_atexit --enable-target-optspace --disable-libquadmath
--disable-libgomp --with-gnu-ld --disable-libssp --disable-multilib
--disable-tls --enable-shared --disable-nls --enable-threads
--disable-decimal-float --with-float=soft --with-abi=apcs-gnu
--disable-largefile

xiii. 建置 gcc !

make! 另外注意一下 gcc 4.4 不支援 make -jx 的功能

make -j8
make install

xiv. 檢查 gcc

~/arm-linux-gcc/arm-linux-gcc/bin/arm-linux-gcc -v

輸出會跟第一次很像但 Configured with: 後面已經換成新的參數，這樣就代表有覆蓋掉舊的了

Using built-in specs.
COLLECT_GCC=/home/kito/arm-linux-gcc/arm-linux-gcc/bin/arm-linux-gcc
COLLECT_LTO_WRAPPER=/home/kito/arm-linux-gcc/arm-linux-gcc/libexec/gcc/arm-unknown-linux-uclibc/4.5.4/lto-wrapper
Target: arm-unknown-linux-uclibc
Configured with: ../gcc-4.5.4/configure
--prefix=/home/kito/arm-linux-gcc/arm-linux-gcc
--target=arm-unknown-linux-uclibc --enable-languages=c
--with-sysroot=/home/kito/arm-linux-gcc/arm-linux-gcc/arm-unknown-linux-uclibc/sysroot
--with-build-time-tools=/home/kito/arm-linux-gcc/arm-linux-gcc/arm-unknown-linux-uclibc/bin
--disable-__cxa_atexit --enable-target-optspace --disable-libquadmath
--disable-libgomp --with-gnu-ld --disable-libssp --disable-multilib
--disable-tls --enable-shared --disable-nls --enable-threads
--disable-decimal-float --with-float=soft --with-abi=apcs-gnu
--disable-largefile : (reconfigured) ../gcc-4.5.4/configure
--prefix=/home/kito/arm-linux-gcc/arm-linux-gcc
--target=arm-unknown-linux-uclibc --enable-languages=c,c++
--with-sysroot=/home/kito/arm-linux-gcc/arm-linux-gcc/arm-unknown-linux-uclibc/sysroot
--with-build-time-tools=/home/kito/arm-linux-gcc/arm-linux-gcc/arm-unknown-linux-uclibc/bin
--disable-__cxa_atexit --enable-target-optspace --disable-libquadmath
--disable-libgomp --with-gnu-ld --disable-libssp --disable-multilib
--disable-tls --enable-shared --disable-nls --enable-threads
--disable-decimal-float --with-float=soft --with-abi=apcs-gnu
--disable-largefile
Thread model: posix
gcc version 4.5.4 (GCC)

xv. 重新 build uClibc

cd ~/arm-linux-gcc/uClibc-0.9.31.1

xvi. 將 buildroot 中 linux header 複製過來

cp -a ~/buildroot-2012.08/output/toolchain/linux/ .

xvii. 更新 uClibc 組態

vim .config

# 修改以下地方

KERNEL_HEADERS="/home/kito/buildroot-2012.08/output/toolchain/linux/include"
改成
KERNEL_HEADERS="/home/kito/arm-linux-gcc/uClibc-0.9.31.1/linux/include"

RUNTIME_PREFIX="/"
改成
RUNTIME_PREFIX="/home/kito/arm-linux-gcc/arm-linux-gcc/"

DEVEL_PREFIX="/usr/"
改成
DEVEL_PREFIX="/home/kito/arm-linux-gcc/arm-linux-gcc/"

CROSS_COMPILER_PREFIX="/home/kito/buildroots/buildroot-2012.08/output/host/usr/bin/arm-unknown-linux-uclibc-"
改成
CROSS_COMPILER_PREFIX="/home/kito/arm-linux-gcc/arm-linux-gcc/bin/arm-unknown-linux-uclibc-"

# 然後存檔離開

xviii. 重新 build uClibc !

make -j8
make install

xix. 往後更動 gcc 步驟

大功告成，往後如果有更動到 gcc
uClibc 必須清掉重新 build 一次

make clean
make -j8
make install

LLVM 程式員手冊 - 重要及有用的 LLVM API

2012-10-30T15:28:00.000+08:00

重要跟有用的 LLVM API

這邊會列出一些有用且玩弄 LLVM 前最好知道的一些 LLVM API。

有關 isa<>, cast<> and dyn_cast<> templates

在 LLVM 大量的使用自製的 RTTI，這些 templates 的功能主要類似於 dynamic_cast<> operator，但是 LLVM 自製版本的沒有 C++ 內建版本的一些缺點 (主要是 dynamic_cast<> 只對於有 v-table _譯註1 的 class 有用，沒有就不能動)。在 LLVM 這類東西經常會用到，所以你最好知道它是怎麼運作的。所有相關的 template 都定義在 llvm/Support/Casting.h 這個檔案 (通常不用自己去 include 這檔案 _譯註2)

譯註1：一個 Class 只有在有 Virtual Function 的時候才會有 v-table ，所以換句話說，沒 Virtual Function 的 Class 家族就完全不能用 dynamic_cast<>

譯註2：幾乎每個 LLVM Header 都會 include 到它，所以基本上你也不用自己去 include

isa<>

isa<> operator 的功能就跟 Java 中的 instanceof operator一樣，它會根據你丟進去的 pointer 或 reference 並且檢查是不是你所預期的類別來回傳 true 或 false ，在許多情況下這傢伙很好用(下面有例子)

cast<>

cast<> operator 主要是拿來轉型用的，並且會作檢查，當你從父類別 (base class) 轉型到子類別 (derived class) 失敗的時候會直接 assertion failure 炸掉，所以只能在你非常確定它真的可以正確的向下轉型的時候使用，下面則是一個使用 isa<> 跟 cast<> template 的例子：

/* 檢查一個 Value 是不是 Loop Invariant */
static bool isLoopInvariant(const Value *V, const Loop *L) {
  if (isa<Constant>(V) || isa<Argument>(V) || isa<GlobalValue>(V))
    return true;

  /* 不是 Constant 、 Argument 或 GlobalValue 則一定是一個 Instruction
      如果不是存在該迴圈中則代表是 Loop Invariant */
  return !L->contains(cast<Instruction>(V)->getParent());
}

註：不要使用 isa<> 然後接著 cast<>，這種情況請直接使用 dyn_cast<> operator

dyn_cast<>

dyn_cast<> operator 主要是拿來轉型用的，並且會作檢查，當你從父類別 (base class) 轉型到子類別 (derived class) 失敗的時候會回傳 NULL pointer，所以上你不能餵 Reference 進去，而它整個功能就跟 C++ 的 dynamic_cast<> operator 非常類似，而且使用情境一樣，通常 dyn_cast<> operator 可以直接拿來塞在 if 判斷式或著是其它塞條件判斷式的地方，下面舉個例子：

/* 如果 Val 可以轉型成 AllocationInst */
if (AllocationInst *AI = dyn_cast<AllocationInst>(Val)) {
  /* ㄎㄎ，可以玩弄 AllocationInst 了 */
}

這樣子就可以有效的結合 isa<> 及 cast<> 變成一個 statement，方便吧～

註：dyn_cast<> operator 就像 C++ 的 dynamic_cast<> 或著是 Java 的 instanceof operator，常被濫用。千萬不要用一串的 dyn_cast<> + if/then/else 去檢查一堆類別。這種情況通常你可以直接用 InstVisitor 這個傢伙會比較方便又好看。

cast_or_null<>

cast_or_null<> operator 功能就跟 cast<> operator 一樣，唯一差別在於它可以塞 NULL pointer 進去，在某些情況下它還滿有用的。

dyn_cast_or_null<>

dyn_cast_or_null<> operator 功能就跟 dyn_cast<> operator 一樣，唯一差別在於它可以塞 NULL pointer 進去，在某些情況下它還滿有用的。

有關 isa<>, cast<> and dyn_cast<> templates 的結語

以上五個 template 能夠能來運作在任何 Class 上，不論它有沒有 v-table。如果你寫的 Class 也想要支援這些 template 的話參考這份文件： How to set up LLVM-style RTTI for your class hierarchy

字串傳遞 (StringRef 及 Twine Class)

雖然在 LLVM 中一般而言不用太多字串的操作，但在 LLVM 中一些重要的 API 參數中是用字串來傳遞，其中兩個重要的例子：

Value Class ：拿來命名指令或著函數之類的
StringMap Class ：在 LLVM 跟 Clang 經常被用到

這兩個 Class 基本上可以接受任何可能塞有 Null 字元的字串，不過它們不能直接轉換成 const char * 或著是 const string &，而許多 LLVM API 的參數通常是吃 StringRef 或著是 const Twine&。

The StringRef class

StringRef 是拿來表示常數字串(字元陣列加上一個長度)用的，支援許多 std::string 的操作，並且大部分不需要額外的 heap 空間。

它可以透過 Implicitly Constructor 來直接吃 C style null-terminated 字串或著是 std::string，或著是一個字元陣列加上一個長度。
例如 StringRef 的 find 函數宣告如下：

  iterator find(StringRef Key);

然後呼叫方可以用下面任意一個方式呼叫

  Map.find("foo");                 // Lookup "foo"
  Map.find(std::string("bar"));    // Lookup "bar"
  Map.find(StringRef("\0baz", 4)); // Lookup "\0baz"

而通常 API 也是回傳 StringRef ，如果你需要轉換成 std::string 的話要使用 str 函數詳細的資訊自己去爬一下llvm/ADT/StringRef.h。

大部分情況下請直接使用 StringRef ，主要是它字串跟物件本身是分離的，也因此在 LLVM 程式碼或 API 中可以發現它幾乎都是直接 pass by value 傳遞。

Twine Class

Twine Class 是一個高效能的字串串接 API。例如在 LLVM 慣例中指令名稱的結尾通常是令一個指令的名稱，範例如下：

    New = CmpInst::Create(..., SO->getName() + ".cmp");

而 Twine Class 則是一個高效率且輕量級建立於 stack 上的 rope _譯註1，Twine 可以由兩個字串的 operator+ 來隱式建構（例如 C-style strings, std::string 或著是 StringRef）。Twine 主要把實際的字串串接動作延遲到實際要需要的時候才進行，這樣可以有效避免不必要中間暫存結果的 Heap 分配_譯註2。詳細可以去挖 llvm/ADT/Twine.h 檔案來啃。

如果是跟 StringRef 互動的話 Twine只會紀錄指標並且幾乎不需要額外的記憶體，他們兩_譯註3主要就是設計來快速有效的傳遞串接字串。

譯註1：一種拿來實作大量字串儲存的資料結構，詳見 wiki 說明 Rope
譯註2：直接看下面範例可以了解 Twine 省了啥：

/* 僅紀錄 abc 及 def 的 pointer, 不實際進行串接動作 */
Twine t1 = "abc" + "def";

/* Twine t1 跟 const char * "xyz" 串接, 但也不進行實際串接動作 */
Twine t2 = t1 + "xyz";

/* 實際到需要的時候內部才會進行串接動作!, 可避免到中間 abcdef 這個暫存字串出現 */
std::cout << t2.str();

譯註3：指 StringRef 跟 Twine 這對好兄弟

DEBUG() macro 跟 -debug 選項

通常在撰寫你的 pass 的時候你會放一堆拿來 debug 用的輸出程式碼，當它正式運作的時候又會想砍掉那串，但等到某天你發現它有 bug 或著是又要開始寫新功能的時候又要加進去那串 debug 用的輸出程式碼。。。

所以很自然的你會不希望砍掉那堆程式碼，但你又不想要它隨時的輸出一堆訊息，一些常見的作法就是把它註解掉，然後要的時候又把那個註解拿掉_譯註1。

譯註1：直接看下面 code

/* 例如把輸出的部份用個 ifdef 包裝 */
#ifdef DEBUG
 fprintf(stderr, "Debug Debug Debug");
#endif

/* 或著好看一點用 marco 包起來 */
#ifdef DEBUG
#define D(arg...) fprintf(stderr, __VA_ARGS__)
#else
#define D(arg...)
#endif

D("Debug Debug Debug");

在 "llvm/Support/Debug.h" 這個檔案中提供了一個 DEBUG() 來漂亮的解決這一類的問題，基本上你可以塞任何程式碼到 DEBUG 當參數，而包在裡面的程式碼只會在執行 opt 加上 -debug 參數的時候會吐出東西：

  DEBUG(errs() << "媽!我在這裡!\n");

所以你可以像這樣去跑你的 pass ：

$ opt < a.bc > /dev/null -mypass
<沒有輸出>
$ opt < a.bc > /dev/null -mypass -debug
媽!我在這裡!

使用 DEBUG() Marco 取代自幹解法讓你不用弄一堆命令列參數_譯註2，在你使用最佳化類型建置 LLVM 時，DEBUG() Marco 則會整個關閉，進而不會影響任何的效能（所以你也不要在 DEBUG 裡面有 side-effects_譯註3！）。

譯註2：GCC 就是這樣幹。。。內部使用的 Debug 命令列參數無敵多。。。可以去 <gcc-source>/gcc/common.opt 參觀所有的命令列列表XD…

譯註3：大致上就是都不要更動到任何變數的值，不論區域或全域。

另一個 DEBUG() Marco 的方便東東就是當你在 gdb 中 debug LLVM 的時候只要輸入 "set DebugFlag=0" 或著是 "set DebugFlag=1" 就可以控制 DEBUG 的開關。

使用 DEBUG_TYPE 及 -debug-only 選項來細部控制 debug 資訊

有些時候你只想要 debug 自己的程式，而 -debug 又吐出全世界的錯誤訊息（例如在 Code Gen 的階段的時候），如果你想要細部控制 debug 資訊的話你就需要定義 DEBUG_TYPE 這個 marco 以及 -debug-only 選項，下面是使用範例：

#undef  DEBUG_TYPE
DEBUG(errs() << "No debug type\n");
#define DEBUG_TYPE "foo"
DEBUG(errs() << "'foo' debug type\n");
#undef  DEBUG_TYPE
#define DEBUG_TYPE "bar"
DEBUG(errs() << "'bar' debug type\n"));
#undef  DEBUG_TYPE
#define DEBUG_TYPE ""
DEBUG(errs() << "No debug type (2)\n");

然後接著你可以這樣跑你的 pass ：

$ opt < a.bc > /dev/null -mypass
<沒有輸出>
$ opt < a.bc > /dev/null -mypass -debug
No debug type
'foo' debug type
'bar' debug type
No debug type (2)
$ opt < a.bc > /dev/null -mypass -debug-only=foo
'foo' debug type
$ opt < a.bc > /dev/null -mypass -debug-only=bar
'bar' debug type

當然在實務上你只需要再程式碼的最上方定義 DEBUG_TYPE 即可，這樣就可以為你的整個模組定義 debug type，（記得要放在#include "llvm/Support/Debug.h" 之前，通常你應該不會想用到醜不拉機的 #undef），然後最好把名稱取的有意義一點，不要用 foo 或 bar 這類沒營養的名字，主要是因為目前沒有任何機制去避免 DEBUG_TYPE 撞名的問題，如果兩個不同的模組使用同樣的 DEBUG_TYPE 名稱，則它們會被一起啟動，例如所有在 instruction scheduling 的 debug 資訊都會在 -debug-type=InstrSched 的時候一起噴出來，而那堆程式碼是散落在許多檔案當中。

DEBUG_WITH_TYPE 這個 Marco 則可以用在你想為某些 DEBUG 資訊設定特定 DEBUG_TYPE 時可以用，這個 Marco 比 DEBUG 多一個參數，第一個參數可以指定 DEBUG_TYPE，下面則是它的使用範例：

DEBUG_WITH_TYPE("", errs() << "No debug type\n");
DEBUG_WITH_TYPE("foo", errs() << "'foo' debug type\n");
DEBUG_WITH_TYPE("bar", errs() << "'bar' debug type\n"));
DEBUG_WITH_TYPE("", errs() << "No debug type (2)\n");

Statistic Class 及 -stats 選項

在 llvm/ADT/Statistic.h 這個檔案中提供一個叫做 Statistic 的 Class，他是專門拿來提供 LLVM 來紀錄各種最佳化對於程式有無實質上的改進。

你會在你的 pass 中處理一些東西，然後通常你會對於某些最佳畫到底執行幾次感興趣，雖然你可以直接在某些重要的函數中插入一些 code 去統計，但這樣的方式實在是有點鳥，而使用 Statistic Class 則可以讓你可以很簡單的去追蹤一些資訊，然後統一的在 pass 執行完後輸出。

下面是一些使用 Statistic class 的範例，他們基本上可以這樣用：

定義一個你的 statistic ：

#define DEBUG_TYPE "mypassname"   // 這行 code 記得塞在所有 #include 前面
STATISTIC(NumXForms, "The # of times I did stuff");

STATISTIC Macro 定義了一個全域的靜態變數，其變數名稱如第一個參數，然後這個 Pass 的名稱它會直接從 DEBUG_TYPE 拿，它的描述則是放在第二個參數，這個變數實際上就像是個 unsigned integer 一當你要執行一些最佳化或轉換的時候，遞增一下這個變數：

++NumXForms;   // 我做了某些事!

然後接著你只要在執行 opt 時加入 -stats 參數：

$ opt -stats -mypassname < program.bc > /dev/null
... statistics output ...

當你用 opt 跑某些測試時他會出現類似下面的統計報告：

   7646 bitcodewriter   - Number of normal instructions
    725 bitcodewriter   - Number of oversized instructions
 129996 bitcodewriter   - Number of bitcode bytes written
   2817 raise           - Number of insts DCEd or constprop'd
   3213 raise           - Number of cast-of-self removed
   5046 raise           - Number of expression trees converted
     75 raise           - Number of other getelementptr's formed
    138 raise           - Number of load/store peepholes
     42 deadtypeelim    - Number of unused typenames removed from symtab
    392 funcresolve     - Number of varargs functions resolved
     27 globaldce       - Number of global variables removed
      2 adce            - Number of basic blocks removed
    134 cee             - Number of branches revectored
     49 cee             - Number of setcc instruction eliminated
    532 gcse            - Number of loads removed
   2919 gcse            - Number of instructions removed
     86 indvars         - Number of canonical indvars added
     87 indvars         - Number of aux indvars removed
     25 instcombine     - Number of dead inst eliminate
    434 instcombine     - Number of insts combined
    248 licm            - Number of load insts hoisted
   1298 licm            - Number of insts hoisted to a loop pre-header
      3 licm            - Number of insts hoisted to multiple loop preds (bad, no loop pre-header)
     75 mem2reg         - Number of alloca's promoted
   1444 cfgsimplify     - Number of blocks simplified

由上面的統計輸出可以看出，程式執行了許多最佳化，而統一的界面讓這件事變得很容易，在你的 pass 中使用這個統一的界面將會使得你的程式碼更好維護！

在 Debug 程式的時候觀看某些 Graph

在 LLVM 當中許多重要的資料結構都是 Graph：例如 CFG 由一堆 Basic Block 組成，在 Instruction Selection 時使用的 DAG，在對 Compiler 除錯的情況下，如果能視覺化的看到內部的 Graph 則會使得除錯變得容易許多。

LLVM 提供許多的 Callback 提供 Debug 的時候用，例如你呼叫 Function::viewCFG() 這個函數，目前的 LLVM 會跳出一個視窗上面畫有該函數精美的 CFG，圖中的節點還會放置著 Basic Block 中的所有指令，而 Function::viewCFGOnly() 則可以讓你只看 Basic Block，不要顯示裡面的指令，類似的東西還有 MachineFunction::viewCFG() ， MachineFunction::viewCFGOnly() 以及SelectionDAG::viewGraph() 這幾個函數，在 GDB 中你只要使用 DAG.viewGraph() 就會跳出視窗並且顯示出來，所以你也可以試著將那些函數呼叫塞到你正在 Debug 的部份。

要讓這個功能動起來事實上你可能需要一些額外的設定，例如在 Unix-linke 系統上需要安裝 graphviz 套件，並且確定 dot 跟 gv 這兩隻程是在你的 PATH 中，如果你在 Mac OS/X 的話，可以下載並安裝 Mac OS/X 的 graphviz 套件，然後加到 /Applications/Graphviz.app/Contents/MacOS/ （或任何你安裝的地方）到你的 PATH，一旦你系統的 PATH 設定好，在重新執行一次 LLVM configure script，並且重新建置 LLVM 就可以啟動這個好用的功能了！

SelectionDAG 部份則有一些方便你定位 Graph 中某些 Node 的功能，在 GDB 中如果你先呼叫 DAG.setGraphColor(node, "color")，再呼叫 DAG.viewGraph() 就會將你想看的 Node 標上指定的顏色（你可以在這個網頁找到color 的列表），事實上你還可以呼叫 DAG.setGraphAttrs(node, "attributes") 更詳細的去設定 Node 的屬性（可參考graphviz 的網頁），如果你想要回復預設 Graph 屬性的話可以呼叫DAG.clearGraphAttrs() 。

LLVM 程式員手冊 - 簡介及背景知識

2012-10-30T12:05:00.000+08:00

簡介

這份文件主要列出一些 LLVM 中重要的類別跟界面，而這邊並不會解釋 LLVM 是甚麼東西，它內部怎麼運作以及 LLVM 的程式碼看起來如何。對於本文件的閱讀者我們假設你對於 LLVM 已經有一些基礎的了解，並且對於寫最佳化、分析或玩弄程式碼有興趣。

這份文件主要引導你如何擴充 LLVM 來達到你想要作的事。另外閱讀這份文件並不能取代啃 Source Code。如果你想看某個 Class 有哪些 Method 並且在幹嘛，那建議可以直接去看線上 doxygen 文件比較符合你的需求。
接下來的第一個章節主要介紹一些背景知識，第二章節則列出一些 LLVM 中核心的一些 Class ，未來這份文件會撰寫有關如何擴充整個 LLVM ，例如使用 Dominator 的資訊， Control Flow Graph 的走訪以及一些有用的小工具例如 InstVisitor template。

背景知識

這個章節放了一些有幫助你玩弄 LLVM 相關資訊的連結，但裡面沒提到 LLVM 相關的 API。

譯註：會寫 C++ 的話直接跳過吧，另外沒用過 STL 的話不算在會 C++ 的範圍內

The C++ Standard Template Library

LLVM 大量使用 C++ 的 Standard Template Library (STL)，所以基本上你需要一些對於 C++ STL 的基礎知識以及一些相關使用慣例，下面提供一些相關資訊的連結可以給你惡補一下。
下面是惡補專區：

C++ Library Dinkumware C++ Library reference - an excellent reference for the STL and other parts of the standard C++ library.
C++ In a Nutshell - This is an O'Reilly book in the making. It has a decent Standard Library Reference that rivals Dinkumware's, and is unfortunately no longer free since the book has been published.
C++ Frequently Asked Questions
SGI's STL Programmer's Guide - Contains a useful Introduction to the STL.
Bjarne Stroustrup's C++ Page
Bruce Eckel's Thinking in C++, 2nd ed. Volume 2 Revision 4.0

開始玩弄 LLVM 前最好也先閱讀一下 LLVM Coding Standards guide ，這份文件主要是讓你寫出好維護又好讀的 Code，而不是去規定你 { 跟 } 要怎麼放。

其它有用的連結

Using static and shared libraries across platforms

ARMv8 (AArch64) Instruction Encoding

2012-10-24T19:41:00.000+08:00

不明原因官方到現在還沒放詳細的 Instruction Encoding 文件

以下是由 ARM 在 binutils 裡面的 binutils/opcodes/aarch64-gen.c 所產生出來的表格

x 是 don't care bit
其它字母則看後面 Operand 可以猜

msb                                 lsb
xx01 1110 xx1x xxx0 1011 10nn nnnd dddd  -  abs Sd Sn     
xx00 1110 xx1x xxx0 1011 10nn nnnd dddd  -  abs Vd Vn     
x001 1010 000m mmmm xxxx 00nn nnnd dddd  -  adc Rd Rn Rm    
x011 1010 000m mmmm xxxx 00nn nnnd dddd  -  adcs Rd Rn Rm    
x100 1110 xx1m mmmm 0100 00nn nnnd dddd  -  addhn2 Vd Vn Vm    
x000 1110 xx1m mmmm 0100 00nn nnnd dddd  -  addhn Vd Vn Vm    
xxx1 1110 xx11 xxx1 1011 10nn nnnd dddd  -  addp Sd Vn     
xxx0 1110 xx1m mmmm 1011 11nn nnnd dddd  -  addp Vd Vn Vm    
x000 1011 xx0x xxxx xxxx xxnn nnnd dddd  -  add Rd Rn Rm_SFT    
x00x 0001 SSii iiii iiii iinn nnnd dddd  -  add Rd_SP Rn_SP AIMM    
x000 1011 0x1x xxxx xxxx xxnn nnnd dddd  -  add Rd_SP Rn_SP Rm_EXT    
x101 1110 xx1m mmmm x000 01nn nnnd dddd  -  add Sd Sn Sm    
x010 1011 xx0x xxxx xxxx xxnn nnnd dddd  -  adds Rd Rn Rm_SFT    
x01x 0001 SSii iiii iiii iinn nnnd dddd  -  adds Rd Rn_SP AIMM    
x010 1011 0x1x xxxx xxxx xxnn nnnd dddd  -  adds Rd Rn_SP Rm_EXT    
xx00 1110 xx1m mmmm 1000 01nn nnnd dddd  -  add Vd Vn Vm    
xxx0 1110 xx11 xxx1 1011 10nn nnnd dddd  -  addv Fd Vn     
1iix 0000 iiii iiii iiii iiii iiid dddd  -  adrp Rd ADDR_ADRP     
0iix 0000 iiii iiii iiii iiii iiid dddd  -  adr Rd ADDR_PCREL21     
xxx0 1110 xx1x 1xxx 0101 10nn nnnd dddd  -  aesd Vd Vn     
xxx0 1110 xx1x 1xx0 0100 10nn nnnd dddd  -  aese Vd Vn     
xxx0 1110 xx1x 1xx0 0111 10nn nnnd dddd  -  aesimc Vd Vn     
xxx0 1110 xx1x 1xx0 0110 10nn nnnd dddd  -  aesmc Vd Vn     
x000 1010 xx0x xxxx xxxx xxnn nnnd dddd  -  and Rd Rn Rm_SFT    
x00x 0010 0Nii iiii iiii iinn nnnd dddd  -  and Rd_SP Rn LIMM    
x11x 0010 0Nii iiii iiii iinn nnnd dddd  -  ands Rd Rn LIMM    
x110 1010 xx0x xxxx xxxx xxnn nnnd dddd  -  ands Rd Rn Rm_SFT    
xx00 1110 001m mmmm 0001 11nn nnnd dddd  -  and Vd Vn Vm    
xxx1 1010 1x0m mmmm xx1x 10nn nnnd dddd  -  asrv Rd Rn Rm    
000x 01ii iiii iiii iiii iiii iiii iiii  -  b ADDR_PCREL26      
010x 0100 iiii iiii iiii iiii iiix xxxx  -  b.c ADDR_PCREL19      
xx1x 0011 0xii iiii iiii iinn nnnd dddd  -  bfm Rd Rn IMMR IMMS   
x00x 1010 xx1x xxxx xxxx xxnn nnnd dddd  -  bic Rd Rn Rm_SFT    
x11x 1010 xx1x xxxx xxxx xxnn nnnd dddd  -  bics Rd Rn Rm_SFT    
xx10 1111 xxxx xxxx 0xx1 x1xx xxxd dddd  -  bic Vd SIMD_IMM_SFT     
xx10 1111 xxxx xxxx 10x1 01xx xxxd dddd  -  bic Vd SIMD_IMM_SFT     
xx00 1110 011m mmmm 0001 11nn nnnd dddd  -  bic Vd Vn Vm    
xx10 1110 111m mmmm 0001 11nn nnnd dddd  -  bif Vd Vn Vm    
xx10 1110 101m mmmm 0001 11nn nnnd dddd  -  bit Vd Vn Vm    
100x 01ii iiii iiii iiii iiii iiii iiii  -  bl ADDR_PCREL26      
x10x 0110 0x1x xxxx xxxx xxnn nnnx xxxx  -  blr Rn      
110x 0100 xx1i iiii iiii iiii iiix xx00  -  brk EXCEPTION      
x10x 0110 000x xxxx xxxx xxnn nnnx xxxx  -  br Rn      
xx10 1110 011m mmmm 0001 11nn nnnd dddd  -  bsl Vd Vn Vm    
xx1x 0101 iiii iiii iiii iiii iiit tttt  -  cbnz Rt ADDR_PCREL19     
xx1x 0100 iiii iiii iiii iiii iiit tttt  -  cbz Rt ADDR_PCREL19     
x0x1 1010 0x0i iiii xxxx 10nn nnnx cccc  -  ccmn Rn CCMP_IMM NZCV COND   
x0x1 1010 010m mmmm xxxx 00nn nnnx cccc  -  ccmn Rn Rm NZCV COND   
x1x1 1010 0x0i iiii xxxx 10nn nnnx cccc  -  ccmp Rn CCMP_IMM NZCV COND   
x1x1 1010 010m mmmm xxxx 00nn nnnx cccc  -  ccmp Rn Rm NZCV COND   
x10x 01x1 xxx0 0xxx xxx1 mmmm 010x xxxx  -  clrex UIMM4      
xxx1 1010 x10x xxxx xxx1 01nn nnnd dddd  -  cls Rd Rn     
xx00 1110 xx1x 0xx0 0100 10nn nnnd dddd  -  cls Vd Vn     
xxx1 1010 110x xxxx xxx1 00nn nnnd dddd  -  clz Rd Rn     
xx10 1110 xx1x 0xx0 0100 10nn nnnd dddd  -  clz Vd Vn     
xx01 1110 xx1x xxx0 1001 10nn nnnd dddd  -  cmeq Sd Sn IMM0    
xx11 1110 xx1m mmmm 1000 11nn nnnd dddd  -  cmeq Sd Sn Sm    
xx00 1110 xx1x xxx0 1001 10nn nnnd dddd  -  cmeq Vd Vn IMM0    
xx10 1110 xx1m mmmm 1000 11nn nnnd dddd  -  cmeq Vd Vn Vm    
xx11 1110 xx1x xxxx 1000 10nn nnnd dddd  -  cmge Sd Sn IMM0    
x101 1110 xx1m mmmm x011 11nn nnnd dddd  -  cmge Sd Sn Sm    
xx10 1110 xx1x xxx0 1000 10nn nnnd dddd  -  cmge Vd Vn IMM0    
xx00 1110 xx1m mmmm 0011 11nn nnnd dddd  -  cmge Vd Vn Vm    
x101 1110 xx1x xxxx 1000 10nn nnnd dddd  -  cmgt Sd Sn IMM0    
x101 1110 xx1m mmmm 0x11 01nn nnnd dddd  -  cmgt Sd Sn Sm    
xx00 1110 xx1x xxx0 1000 10nn nnnd dddd  -  cmgt Vd Vn IMM0    
xx00 1110 xx1m mmmm 0011 01nn nnnd dddd  -  cmgt Vd Vn Vm    
xx11 1110 xx1m mmmm 0x11 01nn nnnd dddd  -  cmhi Sd Sn Sm    
xx10 1110 xx1m mmmm 0011 01nn nnnd dddd  -  cmhi Vd Vn Vm    
xx11 1110 xx1m mmmm xx11 11nn nnnd dddd  -  cmhs Sd Sn Sm    
xx10 1110 xx1m mmmm 0011 11nn nnnd dddd  -  cmhs Vd Vn Vm    
xx11 1110 xx1x xxx0 1001 10nn nnnd dddd  -  cmle Sd Sn IMM0    
xx10 1110 xx1x xxx0 1001 10nn nnnd dddd  -  cmle Vd Vn IMM0    
xxx1 1110 xx10 xxx0 1010 10nn nnnd dddd  -  cmlt Sd Sn IMM0    
xxx0 1110 xx10 xxx0 1010 10nn nnnd dddd  -  cmlt Vd Vn IMM0    
x101 1110 xx1m mmmm 1000 11nn nnnd dddd  -  cmtst Sd Sn Sm    
xx00 1110 xx1m mmmm 1000 11nn nnnd dddd  -  cmtst Vd Vn Vm    
xx00 1110 xx1x 0xxx 0101 10nn nnnd dddd  -  cnt Vd Vn     
x0x1 1010 100m mmmm xxxx 00nn nnnd dddd  -  csel Rd Rn Rm COND   
x0x1 1010 x00m mmmm xxxx 01nn nnnd dddd  -  csinc Rd Rn Rm COND   
x1x1 1010 100m mmmm xxxx 00nn nnnd dddd  -  csinv Rd Rn Rm COND   
x1x1 1010 x00m mmmm xxxx 01nn nnnd dddd  -  csneg Rd Rn Rm COND   
110x 0100 xx1i iiii iiii iiii iiix xx01  -  dcps1 EXCEPTION      
110x 0100 xx1i iiii iiii iiii iiix xx10  -  dcps2 EXCEPTION      
110x 0100 xx1i iiii iiii iiii iiix xx11  -  dcps3 EXCEPTION      
x10x 01x1 xxx0 0xxx xxx1 xxxx xx1x xxxx  -  dmb BARRIER      
x10x 0110 1x1x xxxx xxxx xxxx xxxx xxxx  -  drps       
x10x 01x1 xxx0 0xxx xxx1 xxxx x00x xxxx  -  dsb BARRIER      
x1x1 1110 xx0x xxxx xxxx x1nn nnnd dddd  -  dup Sd En     
xx00 1110 xx0x xxxx xxxx 01nn nnnd dddd  -  dup Vd En     
xx00 1110 xx0x xxxx xx00 11nn nnnd dddd  -  dup Vd Rn     
x10x 1010 xx1x xxxx xxxx xxnn nnnd dddd  -  eon Rd Rn Rm_SFT    
x100 1010 xx0x xxxx xxxx xxnn nnnd dddd  -  eor Rd Rn Rm_SFT    
x10x 0010 0Nii iiii iiii iinn nnnd dddd  -  eor Rd_SP Rn LIMM    
xx10 1110 001m mmmm 0001 11nn nnnd dddd  -  eor Vd Vn Vm    
x10x 0110 100x xxxx xxxx xxxx xxxx xxxx  -  eret       
xxxx 0011 1xxm mmmm iiii iinn nnnd dddd  -  extr Rd Rn Rm IMMS   
xx10 1110 xx0m mmmm xiii i0nn nnnd dddd  -  ext Vd Vn Vm IDX   
xx11 1110 xx1m mmmm 1x01 01nn nnnd dddd  -  fabd Sd Sn Sm    
xx10 1110 1x1m mmmm 1101 01nn nnnd dddd  -  fabd Vd Vn Vm    
xxx1 1110 xx1x x000 1100 00nn nnnd dddd  -  fabs Fd Fn     
xx0x 1110 xx10 xxx0 1111 10nn nnnd dddd  -  fabs Vd Vn     
xx11 1110 0x1m mmmm x110 11nn nnnd dddd  -  facge Sd Sn Sm    
xxx0 1110 0x1m mmmm 1110 11nn nnnd dddd  -  facge Vd Vn Vm    
xx11 1110 1x1m mmmm x110 11nn nnnd dddd  -  facgt Sd Sn Sm    
xxx0 1110 1x1m mmmm 1110 11nn nnnd dddd  -  facgt Vd Vn Vm    
x001 1110 xx1m mmmm 0010 10nn nnnd dddd  -  fadd Fd Fn Fm    
xxxx 1110 xx11 xxx0 1101 10nn nnnd dddd  -  faddp Sd Vn     
xx10 1110 0x1m mmmm 1101 01nn nnnd dddd  -  faddp Vd Vn Vm    
xx00 1110 0x1m mmmm 1101 01nn nnnd dddd  -  fadd Vd Vn Vm    
x001 1110 xx1m mmmm xxxx 01nn nnn1 cccc  -  fccmpe Fn Fm NZCV COND   
x001 1110 xx1m mmmm xxxx 01nn nnn0 cccc  -  fccmp Fn Fm NZCV COND   
xx01 1110 xx10 xxx0 1101 10nn nnnd dddd  -  fcmeq Sd Sn IMM0    
x101 1110 xx1m mmmm xx10 01nn nnnd dddd  -  fcmeq Sd Sn Sm    
xx00 1110 xx10 xxx0 1101 10nn nnnd dddd  -  fcmeq Vd Vn IMM0    
xx00 1110 0x1m mmmm 1110 01nn nnnd dddd  -  fcmeq Vd Vn Vm    
xx11 1110 xx10 xxx0 1100 10nn nnnd dddd  -  fcmge Sd Sn IMM0    
xx11 1110 0x1m mmmm xx10 01nn nnnd dddd  -  fcmge Sd Sn Sm    
xx10 1110 xx10 xxx0 1100 10nn nnnd dddd  -  fcmge Vd Vn IMM0    
xx10 1110 0x1m mmmm 1110 01nn nnnd dddd  -  fcmge Vd Vn Vm    
xx01 1110 xx10 xxx0 1100 10nn nnnd dddd  -  fcmgt Sd Sn IMM0    
xx11 1110 1x1m mmmm xx10 01nn nnnd dddd  -  fcmgt Sd Sn Sm    
xx00 1110 xx10 xxx0 1100 10nn nnnd dddd  -  fcmgt Vd Vn IMM0    
xxx0 1110 1x1m mmmm 1110 01nn nnnd dddd  -  fcmgt Vd Vn Vm    
xx11 1110 xx10 xxx0 1101 10nn nnnd dddd  -  fcmle Sd Sn IMM0    
xx10 1110 xx10 xxx0 1101 10nn nnnd dddd  -  fcmle Vd Vn IMM0    
xxx1 1110 xx1x xxxx 1110 10nn nnnd dddd  -  fcmlt Sd Sn IMM0    
xxx0 1110 xx1x xxxx 1110 10nn nnnd dddd  -  fcmlt Vd Vn IMM0    
xxx1 1110 xx1m mmmm 0010 00nn nnn1 0xxx  -  fcmpe Fn Fm     
xxx1 1110 xx1x xxxx 0010 00nn nnn1 1xxx  -  fcmpe Fn FPIMM0     
xxx1 1110 xx1m mmmm 0010 00nn nnn0 0xxx  -  fcmp Fn Fm     
xxx1 1110 xx1x xxxx 0010 00nn nnn0 1xxx  -  fcmp Fn FPIMM0     
x001 1110 xx1m mmmm xxxx 11nn nnnd dddd  -  fcsel Fd Fn Fm COND   
xxx1 1110 xx1x x100 0000 00nn nnnd dddd  -  fcvtas Rd Fn     
xx01 1110 0x1x xxx1 1100 10nn nnnd dddd  -  fcvtas Sd Sn     
xx00 1110 0x1x xxx1 1100 10nn nnnd dddd  -  fcvtas Vd Vn     
xxx1 1110 xx1x x101 0000 00nn nnnd dddd  -  fcvtau Rd Fn     
xx11 1110 0x1x xxx1 1100 10nn nnnd dddd  -  fcvtau Sd Sn     
xx10 1110 0x1x xxx1 1100 10nn nnnd dddd  -  fcvtau Vd Vn     
xxx1 1110 xx1x x01x x100 00nn nnnd dddd  -  fcvt Fd Fn     
x1x0 1110 xx1x xxx1 0111 10nn nnnd dddd  -  fcvtl2 Vd Vn     
x0x0 1110 xx1x xxx1 0111 10nn nnnd dddd  -  fcvtl Vd Vn     
xxx1 1110 xx11 0000 0000 00nn nnnd dddd  -  fcvtms Rd Fn     
xx01 1110 0x10 xxx1 1011 10nn nnnd dddd  -  fcvtms Sd Sn     
xx00 1110 0x10 xxx1 1011 10nn nnnd dddd  -  fcvtms Vd Vn     
xxx1 1110 xx11 0001 0000 00nn nnnd dddd  -  fcvtmu Rd Fn     
xx11 1110 0x10 xxx1 1011 10nn nnnd dddd  -  fcvtmu Sd Sn     
xx10 1110 0x10 xxx1 1011 10nn nnnd dddd  -  fcvtmu Vd Vn     
x100 1110 xx1x xxx1 0110 10nn nnnd dddd  -  fcvtn2 Vd Vn     
xxx1 1110 xx10 0000 0000 00nn nnnd dddd  -  fcvtns Rd Fn     
xx01 1110 0x10 xxx1 1010 10nn nnnd dddd  -  fcvtns Sd Sn     
xx00 1110 0x10 xxx1 1010 10nn nnnd dddd  -  fcvtns Vd Vn     
xxx1 1110 xx10 0001 0000 00nn nnnd dddd  -  fcvtnu Rd Fn     
xx11 1110 0x10 xxx1 1010 10nn nnnd dddd  -  fcvtnu Sd Sn     
xx10 1110 0x10 xxx1 1010 10nn nnnd dddd  -  fcvtnu Vd Vn     
x000 1110 xx1x xxx1 0110 10nn nnnd dddd  -  fcvtn Vd Vn     
xxx1 1110 xx10 1000 0000 00nn nnnd dddd  -  fcvtps Rd Fn     
xx01 1110 1x10 xxx1 1010 10nn nnnd dddd  -  fcvtps Sd Sn     
xx00 1110 1x10 xxx1 1010 10nn nnnd dddd  -  fcvtps Vd Vn     
xxx1 1110 xx10 1001 0000 00nn nnnd dddd  -  fcvtpu Rd Fn     
xx11 1110 1x10 xxx1 1010 10nn nnnd dddd  -  fcvtpu Sd Sn     
xx10 1110 1x10 xxx1 1010 10nn nnnd dddd  -  fcvtpu Vd Vn     
x110 1110 xx1x xxx1 0110 10nn nnnd dddd  -  fcvtxn2 Vd Vn     
xx11 1110 xx1x xxxx 0110 10nn nnnd dddd  -  fcvtxn Sd Sn     
x010 1110 xx1x xxx1 0110 10nn nnnd dddd  -  fcvtxn Vd Vn     
xxx1 1110 xx11 1000 0000 00nn nnnd dddd  -  fcvtzs Rd Fn     
x0x1 1110 xx0x xx00 SSSS SSnn nnnd dddd  -  fcvtzs Rd Fn FBITS    
xx01 1110 1x10 xxx1 1011 10nn nnnd dddd  -  fcvtzs Sd Sn     
x101 1111 xxxx xxxx 1x1x 11nn nnnd dddd  -  fcvtzs Sd Sn IMM_VLSR    
xx00 1110 1x10 xxx1 1011 10nn nnnd dddd  -  fcvtzs Vd Vn     
xx00 1111 xxxx xxxx 1x11 11nn nnnd dddd  -  fcvtzs Vd Vn IMM_VLSR    
xxx1 1110 xx11 1001 0000 00nn nnnd dddd  -  fcvtzu Rd Fn     
x0x1 1110 xx0x xx01 SSSS SSnn nnnd dddd  -  fcvtzu Rd Fn FBITS    
xx11 1110 1x10 xxx1 1011 10nn nnnd dddd  -  fcvtzu Sd Sn     
xx11 1111 xxxx xxxx 1x11 11nn nnnd dddd  -  fcvtzu Sd Sn IMM_VLSR    
xx10 1110 1x10 xxx1 1011 10nn nnnd dddd  -  fcvtzu Vd Vn     
xx10 1111 xxxx xxxx 1x11 11nn nnnd dddd  -  fcvtzu Vd Vn IMM_VLSR    
x0x1 1110 xx1m mmmm 0001 10nn nnnd dddd  -  fdiv Fd Fn Fm    
xx10 1110 0x1m mmmm 1111 11nn nnnd dddd  -  fdiv Vd Vn Vm    
x001 1111 xx0m mmmm 0aaa aann nnnd dddd  -  fmadd Fd Fn Fm Fa   
x001 1110 xx1m mmmm 0100 10nn nnnd dddd  -  fmax Fd Fn Fm    
xx01 1110 xx1m mmmm 0110 10nn nnnd dddd  -  fmaxnm Fd Fn Fm    
xxx1 1110 0x11 xxx0 1100 10nn nnnd dddd  -  fmaxnmp Sd Vn     
xx10 1110 0x1m mmmm 1100 01nn nnnd dddd  -  fmaxnmp Vd Vn Vm    
xx00 1110 0x1m mmmm 1100 01nn nnnd dddd  -  fmaxnm Vd Vn Vm    
xxx0 1110 0x11 xxx0 1100 10nn nnnd dddd  -  fmaxnmv Fd Vn     
xxx1 1110 0x11 xxx0 1111 10nn nnnd dddd  -  fmaxp Sd Vn     
xx10 1110 0x1m mmmm 1111 01nn nnnd dddd  -  fmaxp Vd Vn Vm    
xx00 1110 0x1m mmmm 1111 01nn nnnd dddd  -  fmax Vd Vn Vm    
xxx0 1110 0x11 xxx0 1111 10nn nnnd dddd  -  fmaxv Fd Vn     
xxx1 1110 xx1m mmmm 0101 10nn nnnd dddd  -  fmin Fd Fn Fm    
x001 1110 xx1m mmmm 0111 10nn nnnd dddd  -  fminnm Fd Fn Fm    
xxx1 1110 1x11 xxx0 1100 10nn nnnd dddd  -  fminnmp Sd Vn     
xx10 1110 1x1m mmmm 1100 01nn nnnd dddd  -  fminnmp Vd Vn Vm    
xx00 1110 1x1m mmmm 1100 01nn nnnd dddd  -  fminnm Vd Vn Vm    
xxx0 1110 1x11 xxx0 1100 10nn nnnd dddd  -  fminnmv Fd Vn     
xxx1 1110 1x11 xxx0 1111 10nn nnnd dddd  -  fminp Sd Vn     
xx10 1110 1x1m mmmm 1111 01nn nnnd dddd  -  fminp Vd Vn Vm    
xx00 1110 1x1m mmmm 1111 01nn nnnd dddd  -  fmin Vd Vn Vm    
xxx0 1110 1x11 xxx0 1111 10nn nnnd dddd  -  fminv Fd Vn     
x101 1111 xxxm mmmm 000x x0nn nnnd dddd  -  fmla Sd Sn Em    
xxx0 1111 xxxm mmmm 0001 x0nn nnnd dddd  -  fmla Vd Vn Em    
xxx0 1110 0x1m mmmm 1100 11nn nnnd dddd  -  fmla Vd Vn Vm    
x101 1111 xxxm mmmm 010x x0nn nnnd dddd  -  fmls Sd Sn Em    
xxx0 1111 xxxm mmmm 0101 x0nn nnnd dddd  -  fmls Vd Vn Em    
xxx0 1110 1x1m mmmm 1100 11nn nnnd dddd  -  fmls Vd Vn Vm    
xxx1 1110 xx1x x000 0100 00nn nnnd dddd  -  fmov Fd Fn     
x0x1 1110 xx1i iiii iii1 00xx xxxd dddd  -  fmov Fd FPIMM     
xxx1 1110 xx1x 0111 0000 00nn nnnd dddd  -  fmov Fd Rn     
xxx1 1110 xx1x 0110 0000 00nn nnnd dddd  -  fmov Rd Fn     
xxx1 1110 xx1x 1110 0000 00nn nnnd dddd  -  fmov Rd VnD1     
xxx1 1110 xx1x 1111 0000 00nn nnnd dddd  -  fmov VdD1 Rn     
xx00 1111 xxxx xxxx 1111 01xx xxxd dddd  -  fmov Vd SIMD_FPIMM     
xx10 1111 xxxx xxxx 1111 01xx xxxd dddd  -  fmov Vd SIMD_FPIMM     
x001 1111 xx0m mmmm 1aaa aann nnnd dddd  -  fmsub Fd Fn Fm Fa   
x0x1 1110 xx1m mmmm 0000 10nn nnnd dddd  -  fmul Fd Fn Fm    
x101 1111 xxxm mmmm 1001 x0nn nnnd dddd  -  fmul Sd Sn Em    
xx00 1111 xxxm mmmm 1001 x0nn nnnd dddd  -  fmul Vd Vn Em    
xx10 1110 xx1m mmmm 1101 11nn nnnd dddd  -  fmul Vd Vn Vm    
xx11 1111 xxxm mmmm 1xxx x0nn nnnd dddd  -  fmulx Sd Sn Em    
x101 1110 xx1m mmmm 1x01 11nn nnnd dddd  -  fmulx Sd Sn Sm    
xx10 1111 xxxm mmmm 1001 x0nn nnnd dddd  -  fmulx Vd Vn Em    
xx00 1110 xx1m mmmm 1101 11nn nnnd dddd  -  fmulx Vd Vn Vm    
xxx1 1110 xx1x x001 0100 00nn nnnd dddd  -  fneg Fd Fn     
xx1x 1110 xx10 xxx0 1111 10nn nnnd dddd  -  fneg Vd Vn     
x001 1111 xx1m mmmm 0aaa aann nnnd dddd  -  fnmadd Fd Fn Fm Fa   
x001 1111 xx1m mmmm 1aaa aann nnnd dddd  -  fnmsub Fd Fn Fm Fa   
x001 1110 xx1m mmmm 1000 10nn nnnd dddd  -  fnmul Fd Fn Fm    
xx01 1110 1x1x xxx1 1101 10nn nnnd dddd  -  frecpe Sd Sn     
xx00 1110 1x1x xxx1 1101 10nn nnnd dddd  -  frecpe Vd Vn     
x101 1110 0x1m mmmm x111 11nn nnnd dddd  -  frecps Sd Sn Sm    
xx00 1110 0x1m mmmm 1111 11nn nnnd dddd  -  frecps Vd Vn Vm    
xxx1 1110 xx1x xxx1 1111 10nn nnnd dddd  -  frecpx Sd Sn     
xxx1 1110 xx1x x110 0100 00nn nnnd dddd  -  frinta Fd Fn     
xx10 1110 0x1x xxx1 1000 10nn nnnd dddd  -  frinta Vd Vn     
xxx1 1110 xx1x x11x 1100 00nn nnnd dddd  -  frinti Fd Fn     
xx1x 1110 1x1x xxx1 1001 10nn nnnd dddd  -  frinti Vd Vn     
xxx1 1110 xx1x x101 0100 00nn nnnd dddd  -  frintm Fd Fn     
xx0x 1110 0x1x xxx1 1001 10nn nnnd dddd  -  frintm Vd Vn     
xxx1 1110 xx1x x100 0100 00nn nnnd dddd  -  frintn Fd Fn     
xx00 1110 0x1x xxx1 1000 10nn nnnd dddd  -  frintn Vd Vn     
xxx1 1110 xx1x x100 1100 00nn nnnd dddd  -  frintp Fd Fn     
xxx0 1110 1x1x xxx1 1000 10nn nnnd dddd  -  frintp Vd Vn     
xxx1 1110 xx1x x111 0100 00nn nnnd dddd  -  frintx Fd Fn     
xx1x 1110 0x1x xxx1 1001 10nn nnnd dddd  -  frintx Vd Vn     
xxx1 1110 xx1x x101 1100 00nn nnnd dddd  -  frintz Fd Fn     
xx0x 1110 1x1x xxx1 1001 10nn nnnd dddd  -  frintz Vd Vn     
xx11 1110 1x1x xxx1 1101 10nn nnnd dddd  -  frsqrte Sd Sn     
xx10 1110 1x1x xxx1 1101 10nn nnnd dddd  -  frsqrte Vd Vn     
x101 1110 1x1m mmmm x111 11nn nnnd dddd  -  frsqrts Sd Sn Sm    
xxx0 1110 1x1m mmmm 1111 11nn nnnd dddd  -  frsqrts Vd Vn Vm    
xxx1 1110 xx1x x001 1100 00nn nnnd dddd  -  fsqrt Fd Fn     
xxx0 1110 xx1x xxx1 1111 10nn nnnd dddd  -  fsqrt Vd Vn     
x001 1110 xx1m mmmm 0011 10nn nnnd dddd  -  fsub Fd Fn Fm    
xx00 1110 1x1m mmmm 1101 01nn nnnd dddd  -  fsub Vd Vn Vm    
x10x 01x1 xxx0 0xxx xx10 mmmm ooox xxxx  -  hint UIMM7      
110x 0100 xx0i iiii iiii iiii iiix xx00  -  hlt EXCEPTION      
110x 0100 xx0i iiii iiii iiii iiix xx10  -  hvc EXCEPTION      
xx10 1110 xx0x xxxx xxxx x1nn nnnd dddd  -  ins Ed En     
xx00 1110 xx0x xxxx xx01 11nn nnnd dddd  -  ins Ed Rn     
x10x 01x1 xxx0 0xxx xxx1 xxxx 110x xxxx  -  isb BARRIER_ISB      
xx00 1101 110x xxxx xx0x xxxx xxxx xxxx  -  ld1 LEt SIMD_ADDR_POST     
xx00 1101 010x xxxx xx0x xxxx xxxx xxxx  -  ld1 LEt SIMD_ADDR_SIMPLE     
xx00 110x 111x xxxx xx0x xxxx xxxx xxxx  -  ld2 LEt SIMD_ADDR_POST     
xx00 1101 011x xxxx xx0x xxxx xxxx xxxx  -  ld2 LEt SIMD_ADDR_SIMPLE     
xx00 1101 110x xxxx xx1x xxxx xxxx xxxx  -  ld3 LEt SIMD_ADDR_POST     
xx00 1101 010x xxxx xx1x xxxx xxxx xxxx  -  ld3 LEt SIMD_ADDR_SIMPLE     
xx00 110x 111x xxxx xx1x xxxx xxxx xxxx  -  ld4 LEt SIMD_ADDR_POST     
xx00 1101 011x xxxx xx1x xxxx xxxx xxxx  -  ld4 LEt SIMD_ADDR_SIMPLE     
xx00 1100 110x xxxx xxxx xxxx xxxx xxxx  -  ld4 LVt SIMD_ADDR_POST     
xx00 1100 01xx xxxx xxxx xxxx xxxx xxxx  -  ld4 LVt SIMD_ADDR_SIMPLE     
0000 100x 11xx xxxx xxxx xxxx xxxt tttt  -  ldarb Rt ADDR_SIMPLE     
0100 100x 11xx xxxx xxxx xxxx xxxt tttt  -  ldarh Rt ADDR_SIMPLE     
1x00 100x 11xx xxxx xxxx xxxx xxxt tttt  -  ldar Rt ADDR_SIMPLE     
xx00 100x 011x xxxx 1ttt ttxx xxxt tttt  -  ldaxp Rt Rt2 ADDR_SIMPLE    
0000 100x 010x xxxx 1xxx xxxx xxxt tttt  -  ldaxrb Rt ADDR_SIMPLE     
0100 100x 010x xxxx 1xxx xxxx xxxt tttt  -  ldaxrh Rt ADDR_SIMPLE     
1x00 100x 010x xxxx 1xxx xxxx xxxt tttt  -  ldaxr Rt ADDR_SIMPLE     
xx10 110I 01ii iiii ittt ttxx xxxt tttt  -  ldnp Ft Ft2 ADDR_SIMM7    
x010 100I 01ii iiii ittt ttxx xxxt tttt  -  ldnp Rt Rt2 ADDR_SIMM7    
xx10 110I 01ii iiii ittt ttxx xxxt tttt  -  ldp Ft Ft2 ADDR_SIMM7    
xx10 110I 11ii iiii ittt ttxx xxxt tttt  -  ldp Ft Ft2 ADDR_SIMM7    
x010 100I 11ii iiii ittt ttxx xxxt tttt  -  ldp Rt Rt2 ADDR_SIMM7    
x110 100I 01ii iiii ittt ttxx xxxt tttt  -  ldpsw Rt Rt2 ADDR_SIMM7    
x110 100I 11ii iiii ittt ttxx xxxt tttt  -  ldpsw Rt Rt2 ADDR_SIMM7    
0011 1000 011x xxxx xxxx 10xx xxxt tttt  -  ldrb Rt ADDR_REGOFF     
0011 1000 01xi iiii iiii I1xx xxxt tttt  -  ldrb Rt ADDR_SIMM9     
00x1 1001 01ii iiii iiii iinn nnnt tttt  -  ldrb Rt ADDR_UIMM12     
xx01 1100 iiii iiii iiii iiii iiit tttt  -  ldr Ft ADDR_PCREL19     
xx11 1100 x1xx xxxx xxxx 10xx xxxt tttt  -  ldr Ft ADDR_REGOFF     
xx11 1100 x1xi iiii iiii I1xx xxxt tttt  -  ldr Ft ADDR_SIMM9     
xxx1 1101 x1ii iiii iiii iinn nnnt tttt  -  ldr Ft ADDR_UIMM12     
0111 1000 011x xxxx xxxx 10xx xxxt tttt  -  ldrh Rt ADDR_REGOFF     
0111 1000 01xi iiii iiii I1xx xxxt tttt  -  ldrh Rt ADDR_SIMM9     
01x1 1001 01ii iiii iiii iinn nnnt tttt  -  ldrh Rt ADDR_UIMM12     
0x01 1000 iiii iiii iiii iiii iiit tttt  -  ldr Rt ADDR_PCREL19     
1x11 1000 011x xxxx xxxx 10xx xxxt tttt  -  ldr Rt ADDR_REGOFF     
1x11 1000 01xi iiii iiii I1xx xxxt tttt  -  ldr Rt ADDR_SIMM9     
1xx1 1001 01ii iiii iiii iinn nnnt tttt  -  ldr Rt ADDR_UIMM12     
0011 1000 1x1x xxxx xxxx 10xx xxxt tttt  -  ldrsb Rt ADDR_REGOFF     
0011 1000 1xxi iiii iiii I1xx xxxt tttt  -  ldrsb Rt ADDR_SIMM9     
00x1 1001 1xii iiii iiii iinn nnnt tttt  -  ldrsb Rt ADDR_UIMM12     
0111 1000 1x1x xxxx xxxx 10xx xxxt tttt  -  ldrsh Rt ADDR_REGOFF     
x111 1000 1xxi iiii iiii I1xx xxxt tttt  -  ldrsh Rt ADDR_SIMM9     
01x1 1001 1xii iiii iiii iinn nnnt tttt  -  ldrsh Rt ADDR_UIMM12     
1001 1000 iiii iiii iiii iiii iiit tttt  -  ldrsw Rt ADDR_PCREL19     
1011 1000 1x1x xxxx xxxx 10xx xxxt tttt  -  ldrsw Rt ADDR_REGOFF     
1011 1000 1xxi iiii iiii I1xx xxxt tttt  -  ldrsw Rt ADDR_SIMM9     
10x1 1001 1xii iiii iiii iinn nnnt tttt  -  ldrsw Rt ADDR_UIMM12     
0011 1000 010i iiii iiii I0xx xxxt tttt  -  ldtrb Rt ADDR_SIMM9     
0111 1000 010i iiii iiii I0xx xxxt tttt  -  ldtrh Rt ADDR_SIMM9     
1x11 1000 010i iiii iiii I0xx xxxt tttt  -  ldtr Rt ADDR_SIMM9     
0011 1000 1x0i iiii iiii I0xx xxxt tttt  -  ldtrsb Rt ADDR_SIMM9     
x111 1000 1x0i iiii iiii I0xx xxxt tttt  -  ldtrsh Rt ADDR_SIMM9     
1011 1000 1x0i iiii iiii I0xx xxxt tttt  -  ldtrsw Rt ADDR_SIMM9     
0011 1000 01xi iiii iiii I0xx xxxt tttt  -  ldurb Rt ADDR_SIMM9     
xx11 1100 x1xi iiii iiii I0xx xxxt tttt  -  ldur Ft ADDR_SIMM9     
0111 1000 01xi iiii iiii I0xx xxxt tttt  -  ldurh Rt ADDR_SIMM9     
1x11 1000 01xi iiii iiii I0xx xxxt tttt  -  ldur Rt ADDR_SIMM9     
0011 1000 1xxi iiii iiii I0xx xxxt tttt  -  ldursb Rt ADDR_SIMM9     
0111 1000 1xxi iiii iiii I0xx xxxt tttt  -  ldursh Rt ADDR_SIMM9     
1011 1000 1xxi iiii iiii I0xx xxxt tttt  -  ldursw Rt ADDR_SIMM9     
xx00 100x 011x xxxx 0ttt ttxx xxxt tttt  -  ldxp Rt Rt2 ADDR_SIMPLE    
0000 100x 010x xxxx 0xxx xxxx xxxt tttt  -  ldxrb Rt ADDR_SIMPLE     
0100 100x 010x xxxx 0xxx xxxx xxxt tttt  -  ldxrh Rt ADDR_SIMPLE     
1x00 100x 010x xxxx 0xxx xxxx xxxt tttt  -  ldxr Rt ADDR_SIMPLE     
xxx1 1010 110m mmmm xx10 00nn nnnd dddd  -  lslv Rd Rn Rm    
xxx1 1010 x10m mmmm xx10 01nn nnnd dddd  -  lsrv Rd Rn Rm    
xxx1 1011 x00m mmmm 0aaa aann nnnd dddd  -  madd Rd Rn Rm Ra   
xxx0 1111 xxxm mmmm 0000 x0nn nnnd dddd  -  mla Vd Vn Em    
xx00 1110 xx1m mmmm 1001 01nn nnnd dddd  -  mla Vd Vn Vm    
xxx0 1111 xxxm mmmm 0100 x0nn nnnd dddd  -  mls Vd Vn Em    
xx10 1110 xx1m mmmm 1001 01nn nnnd dddd  -  mls Vd Vn Vm    
xx10 1111 xxxx xxxx 1110 01xx xxxd dddd  -  movi Sd SIMD_IMM     
xx00 1111 xxxx xxxx 1110 01xx xxxd dddd  -  movi Vd SIMD_IMM     
xx00 1111 xxxx xxxx 0xx0 x1xx xxxd dddd  -  movi Vd SIMD_IMM_SFT     
xx00 1111 xxxx xxxx 10x0 01xx xxxd dddd  -  movi Vd SIMD_IMM_SFT     
xx00 1111 xxxx xxxx 110x 01xx xxxd dddd  -  movi Vd SIMD_IMM_SFT     
xx1x 0010 1xxi iiii iiii iiii iiid dddd  -  movk Rd HALF     
x00x 0010 1xxi iiii iiii iiii iiid dddd  -  movn Rd HALF     
x10x 0010 1xxi iiii iiii iiii iiid dddd  -  movz Rd HALF     
x10x 01x1 xx11 xxxx xxxx xxxx xxxt tttt  -  mrs Rt SYSREG     
x10x 01x1 xxx0 0xxx xx00 mmmm xxxx xxxx  -  msr PSTATEFIELD UIMM4     
x10x 01x1 xx01 xxxx xxxx xxxx xxxt tttt  -  msr SYSREG Rt     
xxx1 1011 xx0m mmmm 1aaa aann nnnd dddd  -  msub Rd Rn Rm Ra   
xxx0 1111 xxxm mmmm 1000 x0nn nnnd dddd  -  mul Vd Vn Em    
xx00 1110 xx1m mmmm 1001 11nn nnnd dddd  -  mul Vd Vn Vm    
xx10 1111 xxxx xxxx 0xx0 x1xx xxxd dddd  -  mvni Vd SIMD_IMM_SFT     
xx10 1111 xxxx xxxx 10x0 01xx xxxd dddd  -  mvni Vd SIMD_IMM_SFT     
xx10 1111 xxxx xxxx 110x 01xx xxxd dddd  -  mvni Vd SIMD_IMM_SFT     
xx11 1110 xx1x xxx0 1011 10nn nnnd dddd  -  neg Sd Sn     
xx10 1110 xx1x xxx0 1011 10nn nnnd dddd  -  neg Vd Vn     
xx10 1110 x01x 0xxx 0101 10nn nnnd dddd  -  not Vd Vn     
x01x 1010 xx1x xxxx xxxx xxnn nnnd dddd  -  orn Rd Rn Rm_SFT    
xx00 1110 111m mmmm 0001 11nn nnnd dddd  -  orn Vd Vn Vm    
x010 1010 xx0x xxxx xxxx xxnn nnnd dddd  -  orr Rd Rn Rm_SFT    
x01x 0010 0Nii iiii iiii iinn nnnd dddd  -  orr Rd_SP Rn LIMM    
xx00 1111 xxxx xxxx 0xx1 x1xx xxxd dddd  -  orr Vd SIMD_IMM_SFT     
xx00 1111 xxxx xxxx 10x1 01xx xxxd dddd  -  orr Vd SIMD_IMM_SFT     
xx00 1110 101m mmmm 0001 11nn nnnd dddd  -  orr Vd Vn Vm    
x1xx 1110 x01m mmmm 1110 00nn nnnd dddd  -  pmull2 Vd Vn Vm    
x1xx 1110 x11m mmmm 1110 00nn nnnd dddd  -  pmull2 Vd Vn Vm    
x0xx 1110 x01m mmmm 1110 00nn nnnd dddd  -  pmull Vd Vn Vm    
x0xx 1110 x11m mmmm 1110 00nn nnnd dddd  -  pmull Vd Vn Vm    
xx10 1110 xx1m mmmm 1001 11nn nnnd dddd  -  pmul Vd Vn Vm    
1101 1000 iiii iiii iiii iiii iiix xxxx  -  prfm PRFOP ADDR_PCREL19     
1111 1000 1x1x xxxx xxxx 10xx xxxx xxxx  -  prfm PRFOP ADDR_REGOFF     
11x1 1001 1xii iiii iiii iinn nnnx xxxx  -  prfm PRFOP ADDR_UIMM12     
1111 1000 1xxi iiii iiii I0xx xxxx xxxx  -  prfum PRFOP ADDR_SIMM9     
x110 1110 xx1m mmmm 0100 00nn nnnd dddd  -  raddhn2 Vd Vn Vm    
x010 1110 xx1m mmmm 0100 00nn nnnd dddd  -  raddhn Vd Vn Vm    
xxx1 1010 110x xxxx xx00 00nn nnnd dddd  -  rbit Rd Rn     
xx10 1110 x11x 0xxx 0101 10nn nnnd dddd  -  rbit Vd Vn     
x10x 0110 x10x xxxx xxxx xxnn nnnx xxxx  -  ret Rn      
xxx1 1010 x10x xxxx xx00 01nn nnnd dddd  -  rev16 Rd Rn     
xxx0 1110 xx1x xxxx 0001 10nn nnnd dddd  -  rev16 Vd Vn     
11x1 1010 1x0x xxxx xx0x 10nn nnnd dddd  -  rev32 Rd Rn     
xx10 1110 xx1x xxxx 0000 10nn nnnd dddd  -  rev32 Vd Vn     
xx00 1110 xx1x xxxx 0000 10nn nnnd dddd  -  rev64 Vd Vn     
01x1 1010 1x0x xxxx xx0x 10nn nnnd dddd  -  rev Rd Rn     
x1x1 1010 xx0x xxxx xx0x 11nn nnnd dddd  -  rev Rd Rn     
xxx1 1010 xx0m mmmm xx1x 11nn nnnd dddd  -  rorv Rd Rn Rm    
x100 1111 xxxx xxxx 1xx0 11nn nnnd dddd  -  rshrn2 Vd Vn IMM_VLSR    
x000 1111 xxxx xxxx 1xx0 11nn nnnd dddd  -  rshrn Vd Vn IMM_VLSR    
x11x 1110 xx1m mmmm 0110 00nn nnnd dddd  -  rsubhn2 Vd Vn Vm    
x01x 1110 xx1m mmmm 0110 00nn nnnd dddd  -  rsubhn Vd Vn Vm    
x100 1110 xx1m mmmm 0101 00nn nnnd dddd  -  sabal2 Vd Vn Vm    
x000 1110 xx1m mmmm 0101 00nn nnnd dddd  -  sabal Vd Vn Vm    
xx00 1110 xx1m mmmm 0111 11nn nnnd dddd  -  saba Vd Vn Vm    
x100 1110 xx1m mmmm x111 00nn nnnd dddd  -  sabdl2 Vd Vn Vm    
x000 1110 xx1m mmmm x111 00nn nnnd dddd  -  sabdl Vd Vn Vm    
xx00 1110 xx1m mmmm 0111 01nn nnnd dddd  -  sabd Vd Vn Vm    
xx00 1110 xx1x 0xx0 0110 10nn nnnd dddd  -  sadalp Vd Vn     
x100 1110 xx1m mmmm 0000 00nn nnnd dddd  -  saddl2 Vd Vn Vm    
xx00 1110 xx1x xxx0 0010 10nn nnnd dddd  -  saddlp Vd Vn     
x000 1110 xx1m mmmm 0000 00nn nnnd dddd  -  saddl Vd Vn Vm    
xx00 1110 xx11 xxx0 0011 10nn nnnd dddd  -  saddlv Fd Vn     
x100 1110 xx1m mmmm 0001 00nn nnnd dddd  -  saddw2 Vd Vn Vm    
x000 1110 xx1m mmmm 0001 00nn nnnd dddd  -  saddw Vd Vn Vm    
x101 1010 000m mmmm xxxx 00nn nnnd dddd  -  sbc Rd Rn Rm    
x111 1010 000m mmmm xxxx 00nn nnnd dddd  -  sbcs Rd Rn Rm    
x00x 0011 0xii iiii iiii iinn nnnd dddd  -  sbfm Rd Rn IMMR IMMS   
xxx1 1110 xx1x x010 0000 00nn nnnd dddd  -  scvtf Fd Rn     
x0x1 1110 xx0x xx10 SSSS SSnn nnnd dddd  -  scvtf Fd Rn FBITS    
xx01 1110 0x1x xxx1 1101 10nn nnnd dddd  -  scvtf Sd Sn     
x101 1111 xxxx xxxx 1xx0 01nn nnnd dddd  -  scvtf Sd Sn IMM_VLSR    
xx00 1110 0x1x xxx1 1101 10nn nnnd dddd  -  scvtf Vd Vn     
x0x1 1010 xx0m mmmm xx0x 11nn nnnd dddd  -  sdiv Rd Rn Rm    
x1x1 1110 xx0m mmmm x000 x0nn nnnd dddd  -  sha1c Fd Fn Vm    
x1x1 1110 xx1x xxxx 0000 10nn nnnd dddd  -  sha1h Fd Fn     
x1x1 1110 xx0m mmmm x010 x0nn nnnd dddd  -  sha1m Fd Fn Vm    
x1x1 1110 xx0m mmmm x001 x0nn nnnd dddd  -  sha1p Fd Fn Vm    
x1x1 1110 xx0m mmmm xx11 x0nn nnnd dddd  -  sha1su0 Vd Vn Vm    
x1x1 1110 xx1x xxxx 0001 10nn nnnd dddd  -  sha1su1 Vd Vn     
x1x1 1110 xx0m mmmm x101 x0nn nnnd dddd  -  sha256h2 Fd Fn Vm    
x1x1 1110 xx0m mmmm x100 x0nn nnnd dddd  -  sha256h Fd Fn Vm    
x101 1110 xx1x xxxx 0010 10nn nnnd dddd  -  sha256su0 Vd Vn     
x1x1 1110 xx0m mmmm x110 x0nn nnnd dddd  -  sha256su1 Vd Vn Vm    
xx00 1110 xx1m mmmm 0000 01nn nnnd dddd  -  shadd Vd Vn Vm    
x1x0 1110 xx1x xxx1 0011 10nn nnnd dddd  -  shll2 Vd Vn SHLL_IMM    
x0x0 1110 xx1x xxx1 0011 10nn nnnd dddd  -  shll Vd Vn SHLL_IMM    
x101 1111 xxxx xxxx 0101 x1nn nnnd dddd  -  shl Sd Sn IMM_VLSL    
xx00 1110 xx1m mmmm 0010 01nn nnnd dddd  -  shsub Vd Vn Vm    
xx11 1111 xxxx xxxx 0101 xxnn nnnd dddd  -  sli Sd Sn IMM_VLSL    
xxx1 1011 0x1m mmmm 0aaa aann nnnd dddd  -  smaddl Rd Rn Rm Ra   
xx00 1110 xx1m mmmm 1010 01nn nnnd dddd  -  smaxp Vd Vn Vm    
xx00 1110 xx1m mmmm 0110 01nn nnnd dddd  -  smax Vd Vn Vm    
xx0x 1110 xx11 xxx0 1010 10nn nnnd dddd  -  smaxv Fd Vn     
110x 0100 xx0i iiii iiii iiii iiix xx11  -  smc EXCEPTION      
xx00 1110 xx1m mmmm 1010 11nn nnnd dddd  -  sminp Vd Vn Vm    
xx00 1110 xx1m mmmm 0110 11nn nnnd dddd  -  smin Vd Vn Vm    
xx0x 1110 xx11 xxx1 1010 10nn nnnd dddd  -  sminv Fd Vn     
x100 1111 xxxm mmmm 0010 x0nn nnnd dddd  -  smlal2 Vd Vn Em    
x10x 1110 xx1m mmmm 1000 00nn nnnd dddd  -  smlal2 Vd Vn Vm    
x000 1111 xxxm mmmm 0010 x0nn nnnd dddd  -  smlal Vd Vn Em    
x00x 1110 xx1m mmmm 1000 00nn nnnd dddd  -  smlal Vd Vn Vm    
x100 1111 xxxm mmmm 0110 x0nn nnnd dddd  -  smlsl2 Vd Vn Em    
x10x 1110 xx1m mmmm 1010 00nn nnnd dddd  -  smlsl2 Vd Vn Vm    
x000 1111 xxxm mmmm 0110 x0nn nnnd dddd  -  smlsl Vd Vn Em    
x00x 1110 xx1m mmmm 1010 00nn nnnd dddd  -  smlsl Vd Vn Vm    
xx00 1110 xx0x xxxx xx10 11nn nnnd dddd  -  smov Rd En     
xxx1 1011 0x1m mmmm 1aaa aann nnnd dddd  -  smsubl Rd Rn Rm Ra   
xxx1 1011 010m mmmm 0xxx xxnn nnnd dddd  -  smulh Rd Rn Rm    
x100 1111 xxxm mmmm 1x10 x0nn nnnd dddd  -  smull2 Vd Vn Em    
x100 1110 xx1m mmmm 1100 00nn nnnd dddd  -  smull2 Vd Vn Vm    
x000 1111 xxxm mmmm 1x10 x0nn nnnd dddd  -  smull Vd Vn Em    
x000 1110 xx1m mmmm 1100 00nn nnnd dddd  -  smull Vd Vn Vm    
x101 1110 xx1x xxxx 0111 10nn nnnd dddd  -  sqabs Sd Sn     
xx00 1110 xx1x 0xx0 0111 10nn nnnd dddd  -  sqabs Vd Vn     
x101 1110 xx1m mmmm 0000 11nn nnnd dddd  -  sqadd Sd Sn Sm    
xx00 1110 xx1m mmmm 0000 11nn nnnd dddd  -  sqadd Vd Vn Vm    
x1x0 1111 xxxm mmmm 0011 x0nn nnnd dddd  -  sqdmlal2 Vd Vn Em    
x1x0 1110 xx1m mmmm 1001 00nn nnnd dddd  -  sqdmlal2 Vd Vn Vm    
x101 1111 xxxm mmmm 001x x0nn nnnd dddd  -  sqdmlal Sd Sn Em    
x1x1 1110 xx1m mmmm x001 00nn nnnd dddd  -  sqdmlal Sd Sn Sm    
x0x0 1111 xxxm mmmm 0011 x0nn nnnd dddd  -  sqdmlal Vd Vn Em    
x0x0 1110 xx1m mmmm 1001 00nn nnnd dddd  -  sqdmlal Vd Vn Vm    
x1x0 1111 xxxm mmmm 0111 x0nn nnnd dddd  -  sqdmlsl2 Vd Vn Em    
x1x0 1110 xx1m mmmm 1011 00nn nnnd dddd  -  sqdmlsl2 Vd Vn Vm    
x101 1111 xxxm mmmm 011x x0nn nnnd dddd  -  sqdmlsl Sd Sn Em    
x1x1 1110 xx1m mmmm xx11 00nn nnnd dddd  -  sqdmlsl Sd Sn Sm    
x0x0 1111 xxxm mmmm 0111 x0nn nnnd dddd  -  sqdmlsl Vd Vn Em    
x0x0 1110 xx1m mmmm 1011 00nn nnnd dddd  -  sqdmlsl Vd Vn Vm    
x101 1111 xxxm mmmm 1xx0 x0nn nnnd dddd  -  sqdmulh Sd Sn Em    
x101 1110 xx1m mmmm 1x11 01nn nnnd dddd  -  sqdmulh Sd Sn Sm    
xxx0 1111 xxxm mmmm 1100 x0nn nnnd dddd  -  sqdmulh Vd Vn Em    
xx00 1110 xx1m mmmm 1011 01nn nnnd dddd  -  sqdmulh Vd Vn Vm    
x1x0 1111 xxxm mmmm 1x11 x0nn nnnd dddd  -  sqdmull2 Vd Vn Em    
x1x0 1110 xx1m mmmm 1101 00nn nnnd dddd  -  sqdmull2 Vd Vn Vm    
x101 1111 xxxm mmmm 1x11 x0nn nnnd dddd  -  sqdmull Sd Sn Em    
x1x1 1110 xx1m mmmm x101 00nn nnnd dddd  -  sqdmull Sd Sn Sm    
x0x0 1111 xxxm mmmm 1x11 x0nn nnnd dddd  -  sqdmull Vd Vn Em    
x0x0 1110 xx1m mmmm 1101 00nn nnnd dddd  -  sqdmull Vd Vn Vm    
xx11 1110 xx1x xxxx 0111 10nn nnnd dddd  -  sqneg Sd Sn     
xx10 1110 xx1x 0xx0 0111 10nn nnnd dddd  -  sqneg Vd Vn     
x101 1111 xxxm mmmm 1101 x0nn nnnd dddd  -  sqrdmulh Sd Sn Em    
xx11 1110 xx1m mmmm 1x11 01nn nnnd dddd  -  sqrdmulh Sd Sn Sm    
xxx0 1111 xxxm mmmm 1101 x0nn nnnd dddd  -  sqrdmulh Vd Vn Em    
xx10 1110 xx1m mmmm 1011 01nn nnnd dddd  -  sqrdmulh Vd Vn Vm    
x101 1110 xx1m mmmm 0x01 11nn nnnd dddd  -  sqrshl Sd Sn Sm    
xx00 1110 xx1m mmmm 0101 11nn nnnd dddd  -  sqrshl Vd Vn Vm    
x100 1111 xxxx xxxx 1x01 11nn nnnd dddd  -  sqrshrn2 Vd Vn IMM_VLSR    
x101 1111 xxxx xxxx 1x0x 11nn nnnd dddd  -  sqrshrn Sd Sn IMM_VLSR    
x000 1111 xxxx xxxx 1x01 11nn nnnd dddd  -  sqrshrn Vd Vn IMM_VLSR    
x110 1111 xxxx xxxx 1xx0 11nn nnnd dddd  -  sqrshrun2 Vd Vn IMM_VLSR    
xx11 1111 xxxx xxxx 1xx0 11nn nnnd dddd  -  sqrshrun Sd Sn IMM_VLSR    
x010 1111 xxxx xxxx 1xx0 11nn nnnd dddd  -  sqrshrun Vd Vn IMM_VLSR    
x101 1111 xxxx xxxx 0111 x1nn nnnd dddd  -  sqshl Sd Sn IMM_VLSL    
x101 1110 xx1m mmmm x100 11nn nnnd dddd  -  sqshl Sd Sn Sm    
xx11 1111 xxxx xxxx 0110 xxnn nnnd dddd  -  sqshlu Sd Sn IMM_VLSL    
xx00 1110 xx1m mmmm 0100 11nn nnnd dddd  -  sqshl Vd Vn Vm    
x101 1111 xxxx xxxx 1xx1 01nn nnnd dddd  -  sqshrn Sd Sn IMM_VLSR    
xx11 1111 xxxx xxxx 1x00 01nn nnnd dddd  -  sqshrun Sd Sn IMM_VLSR    
x101 1110 xx1m mmmm xx10 11nn nnnd dddd  -  sqsub Sd Sn Sm    
xx00 1110 xx1m mmmm 0010 11nn nnnd dddd  -  sqsub Vd Vn Vm    
x100 1110 xx1x xxx1 0100 10nn nnnd dddd  -  sqxtn2 Vd Vn     
x101 1110 xx1x xxxx 0100 10nn nnnd dddd  -  sqxtn Sd Sn     
x000 1110 xx1x xxx1 0100 10nn nnnd dddd  -  sqxtn Vd Vn     
x110 1110 xx1x xxx1 0010 10nn nnnd dddd  -  sqxtun2 Vd Vn     
xx11 1110 xx1x xxxx 0010 10nn nnnd dddd  -  sqxtun Sd Sn     
x010 1110 xx1x xxx1 0010 10nn nnnd dddd  -  sqxtun Vd Vn     
xx00 1110 xx1m mmmm 0001 01nn nnnd dddd  -  srhadd Vd Vn Vm    
xx11 1111 xxxx xxxx 0100 xxnn nnnd dddd  -  sri Sd Sn IMM_VLSR    
x101 1110 xx1m mmmm xx01 01nn nnnd dddd  -  srshl Sd Sn Sm    
xx00 1110 xx1m mmmm 0101 01nn nnnd dddd  -  srshl Vd Vn Vm    
x101 1111 xxxx xxxx 0x10 x1nn nnnd dddd  -  srshr Sd Sn IMM_VLSR    
x101 1111 xxxx xxxx 0011 x1nn nnnd dddd  -  srsra Sd Sn IMM_VLSR    
x101 1110 xx1m mmmm x100 01nn nnnd dddd  -  sshl Sd Sn Sm    
xx00 1110 xx1m mmmm 0100 01nn nnnd dddd  -  sshl Vd Vn Vm    
x101 1111 xxxx xxxx 0x00 x1nn nnnd dddd  -  sshr Sd Sn IMM_VLSR    
x101 1111 xxxx xxxx 0001 x1nn nnnd dddd  -  ssra Sd Sn IMM_VLSR    
x100 1110 xx1m mmmm 0010 00nn nnnd dddd  -  ssubl2 Vd Vn Vm    
x000 1110 xx1m mmmm 0010 00nn nnnd dddd  -  ssubl Vd Vn Vm    
x100 1110 xx1m mmmm 0011 00nn nnnd dddd  -  ssubw2 Vd Vn Vm    
x000 1110 xx1m mmmm 0011 00nn nnnd dddd  -  ssubw Vd Vn Vm    
xx00 1101 100x xxxx xx0x xxxx xxxx xxxx  -  st1 LEt SIMD_ADDR_POST     
xx00 1101 000x xxxx xx0x xxxx xxxx xxxx  -  st1 LEt SIMD_ADDR_SIMPLE     
xx00 110x 101x xxxx xx0x xxxx xxxx xxxx  -  st2 LEt SIMD_ADDR_POST     
xx00 1101 001x xxxx xx0x xxxx xxxx xxxx  -  st2 LEt SIMD_ADDR_SIMPLE     
xx00 1101 100x xxxx xx1x xxxx xxxx xxxx  -  st3 LEt SIMD_ADDR_POST     
xx00 1101 000x xxxx xx1x xxxx xxxx xxxx  -  st3 LEt SIMD_ADDR_SIMPLE     
xx00 110x 101x xxxx xx1x xxxx xxxx xxxx  -  st4 LEt SIMD_ADDR_POST     
xx00 1101 001x xxxx xx1x xxxx xxxx xxxx  -  st4 LEt SIMD_ADDR_SIMPLE     
xx00 1100 100x xxxx xxxx xxxx xxxx xxxx  -  st4 LVt SIMD_ADDR_POST     
xx00 1100 00xx xxxx xxxx xxxx xxxx xxxx  -  st4 LVt SIMD_ADDR_SIMPLE     
0000 100x 10xx xxxx xxxx xxxx xxxt tttt  -  stlrb Rt ADDR_SIMPLE     
0100 100x 10xx xxxx xxxx xxxx xxxt tttt  -  stlrh Rt ADDR_SIMPLE     
1x00 100x 10xx xxxx xxxx xxxx xxxt tttt  -  stlr Rt ADDR_SIMPLE     
xx00 100x 001s ssss 1ttt ttxx xxxt tttt  -  stlxp Rs Rt Rt2 ADDR_SIMPLE   
0000 100x 000s ssss 1xxx xxxx xxxt tttt  -  stlxrb Rs Rt ADDR_SIMPLE    
0100 100x 000s ssss 1xxx xxxx xxxt tttt  -  stlxrh Rs Rt ADDR_SIMPLE    
1x00 100x 000s ssss 1xxx xxxx xxxt tttt  -  stlxr Rs Rt ADDR_SIMPLE    
xx10 110I 00ii iiii ittt ttxx xxxt tttt  -  stnp Ft Ft2 ADDR_SIMM7    
xx10 100I 00ii iiii ittt ttxx xxxt tttt  -  stnp Rt Rt2 ADDR_SIMM7    
xx10 110I 00ii iiii ittt ttxx xxxt tttt  -  stp Ft Ft2 ADDR_SIMM7    
xx10 110I 10ii iiii ittt ttxx xxxt tttt  -  stp Ft Ft2 ADDR_SIMM7    
xx10 100I 10ii iiii ittt ttxx xxxt tttt  -  stp Rt Rt2 ADDR_SIMM7    
0011 1000 001x xxxx xxxx 10xx xxxt tttt  -  strb Rt ADDR_REGOFF     
0011 1000 00xi iiii iiii I1xx xxxt tttt  -  strb Rt ADDR_SIMM9     
00x1 1001 00ii iiii iiii iinn nnnt tttt  -  strb Rt ADDR_UIMM12     
xx11 1100 x0xx xxxx xxxx 10xx xxxt tttt  -  str Ft ADDR_REGOFF     
xx11 1100 x0xi iiii iiii I1xx xxxt tttt  -  str Ft ADDR_SIMM9     
xxx1 1101 x0ii iiii iiii iinn nnnt tttt  -  str Ft ADDR_UIMM12     
0111 1000 001x xxxx xxxx 10xx xxxt tttt  -  strh Rt ADDR_REGOFF     
0111 1000 00xi iiii iiii I1xx xxxt tttt  -  strh Rt ADDR_SIMM9     
01x1 1001 00ii iiii iiii iinn nnnt tttt  -  strh Rt ADDR_UIMM12     
1x11 1000 001x xxxx xxxx 10xx xxxt tttt  -  str Rt ADDR_REGOFF     
1x11 1000 00xi iiii iiii I1xx xxxt tttt  -  str Rt ADDR_SIMM9     
1xx1 1001 00ii iiii iiii iinn nnnt tttt  -  str Rt ADDR_UIMM12     
0011 1000 000i iiii iiii I0xx xxxt tttt  -  sttrb Rt ADDR_SIMM9     
0111 1000 000i iiii iiii I0xx xxxt tttt  -  sttrh Rt ADDR_SIMM9     
1x11 1000 000i iiii iiii I0xx xxxt tttt  -  sttr Rt ADDR_SIMM9     
0011 1000 00xi iiii iiii I0xx xxxt tttt  -  sturb Rt ADDR_SIMM9     
xx11 1100 x0xi iiii iiii I0xx xxxt tttt  -  stur Ft ADDR_SIMM9     
0111 1000 00xi iiii iiii I0xx xxxt tttt  -  sturh Rt ADDR_SIMM9     
1x11 1000 00xi iiii iiii I0xx xxxt tttt  -  stur Rt ADDR_SIMM9     
xx00 100x 001s ssss 0ttt ttxx xxxt tttt  -  stxp Rs Rt Rt2 ADDR_SIMPLE   
0000 100x 000s ssss 0xxx xxxx xxxt tttt  -  stxrb Rs Rt ADDR_SIMPLE    
0100 100x 000s ssss 0xxx xxxx xxxt tttt  -  stxrh Rs Rt ADDR_SIMPLE    
1x00 100x 000s ssss 0xxx xxxx xxxt tttt  -  stxr Rs Rt ADDR_SIMPLE    
x10x 1110 xx1m mmmm 0110 00nn nnnd dddd  -  subhn2 Vd Vn Vm    
x00x 1110 xx1m mmmm 0110 00nn nnnd dddd  -  subhn Vd Vn Vm    
x100 1011 xx0x xxxx xxxx xxnn nnnd dddd  -  sub Rd Rn Rm_SFT    
x10x 0001 SSii iiii iiii iinn nnnd dddd  -  sub Rd_SP Rn_SP AIMM    
x100 1011 0x1x xxxx xxxx xxnn nnnd dddd  -  sub Rd_SP Rn_SP Rm_EXT    
xx11 1110 xx1m mmmm x000 01nn nnnd dddd  -  sub Sd Sn Sm    
x110 1011 xx0x xxxx xxxx xxnn nnnd dddd  -  subs Rd Rn Rm_SFT    
x11x 0001 SSii iiii iiii iinn nnnd dddd  -  subs Rd Rn_SP AIMM    
x110 1011 0x1x xxxx xxxx xxnn nnnd dddd  -  subs Rd Rn_SP Rm_EXT    
xx10 1110 xx1m mmmm 1000 01nn nnnd dddd  -  sub Vd Vn Vm    
x101 1110 xx1x xxxx 0011 10nn nnnd dddd  -  suqadd Sd Sn     
xx00 1110 xx10 xxx0 0011 10nn nnnd dddd  -  suqadd Vd Vn     
110x 0100 xx0i iiii iiii iiii iiix xx01  -  svc EXCEPTION      
x10x 01x1 xx10 1ooo nnnn mmmm ooot tttt  -  sysl Rt UIMM3_OP1 Cn Cm UIMM3_OP2  
x10x 01x1 xx00 1ooo nnnn mmmm ooot tttt  -  sys UIMM3_OP1 Cn Cm UIMM3_OP2 Rt  
xx00 1110 xx0m mmmm xxx0 00nn nnnd dddd  -  tbl Vd LVn Vm    
bx1x 0111 bbbb biii iiii iiii iiit tttt  -  tbnz Rt BIT_NUM ADDR_PCREL14    
xx00 1110 xx0m mmmm xxx1 00nn nnnd dddd  -  tbx Vd LVn Vm    
bx1x 0110 bbbb biii iiii iiii iiit tttt  -  tbz Rt BIT_NUM ADDR_PCREL14    
xx00 1110 xx0m mmmm x0x0 10nn nnnd dddd  -  trn1 Vd Vn Vm    
xx00 1110 xx0m mmmm x1x0 10nn nnnd dddd  -  trn2 Vd Vn Vm    
x110 1110 xx1m mmmm 0101 00nn nnnd dddd  -  uabal2 Vd Vn Vm    
x010 1110 xx1m mmmm 0101 00nn nnnd dddd  -  uabal Vd Vn Vm    
xx10 1110 xx1m mmmm 0111 11nn nnnd dddd  -  uaba Vd Vn Vm    
x110 1110 xx1m mmmm x111 00nn nnnd dddd  -  uabdl2 Vd Vn Vm    
x010 1110 xx1m mmmm x111 00nn nnnd dddd  -  uabdl Vd Vn Vm    
xx10 1110 xx1m mmmm 0111 01nn nnnd dddd  -  uabd Vd Vn Vm    
xx10 1110 xx1x 0xx0 0110 10nn nnnd dddd  -  uadalp Vd Vn     
x110 1110 xx1m mmmm 0000 00nn nnnd dddd  -  uaddl2 Vd Vn Vm    
xx10 1110 xx1x xxx0 0010 10nn nnnd dddd  -  uaddlp Vd Vn     
x010 1110 xx1m mmmm 0000 00nn nnnd dddd  -  uaddl Vd Vn Vm    
xx10 1110 xx11 xxx0 0011 10nn nnnd dddd  -  uaddlv Fd Vn     
x110 1110 xx1m mmmm 0001 00nn nnnd dddd  -  uaddw2 Vd Vn Vm    
x010 1110 xx1m mmmm 0001 00nn nnnd dddd  -  uaddw Vd Vn Vm    
x10x 0011 0xii iiii iiii iinn nnnd dddd  -  ubfm Rd Rn IMMR IMMS   
xxx1 1110 xx1x x011 0000 00nn nnnd dddd  -  ucvtf Fd Rn     
x0x1 1110 xx0x xx11 SSSS SSnn nnnd dddd  -  ucvtf Fd Rn FBITS    
xx11 1110 0x1x xxx1 1101 10nn nnnd dddd  -  ucvtf Sd Sn     
xx11 1111 xxxx xxxx 1x10 01nn nnnd dddd  -  ucvtf Sd Sn IMM_VLSR    
xx10 1110 0x1x xxx1 1101 10nn nnnd dddd  -  ucvtf Vd Vn     
x0x1 1010 1x0m mmmm xx0x 10nn nnnd dddd  -  udiv Rd Rn Rm    
xx10 1110 xx1m mmmm 0000 01nn nnnd dddd  -  uhadd Vd Vn Vm    
xx10 1110 xx1m mmmm 0010 01nn nnnd dddd  -  uhsub Vd Vn Vm    
xxxx 1011 1x1m mmmm 0aaa aann nnnd dddd  -  umaddl Rd Rn Rm Ra   
xx10 1110 xx1m mmmm 1010 01nn nnnd dddd  -  umaxp Vd Vn Vm    
xx10 1110 xx1m mmmm 0110 01nn nnnd dddd  -  umax Vd Vn Vm    
xx1x 1110 xx11 xxx0 1010 10nn nnnd dddd  -  umaxv Fd Vn     
xx10 1110 xx1m mmmm 1010 11nn nnnd dddd  -  uminp Vd Vn Vm    
xx10 1110 xx1m mmmm 0110 11nn nnnd dddd  -  umin Vd Vn Vm    
xx1x 1110 xx11 xxx1 1010 10nn nnnd dddd  -  uminv Fd Vn     
x110 1111 xxxm mmmm 0010 x0nn nnnd dddd  -  umlal2 Vd Vn Em    
x11x 1110 xx1m mmmm 1000 00nn nnnd dddd  -  umlal2 Vd Vn Vm    
x010 1111 xxxm mmmm 0010 x0nn nnnd dddd  -  umlal Vd Vn Em    
x01x 1110 xx1m mmmm 1000 00nn nnnd dddd  -  umlal Vd Vn Vm    
x110 1111 xxxm mmmm 0110 x0nn nnnd dddd  -  umlsl2 Vd Vn Em    
x11x 1110 xx1m mmmm 1010 00nn nnnd dddd  -  umlsl2 Vd Vn Vm    
x010 1111 xxxm mmmm 0110 x0nn nnnd dddd  -  umlsl Vd Vn Em    
x01x 1110 xx1m mmmm 1010 00nn nnnd dddd  -  umlsl Vd Vn Vm    
xx00 1110 xx0x xxxx xx11 11nn nnnd dddd  -  umov Rd En     
xxxx 1011 1x1m mmmm 1aaa aann nnnd dddd  -  umsubl Rd Rn Rm Ra   
xxx1 1011 110m mmmm 0xxx xxnn nnnd dddd  -  umulh Rd Rn Rm    
x110 1111 xxxm mmmm 1x10 x0nn nnnd dddd  -  umull2 Vd Vn Em    
x110 1110 xx1m mmmm 1100 00nn nnnd dddd  -  umull2 Vd Vn Vm    
x010 1111 xxxm mmmm 1x10 x0nn nnnd dddd  -  umull Vd Vn Em    
x010 1110 xx1m mmmm 1100 00nn nnnd dddd  -  umull Vd Vn Vm    
xx11 1110 xx1m mmmm 0000 11nn nnnd dddd  -  uqadd Sd Sn Sm    
xx10 1110 xx1m mmmm 0000 11nn nnnd dddd  -  uqadd Vd Vn Vm    
xx11 1110 xx1m mmmm xx01 11nn nnnd dddd  -  uqrshl Sd Sn Sm    
xx10 1110 xx1m mmmm 0101 11nn nnnd dddd  -  uqrshl Vd Vn Vm    
x110 1111 xxxx xxxx 1x01 11nn nnnd dddd  -  uqrshrn2 Vd Vn IMM_VLSR    
xx11 1111 xxxx xxxx 1x01 11nn nnnd dddd  -  uqrshrn Sd Sn IMM_VLSR    
x010 1111 xxxx xxxx 1x01 11nn nnnd dddd  -  uqrshrn Vd Vn IMM_VLSR    
xx11 1111 xxxx xxxx 0111 xxnn nnnd dddd  -  uqshl Sd Sn IMM_VLSL    
xx11 1110 xx1m mmmm x100 11nn nnnd dddd  -  uqshl Sd Sn Sm    
xx10 1110 xx1m mmmm 0100 11nn nnnd dddd  -  uqshl Vd Vn Vm    
xx11 1111 xxxx xxxx 1xx1 01nn nnnd dddd  -  uqshrn Sd Sn IMM_VLSR    
xx11 1110 xx1m mmmm x010 11nn nnnd dddd  -  uqsub Sd Sn Sm    
xx10 1110 xx1m mmmm 0010 11nn nnnd dddd  -  uqsub Vd Vn Vm    
x110 1110 xx1x xxx1 0100 10nn nnnd dddd  -  uqxtn2 Vd Vn     
xx11 1110 xx1x xxxx 0100 10nn nnnd dddd  -  uqxtn Sd Sn     
x010 1110 xx1x xxx1 0100 10nn nnnd dddd  -  uqxtn Vd Vn     
xx0x 1110 1x1x xxx1 1100 10nn nnnd dddd  -  urecpe Vd Vn     
xx10 1110 xx1m mmmm 0001 01nn nnnd dddd  -  urhadd Vd Vn Vm    
xx11 1110 xx1m mmmm 0x01 01nn nnnd dddd  -  urshl Sd Sn Sm    
xx10 1110 xx1m mmmm 0101 01nn nnnd dddd  -  urshl Vd Vn Vm    
xx11 1111 xxxx xxxx 0010 xxnn nnnd dddd  -  urshr Sd Sn IMM_VLSR    
xx1x 1110 1x1x xxx1 1100 10nn nnnd dddd  -  ursqrte Vd Vn     
xx11 1111 xxxx xxxx 0011 xxnn nnnd dddd  -  ursra Sd Sn IMM_VLSR    
xx11 1110 xx1m mmmm x100 01nn nnnd dddd  -  ushl Sd Sn Sm    
xx10 1110 xx1m mmmm 0100 01nn nnnd dddd  -  ushl Vd Vn Vm    
xx11 1111 xxxx xxxx 0000 xxnn nnnd dddd  -  ushr Sd Sn IMM_VLSR    
xx11 1110 xx1x xxxx 0011 10nn nnnd dddd  -  usqadd Sd Sn     
xx10 1110 xx10 xxx0 0011 10nn nnnd dddd  -  usqadd Vd Vn     
xx11 1111 xxxx xxxx 0001 xxnn nnnd dddd  -  usra Sd Sn IMM_VLSR    
x110 1110 xx1m mmmm 0010 00nn nnnd dddd  -  usubl2 Vd Vn Vm    
x010 1110 xx1m mmmm 0010 00nn nnnd dddd  -  usubl Vd Vn Vm    
x110 1110 xx1m mmmm 0011 00nn nnnd dddd  -  usubw2 Vd Vn Vm    
x010 1110 xx1m mmmm 0011 00nn nnnd dddd  -  usubw Vd Vn Vm    
xx00 1110 xx0m mmmm x001 10nn nnnd dddd  -  uzp1 Vd Vn Vm    
xx00 1110 xx0m mmmm x101 10nn nnnd dddd  -  uzp2 Vd Vn Vm    
x100 1110 xx1x xxx1 0010 10nn nnnd dddd  -  xtn2 Vd Vn     
x000 1110 xx1x xxx1 0010 10nn nnnd dddd  -  xtn Vd Vn     
xx00 1110 xx0m mmmm x011 10nn nnnd dddd  -  zip1 Vd Vn Vm    
xx00 1110 xx0m mmmm x111 10nn nnnd dddd  -  zip2 Vd Vn Vm

	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
adr Rd ADDR_PCREL21	0	i		x	0	0	0	0	i																			d
adrp Rd ADDR_ADRP	1	i		x	0	0	0	0	i																			d
add Rd_SP Rn_SP AIMM	x	0	0	x	0	0	0	1	S		i												n					d
sub Rd_SP Rn_SP AIMM	x	1	0	x	0	0	0	1	S		i												n					d
adds Rd Rn_SP AIMM	x	0	1	x	0	0	0	1	S		i												n					d
subs Rd Rn_SP AIMM	x	1	1	x	0	0	0	1	S		i												n					d
stxrb Rs Rt ADDR_SIMPLE	0	0	0	0	1	0	0	x	0	0	0	s					0	x	x	x	x	x	x	x	x	x	x	t
stxrh Rs Rt ADDR_SIMPLE	0	1	0	0	1	0	0	x	0	0	0	s					0	x	x	x	x	x	x	x	x	x	x	t
stxr Rs Rt ADDR_SIMPLE	1	x	0	0	1	0	0	x	0	0	0	s					0	x	x	x	x	x	x	x	x	x	x	t
stxp Rs Rt Rt2 ADDR_SIMPLE	x	x	0	0	1	0	0	x	0	0	1	s					0	t					x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
stlxrb Rs Rt ADDR_SIMPLE	0	0	0	0	1	0	0	x	0	0	0	s					1	x	x	x	x	x	x	x	x	x	x	t
stlxrh Rs Rt ADDR_SIMPLE	0	1	0	0	1	0	0	x	0	0	0	s					1	x	x	x	x	x	x	x	x	x	x	t
stlxr Rs Rt ADDR_SIMPLE	1	x	0	0	1	0	0	x	0	0	0	s					1	x	x	x	x	x	x	x	x	x	x	t
stlxp Rs Rt Rt2 ADDR_SIMPLE	x	x	0	0	1	0	0	x	0	0	1	s					1	t					x	x	x	x	x	t
stnp Rt Rt2 ADDR_SIMM7	x	x	1	0	1	0	0	I	0	0	i							t					x	x	x	x	x	t
stlrb Rt ADDR_SIMPLE	0	0	0	0	1	0	0	x	1	0	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	t
stlrh Rt ADDR_SIMPLE	0	1	0	0	1	0	0	x	1	0	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	t
stlr Rt ADDR_SIMPLE	1	x	0	0	1	0	0	x	1	0	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	t
stp Rt Rt2 ADDR_SIMM7	x	x	1	0	1	0	0	I	1	0	i							t					x	x	x	x	x	t
ldxrb Rt ADDR_SIMPLE	0	0	0	0	1	0	0	x	0	1	0	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ldxrh Rt ADDR_SIMPLE	0	1	0	0	1	0	0	x	0	1	0	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	t
ldxr Rt ADDR_SIMPLE	1	x	0	0	1	0	0	x	0	1	0	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	t
ldxp Rt Rt2 ADDR_SIMPLE	x	x	0	0	1	0	0	x	0	1	1	x	x	x	x	x	0	t					x	x	x	x	x	t
ldaxrb Rt ADDR_SIMPLE	0	0	0	0	1	0	0	x	0	1	0	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	t
ldaxrh Rt ADDR_SIMPLE	0	1	0	0	1	0	0	x	0	1	0	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	t
ldaxr Rt ADDR_SIMPLE	1	x	0	0	1	0	0	x	0	1	0	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	t
ldaxp Rt Rt2 ADDR_SIMPLE	x	x	0	0	1	0	0	x	0	1	1	x	x	x	x	x	1	t					x	x	x	x	x	t
ldnp Rt Rt2 ADDR_SIMM7	x	0	1	0	1	0	0	I	0	1	i							t					x	x	x	x	x	t
ldpsw Rt Rt2 ADDR_SIMM7	x	1	1	0	1	0	0	I	0	1	i							t					x	x	x	x	x	t
ldarb Rt ADDR_SIMPLE	0	0	0	0	1	0	0	x	1	1	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ldarh Rt ADDR_SIMPLE	0	1	0	0	1	0	0	x	1	1	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	t
ldar Rt ADDR_SIMPLE	1	x	0	0	1	0	0	x	1	1	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	t
ldp Rt Rt2 ADDR_SIMM7	x	0	1	0	1	0	0	I	1	1	i							t					x	x	x	x	x	t
ldpsw Rt Rt2 ADDR_SIMM7	x	1	1	0	1	0	0	I	1	1	i							t					x	x	x	x	x	t
ldr Rt ADDR_PCREL19	0	x	0	1	1	0	0	0	i																			t
ldrsw Rt ADDR_PCREL19	1	0	0	1	1	0	0	0	i																			t
prfm PRFOP ADDR_PCREL19	1	1	0	1	1	0	0	0	i																			x	x	x	x	x
sturb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	0	0	x	i									0	0	x	x	x	x	x	t
sturh Rt ADDR_SIMM9	0	1	1	1	1	0	0	0	0	0	x	i									0	0	x	x	x	x	x	t
stur Rt ADDR_SIMM9	1	x	1	1	1	0	0	0	0	0	x	i									0	0	x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ldurb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	0	1	x	i									0	0	x	x	x	x	x	t
ldurh Rt ADDR_SIMM9	0	1	1	1	1	0	0	0	0	1	x	i									0	0	x	x	x	x	x	t
ldur Rt ADDR_SIMM9	1	x	1	1	1	0	0	0	0	1	x	i									0	0	x	x	x	x	x	t
ldursb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	1	x	x	i									0	0	x	x	x	x	x	t
ldursw Rt ADDR_SIMM9	1	0	1	1	1	0	0	0	1	x	x	i									0	0	x	x	x	x	x	t
ldursh Rt ADDR_SIMM9	0	1	1	1	1	0	0	0	1	x	x	i									0	0	x	x	x	x	x	t
prfum PRFOP ADDR_SIMM9	1	1	1	1	1	0	0	0	1	x	x	i									0	0	x	x	x	x	x	x	x	x	x	x
sttrb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	0	0	0	i									1	0	x	x	x	x	x	t
sttrh Rt ADDR_SIMM9	0	1	1	1	1	0	0	0	0	0	0	i									1	0	x	x	x	x	x	t
sttr Rt ADDR_SIMM9	1	x	1	1	1	0	0	0	0	0	0	i									1	0	x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ldtrb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	0	1	0	i									1	0	x	x	x	x	x	t
ldtrh Rt ADDR_SIMM9	0	1	1	1	1	0	0	0	0	1	0	i									1	0	x	x	x	x	x	t
ldtr Rt ADDR_SIMM9	1	x	1	1	1	0	0	0	0	1	0	i									1	0	x	x	x	x	x	t
ldtrsb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	1	x	0	i									1	0	x	x	x	x	x	t
ldtrsw Rt ADDR_SIMM9	1	0	1	1	1	0	0	0	1	x	0	i									1	0	x	x	x	x	x	t
ldtrsh Rt ADDR_SIMM9	x	1	1	1	1	0	0	0	1	x	0	i									1	0	x	x	x	x	x	t
strb Rt ADDR_REGOFF	0	0	1	1	1	0	0	0	0	0	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
strh Rt ADDR_REGOFF	0	1	1	1	1	0	0	0	0	0	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
str Rt ADDR_REGOFF	1	x	1	1	1	0	0	0	0	0	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
ldrb Rt ADDR_REGOFF	0	0	1	1	1	0	0	0	0	1	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ldrh Rt ADDR_REGOFF	0	1	1	1	1	0	0	0	0	1	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
ldr Rt ADDR_REGOFF	1	x	1	1	1	0	0	0	0	1	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
ldrsb Rt ADDR_REGOFF	0	0	1	1	1	0	0	0	1	x	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
ldrsw Rt ADDR_REGOFF	1	0	1	1	1	0	0	0	1	x	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
ldrsh Rt ADDR_REGOFF	0	1	1	1	1	0	0	0	1	x	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
prfm PRFOP ADDR_REGOFF	1	1	1	1	1	0	0	0	1	x	1	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	x	x	x	x	x
strb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	0	0	x	i									I	1	x	x	x	x	x	t
strh Rt ADDR_SIMM9	0	1	1	1	1	0	0	0	0	0	x	i									I	1	x	x	x	x	x	t
str Rt ADDR_SIMM9	1	x	1	1	1	0	0	0	0	0	x	i									I	1	x	x	x	x	x	t
ldrb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	0	1	x	i									I	1	x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ldrh Rt ADDR_SIMM9	0	1	1	1	1	0	0	0	0	1	x	i									I	1	x	x	x	x	x	t
ldr Rt ADDR_SIMM9	1	x	1	1	1	0	0	0	0	1	x	i									I	1	x	x	x	x	x	t
ldrsb Rt ADDR_SIMM9	0	0	1	1	1	0	0	0	1	x	x	i									I	1	x	x	x	x	x	t
ldrsw Rt ADDR_SIMM9	1	0	1	1	1	0	0	0	1	x	x	i									I	1	x	x	x	x	x	t
ldrsh Rt ADDR_SIMM9	x	1	1	1	1	0	0	0	1	x	x	i									I	1	x	x	x	x	x	t
strb Rt ADDR_UIMM12	0	0	x	1	1	0	0	1	0	0	i												n					t
strh Rt ADDR_UIMM12	0	1	x	1	1	0	0	1	0	0	i												n					t
str Rt ADDR_UIMM12	1	x	x	1	1	0	0	1	0	0	i												n					t
ldrb Rt ADDR_UIMM12	0	0	x	1	1	0	0	1	0	1	i												n					t
ldrh Rt ADDR_UIMM12	0	1	x	1	1	0	0	1	0	1	i												n					t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ldr Rt ADDR_UIMM12	1	x	x	1	1	0	0	1	0	1	i												n					t
ldrsb Rt ADDR_UIMM12	0	0	x	1	1	0	0	1	1	x	i												n					t
ldrsw Rt ADDR_UIMM12	1	0	x	1	1	0	0	1	1	x	i												n					t
ldrsh Rt ADDR_UIMM12	0	1	x	1	1	0	0	1	1	x	i												n					t
prfm PRFOP ADDR_UIMM12	1	1	x	1	1	0	0	1	1	x	i												n					x	x	x	x	x
and Rd_SP Rn LIMM	x	0	0	x	0	0	1	0	0	N	i												n					d
eor Rd_SP Rn LIMM	x	1	0	x	0	0	1	0	0	N	i												n					d
orr Rd_SP Rn LIMM	x	0	1	x	0	0	1	0	0	N	i												n					d
ands Rd Rn LIMM	x	1	1	x	0	0	1	0	0	N	i												n					d
movn Rd HALF	x	0	0	x	0	0	1	0	1	x	x	i																d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
movz Rd HALF	x	1	0	x	0	0	1	0	1	x	x	i																d
movk Rd HALF	x	x	1	x	0	0	1	0	1	x	x	i																d
and Rd Rn Rm_SFT	x	0	0	0	1	0	1	0	x	x	0	x	x	x	x	x	x	x	x	x	x	x	n					d
eor Rd Rn Rm_SFT	x	1	0	0	1	0	1	0	x	x	0	x	x	x	x	x	x	x	x	x	x	x	n					d
orr Rd Rn Rm_SFT	x	0	1	0	1	0	1	0	x	x	0	x	x	x	x	x	x	x	x	x	x	x	n					d
ands Rd Rn Rm_SFT	x	1	1	0	1	0	1	0	x	x	0	x	x	x	x	x	x	x	x	x	x	x	n					d
adc Rd Rn Rm	x	0	0	1	1	0	1	0	0	0	0	m					x	x	x	x	0	0	n					d
sbc Rd Rn Rm	x	1	0	1	1	0	1	0	0	0	0	m					x	x	x	x	0	0	n					d
adcs Rd Rn Rm	x	0	1	1	1	0	1	0	0	0	0	m					x	x	x	x	0	0	n					d
sbcs Rd Rn Rm	x	1	1	1	1	0	1	0	0	0	0	m					x	x	x	x	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
csel Rd Rn Rm COND	x	0	x	1	1	0	1	0	1	0	0	m					x	x	x	x	0	0	n					d
csinv Rd Rn Rm COND	x	1	x	1	1	0	1	0	1	0	0	m					x	x	x	x	0	0	n					d
ccmn Rn Rm NZCV COND	x	0	x	1	1	0	1	0	0	1	0	m					x	x	x	x	0	0	n					x	c
ccmp Rn Rm NZCV COND	x	1	x	1	1	0	1	0	0	1	0	m					x	x	x	x	0	0	n					x	c
rbit Rd Rn	x	x	x	1	1	0	1	0	1	1	0	x	x	x	x	x	x	x	0	0	0	0	n					d
lslv Rd Rn Rm	x	x	x	1	1	0	1	0	1	1	0	m					x	x	1	0	0	0	n					d
clz Rd Rn	x	x	x	1	1	0	1	0	1	1	0	x	x	x	x	x	x	x	x	1	0	0	n					d
ccmn Rn CCMP_IMM NZCV COND	x	0	x	1	1	0	1	0	0	x	0	i					x	x	x	x	1	0	n					x	c
ccmp Rn CCMP_IMM NZCV COND	x	1	x	1	1	0	1	0	0	x	0	i					x	x	x	x	1	0	n					x	c
udiv Rd Rn Rm	x	0	x	1	1	0	1	0	1	x	0	m					x	x	0	x	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
rev Rd Rn	0	1	x	1	1	0	1	0	1	x	0	x	x	x	x	x	x	x	0	x	1	0	n					d
rev32 Rd Rn	1	1	x	1	1	0	1	0	1	x	0	x	x	x	x	x	x	x	0	x	1	0	n					d
asrv Rd Rn Rm	x	x	x	1	1	0	1	0	1	x	0	m					x	x	1	x	1	0	n					d
csinc Rd Rn Rm COND	x	0	x	1	1	0	1	0	x	0	0	m					x	x	x	x	0	1	n					d
csneg Rd Rn Rm COND	x	1	x	1	1	0	1	0	x	0	0	m					x	x	x	x	0	1	n					d
rev16 Rd Rn	x	x	x	1	1	0	1	0	x	1	0	x	x	x	x	x	x	x	0	0	0	1	n					d
lsrv Rd Rn Rm	x	x	x	1	1	0	1	0	x	1	0	m					x	x	1	0	0	1	n					d
cls Rd Rn	x	x	x	1	1	0	1	0	x	1	0	x	x	x	x	x	x	x	x	1	0	1	n					d
sdiv Rd Rn Rm	x	0	x	1	1	0	1	0	x	x	0	m					x	x	0	x	1	1	n					d
rev Rd Rn	x	1	x	1	1	0	1	0	x	x	0	x	x	x	x	x	x	x	0	x	1	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
rorv Rd Rn Rm	x	x	x	1	1	0	1	0	x	x	0	m					x	x	1	x	1	1	n					d
bic Rd Rn Rm_SFT	x	0	0	x	1	0	1	0	x	x	1	x	x	x	x	x	x	x	x	x	x	x	n					d
eon Rd Rn Rm_SFT	x	1	0	x	1	0	1	0	x	x	1	x	x	x	x	x	x	x	x	x	x	x	n					d
orn Rd Rn Rm_SFT	x	0	1	x	1	0	1	0	x	x	1	x	x	x	x	x	x	x	x	x	x	x	n					d
bics Rd Rn Rm_SFT	x	1	1	x	1	0	1	0	x	x	1	x	x	x	x	x	x	x	x	x	x	x	n					d
sbfm Rd Rn IMMR IMMS	x	0	0	x	0	0	1	1	0	x	i												n					d
ubfm Rd Rn IMMR IMMS	x	1	0	x	0	0	1	1	0	x	i												n					d
bfm Rd Rn IMMR IMMS	x	x	1	x	0	0	1	1	0	x	i												n					d
extr Rd Rn Rm IMMS	x	x	x	x	0	0	1	1	1	x	x	m					i						n					d
add Rd Rn Rm_SFT	x	0	0	0	1	0	1	1	x	x	0	x	x	x	x	x	x	x	x	x	x	x	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sub Rd Rn Rm_SFT	x	1	0	0	1	0	1	1	x	x	0	x	x	x	x	x	x	x	x	x	x	x	n					d
adds Rd Rn Rm_SFT	x	0	1	0	1	0	1	1	x	x	0	x	x	x	x	x	x	x	x	x	x	x	n					d
subs Rd Rn Rm_SFT	x	1	1	0	1	0	1	1	x	x	0	x	x	x	x	x	x	x	x	x	x	x	n					d
madd Rd Rn Rm Ra	x	x	x	1	1	0	1	1	x	0	0	m					0	a					n					d
smulh Rd Rn Rm	x	x	x	1	1	0	1	1	0	1	0	m					0	x	x	x	x	x	n					d
umulh Rd Rn Rm	x	x	x	1	1	0	1	1	1	1	0	m					0	x	x	x	x	x	n					d
msub Rd Rn Rm Ra	x	x	x	1	1	0	1	1	x	x	0	m					1	a					n					d
add Rd_SP Rn_SP Rm_EXT	x	0	0	0	1	0	1	1	0	x	1	x	x	x	x	x	x	x	x	x	x	x	n					d
sub Rd_SP Rn_SP Rm_EXT	x	1	0	0	1	0	1	1	0	x	1	x	x	x	x	x	x	x	x	x	x	x	n					d
adds Rd Rn_SP Rm_EXT	x	0	1	0	1	0	1	1	0	x	1	x	x	x	x	x	x	x	x	x	x	x	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
subs Rd Rn_SP Rm_EXT	x	1	1	0	1	0	1	1	0	x	1	x	x	x	x	x	x	x	x	x	x	x	n					d
smaddl Rd Rn Rm Ra	x	x	x	1	1	0	1	1	0	x	1	m					0	a					n					d
smsubl Rd Rn Rm Ra	x	x	x	1	1	0	1	1	0	x	1	m					1	a					n					d
umaddl Rd Rn Rm Ra	x	x	x	x	1	0	1	1	1	x	1	m					0	a					n					d
umsubl Rd Rn Rm Ra	x	x	x	x	1	0	1	1	1	x	1	m					1	a					n					d
b ADDR_PCREL26	0	0	0	x	0	1	i
bl ADDR_PCREL26	1	0	0	x	0	1	i
b.c ADDR_PCREL19	0	1	0	x	0	1	0	0	i																			x	x	x	x	x
hlt EXCEPTION	1	1	0	x	0	1	0	0	x	x	0	i																x	x	x	0	0
brk EXCEPTION	1	1	0	x	0	1	0	0	x	x	1	i																x	x	x	0	0
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
hvc EXCEPTION	1	1	0	x	0	1	0	0	x	x	0	i																x	x	x	1	0
dcps2 EXCEPTION	1	1	0	x	0	1	0	0	x	x	1	i																x	x	x	1	0
svc EXCEPTION	1	1	0	x	0	1	0	0	x	x	0	i																x	x	x	0	1
dcps1 EXCEPTION	1	1	0	x	0	1	0	0	x	x	1	i																x	x	x	0	1
smc EXCEPTION	1	1	0	x	0	1	0	0	x	x	0	i																x	x	x	1	1
dcps3 EXCEPTION	1	1	0	x	0	1	0	0	x	x	1	i																x	x	x	1	1
br Rn	x	1	0	x	0	1	1	0	0	0	0	x	x	x	x	x	x	x	x	x	x	x	n					x	x	x	x	x
eret	x	1	0	x	0	1	1	0	1	0	0	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x
ret Rn	x	1	0	x	0	1	1	0	x	1	0	x	x	x	x	x	x	x	x	x	x	x	n					x	x	x	x	x
blr Rn	x	1	0	x	0	1	1	0	0	x	1	x	x	x	x	x	x	x	x	x	x	x	n					x	x	x	x	x
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
drps	x	1	0	x	0	1	1	0	1	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x
msr PSTATEFIELD UIMM4	x	1	0	x	0	1	x	1	x	x	x	0	0	x	x	x	x	x	0	0	m				x	x	x	x	x	x	x	x
hint UIMM7	x	1	0	x	0	1	x	1	x	x	x	0	0	x	x	x	x	x	1	0	m				o			x	x	x	x	x
dsb BARRIER	x	1	0	x	0	1	x	1	x	x	x	0	0	x	x	x	x	x	x	1	x	x	x	x	x	0	0	x	x	x	x	x
clrex UIMM4	x	1	0	x	0	1	x	1	x	x	x	0	0	x	x	x	x	x	x	1	m				0	1	0	x	x	x	x	x
isb BARRIER_ISB	x	1	0	x	0	1	x	1	x	x	x	0	0	x	x	x	x	x	x	1	x	x	x	x	1	1	0	x	x	x	x	x
dmb BARRIER	x	1	0	x	0	1	x	1	x	x	x	0	0	x	x	x	x	x	x	1	x	x	x	x	x	x	1	x	x	x	x	x
sys UIMM3_OP1 Cn Cm UIMM3_OP2 Rt	x	1	0	x	0	1	x	1	x	x	0	0	1	o			n				m				o			t
sysl Rt UIMM3_OP1 Cn Cm UIMM3_OP2	x	1	0	x	0	1	x	1	x	x	1	0	1	o			n				m				o			t
msr SYSREG Rt	x	1	0	x	0	1	x	1	x	x	0	1	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
mrs Rt SYSREG	x	1	0	x	0	1	x	1	x	x	1	1	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	t
cbz Rt ADDR_PCREL19	x	x	1	x	0	1	0	0	i																			t
tbz Rt BIT_NUM ADDR_PCREL14	b	x	1	x	0	1	1	0	b					i														t
cbnz Rt ADDR_PCREL19	x	x	1	x	0	1	0	1	i																			t
tbnz Rt BIT_NUM ADDR_PCREL14	b	x	1	x	0	1	1	1	b					i														t
st4 LVt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	0	0	0	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x
stnp Ft Ft2 ADDR_SIMM7	x	x	1	0	1	1	0	0	0	0	i							t					x	x	x	x	x	t
st1 LEt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	1	0	0	0	x	x	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	x	x	x
st2 LEt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	1	0	0	1	x	x	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	x	x	x
st3 LEt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	1	0	0	0	x	x	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
st4 LEt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	1	0	0	1	x	x	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x
stp Ft Ft2 ADDR_SIMM7	x	x	1	0	1	1	0	1	0	0	i							t					x	x	x	x	x	t
st4 LVt SIMD_ADDR_POST	x	x	0	0	1	1	0	0	1	0	0	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x
st1 LEt SIMD_ADDR_POST	x	x	0	0	1	1	0	1	1	0	0	x	x	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	x	x	x
st3 LEt SIMD_ADDR_POST	x	x	0	0	1	1	0	1	1	0	0	x	x	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x
st2 LEt SIMD_ADDR_POST	x	x	0	0	1	1	0	x	1	0	1	x	x	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	x	x	x
st4 LEt SIMD_ADDR_POST	x	x	0	0	1	1	0	x	1	0	1	x	x	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x
stp Ft Ft2 ADDR_SIMM7	x	x	1	0	1	1	0	I	1	0	i							t					x	x	x	x	x	t
ld4 LVt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	0	0	1	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x
ldnp Ft Ft2 ADDR_SIMM7	x	x	1	0	1	1	0	0	0	1	i							t					x	x	x	x	x	t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ld1 LEt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	1	0	1	0	x	x	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	x	x	x
ld2 LEt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	1	0	1	1	x	x	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	x	x	x
ld3 LEt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	1	0	1	0	x	x	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x
ld4 LEt SIMD_ADDR_SIMPLE	x	x	0	0	1	1	0	1	0	1	1	x	x	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x
ldp Ft Ft2 ADDR_SIMM7	x	x	1	0	1	1	0	1	0	1	i							t					x	x	x	x	x	t
ld4 LVt SIMD_ADDR_POST	x	x	0	0	1	1	0	0	1	1	0	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x	x
ld1 LEt SIMD_ADDR_POST	x	x	0	0	1	1	0	1	1	1	0	x	x	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	x	x	x
ld3 LEt SIMD_ADDR_POST	x	x	0	0	1	1	0	1	1	1	0	x	x	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x
ld2 LEt SIMD_ADDR_POST	x	x	0	0	1	1	0	x	1	1	1	x	x	x	x	x	x	x	0	x	x	x	x	x	x	x	x	x	x	x	x	x
ld4 LEt SIMD_ADDR_POST	x	x	0	0	1	1	0	x	1	1	1	x	x	x	x	x	x	x	1	x	x	x	x	x	x	x	x	x	x	x	x	x
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ldp Ft Ft2 ADDR_SIMM7	x	x	1	0	1	1	0	I	1	1	i							t					x	x	x	x	x	t
ldr Ft ADDR_PCREL19	x	x	0	1	1	1	0	0	i																			t
stur Ft ADDR_SIMM9	x	x	1	1	1	1	0	0	x	0	x	i									0	0	x	x	x	x	x	t
ldur Ft ADDR_SIMM9	x	x	1	1	1	1	0	0	x	1	x	i									0	0	x	x	x	x	x	t
str Ft ADDR_REGOFF	x	x	1	1	1	1	0	0	x	0	x	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
ldr Ft ADDR_REGOFF	x	x	1	1	1	1	0	0	x	1	x	x	x	x	x	x	x	x	x	x	1	0	x	x	x	x	x	t
str Ft ADDR_SIMM9	x	x	1	1	1	1	0	0	x	0	x	i									I	1	x	x	x	x	x	t
ldr Ft ADDR_SIMM9	x	x	1	1	1	1	0	0	x	1	x	i									I	1	x	x	x	x	x	t
str Ft ADDR_UIMM12	x	x	x	1	1	1	0	1	x	0	i												n					t
ldr Ft ADDR_UIMM12	x	x	x	1	1	1	0	1	x	1	i												n					t
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
tbl Vd LVn Vm	x	x	0	0	1	1	1	0	x	x	0	m					x	x	x	0	0	0	n					d
tbx Vd LVn Vm	x	x	0	0	1	1	1	0	x	x	0	m					x	x	x	1	0	0	n					d
trn1 Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	0	m					x	0	x	0	1	0	n					d
trn2 Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	0	m					x	1	x	0	1	0	n					d
uzp1 Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	0	m					x	0	0	1	1	0	n					d
uzp2 Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	0	m					x	1	0	1	1	0	n					d
zip1 Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	0	m					x	0	1	1	1	0	n					d
zip2 Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	0	m					x	1	1	1	1	0	n					d
ext Vd Vn Vm IDX	x	x	1	0	1	1	1	0	x	x	0	m					x	i				0	n					d
dup Vd En	x	x	0	0	1	1	1	0	x	x	0	x	x	x	x	x	x	x	x	x	0	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
dup Vd Rn	x	x	0	0	1	1	1	0	x	x	0	x	x	x	x	x	x	x	0	0	1	1	n					d
smov Rd En	x	x	0	0	1	1	1	0	x	x	0	x	x	x	x	x	x	x	1	0	1	1	n					d
ins Ed Rn	x	x	0	0	1	1	1	0	x	x	0	x	x	x	x	x	x	x	0	1	1	1	n					d
umov Rd En	x	x	0	0	1	1	1	0	x	x	0	x	x	x	x	x	x	x	1	1	1	1	n					d
ins Ed En	x	x	1	0	1	1	1	0	x	x	0	x	x	x	x	x	x	x	x	x	x	1	n					d
fcvtzs Rd Fn FBITS	x	0	x	1	1	1	1	0	x	x	0	x	x	x	0	0	S						n					d
scvtf Fd Rn FBITS	x	0	x	1	1	1	1	0	x	x	0	x	x	x	1	0	S						n					d
fcvtzu Rd Fn FBITS	x	0	x	1	1	1	1	0	x	x	0	x	x	x	0	1	S						n					d
ucvtf Fd Rn FBITS	x	0	x	1	1	1	1	0	x	x	0	x	x	x	1	1	S						n					d
sha1c Fd Fn Vm	x	1	x	1	1	1	1	0	x	x	0	m					x	0	0	0	x	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sha256h Fd Fn Vm	x	1	x	1	1	1	1	0	x	x	0	m					x	1	0	0	x	0	n					d
sha1m Fd Fn Vm	x	1	x	1	1	1	1	0	x	x	0	m					x	0	1	0	x	0	n					d
sha256su1 Vd Vn Vm	x	1	x	1	1	1	1	0	x	x	0	m					x	1	1	0	x	0	n					d
sha1p Fd Fn Vm	x	1	x	1	1	1	1	0	x	x	0	m					x	0	0	1	x	0	n					d
sha256h2 Fd Fn Vm	x	1	x	1	1	1	1	0	x	x	0	m					x	1	0	1	x	0	n					d
sha1su0 Vd Vn Vm	x	1	x	1	1	1	1	0	x	x	0	m					x	x	1	1	x	0	n					d
dup Sd En	x	1	x	1	1	1	1	0	x	x	0	x	x	x	x	x	x	x	x	x	x	1	n					d
saddl Vd Vn Vm	x	0	0	0	1	1	1	0	x	x	1	m					0	0	0	0	0	0	n					d
saddl2 Vd Vn Vm	x	1	0	0	1	1	1	0	x	x	1	m					0	0	0	0	0	0	n					d
uaddl Vd Vn Vm	x	0	1	0	1	1	1	0	x	x	1	m					0	0	0	0	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
uaddl2 Vd Vn Vm	x	1	1	0	1	1	1	0	x	x	1	m					0	0	0	0	0	0	n					d
fcvtns Rd Fn	x	x	x	1	1	1	1	0	x	x	1	0	0	0	0	0	0	0	0	0	0	0	n					d
fcvtms Rd Fn	x	x	x	1	1	1	1	0	x	x	1	1	0	0	0	0	0	0	0	0	0	0	n					d
fcvtps Rd Fn	x	x	x	1	1	1	1	0	x	x	1	0	1	0	0	0	0	0	0	0	0	0	n					d
fcvtzs Rd Fn	x	x	x	1	1	1	1	0	x	x	1	1	1	0	0	0	0	0	0	0	0	0	n					d
fcvtas Rd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	0	0	0	0	0	0	0	0	n					d
scvtf Fd Rn	x	x	x	1	1	1	1	0	x	x	1	x	x	0	1	0	0	0	0	0	0	0	n					d
fmov Rd Fn	x	x	x	1	1	1	1	0	x	x	1	x	0	1	1	0	0	0	0	0	0	0	n					d
fmov Rd VnD1	x	x	x	1	1	1	1	0	x	x	1	x	1	1	1	0	0	0	0	0	0	0	n					d
fcvtnu Rd Fn	x	x	x	1	1	1	1	0	x	x	1	0	0	0	0	1	0	0	0	0	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fcvtmu Rd Fn	x	x	x	1	1	1	1	0	x	x	1	1	0	0	0	1	0	0	0	0	0	0	n					d
fcvtpu Rd Fn	x	x	x	1	1	1	1	0	x	x	1	0	1	0	0	1	0	0	0	0	0	0	n					d
fcvtzu Rd Fn	x	x	x	1	1	1	1	0	x	x	1	1	1	0	0	1	0	0	0	0	0	0	n					d
fcvtau Rd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	0	1	0	0	0	0	0	0	n					d
ucvtf Fd Rn	x	x	x	1	1	1	1	0	x	x	1	x	x	0	1	1	0	0	0	0	0	0	n					d
fmov Fd Rn	x	x	x	1	1	1	1	0	x	x	1	x	0	1	1	1	0	0	0	0	0	0	n					d
fmov VdD1 Rn	x	x	x	1	1	1	1	0	x	x	1	x	1	1	1	1	0	0	0	0	0	0	n					d
smlal Vd Vn Vm	x	0	0	x	1	1	1	0	x	x	1	m					1	0	0	0	0	0	n					d
smlal2 Vd Vn Vm	x	1	0	x	1	1	1	0	x	x	1	m					1	0	0	0	0	0	n					d
umlal Vd Vn Vm	x	0	1	x	1	1	1	0	x	x	1	m					1	0	0	0	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
umlal2 Vd Vn Vm	x	1	1	x	1	1	1	0	x	x	1	m					1	0	0	0	0	0	n					d
addhn Vd Vn Vm	x	0	0	0	1	1	1	0	x	x	1	m					0	1	0	0	0	0	n					d
addhn2 Vd Vn Vm	x	1	0	0	1	1	1	0	x	x	1	m					0	1	0	0	0	0	n					d
raddhn Vd Vn Vm	x	0	1	0	1	1	1	0	x	x	1	m					0	1	0	0	0	0	n					d
raddhn2 Vd Vn Vm	x	1	1	0	1	1	1	0	x	x	1	m					0	1	0	0	0	0	n					d
smull Vd Vn Vm	x	0	0	0	1	1	1	0	x	x	1	m					1	1	0	0	0	0	n					d
smull2 Vd Vn Vm	x	1	0	0	1	1	1	0	x	x	1	m					1	1	0	0	0	0	n					d
umull Vd Vn Vm	x	0	1	0	1	1	1	0	x	x	1	m					1	1	0	0	0	0	n					d
umull2 Vd Vn Vm	x	1	1	0	1	1	1	0	x	x	1	m					1	1	0	0	0	0	n					d
fmov Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	0	0	0	0	1	0	0	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
frintn Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	0	0	0	1	0	0	0	0	n					d
fneg Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	0	0	1	0	1	0	0	0	0	n					d
frintm Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	0	1	0	1	0	0	0	0	n					d
fabs Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	0	0	0	1	1	0	0	0	0	n					d
frintp Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	0	0	1	1	0	0	0	0	n					d
fsqrt Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	0	0	1	1	1	0	0	0	0	n					d
frintz Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	0	1	1	1	0	0	0	0	n					d
fcvt Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	0	1	x	x	1	0	0	0	0	n					d
frinta Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	1	0	0	1	0	0	0	0	n					d
frintx Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	1	1	0	1	0	0	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
frinti Fd Fn	x	x	x	1	1	1	1	0	x	x	1	x	x	1	1	x	1	1	0	0	0	0	n					d
ssubl Vd Vn Vm	x	0	0	0	1	1	1	0	x	x	1	m					0	0	1	0	0	0	n					d
ssubl2 Vd Vn Vm	x	1	0	0	1	1	1	0	x	x	1	m					0	0	1	0	0	0	n					d
usubl Vd Vn Vm	x	0	1	0	1	1	1	0	x	x	1	m					0	0	1	0	0	0	n					d
usubl2 Vd Vn Vm	x	1	1	0	1	1	1	0	x	x	1	m					0	0	1	0	0	0	n					d
fcmp Fn Fm	x	x	x	1	1	1	1	0	x	x	1	m					0	0	1	0	0	0	n					0	0	x	x	x
fcmpe Fn Fm	x	x	x	1	1	1	1	0	x	x	1	m					0	0	1	0	0	0	n					1	0	x	x	x
fcmp Fn FPIMM0	x	x	x	1	1	1	1	0	x	x	1	x	x	x	x	x	0	0	1	0	0	0	n					0	1	x	x	x
fcmpe Fn FPIMM0	x	x	x	1	1	1	1	0	x	x	1	x	x	x	x	x	0	0	1	0	0	0	n					1	1	x	x	x
smlsl Vd Vn Vm	x	0	0	x	1	1	1	0	x	x	1	m					1	0	1	0	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
smlsl2 Vd Vn Vm	x	1	0	x	1	1	1	0	x	x	1	m					1	0	1	0	0	0	n					d
umlsl Vd Vn Vm	x	0	1	x	1	1	1	0	x	x	1	m					1	0	1	0	0	0	n					d
umlsl2 Vd Vn Vm	x	1	1	x	1	1	1	0	x	x	1	m					1	0	1	0	0	0	n					d
subhn Vd Vn Vm	x	0	0	x	1	1	1	0	x	x	1	m					0	1	1	0	0	0	n					d
subhn2 Vd Vn Vm	x	1	0	x	1	1	1	0	x	x	1	m					0	1	1	0	0	0	n					d
rsubhn Vd Vn Vm	x	0	1	x	1	1	1	0	x	x	1	m					0	1	1	0	0	0	n					d
rsubhn2 Vd Vn Vm	x	1	1	x	1	1	1	0	x	x	1	m					0	1	1	0	0	0	n					d
pmull Vd Vn Vm	x	0	x	x	1	1	1	0	x	0	1	m					1	1	1	0	0	0	n					d
pmull2 Vd Vn Vm	x	1	x	x	1	1	1	0	x	0	1	m					1	1	1	0	0	0	n					d
pmull Vd Vn Vm	x	0	x	x	1	1	1	0	x	1	1	m					1	1	1	0	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
pmull2 Vd Vn Vm	x	1	x	x	1	1	1	0	x	1	1	m					1	1	1	0	0	0	n					d
saddw Vd Vn Vm	x	0	0	0	1	1	1	0	x	x	1	m					0	0	0	1	0	0	n					d
saddw2 Vd Vn Vm	x	1	0	0	1	1	1	0	x	x	1	m					0	0	0	1	0	0	n					d
uaddw Vd Vn Vm	x	0	1	0	1	1	1	0	x	x	1	m					0	0	0	1	0	0	n					d
uaddw2 Vd Vn Vm	x	1	1	0	1	1	1	0	x	x	1	m					0	0	0	1	0	0	n					d
sqdmlal Vd Vn Vm	x	0	x	0	1	1	1	0	x	x	1	m					1	0	0	1	0	0	n					d
sqdmlal2 Vd Vn Vm	x	1	x	0	1	1	1	0	x	x	1	m					1	0	0	1	0	0	n					d
sabal Vd Vn Vm	x	0	0	0	1	1	1	0	x	x	1	m					0	1	0	1	0	0	n					d
sabal2 Vd Vn Vm	x	1	0	0	1	1	1	0	x	x	1	m					0	1	0	1	0	0	n					d
uabal Vd Vn Vm	x	0	1	0	1	1	1	0	x	x	1	m					0	1	0	1	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
uabal2 Vd Vn Vm	x	1	1	0	1	1	1	0	x	x	1	m					0	1	0	1	0	0	n					d
sqdmull Vd Vn Vm	x	0	x	0	1	1	1	0	x	x	1	m					1	1	0	1	0	0	n					d
sqdmull2 Vd Vn Vm	x	1	x	0	1	1	1	0	x	x	1	m					1	1	0	1	0	0	n					d
ssubw Vd Vn Vm	x	0	0	0	1	1	1	0	x	x	1	m					0	0	1	1	0	0	n					d
ssubw2 Vd Vn Vm	x	1	0	0	1	1	1	0	x	x	1	m					0	0	1	1	0	0	n					d
usubw Vd Vn Vm	x	0	1	0	1	1	1	0	x	x	1	m					0	0	1	1	0	0	n					d
usubw2 Vd Vn Vm	x	1	1	0	1	1	1	0	x	x	1	m					0	0	1	1	0	0	n					d
sqdmlsl Vd Vn Vm	x	0	x	0	1	1	1	0	x	x	1	m					1	0	1	1	0	0	n					d
sqdmlsl2 Vd Vn Vm	x	1	x	0	1	1	1	0	x	x	1	m					1	0	1	1	0	0	n					d
sabdl Vd Vn Vm	x	0	0	0	1	1	1	0	x	x	1	m					x	1	1	1	0	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sabdl2 Vd Vn Vm	x	1	0	0	1	1	1	0	x	x	1	m					x	1	1	1	0	0	n					d
uabdl Vd Vn Vm	x	0	1	0	1	1	1	0	x	x	1	m					x	1	1	1	0	0	n					d
uabdl2 Vd Vn Vm	x	1	1	0	1	1	1	0	x	x	1	m					x	1	1	1	0	0	n					d
fmov Fd FPIMM	x	0	x	1	1	1	1	0	x	x	1	i								1	0	0	x	x	x	x	x	d
sqdmlal Sd Sn Sm	x	1	x	1	1	1	1	0	x	x	1	m					x	0	0	1	0	0	n					d
sqdmull Sd Sn Sm	x	1	x	1	1	1	1	0	x	x	1	m					x	1	0	1	0	0	n					d
sqdmlsl Sd Sn Sm	x	1	x	1	1	1	1	0	x	x	1	m					x	x	1	1	0	0	n					d
rev64 Vd Vn	x	x	0	0	1	1	1	0	x	x	1	x	x	x	x	x	0	0	0	0	1	0	n					d
rev32 Vd Vn	x	x	1	0	1	1	1	0	x	x	1	x	x	x	x	x	0	0	0	0	1	0	n					d
fmul Fd Fn Fm	x	0	x	1	1	1	1	0	x	x	1	m					0	0	0	0	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sha1h Fd Fn	x	1	x	1	1	1	1	0	x	x	1	x	x	x	x	x	0	0	0	0	1	0	n					d
cmgt Vd Vn IMM0	x	x	0	0	1	1	1	0	x	x	1	x	x	x	x	0	1	0	0	0	1	0	n					d
cmge Vd Vn IMM0	x	x	1	0	1	1	1	0	x	x	1	x	x	x	x	0	1	0	0	0	1	0	n					d
frintn Vd Vn	x	x	0	0	1	1	1	0	0	x	1	x	x	x	x	1	1	0	0	0	1	0	n					d
frinta Vd Vn	x	x	1	0	1	1	1	0	0	x	1	x	x	x	x	1	1	0	0	0	1	0	n					d
frintp Vd Vn	x	x	x	0	1	1	1	0	1	x	1	x	x	x	x	1	1	0	0	0	1	0	n					d
fnmul Fd Fn Fm	x	0	0	1	1	1	1	0	x	x	1	m					1	0	0	0	1	0	n					d
cmgt Sd Sn IMM0	x	1	0	1	1	1	1	0	x	x	1	x	x	x	x	x	1	0	0	0	1	0	n					d
cmge Sd Sn IMM0	x	x	1	1	1	1	1	0	x	x	1	x	x	x	x	x	1	0	0	0	1	0	n					d
cls Vd Vn	x	x	0	0	1	1	1	0	x	x	1	x	0	x	x	0	0	1	0	0	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
clz Vd Vn	x	x	1	0	1	1	1	0	x	x	1	x	0	x	x	0	0	1	0	0	1	0	n					d
aese Vd Vn	x	x	x	0	1	1	1	0	x	x	1	x	1	x	x	0	0	1	0	0	1	0	n					d
sqxtn Vd Vn	x	0	0	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	0	0	1	0	n					d
sqxtn2 Vd Vn	x	1	0	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	0	0	1	0	n					d
uqxtn Vd Vn	x	0	1	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	0	0	1	0	n					d
uqxtn2 Vd Vn	x	1	1	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	0	0	1	0	n					d
fmax Fd Fn Fm	x	0	0	1	1	1	1	0	x	x	1	m					0	1	0	0	1	0	n					d
sqxtn Sd Sn	x	1	0	1	1	1	1	0	x	x	1	x	x	x	x	x	0	1	0	0	1	0	n					d
uqxtn Sd Sn	x	x	1	1	1	1	1	0	x	x	1	x	x	x	x	x	0	1	0	0	1	0	n					d
fcmgt Vd Vn IMM0	x	x	0	0	1	1	1	0	x	x	1	0	x	x	x	0	1	1	0	0	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fcmge Vd Vn IMM0	x	x	1	0	1	1	1	0	x	x	1	0	x	x	x	0	1	1	0	0	1	0	n					d
fcmgt Sd Sn IMM0	x	x	0	1	1	1	1	0	x	x	1	0	x	x	x	0	1	1	0	0	1	0	n					d
fcmge Sd Sn IMM0	x	x	1	1	1	1	1	0	x	x	1	0	x	x	x	0	1	1	0	0	1	0	n					d
fmaxnmv Fd Vn	x	x	x	0	1	1	1	0	0	x	1	1	x	x	x	0	1	1	0	0	1	0	n					d
fmaxnmp Sd Vn	x	x	x	1	1	1	1	0	0	x	1	1	x	x	x	0	1	1	0	0	1	0	n					d
fminnmv Fd Vn	x	x	x	0	1	1	1	0	1	x	1	1	x	x	x	0	1	1	0	0	1	0	n					d
fminnmp Sd Vn	x	x	x	1	1	1	1	0	1	x	1	1	x	x	x	0	1	1	0	0	1	0	n					d
fcvtas Vd Vn	x	x	0	0	1	1	1	0	0	x	1	x	x	x	x	1	1	1	0	0	1	0	n					d
fcvtau Vd Vn	x	x	1	0	1	1	1	0	0	x	1	x	x	x	x	1	1	1	0	0	1	0	n					d
fcvtas Sd Sn	x	x	0	1	1	1	1	0	0	x	1	x	x	x	x	1	1	1	0	0	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fcvtau Sd Sn	x	x	1	1	1	1	1	0	0	x	1	x	x	x	x	1	1	1	0	0	1	0	n					d
urecpe Vd Vn	x	x	0	x	1	1	1	0	1	x	1	x	x	x	x	1	1	1	0	0	1	0	n					d
ursqrte Vd Vn	x	x	1	x	1	1	1	0	1	x	1	x	x	x	x	1	1	1	0	0	1	0	n					d
saddlp Vd Vn	x	x	0	0	1	1	1	0	x	x	1	x	x	x	x	0	0	0	1	0	1	0	n					d
uaddlp Vd Vn	x	x	1	0	1	1	1	0	x	x	1	x	x	x	x	0	0	0	1	0	1	0	n					d
xtn Vd Vn	x	0	0	0	1	1	1	0	x	x	1	x	x	x	x	1	0	0	1	0	1	0	n					d
xtn2 Vd Vn	x	1	0	0	1	1	1	0	x	x	1	x	x	x	x	1	0	0	1	0	1	0	n					d
sqxtun Vd Vn	x	0	1	0	1	1	1	0	x	x	1	x	x	x	x	1	0	0	1	0	1	0	n					d
sqxtun2 Vd Vn	x	1	1	0	1	1	1	0	x	x	1	x	x	x	x	1	0	0	1	0	1	0	n					d
fadd Fd Fn Fm	x	0	0	1	1	1	1	0	x	x	1	m					0	0	1	0	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sha256su0 Vd Vn	x	1	0	1	1	1	1	0	x	x	1	x	x	x	x	x	0	0	1	0	1	0	n					d
sqxtun Sd Sn	x	x	1	1	1	1	1	0	x	x	1	x	x	x	x	x	0	0	1	0	1	0	n					d
cmlt Vd Vn IMM0	x	x	x	0	1	1	1	0	x	x	1	0	x	x	x	0	1	0	1	0	1	0	n					d
cmlt Sd Sn IMM0	x	x	x	1	1	1	1	0	x	x	1	0	x	x	x	0	1	0	1	0	1	0	n					d
smaxv Fd Vn	x	x	0	x	1	1	1	0	x	x	1	1	x	x	x	0	1	0	1	0	1	0	n					d
umaxv Fd Vn	x	x	1	x	1	1	1	0	x	x	1	1	x	x	x	0	1	0	1	0	1	0	n					d
fcvtns Vd Vn	x	x	0	0	1	1	1	0	0	x	1	0	x	x	x	1	1	0	1	0	1	0	n					d
fcvtnu Vd Vn	x	x	1	0	1	1	1	0	0	x	1	0	x	x	x	1	1	0	1	0	1	0	n					d
fcvtns Sd Sn	x	x	0	1	1	1	1	0	0	x	1	0	x	x	x	1	1	0	1	0	1	0	n					d
fcvtnu Sd Sn	x	x	1	1	1	1	1	0	0	x	1	0	x	x	x	1	1	0	1	0	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fcvtps Vd Vn	x	x	0	0	1	1	1	0	1	x	1	0	x	x	x	1	1	0	1	0	1	0	n					d
fcvtpu Vd Vn	x	x	1	0	1	1	1	0	1	x	1	0	x	x	x	1	1	0	1	0	1	0	n					d
fcvtps Sd Sn	x	x	0	1	1	1	1	0	1	x	1	0	x	x	x	1	1	0	1	0	1	0	n					d
fcvtpu Sd Sn	x	x	1	1	1	1	1	0	1	x	1	0	x	x	x	1	1	0	1	0	1	0	n					d
sminv Fd Vn	x	x	0	x	1	1	1	0	x	x	1	1	x	x	x	1	1	0	1	0	1	0	n					d
uminv Fd Vn	x	x	1	x	1	1	1	0	x	x	1	1	x	x	x	1	1	0	1	0	1	0	n					d
sadalp Vd Vn	x	x	0	0	1	1	1	0	x	x	1	x	0	x	x	0	0	1	1	0	1	0	n					d
uadalp Vd Vn	x	x	1	0	1	1	1	0	x	x	1	x	0	x	x	0	0	1	1	0	1	0	n					d
aesmc Vd Vn	x	x	x	0	1	1	1	0	x	x	1	x	1	x	x	0	0	1	1	0	1	0	n					d
fcvtn Vd Vn	x	0	0	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	1	0	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fcvtn2 Vd Vn	x	1	0	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	1	0	1	0	n					d
fcvtxn Vd Vn	x	0	1	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	1	0	1	0	n					d
fcvtxn2 Vd Vn	x	1	1	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	1	0	1	0	n					d
fmaxnm Fd Fn Fm	x	x	0	1	1	1	1	0	x	x	1	m					0	1	1	0	1	0	n					d
fcvtxn Sd Sn	x	x	1	1	1	1	1	0	x	x	1	x	x	x	x	x	0	1	1	0	1	0	n					d
fcmlt Vd Vn IMM0	x	x	x	0	1	1	1	0	x	x	1	x	x	x	x	x	1	1	1	0	1	0	n					d
fcmlt Sd Sn IMM0	x	x	x	1	1	1	1	0	x	x	1	x	x	x	x	x	1	1	1	0	1	0	n					d
rev16 Vd Vn	x	x	x	0	1	1	1	0	x	x	1	x	x	x	x	x	0	0	0	1	1	0	n					d
fdiv Fd Fn Fm	x	0	x	1	1	1	1	0	x	x	1	m					0	0	0	1	1	0	n					d
sha1su1 Vd Vn	x	1	x	1	1	1	1	0	x	x	1	x	x	x	x	x	0	0	0	1	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
cmeq Vd Vn IMM0	x	x	0	0	1	1	1	0	x	x	1	x	x	x	x	0	1	0	0	1	1	0	n					d
cmle Vd Vn IMM0	x	x	1	0	1	1	1	0	x	x	1	x	x	x	x	0	1	0	0	1	1	0	n					d
cmeq Sd Sn IMM0	x	x	0	1	1	1	1	0	x	x	1	x	x	x	x	0	1	0	0	1	1	0	n					d
cmle Sd Sn IMM0	x	x	1	1	1	1	1	0	x	x	1	x	x	x	x	0	1	0	0	1	1	0	n					d
frintm Vd Vn	x	x	0	x	1	1	1	0	0	x	1	x	x	x	x	1	1	0	0	1	1	0	n					d
frintx Vd Vn	x	x	1	x	1	1	1	0	0	x	1	x	x	x	x	1	1	0	0	1	1	0	n					d
frintz Vd Vn	x	x	0	x	1	1	1	0	1	x	1	x	x	x	x	1	1	0	0	1	1	0	n					d
frinti Vd Vn	x	x	1	x	1	1	1	0	1	x	1	x	x	x	x	1	1	0	0	1	1	0	n					d
cnt Vd Vn	x	x	0	0	1	1	1	0	x	x	1	x	0	x	x	x	0	1	0	1	1	0	n					d
not Vd Vn	x	x	1	0	1	1	1	0	x	0	1	x	0	x	x	x	0	1	0	1	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
rbit Vd Vn	x	x	1	0	1	1	1	0	x	1	1	x	0	x	x	x	0	1	0	1	1	0	n					d
aesd Vd Vn	x	x	x	0	1	1	1	0	x	x	1	x	1	x	x	x	0	1	0	1	1	0	n					d
fmin Fd Fn Fm	x	x	x	1	1	1	1	0	x	x	1	m					0	1	0	1	1	0	n					d
fcmeq Vd Vn IMM0	x	x	0	0	1	1	1	0	x	x	1	0	x	x	x	0	1	1	0	1	1	0	n					d
fcmle Vd Vn IMM0	x	x	1	0	1	1	1	0	x	x	1	0	x	x	x	0	1	1	0	1	1	0	n					d
fcmeq Sd Sn IMM0	x	x	0	1	1	1	1	0	x	x	1	0	x	x	x	0	1	1	0	1	1	0	n					d
fcmle Sd Sn IMM0	x	x	1	1	1	1	1	0	x	x	1	0	x	x	x	0	1	1	0	1	1	0	n					d
faddp Sd Vn	x	x	x	x	1	1	1	0	x	x	1	1	x	x	x	0	1	1	0	1	1	0	n					d
scvtf Vd Vn	x	x	0	0	1	1	1	0	0	x	1	x	x	x	x	1	1	1	0	1	1	0	n					d
ucvtf Vd Vn	x	x	1	0	1	1	1	0	0	x	1	x	x	x	x	1	1	1	0	1	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
scvtf Sd Sn	x	x	0	1	1	1	1	0	0	x	1	x	x	x	x	1	1	1	0	1	1	0	n					d
ucvtf Sd Sn	x	x	1	1	1	1	1	0	0	x	1	x	x	x	x	1	1	1	0	1	1	0	n					d
frecpe Vd Vn	x	x	0	0	1	1	1	0	1	x	1	x	x	x	x	1	1	1	0	1	1	0	n					d
frsqrte Vd Vn	x	x	1	0	1	1	1	0	1	x	1	x	x	x	x	1	1	1	0	1	1	0	n					d
frecpe Sd Sn	x	x	0	1	1	1	1	0	1	x	1	x	x	x	x	1	1	1	0	1	1	0	n					d
frsqrte Sd Sn	x	x	1	1	1	1	1	0	1	x	1	x	x	x	x	1	1	1	0	1	1	0	n					d
suqadd Vd Vn	x	x	0	0	1	1	1	0	x	x	1	0	x	x	x	0	0	0	1	1	1	0	n					d
usqadd Vd Vn	x	x	1	0	1	1	1	0	x	x	1	0	x	x	x	0	0	0	1	1	1	0	n					d
saddlv Fd Vn	x	x	0	0	1	1	1	0	x	x	1	1	x	x	x	0	0	0	1	1	1	0	n					d
uaddlv Fd Vn	x	x	1	0	1	1	1	0	x	x	1	1	x	x	x	0	0	0	1	1	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
shll Vd Vn SHLL_IMM	x	0	x	0	1	1	1	0	x	x	1	x	x	x	x	1	0	0	1	1	1	0	n					d
shll2 Vd Vn SHLL_IMM	x	1	x	0	1	1	1	0	x	x	1	x	x	x	x	1	0	0	1	1	1	0	n					d
fsub Fd Fn Fm	x	0	0	1	1	1	1	0	x	x	1	m					0	0	1	1	1	0	n					d
suqadd Sd Sn	x	1	0	1	1	1	1	0	x	x	1	x	x	x	x	x	0	0	1	1	1	0	n					d
usqadd Sd Sn	x	x	1	1	1	1	1	0	x	x	1	x	x	x	x	x	0	0	1	1	1	0	n					d
abs Vd Vn	x	x	0	0	1	1	1	0	x	x	1	x	x	x	x	0	1	0	1	1	1	0	n					d
neg Vd Vn	x	x	1	0	1	1	1	0	x	x	1	x	x	x	x	0	1	0	1	1	1	0	n					d
abs Sd Sn	x	x	0	1	1	1	1	0	x	x	1	x	x	x	x	0	1	0	1	1	1	0	n					d
neg Sd Sn	x	x	1	1	1	1	1	0	x	x	1	x	x	x	x	0	1	0	1	1	1	0	n					d
fcvtms Vd Vn	x	x	0	0	1	1	1	0	0	x	1	0	x	x	x	1	1	0	1	1	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fcvtmu Vd Vn	x	x	1	0	1	1	1	0	0	x	1	0	x	x	x	1	1	0	1	1	1	0	n					d
fcvtms Sd Sn	x	x	0	1	1	1	1	0	0	x	1	0	x	x	x	1	1	0	1	1	1	0	n					d
fcvtmu Sd Sn	x	x	1	1	1	1	1	0	0	x	1	0	x	x	x	1	1	0	1	1	1	0	n					d
fcvtzs Vd Vn	x	x	0	0	1	1	1	0	1	x	1	0	x	x	x	1	1	0	1	1	1	0	n					d
fcvtzu Vd Vn	x	x	1	0	1	1	1	0	1	x	1	0	x	x	x	1	1	0	1	1	1	0	n					d
fcvtzs Sd Sn	x	x	0	1	1	1	1	0	1	x	1	0	x	x	x	1	1	0	1	1	1	0	n					d
fcvtzu Sd Sn	x	x	1	1	1	1	1	0	1	x	1	0	x	x	x	1	1	0	1	1	1	0	n					d
addv Fd Vn	x	x	x	0	1	1	1	0	x	x	1	1	x	x	x	1	1	0	1	1	1	0	n					d
addp Sd Vn	x	x	x	1	1	1	1	0	x	x	1	1	x	x	x	1	1	0	1	1	1	0	n					d
sqabs Vd Vn	x	x	0	0	1	1	1	0	x	x	1	x	0	x	x	0	0	1	1	1	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sqneg Vd Vn	x	x	1	0	1	1	1	0	x	x	1	x	0	x	x	0	0	1	1	1	1	0	n					d
aesimc Vd Vn	x	x	x	0	1	1	1	0	x	x	1	x	1	x	x	0	0	1	1	1	1	0	n					d
fcvtl Vd Vn	x	0	x	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	1	1	1	0	n					d
fcvtl2 Vd Vn	x	1	x	0	1	1	1	0	x	x	1	x	x	x	x	1	0	1	1	1	1	0	n					d
fminnm Fd Fn Fm	x	0	0	1	1	1	1	0	x	x	1	m					0	1	1	1	1	0	n					d
sqabs Sd Sn	x	1	0	1	1	1	1	0	x	x	1	x	x	x	x	x	0	1	1	1	1	0	n					d
sqneg Sd Sn	x	x	1	1	1	1	1	0	x	x	1	x	x	x	x	x	0	1	1	1	1	0	n					d
fabs Vd Vn	x	x	0	x	1	1	1	0	x	x	1	0	x	x	x	0	1	1	1	1	1	0	n					d
fneg Vd Vn	x	x	1	x	1	1	1	0	x	x	1	0	x	x	x	0	1	1	1	1	1	0	n					d
fmaxv Fd Vn	x	x	x	0	1	1	1	0	0	x	1	1	x	x	x	0	1	1	1	1	1	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fmaxp Sd Vn	x	x	x	1	1	1	1	0	0	x	1	1	x	x	x	0	1	1	1	1	1	0	n					d
fminv Fd Vn	x	x	x	0	1	1	1	0	1	x	1	1	x	x	x	0	1	1	1	1	1	0	n					d
fminp Sd Vn	x	x	x	1	1	1	1	0	1	x	1	1	x	x	x	0	1	1	1	1	1	0	n					d
fsqrt Vd Vn	x	x	x	0	1	1	1	0	x	x	1	x	x	x	x	1	1	1	1	1	1	0	n					d
frecpx Sd Sn	x	x	x	1	1	1	1	0	x	x	1	x	x	x	x	1	1	1	1	1	1	0	n					d
shadd Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	0	0	0	0	1	n					d
uhadd Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	0	0	0	0	1	n					d
add Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					1	0	0	0	0	1	n					d
sub Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					1	0	0	0	0	1	n					d
sshl Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	1	0	0	0	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
ushl Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	1	0	0	0	1	n					d
fmaxnm Vd Vn Vm	x	x	0	0	1	1	1	0	0	x	1	m					1	1	0	0	0	1	n					d
fmaxnmp Vd Vn Vm	x	x	1	0	1	1	1	0	0	x	1	m					1	1	0	0	0	1	n					d
fminnm Vd Vn Vm	x	x	0	0	1	1	1	0	1	x	1	m					1	1	0	0	0	1	n					d
fminnmp Vd Vn Vm	x	x	1	0	1	1	1	0	1	x	1	m					1	1	0	0	0	1	n					d
shsub Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	0	1	0	0	1	n					d
uhsub Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	0	1	0	0	1	n					d
smaxp Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					1	0	1	0	0	1	n					d
umaxp Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					1	0	1	0	0	1	n					d
smax Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	1	1	0	0	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
umax Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	1	1	0	0	1	n					d
fcmeq Vd Vn Vm	x	x	0	0	1	1	1	0	0	x	1	m					1	1	1	0	0	1	n					d
fcmge Vd Vn Vm	x	x	1	0	1	1	1	0	0	x	1	m					1	1	1	0	0	1	n					d
fcmgt Vd Vn Vm	x	x	x	0	1	1	1	0	1	x	1	m					1	1	1	0	0	1	n					d
srhadd Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	0	0	1	0	1	n					d
urhadd Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	0	0	1	0	1	n					d
mla Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					1	0	0	1	0	1	n					d
mls Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					1	0	0	1	0	1	n					d
srshl Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	1	0	1	0	1	n					d
urshl Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	1	0	1	0	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fadd Vd Vn Vm	x	x	0	0	1	1	1	0	0	x	1	m					1	1	0	1	0	1	n					d
faddp Vd Vn Vm	x	x	1	0	1	1	1	0	0	x	1	m					1	1	0	1	0	1	n					d
fsub Vd Vn Vm	x	x	0	0	1	1	1	0	1	x	1	m					1	1	0	1	0	1	n					d
fabd Vd Vn Vm	x	x	1	0	1	1	1	0	1	x	1	m					1	1	0	1	0	1	n					d
cmgt Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	0	1	1	0	1	n					d
cmhi Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	0	1	1	0	1	n					d
sqdmulh Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					1	0	1	1	0	1	n					d
sqrdmulh Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					1	0	1	1	0	1	n					d
sabd Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	1	1	1	0	1	n					d
uabd Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	1	1	1	0	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fmax Vd Vn Vm	x	x	0	0	1	1	1	0	0	x	1	m					1	1	1	1	0	1	n					d
fmaxp Vd Vn Vm	x	x	1	0	1	1	1	0	0	x	1	m					1	1	1	1	0	1	n					d
fmin Vd Vn Vm	x	x	0	0	1	1	1	0	1	x	1	m					1	1	1	1	0	1	n					d
fminp Vd Vn Vm	x	x	1	0	1	1	1	0	1	x	1	m					1	1	1	1	0	1	n					d
fccmp Fn Fm NZCV COND	x	0	0	1	1	1	1	0	x	x	1	m					x	x	x	x	0	1	n					0	c
fccmpe Fn Fm NZCV COND	x	0	0	1	1	1	1	0	x	x	1	m					x	x	x	x	0	1	n					1	c
add Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					x	0	0	0	0	1	n					d
sshl Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					x	1	0	0	0	1	n					d
fcmeq Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					x	x	1	0	0	1	n					d
srshl Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					x	x	0	1	0	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
cmgt Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					0	x	1	1	0	1	n					d
sqdmulh Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					1	x	1	1	0	1	n					d
sub Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					x	0	0	0	0	1	n					d
ushl Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					x	1	0	0	0	1	n					d
fcmge Sd Sn Sm	x	x	1	1	1	1	1	0	0	x	1	m					x	x	1	0	0	1	n					d
fcmgt Sd Sn Sm	x	x	1	1	1	1	1	0	1	x	1	m					x	x	1	0	0	1	n					d
urshl Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					0	x	0	1	0	1	n					d
fabd Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					1	x	0	1	0	1	n					d
cmhi Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					0	x	1	1	0	1	n					d
sqrdmulh Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					1	x	1	1	0	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sqadd Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	0	0	0	1	1	n					d
uqadd Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	0	0	0	1	1	n					d
cmtst Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					1	0	0	0	1	1	n					d
cmeq Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					1	0	0	0	1	1	n					d
sqshl Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	1	0	0	1	1	n					d
uqshl Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	1	0	0	1	1	n					d
fmla Vd Vn Vm	x	x	x	0	1	1	1	0	0	x	1	m					1	1	0	0	1	1	n					d
fmls Vd Vn Vm	x	x	x	0	1	1	1	0	1	x	1	m					1	1	0	0	1	1	n					d
sqsub Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	0	1	0	1	1	n					d
uqsub Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	0	1	0	1	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sminp Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					1	0	1	0	1	1	n					d
uminp Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					1	0	1	0	1	1	n					d
smin Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	1	1	0	1	1	n					d
umin Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	1	1	0	1	1	n					d
facge Vd Vn Vm	x	x	x	0	1	1	1	0	0	x	1	m					1	1	1	0	1	1	n					d
facgt Vd Vn Vm	x	x	x	0	1	1	1	0	1	x	1	m					1	1	1	0	1	1	n					d
and Vd Vn Vm	x	x	0	0	1	1	1	0	0	0	1	m					0	0	0	1	1	1	n					d
eor Vd Vn Vm	x	x	1	0	1	1	1	0	0	0	1	m					0	0	0	1	1	1	n					d
orr Vd Vn Vm	x	x	0	0	1	1	1	0	1	0	1	m					0	0	0	1	1	1	n					d
bit Vd Vn Vm	x	x	1	0	1	1	1	0	1	0	1	m					0	0	0	1	1	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
bic Vd Vn Vm	x	x	0	0	1	1	1	0	0	1	1	m					0	0	0	1	1	1	n					d
bsl Vd Vn Vm	x	x	1	0	1	1	1	0	0	1	1	m					0	0	0	1	1	1	n					d
orn Vd Vn Vm	x	x	0	0	1	1	1	0	1	1	1	m					0	0	0	1	1	1	n					d
bif Vd Vn Vm	x	x	1	0	1	1	1	0	1	1	1	m					0	0	0	1	1	1	n					d
mul Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					1	0	0	1	1	1	n					d
pmul Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					1	0	0	1	1	1	n					d
sqrshl Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	1	0	1	1	1	n					d
uqrshl Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	1	0	1	1	1	n					d
fmulx Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					1	1	0	1	1	1	n					d
fmul Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					1	1	0	1	1	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
cmge Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	0	1	1	1	1	n					d
cmhs Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	0	1	1	1	1	n					d
addp Vd Vn Vm	x	x	x	0	1	1	1	0	x	x	1	m					1	0	1	1	1	1	n					d
saba Vd Vn Vm	x	x	0	0	1	1	1	0	x	x	1	m					0	1	1	1	1	1	n					d
uaba Vd Vn Vm	x	x	1	0	1	1	1	0	x	x	1	m					0	1	1	1	1	1	n					d
frecps Vd Vn Vm	x	x	0	0	1	1	1	0	0	x	1	m					1	1	1	1	1	1	n					d
fdiv Vd Vn Vm	x	x	1	0	1	1	1	0	0	x	1	m					1	1	1	1	1	1	n					d
frsqrts Vd Vn Vm	x	x	x	0	1	1	1	0	1	x	1	m					1	1	1	1	1	1	n					d
fcsel Fd Fn Fm COND	x	0	0	1	1	1	1	0	x	x	1	m					x	x	x	x	1	1	n					d
sqadd Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					0	0	0	0	1	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
cmtst Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					1	0	0	0	1	1	n					d
sqshl Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					x	1	0	0	1	1	n					d
sqsub Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					x	x	1	0	1	1	n					d
sqrshl Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					0	x	0	1	1	1	n					d
fmulx Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					1	x	0	1	1	1	n					d
cmge Sd Sn Sm	x	1	0	1	1	1	1	0	x	x	1	m					x	0	1	1	1	1	n					d
frecps Sd Sn Sm	x	1	0	1	1	1	1	0	0	x	1	m					x	1	1	1	1	1	n					d
frsqrts Sd Sn Sm	x	1	0	1	1	1	1	0	1	x	1	m					x	1	1	1	1	1	n					d
uqadd Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					0	0	0	0	1	1	n					d
cmeq Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					1	0	0	0	1	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
uqshl Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					x	1	0	0	1	1	n					d
uqsub Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					x	0	1	0	1	1	n					d
facge Sd Sn Sm	x	x	1	1	1	1	1	0	0	x	1	m					x	1	1	0	1	1	n					d
facgt Sd Sn Sm	x	x	1	1	1	1	1	0	1	x	1	m					x	1	1	0	1	1	n					d
uqrshl Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					x	x	0	1	1	1	n					d
cmhs Sd Sn Sm	x	x	1	1	1	1	1	0	x	x	1	m					x	x	1	1	1	1	n					d
mla Vd Vn Em	x	x	x	0	1	1	1	1	x	x	x	m					0	0	0	0	x	0	n					d
mls Vd Vn Em	x	x	x	0	1	1	1	1	x	x	x	m					0	1	0	0	x	0	n					d
smlal Vd Vn Em	x	0	0	0	1	1	1	1	x	x	x	m					0	0	1	0	x	0	n					d
smlal2 Vd Vn Em	x	1	0	0	1	1	1	1	x	x	x	m					0	0	1	0	x	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
umlal Vd Vn Em	x	0	1	0	1	1	1	1	x	x	x	m					0	0	1	0	x	0	n					d
umlal2 Vd Vn Em	x	1	1	0	1	1	1	1	x	x	x	m					0	0	1	0	x	0	n					d
smlsl Vd Vn Em	x	0	0	0	1	1	1	1	x	x	x	m					0	1	1	0	x	0	n					d
smlsl2 Vd Vn Em	x	1	0	0	1	1	1	1	x	x	x	m					0	1	1	0	x	0	n					d
umlsl Vd Vn Em	x	0	1	0	1	1	1	1	x	x	x	m					0	1	1	0	x	0	n					d
umlsl2 Vd Vn Em	x	1	1	0	1	1	1	1	x	x	x	m					0	1	1	0	x	0	n					d
fmla Vd Vn Em	x	x	x	0	1	1	1	1	x	x	x	m					0	0	0	1	x	0	n					d
fmls Vd Vn Em	x	x	x	0	1	1	1	1	x	x	x	m					0	1	0	1	x	0	n					d
sqdmlal Vd Vn Em	x	0	x	0	1	1	1	1	x	x	x	m					0	0	1	1	x	0	n					d
sqdmlal2 Vd Vn Em	x	1	x	0	1	1	1	1	x	x	x	m					0	0	1	1	x	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sqdmlsl Vd Vn Em	x	0	x	0	1	1	1	1	x	x	x	m					0	1	1	1	x	0	n					d
sqdmlsl2 Vd Vn Em	x	1	x	0	1	1	1	1	x	x	x	m					0	1	1	1	x	0	n					d
movi Vd SIMD_IMM_SFT	x	x	0	0	1	1	1	1	x	x	x	x	x	x	x	x	0	x	x	0	x	1	x	x	x	x	x	d
mvni Vd SIMD_IMM_SFT	x	x	1	0	1	1	1	1	x	x	x	x	x	x	x	x	0	x	x	0	x	1	x	x	x	x	x	d
orr Vd SIMD_IMM_SFT	x	x	0	0	1	1	1	1	x	x	x	x	x	x	x	x	0	x	x	1	x	1	x	x	x	x	x	d
bic Vd SIMD_IMM_SFT	x	x	1	0	1	1	1	1	x	x	x	x	x	x	x	x	0	x	x	1	x	1	x	x	x	x	x	d
fmadd Fd Fn Fm Fa	x	0	0	1	1	1	1	1	x	x	0	m					0	a					n					d
fnmadd Fd Fn Fm Fa	x	0	0	1	1	1	1	1	x	x	1	m					0	a					n					d
fmla Sd Sn Em	x	1	0	1	1	1	1	1	x	x	x	m					0	0	0	x	x	0	n					d
fmls Sd Sn Em	x	1	0	1	1	1	1	1	x	x	x	m					0	1	0	x	x	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sqdmlal Sd Sn Em	x	1	0	1	1	1	1	1	x	x	x	m					0	0	1	x	x	0	n					d
sqdmlsl Sd Sn Em	x	1	0	1	1	1	1	1	x	x	x	m					0	1	1	x	x	0	n					d
sshr Sd Sn IMM_VLSR	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	0	x	0	0	x	1	n					d
srshr Sd Sn IMM_VLSR	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	0	x	1	0	x	1	n					d
ssra Sd Sn IMM_VLSR	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	0	0	0	1	x	1	n					d
shl Sd Sn IMM_VLSL	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	0	1	0	1	x	1	n					d
srsra Sd Sn IMM_VLSR	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	0	0	1	1	x	1	n					d
sqshl Sd Sn IMM_VLSL	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	0	1	1	1	x	1	n					d
ushr Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	0	0	0	0	x	x	n					d
sri Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	0	1	0	0	x	x	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
urshr Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	0	0	1	0	x	x	n					d
sqshlu Sd Sn IMM_VLSL	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	0	1	1	0	x	x	n					d
usra Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	0	0	0	1	x	x	n					d
sli Sd Sn IMM_VLSL	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	0	1	0	1	x	x	n					d
ursra Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	0	0	1	1	x	x	n					d
uqshl Sd Sn IMM_VLSL	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	0	1	1	1	x	x	n					d
mul Vd Vn Em	x	x	x	0	1	1	1	1	x	x	x	m					1	0	0	0	x	0	n					d
sqdmulh Vd Vn Em	x	x	x	0	1	1	1	1	x	x	x	m					1	1	0	0	x	0	n					d
smull Vd Vn Em	x	0	0	0	1	1	1	1	x	x	x	m					1	x	1	0	x	0	n					d
smull2 Vd Vn Em	x	1	0	0	1	1	1	1	x	x	x	m					1	x	1	0	x	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
umull Vd Vn Em	x	0	1	0	1	1	1	1	x	x	x	m					1	x	1	0	x	0	n					d
umull2 Vd Vn Em	x	1	1	0	1	1	1	1	x	x	x	m					1	x	1	0	x	0	n					d
fmul Vd Vn Em	x	x	0	0	1	1	1	1	x	x	x	m					1	0	0	1	x	0	n					d
fmulx Vd Vn Em	x	x	1	0	1	1	1	1	x	x	x	m					1	0	0	1	x	0	n					d
sqrdmulh Vd Vn Em	x	x	x	0	1	1	1	1	x	x	x	m					1	1	0	1	x	0	n					d
sqdmull Vd Vn Em	x	0	x	0	1	1	1	1	x	x	x	m					1	x	1	1	x	0	n					d
sqdmull2 Vd Vn Em	x	1	x	0	1	1	1	1	x	x	x	m					1	x	1	1	x	0	n					d
movi Vd SIMD_IMM_SFT	x	x	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	0	x	0	0	1	x	x	x	x	x	d
mvni Vd SIMD_IMM_SFT	x	x	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	0	x	0	0	1	x	x	x	x	x	d
orr Vd SIMD_IMM_SFT	x	x	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	0	x	1	0	1	x	x	x	x	x	d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
bic Vd SIMD_IMM_SFT	x	x	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	0	x	1	0	1	x	x	x	x	x	d
movi Vd SIMD_IMM_SFT	x	x	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	1	0	x	0	1	x	x	x	x	x	d
mvni Vd SIMD_IMM_SFT	x	x	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	1	0	x	0	1	x	x	x	x	x	d
movi Vd SIMD_IMM	x	x	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	1	1	0	0	1	x	x	x	x	x	d
movi Sd SIMD_IMM	x	x	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	1	1	0	0	1	x	x	x	x	x	d
fmov Vd SIMD_FPIMM	x	x	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	1	1	1	0	1	x	x	x	x	x	d
fmov Vd SIMD_FPIMM	x	x	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	1	1	1	0	1	x	x	x	x	x	d
rshrn Vd Vn IMM_VLSR	x	0	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	x	0	1	1	n					d
rshrn2 Vd Vn IMM_VLSR	x	1	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	x	0	1	1	n					d
sqrshrun Vd Vn IMM_VLSR	x	0	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	x	0	1	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
sqrshrun2 Vd Vn IMM_VLSR	x	1	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	x	0	1	1	n					d
sqrshrn Vd Vn IMM_VLSR	x	0	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	0	1	1	1	n					d
sqrshrn2 Vd Vn IMM_VLSR	x	1	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	0	1	1	1	n					d
uqrshrn Vd Vn IMM_VLSR	x	0	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	0	1	1	1	n					d
uqrshrn2 Vd Vn IMM_VLSR	x	1	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	0	1	1	1	n					d
fcvtzs Vd Vn IMM_VLSR	x	x	0	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	1	1	1	1	n					d
fcvtzu Vd Vn IMM_VLSR	x	x	1	0	1	1	1	1	x	x	x	x	x	x	x	x	1	x	1	1	1	1	n					d
fmsub Fd Fn Fm Fa	x	0	0	1	1	1	1	1	x	x	0	m					1	a					n					d
fnmsub Fd Fn Fm Fa	x	0	0	1	1	1	1	1	x	x	1	m					1	a					n					d
sqdmulh Sd Sn Em	x	1	0	1	1	1	1	1	x	x	x	m					1	x	x	0	x	0	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
fmul Sd Sn Em	x	1	0	1	1	1	1	1	x	x	x	m					1	0	0	1	x	0	n					d
sqrdmulh Sd Sn Em	x	1	0	1	1	1	1	1	x	x	x	m					1	1	0	1	x	0	n					d
sqdmull Sd Sn Em	x	1	0	1	1	1	1	1	x	x	x	m					1	x	1	1	x	0	n					d
scvtf Sd Sn IMM_VLSR	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	x	0	0	1	n					d
sqshrn Sd Sn IMM_VLSR	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	x	1	0	1	n					d
sqrshrn Sd Sn IMM_VLSR	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	0	x	1	1	n					d
fcvtzs Sd Sn IMM_VLSR	x	1	0	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	1	x	1	1	n					d
fmulx Sd Sn Em	x	x	1	1	1	1	1	1	x	x	x	m					1	x	x	x	x	0	n					d
sqshrun Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	0	0	0	1	n					d
ucvtf Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	1	0	0	1	n					d
	31	30	29	28	27	26	25	24	23	22	21	20	19	18	17	16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
uqshrn Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	x	1	0	1	n					d
sqrshrun Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	x	0	1	1	n					d
uqrshrn Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	0	1	1	1	n					d
fcvtzu Sd Sn IMM_VLSR	x	x	1	1	1	1	1	1	x	x	x	x	x	x	x	x	1	x	1	1	1	1	n					d

LLVM : Control Flow Graph

2012-10-09T02:02:00.002+08:00

主要紀錄 LLVM Basic Block 走訪方式

建議可搭配 LLVM 寫一個 pass - 教學入門篇一起玩
另外這是 GCC 的對照組GCC : Control Flow Graph

0. 使用前注意

通常在 LLVM 裡面你會是在某個 Pass 裡面去走訪 CFG,
而這個時候你必須明確告訴 LLVM 你有使用 CFG, 然後他在呼叫你的 pass 之前就一定會幫你準備好
要作到這件事則必須把以下函數加入到你的 Pass 的那個 struct/class 中

virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  AU.setPreservesCFG();
}

1. 走訪該函數所有的 Basic Block

Function F;

for (Function::iterator itr = F.begin();
     itr != F.end();
     ++itr) {
  BasicBlock &bb = *itr;
}

2. 走訪 basic block 的所有 successor

BasicBlock bb;
for (succ_iterator itr = succ_begin(&bb);
     itr != succ_end(&bb);
     ++itr) {
     BasicBlock *succ = *itr;

}

3. 走訪 basic block 的所有 Predecessor

BasicBlock bb;
for (pred_iterator itr = pred_begin(&bb);
     itr != pred_end(&bb);
     ++itr) {
     BasicBlock *pred = *itr;

}

4. 取得 Function 的 Entry Basic Block

要注意的是收的變數最好是 Reference !

Function F;

BasicBlock &bb = F.getEntryBlock();

5. Basic Block中所有指令

BasicBlock bb;
for (BasicBlock::iterator itr = bb.begin();
     itr != bb.end();
     ++itr) {
  Instruction &inst = *itr;
}

跳過所有 PHI Node

BasicBlock bb;
for (BasicBlock::iterator itr = bb.getFirstNonPHI();
     itr != bb.end();
     ++itr) {
  Instruction &inst = *itr;
}

另外還有getFirstNonPHIOrDbg () 及 getFirstNonPHIOrDbgOrLifetime () 可以跳過除錯資訊及Lifetime 的資訊

6. 走訪一個函數裡面所有 BB 中的指令之FunctionPass 範例程式碼

#define DEBUG_TYPE "hello"
#include "llvm/Pass.h"
#include "llvm/Function.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Support/CFG.h"
using namespace llvm;

STATISTIC(HelloCounter, "Counts number of functions greeted");

namespace {
  // Hello - The first implementation, without getAnalysisUsage.
  struct Hello : public FunctionPass {
    static char ID; // Pass identification, replacement for typeid
    Hello() : FunctionPass(ID) {}

    virtual bool runOnFunction(Function &F) {
      ++HelloCounter;
      errs() << "Hello: ";
      errs() << F.getName() << '\n';
      for (Function::iterator itr = F.begin();
           itr != F.end();
           ++itr) {
        BasicBlock &bb = *itr;
        errs() << "Basic block :" << bb.getName () << "\n";
        errs() << "successor : {";
        for (succ_iterator ssitr = succ_begin(&bb);
             ssitr != succ_end(&bb);
             ++ssitr) {
          BasicBlock *ss = *ssitr;
          errs() << ss->getName() <<", ";
        }
        errs() << "}\n";
        errs() << "predecessors : {";
        for (pred_iterator ssitr = pred_begin(&bb);
             ssitr != pred_end(&bb);
             ++ssitr) {
          BasicBlock *ss = *ssitr;
          errs() << ss->getName() <<", ";
        }
        errs() << "}\n";
        for (BasicBlock::iterator iitr = bb.begin();
             iitr != bb.end();
             ++iitr) {
          Instruction &inst = *iitr;
          errs() << inst << '\n';
        }

      }
      return false;
    }
    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
      AU.setPreservesCFG();
    }
  };
}

char Hello::ID = 0;
static RegisterPass<Hello> X("hello", "Hello World Pass");

建置與安裝 LLVM + Clang

2012-10-08T20:29:00.001+08:00

這篇文章教你怎麼從 LLVM trunk 下載 Source code, 並且建置與安裝 LLVM + Clang

下載程式碼

git clone http://llvm.org/git/llvm.git llvm
cd llvm/tools
git clone http://llvm.org/git/clang.git
cd ../../

建置 llvm

有興趣的話 configure 可以加個 --enable-cxx11
--enable-optimized 則是會用 -O2 來建置

mkdir build-llvm
cd build-llvm
../llvm/configure --prefix=$HOME --enable-optimized
make -j8
make install

將 llvm 加入 path

將下面那一行加到 .bashrc 中

export PATH=$HOME/bin:$PATH

然後重新開啟一個 console/terminal 以利重新載入環境變數接著檢查一下路徑看看是不是正確的

which clang

預期應該是會輸出

~/bin/clang

接著執行看看吧!

clang -v

應該是會跟你吐類似下面的訊息, 在不同電腦上可能會有一點不同

clang version 3.2 
Target: x86_64-unknown-linux-gnu
Thread model: posix

clang 的選項大致上跟 gcc 很類似, 可以 --help 看一下選項

clang --help

使用 clang 編譯

clang hello.c -o hello

使用 clang 編譯成 bitcode

clang hello.c -o hello.bc -c -emit-llvm

使用 clang 編譯成 bitcode, 並且使用 lli 執行

clang hello.c -o hello.bc -c -emit-llvm
lli hello.bc

把玩 LLVM

[1] LLVM 寫一個 pass - 入門篇
[2] Writing an LLVM Pass

LLVM 寫一個 pass - 教學入門篇

2012-10-08T19:43:00.002+08:00

注意!! 這篇文章並非官方的 Writing an LLVM Pass 的中文翻譯版本!!

而是精簡版, 採用建置方式是將 pass 的程式碼獨立於 LLVM 的 Source tree 外
這樣的好處是可避免與整串 LLVM 搞在一起, 並且對於整體建置流程會較為清楚

這篇文章對於讀者有些假設 :

已經會建置 LLVM (不會? 建置與安裝 LLVM + Clang)
對於 Makefile 有一點基礎知識 (沒有? 快來惡補)

1. 先從 LLVM 抄一個 Hello Pass

#define DEBUG_TYPE "hello"
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;

namespace {
  // Hello - The first implementation, without getAnalysisUsage.
  struct Hello : public FunctionPass {
    static char ID; // Pass identification, replacement for typeid
    Hello() : FunctionPass(ID) {}

    virtual bool runOnFunction(Function &F) {
      errs() << "Hello: ";
      errs() << F.getName() << '\n';
      return false;
    }
  };
}

char Hello::ID = 0;
static RegisterPass<Hello> X("hello", "Hello World Pass");

將上列程式碼儲存成 Hello.cpp 或著任何你喜歡的檔名
原程式碼上面有一些授權宣告跟註解, 基於文章版面配置將那部份移除, 其詳細授權見LLVM Developer Policy
說明？能建置成功前先把細節拋一邊吧

2. 建置 Makefile

LLVM_CONFIG=llvm-config

CXX=`$(LLVM_CONFIG) --bindir`/clang
CXXFLAGS=`$(LLVM_CONFIG) --cppflags` -fPIC -fno-rtti
LDFLAGS=`$(LLVM_CONFIG) --ldflags`

all: hello.so

hello.so: Hello.o
        $(CXX) -shared Hello.o -o hello.so $(LDFLAGS) -fPIC

Hello.o: Hello.cpp
        $(CXX) -c Hello.cpp -o Hello.o $(CXXFLAGS)

clean:
        rm -f *.o hello.so

把上面內容抄到與 Hello.cpp 同目錄下的 Makefile 中
注意一下 Makefile 建置動作前面的是 Tab 字元不是空白字元, 相當重要
這邊唯一要注意的是 LLVM_CONFIG 要設定為你安裝的 llvm 路徑裡面的那個 llvm-config
例如 LLVM 裝在家目錄底下, 那麼 LLVM_CONFIG 就設定為 /home/kito/bin/llvm-config

3. 建置與測試

接著執行 make,

make

應該會吐出下面兩行

`llvm-config --bindir`/clang -c Hello.cpp -o Hello.o `llvm-config --cppflags` -fPIC
`llvm-config --bindir`/clang -shared Hello.o -o hello.so `llvm-config --ldflags` -fPIC

然後目錄下應該會出現 Hello.so 才對

ls
# Hello.cpp  Hello.o  hello.so  Makefile

接著寫個 Hello World 的小程式

#include <stdio.h>

int main () {
  printf("Hello LLVM!\n");
}

將以上簡單內容存檔成 HelloWorld.c 接著把 Hello World 產生 .bc 檔, 加上 -emit-llvm 告訴 llvm 你要產生 bitcode

clang -c -emit-llvm -o HelloWorld.bc HelloWorld.c

最後步驟就是把你的 HelloWorld.bc 丟到前面寫的 Hello Pass !

opt -load ./hello.so -hello HelloWorld.bc -o /dev/null

後面 -o /dev/null 的意思是叫 opt 把經過最佳化或分析的結果直接丟掉
執行完後 LLVM 就會跟你說 Hello 了!

Hello: main

main 是你 Hello World 中的 Function 名稱

4. 回頭看一下 Hello Pass

DEBUG_TYPE 是 LLVM 拿來統計該 pass 被呼叫幾次或著是使用 DEBUG 輸出除錯訊息的時候用的

#define DEBUG_TYPE "hello"

include 要用到的 LLVM 的

#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/Statistic.h"

把 llvm namespace 的東西都弄進來, 雖然這是不好的習慣, 不過由於方便起見直接 using 下去吧XD

using namespace llvm;

匿名 namespace, 避免 export 裡面的 symbol,
聽無上一句在講啥就先跳過就可以了

namespace {

Hello 繼承 FunctionPass, 代表 Hello Pass 的輸入是以 Function 為單位

  // Hello - The first implementation, without getAnalysisUsage.
  struct Hello : public FunctionPass {

現階段下面這行就照抄吧
給 LLVM 用來識別這個 Pass 的 id

    static char ID; // Pass identification, replacement for typeid

Constructor

    Hello() : FunctionPass(ID) {}

這邊則是整個 pass 的精華所在, LLVM 會以一次一個 Function 為單位, 餵進來給你玩
大致上裡面的行為就是將餵進來的 Function 的名稱印出來而已
其中 return false 是告訴 LLVM 你沒有修改任何東西

    virtual bool runOnFunction(Function &F) {
      errs() << "Hello: ";
      errs() << F.getName()) << '\n';
      return false;
    }

class 跟 namespace 的結束, 沒啥好說的

  };
}

定義下一下 Hello::ID 的實體

char Hello::ID = 0;

跟 LLVM 註冊你的這個 Pass, 第一個參數是 pass name, 第二個則是說明用的文字

static RegisterPass<hello> X("hello", "Hello World Pass");

5. 解析 Makefile

先指定 llvm-config 執行檔的所在位置, 如果 llvm-config 已經加到 PATH 中的話那就填 llvm-config 就好

LLVM_CONFIG=llvm-config

llvm-config 這隻程式可以幫你產生出大部分你所需的 flag
用 --help 可以檢視所有可用選項

llvm-config --help

指定編譯器使用 clang, 單純個人喜好XD

CXX=`$(LLVM_CONFIG) --bindir`/clang

指定編譯的參數, 大部分從 llvm-config --cppflags 即可,
但由於我們現在是要編譯的是 Shared Library 所以要加 -fPIC
不知道 Shared Library 是啥? 快去弄一本程式設計師的自我修養來 K 阿~~
-fno-rtti 則是指定不產生 Run-time Typeinfo 的資訊，加了此選項後 typeid 及 dynamic_cast 會無法使用，基於實作成本 LLVM 在這方面有實作自己一套的 RTTI 機制

CXXFLAGS=`$(LLVM_CONFIG) --cppflags` -fPIC -fno-rtti

指定 Link 的參數, 大部分從 llvm-config --ldflags 即可,
現在是要編譯的是 Shared Library 所以加 -shared

LDFLAGS=`$(LLVM_CONFIG) --ldflags` -shared

我們總共要建置 hello.so

all: hello.so

hello.so 怎麼生勒?, 生之前要先生出 Hello.o
然後下面一行則是建置規則

hello.so: Hello.o
        $(CXX) Hello.o -o hello.so $(LDFLAGS)

Hello.o 的建置規則, 以及其相依 Hello.cpp

Hello.o: Hello.cpp
        $(CXX) -c Hello.cpp -o Hello.o $(CXXFLAGS)

寫 Makefile 時寫個 clean 的 rule 是個好習慣 :)

clean:
        rm -f *.o hello.so

參考

[1] Writing an LLVM Pass
[2] 程式設計師的自我修養－連結、載入、程式庫

Update Note

(2012/11/16) 在較新版的 llvm-config 無提供 -fno-rtti 選項，必須自行在 CXXFLAGS 那邊自行添加
(201211/22) 上面提到那個項目目前不確定是 bug 還是怎樣，cmake 出來的 llvm-config 不會有 -fno-rtti，但 configure 建置出來的 llvm-config 則會有
(2018/10/18) 更新範例中的 include path, 已測試於 LLVM 6 及 7

C++11 : Strongly typed enumerations (enum class)

2012-09-19T11:54:00.001+08:00

回顧 enum

在 C++11 以前以下 enum 會污染整個 namespace

大致的意思是如果你宣告了一個 enum E, 他有 A, B, C 三個值

enum E {
  A,  
  B,  
  C,  
};

那麼在這個 namespace 底下你就不能先告任何以 A, B, C 為 ID 型別或變數

enum E {
  A,  
  B,  
  C,  
};

int A; /* Oop, compiler 會跟你抱怨 A 這個符號重複定義了!! */

而且很不近乎人情的你想要使用 E::A 的方式取值還會跟你抱怨 E 不是一個 namespace 或 class
(在 VC++ 中有 extension 讓你可以這樣取)

C++11 前的折衷作法

這種情況事實上也不是不能解, 只要在 enum 外面包一層 namespace 即可, 但看起來會有點鳥就是了

namespace E {
  enum Type {
    A,  
    B,  
    C,  
  };
}

int A; /* A 這個 ID 可以用了! */

int var = E::B; /* 取用方式也以用 E:: 的方式取用 */

E::Type e = E::A; /* 最大缺點就是 Type name 會變成 E::Type */

enum 的型別問題

前一段包一層 namespace 的作法可以解決大部分的問題,

但是事實上 enum 還有一個問題就是, enum 常被拿來定義常數,

但是他實際的型別不明!!

在標準中也沒有規範 enum 要占多少大小

所以在大部分實作中, 大部分會以 int 來處理

在必要的時候他會長大成 64-bit 的 long long

#include <stdio.h>

enum E1 {
  A = 213,
  B,
  C,
};

enum E2 {
  D = 21343245325435ll,
  E,
  F,
};

int main(){
  printf("%zd\n", sizeof(enum E1)); /* 印出 4 */
  printf("%zd\n", sizeof(enum E2)); /* 印出 8 */
  return 0;
}
/* 註: 環境是 Fedora 17 x86-64
       編譯器為 g++ 4.6.3 以及 clang++  3.2 */

enum 的型別問題在哪?

enum E {
  A = 0x0ea92d6f << 4,
  B,
  C,
};

int main(){
  unsigned v = A;
  switch (v) {
    case A: /* gcc 4.6.3 可以 通過, clang 會跟你抱怨 - 359475472 沒辦法降轉到 unsigned! */
      break;
    default:
      break;
  }
  return 0;
}

/* 註: 環境是 Fedora 17 x86-64
       編譯器為 g++ 4.6.3 以及 clang++  3.2 */

enum E {
  A = 0x0ea92d6fu << 4, /*這邊加個 suffix u 就可解決 */
  B,
  C,
};

int main(){
  unsigned v = A;
  switch (v) {
    case A:
      break;
    default:
      break;
  }
  return 0;
}

/* 註: 環境是 Fedora 17 x86-64
       編譯器為 g++ 4.6.3 以及 clang++  3.2 */

當然第一眼看到可能會覺得這是編譯器實作問題,

但是事實上最核心的問題是

enum 的型別是啥

個人認為這等於在整個型別檢查上開了個漏洞...雖然 C 的 Type system 本來就很薄弱

C++ 則是不幸的承受了 C 的一切

Strongly typed enumerations

C++11 中目前加入了 Strongly typed enumerations 以及一些語法上的改進

解決了上列所提到的問題點

ENUM::VAL

enum E {
  A = 0x0ea92d6f,
  B,
  C,
};

int main(){
  int v1 = E::A; /* Ohhh 現在這是合法的使用方式了 */
  int v2 = A; /* 舊有取值方式向下相容 */
  return v;
}

型別問題

enum E : long long { /* 可以明確指定底層使用型別! */
  A = 123,
  B,
  C,
};

int main() {
  printf("%zd\n", sizeof(E)); /* 8 ! */
  return 0;
}

Strong Type

enum 除了可以拿來當常數宣告外,

在只拿來當列舉值時, 你可能就不會喜歡他能跟類 int 型別互轉不用錢的特性了

enum class E { /* 加個 class enum 換成 Strong Type! */
  A = 123,
  B,
  C,
};

int main() {
  int val = E::A; /* 跟你抱怨不能從 E 強轉成 int */
  return 0;
}

接著他也可以跟前面指定形別的語法結合

enum class E : long long { /* 加個 class enum 換成 Strong Type!
                             並且指定為 long long */
  A = 123,
  B,
  C,
};

最後要注意一點的是雖然他加了個 class, 不過他依然只是 enum, 不能有 member data 及 member function

vim 顯示多餘空白( trailing whitespace )

2012-09-03T11:41:00.001+08:00

目前找到最短最方便的 script :D

" High light unwanted spaces in end of line
highlight ExtraWhitespace ctermbg=darkred guibg=darkcyan
autocmd BufEnter * if &ft != 'help' | match ExtraWhitespace /\s\+$/ | endif
autocmd BufEnter * if &ft == 'help' | match none /\s\+$/ | endif

把上面幾行丟到 ~/.vimrc 即可

預覽

紅色部份就是多餘的空白/Tab 字元

typeid in c++11

2012-08-17T23:47:00.003+08:00

在 C++11 裡面把 typeid 拔掉, 取而代之的是 decltype

所以如果 code 有到的話

目前過渡期解法就在 Compile Flag 加個 `-Dtypeof=decltype` 吧

範例:

g++ -std=c++0x -Dtypeof=decltype foo.cpp
g++ -std=c++11 -Dtypeof=decltype foo.cpp

但如果 compiler 跟你抱怨 rvalue 不能轉 T& 的話...就用下面這有點邪門的解法吧

首先先在 code 頂端或著某個一定會 include 的 header 檔加入以下的 code

template<class T> struct unref     { typedef T type; };
template<class T> struct unref<T&> { typedef T type; };

然後編譯選項換成下面這樣

g++ -std=c++0x -Dtypeof\(x\)="unref<decltype(x)>::type" foo.cpp
g++ -std=c++11 -Dtypeof\(x\)="unref<decltype(x)>::type" foo.cpp

c++ 真的是越來越難學易用了XD...

參考

How can I use decltype to get the type of a reference? (from Stackoverflow)

git diff 使用 GUI 工具 diffmerge

2012-08-17T12:24:00.002+08:00

在 git 使用時 git diff 是個很常會使用指令

但 git diff 是在 console 底下, 在某些情況下可能會有些吃力

這時候如果有 GUI 工具可以輔助的話效果會不錯

上面的圖示就是使用 diffmerge 的畫面, 左邊那調紅色代表兩邊不一樣的地方
左邊是舊有的右邊則是目前的, 並且右邊的視窗可以編輯

設定

而要使用 diffmerge 當 difftool 的話輸入以下指令設定

git config --global diff.tool diffmerge
git config --global difftool.diffmerge.cmd 'diffmerge "$LOCAL" "$REMOTE"'
git config --global merge.tool diffmerge
git config --global mergetool.diffmerge.cmd 'diffmerge --merge --result="$MERGED" "$LOCAL" "$(if test -f "$BASE"; then echo "$BASE"; else echo "$LOCAL"; fi)" "$REMOTE"'
git config --global mergetool.diffmerge.trustExitCode true

而之後使用 git difftool 或 git mergetool 則可呼叫出 diffmerge!

參考資料

Using DiffMerge as your Git visual merge and diff tool

GCC : Control Flow Graph

2012-08-15T01:04:00.000+08:00

趁著記憶新鮮的時候先來紀錄一下

每個 Compiler 裡面的重要基礎設施之一就是 Control Flow Graph, 也就是 Basic Block 及其 Edge, 而這邊大概介紹一下 GCC 內部的資料結構及走訪方式, 主要參考來源是 GCC Source Code 及 GCC Internal.
GCC 的 Basic Block 在實作上要比較注意的一點是 GIMPLE 及 RTL 都會使用同樣得資料結構來表示, 但 RTL 的部份照慣例一樣是 expand 完後才會有, 而且同一個時間點只會是 GIMPLE 或 RTL

詳細的程式碼則可到 gcc/basic-block.h 裡面撈

1. Basic Block

在整個 CFG 中有兩個特別的 Block 一個是 ENTRY_BLOCK, 一個是 EXIT_BLOCK 他們分別可由 ENTRY_BLOCK_PTR EXIT_BLOCK_PTR 取得

在 basic_block 這個 struct 中有 next_bb 及 prev_bb 兩個欄位, 但沒事請直接別碰這兩個傢伙, 要走訪所有的 Basic Block 或要找兒子/父親的話下面有一些範例程式碼

走訪所有 Basic Block

basic_block bb;

FOR_EACH_BB (bb) {
  /* do something */
}

要注意的一點是有個東西叫 FOR_ALL_BB, 差別在於他會走到 ENTRY_BLOCK 跟 EXIT_BLOCK 而 FOR_EACH_BB 不會

basic_block bb;

FOR_ALL_BB (bb) {
  /* do something */
}

找父親

basic_block bb;
edge e;
edge_iterator ei;
FOR_EACH_EDGE(e, ei, bb->preds){
  /*
   * get src by `e->src`
   * get dest by `e->dest`
   */
}

找兒子


basic_block bb;
edge e;
edge_iterator ei;
FOR_EACH_EDGE(e, ei, bb->succs){
  /*
   * get src by `e->src`
   * get dest by `e->dest`
   */
}

走訪該 BB 的所有 RTL INSN

rtx insn;
basic_block bb;
FOR_BB_INSNS(bb, insn) {
  /* do something with insn */
}

走訪該 BB 的所有 GIMPLE stmt 及 PHI node


basic_block bb;
gimple_stmt_iterator si;

for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) {
  gimple phi = gsi_stmt (si);
  print_gimple_stmt (dump_file, phi, 0, TDF_SLIM);
}
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) {
  gimple stmt = gsi_stmt (si);
  print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}

2. Edges

Edge flag 如下
以下是從 basic-block.h 那邊抽出來的, 跟 GCC Internal 描述的是不太一樣的東西

EDGE_FALLTHRU : 這個 edge 不會產生額外的 jump, 代表 src/dest 之後一定會放在一起
EDGE_ABNORMAL : Indirect jump 或著是 Exception Handling 的 Edge
EDGE_ABNORMAL_CALL : 呼叫一個可能會發生 Exception 的函數或著是 No return 的函數(例如呼叫 exit 或 abort)
EDGE_EH : 處理 Exception Handling 的 Edge
EDGE_FAKE : 他是一個不是 edge 的 edge! 拿來給 profiling 時用的
EDGE_DFS_BACK : 是一個 back edge
EDGE_CAN_FALLTHRU : 可以弄成 EDGE_FALLTHRU
EDGE_IRREDUCIBLE_LOOP : irreducible loop 裡面的 edge
EDGE_SIBCALL : 摳到 sibcall
EDGE_LOOP_EXIT : 迴圈的終點
EDGE_TRUE_VALUE : 當 Conditional Branch 的 Condition 為 True 時的目的地
EDGE_FALSE_VALUE : 當 Conditional Branch 的 Condition 為 False 時的目的地
EDGE_EXECUTABLE : 作 SSA-CCP 最佳化的時候用的, 其他時候請不要亂用
EDGE_CROSSING : Cold code 與 Hot code 交界點
EDGE_PRESERVE : 這個 Edge 不准砍!!!
EDGE_ALL_FLAGS : 代表所有 flag
EDGE_COMPLEX : EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE, 很複雜就對了!

GCC RTL INSN 簡介

2012-06-28T01:48:00.001+08:00

簡介

在 GCC Backend 中的 IR 主要使用 RTL , 當作一些 Target Dependency 的一些相關操作時常會需要直接的對 RTL 去做一些檢查或掃描, 而在這篇文章概略性的介紹了 RTL INSN 的種類及樣貌, 以供入門

RTL INSN

RTL INSN 所用的內部的結構為 Doubly-Linked Lists
由一個又一個的 INSN 所串列而成
其中 insn 分為下列幾種

insn: 一般的指令, 非 branch/jump/call 的指令
jump_insn: 跳躍指令, 會造成任何 control flow 轉移的指令類型, 包含 conditional/unconditional jump, 及 indirect jump.
call_insn: 任何呼叫函數的指令
debug_insn: 塞 debug info 的
note: 就 note 阿
barrier: 任何 control flow 都不應該穿越這傢伙, 隔絕各個 Basic Block 東東
code_label: 在 c 裡面給 goto 用的 label 會變成這種東西

當然詳細的還是到 GCC Internal 會寫的比較清楚 http://gcc.gnu.org/onlinedocs/gccint/Insns.html
接著來看一下實際的 insn 長怎樣

(insn 21 20 22 6 
      (set (reg:SI 59 [ D.1238 ])
           (mem/c/i:SI (plus:SI (reg/f:SI 54 virtual-stack-vars)
                                (const_int -8 [0xfffffffffffffff8])) [0 sum+0 S4 A32]))
      /home/kito/sum.c:7 -1
      (nil))

大致上就是 Lisp-style 的樣子
在 gcc/rtl.def 檔案裡可以找到 insn 的定義 DEF_RTL_EXPR(INSN, "insn", "iuuBeiie", RTX_INSN)
由這串我們來解讀整個是在幹嘛的

攤開成一個一行來看, 並且參照上面定義 : "iuuBeiie", 一道 insn 總共由八個東西所組成

(insn 21
      20
      22
      6 
      (set (reg:SI 59 [ D.1238 ])
           (mem/c/i:SI (plus:SI (reg/f:SI 54 virtual-stack-vars)
                                (const_int -8 [0xfffffffffffffff8])) [0 sum+0 S4 A32]))
      /home/kito/sum.c:7
      -1
      (nil))

後面 # 後面為註解

(insn 21 # 1. i
      20 # 2. u
      22 # 3. u
      6  # 4. B
      (set (reg:SI 59 [ D.1238 ])
           (mem/c/i:SI (plus:SI (reg/f:SI 54 virtual-stack-vars)
                                (const_int -8 [0xfffffffffffffff8])) [0 sum+0 S4 A32])) # 5. e
      /home/kito/sum.c:7 # i
      -1 # 6. i
      (nil)) # 7. e

i 代表該 INSN 的 uid , 也就是唯一的編號
u 上一道 INSN 的 uid
u 下一道 INSN 的 uid
B Basic Block 的編號
e 這道 INSN 的主要內容, 例如這上面那道指令所描述的是從記憶體讀取一個值到暫存器中
i 此 INSN 相對應回原始碼的位置
i 放 RTL pattern Name
e 塞 REG_NOTES 資訊, 主要是暫存器相關資訊如 live or kill 等等

相關存取函數可以從 rtl.h 中找到

/* ACCESS MACROS for particular fields of insns.  */

/* Holds a unique number for each insn.
   These are not necessarily sequentially increasing.  */
#define INSN_UID(INSN)  XINT (INSN, 0)

/* Chain insns together in sequence.  */
#define PREV_INSN(INSN) XEXP (INSN, 1)
#define NEXT_INSN(INSN) XEXP (INSN, 2)

#define BLOCK_FOR_INSN(INSN) XBBDEF (INSN, 3)

/* The body of an insn.  */
#define PATTERN(INSN)   XEXP (INSN, 4)

#define INSN_LOCATOR(INSN) XINT (INSN, 5)

相關判斷函數也可以從 rtl.h 中找到

/* Predicate yielding nonzero iff X is a label insn.  */
#define LABEL_P(X) (GET_CODE (X) == CODE_LABEL)

/* Predicate yielding nonzero iff X is a jump insn.  */
#define JUMP_P(X) (GET_CODE (X) == JUMP_INSN)

/* Predicate yielding nonzero iff X is a call insn.  */
#define CALL_P(X) (GET_CODE (X) == CALL_INSN)

/* Predicate yielding nonzero iff X is an insn that cannot jump.  */
#define NONJUMP_INSN_P(X) (GET_CODE (X) == INSN)

/* Predicate yielding nonzero iff X is a debug note/insn.  */
#define DEBUG_INSN_P(X) (GET_CODE (X) == DEBUG_INSN)

/* Predicate yielding nonzero iff X is an insn that is not a debug insn.  */
#define NONDEBUG_INSN_P(X) (INSN_P (X) && !DEBUG_INSN_P (X))

/* Nonzero if DEBUG_INSN_P may possibly hold.  */
#define MAY_HAVE_DEBUG_INSNS MAY_HAVE_DEBUG_STMTS

/* Predicate yielding nonzero iff X is a real insn.  */
#define INSN_P(X) \
  (NONJUMP_INSN_P (X) || DEBUG_INSN_P (X) || JUMP_P (X) || CALL_P (X))

/* Predicate yielding nonzero iff X is a note insn.  */
#define NOTE_P(X) (GET_CODE (X) == NOTE)

/* Predicate yielding nonzero iff X is a barrier insn.  */
#define BARRIER_P(X) (GET_CODE (X) == BARRIER)

其中要注意的部份是 INSN_P 所濾出來的不是 INSN 而是 INSN, DEBUG_INSN, JUMP_INSN 及 CALL_INSN
要單純的 INSN 要用 NONJUMP_INSN_P 來判斷

小結

對於 GCC Backend 的 Porting 來說 RTL 相關部份是相當重要的基礎知識之一,
如果真的不幸的踏入 GCC 屠龍之道則相關文件一定要先熟讀幾次
以及 rtl.h 也一定要仔細的看一遍, 避免發生悲劇...

GCC : Predicates vs Constraints

2012-06-03T02:31:00.001+08:00

順手先把一些東西紀錄一下

在 GCC 的 md 中, 寫那堆 define_insn, define_expand, ...等的 pattern 中

很重要的一環是要寫好 match_operand 中的 Predicates 跟 Constraints

例如以下拿 arm 的 movsi 的 pattern 來說

(define_insn "*arm_movsi_insn"
[(set (match_operand:SI 0 "nonimmediate_operand" "=rk,r,r,r,rk,m")
(match_operand:SI 1 "general_operand" "rk, I,K,j,mi,rk"))]
"TARGET_ARM && ! TARGET_IWMMXT
&& !(TARGET_HARD_FLOAT && TARGET_VFP)
&& ( register_operand (operands[0], SImode)
|| register_operand (operands[1], SImode))"
"@
mov%?\\t%0, %1
mov%?\\t%0, %1
mvn%?\\t%0, #%B1
movw%?\\t%0, %1
ldr%?\\t%0, %1"
[(set_attr "type" "*,*,*,*,load1")
(set_attr "insn" "mov,mov,mvn,mov,*")
(set_attr "predicable" "yes")
(set_attr "pool_range" "*,*,*,*,4096")
(set_attr "neg_pool_range" "*,*,*,*,4084")]
)

其中 nonimmediate_operand 及 general_operand 是 Predicates 的部份

Constraints 則是後面那串 "=rk,r,r,r,rk,m" 及 "rk, I,K,j,mi,rk"

而這兩者之間的差別在於一個指定大類別, 一個小類別

可以想像成 Predicates 是大篩子, Constraints 是小篩子

因此在 Insn Pattern Match 時, GCC 會先透過大篩子

來分類每個 RTL Insn 會適用於哪個 Insn Pattern

然後再想辦法透過任何可能的方法讓他符合任何一個 Constraints

(其中方法包含 split, expand 或著是神奇的 reload

所以若要將 mov pattern 拆解成 mov, store, load 三個 pattern 的話

就必須將 Predicates 的部份作適度的調整,

則可避免 Insn Pattern Match 時統統掉入 mov pattern

值得注意的是, GCC 內部是會由上到下掃描各式 pattern,

所以若大篩子不夠嚴謹造成某個 RTL Insn 可 match 多個 pattern 時,

則會採用第一個 match 到的 pattern,

相對於 md 來說就是比較前面定義的 pattern 會先被 match 到

而以上部份就是大致 gcc 在 md 中的 Predicates 與 Constraints 的大略運作方式.

Android C Library: Bionic 成長計畫

2012-04-17T02:48:00.002+08:00

今年 OSDC 2012 所分享的 take, 內容主要包含對於 Bionic C Library 的一些改進, 一般而言, 看到 C Library 人們直覺可能會想到 printf 等等標準函數庫所提供的函式,但事實上除此之外 C Library 也通常會附贈許多額外功能, 例如 Dynamic Linker 以及一些 Profiling 的支援, 以一般 Linux 常見的 Glibc 來說其中就包含了 Dynamic Linker, gprof 及 sprof 等額外功能而在 Bionic 中在這部份而言相對貧乏, 雖然有包含 Dynamic Linker 但其實作相對 Glibc 少上許多功能, 因此我們所改進的方向是往補強功能的部份發展, 而在主題當中主要包含下列幾個部份

GNU-Style Hash 支援
Prelink 的改善(更多細節可參照Android Prelinker : Apriori)
Aprof(更多細節可參照)
Checkpoint 簡介

其中 Checkpoint 的部份與 C Library 較無直接關聯, 但事實上 Checkpoint 過程中會與 C Library 及 Dynamic Linker 實作有相當大的依存性, 因此我們的長期目標是將 Checkpoint 功能整合進 Bionic 裡面, 以期更簡潔快速的 Checkpoint 功能實作

Android C Library: Bionic 成長計畫

View more presentations from Kito Cheng

Aprof : Android Profiler - A profiling tool for android native code

2012-02-01T17:53:00.000+08:00

目前 Android 在 profiling tool 這邊大致上有 traceview 及 oprofile 可用, 但 traceview 是針對於一般的 DVM 程式, 而 oprofile 又相對的較複雜, 且缺乏類似 gprof 的簡易工具來觀測效能

而事實上已經有人開始注意到此事並提出方法, 最直接的方式是實作 mcount 函數並透過 gcc -pg 選項來使用, 如此一來變不須更動太多部份,例如 android-ndk-profiler 便是採用此方式, Aprof 也將尋此方式來進行擴充, 但我們所採用的方式並非單純將 gprof 功能實作, 而是進一步擴充並且為 Android 系統量身打造.

Aprof 簡介

有鑑於目前 android 平台上對於 native code 的 profiler 較於缺乏, 因此我們提出實作一個為 Android 量身訂作的 Profiler, 取名為 aprof, 主要功能與 gprof 相仿, 提供 Call Graph 與 Time Sample Info.

在 aprof 設計時的幾個主要目標:

採用舊有 gprof 的 mcount 界面, 避免修改 toolchain
能夠支援 Shared Library
可以對 JNI 的 Shared Library 進行 Profiling

在 aprof 中主要也是透過 mcount 函數及 gcc -pg 選項來使用, 但在這邊我們所採取的方式是與 gprof 輸出格式不相容, 主要原因在於 gprof 輸出格式無法支援 shared library 的 profiling, 若沿用原本格式將造成功能上的限制.

Aprof 使用方法

若要使用 Aprof 來 profile 執行檔的話只要在 Android.mk 加入以下的選項開啟, 對於一般的 static library 也是採用相同方式即可

LOCAL_ENABLE_APROF := true

但要注意的是若是要使用 Aprof 來 profile Shared Library 的話主要分為兩種情況使用

針對一般 Non-JNI 使用的 Shared Library 採用與一般執行檔的開啟方式即可, 但要執行檔也開啟 Aprof 時才會啟動 profiling

若是對於 JNI 使用的 Shared Library 則在 Android.mk 加入以下的選項, 其 profiling 資訊將會於 Activity 於 Life Cycle 中的 stop 時寫入檔案, 值得注意的是若程式已經開啟 Aprof 則會以 Non-JNI aprof mode 來進行 profiling

LOCAL_ENABLE_APROF_JNI := true

在開啟 Aprof 並且重新建置程式後, 便可開始準備 profiling, 開始的方式則是執行一次該程式, 在開啟 profiling 的情況下會比未開啟的情況下慢上許多, 在執行完成程式後變可以到 /sdcard/ 裡面檢查 profiling 的輸出, 預設檔名是 $(progname).aprof

接著 profiling file 撈回 Host 端, 也就是使用 adb 去下載, 方式可參考以下指令:

adb pull /sdcard/$(progname).aprof
 
# 例如進行 Profiling 的程式是 foo
adb pull /sdcard/foo.aprof

然後使用 aprof 來讀取 profiling file 的資訊, 使用方式如下:

# aprof $(prog_file) $(prof_file)
aprof foo foo.aprof

下面則是範例輸出:

  %      cumulative     self                 self       total
 time     time          time      calls    ms/call    ms/call   name
 99.52       2170       2140    2178309          0          0   fib
  0.00       2170          0          1          0        217   main
  0.48          0         30          0          0          0   <libc.so>
 
Call graph (explanation follows)
 
-------------------------------------------------------------
Image           : foo
Cumulative time : 2170 ms
Self time       : 2140 ms
  Function  % time  cumulative        self       Count  Call by
 fib                      2170        2140
            100.00        2170           0           1  main
            100.00        2170        2140     2178308  fib
 main                     2170           0
            100.00        2170           0           1  <libc.so>

上半部份主要是顯示各個函數所佔用的時間與百分比, cumulative time 表示包含子函數的時間, 而 self time 則表示該函數所有消耗時間, 例如 a() call b(), a() 花了 1 sec, b() 花了 2 sec, 則 a() 的 cumulative time 為 3 sec, self time 為 2 sec, calls 代表該函數總共被呼叫的次數, self ms/call 及 total ms/call 分別代表每次呼叫約花費多少時間.

但在上面的例子中可以發現有的這個符號, 主要原因是 aprof 沒有載入該 shared library 的符號資訊, 我們可以透過 -L 來指定 Shared Library 的搜索路徑, 一般搜索路徑設置在 Android 的目錄下的 out/target/product/panda/symbols/system/lib (以 panda board 為例)即可.

# aprof $(prog_file) $(prof_file) -L$(lib_path)
aprof foo foo.aprof -L out/target/product/panda/symbols/system/lib

一般而言在載入了符號後資訊會較為詳細, 但仍有些不足的地方, 例如在 calls 的部份若該 Shared Library 建置時並無開啟 aprof 則無法得到此部份的資訊, 也因此 cumulative time 部份會無法計算, 不過 Self time 的部份在有了 symbol 資訊後則可正確定位.

  %      cumulative     self                 self       total
 time     time          time      calls    ms/call    ms/call   name
 99.52       2170       2140    2178309          0          0   fib
  0.00       2170          0          1          0        217   main
  0.32          0         20          0          0          0   write
  0.16          0         10          0          0          0   memcpy
 
 
Call graph (explanation follows)
 
-------------------------------------------------------------
Image           : foo
Cumulative time : 2170 ms
Self time       : 2140 ms
  Function  % time  cumulative        self       Count  Call by
 fib                      2170        2140
            100.00        2170           0           1  main
            100.00        2170        2140     2178308  fib
 main                     2170           0
            100.00        2170           0           1  __libc_init
-------------------------------------------------------------
Image           : foo
Cumulative time : 2170 ms
Self time       : 30 ms
 write                       0          20
 memcpy                      0          10

接下來的部份則是介紹對於將結果視覺化呈現的方式, aprof 支援 dot 格式的輸出, 可透過 -d 來輸出 dot 格式, 可透過 pipeline 到 dot (通常包含於 graphviz 套件)直接將其結果輸出成圖檔, 使用方式參考下列指令

# aprof $(prog_file) $(prof_file) -L$(lib_path)
aprof foo foo.aprof -L out/target/product/panda/symbols/system/lib -d | dot -Tpng -o foo.aprof.png

在這邊附上一個 busybox 的 md5sum 的 aprof 輸出圖檔供參考:

圖 1. md5sum 的 Call Graph 輸出

Aprof 的使用方式及輸出資訊大致介紹到這個部份.

Aprof 實作

Aprof 為了能夠支援較完整的 Shared Library Profiling 機制, 所以有一大部分是實作在 linker 中, 這樣的作法主要是參考自 sprof 的實作方式, 而在這邊為何要重新打造一個 Profiler 主要有兩個原因:

sprof 實作於 glibc 的 dynamic linker, 其授權是採用 GPL, 因此無法直接採用
整合 gprof 與 sprof, 並為 Android 系統的需求設計

為何分 JNI 及 Non-JNI mode ?

對於 Shared Library , aprof 提供兩種模式可進行 Profiling, 兩者之間的行為差別在於 JNI mode 下會各個 Shared Library 會分別 Profiling , 分別輸出檔案, 並且最重要的是執行檔不需要開啟 Aprof 也可進行 Profiling.

non-JNI mode 則是必須執行檔開啟 Aprof 時才會進行 Profiling, 這樣的設計主要是因為避免其他 Link 到該 Shared Library 的執行檔皆受到無差別的效能攻擊.

JNI mode 主要存在的意義就在於如其命名一樣, 針對 JNI 的 Shared Library 來使用, 在作為 JNI 的 Shared Library 通常是被 DVM (app_process / zygote)所開啟, 而要等到其執行結束則會有點困難, 故在這邊的設計是採用於 Activity 於 Life Cycle 中的 stop 時輸出 Profiling File.

另外需要注意的是若用在 JNI 上的話, 必須確保該應用程式有寫入的權限, 也就是記得在 AndroidManifest.xml 中加入 android.permission.WRITE_EXTERNAL_STORAG

AndroidManifest.xml:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.example.android.simplejni">
    <application android:label="Simple JNI">
        <activity android:name="SimpleJNI">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
</manifest>

目前狀態

若使用 AOSP JB 或 ICS 的話 Aprof 僅需要再使用以下 patch 即可

Aprof 也支援及 Gingerbread, 但如果你使用的是 Linaro, CyanogenMod (包含其延伸) 或 Gingerbread, 則需要額外多加入這幾個 patch 才可正常運作:

Android Prelinker : Apriori

2012-01-31T20:44:00.000+08:00

雖然 apriori 於 ICS 中被移除了, 但於 gingerbread 中還是長存著, 寫這篇文章順便為自己之前修改 Apriori 的部分發篇文介紹一下做個小結案

簡介
Prelink 的機制主要目的在於減少 Dynamic Linker 載入程式時 link 所花的時間已達到加速程式啟動, 目前在一般 Linux 有由Redhat 的 Jakub 所提出的 prelink[1], 並可有效減少 link time, 而該方法需要於檔案中塞入額外的資訊, 因此較不適用於 Android 的用途上, 也因此 Android 自己弄了一套 Prelink 機制.

Dynamic Linking

在開始說明 Prelink 前先來說明, dynamic linking 的流程與用途, 避免無相關背景知識讀者看無. 而為了簡化說明這邊僅介紹採用 ELF 格式下的情況.

一般而言我們在撰寫程式的時候會使用到一些函數庫, 例如 printf, scanf 等等各式各樣的函數, 但這些函數都經常被各個程式使用, 若每個程式都包含了一份各字的 printf, scanf 那麼整個系統將會變得相當龐大, 而 Dynamic Linking 就是在面對這樣的問題底下所出現一種解法, 將一些常用的函數抽出來變成一個函數庫, 並且函數庫可以在各個程式間共用, 避免不必要的浪費.

有了基本的概念後直接來看個 Hello World 的例子 :

#include <stdio.h>

int main(){
    printf("Hello world!\n");
    return 0;
}

其中的 printf 很明顯的不存在以上的程式中, 而是來自於 C library, 因此在編譯好的可執行檔中有紀錄幾個資訊

相依到哪些 Shared library
有哪些 Symbol (函數/變數皆屬於一個 Symbol)是來自外部 shared library (要注意並無紀錄 Symbol 是由哪個 shared library 來)

在執行程式時, 系統可根據在執行檔中的資訊去幫你進行 Dynamic Linking, 這個動作在 Linux 當中通常由 ld.so 來處理, 在 Android 中則由 /system/bin/linker 處理.

前面提到執行檔中僅紀錄有哪些 Symbol 是外來的, 並無紀錄其歸屬因此 Dynamic Linker 的主要工作流程如下

將執行檔載入記憶體中
載入所有相依的 Shared library (包含相依的相依)
查找 Symbol 在哪個 Shared library 中
將查找結果更新(Relocation)
所有 Symbol 處理完畢_註1後才開始執行程式

因此程式的啟動時間總共是 1~4 在 Prelink 中主要可以加速的是 3+4 的部份.

其中 4 的更新的步驟主要是將 Shared library 的基底位置(Base Address, 指載入到的記憶體區段開頭)在加上 Symbol 在該動態函式庫的位址.

註解

註1 : 有些例外, 但這邊不探討, keyword 為 weak symbol

Prelink

在有了 Dynamic Linker 運作的基本流程後, 接著我們可以來探討 Prelink 的機制, Prelink 機制前面有提到主要目的在於減少查找 Symbol 在哪個 Shared library 的時間, 也就是先把所有符號查起來並且將結果存起來.

那該如何達到這點呢？首先我們所遇到的第一個問題會是 Shared library 的基底位置該如何處理, Shared library 在設計時變考量到必須可載入任何位置皆可以動(PIC), 否則將會因此浪費記憶體定址空間, 且也可能因此衝突.

所以有幾個方法可以處理這個問題 1. 掃描所有的 Shared library 並分配位址空間 2. 為 Shared library 預分配位址, 在 Android 中所採用的方法為後者也就是透過 prelink map 的方式來設定該 shared library.

在 Shared library 的基底位置決定後, 便可以先處理所有的 Relocation, 但要注意的是 Shared library 也因此喪失部份的彈性, 變得必須載入至固定位址, 因此在 Dynamic Linker 中也必須支援.

但相對的也可得到一些其他的優勢, 例如 Relocation 都處理完的話, 那其資訊也可以直接丟掉了, 在檔案大小上會小上一些, 間接的會再度加速整個程式載入的流程.

不過上敘的部份是針對 Android Prelink 機制而言 linux 上 prelink 完後會塞入一些額外資訊, 檔案反而會變肥.

Android Prelink 實作

在 Android 上的 Prelinker 實作相對於 linux 的 prelink 來說相當輕薄短小, 並且設計簡單, 執行流程如下

載入要 Prelink 的 Shared Library
查找 Prelink map 或從參數設定 Base Address
查找 Symbol , 若找的到即更新其 Address
處理掉相對位址的 Relocation
將已經處理完的 Relocation 從檔案中移除
把 Base Address 塞到檔案最後面

而其中第 6 項目, 個人猜測是 Android 為啥 ICS 以前不採用 strip 而採用自家的 soslim 來為 Shared library 瘦身的原因

但因不明原因 Android Prelink 機制只做半套, 只有 Local Prelink, 意思是只能處理同檔案下的 Symbol 而已, 因此能 Prelink 的有限.

在 Dynamic Linker (bionic/linker) 方面載入 Shared Library 的工作流程如下

開啟 Shared Library 檔案
判斷檔案後面有沒有塞 Prelink 資訊
有的話讀出其 Base Address
接著按照其資訊載入預定記憶體位置

Android Global Prelink

前面提到 Apriori 只有做 Local Prelink, 因此我們對於 Apriori 進行補完(實際上內部程式碼已經有 Global Prelink 的雛型, 但未完成)

載入要 Prelink 的 Shared Library
查找 Prelink map 或從參數設定 Base Address
載入相依的 Prelink 過的 Shared Library, Non-prelink 的 Shared Library 將直接掠過
查找 Symbol , 若在已 Prelink 過的相依 Shared Library 找的到即更新其 Address
處理掉相對位址的 Relocation
將已經處理完的 Relocation 從檔案中移除
把 Base Address 塞到檔案最後面

主要在流程中插入載入相依的 Shared Library, 使得能處理的 Relocation 數激增, 在沒有 Undefined Weak Symbol 及 Multiple Definition 的情況下, 可以完全處理完畢, 與原本的 Apriori 相比有相當卓越的效果(文章最後面會附上實驗數據).

Android Partial Global Prelink

而 Apriori 的 prelink 是依賴 Prelink map 來實行, 未列於 Prelink map 的 Shared Library 將不會進行任何的 Prelink, 但經過觀察我們發現, 並非完全無法處理, 因為 Prelink 的必要條件在於有 Base Address 及 Symbol Offset, 但未列於 Prelink map 的 Shared Library 僅缺乏自身的 Base Address, 其相依的 Shared Library 已經 Prelink, 則其 Base Address 已經決定, 因此有相當大一部份是可以 Prelink 的, 也因此這個部份稱之為 Partial Global Prelink, 其運作流程如下:

載入要 Prelink 的 Shared Library
載入相依且 Prelink 過的 Shared Library, Non-prelink 的 Shared Library 將直接掠過
查找 Symbol , 若在已 Prelink 過的相依 Shared Library 找的到即更新其 Address
將已經處理完的 Relocation 從檔案中移除, 相對位址類型的 Relocation 將不做任何處理

由流程可以看到, 相較於一般 Global Prelink 的行為較為簡化, 在這邊舉一個例子, 假設我們有一個 libfoo.so, 其原始碼如下:

#include <stdio.h>

int bar() {
    return 1;
}

int foo(){
    printf("Hello world!\n");
    return bar();
}

編譯出來後因為 libfoo.so 有用到 printf 因此會相依到 libc.so
而 libfoo.so 中有兩個 relocation 要處理, foo 函數中的 printf 及 bar
假設 libc.so 已經有 prelink 過那麼 libc.so 則已經有 Base Address,
因此如果我們對 libfoo.so 進行 Partial Global Prelink 後, relocation 將僅剩下 foo 函數中的 bar 要處理.

由以上例子可以看出此方式可大大減少 dynamic link time, 而且 bionic/linker 會優先查找自己的 symbol, 因此剩餘的 relocation 也可以快速的處理掉.

Android Executable Prelink

這部份就比較單純了, 因為 executable 不是 PIC, 其 Base Address 已經固定為 0, 所以直接來看流程吧.

載入要 Prelink 的 Executable
載入相依的 Prelink 過的 Shared Library, Non-prelink 的 Shared Library 將直接掠過
查找 Symbol , 若在已 Prelink 過的相依 Shared Library 找的到即更新其 Address
處理掉相對位址的 Relocation
將已經處理完的 Relocation 從檔案中移除

與 Global Prelink 部份差不多, 但不用去 Prelink Map 查找, 也不用將 Base Address 塞到檔案尾巴.

實驗數據

最重要的部份就是效果到底如何勒, 圖表中的神秘代號解釋如下 :

lp : Local Prelink
gp : Global Prelink
re : Reorder DT_NEEDED entries
pe : Prelink executable
pgp : Partial global prelink
are : Aggressive reorder look-up order

圖1. Normalized Dynamic Link time

圖2. Normalized Number of Symbol Lookup

可由圖中觀察到 Global Prelink 以及 Executable Prelink 對於 Dynamic Link Time 有相當不錯的進步, 若原本 Dynamic Link Time 越長則效果會越好, Partial Global Prelink 在這份圖表中看不出什麼效果, 主要原因是採用的實驗對象是 Android 開機會開到的幾隻程式, 其中幾乎沒有包含 Non-Prelink 的 Shared Library.

Future Work

自從 Prelink 在 ICS 被拔掉後, 以上的東西就用不到了, 預期之後將會發展一套 cache 機制來加速 Dynamic Link Time, 來避免掉 Prelink 的缺點, 以及想辦法加速 Dynamic Link Time.

附註

以上的修改(包含只出現在圖表中的方法), 目前皆可在 0xdroid 抓的到程式碼, 分佈在 bionic 及 build 裡面.

參照
[1] http://people.redhat.com/jakub/prelink.pdf
[2] 程式設計師的自我修養：連結、載入、程式庫

Clang + LLVM as cross compiler

2012-01-21T02:43:00.000+08:00

Update Note:

(2012/11/22) 目前 trunk 及 3.2 以後，將以 -target 取代那串語意不太清楚的 -ccc-host-triple, 所以如果 clang 跟你抱怨 clang: error: unsupported option '-ccc-host-triple' 的話請將文中指令的 -ccc-host-triple 替換成 -target

這篇文章主要講解怎麼把 Clang + LLVM 來當作一般的 Cross Compiler 來用, 也就是一般使用 arm-linux-gcc 一樣, 跟平常用 gcc 一樣就能動了

arm-linux-gcc hello.c -o hello

所以最終目標是想要

clang -arch arm hello.c -o hello

不過很殘念的是這只能在 Darwin 上可以這樣用...在 cfe-dev 上有人提過 [1]

而最近雖然有偉大的 ELLCC 可以用, 但其使用的 C Library 看起來還不太齊全(至少不夠編出 SPEC2000, 來自 NetBSD C Library), 而且編譯 SPEC2000 的 perlbmk 也會鬼打牆似的 symbol redefine ...

所以在 ELLCC 成熟前先將就點退而其之用 clang 撐著用

用 Clang + LLVM 當 cross compiler 注意 LLVM 當初編的時候 Target 要開, 免得耍蠢

在這邊先假設已經有 Clang + LLVM 的執行檔下開始作說明

我們的暫定目標是將 Clnag + LLVM 弄成可以編出 arm-linux 上的程式

首先先弄一套 arm linux toolchain 懶得自己編就去弄一套 Code Sourcery 的以下是其中一個版本的連結 (選IA32 GNU/Linux TAR)

或著是你可以到此頁面下載最新版

然後解壓縮放在你家, 接著確認他會不會動

# ~/arm-2011.09/bin/arm-none-linux-gnueabi-gcc -v

Using built-in specs.
COLLECT_GCC=arm-2011.09/bin/arm-none-linux-gnueabi-gcc
COLLECT_LTO_WRAPPER=/home/kito/arm-2011.09/bin/../libexec/gcc/arm-none-linux-gnueabi/4.6.1/lto-wrapper
Target: arm-none-linux-gnueabi
...
確認會動後下一步終於要啟動 clang 了
首先先將你的 arm-linux-gcc 的資料夾弄給 clang 知道
不用加 bin/, clang 會掃描該自料夾
clang -gcc-toolchain /home/kito/arm-2011.09/
主要原因是 clang 會去找 gcc 來用, 以此辨別 ld 跟 as 位置

接著
clang -gcc-toolchain /home/kito/arm-2011.09/ -ccc-host-triple arm-none-linux-gnueabi hello.c
看起來是這樣應該就要可以動了
但實際跑起來會跟你抱怨找不到 Library, 以及很嚴重的是 include 檔是抓 x86 的

/home/kito/arm-2011.09//lib/gcc/arm-none-linux-gnueabi/4.6.1/../../../../arm-none-linux-gnueabi/bin/ld: warning: library search path "/lib/../lib64" is unsafe for cross-compilation /home/kito/arm-2011.09//lib/gcc/arm-none-linux-gnueabi/4.6.1/../../../../arm-none-linux-gnueabi/bin/ld: warning: library search path "/usr/lib/../lib64" is unsafe for cross-compilation /home/kito/arm-2011.09//lib/gcc/arm-none-linux-gnueabi/4.6.1/../../../../arm-none-linux-gnueabi/bin/ld: warning: library search path "/lib" is unsafe for cross-compilation /home/kito/arm-2011.09//lib/gcc/arm-none-linux-gnueabi/4.6.1/../../../../arm-none-linux-gnueabi/bin/ld: warning: library search path "/usr/lib" is unsafe for cross-compilation /usr/lib/../lib64/crt1.o: file not recognized: File format not recognized clang-3: error: linker command failed with exit code 1 (use -v to see invocation)

所以下一步驟是加入搜索路徑

clang -ccc-host-triple arm-none-linux-gnueabi --sysroot=/home/kito/arm-2011.09/arm-none-linux-gnueabi/libc/ hello.c

然後~噁他在動~!!!
但相信只要是人都會覺得那串太長
所以把下面那串弄到 .bashrc 裡

alias arm-clang='/home/kito/llvm/llvm/bin/clang -gcc-toolchain /home/kito/arm-2011.09/ -ccc-host-triple arm-none-linux-gnueabi --sysroot=/home/kito/arm-2011.09/arm-none-linux-gnueabi/libc/'

從今以後也可以使用簡單的方式來編譯了

arm-clang hello.c -o hello

若要驗證可使用 qemu-arm 來驗證, 不過記得要加 -static 參數

最後要注意的是 sysroot 裡面的路徑 /home/kito/ 不可縮減為 ~/ 會因此找不到路徑呦

備註:

clang 可使用 -march 來指定最佳化的ISA,如-march=armv4, -march=armv7
clang 跟 gcc 在一些細節支援上有些不同, 必須留意(例如 clang 不支援 register storage class global variable )
上敘的使用方法還是會相依到 libgcc, 如果是要研究用途的請留意, 有個東西叫 compiler-rt 是 libgcc 的替代品, 但目前還不知道怎麼整進去
上敘的方法有拿去編譯 uClibc 跟 SPEC2000 試過了

[1] http://lists.cs.uiuc.edu/pipermail/cfe-dev/2010-July/009878.html

Kito's Lab

icecream / icecc: 分散式編譯系統簡介

Target Triple

Reference

GCC 5 Releas Note

提醒！

一般性的最佳化改善

連結時期最佳化(Link-time optimization LTO)的改善:

連結時期最佳化(Link-time optimization LTO)的改善:

回饋導向最佳化(Feedback directed optimization) 的改善:

暫存器分配 (Register allocation) 的改善:

UndefinedBehaviorSanitizer 新增選項:

指標邊界檢查器 (Pointer Bounds Checker):

新語言以及語言相關的改善:

OpenMP 4.0 規格中的 offloading 功能目前支援 C, C++, and Fortran:

C 家族

C

C++

Runtime Library (libstdc++)

Go

libgccjit

新的 Target 以及 Target 相關改善：

AArch64

ARM

IA-32/x86-64

NDS32

其它改善

GCC 4.9 Release Note

提醒！

一般性的最佳化改善

連結時期最佳化(Link-time optimization LTO)的改善:

跨函數最佳化(Inter-procedural optimization) 的改善:

回饋導向最佳化(Feedback directed optimization) 的改善:

新語言以及語言相關的改善:

C 家族

C

C++

Runtime Library (libstdc++)

新的 Target 以及 Target 相關改善:

AArch64

ARM

IA-32/x86-64

NDS32

GCC 4.8 Release Note

一般性

語言相關

C++11專區

ARM

Reference

Address-sanitizer : 新的 Android 快速記憶體錯誤偵測工具

簡介

偵測錯誤的類型

越界存取(Out of bound)

釋放後使用 (Use after free)

使用方式

錯誤報告的解讀

副作用及使用限制

與 Valgrind 的比較表格

小結

參考鍊結

快快樂樂 Makefile 入門教學 Part.II 泛用規則/萬用字元應用

一堆 .o 一堆 rule

救命 難道只能寫一堆 rule 了嗎？

Makefile 萬用字元使用方式 %, $@, $^

小結

使用 buildroot 建置可用於 SimpleScalar 的 ARM toolchain

0. 前言

1. 使用 buildroot 建置 ARM toolchain

i. 抓取 buildroot

ii. 解壓縮 buildroot

iii. 組態 buildroot

iii. 測試 buildroot

2. 將 GCC, Bintuils 及 uClibc 拉出來重新建置

i. 建立一個要放等一下所有東西的資料夾

ii. 把整串 toolchain 拉出來

iii. 資料夾重新命名為 arm-linux-gcc

iv. gcc, binutils, uclibc 等 source code 拉出來

v. 建立 bulid-* 資料夾準備

vi. 重新 build bintuils

vii. 開啟bintuils 的 config log 看一下怎麼下

救命難道只能寫一堆 rule 了嗎？