Rust 使用 LLVM Intrinsics 實作非區域性跳轉

– 16 分鐘閱讀

在系統程式設計中，精確控制程式流程至關重要。本文將深入探討如何在 Rust 中利用 LLVM Intrinsics，特別是 setjmp 和 longjmp，實作非區域性跳轉，並剖析相關的型別轉換、訊號處理機制，以及與 LLVM 的底層互動。這些技術允許開發者繞過傳統的函式呼叫傳回機制，直接跳轉到程式中的特定位置，對於錯誤處理、狀態還原等場景至關重要。理解這些底層機制能幫助開發者編寫更有效率且更具控制力的程式碼。

use libc::{
    SIGALRM, SIGHUP, SIGQUIT, SIGTERM, SIGUSR1,
};

const JMP_BUF_WIDTH: usize = std::mem::size_of::<usize>() * 8;
type jmp_buf = [i8; JMP_BUF_WIDTH];


static mut SHUT_DOWN: bool = false;
static mut RETURN_HERE: jmp_buf = [0; JMP_BUF_WIDTH];

const MOCK_SIGNAL_AT: usize = 3;


extern "C" {
    #[link_name = "llvm.eh.sjlj.setjmp"]
    pub fn setjmp(_: *mut i8) -> i32;

    #[link_name = "llvm.eh.sjlj.longjmp"]
    pub fn longjmp(_: *mut i8, _: i32);
}


#[inline]
fn ptr_to_jmp_buf() -> *mut i8 {
    unsafe { &RETURN_HERE as *const i8 as *mut i8 }
}

#[inline]
fn return_early() {
    let franken_pointer = ptr_to_jmp_buf();
    unsafe { longjmp(franken_pointer, 1) };
}


fn register_signal_handler() {}



fn main() {}

1. print_depth 函式

fn print_depth(depth: usize) {
    for _ in 0..depth {
        print!("#");
    }
    println!("");
}

此函式負責印刷指定深度的 # 符號。它使用 for 迴圈重影印刷 #，重複次數由 depth 引數決定。

內容解密：

  • for _ in 0..depth：此迴圈從 0 到 depth-1 迴圈 depth 次。
  • print!("#")：在每次迴圈中，印刷一個 # 符號。
  • println!("")：在迴圈結束後，印刷一個換行符號，以便在下一次呼叫時從新行開始。

2. dive 函式

fn dive(depth: usize, max_depth: usize) {
    print_depth(depth);
    if depth >= max_depth {
        return;
    } else {
        dive(depth + 1, max_depth);
    }
    print_depth(depth);
}

此函式是一個遞迴函式，負責印刷從初始深度到最大深度的 # 符號，並在傳回時再次印刷相同的深度。

內容解密：

  • print_depth(depth)：先印刷當前深度的 # 符號。
  • if depth >= max_depth { return; }：如果當前深度已經達到最大深度，則結束遞迴。
  • else { dive(depth + 1, max_depth); }：否則，遞迴呼叫 dive 函式，深度增加 1。
  • print_depth(depth)：在遞迴傳回時，再次印刷當前深度的 # 符號。

Mermaid 圖表：遞迴流程

  flowchart TD
    A[開始] --> B[印刷當前深度]
    B --> C[判斷是否達到最大深度]
    C -->|是| D[結束遞迴]
    C -->|否| E[遞迴呼叫 dive]
    E --> F[印刷傳回深度]
    F --> D

圖表翻譯：

此圖表描述了 dive 函式的遞迴流程。首先，印刷當前深度的 # 符號。然後，判斷是否達到最大深度。如果是，結束遞迴。如果否，遞迴呼叫 dive 函式，並在傳回時再次印刷相同的深度。這個過程一直重複，直到達到最大深度。

控制流程的魔術：使用Intrinsic函式

