LLVM 言語マニュアル(Language Reference Manual)

Original site is here(llvm.org).

The top page of this site is here(http://www.h3.dion.ne.jp/~mu-ra/).


  1. 概要(Abstract)
  2. 導入(Introduction)
  3. 識別子(Identifiers)
  4. 高級構造体(High Level Structure)
    1. モジュール構造体(Module Structure)
    2. 結合種別(Linkage Types)
    3. 呼出規約(Calling Conventions)
    4. 定義型(Named Types)
    5. 大域変数(Global Variables)
    6. 関数(Functions)
    7. 別名(Aliases)
    8. 引数属性(Parameter Attributes)
    9. 関数属性(Function Attributes)
    10. ガベコレ名(Garbage Collector Names)
    11. モジュールレベル・インラインアセンブリ(Module-Level Inline Assembly)
    12. データ形式(Data Layout)
  5. 型体系(Type System)
    1. 型分類(Type Classifications)
    2. 基本型(Primitive Types)
      1. 浮動小数型(Floating Point Types)
      2. void型(Void Type)
      3. ラベル型(Label Type)
      4. メタデータ型(Metadata Type)
    3. 派生型(Derived Types)
      1. 整数型(Integer Type)
      2. 配列型(Array Type)
      3. 関数型(Function Type)
      4. ポインタ型(Pointer Type)
      5. 構造体型(Structure Type)
      6. 圧縮構造体型(Packed Structure Type)
      7. ベクトル型(Vector Type)
      8. 不確定型(Opaque Type)
    4. 型の上方参照(Type Up-references)
  6. 定数(Constants)
    1. 単純定数(Simple Constants)
    2. 複合定数(Complex Constants)
    3. 大域変数と関数アドレス(Global Variable and Function Addresses)
    4. 不定値(Undefined Values)
    5. 定数式(Constant Expressions)
    6. 埋込メタデータ(Embedded Metadata)
  7. その他の値(Other Values)
    1. インラインアセンブリ式(Inline Assembler Expressions)
  8. 命令参照(Instruction Reference)
    1. 終端命令(Terminator Instructions)
      1. 復帰(ret)命令
      2. 分岐(br)命令
      3. 選択(switch)命令
      4. 呼出※(invoke)命令
      5. 復元(unwind)命令
      6. 不到達(unreachable)命令
    2. 二項演算子(Binary Operations)
      1. 整数加算(add)命令
      2. 浮動小数加算(fadd)命令
      3. 整数減算(sub)命令
      4. 浮動小数減算(fsub)命令
      5. 整数乗算(mul)命令
      6. 浮動小数乗算(fmul)命令
      7. 符号無除算(udiv)命令
      8. 符号付除算(sdiv)命令
      9. 浮動小数除算(fdiv)命令
      10. 符号無剰余算(urem)命令
      11. 符号付剰余算(srem)命令
      12. 浮動小数剰余算(frem)命令
    3. 二項ビット演算子(Bitwise Binary Operations)
      1. 左シフトshl命令
      2. 右シフトlshr命令
      3. 算術右シフト(ashr)命令
      4. 論理積(and)命令
      5. 論理和(or)命令
      6. 排他論理和(xor)命令
    4. ベクトル演算子(Vector Operations)
      1. 要素除去(extractelement)命令
      2. 要素挿入(insertelement)命令
      3. ベクトル混合(shufflevector)命令
    5. 集合演算子(Aggregate Operations)
      1. 値除去(extractvalue)命令
      2. 値挿入(insertvalue)命令
    6. メモリアクセス/アドレス演算子(Memory Access and Addressing Operations)
      1. ヒープメモリ割当(malloc)命令
      2. メモリ解放(free)命令
      3. スタックメモリ割当(alloca)命令
      4. メモリ読出(load)命令
      5. メモリ書込(store)命令
      6. 要素ポインタ取得(getelementptr)命令
    7. 変換演算子(Conversion Operations)
      1. 切捨(trunc .. to)命令
      2. ※(zext .. to)命令
      3. ※(sext .. to)命令
      4. 浮動小数切捨(fptrunc .. to)命令
      5. ※(fpext .. to)命令
      6. 浮動小数符号無整数変換(fptoui .. to)命令
      7. 浮動小数符号付整数変換(fptosi .. to)命令
      8. 符号無整数浮動小数変換(uitofp .. to)命令
      9. 符号付整数浮動小数変換(sitofp .. to)命令
      10. 整数ポインタ変換(ptrtoint .. to)命令
      11. ポインタ整数変換(inttoptr .. to)命令
      12. ビット変換(bitcast .. to)命令
    8. その他の演算子(Other Operations)
      1. 整数比較命令(icmp)命令
      2. 浮動小数比較命令(fcmp)命令
      3. phi命令(phi)命令
      4. select命令(select)命令
      5. 呼出(call)命令
      6. va_arg(va_arg)命令
  9. 組込処理(Intrinsic Functions)
    1. 可変引数取扱組込処理(Variable Argument Handling Intrinsics)
      1. 可変引数始点(llvm.va_start)組込処理
      2. 可変引数終点(llvm.va_end)組込処理
      3. 可変引数複製(llvm.va_copy)組込処理
    2. 正確なガベコレ組込処理(Accurate Garbage Collection Intrinsics)
      1. llvm.gcroot※(llvm.gcroot)組込処理
      2. ガベコレ読出(llvm.gcread)組込処理
      3. ガベコレ書込(llvm.gcwrite)組込処理
    3. コード生成組込処理(Code Generator Intrinsics)
      1. llvm.returnaddress(llvm.returnaddress)組込処理
      2. llvm.frameaddress(llvm.frameaddress)組込処理
      3. スタック保存(llvm.stacksave)組込処理
      4. スタック復元(llvm.stackrestore)組込処理
      5. llvm.prefetch(llvm.prefetch)組込処理
      6. llvm.pcmarker(llvm.pcmarker)組込処理
      7. 循環カウンタ読出(llvm.readcyclecounter)組込処理
    4. 標準Cライブラリ組込処理(Standard C Library Intrinsics)
      1. メモリ複製(llvm.memcpy.*)組込処理
      2. メモリ移動(llvm.memmove.*)組込処理
      3. メモリ設定(llvm.memset.*)組込処理
      4. 平方根(llvm.sqrt.*)組込処理
      5. 整数乗数(llvm.powi.*)組込処理
      6. コサイン(llvm.sin.*)組込処理
      7. サイン(llvm.cos.*)組込処理
      8. 乗数(llvm.pow.*)組込処理
    5. ビット操作組込処理(Bit Manipulation Intrinsics)
      1. バイト交換(llvm.bswap.*)組込処理
      2. llvm.ctpop.*(llvm.ctpop.*)組込処理
      3. llvm.ctlz.*(llvm.ctlz.*)組込処理
      4. llvm.cttz.*(llvm.cttz.*)組込処理
    6. オーバフロー付算術組込処理(Arithmetic with Overflow Intrinsics)
      1. llvm.sadd.*(llvm.sadd.with.overflow.*)組込処理
      2. llvm.uadd.*(llvm.uadd.with.overflow.*)組込処理
      3. llvm.ssub.*(llvm.ssub.with.overflow.*)組込処理
      4. llvm.usub.*(llvm.usub.with.overflow.*)組込処理
      5. llvm.smul.*(llvm.smul.with.overflow.*)組込処理
      6. llvm.umul.*(llvm.umul.with.overflow.*)組込処理
    7. デバッグ用組込処理(Debugger intrinsics)
    8. 例外取扱組込処理(Exception Handling intrinsics)
    9. トランポリン組込処理(Trampoline Intrinsic)
      1. トランポリン初期化(llvm.init.trampoline)組込処理
    10. 基本的組込処理(Atomic intrinsics)
      1. メモリバリア(llvm.memory_barrier)組込処理
      2. 不分割比較交換(llvm.atomic.cmp.swap)組込処理
      3. 不分割交換(llvm.atomic.swap)組込処理
      4. 不分割読出加算(llvm.atomic.load.add)組込処理
      5. 不分割読出減算(llvm.atomic.load.sub)組込処理
      6. 不分割読出論理積(llvm.atomic.load.and)組込処理
      7. 不分割読出否定論理積(llvm.atomic.load.nand)組込処理
      8. 不分割読出論理和(llvm.atomic.load.or)組込処理
      9. 不分割読出論理積(llvm.atomic.load.xor)組込処理
      10. 不分割※(llvm.atomic.load.max)組込処理
      11. 不分割※(llvm.atomic.load.min)組込処理
      12. 不分割※(llvm.atomic.load.umax)組込処理
      13. 不分割※(llvm.atomic.load.umin)組込処理
    11. 汎用組込処理(General intrinsics)
      1. llvm.var.annotation(llvm.var.annotation)組込処理
      2. llvm.annotation.*(llvm.annotation.*)組込処理
      3. llvm.trap(llvm.trap)組込処理
      4. llvm.stackprotector(llvm.stackprotector)組込処理

Written by Chris Lattner and Vikram Adve 日本語訳:Mura.※翻訳は適当です。権利関係はオリジナルに準じます。

概要(Abstract)

この文書は、LLVMアセンブリ言語の参照マニュアルです。 LLVMは、型安全で、低水準な操作ができる、柔軟な、 そして全ての高級言語を簡潔に表現できる能力を提供する静的単一代入(Static Single Assignment:SSA)ベースの表現です。 これはLLVMのコンパイル戦略のすべてのフェイズにわたって使用される共通コード表現です。

導入(Introduction)

LLVMコード表現は、3つの異なる形式で使用できるように設計されています。 インメモリコンパイラ(IR)、 ディスク上でのビットコード表現(JITコンパイラの高速ロード対応)、 そして、可読アセンブリ言語表現です。 これは、変形にデバッグや視覚化の自然さを残しながら、 LLVMが効率的なコンパイラ変形および分析に強力な中間表現を提供することを可能にします。 LLVMの3つの異なる形式はすべて等価です。 このドキュメントは人間の判読可能な表現および表記法について記述します。

LLVM表現は、表現力があり、型付けされ、拡張可能であると同時に、一方で軽量かつ低水準を目指します。 マイクロプロセッサが「汎用IR」のように多くの元言語を写像できることに似て) 簡潔に高水準の思考を写像できる程に低水準とすることにより「汎用IR」のようなものを目指します。 型情報の提供によって、LLVMは対象の最適化に使用できます。 例えば、ポインタ分析を通じて現在の関数以外からCの自動変数が参照されないと証明できれば、 メモリの代わりに単純なSSA値にそれを昇格することを認めます。

適合性(Well-Formedness)

この文書が適合性あるLLVMアセンブリ言語について記述していることに注目することは重要です。 パーサが受け入れるものと、適合性あると考えられるものには差があります。 例えば、次の命令は構文上OKですが、適合性はありません。:

%x = add i32 1, %x

…%xの定義がその用途すべてを決定するとは限らないので。 LLVMの基盤は、LLVMモジュールの適合性を確認するために使えるかもしれない検証手順を提供します。 この手順は、ビットコードを出力する前に、 入力アセンブリを解析した後のパーサとオプティマイザから自動的に実行されます。 この検証手順によって指摘された違反は、変形手段あるいはパーサへの入力のバグを示します。

識別子(Identifiers)

LLVM識別子は2つの基本型を持ちます。大域と局所です。 大域識別子(関数、大域変数)は@文字から始まります。 局所識別子(レジスタ名、型)は%文字から始まります。 さらに、異なる目的のために、識別子には3つの異なる書式があります。

  1. 命名された値は、接頭辞を含めた文字列として表わされます。 例えば、%foo、@DivisionByZero、%a.really.long.identifierなどです。 実際の正規表現は'[%@][a-zA-Z$._][a-zA-Z$._0-9]*'となります。 名前に他の文字を必要とする識別子は、クォートで囲むことができます。 「\xx」のxxに16進数で文字のASCIIコードを入れ、特殊文字をエスケープしてもかまいません。 このように、命名された値にはクォート自身さえも含む任意の文字を使用できます。
  2. 無名の値は、接頭辞を持つ符号無の数値として表されます。 例えば、%12, @2, %44などです。
  3. 定数の節で説明する定数については後述します。

LLVMは、2つの理由で値が接頭辞で始まることを要求します: コンパイラは予約語を含めた名前衝突について心配する必要はありません。 また、予約語のセットは弊害無しに今後拡張できます。 さらに、無名の識別子は、コンパイラがシンボル表での解決が不要な一時変数での高速な処理を可能にします。

LLVMの予約語は、多言語の予約語に非常によく似ています。 命令(整数加算(add), ビットキャスト(bitcast), 復帰(ret), 等)や、 基本型名(void, i32 等)、 その他など、異なる予約語があります。 これらの予約語は、接頭辞(%や@)で始まらないため、変数名とは衝突しません。

整数変数%Xに8を掛けるLLVMコードの例です。:

簡単な方法:

%result = mul i32 %X, 8

強度減少後:

%result = shl i32 %X, i8 3

そして難しい方法:

add i32 %X, %X           ; yields {i32}:%0
add i32 %0, %0           ; yields {i32}:%1
%result = add i32 %1, %1

%Xに8を掛ける最後の方法は、LLVMの幾つかの重要な文法的特徴を表します。:

  1. コメントは ; で区切られ、行末まで続きます。
  2. 命名された値に計算結果を割り当てない場合、無名の一時変数を作成する。
  3. 無名の一時変数は連番となる。

さらに、私たちがこのドキュメント中で従う規約も示しています。 命令を例示する時には、命令に生成した値の型と名を定義するコメントを命令に続けます。 コメントは斜体です。

高級構造体(High Level Structure)
モジュール構造体(Module Structure)

LLVMプログラムは、入力プログラムの翻訳単位となる各「モジュール」からできています。 各モジュールはそれぞれ関数、大域変数およびシンボル表エントリからなります。 モジュールはLLVMリンカで一緒に組み合わされるかもしれません。 それは関数(また大域変数)の定義をマージし、前方宣言を解決し、シンボル表エントリをマージします。 「hello world」モジュール:の一例です。:

; 大域定数として文字列定数を宣言する…
@.LC0 = internal constant [13 x i8] c"hello world\0A\00"          ; [13 x i8]*

; puts関数の外部宣言
declare i32 @puts(i8 *)                                            ; i32(i8 *)* 

; main関数の定義
define i32 @main() {                                                 ; i32()* 
        ; Convert [13 x i8]* to i8  *...
        %cast210 = getelementptr [13 x i8]* @.LC0, i64 0, i64 0 ; i8 *

        ; 文字列を標準出力に書き出すためにputs関数を呼ぶ
        call i32 @puts(i8 * %cast210)                              ; i32
        ret i32 0
}

この例は、.LC0という名の大域変数と、 puts関数の外部宣言、そしてmain関数定義からなります。

一般に、関数と大域変数の両方が大域な値である場合、大域な値のリストからモジュールを構成します。 大域な値はポインタの記憶場所(この場合は文字配列へのポインタと関数へのポインタ)として表現され、 次の結合種別の一つを持ちます。

結合種別(Linkage Types)

全ての大域変数と関数は、以下の結合種別のいずれかを持ちます。

プライベート(private)
プライベートな結合性を持つ大域値は現在のモジュール内のオブジェクトからのみ直接参照されます。 プライベートの大域値を持つモジュールをリンクするコードは、衝突の回避に必要ならば、そのプライベートな大域値をリネームするかもしれません。 シンボルがモジュールにプライベートなので、参照をすべて更新することは可能です。 これはオブジェクトファィル中のどんなシンボル表いえでも現われません。
内部(internal)
プライベート(private)と似ていますが、値はオブジェクトファイル内のローカルシンボル(ELFの場合はSTB_LOCAL)と見えます。 C言語の予約語staticの概念がこれに相当します。
available_externally:
available_externally結合を持つ大域は、LLVMモジュールに対応するオブジェクトファィルには出力されません。 それらはインライン他の最適化が、モジュール外のどこかにあると知っっている大域な定義についての情報を保持するために存在します。 available_externally結合を持つ大域は、廃棄されてもかまいませんし、またlinkonce_odrと同義です。 この結合種別は宣言ではなく定義のみを許可します。
単独体(linkonce):
linkonce結合をもつ大域は、結合で生じた同名の他の大域とマージされます。 これは典型的には、インライン関数の実装や、それを使う各翻訳単位でのコードの生成にしようされます。 参照されないlinkonceな参照は破棄してもかまいません。
共通(common):
common結合は、参照されないcommonでも破棄されないことを除き、linkonce結合と完全に同一です。 これは多数の翻訳単位中で出力されるかもしれないけれど、それらを使用するすべての翻訳単位で出力されるとは保証されない大域に使用します。 一例として、大域スコープでのint X;のようなC言語の仮定義があります。
弱参照(weak):
weak結合は、対象固有の理由で異なるアセンブリシーケンスを生成する可能性があることを除き、 common結合と同一です。これはCソースコードで弱く(weak)宣言された大域に使用します。
追加(appending):
appending結合は配列型へのポインタの大域変数だけに使われるかもしれません。 追加結合を持つ二つの大域変数を一緒にリンクすると、二つの大域配列は一つにまとめられます。 これはLLVMが、.oファイルをリンクした際に、システムリンカに同一の名前を持った「セクション」を型安全に追加する相当物です。
(※This is the LLVM, typesafe, equivalent of having the system linker append together "sections" with identical names when .o files are linked.)
外部弱参照(extern_weak):
この結合の意味は、ELFオブジェクトファイルモデルによります。 シンボルはリンクされるまで弱く(weak)、そのシンボルは未定義参照の代わりにnullになります。
単一定義単一体(linkonce_odr):
単一定義弱参照(weak_odr):
幾つかの言語では、異なる意味を持つ二つの関数のような、異なる大域をマージすることが許されています。 C++のような他の言語では、常に等価な大域だけをマージすることを保証します。(「単一定義則(ODR)」) そのような言語では、完全に等価な大域としてマージすることを示すために、 linkonce_odrおよびweak_odr結合タイプを使用することができます。 これらの結合種別はそうでなければ各非odr形式と同一です。
外部可視(externally visible):
上記の識別子のいずれも使用しない場合、その大域は外部可視となり、結合に参加し外部シンボル参照を解決するために使用することができることを意味します。

次の2つの結合種別はMicrosoft Windows環境のみを対象とします。 それらは、DLL(ダイナミックリンクライブラリ)から/に、シンボルをインポート/エクスポートするためのものです。

DLLインポート(dllimport):
dllimport結合は、コンパイラにDLLのエクスポートするシンボルへの大域ポインタ経由の関数または変数の参照を生じます。 Microsoft Windows環境では、このポインタ名は、関数または変数名に_imp_を合わせたものになります。
DLLエクスポート(dllexport):
dllexport結合は、コンパイラにDLL内のポインタへの大域ポインタの提供を生じます。 つまり、dllimport属性を参照できます。 Microsoft Windows環境では、このポインタ名は、関数または変数名に_imp_を合わせたものになります。

例えば、既に.LC0変数が内部(internal)として定義されている時、もし他のモジュールが.LC0変数を定義し、それをリンクした場合、 二つのうちの一つはリネームされて衝突が回避されるでしょう。 既にmainputsが外部(external)で定義されている時(例:結合宣言がない)、現在のモジュール外からも参照可能です。

関数宣言が、"externally visible"、dllimportまたはextern_weak以外の結合種別を持っているのは不正です。

別名(aliases)は、externalinternalweak、またはweak_odr種別のみを持てます。

呼出規約(Calling Conventions)

LLVM関数呼出(calls)呼出(invokes)は、 その呼び出しに際して全ての付加的な呼出規約を持つことができます。 あらゆる動的な呼出元/呼出先の呼出規約は一致していなければならず、不一致時の動作は未定義です。 以下の呼出規約がLLVMにサポートされており、将来的には更に増えるかもしれません。

ccc - C宣言呼出規約(The C calling convention)
この呼出規約(他の呼出規約が指定されない場合のデフォルト)は、Cの呼出規約と一致します。 この呼出規約は、可変引数の関数呼出をサポートし、 (正常なCがそうするように)関数の宣言されたプロトタイプと実装された関数宣言の若干の誤った組合せを許容します。
fastcc - 高速呼出規約(The fast calling convention):
この呼出規約は、可能な限り高速な呼出(例えば情報のレジスタ渡し)を試みます。 この呼出規約は、外部定義のABI(アプリケーションバイナリインタフェース)に準拠することなく、 対象の呼出をより早くするための、あらゆるトリッキーなコードを生成することを認めます。 この規約の実装は、任意の末尾呼出最適化をサポートするべきです。 この呼出規約は可変引数をサポートせず、全ての呼び出し元に正確な関数定義のプロトタイプと合致を要求します。
coldcc - 冷たい(※)呼出規約(The cold calling convention)
この呼出規約は、大抵の場合に呼び出されないという仮定の下に、できる限り効率的な呼出コードを生成しようとします。 このため、この呼出はしばしば、呼出元で有効な範囲の何かを破壊しないよう、全てのレジスタを保存します。 この呼出規約は可変引数をサポートせず、全ての呼び出し元に正確な関数定義のプロトタイプと合致を要求します。
cc <n> - 序数規約(Numbered convention)
番号で規定されるだろうあらゆる呼出規約は、対象依存の呼出規約を用いることを認めます。 対象の規定する呼出規約は、64から始まります。