在Rust中，控制流程的管理通常由語言本身和標準函式庫提供的功能來實作。然而，當我們需要進行一些低階別的操作，例如控制流程的跳轉時，就需要使用到Intrinsic函式。Intrinsic函式是編譯器提供的一些特殊函式，允許應用程式直接存取硬體資源或進行一些特殊的操作。

什麼是Intrinsic函式？

Intrinsic函式是一種特殊的函式，直接由編譯器實作，而不是由標準函式庫或應用程式實作。它們通常用於提供一些低階別的功能，例如記憶體管理、I/O操作等。在Rust中，Intrinsic函式可以透過使用llvm_intrinsics特性來啟用。

啟用Intrinsic函式

要在Rust中使用Intrinsic函式，需要在crate層級新增#![feature(link_llvm_intrinsics)]屬性。這將啟用對LLVM Intrinsic函式的支援。

使用Intrinsic函式

一旦啟用了Intrinsic函式，就可以使用它們來進行一些特殊的操作。例如，setjmp()和longjmp()函式可以用於控制流程的跳轉。然而，使用Intrinsic函式需要在unsafe塊中進行，因為它們可能會導致記憶體安全問題。

示例：sjlj專案

sjlj專案示範瞭如何使用Intrinsic函式來控制流程的跳轉。該專案使用setjmp()和longjmp()函式來實作控制流程的跳轉。

設定Intrinsic函式

要使用Intrinsic函式，需要告訴Rust關於這些函式的存在。可以透過在unsafe塊中定義這些函式來實作。

內容解密：
// 啟用Intrinsic函式
#![feature(link_llvm_intrinsics)]

// 定義Intrinsic函式
extern "C" {
    fn setjmp();
    fn longjmp();
}

fn main() {
    // 使用Intrinsic函式
    unsafe {
        setjmp();
    }
}

圖表翻譯：

  graph LR
    A[啟用Intrinsic函式] --> B[定義Intrinsic函式]
    B --> C[使用Intrinsic函式]
    C --> D[控制流程的跳轉]

在這個圖表中，展示了啟用Intrinsic函式、定義Intrinsic函式、使用Intrinsic函式和控制流程的跳轉之間的關係。

程式語言的底層運作：理解Intrinsic Functions和LLVM

在程式設計中，瞭解程式語言的底層運作機制對於開發高效且可靠的軟體至關重要。其中，Intrinsic Functions和LLVM是兩個重要的概念，分別與編譯器提供的特殊功能和編譯器的基礎架構有關。在本文中，我們將深入探討Intrinsic Functions和LLVM的世界，探索它們如何提升程式設計的效率和功能。

什麼是Intrinsic Functions？

Intrinsic Functions，簡稱為Intrinsics，是由編譯器提供的一組特殊功能。這些功能不屬於程式語言本身，而是由編譯器根據目標環境提供的額外功能。Intrinsics可以讓程式設計師直接存取硬體資源，例如CPU指令，從而實作更高效的程式執行。

Atomic Operations

Atomic Operations是一種Intrinsic Function，允許程式設計師執行原子操作。原子操作是指不能被中斷的操作，確保在多執行緒環境中資料的一致性。例如，更新一個整數變數可以被實作為一個原子操作，確保即使在多執行緒環境中，也能夠正確地更新變數。

Exception Handling

Exception Handling是另一種Intrinsic Function，提供了處理異常情況的機制。這些機制可以被用於捕捉和處理程式執行過程中出現的異常，例如除零錯誤或記憶體溢位錯誤。

什麼是LLVM？

LLVM（Low Level Virtual Machine）是一個編譯器基礎架構，為多種程式語言提供了共同的後端。從Rust程式設計師的角度來看，LLVM可以被視為Rust編譯器（rustc）的子元件。LLVM提供了一系列工具和功能，包括Intrinsic Functions，可以被Rust程式設計師使用。

LLVM的工具

LLVM提供了多種工具，包括Intrinsic Functions，可以用於最佳化程式執行效率和功能。例如，LLVM的Intrinsic Functions可以用於實作原子操作、例外處理等功能。

內容解密：

在上述內容中，我們探討了Intrinsic Functions和LLVM的概念和應用。Intrinsic Functions提供了特殊功能，可以用於最佳化程式執行效率和功能。LLVM作為一個編譯器基礎架構，提供了多種工具和功能，可以被用於提升程式設計的效率和功能。瞭解這些概念，可以幫助程式設計師更好地掌握程式語言的底層運作機制。

  graph LR
    A[Intrinsic Functions] -->|提供特殊功能|> B[最佳化程式執行效率]
    B -->|提升功能|> C[LLVM]
    C -->|提供工具|> D[提升程式設計效率]
    D -->|最佳化軟體|> E[高效可靠軟體]

圖表翻譯：

上述Mermaid圖表展示了Intrinsic Functions、LLVM和程式設計之間的關係。Intrinsic Functions提供了特殊功能，可以用於最佳化程式執行效率和功能。LLVM作為一個編譯器基礎架構，提供了多種工具和功能，可以被用於提升程式設計的效率和功能。最終，瞭解這些概念可以幫助程式設計師開發出更高效、更可靠的軟體。

程式編譯與連結的過程

在探討程式編譯和連結的過程時，我們需要了解各個工具之間的相互作用。首先，編譯器（如Rust的編譯器）將程式碼轉換為中間語言（Intermediate Representation, IR），然後再轉換為機器可讀的組合語言。接下來，連結器（Linker）負責將多個程式單元（如函式庫）連結在一起，形成最終的可執行檔。

LLVM與Rust編譯器

LLVM是一個編譯器基礎設施，它扮演著程式編譯過程中的關鍵角色。Rust編譯器（rustc）產生LLVM IR，這些IR程式碼隨後被LLVM翻譯為機器碼。這個過程相當於將高階語言轉換為低階語言，以便電腦能夠直接執行。

連結器的角色

連結器（Linker）是一種工具，負責將多個物件檔案（Object Files）或函式庫連結在一起，形成一個完整的可執行檔。它需要知道哪些函式或變數定義在哪些檔案中，以便正確地解析外部參考。在Windows上，Rust使用link.exe，而在其他作業系統上，則使用GNU連結器（ld）。

指標型別之間的轉換

在Rust中，指標型別之間的轉換可能會有些棘手。特別是當遇到C函式如setjmp()和longjmp()時，這些函式的簽名可能會導致型別不匹配的問題。例如，以下程式碼片段展示瞭如何定義這些函式：

extern "C" {
    #[link_name = "llvm.eh.sjlj.setjmp"]
    pub fn setjmp(_: *mut i8) -> i32;

    #[link_name = "llvm.eh.sjlj.longjmp"]
    pub fn longjmp(_: *mut i8);
}

這些函式都接受一個*mut i8指標作為引數，這可能會導致型別不匹配的問題，因為Rust的型別系統非常嚴格。

內容解密：

上述程式碼片段使用了extern "C"關鍵字來定義C函式介面。#[link_name = "llvm.eh.sjlj.setjmp"]屬性指定了這個函式在連結時應該使用的名稱。函式setjmp()和longjmp()分別傳回一個i32值和接受一個*mut i8指標作為引數。

程式編譯流程

程式編譯流程可以概括為以下步驟：

  1. 編譯: 編譯器將原始碼轉換為中間語言（IR）。
  2. 最佳化: 對IR進行最佳化，以改善程式的效率。
  3. 程式碼生成: 將最佳化後的IR轉換為機器碼。
  4. 連結: 將多個物件檔案或函式庫連結在一起，形成最終的可執行檔。

圖表翻譯：

  flowchart TD
    A[原始碼] --> B[編譯]
    B --> C[最佳化]
    C --> D[程式碼生成]
    D --> E[連結]
    E --> F[可執行檔]

這個流程圖展示了從原始碼到可執行檔的整個編譯流程。每一步驟都對應著一個特定的工具或過程，最終形成了可以在電腦上直接執行的程式。