Pascal規約やその他の有名な対象非依存規約をサポートするために、 必要な基底に応じて、より多くの呼出規約を追加/定義できます。

可視性(Visibility Styles)

全ての大域変数と関数は、以下のいずれかの可視性を持ちます。

default - デフォルト型(Default style)
ELFオブジェクトファィル形式を使用する対象では、デフォルトの可視性とは宣言が他のモジュール、共有ライブラリ内から参照でき、 その宣言された実体は無視されるかもしれません。 ダーウィンにおいては、デフォルトの可視性は、他のモジュールから参照できることを意味します。 デフォルトの可視性は、言語では「外部結合」に相当します。
hidden - 不可視(Hidden style)
不可視性を持つオブジェクトの2つの宣言が同じ共用対象にある場合、その2つは同じオブジェクトを指します。 通常、不可視性は動的シンボル表にシンボルが入らないだろうことを示します。 従って、他のモジュール(実行可能でも共有ライブラリでも)はそれを直接的には参考できません。
protected - 保護(Protected style):
ELFにおいては、保護された可視性が、動的シンボル表にシンボルを置くものの、 その動的モジュール内の参照は局所的なシンボルに拘束されるだろう事を示します。 すなわち、他のモジュールはこのシンボルを無視できません。
定義型(Named Types)

LLVM IRは、ある型の別名を規定することを認めます。 これは、IRの読み込みと更なる圧縮を容易にします(特に再帰的な型を含む場合)。 命名仕様の一例です。

%mytype = type { %mytype*, i32 }

voidを除くあらゆるに名前を与えてもかまいません。 型名の別名は、"%mytype"という文法で型を期待するあらゆる箇所に使用できます。

型名がそれらが示す構造体型の別名で、したがって、同一の型に複数の名前を規定できることに注意してください。 .llファイルをダンプする場合に、これはしばしば混乱を招きます。 LLVM IRが構造化された型付けを使用するので、名前は型の一部ではありません。 LLVM IRを印刷する場合、プリンタはすべての型の特別の形を得るために1つの名前を選ぶでしょう。 これは、もし2つの異なるソース型が結局同じLLVM型を持っている場合に、 ダンプは時々「間違った」あるいは予期しない型を印刷する可能性があることを意味します。 これは重要な設計点で変更できません。

大域変数(Global Variables)