解決Rust與LLVM之間的jmp_buf型別衝突

在使用Rust呼叫LLVM的intrinsics函式時，可能會遇到型別不符的問題。其中一個常見的問題是LLVM的intrinsics函式要求一個*mut i8作為輸入引數，但Rust的jmp_buf型別卻是一個參考（&jmp_buf）。

jmp_buf型別定義

jmp_buf型別在Rust中被定義為一個型別別名，代表一個i8的陣列，陣列的寬度與usize的大小有關。

const JMP_BUF_WIDTH: usize = mem::size_of::<usize>() * 8;
type jmp_buf = [i8; JMP_BUF_WIDTH];

這個型別用於儲存程式的狀態，以便在需要時還原CPU的暫存器。

將jmp_buf轉換為*mut i8

為了將jmp_buf轉換為*mut i8，我們可以使用以下四個步驟：

  1. 先取得jmp_buf的參考（&jmp_buf）。
  2. 將參考轉換為*const i8。
  3. 將*const i8轉換為*mut i8。
  4. 將轉換過程包裹在unsafe區塊中，因為它涉及到存取全域靜態變數。

這四個步驟可以被壓縮成一行：

unsafe { &RETURN_HERE as *const i8 as *mut i8 }

為什麼不使用&mut RETURN_HERE as *mut i8？

直接使用&mut RETURN_HERE as *mut i8可能會使Rust編譯器感到不安，因為它涉及到將Rust的資料暴露給LLVM。從只讀參考開始的方法可以讓Rust感到更安全。

編譯sjlj專案

現在，我們已經解決了jmp_buf型別衝突的問題，可以繼續編譯sjlj專案了。請確保rustc是在nightly channel上，否則可能會遇到錯誤。如果遇到錯誤，可以使用rustup install nightly安裝nightly版本的rustc，並使用--nightly引數來啟用它。

使用LLVM編譯器存取作業系統的long-jmp設施

在這個範例中，我們將使用LLVM編譯器來存取作業系統的long-jmp設施。long-jmp是一種允許程式跳出其堆積疊框架並跳轉到其位址空間中的任何位置的功能。

專案設定

首先，我們需要設定專案的metadata。在Cargo.toml檔案中，我們定義了專案的名稱、版本和edition。

[package]
name = "sjlj"
version = "0.1.0"
edition = "2018"

接下來，我們需要新增依賴項。在這個範例中，我們只需要新增libc依賴項。

[dependencies]
libc = "0.2"

主程式

現在，我們可以開始編寫主程式。在src/main.rs檔案中，我們定義了以下程式碼：

#![feature(link_llvm_intrinsics)]
#![allow(non_camel_case_types)]
#![cfg(not(windows))]

//...程式碼內容...

這裡，我們使用了三個屬性：

  • #![feature(link_llvm_intrinsics)]：啟用LLVM編譯器的內建函式。
  • #![allow(non_camel_case_types)]：允許非駝峰式命名約定。
  • #![cfg(not(windows))]：設定組態以排除Windows平臺。

long-jmp設施

在這個範例中，我們將使用long-jmp設施來跳出堆積疊框架並跳轉到其位址空間中的任何位置。long-jmp是一種強大的功能，但也可能導致程式當機或產生不可預期的行為。

Mermaid圖表

  flowchart TD
    A[開始] --> B[設定long-jmp]
    B --> C[跳出堆積疊框架]
    C --> D[跳轉到位址空間]
    D --> E[結束]

圖表翻譯

此圖表展示了long-jmp設施的工作流程。首先，我們設定long-jmp功能，然後跳出堆積疊框架，接著跳轉到位址空間中的任何位置，最後結束程式。

使用Rust語言實作訊號處理和跳轉

訊號處理機制

在Rust中，訊號處理機制是透過使用外部函式來實作的。這些外部函式通常是由C函式庫提供的，例如libc函式庫。在以下的程式碼中，我們將使用libc函式庫中的訊號常數和函式。

訊號常數和函式

use libc::{
    SIGALRM, SIGHUP, SIGQUIT, SIGTERM, SIGUSR1,
};

在這裡，我們匯入了幾個訊號常數，包括：

  • SIGALRM: 時間到期訊號
  • SIGHUP: 控制終端斷開連線訊號
  • SIGQUIT: 終止程式訊號
  • SIGTERM: 終止程式訊號
  • SIGUSR1: 使用者定義訊號1

jmp_buf型別定義

const JMP_BUF_WIDTH: usize = mem::size_of::<usize>() * 8;
type jmp_buf = [i8; JMP_BUF_WIDTH];

在這裡，我們定義了一個jmp_buf型別，它是一個長度為JMP_BUF_WIDTH的i8陣列。JMP_BUF_WIDTH是根據usize型別的大小計算出來的。

靜態變數定義

static mut SHUT_DOWN: bool = false;
static mut RETURN_HERE: jmp_buf = [0; JMP_BUF_WIDTH];

在這裡，我們定義了兩個靜態變數：

  • SHUT_DOWN: 一個布林值，表示是否需要關閉程式
  • RETURN_HERE: 一個jmp_buf型別的變數，用於儲存跳轉地址

外部函式定義

extern "C" {
    #[link_name = "llvm.eh.sjlj.setjmp"]
    pub fn setjmp(_: *mut i8) -> i32;

    #[link_name = "llvm.eh.sjlj.longjmp"]
    //...
}

在這裡，我們定義了兩個外部函式：

  • setjmp: 設定跳轉地址
  • longjmp: 執行跳轉

注意：這裡只展示了setjmp函式的定義，longjmp函式的定義暫時省略。

MOCK_SIGNAL_AT常數定義

const MOCK_SIGNAL_AT: usize = 3;

在這裡，我們定義了一個常數MOCK_SIGNAL_AT,用於模擬訊號的傳送。

內容解密：

在這段程式碼中，我們使用Rust語言實作了訊號處理和跳轉機制。首先，我們匯入了必要的訊號常數和函式。然後，我們定義了一個jmp_buf型別，用於儲存跳轉地址。接下來，我們定義了兩個靜態變數，分別用於表示是否需要關閉程式和儲存跳轉地址。最後，我們定義了兩個外部函式，分別用於設定跳轉地址和執行跳轉。

圖表翻譯：

  graph LR
    A[訊號處理] -->|匯入訊號常數|> B[定義jmp_buf型別]
    B -->|定義靜態變數|> C[設定跳轉地址]
    C -->|執行跳轉|> D[模擬訊號傳送]
    D -->|傳回跳轉地址|> E[結束程式]

在這個圖表中，我們展示了訊號處理和跳轉機制的流程。首先，我們匯入訊號常數。然後，我們定義了jmp_buf型別和靜態變數。接下來，我們設定跳轉地址和執行跳轉。最後，我們模擬訊號傳送和傳回跳轉地址，結束程式。

程式碼實作：

fn main() {
    unsafe {
        // 設定跳轉地址
        let mut buf: jmp_buf = [0; JMP_BUF_WIDTH];
        let ret = setjmp(&mut buf as *mut i8);
        if ret == 0 {
            // 執行跳轉
            longjmp(&mut buf as *mut i8, 1);
        } else {
            // 傳回跳轉地址
            println!("傳回跳轉地址：{:?}", buf);
        }
    }
}

在這個程式碼中，我們使用了setjmp和longjmp函式來實作跳轉機制。首先，我們設定跳轉地址。然後，我們執行跳轉。如果傳回值為0，則表示執行跳轉成功。否則，則表示傳回跳轉地址。

圖表翻譯：

  graph LR
    A[設定跳轉地址] -->|執行跳轉|> B[傳回跳轉地址]
    B -->|列印傳回值|> C[結束程式]