大域変数は、実行時ではなくコンパイル時に定義されたメモリ領域を割り当てます。 大域変数は、任意に初期化されるかもしれないし、明示的な配置セクションを持っているかもしれないし、 任意の明示的なアライメントを規定するかもしれません。 変数は、スレッド間で共有されないスレッド固有(thread local)なものとして定義されるかもしれません。 (各スレッドは個別の変数の複製を持つでしょう) 変数はその値が決して変更されない大域定数(constant)として定義されるかもしれません。 (よりよい最適化のために、大域データを実行ファイル等の読出専用セクション(read-only)に配置してもかまいません。 実行時初期化が必要な変数は定数とマークできず、そこに変数を保存できないことに注意してください。

大域変数の最終定義が定数でなかったとしても、LLVMは定数とマークされた大域変数の宣言を明示的に認めます。 この能力はプログラムのわずかばかりの最適化に使用できますが、 「定数性」に基づく最適化が、定義を含まない翻訳単位でも有効であるという保証を言語定義に要求します。

SSA値として、(大域変数が有効な)プログラム内の全基本ブロックで、大域変数はそのスコープのポインタ値を定義します。 大域変数はメモリ領域を記述しており、それらの「コンテンツ」型へのポインタは常に定義されています。 LLVMにおける全メモリオブジェクトは、ポインタを通じてアクセスされます。

対象規定番号のアドレス空間に存在するように大域変数は宣言されるかもしれません。 そういったアドレス空間をサポートする対象では、アドレス空間が、 どのように最適化すると効率的か/どんな対象の命令が変数へのアクセスに使われるか、に影響するかもしれません。 デフォルト・アドレス空間は0です。アドレス空間修飾語は他の属性よりも先に行わなければなりません。

LLVMは、大域規定用の明示的なセクションを許容します。 対象がそれをサポートすれば、それは規定されたセクショに大域を出力するでしょう。

明示的なアライメントが指定されるかもしれません。 提示されないか、アライメントに0が指定された場合、全ての大域のアライメントを対象が最適と思うものに設定します。 もし明示的なアライメントが規定された場合、大域は少なくとも多くのアライメントを強います。 全てのアライメントは2の乗数でなければなりません。

例えば、次では初期化子、セクション、アライメントを持つ番号指定のアドレス空間に大域を定義します。

@G = addrspace(5) constant float 1.0, section "foo", align 4
関数(Functions)

LLVM関数定義は、define予約語と、 任意の結合種別、任意の可視性、 任意の呼出規約、戻り型、 任意の戻り型用の引数属性、関数名、 (恐らく空の)引数リスト(各々が任意に引数属性を持つ)、 任意の関数属性、任意のセクション、任意のアライメント、 任意のガベコレ名、開始中括弧、基本ブロックのリスト、終了中括弧、からなります。 LLVM関数宣言は、declare予約語と、 任意の結合種別、任意の可視性、 任意の呼出規約、戻り型、 任意の戻り型用の引数属性、関数名、 恐らく空の引数リスト、任意のアライメント、任意のガベコレ名、からなります。

関数定義は、基本ブロックのリストと関数の制御フローグラフ(CFG: Control Flow Graph)からなります。 基本ブロックはそれぞれ、任意にラベル(基本ブロックにシンボル表エントリを与えて)で始まるかもしれませんし、 命令のリストを含み、(分岐や関数復帰のような)terminator命令で終わるかもしれません。

関数中の最初の基本ブロックは2つの方法で特別です。 関数突入時に直ちに実行されます。また、それは前任基本ブロックを許されません(つまり関数の開始ブロックに分岐はありえません)。 ブロックに前任がありえないので、さらにPHIノードもありえません。

LLVMは、関数用に規定された明示的なセクションを許容します。 対象がそれをサポートすれば、それは規定されたセクションに関数を出力するでしょう。

関数に明示的なアライメントが指定されるかもしれません。 提示されないか、アライメントに0が指定された場合、関数のアライメントを対象が最適と思うものに設定します。 もし明示的なアライメントが規定された場合、関数は少なくとも多くのアライメントを強います。 全てのアライメントは2の乗数でなければなりません。

文法:
define [linkage] [visibility] [cconv] [ret attrs] <ResultType> @<FunctionName> ([argument list]) [fn Attrs] [section "name"] [align N] [gc] { ... }
別名(Aliases)

別名は、別名をつける値(それは関数、大域変数、別の別名あるいは大域値のビットキャストのいずれか)の「第2の名前」として作用します。 別名には任意の結合種別および任意の可視性があるかもしれません。

文法:
@<Name> = alias [Linkage] [Visibility] <AliaseeTy> @<Aliasee>
引数属性(Parameter Attributes)

関数型の戻り型と各引数は引数属性のセットに関係しているかもしれません。 引数属性は、関数の結果あるいは引数に関する追加情報をやりとりするために使用します。 引数属性は関数型ではなく、関数の一部と考えられます。 従って、異なる引数属性を持つ関数が同じ関数型になることもありえます。

引数属性は、型の規定に続く簡単な予約語です。複数の引数属性が必要な場合、空白で分割されます。 例えば、

declare i32 @printf(i8* noalias nocapture, ...)
declare i32 @atoi(i8 zeroext)
declare signext i8 @returns_signed_char()

関数結果のあらゆる属性(nounwind, readonly)は、引数リストの直後に来ることに注意してください。

現在、次の引数属性だけが定義されます。

zeroext
これは呼出元(引数用)あるいは呼出先(戻値用)が32ビット値まで引数か戻値を0拡張するべきだとコード生成部に示します。
signext
これは呼出元(引数用)あるいは呼出先(戻値用)が32ビット値まで引数か戻値を符号拡張するべきだとをコード生成部に示します。
inreg
これは関数呼出か復帰のコード出力時に、特別な対象依存の方法(通常、いくつかの対象は2つの異なるレジスタ種別を識別するために使用しますが、 メモリでなくレジスタにそれを入れるなど)で、この引数または戻値を処理するべきであることを示します。この属性の使用は処理系依存です。
byval
これはポインタ引数が実際に関数への値渡しであるべきであることを示します。 属性は呼出元と呼出先の間でポイント先の隠れたコピーを作ることを示唆します。 従って、呼出先は呼出先の中で値を修正できません。 この属性はLLVMポインタ引数でのみ有効です。 一般には値による構造体および配列の受け渡しに使用しますが、スカラへのポインタ上でも有効です。 コピーは呼出先ではなく、呼出元が所有していると考えます (例えば、readonlyな関数はbyvalな引数に書くべきではありません)。 この属性は戻値には無効です。 byvalな属性はさらにalign属性によるアライメントの規定をサポートします。 これは通常、合成されたスタック・スロットの希望するアライメントを示すコード生成部に対象特有の効果があります。
sret
これはポインタ引数がソース・プログラム中の関数の戻値である構造体のアドレスを規定することを示します。 呼出元は、呼出先はトラップなしで構造体への読み書きをすることを想定し、このポインタの有効性を保証しなければなりません。 これは最初の引数にだけ適用してもかまいません。 この属性は戻値には無効です。
noalias
これはポインタが大域やその他の引数の別名でないことを示します。 呼出元はこれを保証する責任を負います。関数の戻り値においては、noaliasはさらに、 ポインタが呼出元に見える他のポインタの別名でないことも示します。 より詳細については、別名解析のNoAlias応答の議論を参照してください。
nocapture
これは呼出先が、呼出先より生存期間の長いポインタのコピーを作らないことを示します。この属性は戻値には無効です。
nest
これは、トランポリン組込処理を使用して、ポインタ引数を削除できることを示します。 この属性は戻値には無効です。
ガベコレ名(Garbage Collector Names)

関数はそれぞれガベコレ名(単なる文字列)を規定するかもしれません。

define void @f() gc "name" { ...

コンパイラは、サポートする名前の値を宣言します。 名づけられたガベコレ・アルゴリズムをサポートするために、コレクタの規定はコンパイラの出力変更を引き起こします。

関数属性(Function Attributes)

関数属性は、関数に関する追加情報をやり取りするものです。 引数属性は、関数の結果あるいは引数に関する追加情報をやりとりするために使用します。 引数属性は関数型ではなく、関数の一部と考えられます。 従って、異なる引数属性を持つ関数が同じ関数型になることもありえます。

関数属性は、型の規定に続く簡単な予約語です。複数の引数属性が必要な場合、空白で分割されます。 例えば、

define void @f() noinline { ... }
define void @f() alwaysinline { ... }
define void @f() alwaysinline optsize { ... }
define void @f() optsize
常にインライン展開(alwaysinline)
この属性は、この呼出元への全てのアクティブなインラインサイズの閾値も無視して、 可能な場合は常にこの関数を呼出元の中にインライン展開するべきであることを示します。
インライン展開しない(noinline)
この属性は、いかなる場合でもこの関数はインライン展開するべきではないことを示します alwaysinline属性と一緒に使うことはできません。
最適化(optsize)
この属性は、最適化とコード生成においてこの関数のコード・サイズが小さく維持するか、 または特にコード・サイズを縮小する最適化ために、インライン化を示唆します。
復帰しない(noreturn)
この関数属性は、通常この関数が復帰しないことを示します。 もし関数が動的に復帰した場合、実行時おn未定義動作を起こします。
巻き戻さない(nounwind)
この関数属性は、例外処理や巻き戻しが怒らないことを示します。 もしこの関数で巻き戻しが発生した場合、その実行時の動作は未定義です。
何も読まない(readnone)
この属性は、呼出元から見えるあらゆる配列変数の参照を外さず、 また呼出元から見えるあらゆる可変状態(例えばメモリや制御レジスタ等)を参照せず、 関数が引数だけに基づいてその結果を計算できる(または例外の巻き戻しを決定できる)ことを示します。 この関数は、(byval引数も含む)あらゆるポインタ引数に書き出しせず、 呼出元に見えるあらゆる状態を変更しません。 これは、C++例外処理方法の呼び出しにより、例外が巻き戻せないことを意味しますが、 unwind命令は使用可能です。
読出のみ(readonly)
この属性は、関数が(byval引数を含む)どんなポインタ引数にも書き出しせず、 また呼出元から見えるあらゆる状態(例えばメモリや制御レジスタ等)を変更しないことを示します。 ポインタ引数の参照外しや呼出元で設定した状態は参照してもかまいません。 読出のみ(readonly)の関数は、大域の状態と引数が全て同一なら、常に同じ値を返します(または特定の例外を巻き戻します)。 それはC++例外を投げる方法を呼ぶことにより例外を解くことができないが使用するかもしれません‥‥命令を解きます。 これは、C++例外処理方法の呼び出しにより、例外が巻き戻せないことを意味しますが、 unwind命令は使用可能です。
スタック破壊保護(ssp)
この属性は、関数がスタック破壊保護を生成することを示します— canary形式で。 関数から復帰した際に上書きされているかを見るために、局所変数の前のスタックに乱数を格納します。 関数がスタック保護を必要とするか否かを判断するためにヒューリスティックを使用します。

もしssp属性を持つ関数が、ssp属性を持たない関数にインライン展開される場合、 生じる関数はssp属性を持つでしょう。
スタック破壊保護要求(sspreq)
この属性は、関数がスタック破壊保護を常に出力するべきであることを示します。 この属性はssp関数属性を上書きします。

もしsspreq属性を持つ関数が、sspreq属性を持たない関数にインライン展開される場合、 生じる関数はsspreq属性を持つでしょう。
危険域不使用(noredzone)
この属性は、対象固有のABIが通常それを許しても、コード生成時に危険域(redzone)を使用するべきでないことを示します。
暗黙の浮動小数禁止(noimplicitfloat)
この属性は暗黙の浮動小数点命令を不能にします。
生(naked)
この属性は、関数の突入/離脱処理を生成しません。 これは極めてシステム特有の結果をもたらします。
(モジュールレベル・インラインアセンブリ(Module-Level Inline Assembly)

モジュールは、モジュールレベル・インラインアセンブリ(module-level inline asm)ブロックを含むことができます。 これはGCCの「ファイルスコープ・インラインアセンブリ」ブロックに相当します。。 このブロックは、LLVMによって内部的に連結され、単一の単位として扱われますが、 もし望むなら.llファイル内では分離していてもかまいません。 書式は非常に簡単です。

module asm "inline asm code goes here"
module asm "more can go here"

文字列は印字不能文字をエスケープすることによって任意の文字を含むことができます。 エスケープシーケンスは単に「\xx」で、「xx」は二桁の16進数です。

アセンブラコードを生成する場合、単に機械語コードの.sファイルにインラインアセンブリコードを印刷します。

データ形式(Data Layout)

モジュールは、メモリにどのようにデータを配置するか明示する目標固有のデータ形式文字列を規定してもかまいません。 データ形式の文法は単にあります単純です。

    target datalayout = "layout specification"

配置仕様(layout specification)はマイナス符号('-')で区切られた仕様の一覧からなります。 各仕様は文字で始まり、その後ろにデータ形式のある側面を定義する情報を含むこともあります。 認められている仕様は以下の通りです。

E
対象はビッグ・エンディアン形式のデータ配置だと規定します。 すなわち、最上位ビットが最低位アドレス配置にあります。
e
対象はリトル・エンディアン形式のデータ配置だと規定します。 すなわち、最下位ビットが最低位アドレス配置にあります。
p:size:abi:pref
ポインタのsizeとそのabiを規定し、preferredでアライメントを取ります。サイズは全てビット表記です。 prefのアライメント規定は任意です。prefを省略する場合、その前の:も省略するべきです。
isize:abi:pref
与えられたビット・サイズ(size)の整数型用のアライメントを規定します。sizeの値は[1,2^23)の範囲になければなりません。
vsize:abi:pref
与えられたビット・サイズ(size)の配列用のアライメントを規定します。
fsize:abi:pref
与えられたビット・サイズ(size)の浮動小数用のアライメントを規定します。 サイズsizeの値は32(実数型)か64(倍長実数型)でなければなりません。
asize:abi:pref
与えられたビット・サイズ(size)の集合型用のアライメントを規定します。
ssize:abi:pref
与えられたビット・サイズ(size)のスタックオブジェクト用のアライメントを規定します。

与えられた対象用のデータ形式を構築する場合、 データ形式(datalayout)キーワード(指定があれば)で仕様が上書きされるまで、 LLVMはデフォルトの仕様セットを用います。デフォルト仕様はこの一覧から与えます。

LLVMが与えられた型のアライメントを決める場合、以下の規則を使用する。

  1. 型が特定の仕様に完全に合致する場合、その仕様を使用します。
  2. 型が整数型で合致するものが見つからない場合、型のビットサイズより大きいもので最小を整数型のものを使用します。 それよりもビットサイズの大きい仕様がない場合、最大の整数型を使用します。 例えば、上のデフォルト仕様が与えられた場合、i7型はi8(次に大きい)のアライメントを、 一方、i65もi256もi64(最大仕様)のアライメントを使用します。
  3. 型が配列型で合致するものが見つからない場合、fall back(※)として最小の配列型が使われる。 例えば、<128 x double>は64 <2 x double>で実装される。
型体系(Type System)

LLVMの型体系は、中間表現の重要な特長の一つです。 型によって、変形前に余分な解析を必要とせずに、中間表現で多くを直接最適化できます。 強い型体系は、生成コードを読みやすくし、 普通の三アドレスコード表現では実現できない新しい解析および変形を可能にします。

型分類(Type Classifications)

型は幾つかの有用な分類に分けられます。

分類
整数(integer) i1, i2, i3, ... i8, ... i16, ... i32, ... i64, ...
浮動小数(floating point) float, double, x86_fp80, fp128, ppc_fp128
※(first class) 整数(integer), 浮動小数(floating point), ポインタ(pointer), ベクトル(vector), 構造体(structure), 配列(array), ラベル(label), メタデータ(metadata).
原始型(primitive) ラベル(label), void(void), 浮動小数(floating point), メタデータ(metadata).
派生型(derived) 整数(integer), 配列(array), 関数(function), ポインタ(pointer), 構造体(structure), 圧縮構造体(packed structure), ベクトル(vector), 不確定型(opaque).

※(first class)型は恐らく最も重要です。 命令が提供したり、引数で渡されたり、命令の項として使われるのは、これらの型の値だけです。

原始型(Primitive Types)

原始型(primitive types)はLLVMシステムの基本的な組込構造です。

浮動小数型(Floating Point)
Type説明
float32ビット浮動小数
double64ビット浮動小数
fp128128ビット浮動小数(112-bit mantissa)
x86_fp8080ビット浮動小数(X87)
ppc_fp128128ビット浮動小数(two 64-bits)
Void型
概要:

Void型(void type)は何らの値を表現せず、サイズもありません。

構文:
  void
ラベル型(Label)
概要:

ラベル(label)型はコードのラベルを表現します。

構文:
  label
メタデータ型(Metadata)
概要:

メタデータ(metadata)型は埋込のメタデータを表現します。 ※メタデータを含む派生型はmetadata*だけで、 メタデータを受け取るか返す関数型のパラメータはメタデータですが、ポインタではありません。

The only derived type that may contain metadata is metadata* or a function type that returns or takes metadata typed parameters, but not pointer to metadata types.
構文:
  metadata
派生型(Derived Types)

LLVMの本当の力はシステムの派生型にあります。 これはプログラマに配列、関数、ポインタ、その他の有用な型を与えます。 派生型は再帰できることに注意してください。例えば、これは二次元配列を可能にします。

整数型(Integer)
概要:

整数型(integer)は単にその整数型が望むビット幅を指定するだけの非常に単純な派生型です。 1~2^23-1(約8億)迄の任意のビット幅を指定できます。

構文:
  iN

Nの値で整数が望むビット数を規定します。

例:
i1 単一ビット整数
i32 a 32ビット整数
i1942652 1億ビットを超える本当に大きな整数

コード生成部が関数の戻り値型に大きな整数型をサポートしないことに注意してください。 コード生成部が処理できる戻り値型の上限値は対象依存です。 今のところ、大抵の32bビット対象では64ビットまで、64ビット対象では128ビットまでです。

配列型(Array)
概要:

配列(array)は非常に単純な派生型でメモリ上に要素を連続して配置します。 配列はサイズ(要素数)と元になる型を必要とします。

構文:
  [<# elements> x <elementtype>]

要素数は整数定数で、elementtypeはゼロ長を含めた任意の型です。

例:
[40 x i32] 32ビット整数40個の配列
[41 x i32] 32ビット整数41個の配列
[4 x i8] 8ビット整数4個の配列

多次元配列の例です。

[3 x [4 x i32]] 32ビット整数の3x4配列
[12 x [10 x float]] 単精度浮動小数12x10配列
[2 x [3 x [4 x i16]]] 16ビット整数の2x3x4配列

LLVMの可変長配列(variable sized arrays)では、ゼロ長配列でも実装できます。 通常、LLVMにおいて、配列の終端を過ぎたアクセスは未定義です。 (例:3要素の配列に対して5番目の要素にアクセスするのは不正) しかしながら、特例として、ゼロ長配列は可変長であると認識されます。 これにより、例えばパスカル形式配列(pascal style arrays)の実装が、 LLVMの"{ i32, [0 x float]}"で可能になります。

コード生成部が関数の戻り値型に大きな集合型をサポートしないことに注意してください。 コード生成部が処理できる戻り値型の上限値は対象と集合要素の型に依存します。

関数型(Function)
概要:

関数型(function)は関数シグニチャとみなせます。それは戻り値型と仮引数型のリストから構成されます。 関数型の戻り値型は巣から型、void型、または構造体型です。 もし戻り値型が構造体型の場合、全ての構造体要素は※first class typeで、 また構造体は少なくとも一つ以上の要素を持っていなければなりません。

構文:
  <returntype list> (<parameter list>)

引数リスト(<parameter list>)の箇所は、型指定子のコンマ区切リストです。 引数リストは任意に、関数が可変個の引数をとることを示す...型を含んでいるかもしれません。 可変個引数関数は、可変引数取扱組込処理(variable argument handling intrinsic)により、 それらの要素にアクセスできます。 「<戻り値リスト(returntype list)>は、 ファーストクラス(first class)型指定子のコンマに分離されたリストです。

例:
i32 (i32) i32を一つ引数に取り、i32を返す関数。
float (i16 signext, i32 *) * 符号拡張するi16i32ポインタを引数に取り、 floatを返す関数へのポインタ(Pointer)
i32 (i8*, ...) 少なくとも一つ以上のi8(Cでいえばchar)のポインタを取り、 整数を返す可変引数関数。これはprintfのLLVMにおけるシグニチャです。
{i32, i32} (i32) i32の引数を取り、二つのi32を一つの集合体型{ i32, i32 }として返す関数。
構造体型(Structure Type)
概要(Overview)

構造体型(structure type)はメモリ上でデータメンバの集合をまとめて表現するために用います。 基底となるプロセッサのABIに合わせてフィールド型のパッキングを定義します。 構造体の要素はサイズを持つ任意の型になりえます。

構造体は、getelementptr命令でフィールドのアドレスを得て、 loadstoreを用いてアクセスします。

構文:
  { <type list> }
例:
{ i32, i32, i32 } 3つのi32値を持ちます。
{ float, i32 (i32) * } 最初の要素floatと、 次の要素にi32を引数にとりi32を返す関数ポインタを持つペア

コード生成部が関数の戻り値型に大きな集合型をサポートしないことに注意してください。 コード生成部が処理できる戻り値型の上限値は対象と集合要素の型に依存します。

圧縮構造体型(Packed Structure Type)
概要:

圧縮構造体(packed structure)型は、メモリ上でデータメンバの集合をまとめて表現するために用います。 フィールドの間にパディングはありません。更に、圧縮構造体型のアライメントは1バイトです。 圧縮構造体の要素はサイズを持つ任意の型になりえます。

構造体は、getelementptr命令でフィールドのアドレスを得て、 loadstoreを用いてアクセスします。

構文:
  < { <type list> } > 
例:
< { i32, i32, i32 } > 3つのi32値を持ちます。
< { float, i32 (i32)* } > 最初の要素floatと、 次の要素にi32を引数にとりi32を返す関数ポインタを持つペア
ポインタ型(Pointer)
概要:

多くの言語において、ポインタ型はメモリ上で有効な他のオブジェクトへの、 ポインタまたは参照として表されます。 ポインタ型には、ポイントするオブジェクトが存在する対象固有のアドレス空間を定義するための数値、 任意のアドレス空間属性を持つかもしれません。デフォルト・アドレス空間は0です。

LLVMは、ラベルへのポインタ(label*)は許しても、 voidへのポインタ(void*)を許容しないことに注意してください。 代わりにi8*を使います。

構文:
  <type> *
例:
[4 x i32]* 四つのi32値を持つ配列へのポインタ
i32 (i32 *) * i32*を引数に取りi32を返す関数へのポインタ
i32 addrspace(5)* アドレス空間#5にあるi32へのポインタ
ベクトル型(Vector)
概要:

ベクトル(vector)は要素の配列を表す単純な派生型です。ベクトル型は複数の原始データが並列していて、 単一命令で並行的に操作される時に使用します。(SIMD) ベクトルはサイズ(要素数)と元になる型を必要とします。

またベクトルの長さは2の乗数((1, 2, 4, 8, 16 ...)でなければなりません。 ベクトルは※first classと考えられます。

構文:
  < <# elements> x <elementtype> >

要素数は整数定数で、要素の型は整数または浮動小数になります。

例:
<4 x i32> 4つの32ビット整数によるベクトル
<8 x float> 8つの32ビット浮動小数によるベクトル
<2 x i64> 2つの 64ビット整数によるベクトル

コード生成部が関数の戻り値型に大きなベクトル型をサポートしないことに注意してください。 コード生成部が処理できる戻り値型の上限値は対象に依存します。 現状、ハードウェアのベクトルレジスタの数倍程度が限界です。

不確定型(Opaque)
概要:

不確定型(Opaque)はシステムで不明な型を表現します。 これは(例えば)Cの概念で言う前方宣言の構造体型に相当します。 LLVMでは、最終的に任意の型(構造体型だけでない)に不確定型を解決することができます。

構文:
  opaque
例:
opaque 不確定型
型の上方参照(Type Up-references)
概要:

上方参照("up reference")は名前を持つことを要求せずに語彙的に囲まれた型を許します。 例えば、構造体宣言は語彙的なメンバーである型(※)の何かへのポインタを含むかもしれません。 (型宣言と命名されるような相当物の)上方参照の例は次のものを含んでいる

   { \2 * }                %x = type { %x* }
   { \2 }*                 %y = type { %y }*
   \1*                     %z = type %z*

上方参照は、アセンブリ出力が、その周期中に型の名前宣言がない場合に周期的な型を出力するために必要です。 アセンブリ出力は無限に型文字列を出力したくないので、無名の再帰的な型を扱うために構文を必要とします。 (llvm IRにおいては全ての名前が任意です)

構文:
   \<level>

このlevelは引用している語彙方の数です。

例:
\1* 自己参照ポインタ
{ { \3*, i8 }, i32 } 上方参照が一番外の構造体を指す再帰的構造体
定数(Constants)

LLVMには幾つかの異なる定数の基本型があります。この節ではそれらとその構文について説明します。

単純定数(Simple Constants)
真偽値定数(Boolean constants)
truefalseの二つの文字列がi1型の定数として有効です。
整数定数(Integer constants)
('4'のような)標準整数(Standard constants)は整数型の整数です。負数も使用可能です。
浮動小数定数(Floating point constants)
浮動小数定数(Floating point constants)は標準的な十進法(例:123.421)、 指数表現(例:1.23421e+2)、またはより精度の高い十六進法(後述)を使用します. アセンブリは浮動小数定数の正確な十進値を要求します。 例えば、アセンブリが1.25を許容しても、1.3は二進数で循環数になるので拒否します。 浮動小数定数は浮動小数型が必要です。
ヌルポインタ定数(Null pointer constants)
識別子nullはヌルポインタ定数であり、ポインタ型になります。

定数用の1つの非直感的なの表記法は浮動小数点定数の十六進形式です。 例えば、形式「double 0x432ff973cafa8000」は(はるかに読みにくいですが) 「double 4.5e+15」と等価です。 16進の浮動小数定数が必要となる唯一のケース(そして逆アセンブラがそれを生成する唯一のケース)は、 浮動小数点定数を生成しなければならないが、合理的な桁数の中で10進の浮動小数点数としてそれを表わすことができない場合です。 例えば、アセンブラと逆アセンブラが定数のビットを変更しないよう、 非数(NaN)、無限大、その他の特殊な値はIEEEの16進数形式で表現します。

16進数形式を使用する場合、浮動小数(float)と倍長精度浮動小数(double)の定数は上のような16桁形式で表現します。 (これは倍長精度浮動小数(double)のIEEE754表現に合致します) しかし浮動小数(float)値も、IEE754単精度のように正確に値を表現できなければなりません。 16進数形式は常にlong doubleを使用します。long doubleには三種類の形式があります。 x86が使う80ビット形式は0xKに続く20桁の十六進数で表現します。 PowerPCが使う128ビット形式(doubleを二つ並べたもの)は0xMに続く32桁の十六進数で表現します。 IEEEの128ビット形式は0xLに続く32桁の十六進数で表現します。現状サポートする対象では、この形式使用されません。 long doubleは、対象のlong double形式と合致した場合に使用できます。 全ての16進数形式はビッグエンディアン(左に符号ビット)です。

複合定数(Complex Constants)

複合定数は単純な定数とより小さな複合定数の(潜在的に再帰する)組み合わせです。 .

構造体定数(Structure constants)
構造体定数は、構造体型定義(括弧({})で囲まれた要素のカンマ区切りリスト)に似た記法で表します。 例えば「{ i32 4, float 17.0, i32* @G }」では、@G@G = external global i32として宣言されます。 構造体定数は構造体型でなければならず、要素の数と型はその型の規定と一致しなければなりません。
配列定数(Array constants)
配列定数は配列型定義(括弧([])で囲まれた要素のカンマ区切りリスト)に似た記法で表します。 例えば「[ i32 42, i32 11, i32 74 ]」のように。 配列定数は配列型でなければならず、要素の数と型はその型の規定と一致しなければなりません。
ベクトル 定数(Vector constants)
ベクトル定数はベクトル配型定義(括弧(<>)で囲まれた要素のカンマ区切りリスト)に似た記法で表します。 例えば、「< i32 42, i32 11, i32 74, i32 100 >」のように。 ベクトル定数はベクトル型でなければならず、要素の数と型はその型の規定と一致しなければなりません。
ゼロ初期化(Zero initialization)
文字列zeroinitializerで、スカラや複合型を含む任意の型をゼロ初期化して使用できます。 これは大量のゼロ初期化(例えば大きな配列)の表示を避ける場合などに使われ、 それは常に正確に明示的なゼロ初期化と等価になります。
メタデータ節(Metadata node)
メタデータ節(metadata node)はメタデータ型を持つ構造体のような定数です。 例えば「metadata !{ i32 0, metadata !"test" }」のような。 命令ストリームの一部と解釈される他の定数と異なり、メタデータは例えばデバッグ情報のような付加情報をその場所に付与します。
大域変数と関数アドレス(Global Variable and Function Addresses)

大域変数(global variables)関数のアドレスは、常に暗黙に有効な(結合時)定数です。 これらの定数は大域識別子が使われる際に明示的に参照され、 常にポインタ型です。例えば、以下はLLVMで正当なファイルです。

@X = global i32 17
@Y = global i32 42
@Z = global [2 x i32*] [ i32* @X, i32* @Y ]
不定値(Undefined Values)

文字列undefは特定の値を持たず、型のない(type-less)定数と認識されます。 不定値は定数の許される場所なら何処でも、どんな型にもなります。

不定値はコンパイラにプログラムがその値を問題なく使用できることを示し(※)、 コンパイラは最適化のためにこれを自由に使用します。

定数式(Constant Expressions)

定数式(Constant expressions)は、定数として他の定数による式を許すために使用します。 定数式は任意のfirst class(※)型であり、 副作用(side effects)のない任意のLLVM命令が使用できます。 (例えばloadやcallは対応していません) 以下が定数式の構文です。

trunc ( CST to TYPE )
定数を他の型の定数に切り詰めます。CSTのビット幅はTYPEのビット幅より広くなければなりません。 また、両方とも整数型でなければなりません。
zext ( CST to TYPE )
定数を他の型の定数にゼロ拡張します。CSTのビット幅はTYPEのビット幅以下でなければなりません。 また、両方とも整数型でなければなりません。
sext ( CST to TYPE )
定数を他の型の定数に符号拡張します。CSTのビット幅はTYPEのビット幅以下でなければなりません。 また、両方とも整数型でなければなりません。
fptrunc ( CST to TYPE )
浮動小数を他の浮動小数型定数に切り詰めます。 CSTのビット幅はTYPEのビット幅より広くなければなりません。 また、両方とも浮動小数型でなければなりません。
fpext ( CST to TYPE )
浮動小数を他の型の定数に拡張します。CSTのビット幅はTYPEのビット幅以下でなければなりません。 また、両方とも浮動小数型でなければなりません。
fptoui ( CST to TYPE )
浮動小数定数を相当する符号無整数定数に変換します。 TYPEはスカラまたはベクトルの整数型でなければなりません。 CSTはスカラまたはベクトルの浮動小数型でなければなりません。 CSTもTYPEもスカラまたはまたは同一要素数のベクトル型でなければなりません。 もしその値が整数で表現できない場合、その結果は未定義です。
fptosi ( CST to TYPE )
浮動小数定数を相当する符号付整数定数に変換します。 TYPEはスカラまたはベクトルの整数型でなければなりません。 CSTはスカラまたはベクトルの浮動小数型でなければなりません。 CSTもTYPEもスカラまたはまたは同一要素数のベクトル型でなければなりません。 もしその値が整数で表現できない場合、その結果は未定義です。
uitofp ( CST to TYPE )
符号無整数定数を相当する浮動小数定数に変換します。 TYPEはスカラまたはベクトルの浮動小数型でなければなりません。 CSTはスカラまたはベクトルの整数型でなければなりません。 CSTもTYPEもスカラまたはまたは同一要素数のベクトル型でなければなりません。 もしその値が浮動小数で表現できない場合、その結果は未定義です。
sitofp ( CST to TYPE )
符号付整数定数を相当する浮動小数定数に変換します。 TYPEはスカラまたはベクトルの浮動小数型でなければなりません。 CSTはスカラまたはベクトルの整数型でなければなりません。 CSTもTYPEもスカラまたはまたは同一要素数のベクトル型でなければなりません。 もしその値が浮動小数で表現できない場合、その結果は未定義です。
ptrtoint ( CST to TYPE )
ポインタ型定数を相当する整数定数に変換します。 TYPEは整数型でなければなりません。CSTはポインタ型でなければなりません。 CSTは整数型にT合わせるため、必要ならばゼロ拡張されるか、切り捨てられるかします。
inttoptr ( CST to TYPE )
整数定数を相当するポインタ型定数に変換します。 TYPEはポインタ型でなければなりません。CSTは整数型でなければなりません。 CSTはポインタ型にあわせるため、必要ならばゼロ拡張されるか、切り捨てられるかします。 これは本当に危険です!
bitcast ( CST to TYPE )
定数CSTを他のTYPEに変換します。この項の制約はbitcast 命令のものと同様です。(※)
getelementptr ( CSTPTR, IDX0, IDX1, ... )
getelementptr操作を定数に行います。 getelementptr命令により、 このインデクスリストはゼロ個以上のインデクスを持つ可能性があります。 これはCSTPTR型の感覚を得る必要があります。(※)
select ( COND, VAL1, VAL2 )
定数にselect操作を行います。
icmp COND ( VAL1, VAL2 )
定数にicmp操作を行います。
fcmp COND ( VAL1, VAL2 )
定数にfcmp演算を行います。
extractelement ( VAL, IDX )
定数にextractelement演算を行います。
insertelement ( VAL, ELT, IDX )
定数にinsertelement演算を行います。
shufflevector ( VEC1, VEC2, IDXMASK )
定数にshufflevector演算を行います。
OPCODE ( LHS, RHS )
LHSとRHS定数に特定の演算を行います。 OPCODEは任意のバイナリビット単位バイナリ演算です。 項の制約は相当する命令と同等です。(例えば浮動小数のビット演算は許されません)
埋込メタデータ(Embedded Metadata)

埋込メタデータ(Embedded metadata)はプログラムの動作に影響を与えずに、 命令ストリームに任意の情報を付加する方法を提供します。 文字列と節の、二つの基本的なメタデータがあります。 全てのメタデータはmetadata型を持ち、構文上は先行する感嘆符(!)で識別されます。

メタデータ文字列はダブルクォートで囲まれた文字列です。 非印刷文字を"\xx"("xx"は二桁の十六進コード)でエスケープすることで、任意の文字を含めることができます。 例えば、!"test\00"のように。

メタデータ節は、構造体定数のような記法で表されます(大括弧で囲まれた要素のカンマ区切リストと先行する感嘆符)。 例えば、!{ metadata !"test\00", i32 10}のように。

メタデータ節は自身が保持する値の変更を追跡しようとします。 値が削除される時、metadata !{null, i32 10}のように型のないnullに置換されます。

命令が利用可能できないか、容易に計算できないプログラムに関する追加情報を提供するために、 最適化はメタデータを土台とするかもしれません。 同様に、コード生成部はデバッギング情報を示すために特定のメタデータ形式の使用を予期するかもしれません。

その他の値
インラインアセンブリ式(Inline Assembler Expressions)

LLVMは、(モジュールレベル・インラインアセンブリ以外に) 特定の値を通してインラインアセンブリ式をサポートします。 この値は(生成する命令を含む)文字列、(文字列としてstoreされる)の項制約リスト、 そしてそのインラインアセンブリ式が副作用を持つか否かを示すフラグとして、 インラインアセンブリを表現します。 インラインアセンブリ式の例です。

i32 (i32) asm "bswap $0", "=r,r"

インラインアセンブリ式はcall命令の呼出項としてのみ使用できます。 従って、典型的にはこうなります。

%X = call i32 asm "bswap $0", "=r,r"(i32 %Y)

制約リストにない副作用を持つインラインアセンブリは、副作用を持つマークを持たなければなりません。 これは、以下のようにsideeffectキーワードを用いて行います。

call void asm sideeffect "eieio", ""()

TODO: アセンブリの書式と文字列の制約の文書化が必要です。 何ができるかに制約を課します(例えば複製、移動等の文書化が必要です) このリファレンスは恐らく、総合的な観点からインラインアセンブリをカバーする他のドキュメントになるでしょう。

命令参照(Instruction Reference)

LLVM命令セットは幾つかの異なる命令分類からなります。 終端命令(terminator instructions)二項命令(binary instructions)ビット単位二項命令(bitwise binary instructions)メモリ命令(memory instructions)、 そして、その他の命令(other instructions)です。

終端命令(Terminator Instructions)

前述のように、 プログラム内の全ての基本ブロックは終端(Terminator)命令で終わります。 これは現在のブロックが完了した後に、どのブロックが実行されるべきかということを示します。 これらの終端命令は、大抵void値です。 (唯一の例外invoke命令を除いて)これらは値ではなく制御フローを生成します。

ret命令、 br命令、 switch命令、 invoke命令、 unwind命令、 unreachable命令、 の六つの異なる終端命令があります。

復帰(ret)命令
構文:
  ret <type> <value>       ; 非void関数から値を返す
  ret void                 ; void関数から復帰
概要:

ret命令は、関数ブロックから呼出元に制御フローを戻す(そして必要なら値を返す)ために使用します。

二つのret命令形式があります。 一つは値を返して制御フローを復帰するもの、もう一つは制御フローだけを復帰するものです。

引数:

ret命令は任意に一つの引数(戻り値になります)を取れます。 戻り値の型は、first class※でなければなりません

もし戻り値が非void型にもかかわらず戻り値を持たないret命令や、 戻り値がvoid型にもかからわず戻り値のあるret命令を持つ関数は、 規格合致(well formed)ではありません。

意味:

ret命令が実行されるとき、制御フローが呼出元関数のコンテキストに復帰します。 もし呼出元が呼出(call)命令ならば、実行は呼出の命令に続きます。 もし呼出元がinvoke命令ならば、「通常(normal)」対象ブロックの 開始点にある命令に続きます。この命令が値を返す場合、その値は呼出元かインボーカ(※)命令の 戻り値に設定されるものとします。

  ret i32 5                       ; 整数の5を返す
  ret void                        ; void関数からの復帰
  ret { i32, i8 } { i32 4, i8 2 } ; 4と2の構造体を返す

コード生成部は大きな戻り値を完全にはサポートしないことに注意してください。 現状サポートされる規定サイズは対象に依存します。 整数であれば、32ビットの対象では大抵64ビットが上限、64ビットの対象であれば128ビットが上限です。 複合型については、現状の制限は要素型に依存します。 例えば大抵の環境で合計2つの整数か合計2つの浮動小数要素が上限です。

分岐(br)命令
構文:
  br i1 <cond>, label <iftrue>, label <iffalse>
br label <dest> ; 無条件分岐
概要:

br命令は、現在の関数内で異なる基本ブロックに制御フローを移す際に使用します。 この命令には二つの形式があり、条件分岐と無条件分岐に相当します

引数:

br命令の条件分岐形式は単項のi1値と二つのlabel値を取ります。 br命令の無条件分岐形式は単項のlabel値を飛び先として取ります。

意味:

上の条件付br命令では、i1引数が評価されます。 その値がtrueならば、制御フローはiftrueラベル引数に移ります。 また、"cond"がfalseならば、制御フローはiffalseラベル引数に移ります。

Test:
%cond = icmp eq i32 %a, %b
br i1 %cond, label %IfEqual, label %IfUnequal
IfEqual:
ret i32 1
IfUnequal:
ret i32 0
選択(switch)命令
構文:
  switch <intty> <value>, label <defaultdest> [ <intty> <val>, label <dest> ... ]
概要:

switch命令は、制御フローを複数の異なる場所に移動するために使用します。 これは複数の飛び出しから一つを選んで分岐できるbr命令の生成です。

引数:

switch命令は3つの引数を取ります。整数の比較値valueと、 デフォルトのラベル先、そして比較値定数とラベルのペアの配列です。 テーブルに同じ定数のエントリが重複してはなりません。

意味:

switch命令は値と飛び先のテーブルを規定します。 switch命令が実行されるとき、このテーブルが与えられた値で走査されます。 値が見つかると、制御フローは相当する飛び先に移動します。 見つからない場合、制御フローはデフォルトの飛び先に移動します。

実装

対象マシンと特にswitch命令の特性によって、 この命令は異なる実装コードを生成するかもしれません。 例えば、条件分岐の連続やテーブル参照などです。

 ; 条件付分岐命令の例
 %Val = zext i1 %value to i32
 switch i32 %Val, label %truedest [ i32 0, label %falsedest ]

 ; 無条件分岐の疑似
 switch i32 0, label %dest [ ]

 ; ジャンプテーブル参照の実装
 switch i32 %val, label %otherwise [ i32 0, label %onzero
                                     i32 1, label %onone
                                     i32 2, label %ontwo ]
呼出※(invoke)命令
構文:
  <result> = invoke [cconv] [ret attrs] <ptr to function ty> <function ptr val>(<function args>) [fn attrs]
                to label <normal label> unwind label <exception label>
概要:

invoke命令は、制御フローをnormalラベルまたはexceptionラベルに移せるように、 制御を特定の関数に移します。 呼ばれた関数がret命令で復帰する場合、 制御フローは"normal"ラベルに戻ります。 もし呼ばれた関数(あらゆる間接的な呼び出しも含む)がunwind命令で戻る場合、 制御フローは割り込まれ、動的に最も近い"exception"ラベルに続きます。

引数:

この命令は幾つかの引数を要求します。

  1. 任意の"cconv"マーカは、calling convention呼出の使用を示します。 もし定義がない場合、この呼出はデフォルトでC呼出変換を使用します。
  2. 戻り値用に任意のParameter Attributesを並べます。 ここでは、zeroextsignextinreg属性だけが有効です。
  3. ptr to function tyは、呼び出される関数値のポインタのシグニチャが必要です。。 大抵の場合、これは直接的な関数呼出ですが、関数値の任意のポインタから分岐する間接的なinvoke呼出も可能です。
  4. function ptr valは、呼び出された関数のポインタを含む値です。
  5. function argsは、関数の引数型に合致する引数のリストです。 関数シグニチャが関数に可変個引数を許している場合、 追加の引数を規定してもかまいません。
  6. normal labelは、呼ばれた関数がret命令を呼んだ場合に到達します。
  7. exception labelは、呼ばれた関数がunwindで戻る場合に到達します。
  8. 任意のfunction attributesリストです。 ここでは、noreturnnounwindreadonlyreadnone属性だけが有効です。
意味:

この命令は、ほとんどの点で標準的なcall命令を処理するために設計されています。 主要な違いは、実行時ライブラリがスタックを巻き戻すためのラベルと関連して確立する点です。

この命令は、longjmpや例外の投入時に適切な掃除を保証するデストラクタを持つ言語で使用します。 加えて、catch節をサポートする高級言語の実装にも重要です。

SSA形式の目的から、invoke命令の戻す値の定義は現在のブロックから"normal"ラベルへの境界に至るまで有効です。 巻き戻しが起こった場合の戻り値は無効です。

  %retval = invoke i32 @Test(i32 15) to label %Continue
              unwind label %TestCleanup              ; {i32}:retval set
  %retval = invoke coldcc i32 %Testfnptr(i32 15) to label %Continue
              unwind label %TestCleanup              ; {i32}:retval set
復元(unwind)命令
構文:
  unwind
概要:
例外処理をインプリメントするために主としてこれを使用します。

unwind命令は、スタックを巻き戻し、 呼び出された際のinvoke命令で使用した動的な呼出スタック内の最初の呼出元から制御フローを続けます。 これは主に例外処理の実装で使用されます。

意味:

unwind命令は、現在の関数の即時的な中断を引き起こします。 動的な呼出スタックはその後、呼出スタックの先頭invoke命令を走査します。 一度見つけたならば、実行はinvoke命令で指定した"exceptional"宛先ブロックに継続します。 もし動的呼出にinvoke命令がない場合、その結果は未定義です。

不到達(unreachable命令
構文:
  unreachable
概要:

unreachable命令には、定義された意味がありません。 この命令は、コードが特定の箇所に到達しないことを最適化処理に伝えるために使用します。 戻らない関数やその他の理由で、その後のコードに到達しないことを示します。

意味:

unreachable命令には、定義された意味がありません。

二項演算子(Binary Operations)

二項演算子は、プログラム中のほとんどの演算で使用されます。 これらは同じ型の引数を二つ取り、それを演算して一つの値を得ます。 vectorデータ型の場合のように、複数のデータを表す項もあります。 戻り値も項と同じ型を持ちます。

幾つかの項が異なる二項演算子があります。

整数加算(add)命令
構文:
  <result> = add <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

add命令は二項の合計を返します。

引数:

add命令の二つの項は、整数値か整数値のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

生成される整数値は二項の合計です。

合計が符号無でオーバフローする場合、戻り値はモジュロ2n(nは結果のビット幅)の算術結果を返します。

LLVMの整数は2の補数表現なので、この命令は符号付と符号無の両方に有効です。

  <result> = add i32 4, %var          ; yields {i32}:result = 4 + %var
浮動小数加算(fadd)命令
構文:
  <result> = fadd <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

fadd命令は二項の合計を返します。

引数:

fadd命令の二つの項は、浮動小数または浮動小数のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

生成される浮動小数値は二項の合計です。

  <result> = fadd float 4.0, %var          ; yields {float}:result = 4.0 + %var
整数減算(sub)命令
構文:
  <result> = sub <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

sub命令は二項の差を返します。

他のほとんどの中間表現にあるneg命令を表わすためにsub命令を使用することに注意してください。

引数:

sub命令の二つの項は、整数値か整数値のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

生成される整数値は二項の差です。

差が符号無でオーバフローする場合、戻り値はモジュロ2n(nは結果のビット幅)の算術結果を返します。

LLVMの整数は2の補数表現なので、この命令は符号付と符号無の両方に有効です。

  <result> = sub i32 4, %var          ; yields {i32}:result = 4 - %var
  <result> = sub i32 0, %val          ; yields {i32}:result = -%var
浮動小数減算(fsub)命令
構文:
  <result> = fsub <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

fsub命令は二項の差を返します。

他のほとんどの中間表現にあるfneg命令を表わすためにfsub命令を使用することに注意してください。

引数:

fsub命令の二つの項は、浮動小数または浮動小数のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

生成される浮動小数値は二項の差です。

  <result> = fsub float 4.0, %var           ; yields {float}:result = 4.0 - %var
  <result> = fsub float -0.0, %val          ; yields {float}:result = -%var
整数乗算(mul)命令
構文:
  <result> = mul <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

mul命令は二項の積を返します。

引数:

mul命令の二つの項は、整数値か整数値のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

生成される整数値は二項の積です。

乗算結果が符号無でオーバフローする場合、戻り値はモジュロ2n(nは結果のビット幅)の算術結果を返します。

LLVMの整数は2の補数表現で結果は項と同じビット幅を持つので、この命令は符号付と符号無の両方に有効です。 切捨てのない商(例:i32xi32->i64)が必要な場合は、 二項を符号拡張またはゼロ拡張して切捨てされない積のサイズに合わせておくべきです。

  <result> = mul i32 4, %var          ; yields {i32}:result = 4 * %var
'fmul' Instruction
構文:
  <result> = fmul <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

fmul命令は二項の積を返します。

引数:

fmul命令の二つの項は、浮動小数または浮動小数のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

生成される浮動小数値は二項の積です。

  <result> = fmul float 4.0, %var          ; yields {float}:result = 4.0 * %var
'udiv' Instruction
構文:
  <result> = udiv <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

udiv命令は二項の商を返します。

引数:

udiv命令の二つの項は、整数値か整数値のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

生成される符号無整数値は二項の商です。

符号付整数と符号無整数の除算は異なることに注意してください。 符号付整数の除算はsdivを使ってください。

ゼロ除算は未定義動作となります。

  <result> = udiv i32 4, %var          ; yields {i32}:result = 4 / %var
'sdiv' Instruction
構文:
  <result> = sdiv <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

sdiv命令は二項の商を返します。

引数:

sdiv命令の二つの項は、整数値か整数値のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

符号付整数と符号無整数の除算は異なることに注意してください。 符号付整数の除算はsdivを使ってください。

意味:

生成される符号付整数値は小数部を切り捨てた二項の商です。

符号付整数と符号無整数の除算は異なることに注意してください。 符号無整数の除算はudivを使ってください。

ゼロ除算は未定義動作となります。 オーバフローも同様に未定義動作です。オーバフローはレアなケースですが、しかし発生します。 例えば、-2147483648を-1で32ビット除算した場合です。

  <result> = sdiv i32 4, %var          ; yields {i32}:result = 4 / %var
'fdiv' Instruction
構文:
  <result> = fdiv <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

fdiv命令は二項の商を返します。

引数:

fdiv命令の二つの項は、浮動小数または浮動小数のベクトルでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

生成される浮動小数値は二項の商です。

  <result> = fdiv float 4.0, %var          ; yields {float}:result = 4.0 / %var
符号無剰余算(urem)命令
構文:
  <result> = urem <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

uremは二項の符号無除算の剰余を返します。

引数:

urem命令の二つの引数は、integerまたは整数のvectorでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

この命令は、符号無整数で除算の剰余(remainder)を返します。 この命令は常に剰余を得るために整数除算を実行します。

符号無整数の剰余と符号付整数の剰余は異なる命令なことに注意してください。 符号付整数の乗除には、sremを使用します。

ゼロ除算の剰余は未定義動作となります。

  <result> = urem i32 4, %var          ; yields {i32}:result = 4 % %var
符号付剰余算(srem)命令
構文:
  <result> = srem <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

srem命令は二項の符号付除算の剰余を返します。 この命令はvector版もありますが、その場合でもその要素は整数でなければなりません。

引数:

srem命令の二つの引数は、integerまたは整数のvectorでなければなりません。 両者は識別できる方を持っていなければなりません。(※identical types)。

意味:

この命令は、除算の剰余(remainder)を返します。 除算するop2と同じ符号を持つmodulo命令とは異なり、この結果は被除数op1と同じ符号を持ちます。 この差異に関する更なる情報は、The Math Forumを参照してください。 これが多くの言語においてどのように実装されているかについての表は、Wikipedia: modulo operationを参照してください。

符号無整数の剰余と符号付整数の剰余は異なる命令なことに注意してください。 符号無整数の乗除には、uremを使用します。

ゼロ除算の剰余は未定義動作となります。 オーバフローも同様に未定義動作です。オーバフローはレアなケースですが、しかし発生します。 例えば、-2147483648を-1で32ビット除算した場合です。
(この剰余は正確にはオーバフローしませんが、このルールにより除算と剰余の両方の結果を返す命令でsremを実装することができるようになります。

  <result> = srem i32 4, %var          ; yields {i32}:result = 4 % %var
剰余残(frem)命令
構文:
  <result> = frem <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

frem命令は二項の除算の剰余を返します。

引数:

frem命令の二つの引数はfloating pointまたは浮動小数のvectorです。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

この命令は、除算の剰余(remainder)を返します。 剰余は被除数と同じ符号を持ちます。

  <result> = frem float 4.0, %var          ; yields {float}:result = 4.0 % %var
二項ビット演算子(Bitwise Binary Operations)

二項ビット演算子はプログラム中でビットを操作する様々な形式を行うために使用されます。 それらは一般に非常に効率的な命令で、一般に他の命令から還元された強さになりえます。 それらは、同じ型の2つのオペランドを要求し、それらに対する演算を行い、単一の値を生みます。 最終的な値はそのオペランドと同じ型です。

左シフト(shl)命令
構文:
  <result> = shl <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

shl命令は、第一項を指定ビット数だけ左方向にシフトして返します。

引数:

shlの両引数は同じintegerまたは整数のvector型でなければなりません。 op2は符号無値と扱われます。

意味:

生成される値は、op1 * 2op2 mod 2n (但しnは結果の幅)です。 もしop2が(動的にでも静的にでも)負数、またはop1のビット数以上だった場合、結果は未定義です。 もし引数がベクタならば、op1の各ベクタ要素は、対応するop2のシフト量でシフトされます。

  <result> = shl i32 4, %var   ; yields {i32}: 4 << %var
  <result> = shl i32 4, 2      ; yields {i32}: 16
  <result> = shl i32 1, 10     ; yields {i32}: 1024
  <result> = shl i32 1, 32     ; undefined
  <result> = shl <2 x i32> < i32 1, i32 1>, < i32 1, i32 2>   ; yields: result=<2 x i32> < i32 2, i32 4>
論理右シフト(lshr)命令
構文:
  <result> = lshr <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

lshr命令(論理右シフト: logical shift right)は、第一項を指定ビット数だけゼロ埋めして指定数だけ右シフトして返します。

引数:

lshr命令の両引数は同じintegerまたは整数のvector型でなければなりません。 op2は符号無値と扱われます。

意味:

この命令は、常に論理右シフト演算をします。シフト後の最上位ビットはゼロビットで埋められるでしょう。 もしop2が(動的にでも静的にでも)負数、またはop1のビット数以上だった場合、結果は未定義です。 もし引数がベクタならば、op1の各ベクタ要素は、対応するop2のシフト量でシフトされます。

  <result> = lshr i32 4, 1   ; yields {i32}:result = 2
  <result> = lshr i32 4, 2   ; yields {i32}:result = 1
  <result> = lshr i8  4, 3   ; yields {i8}:result = 0
  <result> = lshr i8 -2, 1   ; yields {i8}:result = 0x7FFFFFFF 
  <result> = lshr i32 1, 32  ; undefined
  <result> = lshr <2 x i32> < i32 -2, i32 4>, < i32 1, i32 2>   ; yields: result=<2 x i32> < i32 0x7FFFFFFF, i32 1>
算術右シフト(ashr)命令
構文:
  <result> = ashr <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

ashr命令(算術右シフト:arithmetic shift right)は、第一項を符号拡張して指定数だけ右シフトして返します。

引数:

ashr命令の両引数は同じintegerまたは整数のvector型でなければなりません。 op2は符号無値と扱われます。

意味:

この命令は、常に算術右シフトをします。結果のの最上位ビットは、op1の符号ビットで埋められるでしょう。 もしop2が(動的にでも静的にでも)負数、またはop1のビット数以上だった場合、結果は未定義です。 もし引数がベクタならば、op1の各ベクタ要素は、対応するop2のシフト量でシフトされます。

  <result> = ashr i32 4, 1   ; yields {i32}:result = 2
  <result> = ashr i32 4, 2   ; yields {i32}:result = 1
  <result> = ashr i8  4, 3   ; yields {i8}:result = 0
  <result> = ashr i8 -2, 1   ; yields {i8}:result = -1
  <result> = ashr i32 1, 32  ; undefined
  <result> = ashr <2 x i32> < i32 -2, i32 4>, < i32 1, i32 3>   ; yields: result=<2 x i32> < i32 -1, i32 0>
論理積(and)命令
構文:
  <result> = and <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

and命令は二項のビット論理積を返します。

引数:

and命令の二引数は、integerまたは整数のvectorでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

and命令の真偽表は以下です。

In0 In1 Out
0 0 0
0 1 0
1 0 0
1 1 1
  <result> = and i32 4, %var         ; yields {i32}:result = 4 & %var
  <result> = and i32 15, 40          ; yields {i32}:result = 8
  <result> = and i32 4, 8            ; yields {i32}:result = 0
論理和(or)命令
構文:
  <result> = or <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

or命令は、二項のビット論理和を返します。

引数:

or命令の二引数はintegerまたは整数のvectorでなかればなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

or命令の真偽表は以下です。

In0 In1 Out
0 0 0
0 1 1
1 0 1
1 1 1
  <result> = or i32 4, %var         ; yields {i32}:result = 4 | %var
  <result> = or i32 15, 40          ; yields {i32}:result = 47
  <result> = or i32 4, 8            ; yields {i32}:result = 12
排他的論理和(xor)命令
構文:
  <result> = xor <ty> <op1>, <op2>   ; 結果{ty}を生じます
概要:

xor命令は、二項のビット排他論理和を返します。 xorは一の補数演算で実装されます。C言語でいう"~"演算子です。

引数:

xor命令の二引数はintegerまたは整数のvectorでなければなりません。 両項は識別できる型を持っていなければなりません(※identical types)。

意味:

xor命令の真偽表は以下です。

In0 In1 Out
0 0 0
0 1 1
1 0 1
1 1 0
  <result> = xor i32 4, %var         ; yields {i32}:result = 4 ^ %var
  <result> = xor i32 15, 40          ; yields {i32}:result = 39
  <result> = xor i32 4, 8            ; yields {i32}:result = 12
  <result> = xor i32 %V, -1          ; yields {i32}:result = ~%V
ベクタ演算((Vector Operations)

LLVMはターゲット依存の慣習でベクタ演算を表現するためのいくつかの命令をサポートします。 これらの命令は、ベクタを有効に処理するために必要とされる要素アクセスおよびベクタ特殊演算をカバーします。 LLVMは直接これらのベクタ演算をサポートしていますが、多くの精巧なアルゴリズムが、 特定の目標を十分に利用するように目標に特有の組込処理(intrinsics)を使用したいと思うでしょう。

要素除去(extractelement)命令
構文:
  <result> = extractelement <n x <ty>> <val>, i32 <idx>    ; yields <ty>
概要:

extractelement命令は、単一のスカラ要素をベクタの特定インデクスから除去します。

引数:

extract element命令の第一引数はvector型です。 第二引数は除去する要素の位置を示すインデクスです。このインデクスは変数でもかまいません。

意味:

結果は、valの要素型と同型のスカラです。 その値はvalidx位置にある値と同値です。 もしidxvalの長さを超えていたら、その結果は未定義です。

  %result = extractelement <4 x i32> %vec, i32 0    ; yields i32
要素挿入(insertelement)命令
構文:
  <result> = insertelement <n x <ty>> <val>, <ty> <elt>, i32 <idx>    ; yields <n x <ty>>
概要:

insertelement命令は、ベクタの特定インデクスにスカラ要素を挿入します。

引数:

insertelement命令の第一引数はvector型です。 第二引数は、第一引数の要素型と同型でなければなりません。 第三引数は、その値を代入しようとする位置を示すインデクスです。このインデクスは変数でもかまいません。

意味:

結果は、valと同型のベクタです。 その要素はidx位置(eltの値が挿入されています)を除いてvalの値と同一です。 もしidxvalの長さを超えていたら、その結果は未定義です。

  %result = insertelement <4 x i32> %vec, i32 1, i32 0    ; yields <4 x i32>
ベクトル混合(shufflevector)命令
構文:
  <result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <m x i32> <mask>    ; yields <m x <ty>>
概要:

shufflevector命令は、混合マスクと同じである入力および長さと同じ要素型を備えたベクトルを返して、 2つの入力ベクトルからの要素の交換を構築します。

引数:

shufflevector命令の最初の二引数は、互いに一致する方のベクタです。 第三引数は入替マスクで、常にi32型です。この命令の結果は、入替マスクと同じ長さで、最初の二引数の要素と同型を持つベクタです。

入替マスク引数は、定数整数か未定義値のいずれかによる定数ベクトルが必要です。

意味:

番号は、ベクトル両方を横切って左から右まで2つの入力ベクトルの要素に付けられます。 入替マスク引数は、結果ベクトルの各要素のために、結果要素が2つの入力ベクトルのどの要素を得るか明示します。 要素選択はundef(無視)でもよく、単一ベクトルから混合する場合、第二引数はundefかもしれません。

  %result = shufflevector <4 x i32> %v1, <4 x i32> %v2, 
                          <4 x i32> <i32 0, i32 4, i32 1, i32 5>  ; yields <4 x i32>
  %result = shufflevector <4 x i32> %v1, <4 x i32> undef, 
                          <4 x i32> <i32 0, i32 1, i32 2, i32 3>  ; yields <4 x i32> - Identity shuffle.
  %result = shufflevector <8 x i32> %v1, <8 x i32> undef, 
                          <4 x i32> <i32 0, i32 1, i32 2, i32 3>  ; yields <4 x i32>
  %result = shufflevector <4 x i32> %v1, <4 x i32> %v2, 
                          <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7 >  ; yields <8 x i32>
集合演算子(Aggregate Operations)

LLVMは集合に対するいくつかの命令をサポートします。

値除去(extractvalue)命令
構文:
  <result> = extractvalue <aggregate type> <val>, <idx>{, <idx>}*
概要:

extractvalue命令は、集合から構造体フィールド値や配列要素を除去します。

引数:

extractvalue命令の第一引数は、structか、array型の値です。 引数はgetelementptr命令に似た作法で除去する特定の値を示す定数です。

意味:

この結果は、引数インデクスが示す集合内の位置の値です。 The result is the value at the position in the aggregate specified by the index operands.

  %result = extractvalue {i32, float} %agg, 0    ; yields i32
値挿入(insertvalue)命令
構文:
  <result> = insertvalue <aggregate type> <val>, <ty> <val>, <idx>    ; yields <n x <ty>>
概要:

insertvalue命令は、値を集合の構造体フィールドまたは配列要素に挿入します。

引数:

insertvalue命令の第一引数は、structまたはarray型の値です。 第二引数は、挿入する一級値(※first-class value)です。 続く引数は定数です。 getelementptr命令と似た作法で値を挿入する位置を示す定数です。 挿入する値はインデクスが示す値と同型でなければなりません。

意味:

この結果は、valと同型の集合です。 インデックスによって指定された位置の値がeltのものであるという点を除いて、その値はvalのものです。

  %result = insertvalue {i32, float} %agg, i32 1, 0    ; yields {i32, float}
メモリアクセス/アドレス演算子(Memory Access and Addressing Operations)

SSAベース表現の設計キーポイントはメモリをどう表現するかです。 LLVMでは、メモリ配置はSSAフォームに含まれず、非常に簡潔です。 この節では、LLVMでどのようにメモリを読み、書き、確保し、解放するかを説明します。

ヒープメモリ割当(malloc)命令
構文:
  <result> = malloc <type>[, i32 <NumElements>][, align <alignment>]     ; yields {type*}:result
概要:

malloc命令はシステムヒープからメモリを割り当て、そのポインタを返します。 対象は常に汎用メモリ空間(アドレス空間ゼロ)に割り当てられます。

引数:

malloc命令はオペレーションシステムからsizeof(<type>)*NumElementsバイトのメモリを割り当て、 プログラムに適した型のポインタを返します。 "NumElements"を指定した場合、それは割り当てる要素数となります。 指定しなければ、"NumElements"はデフォルトで1です。 もし固定のアライメントを指定した場合、割り当て結果の値は少なくとも境界にアライメントされて生成されます。 指定しないかゼロを指定した場合、対象は型と互換性のあるあらゆる便利な境界への割り当てを選択できます。

typeはサイズを持つ型でなければなりません。

意味:

メモリは、システムのmalloc関数で割り当てられ、ポインタが戻ります。 ゼロサイズの割り当て結果は未定義です。メモリが確保できない場合、結果はNULLにになります。

  %array  = malloc [4 x i8]                     ; yields {[%4 x i8]*}:array

  %size   = add i32 2, 2                        ; yields {i32}:size = i32 4
  %array1 = malloc i8, i32 4                    ; yields {i8*}:array1
  %array2 = malloc [12 x i8], i32 %size         ; yields {[12 x i8]*}:array2
  %array3 = malloc i32, i32 4, align 1024       ; yields {i32*}:array3
  %array4 = malloc i32, align 1024              ; yields {i32*}:array4

コード生成部ではアライメント値に配慮しないことに注意してください。

メモリ解放(free)命令
構文:
  free <type> <value>                           ; yields {void}
概要:

free命令は将来再割り当てされる未使用メモリヒープのメモリブロックを返します。

引数:

valuemalloc命令で割り当てられた値を指すポインタとします。

意味:

この命令実行後、ポインタが指すメモリはもはや定義されません。 もしポインタがNULLの場合、命令はnoopになります。

  %array  = malloc [4 x i8]                     ; yields {[4 x i8]*}:array
            free   [4 x i8]* %array
スタックメモリ割当('alloca)命令
構文:
  <result> = alloca <type>[, i32 <NumElements>][, align <alignment>]     ; yields {type*}:result
概要:

alloca命令は、この関数がその呼び出し元に戻ったときに自動的に解放されるよう、 現在実行中の関数のスタックフレーム上のメモリを割り当てます。 対象は常に汎用メモリ空間(アドレス空間ゼロ)に割り当てられます。

引数:

malloc命令は実行スタック上にsizeof(<type>)*NumElementsバイトのメモリを割り当て、 プログラムに適した型のポインタを返します。 "NumElements"を指定した場合、それは割り当てる要素数となります。 指定しなければ、"NumElements"はデフォルトで1です。 もし固定のアライメントを指定した場合、割り当て結果の値は少なくとも境界にアライメントされて生成されます。 指定しないかゼロを指定した場合、対象は型と互換性のあるあらゆる便利な境界への割り当てを選択できます。

typeはサイズを持つ型でなければなりません。

意味:

メモリが割り当てられ、ポインタが返ります。 割り当て用の十分なスタックサイズがない場合、処理は未定義です。 allocaされたメモリは関数からの復帰時に自動的に解放されます。 alloca命令は一般的に有効なアドレスを持つ自動変数を表現するために使用されます。 (retunwind命令で)関数が返るとき、メモリは返却されます。 ゼロバイトの割り当ては正当ですが、結果は未定義です。

  %ptr = alloca i32                             ; yields {i32*}:ptr
  %ptr = alloca i32, i32 4                      ; yields {i32*}:ptr
  %ptr = alloca i32, i32 4, align 1024          ; yields {i32*}:ptr
  %ptr = alloca i32, align 1024                 ; yields {i32*}:ptr
メモリ読出(load)命令
構文:
  <result> = load <ty>* <pointer>[, align <alignment>]
<result> = volatile load <ty>* <pointer>[, align <alignment>]
概要:

load命令はメモリからの読み出しに使用します。

引数:

load命令の引数は読むためのメモリアドレスを規定します。 ポインタはfirst class型を指していなければなりません。 もしloadvolatileと指定されていれば、 最適化はこのloadと他のvolatileなloadおよび store命令とで実行順や実行数を変更することができなくなります。

任意の定数"align"引数は、演算のアライメント(メモリアドレスのアライメント)を規定します。 ゼロまたは"align"の省略は、対象の優先するアライメントを用います。 アライメント情報が正しいことを保証するのはコード生成部の責務です。 アライメントが過大だった場合の結果は未定義動作です。 アライメントが過少だった場合は効率の悪いコードが生成されるでしょう。 アライメントに対する1の指定は常に安全です。

意味:

指しているメモリ位置がロードされます。もしもロードされた値がスカラ型のものであれば、 読み出すバイト数はその型の全ビットを保持するのに必要な最小バイト数を超えません。 例えば、i24の読み出しは多くても3バイトです。 i20のような整数バイトでない型の値を読み出す場合、 読み出し元が同じ型として書き出されていないなら結果は未定義です。

例:
  %ptr = alloca i32                               ; yields {i32*}:ptr
  store i32 3, i32* %ptr                          ; yields {void}
  %val = load i32* %ptr                           ; yields {i32}:val = i32 3
'store' Instruction
構文:
  store <ty> <value>, <ty>* <pointer>[, align <alignment>]                   ; yields {void}
  volatile store <ty> <value>, <ty>* <pointer>[, align <alignment>]          ; yields {void}
概要:

store命令はメモリへの書き出しに用います。

引数:

store命令には二つの引数があります。: 保存する値とそれを保存するアドレスです。 <pointer>引数の型は、<value>引数のfirst class型のポインタでなければなりません。 もしstorevolatileと指定されていれば、 最適化処理はこのstoreと他のvolatileなloadstore命令の実行命令数を変更できません。

任意の定数"align"引数は演算のアライメント(メモリアドレスのアライメント)を指定します。 ゼロまたは"align"の省略は、対象の優先するアライメントを用います。 アライメント情報が正しいことを保証するのはコード生成部の責務です。 アライメントが過大だった場合の結果は未定義動作です。 アライメントが過少だった場合は効率の悪いコードが生成されるでしょう。 アライメントに対する1の指定は常に安全です。

意味:

メモリの内容が<pointer>引数で指定された位置の<value>を含むように更新されます。 もし<value>がスカラ型のものであれば、 書き出すバイト数はその型の全ビットを保持するのに必要な最小バイト数を超えません。 例えば、i24の書き出しは多くても3バイトです。 i20のような整数バイトでない型の値を書き出す場合、 その型に続く余分なビットが何を引き起こすかは未規定です。しかし、大抵は上書きすることになるでしょう。

  %ptr = alloca i32                               ; yields {i32*}:ptr
  store i32 3, i32* %ptr                          ; yields {void}
  %val = load i32* %ptr                           ; yields {i32}:val = i32 3
getelementptr命令
構文:
  <result> = getelementptr <pty>* <ptrval>{, <ty> <idx>}*
概要:

getelementptr命令は、複合データ構造内の要素のアドレスを得るために使用します。 この命令はアドレスを計算するだけでメモリにはアクセスしません。

引数:

最初の引数は常にポインタで、計算の基底となります。The remaining arguments are indices, that indicate which of the elements of the aggregate object are indexed. The interpretation of each index is dependent on the type being indexed into. The first index always indexes the pointer value given as the first argument, the second index indexes a value of the type pointed to (not necessarily the value directly pointed to, since the first index can be non-zero), etc. The first type indexed into must be a pointer value, subsequent types can be arrays, vectors and structs. Note that subsequent types being indexed into can never be pointers, since that would require loading the pointer before continuing calculation.

The type of each index argument depends on the type it is indexing into. When indexing into a (packed) structure, only i32 integer constants are allowed. When indexing into an array, pointer or vector, integers of any width are allowed (also non-constants).

For example, let's consider a C code fragment and how it gets compiled to LLVM:

struct RT {
  char A;
  int B[10][20];
  char C;
};
struct ST {
  int X;
  double Y;
  struct RT Z;
};

int *foo(struct ST *s) {
  return &s[1].Z.B[5][13];
}

GCCフロントエンドが出力したLLVMコード:

%RT = type { i8 , [10 x [20 x i32]], i8  }
%ST = type { i32, double, %RT }

define i32* %foo(%ST* %s) {
entry:
  %reg = getelementptr %ST* %s, i32 1, i32 2, i32 1, i32 5, i32 13
  ret i32* %reg
}
意味:

上の例では, the first index is indexing into the '%ST*' type, which is a pointer, yielding a '%ST' = '{ i32, double, %RT }' type, a structure. The second index indexes into the third element of the structure, yielding a '%RT' = '{ i8 , [10 x [20 x i32]], i8 }' type, another structure. The third index indexes into the second element of the structure, yielding a '[10 x [20 x i32]]' type, an array. The two dimensions of the array are subscripted into, yielding an 'i32' type. The 'getelementptr' instruction returns a pointer to this element, thus computing a value of 'i32*' type.

Note that it is perfectly legal to index partially through a structure, returning a pointer to an inner element. Because of this, the LLVM code for the given testcase is equivalent to:

  define i32* %foo(%ST* %s) {
    %t1 = getelementptr %ST* %s, i32 1                        ; yields %ST*:%t1
    %t2 = getelementptr %ST* %t1, i32 0, i32 2                ; yields %RT*:%t2
    %t3 = getelementptr %RT* %t2, i32 0, i32 1                ; yields [10 x [20 x i32]]*:%t3
    %t4 = getelementptr [10 x [20 x i32]]* %t3, i32 0, i32 5  ; yields [20 x i32]*:%t4
    %t5 = getelementptr [20 x i32]* %t4, i32 0, i32 13        ; yields i32*:%t5
    ret i32* %t5
  }

Note that it is undefined to access an array out of bounds: array and pointer indexes must always be within the defined bounds of the array type when accessed with an instruction that dereferences the pointer (e.g. a load or store instruction). The one exception for this rule is zero length arrays. These arrays are defined to be accessible as variable length arrays, which requires access beyond the zero'th element.

The getelementptr instruction is often confusing. For some more insight into how it works, see the getelementptr FAQ.

    ; yields [12 x i8]*:aptr
    %aptr = getelementptr {i32, [12 x i8]}* %saptr, i64 0, i32 1
    ; yields i8*:vptr
    %vptr = getelementptr {i32, <2 x i8>}* %svptr, i64 0, i32 1, i32 1
    ; yields i8*:eptr
    %eptr = getelementptr [12 x i8]* %aptr, i64 0, i32 1
    ; yields i32*:iptr
    %iptr = getelementptr [10 x i32]* @arr, i16 0, i16 0
Conversion Operations

The instructions in this category are the conversion instructions (casting) which all take a single operand and a type. They perform various bit conversions on the operand.

'trunc .. to' Instruction
構文:
  <result> = trunc <ty> <value> to <ty2>             ; yields ty2
概要:

The 'trunc' instruction truncates its operand to the type ty2.

引数:

The 'trunc' instruction takes a value to trunc, which must be an integer type, and a type that specifies the size and type of the result, which must be an integer type. The bit size of value must be larger than the bit size of ty2. Equal sized types are not allowed.

意味:

The 'trunc' instruction truncates the high order bits in value and converts the remaining bits to ty2. Since the source size must be larger than the destination size, trunc cannot be a no-op cast. It will always truncate bits.

  %X = trunc i32 257 to i8              ; yields i8:1
  %Y = trunc i32 123 to i1              ; yields i1:true
  %Y = trunc i32 122 to i1              ; yields i1:false
'zext .. to' Instruction
構文:
  <result> = zext <ty> <value> to <ty2>             ; yields ty2
概要:

The 'zext' instruction zero extends its operand to type ty2.

引数:

The 'zext' instruction takes a value to cast, which must be of integer type, and a type to cast it to, which must also be of integer type. The bit size of the value must be smaller than the bit size of the destination type, ty2.

意味:

The zext fills the high order bits of the value with zero bits until it reaches the size of the destination type, ty2.

When zero extending from i1, the result will always be either 0 or 1.

  %X = zext i32 257 to i64              ; yields i64:257
  %Y = zext i1 true to i32              ; yields i32:1
'sext .. to' Instruction
構文:
  <result> = sext <ty> <value> to <ty2>             ; yields ty2
概要:

The 'sext' sign extends value to the type ty2.

引数:

The 'sext' instruction takes a value to cast, which must be of integer type, and a type to cast it to, which must also be of integer type. The bit size of the value must be smaller than the bit size of the destination type, ty2.

意味:

The 'sext' instruction performs a sign extension by copying the sign bit (highest order bit) of the value until it reaches the bit size of the type ty2.

When sign extending from i1, the extension always results in -1 or 0.

  %X = sext i8  -1 to i16              ; yields i16   :65535
  %Y = sext i1 true to i32             ; yields i32:-1
'fptrunc .. to' Instruction
構文:
  <result> = fptrunc <ty> <value> to <ty2>             ; yields ty2
概要:

The 'fptrunc' instruction truncates value to type ty2.

引数:

The 'fptrunc' instruction takes a floating point value to cast and a floating point type to cast it to. The size of value must be larger than the size of ty2. This implies that fptrunc cannot be used to make a no-op cast.

意味:

The 'fptrunc' instruction truncates a value from a larger floating point type to a smaller floating point type. If the value cannot fit within the destination type, ty2, then the results are undefined.

  %X = fptrunc double 123.0 to float         ; yields float:123.0
  %Y = fptrunc double 1.0E+300 to float      ; yields undefined
'fpext .. to' Instruction
構文:
  <result> = fpext <ty> <value> to <ty2>             ; yields ty2
概要:

The 'fpext' extends a floating point value to a larger floating point value.

引数:

The 'fpext' instruction takes a floating point value to cast, and a floating point type to cast it to. The source type must be smaller than the destination type.

意味:

The 'fpext' instruction extends the value from a smaller floating point type to a larger floating point type. The fpext cannot be used to make a no-op cast because it always changes bits. Use bitcast to make a no-op cast for a floating point cast.

  %X = fpext float 3.1415 to double        ; yields double:3.1415
  %Y = fpext float 1.0 to float            ; yields float:1.0 (no-op)
'fptoui .. to' Instruction
構文:
  <result> = fptoui <ty> <value> to <ty2>             ; yields ty2
概要:

The 'fptoui' converts a floating point value to its unsigned integer equivalent of type ty2.

引数:

The 'fptoui' instruction takes a value to cast, which must be a scalar or vector floating point value, and a type to cast it to ty2, which must be an integer type. If ty is a vector floating point type, ty2 must be a vector integer type with the same number of elements as ty

意味:

The 'fptoui' instruction converts its floating point operand into the nearest (rounding towards zero) unsigned integer value. If the value cannot fit in ty2, the results are undefined.

  %X = fptoui double 123.0 to i32      ; yields i32:123
  %Y = fptoui float 1.0E+300 to i1     ; yields undefined:1
  %X = fptoui float 1.04E+17 to i8     ; yields undefined:1
'fptosi .. to' Instruction
構文:
  <result> = fptosi <ty> <value> to <ty2>             ; yields ty2
概要:

The 'fptosi' instruction converts floating point value to type ty2.

引数:

The 'fptosi' instruction takes a value to cast, which must be a scalar or vector floating point value, and a type to cast it to ty2, which must be an integer type. If ty is a vector floating point type, ty2 must be a vector integer type with the same number of elements as ty

意味:

The 'fptosi' instruction converts its floating point operand into the nearest (rounding towards zero) signed integer value. If the value cannot fit in ty2, the results are undefined.

  %X = fptosi double -123.0 to i32      ; yields i32:-123
  %Y = fptosi float 1.0E-247 to i1      ; yields undefined:1
  %X = fptosi float 1.04E+17 to i8      ; yields undefined:1
'uitofp .. to' Instruction
構文:
  <result> = uitofp <ty> <value> to <ty2>             ; yields ty2
概要:

The 'uitofp' instruction regards value as an unsigned integer and converts that value to the ty2 type.

引数:

The 'uitofp' instruction takes a value to cast, which must be a scalar or vector integer value, and a type to cast it to ty2, which must be an floating point type. If ty is a vector integer type, ty2 must be a vector floating point type with the same number of elements as ty

意味:

The 'uitofp' instruction interprets its operand as an unsigned integer quantity and converts it to the corresponding floating point value. If the value cannot fit in the floating point value, the results are undefined.

  %X = uitofp i32 257 to float         ; yields float:257.0
  %Y = uitofp i8 -1 to double          ; yields double:255.0
'sitofp .. to' Instruction
構文:
  <result> = sitofp <ty> <value> to <ty2>             ; yields ty2
概要:

The 'sitofp' instruction regards value as a signed integer and converts that value to the ty2 type.

引数:

The 'sitofp' instruction takes a value to cast, which must be a scalar or vector integer value, and a type to cast it to ty2, which must be an floating point type. If ty is a vector integer type, ty2 must be a vector floating point type with the same number of elements as ty

意味:

The 'sitofp' instruction interprets its operand as a signed integer quantity and converts it to the corresponding floating point value. If the value cannot fit in the floating point value, the results are undefined.

  %X = sitofp i32 257 to float         ; yields float:257.0
  %Y = sitofp i8 -1 to double          ; yields double:-1.0
'ptrtoint .. to' Instruction
構文:
  <result> = ptrtoint <ty> <value> to <ty2>             ; yields ty2
概要:

The 'ptrtoint' instruction converts the pointer value to the integer type ty2.

引数:

The 'ptrtoint' instruction takes a value to cast, which must be a pointer value, and a type to cast it to ty2, which must be an integer type.

意味:

The 'ptrtoint' instruction converts value to integer type ty2 by interpreting the pointer value as an integer and either truncating or zero extending that value to the size of the integer type. If value is smaller than ty2 then a zero extension is done. If value is larger than ty2 then a truncation is done. If they are the same size, then nothing is done (no-op cast) other than a type change.

  %X = ptrtoint i32* %X to i8           ; yields truncation on 32-bit architecture
  %Y = ptrtoint i32* %x to i64          ; yields zero extension on 32-bit architecture
'inttoptr .. to' Instruction
構文:
  <result> = inttoptr <ty> <value> to <ty2>             ; yields ty2
概要:

The 'inttoptr' instruction converts an integer value to a pointer type, ty2.

引数:

The 'inttoptr' instruction takes an integer value to cast, and a type to cast it to, which must be a pointer type.

意味:

The 'inttoptr' instruction converts value to type ty2 by applying either a zero extension or a truncation depending on the size of the integer value. If value is larger than the size of a pointer then a truncation is done. If value is smaller than the size of a pointer then a zero extension is done. If they are the same size, nothing is done (no-op cast).

  %X = inttoptr i32 255 to i32*          ; yields zero extension on 64-bit architecture
  %X = inttoptr i32 255 to i32*          ; yields no-op on 32-bit architecture
  %Y = inttoptr i64 0 to i32*            ; yields truncation on 32-bit architecture
'bitcast .. to' Instruction
構文:
  <result> = bitcast <ty> <value> to <ty2>             ; yields ty2
概要:

The 'bitcast' instruction converts value to type ty2 without changing any bits.

引数:

The 'bitcast' instruction takes a value to cast, which must be a non-aggregate first class value, and a type to cast it to, which must also be a non-aggregate first class type. The bit sizes of value and the destination type, ty2, must be identical. If the source type is a pointer, the destination type must also be a pointer. This instruction supports bitwise conversion of vectors to integers and to vectors of other types (as long as they have the same size).

意味:

The 'bitcast' instruction converts value to type ty2. It is always a no-op cast because no bits change with this conversion. The conversion is done as if the value had been stored to memory and read back as type ty2. Pointer types may only be converted to other pointer types with this instruction. To convert pointers to other types, use the inttoptr or ptrtoint instructions first.

  %X = bitcast i8 255 to i8              ; yields i8 :-1
  %Y = bitcast i32* %x to sint*          ; yields sint*:%x
  %Z = bitcast <2 x int> %V to i64;      ; yields i64: %V   
その他の演算子(Other Operations)

この分類の命令は、よりよい分類が難しい"雑多な"命令です。

整数比較(icmp)命令
構文:
  <result> = icmp <cond> <ty> <op1>, <op2>   ; yields {i1} or {<N x i1>}:result
概要:

icmp命令は、真偽値、または比較する二つの整数/整数ベクタ/ポインタ引数の真偽値のベクタを返します。

引数:

icmp命令は3つの引数を取ります。最初の引数は実行する比較の種類を示す条件コードです。 これは値ではなく予約語です。可能な条件コードは以下です。

  1. eq: 等価(equal)
  2. ne: 不等価(not equal)
  3. ugt: 符号無大なり(unsigned greater than)
  4. uge: 符号無以上(unsigned greater or equal)
  5. ult: 符号無未満(unsigned less than)
  6. ule: 符号無以下(unsigned less or equal)
  7. sgt: 符号付大なり(signed greater than)
  8. sge: 符号付以上(signed greater or equal)
  9. slt: 符号付未満(signed less than)
  10. sle: 符号付以下(signed less or equal)

残った2つの引数は、整数またはポインタまたは 整数ベクタ型でなければなりません。 それらはまた識別できる型(identical types)でなければなりません。

意味:

icmpop1op2condとして与えられる条件コードに従って比較します。 この比較は常に、以下のようにi1またはi1結果のベクタを生じるように行われます。

  1. eq: 引数が等しいならばtrueを生じます。さもなければfalseです。 符号の解釈は不要で、実施されません。
  2. ne: 引数が等しくなければtrueを生じます。さもなければfalseです。 符号の解釈は不要で、実施されません。
  3. ugt: 引数を符号無値と解釈し、もしop1op2より大きければtrueを生じます。
  4. uge: 引数を符号無値と解釈し、もしop1op2以上ならばtrueを生じます。
  5. ult: 引数を符号無値と解釈し、もしop1op2未満ならばtrueを生じます。
  6. ule: 引数を符号無値と解釈し、もしop1op2以下ならばtrueを生じます。
  7. sgt: 引数を符号付値と解釈し、もしop1op2より大きければtrueを生じます。
  8. sge: 引数を符号付値と解釈し、もしop1op2以上ならばtrueを生じます。
  9. slt: 引数を符号付値と解釈し、もしop1op2未満ならばtrueを生じます。
  10. sle: 引数を符号付値と解釈し、もしop1op2以下ならばtrueを生じます。

もし引数がポインタ型ならば、そのポインタは整数であるとして比較されます。

もし引数が整数ベクタならば、各要素同士が比較されます。結果は比較した値と同一な要素数のi1ベクタになります。 そうでない場合、結果は単一のi1です。

  <result> = icmp eq i32 4, 5          ; yields: result=false
  <result> = icmp ne float* %X, %X     ; yields: result=false
  <result> = icmp ult i16  4, 5        ; yields: result=true
  <result> = icmp sgt i16  4, 5        ; yields: result=false
  <result> = icmp ule i16 -4, 5        ; yields: result=false
  <result> = icmp sge i16  4, 5        ; yields: result=false

コード生成部がicmp命令のベクタ型に依然対応していないことに注意してください。

浮動小数比較(fcmp)命令
構文:
  <result> = fcmp <cond> <ty> <op1>, <op2>     ; yields {i1} or {<N x i1>}:result
概要:

fcmp命令は、真偽値、または比較する引数の真偽値のベクタを返します。

もし引数が浮動小数のスカラであれば、結果の型は真偽値(oolean) (i1)です。

もし引数が浮動小数のベクタであれば、結果の型は比較する引数の要素数と同数の要素を持つ真偽値のベクタです。

引数:

fcmp命令は3つの引数を取ります。最初の引数は実行する比較の種類を示す条件コードです。 これは値ではなく予約語です。可能な条件コードは以下です。

  1. false: 比較無しで、常にfalseを返す
  2. oeq: 比較可能で、等しい
  3. ogt: 比較可能で、大なり
  4. oge: 比較可能で、以上
  5. olt: 比較可能で、未満
  6. ole: 比較可能で、以下
  7. one: 比較可能で、等しくない
  8. ord: 比較可能(nanではない)
  9. ueq: 比較不能か、等しい
  10. ugt: 比較不能か、大なり
  11. uge: 比較不能か、以上
  12. ult: 比較不能か、未満
  13. ule: 比較不能か、以下
  14. une: 比較不能か、等しくない
  15. uno: 比較不能(もしくはnans)
  16. true: 比較無しで、常にtrueを返す

比較可能(Ordered)の引数がQNANでなく、一方比較不能(unordered)は引数がQNANでもよい。

val1val2のいずれの引数も、浮動小数型か 浮動小数型のベクタのいずれかでなければなりません。 それらはまた識別できる型(identical types)でなければなりません。

意味:

The 'fcmp' instruction compares op1 and op2 according to the condition code given as cond. If the operands are vectors, then the vectors are compared element by element. Each comparison performed always yields an i1 result, as follows:

  1. false: 引数によらず、常にfalseを生じます。
  2. oeq: 両引数がQNANでなくop1op2と等しいならば、trueを生じます。
  3. ogt: 両引数がQNANでなくop1op2より大きければ、trueを生じます。
  4. oge: 両引数がQNANでなくop1op2以上ならば、trueを生じます。
  5. olt: 両引数がQNANでなくop1op2未満ならば、trueを生じます。
  6. ole: 両引数がQNANでなくop1op2以下ならば、trueを生じます。
  7. one: 両引数がQNANでなくop1op2と等しくないならば、trueを生じます。
  8. ord: 両引数がQNANでないならば、trueを生じます。
  9. ueq: 両引数がQNANであるか、op1op2と等しいならば、trueを生じます。
  10. ugt: 両引数がQNANであるか、op1op2より大きければ、trueを生じます。
  11. uge: 両引数がQNANであるか、op1op2以上ならば、trueを生じます。
  12. ult: 両引数がQNANであるか、op1op2未満ならば、trueを生じます。
  13. ule: 両引数がQNANであるか、op1op2以下ならば、trueを生じます。
  14. une: 両引数がQNANであるか、op1op2と等しくないならば、trueを生じます。
  15. uno: 両引数がQNANならば、trueを生じます。
  16. true: 引数によらず、常にtrueを生じます。
  <result> = fcmp oeq float 4.0, 5.0    ; yields: result=false
  <result> = fcmp one float 4.0, 5.0    ; yields: result=true
  <result> = fcmp olt float 4.0, 5.0    ; yields: result=true
  <result> = fcmp ueq double 1.0, 2.0   ; yields: result=false

コード生成部がfcmp命令のベクタ型に依然対応していないことに注意してください。

phi(phi)命令
構文:
  <result> = phi <ty> [ <val0>, <label0>], ...
概要:

phi命令は関数を表すSSAグラフのφノードを実装するために使用します。

引数:

入力値の型は最初の型フィールドで規定されます。 その後、phi命令は引数として複数ペアのリストを取ります。 一つのペアは現在のブロックの前の基底ブロックです。 first class型の値だけが、このPHIノードの値引数として使用されるでしょう。 ラベルだけがラベル引数に使用されるでしょう。

基底ブロックの始点とPHI命令の間は「非phi」ではない命令が必要です。 つまり、PHI命令は基底ブロックの最初に無ければなりません。

SSA形成の目的上、(同じエッジ上であらゆるinvoke命令の戻り値の定義後) 各入力値の使用は対応する前ブロックから現在のブロックまでエッジ(edge)に生じるとみなされました。

意味:

実行時に、phi命令は logically takes on the value specified by the pair corresponding to the predecessor basic block that executed just prior to the current block.

Loop:       ; Infinite loop that counts from 0 on up...
  %indvar = phi i32 [ 0, %LoopHeader ], [ %nextindvar, %Loop ]
  %nextindvar = add i32 %indvar, 1
  br label %Loop
'select' Instruction
構文:
  <result> = select selty <cond>, <ty> <val1>, <ty> <val2>             ; yields ty

  selty is either i1 or {<N x i1>}
概要:

The 'select' instruction is used to choose one value based on a condition, without branching.

引数:

The 'select' instruction requires an 'i1' value or a vector of 'i1' values indicating the condition, and two values of the same first class type. If the val1/val2 are vectors and the condition is a scalar, then entire vectors are selected, not individual elements.

意味:

If the condition is an i1 and it evaluates to 1, the instruction returns the first value argument; otherwise, it returns the second value argument.

If the condition is a vector of i1, then the value arguments must be vectors of the same size, and the selection is done element by element.

  %X = select i1 true, i8 17, i8 42          ; yields i8:17

Note that the code generator does not yet support conditions with vector type.

'call' Instruction
構文:
  <result> = [tail] call [cconv] [ret attrs] <ty> [<fnty>*] <fnptrval>(<function args>) [fn attrs]
概要:

call命令は単純な関数呼び出しを表します。

引数:

この命令にはいくつかの引数が必要です。:

  1. 任意の"tail"マーカは marker indicates whether the callee function accesses any allocas or varargs in the caller. If the "tail" marker is present, the function call is eligible for tail call optimization. Note that calls may be marked "tail" even if they do not occur before a ret instruction.

  2. 任意の"cconv"マーカは、calling convention呼出の使用を示します。 もし定義がない場合、この呼出はデフォルトでC呼出変換を使用します。

  3. The optional Parameter Attributes list for return values. Only 'zeroext', 'signext', and 'inreg' attributes are valid here.

  4. 'ty': the type of the call instruction itself which is also the type of the return value. Functions that return no value are marked void.

  5. 'fnty': shall be the signature of the pointer to function value being invoked. The argument types must match the types implied by this signature. This type can be omitted if the function is not varargs and if the function type does not return a pointer to a function.

  6. 'fnptrval': An LLVM value containing a pointer to a function to be invoked. In most cases, this is a direct function invocation, but indirect calls are just as possible, calling an arbitrary pointer to function value.

  7. 'function args': argument list whose types match the function signature argument types. All arguments must be of first class type. If the function signature indicates the function accepts a variable number of arguments, the extra arguments can be specified.

  8. The optional function attributes list. Only 'noreturn', 'nounwind', 'readonly' and 'readnone' attributes are valid here.

意味:

The 'call' instruction is used to cause control flow to transfer to a specified function, with its incoming arguments bound to the specified values. Upon a 'ret' instruction in the called function, control flow continues with the instruction after the function call, and the return value of the function is bound to the result argument.

  %retval = call i32 @test(i32 %argc)
  call i32 (i8 *, ...)* @printf(i8 * %msg, i32 12, i8 42)      ; yields i32
  %X = tail call i32 @foo()                                    ; yields i32
  %Y = tail call fastcc i32 @foo()  ; yields i32
  call void %foo(i8 97 signext)

  %struct.A = type { i32, i8 }
  %r = call %struct.A @foo()                        ; yields { 32, i8 }
  %gr = extractvalue %struct.A %r, 0                ; yields i32
  %gr1 = extractvalue %struct.A %r, 1               ; yields i8
  %Z = call void @foo() noreturn                    ; indicates that %foo never returns normally
  %ZZ = call zeroext i32 @bar()                     ; Return value is %zero extended
'va_arg' Instruction
構文:
  <resultval> = va_arg <va_list*> <arglist>, <argty>
概要:

The 'va_arg' instruction is used to access arguments passed through the "variable argument" area of a function call. It is used to implement the va_arg macro in C.

引数:

This instruction takes a va_list* value and the type of the argument. It returns a value of the specified argument type and increments the va_list to point to the next argument. The actual type of va_list is target specific.

意味:

The 'va_arg' instruction loads an argument of the specified type from the specified va_list and causes the va_list to point to the next argument. For more information, see the variable argument handling Intrinsic Functions.

It is legal for this instruction to be called in a function which does not take a variable number of arguments, for example, the vfprintf function.

va_arg is an LLVM instruction instead of an intrinsic function because it takes a type as an argument.

See the variable argument processing section.

Note that the code generator does not yet fully support va_arg on many targets. Also, it does not currently support va_arg with aggregate types on any target.

組込処理(Intrinsic Functions)

LLVM supports the notion of an "intrinsic function". These functions have well known names and semantics and are required to follow certain restrictions. Overall, these intrinsics represent an extension mechanism for the LLVM language that does not require changing all of the transformations in LLVM when adding to the language (or the bitcode reader/writer, the parser, etc...).

Intrinsic function names must all start with an "llvm." prefix. This prefix is reserved in LLVM for intrinsic names; thus, function names may not begin with this prefix. Intrinsic functions must always be external functions: you cannot define the body of intrinsic functions. Intrinsic functions may only be used in call or invoke instructions: it is illegal to take the address of an intrinsic function. Additionally, because intrinsic functions are part of the LLVM language, it is required if any are added that they be documented here.

Some intrinsic functions can be overloaded, i.e., the intrinsic represents a family of functions that perform the same operation but on different data types. Because LLVM can represent over 8 million different integer types, overloading is used commonly to allow an intrinsic function to operate on any integer type. One or more of the argument types or the result type can be overloaded to accept any integer type. Argument types may also be defined as exactly matching a previous argument's type or the result type. This allows an intrinsic function which accepts multiple arguments, but needs all of them to be of the same type, to only be overloaded with respect to a single argument or the result.

Overloaded intrinsics will have the names of its overloaded argument types encoded into its function name, each preceded by a period. Only those types which are overloaded result in a name suffix. Arguments whose type is matched against another type do not. For example, the llvm.ctpop function can take an integer of any width and returns an integer of exactly the same integer width. This leads to a family of functions such as i8 @llvm.ctpop.i8(i8 %val) and i29 @llvm.ctpop.i29(i29 %val). Only one type, the return type, is overloaded, and only one type suffix is required. Because the argument's type is matched against the return type, it does not require its own name suffix.

To learn how to add an intrinsic function, please see the Extending LLVM Guide.

Variable Argument Handling Intrinsics

Variable argument support is defined in LLVM with the va_arg instruction and these three intrinsic functions. These functions are related to the similarly named macros defined in the <stdarg.h> header file.

All of these functions operate on arguments that use a target-specific value type "va_list". The LLVM assembly language reference manual does not define what this type is, so all transformations should be prepared to handle these functions regardless of the type used.

This example shows how the va_arg instruction and the variable argument handling intrinsic functions are used.

define i32 @test(i32 %X, ...) {
  ; Initialize variable argument processing
  %ap = alloca i8*
  %ap2 = bitcast i8** %ap to i8*
  call void @llvm.va_start(i8* %ap2)

  ; Read a single integer argument
  %tmp = va_arg i8** %ap, i32

  ; Demonstrate usage of llvm.va_copy and llvm.va_end
  %aq = alloca i8*
  %aq2 = bitcast i8** %aq to i8*
  call void @llvm.va_copy(i8* %aq2, i8* %ap2)
  call void @llvm.va_end(i8* %aq2)

  ; Stop processing of arguments.
  call void @llvm.va_end(i8* %ap2)
  ret i32 %tmp
}

declare void @llvm.va_start(i8*)
declare void @llvm.va_copy(i8*, i8*)
declare void @llvm.va_end(i8*)
'llvm.va_start' Intrinsic
構文:
  declare void %llvm.va_start(i8* <arglist>)
概要:

The 'llvm.va_start' intrinsic initializes *<arglist> for subsequent use by va_arg.

引数:

The argument is a pointer to a va_list element to initialize.

意味:

The 'llvm.va_start' intrinsic works just like the va_start macro available in C. In a target-dependent way, it initializes the va_list element to which the argument points, so that the next call to va_arg will produce the first variable argument passed to the function. Unlike the C va_start macro, this intrinsic does not need to know the last argument of the function as the compiler can figure that out.

'llvm.va_end' Intrinsic
構文:
  declare void @llvm.va_end(i8* <arglist>)
概要:

The 'llvm.va_end' intrinsic destroys *<arglist>, which has been initialized previously with llvm.va_start or llvm.va_copy.

引数:

The argument is a pointer to a va_list to destroy.

意味:

The 'llvm.va_end' intrinsic works just like the va_end macro available in C. In a target-dependent way, it destroys the va_list element to which the argument points. Calls to llvm.va_start and llvm.va_copy must be matched exactly with calls to llvm.va_end.

'llvm.va_copy' Intrinsic
構文:
  declare void @llvm.va_copy(i8* <destarglist>, i8* <srcarglist>)
概要:

The 'llvm.va_copy' intrinsic copies the current argument position from the source argument list to the destination argument list.

引数:

The first argument is a pointer to a va_list element to initialize. The second argument is a pointer to a va_list element to copy from.

意味:

The 'llvm.va_copy' intrinsic works just like the va_copy macro available in C. In a target-dependent way, it copies the source va_list element into the destination va_list element. This intrinsic is necessary because the llvm.va_start intrinsic may be arbitrarily complex and require, for example, memory allocation.

Accurate Garbage Collection Intrinsics

LLVM support for Accurate Garbage Collection (GC) requires the implementation and generation of these intrinsics. These intrinsics allow identification of GC roots on the stack, as well as garbage collector implementations that require read and write barriers. Front-ends for type-safe garbage collected languages should generate these intrinsics to make use of the LLVM garbage collectors. For more details, see Accurate Garbage Collection with LLVM.

The garbage collection intrinsics only operate on objects in the generic address space (address space zero).

'llvm.gcroot' Intrinsic
構文:
  declare void @llvm.gcroot(i8** %ptrloc, i8* %metadata)
概要:

The 'llvm.gcroot' intrinsic declares the existence of a GC root to the code generator, and allows some metadata to be associated with it.

引数:

The first argument specifies the address of a stack object that contains the root pointer. The second pointer (which must be either a constant or a global value address) contains the meta-data to be associated with the root.

意味:

At runtime, a call to this intrinsic stores a null pointer into the "ptrloc" location. At compile-time, the code generator generates information to allow the runtime to find the pointer at GC safe points. The 'llvm.gcroot' intrinsic may only be used in a function which specifies a GC algorithm.

'llvm.gcread' Intrinsic
構文:
  declare i8* @llvm.gcread(i8* %ObjPtr, i8** %Ptr)
概要:

The 'llvm.gcread' intrinsic identifies reads of references from heap locations, allowing garbage collector implementations that require read barriers.

引数:

The second argument is the address to read from, which should be an address allocated from the garbage collector. The first object is a pointer to the start of the referenced object, if needed by the language runtime (otherwise null).

意味:

The 'llvm.gcread' intrinsic has the same semantics as a load instruction, but may be replaced with substantially more complex code by the garbage collector runtime, as needed. The 'llvm.gcread' intrinsic may only be used in a function which specifies a GC algorithm.

'llvm.gcwrite' Intrinsic
構文:
  declare void @llvm.gcwrite(i8* %P1, i8* %Obj, i8** %P2)
概要:

The 'llvm.gcwrite' intrinsic identifies writes of references to heap locations, allowing garbage collector implementations that require write barriers (such as generational or reference counting collectors).

引数:

The first argument is the reference to store, the second is the start of the object to store it to, and the third is the address of the field of Obj to store to. If the runtime does not require a pointer to the object, Obj may be null.

意味:

The 'llvm.gcwrite' intrinsic has the same semantics as a store instruction, but may be replaced with substantially more complex code by the garbage collector runtime, as needed. The 'llvm.gcwrite' intrinsic may only be used in a function which specifies a GC algorithm.

Code Generator Intrinsics

These intrinsics are provided by LLVM to expose special features that may only be implemented with code generator support.

'llvm.returnaddress' Intrinsic
構文:
  declare i8  *@llvm.returnaddress(i32 <level>)
概要:

The 'llvm.returnaddress' intrinsic attempts to compute a target-specific value indicating the return address of the current function or one of its callers.

引数:

The argument to this intrinsic indicates which function to return the address for. Zero indicates the calling function, one indicates its caller, etc. The argument is required to be a constant integer value.

意味:

The 'llvm.returnaddress' intrinsic either returns a pointer indicating the return address of the specified call frame, or zero if it cannot be identified. The value returned by this intrinsic is likely to be incorrect or 0 for arguments other than zero, so it should only be used for debugging purposes.

Note that calling this intrinsic does not prevent function inlining or other aggressive transformations, so the value returned may not be that of the obvious source-language caller.

'llvm.frameaddress' Intrinsic
構文:
  declare i8 *@llvm.frameaddress(i32 <level>)
概要:

The 'llvm.frameaddress' intrinsic attempts to return the target-specific frame pointer value for the specified stack frame.

引数:

The argument to this intrinsic indicates which function to return the frame pointer for. Zero indicates the calling function, one indicates its caller, etc. The argument is required to be a constant integer value.

意味:

The 'llvm.frameaddress' intrinsic either returns a pointer indicating the frame address of the specified call frame, or zero if it cannot be identified. The value returned by this intrinsic is likely to be incorrect or 0 for arguments other than zero, so it should only be used for debugging purposes.

Note that calling this intrinsic does not prevent function inlining or other aggressive transformations, so the value returned may not be that of the obvious source-language caller.

スタック保存(llvm.stacksave)組込処理
構文:
  declare i8 *@llvm.stacksave()
概要:

llvm.stacksave組込処理は、スタック復元(llvm.stackrestore)と共に、 関数スタックの現在状態を記憶するために使用します。 これはC99の自動可変サイズ配列などの言語機能を実装する際に有用です。

意味:

この組込処理は、llvm.stackrestoreに渡すことができる、 奇妙なポインタ値を返します。 llvm.stacksaveが保存した値でllvm.stackrestore組込命令を実行すると、 llvm.stacksave組込命令を実行した時の状態に効率よくスタックの状態を復元することが出来ます。 実例として、llvm.stacksave実行後にallocaがメモリから割り当てたあらゆるブロックをポップできます。

スタック復元(llvm.stackrestore)組込処理
構文:
  declare void @llvm.stackrestore(i8 * %ptr)
概要:

llvm.stackrestore組込処理はllvm.stacksave 組込処理を実行した際の状態に関数スタックの状態を復元するために使用します。 これはC99の自動可変サイズ配列などの言語機能を実装する際に有用です。

意味:

llvm.stacksaveの説明を参照してください。

'llvm.prefetch' Intrinsic
構文:
  declare void @llvm.prefetch(i8* <address>, i32 <rw>, i32 <locality>)
概要:

The 'llvm.prefetch' intrinsic is a hint to the code generator to insert a prefetch instruction if supported; otherwise, it is a noop. Prefetches have no effect on the behavior of the program but can change its performance characteristics.

引数:

address is the address to be prefetched, rw is the specifier determining if the fetch should be for a read (0) or write (1), and locality is a temporal locality specifier ranging from (0) - no locality, to (3) - extremely local keep in cache. The rw and locality arguments must be constant integers.

意味:

This intrinsic does not modify the behavior of the program. In particular, prefetches cannot trap and do not produce a value. On targets that support this intrinsic, the prefetch can provide hints to the processor cache for better performance.

'llvm.pcmarker' Intrinsic
構文:
  declare void @llvm.pcmarker(i32 <id>)
概要:

The 'llvm.pcmarker' intrinsic is a method to export a Program Counter (PC) in a region of code to simulators and other tools. The method is target specific, but it is expected that the marker will use exported symbols to transmit the PC of the marker. The marker makes no guarantees that it will remain with any specific instruction after optimizations. It is possible that the presence of a marker will inhibit optimizations. The intended use is to be inserted after optimizations to allow correlations of simulation runs.

引数:

id is a numerical id identifying the marker.

意味:

This intrinsic does not modify the behavior of the program. Backends that do not support this intrinisic may ignore it.

'llvm.readcyclecounter' Intrinsic
構文:
  declare i64 @llvm.readcyclecounter( )
概要:

The 'llvm.readcyclecounter' intrinsic provides access to the cycle counter register (or similar low latency, high accuracy clocks) on those targets that support it. On X86, it should map to RDTSC. On Alpha, it should map to RPCC. As the backing counters overflow quickly (on the order of 9 seconds on alpha), this should only be used for small timings.

意味:

When directly supported, reading the cycle counter should not modify any memory. Implementations are allowed to either return a application specific value or a system wide value. On backends without support, this is lowered to a constant 0.

Standard C Library Intrinsics

LLVM provides intrinsics for a few important standard C library functions. These intrinsics allow source-language front-ends to pass information about the alignment of the pointer arguments to the code generator, providing opportunity for more efficient code generation.

'llvm.memcpy' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.memcpyはあらゆる整数ビット幅に対して使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

  declare void @llvm.memcpy.i8(i8 * <dest>, i8 * <src>,
                                i8 <len>, i32 <align>)
  declare void @llvm.memcpy.i16(i8 * <dest>, i8 * <src>,
                                i16 <len>, i32 <align>)
  declare void @llvm.memcpy.i32(i8 * <dest>, i8 * <src>,
                                i32 <len>, i32 <align>)
  declare void @llvm.memcpy.i64(i8 * <dest>, i8 * <src>,
                                i64 <len>, i32 <align>)
概要:

The 'llvm.memcpy.*' intrinsics copy a block of memory from the source location to the destination location.

Note that, unlike the standard libc function, the llvm.memcpy.* intrinsics do not return a value, and takes an extra alignment argument.

引数:

The first argument is a pointer to the destination, the second is a pointer to the source. The third argument is an integer argument specifying the number of bytes to copy, and the fourth argument is the alignment of the source and destination locations.

If the call to this intrinisic has an alignment value that is not 0 or 1, then the caller guarantees that both the source and destination pointers are aligned to that boundary.

意味:

The 'llvm.memcpy.*' intrinsics copy a block of memory from the source location to the destination location, which are not allowed to overlap. It copies "len" bytes of memory over. If the argument is known to be aligned to some boundary, this can be specified as the fourth argument, otherwise it should be set to 0 or 1.

'llvm.memmove' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.memmoveはあらゆる整数ビット幅に対して使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

  declare void @llvm.memmove.i8(i8 * <dest>, i8 * <src>,
                                 i8 <len>, i32 <align>)
  declare void @llvm.memmove.i16(i8 * <dest>, i8 * <src>,
                                 i16 <len>, i32 <align>)
  declare void @llvm.memmove.i32(i8 * <dest>, i8 * <src>,
                                 i32 <len>, i32 <align>)
  declare void @llvm.memmove.i64(i8 * <dest>, i8 * <src>,
                                 i64 <len>, i32 <align>)
概要:

The 'llvm.memmove.*' intrinsics move a block of memory from the source location to the destination location. It is similar to the 'llvm.memcpy' intrinsic but allows the two memory locations to overlap.

Note that, unlike the standard libc function, the llvm.memmove.* intrinsics do not return a value, and takes an extra alignment argument.

引数:

The first argument is a pointer to the destination, the second is a pointer to the source. The third argument is an integer argument specifying the number of bytes to copy, and the fourth argument is the alignment of the source and destination locations.

If the call to this intrinisic has an alignment value that is not 0 or 1, then the caller guarantees that the source and destination pointers are aligned to that boundary.

意味:

The 'llvm.memmove.*' intrinsics copy a block of memory from the source location to the destination location, which may overlap. It copies "len" bytes of memory over. If the argument is known to be aligned to some boundary, this can be specified as the fourth argument, otherwise it should be set to 0 or 1.

'llvm.memset.*' Intrinsics
構文:

これはオーバーロードされた組込処理です。llvm.memsetはあらゆる整数ビット幅に対して使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

  declare void @llvm.memset.i8(i8 * <dest>, i8 <val>,
                                i8 <len>, i32 <align>)
  declare void @llvm.memset.i16(i8 * <dest>, i8 <val>,
                                i16 <len>, i32 <align>)
  declare void @llvm.memset.i32(i8 * <dest>, i8 <val>,
                                i32 <len>, i32 <align>)
  declare void @llvm.memset.i64(i8 * <dest>, i8 <val>,
                                i64 <len>, i32 <align>)
概要:

The 'llvm.memset.*' intrinsics fill a block of memory with a particular byte value.

Note that, unlike the standard libc function, the llvm.memset intrinsic does not return a value, and takes an extra alignment argument.

引数:

The first argument is a pointer to the destination to fill, the second is the byte value to fill it with, the third argument is an integer argument specifying the number of bytes to fill, and the fourth argument is the known alignment of destination location.

If the call to this intrinisic has an alignment value that is not 0 or 1, then the caller guarantees that the destination pointer is aligned to that boundary.

意味:

The 'llvm.memset.*' intrinsics fill "len" bytes of memory starting at the destination location. If the argument is known to be aligned to some boundary, this can be specified as the fourth argument, otherwise it should be set to 0 or 1.

'llvm.sqrt.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.sqrtは任意の浮動小数または浮動小数のベクタ型に対して使用可能です。 しかしながら、全ての対象があらゆる型をサポートするとは限りません。

  declare float     @llvm.sqrt.f32(float %Val)
  declare double    @llvm.sqrt.f64(double %Val)
  declare x86_fp80  @llvm.sqrt.f80(x86_fp80 %Val)
  declare fp128     @llvm.sqrt.f128(fp128 %Val)
  declare ppc_fp128 @llvm.sqrt.ppcf128(ppc_fp128 %Val)
概要:

The 'llvm.sqrt' intrinsics return the sqrt of the specified operand, returning the same value as the libm 'sqrt' functions would. Unlike sqrt in libm, however, llvm.sqrt has undefined behavior for negative numbers other than -0.0 (which allows for better optimization, because there is no need to worry about errno being set). llvm.sqrt(-0.0) is defined to return -0.0 like IEEE sqrt.

引数:

The argument and return value are floating point numbers of the same type.

意味:

This function returns the sqrt of the specified operand if it is a nonnegative floating point number.

'llvm.powi.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.powiは任意の浮動小数または浮動小数のベクタ型に対して使用可能です。 しかしながら、全ての対象があらゆる型をサポートするとは限りません。

  declare float     @llvm.powi.f32(float  %Val, i32 %power)
  declare double    @llvm.powi.f64(double %Val, i32 %power)
  declare x86_fp80  @llvm.powi.f80(x86_fp80  %Val, i32 %power)
  declare fp128     @llvm.powi.f128(fp128 %Val, i32 %power)
  declare ppc_fp128 @llvm.powi.ppcf128(ppc_fp128  %Val, i32 %power)
概要:

The 'llvm.powi.*' intrinsics return the first operand raised to the specified (positive or negative) power. The order of evaluation of multiplications is not defined. When a vector of floating point type is used, the second argument remains a scalar integer value.

引数:

The second argument is an integer power, and the first is a value to raise to that power.

意味:

This function returns the first value raised to the second power with an unspecified sequence of rounding operations.

'llvm.sin.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.sinは任意の浮動小数または浮動小数のベクタ型に対して使用可能です。 しかしながら、全ての対象があらゆる型をサポートするとは限りません。

  declare float     @llvm.sin.f32(float  %Val)
  declare double    @llvm.sin.f64(double %Val)
  declare x86_fp80  @llvm.sin.f80(x86_fp80  %Val)
  declare fp128     @llvm.sin.f128(fp128 %Val)
  declare ppc_fp128 @llvm.sin.ppcf128(ppc_fp128  %Val)
概要:

The 'llvm.sin.*' intrinsics return the sine of the operand.

引数:

The argument and return value are floating point numbers of the same type.

意味:

This function returns the sine of the specified operand, returning the same values as the libm sin functions would, and handles error conditions in the same way.

'llvm.cos.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.cosは任意の浮動小数または浮動小数のベクタ型に対して使用可能です。 しかしながら、全ての対象があらゆる型をサポートするとは限りません。

  declare float     @llvm.cos.f32(float  %Val)
  declare double    @llvm.cos.f64(double %Val)
  declare x86_fp80  @llvm.cos.f80(x86_fp80  %Val)
  declare fp128     @llvm.cos.f128(fp128 %Val)
  declare ppc_fp128 @llvm.cos.ppcf128(ppc_fp128  %Val)
概要:

The 'llvm.cos.*' intrinsics return the cosine of the operand.

引数:

The argument and return value are floating point numbers of the same type.

意味:

This function returns the cosine of the specified operand, returning the same values as the libm cos functions would, and handles error conditions in the same way.

'llvm.pow.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.powは任意の浮動小数または浮動小数のベクタ型に対して使用可能です。 しかしながら、全ての対象があらゆる型をサポートするとは限りません。

  declare float     @llvm.pow.f32(float  %Val, float %Power)
  declare double    @llvm.pow.f64(double %Val, double %Power)
  declare x86_fp80  @llvm.pow.f80(x86_fp80  %Val, x86_fp80 %Power)
  declare fp128     @llvm.pow.f128(fp128 %Val, fp128 %Power)
  declare ppc_fp128 @llvm.pow.ppcf128(ppc_fp128  %Val, ppc_fp128 Power)
概要:

The 'llvm.pow.*' intrinsics return the first operand raised to the specified (positive or negative) power.

引数:

The second argument is a floating point power, and the first is a value to raise to that power.

意味:

This function returns the first value raised to the second power, returning the same values as the libm pow functions would, and handles error conditions in the same way.

Bit Manipulation Intrinsics

LLVM provides intrinsics for a few important bit manipulation operations. These allow efficient code generation for some algorithms.

'llvm.bswap.*' Intrinsics
構文:

これはオーバーロードされた組込処理です。llvm.bswapは任意の偶数バイト長(すなわちBitWidth % 16 == 0)の整数型に対して使用可能です。

  declare i16 @llvm.bswap.i16(i16 <id>)
  declare i32 @llvm.bswap.i32(i32 <id>)
  declare i64 @llvm.bswap.i64(i64 <id>)
概要:

The 'llvm.bswap' family of intrinsics is used to byte swap integer values with an even number of bytes (positive multiple of 16 bits). These are useful for performing operations on data that is not in the target's native byte order.

意味:

The llvm.bswap.i16 intrinsic returns an i16 value that has the high and low byte of the input i16 swapped. Similarly, the llvm.bswap.i32 intrinsic returns an i32 value that has the four bytes of the input i32 swapped, so that if the input bytes are numbered 0, 1, 2, 3 then the returned i32 will have its bytes in 3, 2, 1, 0 order. The llvm.bswap.i48, llvm.bswap.i64 and other intrinsics extend this concept to additional even-byte lengths (6 bytes, 8 bytes and more, respectively).

'llvm.ctpop.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.ctpopは任意のビット幅の整数に対して使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

  declare i8 @llvm.ctpop.i8(i8  <src>)
  declare i16 @llvm.ctpop.i16(i16 <src>)
  declare i32 @llvm.ctpop.i32(i32 <src>)
  declare i64 @llvm.ctpop.i64(i64 <src>)
  declare i256 @llvm.ctpop.i256(i256 <src>)
概要:

The 'llvm.ctpop' family of intrinsics counts the number of bits set in a value.

引数:

The only argument is the value to be counted. The argument may be of any integer type. The return type must match the argument type.

意味:

The 'llvm.ctpop' intrinsic counts the 1's in a variable.

'llvm.ctlz.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.ctlzは任意のビット幅の整数に対して使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

  declare i8 @llvm.ctlz.i8 (i8  <src>)
  declare i16 @llvm.ctlz.i16(i16 <src>)
  declare i32 @llvm.ctlz.i32(i32 <src>)
  declare i64 @llvm.ctlz.i64(i64 <src>)
  declare i256 @llvm.ctlz.i256(i256 <src>)
概要:

The 'llvm.ctlz' family of intrinsic functions counts the number of leading zeros in a variable.

引数:

The only argument is the value to be counted. The argument may be of any integer type. The return type must match the argument type.

意味:

The 'llvm.ctlz' intrinsic counts the leading (most significant) zeros in a variable. If the src == 0 then the result is the size in bits of the type of src. For example, llvm.ctlz(i32 2) = 30.

'llvm.cttz.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。llvm.cttzは任意のビット幅の整数に対して使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

  declare i8 @llvm.cttz.i8 (i8  <src>)
  declare i16 @llvm.cttz.i16(i16 <src>)
  declare i32 @llvm.cttz.i32(i32 <src>)
  declare i64 @llvm.cttz.i64(i64 <src>)
  declare i256 @llvm.cttz.i256(i256 <src>)
概要:

The 'llvm.cttz' family of intrinsic functions counts the number of trailing zeros.

引数:

The only argument is the value to be counted. The argument may be of any integer type. The return type must match the argument type.

意味:

The 'llvm.cttz' intrinsic counts the trailing (least significant) zeros in a variable. If the src == 0 then the result is the size in bits of the type of src. For example, llvm.cttz(2) = 1.

Arithmetic with Overflow Intrinsics

LLVM provides intrinsics for some arithmetic with overflow operations.

'llvm.sadd.with.overflow.*' Intrinsics
構文:

これはオーバーロードされた組込処理です。llvm.sadd.with.overflowは任意のビット幅の整数に対して使用可能です。

  declare {i16, i1} @llvm.sadd.with.overflow.i16(i16 %a, i16 %b)
  declare {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 %b)
  declare {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 %b)
概要:

The 'llvm.sadd.with.overflow' family of intrinsic functions perform a signed addition of the two arguments, and indicate whether an overflow occurred during the signed summation.

引数:

The arguments (%a and %b) and the first element of the result structure may be of integer types of any bit width, but they must have the same bit width. The second element of the result structure must be of type i1. %a and %b are the two values that will undergo signed addition.

意味:

The 'llvm.sadd.with.overflow' family of intrinsic functions perform a signed addition of the two variables. They return a structure — the first element of which is the signed summation, and the second element of which is a bit specifying if the signed summation resulted in an overflow.

例:
  %res = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 %b)
  %sum = extractvalue {i32, i1} %res, 0
  %obit = extractvalue {i32, i1} %res, 1
  br i1 %obit, label %overflow, label %normal
'llvm.uadd.with.overflow.*' Intrinsics
構文:

これはオーバーロードされた組込処理です。llvm.uadd.with.overflowは任意のビット幅の整数に対して使用可能です。

  declare {i16, i1} @llvm.uadd.with.overflow.i16(i16 %a, i16 %b)
  declare {i32, i1} @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
  declare {i64, i1} @llvm.uadd.with.overflow.i64(i64 %a, i64 %b)
概要:

The 'llvm.uadd.with.overflow' family of intrinsic functions perform an unsigned addition of the two arguments, and indicate whether a carry occurred during the unsigned summation.

引数:

The arguments (%a and %b) and the first element of the result structure may be of integer types of any bit width, but they must have the same bit width. The second element of the result structure must be of type i1. %a and %b are the two values that will undergo unsigned addition.

意味:

The 'llvm.uadd.with.overflow' family of intrinsic functions perform an unsigned addition of the two arguments. They return a structure — the first element of which is the sum, and the second element of which is a bit specifying if the unsigned summation resulted in a carry.

例:
  %res = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
  %sum = extractvalue {i32, i1} %res, 0
  %obit = extractvalue {i32, i1} %res, 1
  br i1 %obit, label %carry, label %normal
'llvm.ssub.with.overflow.*' Intrinsics
構文:

これはオーバーロードされた組込処理です。llvm.ssub.with.overflowは任意のビット幅の整数に対して使用可能です。

  declare {i16, i1} @llvm.ssub.with.overflow.i16(i16 %a, i16 %b)
  declare {i32, i1} @llvm.ssub.with.overflow.i32(i32 %a, i32 %b)
  declare {i64, i1} @llvm.ssub.with.overflow.i64(i64 %a, i64 %b)
概要:

The 'llvm.ssub.with.overflow' family of intrinsic functions perform a signed subtraction of the two arguments, and indicate whether an overflow occurred during the signed subtraction.

引数:

The arguments (%a and %b) and the first element of the result structure may be of integer types of any bit width, but they must have the same bit width. The second element of the result structure must be of type i1. %a and %b are the two values that will undergo signed subtraction.

意味:

The 'llvm.ssub.with.overflow' family of intrinsic functions perform a signed subtraction of the two arguments. They return a structure — the first element of which is the subtraction, and the second element of which is a bit specifying if the signed subtraction resulted in an overflow.

例:
  %res = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %a, i32 %b)
  %sum = extractvalue {i32, i1} %res, 0
  %obit = extractvalue {i32, i1} %res, 1
  br i1 %obit, label %overflow, label %normal
'llvm.usub.with.overflow.*' Intrinsics
構文:

これはオーバーロードされた組込処理です。llvm.uadd.with.overflowは任意のビット幅の整数に対して使用可能です。

  declare {i16, i1} @llvm.usub.with.overflow.i16(i16 %a, i16 %b)
  declare {i32, i1} @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
  declare {i64, i1} @llvm.usub.with.overflow.i64(i64 %a, i64 %b)
概要:

The 'llvm.usub.with.overflow' family of intrinsic functions perform an unsigned subtraction of the two arguments, and indicate whether an overflow occurred during the unsigned subtraction.

引数:

The arguments (%a and %b) and the first element of the result structure may be of integer types of any bit width, but they must have the same bit width. The second element of the result structure must be of type i1. %a and %b are the two values that will undergo unsigned subtraction.

意味:

The 'llvm.usub.with.overflow' family of intrinsic functions perform an unsigned subtraction of the two arguments. They return a structure — the first element of which is the subtraction, and the second element of which is a bit specifying if the unsigned subtraction resulted in an overflow.

例:
  %res = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
  %sum = extractvalue {i32, i1} %res, 0
  %obit = extractvalue {i32, i1} %res, 1
  br i1 %obit, label %overflow, label %normal
'llvm.smul.with.overflow.*' Intrinsics
構文:

これはオーバーロードされた組込処理です。llvm.smul.with.overflowは任意のビット幅の整数に対して使用可能です。

  declare {i16, i1} @llvm.smul.with.overflow.i16(i16 %a, i16 %b)
  declare {i32, i1} @llvm.smul.with.overflow.i32(i32 %a, i32 %b)
  declare {i64, i1} @llvm.smul.with.overflow.i64(i64 %a, i64 %b)
概要:

The 'llvm.smul.with.overflow' family of intrinsic functions perform a signed multiplication of the two arguments, and indicate whether an overflow occurred during the signed multiplication.

引数:

The arguments (%a and %b) and the first element of the result structure may be of integer types of any bit width, but they must have the same bit width. The second element of the result structure must be of type i1. %a and %b are the two values that will undergo signed multiplication.

意味:

The 'llvm.smul.with.overflow' family of intrinsic functions perform a signed multiplication of the two arguments. They return a structure — the first element of which is the multiplication, and the second element of which is a bit specifying if the signed multiplication resulted in an overflow.

例:
  %res = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %a, i32 %b)
  %sum = extractvalue {i32, i1} %res, 0
  %obit = extractvalue {i32, i1} %res, 1
  br i1 %obit, label %overflow, label %normal
'llvm.umul.with.overflow.*' Intrinsics
構文:

これはオーバーロードされた組込処理です。llvm.umul.with.overflowは任意のビット幅の整数に対して使用可能です。

  declare {i16, i1} @llvm.umul.with.overflow.i16(i16 %a, i16 %b)
  declare {i32, i1} @llvm.umul.with.overflow.i32(i32 %a, i32 %b)
  declare {i64, i1} @llvm.umul.with.overflow.i64(i64 %a, i64 %b)
概要:

The 'llvm.umul.with.overflow' family of intrinsic functions perform a unsigned multiplication of the two arguments, and indicate whether an overflow occurred during the unsigned multiplication.

引数:

The arguments (%a and %b) and the first element of the result structure may be of integer types of any bit width, but they must have the same bit width. The second element of the result structure must be of type i1. %a and %b are the two values that will undergo unsigned multiplication.

意味:

The 'llvm.umul.with.overflow' family of intrinsic functions perform an unsigned multiplication of the two arguments. They return a structure — the first element of which is the multiplication, and the second element of which is a bit specifying if the unsigned multiplication resulted in an overflow.

例:
  %res = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %a, i32 %b)
  %sum = extractvalue {i32, i1} %res, 0
  %obit = extractvalue {i32, i1} %res, 1
  br i1 %obit, label %overflow, label %normal
Debugger Intrinsics

The LLVM debugger intrinsics (which all start with llvm.dbg. prefix), are described in the LLVM Source Level Debugging document.

Exception Handling Intrinsics

The LLVM exception handling intrinsics (which all start with llvm.eh. prefix), are described in the LLVM Exception Handling document.

Trampoline Intrinsic

This intrinsic makes it possible to excise one parameter, marked with the nest attribute, from a function. The result is a callable function pointer lacking the nest parameter - the caller does not need to provide a value for it. Instead, the value to use is stored in advance in a "trampoline", a block of memory usually allocated on the stack, which also contains code to splice the nest value into the argument list. This is used to implement the GCC nested function address extension.

For example, if the function is i32 f(i8* nest %c, i32 %x, i32 %y) then the resulting function pointer has signature i32 (i32, i32)*. It can be created as follows:

  %tramp = alloca [10 x i8], align 4 ; size and alignment only correct for X86
  %tramp1 = getelementptr [10 x i8]* %tramp, i32 0, i32 0
  %p = call i8* @llvm.init.trampoline( i8* %tramp1, i8* bitcast (i32 (i8* nest , i32, i32)* @f to i8*), i8* %nval )
  %fp = bitcast i8* %p to i32 (i32, i32)*

The call %val = call i32 %fp( i32 %x, i32 %y ) is then equivalent to %val = call i32 %f( i8* %nval, i32 %x, i32 %y ).

'llvm.init.trampoline' Intrinsic
構文:
declare i8* @llvm.init.trampoline(i8* <tramp>, i8* <func>, i8* <nval>)
概要:

This fills the memory pointed to by tramp with code and returns a function pointer suitable for executing it.

引数:

The llvm.init.trampoline intrinsic takes three arguments, all pointers. The tramp argument must point to a sufficiently large and sufficiently aligned block of memory; this memory is written to by the intrinsic. Note that the size and the alignment are target-specific - LLVM currently provides no portable way of determining them, so a front-end that generates this intrinsic needs to have some target-specific knowledge. The func argument must hold a function bitcast to an i8*.

意味:

The block of memory pointed to by tramp is filled with target dependent code, turning it into a function. A pointer to this function is returned, but needs to be bitcast to an appropriate function pointer type before being called. The new function's signature is the same as that of func with any arguments marked with the nest attribute removed. At most one such nest argument is allowed, and it must be of pointer type. Calling the new function is equivalent to calling func with the same argument list, but with nval used for the missing nest argument. If, after calling llvm.init.trampoline, the memory pointed to by tramp is modified, then the effect of any later call to the returned function pointer is undefined.

Atomic Operations and Synchronization Intrinsics

These intrinsic functions expand the "universal IR" of LLVM to represent hardware constructs for atomic operations and memory synchronization. This provides an interface to the hardware, not an interface to the programmer. It is aimed at a low enough level to allow any programming models or APIs (Application Programming Interfaces) which need atomic behaviors to map cleanly onto it. It is also modeled primarily on hardware behavior. Just as hardware provides a "universal IR" for source languages, it also provides a starting point for developing a "universal" atomic operation and synchronization IR.

These do not form an API such as high-level threading libraries, software transaction memory systems, atomic primitives, and intrinsic functions as found in BSD, GNU libc, atomic_ops, APR, and other system and application libraries. The hardware interface provided by LLVM should allow a clean implementation of all of these APIs and parallel programming models. No one model or paradigm should be selected above others unless the hardware itself ubiquitously does so.

'llvm.memory.barrier' Intrinsic
構文:
declare void @llvm.memory.barrier( i1 <ll>, i1 <ls>, i1 <sl>, i1 <ss>, 
i1 <device> )

概要:

The llvm.memory.barrier intrinsic guarantees ordering between specific pairs of memory access types.

引数:

The llvm.memory.barrier intrinsic requires five boolean arguments. The first four arguments enables a specific barrier as listed below. The fith argument specifies that the barrier applies to io or device or uncached memory.

意味:

This intrinsic causes the system to enforce some ordering constraints upon the loads and stores of the program. This barrier does not indicate when any events will occur, it only enforces an order in which they occur. For any of the specified pairs of load and store operations (f.ex. load-load, or store-load), all of the first operations preceding the barrier will complete before any of the second operations succeeding the barrier begin. Specifically the semantics for each pairing is as follows:

These semantics are applied with a logical "and" behavior when more than one is enabled in a single memory barrier intrinsic.

Backends may implement stronger barriers than those requested when they do not support as fine grained a barrier as requested. Some architectures do not need all types of barriers and on such architectures, these become noops.

%ptr      = malloc i32
            store i32 4, %ptr

%result1  = load i32* %ptr      ; yields {i32}:result1 = 4
            call void @llvm.memory.barrier( i1 false, i1 true, i1 false, i1 false )
                                ; guarantee the above finishes
            store i32 8, %ptr   ; before this begins
'llvm.atomic.cmp.swap.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。 llvm.atomic.cmp.swapは任意のビット幅の整数に対してと、アドレス空間の差異のために使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

declare i8 @llvm.atomic.cmp.swap.i8.p0i8( i8* <ptr>, i8 <cmp>, i8 <val> )
declare i16 @llvm.atomic.cmp.swap.i16.p0i16( i16* <ptr>, i16 <cmp>, i16 <val> )
declare i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* <ptr>, i32 <cmp>, i32 <val> )
declare i64 @llvm.atomic.cmp.swap.i64.p0i64( i64* <ptr>, i64 <cmp>, i64 <val> )

概要:

This loads a value in memory and compares it to a given value. If they are equal, it stores a new value into the memory.

引数:

The llvm.atomic.cmp.swap intrinsic takes three arguments. The result as well as both cmp and val must be integer values with the same bit width. The ptr argument must be a pointer to a value of this integer type. While any bit width integer may be used, targets may only lower representations they support in hardware.

意味:

This entire intrinsic must be executed atomically. It first loads the value in memory pointed to by ptr and compares it with the value cmp. If they are equal, val is stored into the memory. The loaded value is yielded in all cases. This provides the equivalent of an atomic compare-and-swap operation within the SSA framework.

例:
%ptr      = malloc i32
            store i32 4, %ptr

%val1     = add i32 4, 4
%result1  = call i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* %ptr, i32 4, %val1 )
                                          ; yields {i32}:result1 = 4
%stored1  = icmp eq i32 %result1, 4       ; yields {i1}:stored1 = true
%memval1  = load i32* %ptr                ; yields {i32}:memval1 = 8

%val2     = add i32 1, 1
%result2  = call i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* %ptr, i32 5, %val2 )
                                          ; yields {i32}:result2 = 8
%stored2  = icmp eq i32 %result2, 5       ; yields {i1}:stored2 = false

%memval2  = load i32* %ptr                ; yields {i32}:memval2 = 8
'llvm.atomic.swap.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。 llvm.atomic.swapは任意のビット幅の整数に対して使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

declare i8 @llvm.atomic.swap.i8.p0i8( i8* <ptr>, i8 <val> )
declare i16 @llvm.atomic.swap.i16.p0i16( i16* <ptr>, i16 <val> )
declare i32 @llvm.atomic.swap.i32.p0i32( i32* <ptr>, i32 <val> )
declare i64 @llvm.atomic.swap.i64.p0i64( i64* <ptr>, i64 <val> )

概要:

This intrinsic loads the value stored in memory at ptr and yields the value from memory. It then stores the value in val in the memory at ptr.

引数:

The llvm.atomic.swap intrinsic takes two arguments. Both the val argument and the result must be integers of the same bit width. The first argument, ptr, must be a pointer to a value of this integer type. The targets may only lower integer representations they support.

意味:

This intrinsic loads the value pointed to by ptr, yields it, and stores val back into ptr atomically. This provides the equivalent of an atomic swap operation within the SSA framework.

例:
%ptr      = malloc i32
            store i32 4, %ptr

%val1     = add i32 4, 4
%result1  = call i32 @llvm.atomic.swap.i32.p0i32( i32* %ptr, i32 %val1 )
                                        ; yields {i32}:result1 = 4
%stored1  = icmp eq i32 %result1, 4     ; yields {i1}:stored1 = true
%memval1  = load i32* %ptr              ; yields {i32}:memval1 = 8

%val2     = add i32 1, 1
%result2  = call i32 @llvm.atomic.swap.i32.p0i32( i32* %ptr, i32 %val2 )
                                        ; yields {i32}:result2 = 8

%stored2  = icmp eq i32 %result2, 8     ; yields {i1}:stored2 = true
%memval2  = load i32* %ptr              ; yields {i32}:memval2 = 2
'llvm.atomic.load.add.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。 llvm.atomic.load.addは任意のビット幅の整数に対して使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

declare i8 @llvm.atomic.load.add.i8..p0i8( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.add.i16..p0i16( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.add.i32..p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.add.i64..p0i64( i64* <ptr>, i64 <delta> )

概要:

This intrinsic adds delta to the value stored in memory at ptr. It yields the original value at ptr.

引数:

The intrinsic takes two arguments, the first a pointer to an integer value and the second an integer value. The result is also an integer value. These integer types can have any bit width, but they must all have the same bit width. The targets may only lower integer representations they support.

意味:

This intrinsic does a series of operations atomically. It first loads the value stored at ptr. It then adds delta, stores the result to ptr. It yields the original value stored at ptr.

例:
%ptr      = malloc i32
        store i32 4, %ptr
%result1  = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 4 )
                                ; yields {i32}:result1 = 4
%result2  = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 2 )
                                ; yields {i32}:result2 = 8
%result3  = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 5 )
                                ; yields {i32}:result3 = 10
%memval1  = load i32* %ptr      ; yields {i32}:memval1 = 15
'llvm.atomic.load.sub.*' Intrinsic
構文:

これはオーバーロードされた組込処理です。 llvm.atomic.load.subは任意のビット幅の整数に対してと、アドレス空間の差異のために使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

declare i8 @llvm.atomic.load.sub.i8.p0i32( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.sub.i16.p0i32( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.sub.i32.p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.sub.i64.p0i32( i64* <ptr>, i64 <delta> )

概要:

This intrinsic subtracts delta to the value stored in memory at ptr. It yields the original value at ptr.

引数:

The intrinsic takes two arguments, the first a pointer to an integer value and the second an integer value. The result is also an integer value. These integer types can have any bit width, but they must all have the same bit width. The targets may only lower integer representations they support.

意味:

This intrinsic does a series of operations atomically. It first loads the value stored at ptr. It then subtracts delta, stores the result to ptr. It yields the original value stored at ptr.

例:
%ptr      = malloc i32
        store i32 8, %ptr
%result1  = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 4 )
                                ; yields {i32}:result1 = 8
%result2  = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 2 )
                                ; yields {i32}:result2 = 4
%result3  = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 5 )
                                ; yields {i32}:result3 = 2