在這個圖表中，我們展示了程式碼實作的流程。首先，我們設定跳轉地址。然後，我們執行跳轉。如果傳回值為0，則表示執行跳轉成功。否則，則表示傳回跳轉地址，並列印傳回值。最後，結束程式。

使用Rust語言呼叫C函式實作非區域性跳躍

非區域性跳躍介紹

非區域性跳躍是一種程式設計技術，允許程式從某個點跳轉到另一個點，並且可以跨越函式的範圍。這種技術在某些情況下非常有用，例如當程式需要快速傳回主程式或是處理異常時。

Rust語言中的非區域性跳躍

在Rust語言中，可以使用std::panic模組來實作非區域性跳躍。但是，如果需要呼叫C函式實作非區域性跳躍，可以使用extern關鍵字來宣告C函式，並使用unsafe區塊來呼叫C函式。

longjmp 函式

longjmp函式是一個C標準函式，用於實作非區域性跳躍。它的原型如下：

void longjmp(jmp_buf env, int val);

其中，jmp_buf是一個結構體，用於儲存當前的執行環境；val是傳回值。

ptr_to_jmp_buf 函式

ptr_to_jmp_buf函式用於取得一個指向jmp_buf結構體的指標。它的實作如下：

#[inline]
fn ptr_to_jmp_buf() -> *mut i8 {
    unsafe { &RETURN_HERE as *const i8 as *mut i8 }
}

其中，RETURN_HERE是一個全域變數，用於儲存當前的執行環境。

return_early 函式

return_early函式用於實作非區域性跳躍。它的實作如下：

#[inline]
fn return_early() {
    let franken_pointer = ptr_to_jmp_buf();
    unsafe { longjmp(franken_pointer) };
}

其中，franken_pointer是指向jmp_buf結構體的指標；longjmp函式用於實作非區域性跳躍。

register_signal_handler 函式

register_signal_handler函式用於註冊一個訊號處理器。它的實作如下：

fn register_signal_handler() {
    //...
}

目前，這個函式尚未實作。

Mermaid 圖表

以下是使用Mermaid語法繪製的流程圖：

  flowchart TD
    A[開始] --> B[呼叫ptr_to_jmp_buf]
    B --> C[取得jmp_buf指標]
    C --> D[呼叫longjmp]
    D --> E[實作非區域性跳躍]
    E --> F[傳回]

圖表翻譯

這個流程圖描述瞭如何使用Rust語言呼叫C函式實作非區域性跳躍。首先，呼叫ptr_to_jmp_buf函式取得一個指向jmp_buf結構體的指標。然後，呼叫longjmp函式實作非區域性跳躍。最後，傳回主程式。

使用LLVM的內部編譯機制（intrinsics）

在某些情況下，開發人員可能需要直接使用LLVM的內部編譯機制（intrinsics）來實作特定的功能。這些intrinsics提供了一種方法，可以直接存取LLVM的內部實作，從而實作一些特殊的功能。

從底層實作到高階應用的全面檢視顯示，Rust 與 LLVM 的整合，在實作高效能與底層控制方面展現了其獨特優勢。透過深入剖析 setjmp 和 longjmp 等 intrinsics 函式，我們理解了如何在 Rust 中實作非區域性跳轉及訊號處理等進階功能，並有效控制程式流程。然而，直接使用 intrinsics 也伴隨著安全性風險，需要謹慎處理指標轉換及記憶體管理，並在 unsafe 區塊中操作以確保記憶體安全。展望未來，隨著 Rust 語言的持續發展和 LLVM 基礎設施的日益完善，我們預見更多底層控制能力將被釋放，並應用於更廣泛的領域，例如嵌入式系統、作業系統核心開發以及高效能運算等。對於追求極致效能和底層控制的開發者而言，深入理解 Rust 與 LLVM 的互動機制至關重要。玄貓認為，掌握此一技術將賦予開發者更強大的能力，創造出更具競爭力的應用程式。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。