%memval1  = load i32* %ptr      ; yields {i32}:memval1 = -3
'llvm.atomic.load.and.*' Intrinsic
'llvm.atomic.load.nand.*' Intrinsic
'llvm.atomic.load.or.*' Intrinsic
'llvm.atomic.load.xor.*' Intrinsic
構文:

これらはオーバーロードされた組込処理です。 llvm.atomic.load_and, llvm.atomic.load_nand, llvm.atomic.load_or, llvm.atomic.load_xor はあらゆる整数ビット幅に対してと、アドレス空間の差異に使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

declare i8 @llvm.atomic.load.and.i8.p0i8( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.and.i16.p0i16( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.and.i32.p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.and.i64.p0i64( i64* <ptr>, i64 <delta> )

declare i8 @llvm.atomic.load.or.i8.p0i8( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.or.i16.p0i16( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.or.i32.p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.or.i64.p0i64( i64* <ptr>, i64 <delta> )

declare i8 @llvm.atomic.load.nand.i8.p0i32( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.nand.i16.p0i32( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.nand.i32.p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.nand.i64.p0i32( i64* <ptr>, i64 <delta> )

declare i8 @llvm.atomic.load.xor.i8.p0i32( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.xor.i16.p0i32( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.xor.i32.p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.xor.i64.p0i32( i64* <ptr>, i64 <delta> )

概要:

These intrinsics bitwise the operation (and, nand, or, xor) delta to the value stored in memory at ptr. It yields the original value at ptr.

引数:

These intrinsics take two arguments, the first a pointer to an integer value and the second an integer value. The result is also an integer value. These integer types can have any bit width, but they must all have the same bit width. The targets may only lower integer representations they support.

意味:

These intrinsics does a series of operations atomically. They first load the value stored at ptr. They then do the bitwise operation delta, store the result to ptr. They yield the original value stored at ptr.

例:
%ptr      = malloc i32
        store i32 0x0F0F, %ptr
%result0  = call i32 @llvm.atomic.load.nand.i32.p0i32( i32* %ptr, i32 0xFF )
                                ; yields {i32}:result0 = 0x0F0F
%result1  = call i32 @llvm.atomic.load.and.i32.p0i32( i32* %ptr, i32 0xFF )
                                ; yields {i32}:result1 = 0xFFFFFFF0
%result2  = call i32 @llvm.atomic.load.or.i32.p0i32( i32* %ptr, i32 0F )
                                ; yields {i32}:result2 = 0xF0
%result3  = call i32 @llvm.atomic.load.xor.i32.p0i32( i32* %ptr, i32 0F )
                                ; yields {i32}:result3 = FF
%memval1  = load i32* %ptr      ; yields {i32}:memval1 = F0
'llvm.atomic.load.max.*' Intrinsic
'llvm.atomic.load.min.*' Intrinsic
'llvm.atomic.load.umax.*' Intrinsic
'llvm.atomic.load.umin.*' Intrinsic
構文:

これらはオーバーロードされた組込処理です。 llvm.atomic.load_max, llvm.atomic.load_min, llvm.atomic.load_umax, llvm.atomic.load_umin はあらゆる整数ビット幅に対してと、アドレス空間の差異に使用可能です。 しかしながら、全ての対象があらゆるビット幅をサポートするとは限りません。

declare i8 @llvm.atomic.load.max.i8.p0i8( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.max.i16.p0i16( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.max.i32.p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.max.i64.p0i64( i64* <ptr>, i64 <delta> )

declare i8 @llvm.atomic.load.min.i8.p0i8( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.min.i16.p0i16( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.min.i32..p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.min.i64..p0i64( i64* <ptr>, i64 <delta> )

declare i8 @llvm.atomic.load.umax.i8.p0i8( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.umax.i16.p0i16( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.umax.i32.p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.umax.i64.p0i64( i64* <ptr>, i64 <delta> )

declare i8 @llvm.atomic.load.umin.i8..p0i8( i8* <ptr>, i8 <delta> )
declare i16 @llvm.atomic.load.umin.i16.p0i16( i16* <ptr>, i16 <delta> )
declare i32 @llvm.atomic.load.umin.i32..p0i32( i32* <ptr>, i32 <delta> )
declare i64 @llvm.atomic.load.umin.i64..p0i64( i64* <ptr>, i64 <delta> )

概要:

これらの組込命令は、deltaptrメモリに保存された値との、 符号付または符号無の最大値または最小値を得ます。 それはptrにオリジナルの値を生じます。

引数:

These intrinsics take two arguments, the first a pointer to an integer value and the second an integer value. The result is also an integer value. These integer types can have any bit width, but they must all have the same bit width. The targets may only lower integer representations they support.

意味:

These intrinsics does a series of operations atomically. They first load the value stored at ptr. They then do the signed or unsigned min or max delta and the value, store the result to ptr. They yield the original value stored at ptr.

例:
%ptr      = malloc i32
        store i32 7, %ptr
%result0  = call i32 @llvm.atomic.load.min.i32.p0i32( i32* %ptr, i32 -2 )
                                ; yields {i32}:result0 = 7
%result1  = call i32 @llvm.atomic.load.max.i32.p0i32( i32* %ptr, i32 8 )
                                ; yields {i32}:result1 = -2
%result2  = call i32 @llvm.atomic.load.umin.i32.p0i32( i32* %ptr, i32 10 )
                                ; yields {i32}:result2 = 8
%result3  = call i32 @llvm.atomic.load.umax.i32.p0i32( i32* %ptr, i32 30 )
                                ; yields {i32}:result3 = 8
%memval1  = load i32* %ptr      ; yields {i32}:memval1 = 30
汎用組込処理(General Intrinsics)

この組込処理の分類は、特定の目的を持たない汎用的なものである。

llvm.var.annotation組込処理
構文:
  declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32  <int> )
概要:

llvm.var.annotation組込命令

引数:

第一引数は値のポインタです。 第二引数はグローバルな文字列のポインタです。 第三引数はソースファイル名を示すグローバルな文字列のポインタです。 最後の引数は行番号です。

意味:

この組込命令はarbitrary stringsを持つローカル変数の注釈を許します。 This intrinsic allows annotation of local variables with arbitrary strings. This can be useful for special purpose optimizations that want to look for these annotations. These have no other defined use, they are ignored by code generation and optimization.

llvm.annotation.*組込処理
構文:

これはオーバーロードされた組込処理です。llvm.annotationはあらゆる整数ビット幅に対して使用可能です。

  declare i8 @llvm.annotation.i8(i8 <val>, i8* <str>, i8* <str>, i32  <int> )
  declare i16 @llvm.annotation.i16(i16 <val>, i8* <str>, i8* <str>, i32  <int> )
  declare i32 @llvm.annotation.i32(i32 <val>, i8* <str>, i8* <str>, i32  <int> )
  declare i64 @llvm.annotation.i64(i64 <val>, i8* <str>, i8* <str>, i32  <int> )
  declare i256 @llvm.annotation.i256(i256 <val>, i8* <str>, i8* <str>, i32  <int> )
概要:

llvm.annotation組込命令

引数:

第一引数は(何らかの指揮の結果である)整数値です。 第二引数はグローバルな文字列のポインタです。 第三引数はソースファイル名を示すグローバルな文字列のポインタです。 最後の引数は行番号です。 この命令は第一引数の値を返します。

意味:

この組込命令はarbitrary expressions with arbitrary stringsにつけられた注釈を許します。 このような注釈を見(て判断)したい特殊な目的の最適化に有用です。 これらはそれ以外に定義された用法を持たず、コード生成部及び最適化処置によって無視されます。

llvm.trap組込処理
構文:
  declare void @llvm.trap()
概要:

llvm.trap組込命令

引数:

None

意味:

この組込命令は対象依存のトラップ命令をlowered to します。 This intrinsics is lowered to the target dependent trap instruction. 対象がトラップ命令を持たない場合、この組込命令はabort()関数の呼び出しにlowered toされるでしょう。

'llvm.stackprotector'組込処理
構文:
declare void @llvm.stackprotector( i8* <guard>, i8** <slot> )

概要:

The llvm.stackprotector intrinsic takes the guard and stores it onto the stack at slot. The stack slot is adjusted to ensure that it is placed on the stack before local variables.

引数:

The llvm.stackprotector intrinsic requires two pointer arguments. The first argument is the value loaded from the stack guard @__stack_chk_guard. The second variable is an alloca that has enough space to hold the value of the guard.

意味:

This intrinsic causes the prologue/epilogue inserter to force the position of the AllocaInst stack slot to be before local variables on the stack. This is to ensure that if a local variable on the stack is overwritten, it will destroy the value of the guard. When the function exits, the guard on the stack is checked against the original guard. If they're different, then the program aborts by calling the __stack_chk_fail() function.


Valid CSS Valid HTML 4.01 Chris Lattner
LLVMコンパイラ基盤
Last modified: $Date: 2009-07-17 16:14:28 -0500 (Fri, 17 Jul 2009) $