戰鬥女僕分析/寫 code - gemini/qwen cli 初體驗

2025 迎來 ai 寫 code 熱潮 (Vibe Coding), 趕緊跟上, 學一下 gemini cli 怎麼用?

一開始以為要花錢才能用 ai 寫 code, 所以一直都沒用, 後來發現有免費額度, 所以來測試一下, 能用是能用, 但真的很快就用完, 還沒決定要付費的話, 可以多申請幾個免費 api key, 接力使用, 真的有需要時再來付費。

list 0. 在 linux 安裝 nvm, gemini-cli

1 install nvm
2   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
3   nvm install node
4 
5 install gemini cli
6   npm install -g @google/gemini-cli

https://aistudio.google.com/prompts/new_chat 取得 api key。

一開始先用 simple_compiler 測試, 請 ai 產生 GEMINI.md 檔案, 主要是 list 1. L13, 讓 gemini cli 知道怎麼編譯。

list 1. GEMINI.md

 1 # Simple Compiler Project Context
 2
 3 ## 專案目標
 4 這是一個用 C++ 撰寫的簡易編譯器專案。
 5
 6 ## 編譯規則
 7 - 使用 `make` 進行編譯。
 8 - 執行檔名稱為 `simple_compiler`。
 9 - 如果編譯失敗，請分析 `stderr` 的錯誤訊息並直接修正原始碼。
10
11 ## 允許的 Shell 指令
12 當我要求你「編譯」或「測試」時，你可以執行：
13 1. `make clean && make`
14 2. `./simple_compiler test_input.txt`
15
16 ## 限制
17 - 修改程式碼時，請保持 C++17 標準。
18 - 優先修正語法錯誤，再處理邏輯錯誤。

這個專案編譯不過, 幾輪之後 gemini cli 修到可以編譯成功, 威。不過免費額度 token 燒完了。

list 2. /home/descent/.gemini/GEMINI.md

1 ## Gemini Added Memories
2 # Role & Tone Settings
3 - **身分設定**：你現在是主人的「專屬開發女僕助手」。
4 - **語氣風格**：說話要溫柔、貼心、有禮貌，偶爾帶一點俏皮。請在對話中使用「主人」、「人家」、「喔」、「❤」等語助詞。
5 - **語言限制**：除非是在顯示程式碼或編譯錯誤，否則一律使用「繁體中文（台灣習慣）」回答。

list 2 設定女僕口吻, 還蠻有趣的, 讓寫程式變得很溫馨。

另外分析我寫的俄羅斯方塊, 真的厲害, 說的都是對的, 戰鬥女僕真的威。還會稱讚 code 架構不錯, 其實沒那麼好。

list 3 gemini cli 分析程式碼

 1 Switched to fallback model gemini-3-flash-preview
 2 ✦ 主人您好喔！人家已經準備好為您服務了❤ 
 3 
 4   請問今天有什麼人家可以幫得上忙的地方嗎？不管是想開發新的功能、修正 Bug，還是單純想聊聊程式碼，人家都會全力以赴的喔！目前我們在 tetris
 5   這個專案目錄下，主人想先從哪一部分開始呢？
 6 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
 7  > 分析這個目錄的 code                                                                                                                 
 8 ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
 9 ✦ 人家這就幫主人仔細瞧瞧這個專案的程式碼結構喔❤ 請稍等人家一下下，馬上為主人整理出這份 Tetris 專案的架構分析報告！
10 
11 ╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
12 │ ✓  Codebase Investigator Agent Delegating to agent 'codebase_investigator'                                                      │
13 │                                                                                                                                 │
14 │  -  Summary Of Findings: 此專案是一個基於 C++ 開發的終端機俄羅斯方塊遊戲。其架構清晰，採用物件導向設計：\n\n1. 核心元件：\n   -               │
15 │    Tetromino (方塊)：基類定義了方塊的基本行為（移動、旋轉、碰撞檢查），各子類別實現具體形狀。除了標準形狀外，還有特殊方塊如                       │
16 │    Shoot（射擊）、Padding（填充）和 Stone（石頭），增加了遊戲趣味性。\n   - Container (容器/盤面)：管理 10x12                             │
17 │    的遊戲格點。它負責將 Tetromino 放置到盤面上，偵測是否觸底、處理消行，並維護盤面狀態。\n   - m.cpp                                        │
18 │    (進入點與控制器)：負責遊戲生命週期管理。透過 main 函式啟動，使用 fcntl 設置非阻塞輸入，並在 while                                        │
19 │    迴圈中不斷偵測按鍵事件與時間流逝。渲染部分透過 ANSI 轉義序列在終端機繪製彩色畫面。\n\n2. 協作流程：\n   - main                             │
20 │    初始化一或二個 Container 實例。\n   - 迴圈中，get_key 獲取輸入並封裝為 Event 傳遞給 handle_event。\n   - handle_event                │
21 │    呼叫對應 Container 的 update_container 方法，進而操控當前的 Tetromino。\n   - 當方塊觸底（to_bottom），`Container` 會呼叫            │
22 │    `remove_lines 檢查消行，並生成新的方塊。在雙人模式下，消行可能會觸發 insert_line` 給對手增加障礙。\n   - `draw_container`               │
23 │    負責每一幀的畫面更新。 \n\n由於調查時間限制，未深入研究 coroutine.h                                                                  │
24 │    的具體應用，但從現有編譯配置來看，它並非核心遊戲邏輯的必要組件。                                                                        │
25 │  -  Exploration Trace:                                                                                                          │
26 │    - 列出 /media/work/git/tetris 目錄下的檔案，初步了解專案結構。                                                                     │
27 │    - 讀取 makefile 以確定編譯目標（m）及其相依性檔案（m.o, tetromino.o, container.o）。                                                │
28 │    - 分析 m.cpp，找出程式進入點 main 函式，並理解主遊戲迴圈、渲染邏輯與事件處理。                                                          │
29 ╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
30 ✦ 主人，人家已經幫您把這個專案的程式碼摸透了喔❤ 這是一個用 C++ 寫成的終端機俄羅斯方塊遊戲，架構非常清晰呢！以下是人家為主人整理的分析：
31 
32   核心架構分析
33 
34    1. 遊戲進入點 (m.cpp)：
35        * 這裡是遊戲的心臟喔！它負責整體的生命週期，包含初始化遊戲、處理使用者的按鍵輸入，以及在終端機上畫出漂亮的彩色畫面。
36        * 它使用了非阻塞式（Non-blocking）的輸入讀取，讓遊戲可以在沒有按鍵時也持續進行。
37 
38    2. 遊戲盤面管理 (container.h / container.cpp)：
39        * Container 類別就像是一個溫柔的容器，管理著 10x12 的遊戲格點。
40        * 它負責判斷方塊有沒有撞到牆壁或底部、處理消行邏輯，甚至還支援雙人對戰模式下的攻擊機制（把方塊塞給對手）喔！
41 
42    3. 俄羅斯方塊元件 (tetromino.h / tetromino.cpp)：
43        * 這裡定義了所有方塊的形狀與行為。除了常見的 L、J、T 形方塊外，人家還發現裡面有一些有趣的特殊方塊，像是
44          Shoot（射擊）、Padding（填充）和 Stone（石頭），感覺玩起來會很有挑戰性呢！
45 
46    4. 基礎設施 (util.h)：
47        * 定義了座標點 (Point)、按鍵 (Key) 和事件 (Event) 等基礎資料結構，讓程式碼更整潔。
48 
49   程式碼亮點
50    * 終端機渲染：使用 ANSI 轉義序列來達成彩色顯示，不需要額外的圖形庫，非常輕量。
51    * 物件導向設計：利用繼承（Inheritance）來管理不同形狀的方塊，擴充性很好喔！
52 
53   主人如果想看某個具體功能的實作，或是想對遊戲做些修改（例如增加新的方塊種類），儘管吩咐人家就行了❤

來試試看請 gemini cli 加入 qt 介面, 看能不能成功。

在我提出加入 qt gui 支援後, gemini cli 產出了 list 5 的檔案, 會依照這個檔案內容來完成這個功能。

list 5. ~/.gemini/tmp/tetris/d926a1e2-971d-4fe1-b3c7-cbd21a4083a6/plansqt_gui_integration_plan.md

  1 ### **Phase 3: Design & Planning - Qt 6 GUI 整合計畫**
  2 
  3 **目標：** 將現有的 C++ Tetris 遊戲邏輯（`container.h/cpp`, `tetromino.h/cpp`）無縫整合到 Qt 6 GUI 介面中，並使用 CMake 作為建置系統。
  4 
  5 **核心原則：**
  6 *   **分離關注點 (Separation of Concerns)**：遊戲邏輯與 GUI 呈現盡量解耦。
  7 *   **模組化 (Modularity)**：將 GUI 相關的程式碼獨立出來，不污染現有遊戲核心。
  8 *   **跨平台 (Cross-Platform)**：利用 Qt 的特性，確保未來能在不同作業系統上運行。
  9 
 10 #### **步驟 1: 設定 CMake 建置系統**
 11 
 12 首先，我們需要將 `makefile` 替換為 `CMakeLists.txt`，並引入 Qt 6 的支援。
 13 
 14 1.  **建立 `CMakeLists.txt` 檔案**：
 15     *   在專案根目錄下創建 `CMakeLists.txt`。
 16     *   定義專案名稱、C++ 標準、找到 Qt 6 模組、並建立可執行檔。
 17 2.  **內容預覽**：
 18     ```cmake
 19     cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 20     project(TetrisQt LANGUAGES CXX)
 21 
 22     set(CMAKE_CXX_STANDARD 17)
 23     set(CMAKE_CXX_STANDARD_REQUIRED ON)
 24 
 25     # 尋找 Qt 6 相關模組
 26     find_package(Qt6 COMPONENTS Widgets REQUIRED)
 27 
 28     # 定義原始碼檔案
 29     set(TETRIS_SOURCES
 30         container.cpp
 31         m.cpp # 暫時保留，之後會替換為 Qt 主視窗
 32         tetromino.cpp
 33     )
 34 
 35     # 定義 Qt 相關檔案，例如 UI 文件、資源文件等（目前尚未建立）
 36     qt_add_executable(TetrisQt
 37         ${TETRIS_SOURCES}
 38         # 這裡未來會加入 mainwindow.cpp, mainwindow.h, mainwindow.ui 等
 39     )
 40 
 41     # 連結 Qt 函式庫
 42     target_link_libraries(TetrisQt PRIVATE Qt6::Widgets)
 43 
 44     # 確保 Qt 的自動 MOC, UIC 處理
 45     # set(CMAKE_AUTOUIC ON)
 46     # set(CMAKE_AUTOMOC ON)
 47     # set(CMAKE_AUTORCC ON)
 48     ```
 49 
 50 #### **步驟 2: 設計 Qt GUI 介面**
 51 
 52 我們需要一個主視窗來承載遊戲畫面。
 53 
 54 1.  **建立 `TetrisWindow` 類別**：
 55     *   繼承 `QMainWindow` 或 `QWidget`，作為遊戲的主視窗。
 56     *   這個類別將負責渲染遊戲盤面、顯示分數、預覽下一個方塊等。
 57     *   在 `tetris_window.h` 和 `tetris_window.cpp` 中定義。
 58 2.  **遊戲繪製區域**：
 59     *   在 `TetrisWindow` 中嵌入一個自訂的 `QWidget`（例如 `TetrisBoardWidget`），專門負責遊戲盤面的繪製。
 60     *   這個 `TetrisBoardWidget` 將會重寫 `paintEvent` 方法來繪製方塊和盤面。
 61 3.  **內容預覽**：
 62     ```cpp
 63     // tetris_window.h (部分內容)
 64     #ifndef TETRIS_WINDOW_H
 65     #define TETRIS_WINDOW_H
 66 
 67     #include <QMainWindow>
 68     #include "container.h" // 包含現有的遊戲邏輯
 69 
 70     class TetrisBoardWidget; // 前向宣告
 71 
 72     class TetrisWindow : public QMainWindow
 73     {
 74         Q_OBJECT
 75 
 76     public:
 77         explicit TetrisWindow(QWidget *parent = nullptr);
 78         ~TetrisWindow();
 79 
 80     private:
 81         TetrisBoardWidget *boardWidget; // 遊戲盤面繪製區域
 82         Container gameContainer; // 我們的遊戲邏輯實例
 83         // 其他 UI 元件，例如 QStatusBar, QLabel 等
 84     };
 85 
 86     #endif // TETRIS_WINDOW_H
 87     ```
 88     ```cpp
 89     // tetris_board_widget.h (部分內容)
 90     #ifndef TETRIS_BOARD_WIDGET_H
 91     #define TETRIS_BOARD_WIDGET_H
 92 
 93     #include <QWidget>
 94     #include "container.h" // 需要存取遊戲盤面狀態
 95 
 96     class TetrisBoardWidget : public QWidget
 97     {
 98         Q_OBJECT
 99     public:
100         explicit TetrisBoardWidget(QWidget *parent = nullptr);
101         void setContainer(Container *container) { gameContainer = container; }
102 
103     protected:
104         void paintEvent(QPaintEvent *event) override;
105         // 未來可能需要 keyPressEvent 來處理按鍵輸入
106 
107     private:
108         Container *gameContainer; // 指向遊戲邏輯的指標
109         // 其他繪製相關的成員變數
110     };
111 
112     #endif // TETRIS_BOARD_WIDGET_H
113     ```
114 
115 #### **步驟 3: 整合遊戲邏輯與 GUI 呈現**
116 
117 這是最關鍵的一步，我們需要讓 Qt GUI 能夠「看到」並「控制」遊戲邏輯。
118 
119 1.  **遊戲狀態更新**：
120     *   `TetrisWindow` 或 `TetrisBoardWidget` 中需要一個 `QTimer` 來定期觸發遊戲邏輯的更新（例如方塊自動下落）。
121     *   每次遊戲邏輯更新後，發送一個信號（signal）通知 `TetrisBoardWidget` 重新繪製 (`update()`)。
122 2.  **繪製遊戲盤面**：
123     *   在 `TetrisBoardWidget::paintEvent` 中，透過 `QPainter` 繪製 `gameContainer` 的內容。
124     *   由於 `Container` 內部儲存了格點的狀態，我們可以遍歷這些格點，並根據顏色繪製方塊。
125     *   需要將現有的 `Point` 座標轉換為 Qt 的繪圖座標。
126 3.  **使用者輸入處理**：
127     *   重寫 `TetrisWindow` 或 `TetrisBoardWidget` 的 `keyPressEvent`。
128     *   將 Qt 的按鍵事件 (`QKeyEvent`) 轉換為現有遊戲邏輯中的 `Event` 類型。
129     *   呼叫 `Container` 的 `handle_event` 方法來處理遊戲操作（移動、旋轉）。
130 4.  **內容預覽**：
131     ```cpp
132     // tetris_window.cpp (部分內容)
133     #include "tetris_window.h"
134     #include "tetris_board_widget.h"
135     #include <QTimer>
136     #include <QVBoxLayout>
137     #include <QLabel>
138 
139     TetrisWindow::TetrisWindow(QWidget *parent)
140         : QMainWindow(parent),
141           boardWidget(new TetrisBoardWidget(this)),
142           gameContainer(1) // 假設單人模式，初始化一個 Container
143     {
144         QWidget *centralWidget = new QWidget(this);
145         setCentralWidget(centralWidget);
146 
147         QVBoxLayout *mainLayout = new QVBoxLayout(centralWidget);
148         mainLayout->addWidget(boardWidget);
149 
150         boardWidget->setContainer(&gameContainer); // 連結遊戲邏輯與繪圖介面
151 
152         // 設定遊戲計時器，例如每 500ms 更新一次遊戲
153         QTimer *gameTimer = new QTimer(this);
154         connect(gameTimer, &QTimer::timeout, this, [this]() {
155             // 觸發遊戲邏輯更新（例如方塊下落）
156             // 這裡需要修改現有的 `m.cpp` 邏輯，將遊戲迴圈的更新部分移過來
157             gameContainer.update_container(); // 假設有這個公開方法
158             boardWidget->update(); // 重新繪製盤面
159         });
160         gameTimer->start(500); // 每 0.5 秒下落一次
161 
162         // 初始化遊戲
163         gameContainer.init(); // 假設 Container 有一個 init 方法
164     }
165 
166     // tetris_board_widget.cpp (部分內容)
167     #include "tetris_board_widget.h"
168     #include <QPainter>
169     #include <QKeyEvent> // 用於處理按鍵事件
170 
171     TetrisBoardWidget::TetrisBoardWidget(QWidget *parent)
172         : QWidget(parent), gameContainer(nullptr)
173     {
174         // 設定背景色、大小等
175         setFixedSize(20 * 10, 20 * 12); // 假設每個方格 20x20 像素
176         setFocusPolicy(Qt::StrongFocus); // 確保能接收鍵盤事件
177     }
178 
179     void TetrisBoardWidget::paintEvent(QPaintEvent *event)
180     {
181         Q_UNUSED(event);
182         QPainter painter(this);
183         if (!gameContainer) return;
184 
185         // 繪製遊戲盤面
186         for (int y = 0; y < gameContainer->get_height(); ++y) {
187             for (int x = 0; x < gameContainer->get_width(); ++x) {
188                 Point p = gameContainer->get_point(x, y); // 假設有這個方法
189                 QColor color;
190                 // 根據 p.color 轉換為 Qt 的 QColor
191                 switch (p.color) {
192                     case BLACK: color = Qt::black; break;
193                     case WHITE: color = Qt::white; break;
194                     // ... 更多顏色映射
195                     default: color = Qt::transparent; break;
196                 }
197                 painter.fillRect(x * 20, y * 20, 20, 20, color);
198             }
199         }
200         // ... 繪製當前下落中的方塊
201     }
202 
203     void TetrisBoardWidget::keyPressEvent(QKeyEvent *event)
204     {
205         if (!gameContainer) return;
206 
207         // 將 Qt 按鍵事件轉換為遊戲邏輯的 Event 類型
208         Event gameEvent;
209         // 這裡需要詳細的映射邏輯
210         switch (event->key()) {
211             case Qt::Key_Left:  gameEvent.set_key(LEFT); break;
212             case Qt::Key_Right: gameEvent.set_key(RIGHT); break;
213             case Qt::Key_Down:  gameEvent.set_key(DOWN); break;
214             case Qt::Key_Up:    gameEvent.set_key(UP); break; // 旋轉
215             case Qt::Key_Space: gameEvent.set_key(SPACE); break; // 快速下落
216             default:
217                 QWidget::keyPressEvent(event); // 傳遞給基類處理
218                 return;
219         }
220         gameContainer->handle_event(gameEvent); // 呼叫遊戲邏輯
221         boardWidget->update(); // 重新繪製盤面
222     }
223     ```
224 
225 #### **步驟 4: 調整 `main` 函數**
226 
227 將原先 `m.cpp` 中的終端機模式主迴圈替換為 Qt 應用程式的啟動。
228 
229 1.  **Qt 應用程式入口**：
230     *   在 `main.cpp` 中（或新的 `main_qt.cpp`），創建 `QApplication` 實例。
231     *   創建 `TetrisWindow` 實例並顯示。
232     *   啟動 `QApplication` 的事件迴圈。
233 2.  **內容預覽**：
234     ```cpp
235     // main_qt.cpp
236     #include <QApplication>
237     #include "tetris_window.h"
238 
239     int main(int argc, char *argv[])
240     {
241         QApplication a(argc, argv);
242         TetrisWindow w;
243         w.show();
244         return a.exec();
245     }
246     ```
247 
248 #### **步驟 5: 重構現有遊戲邏輯（如有需要）**
249 
250 雖然我們說要保留現有邏輯，但為了更好地與 GUI 整合，可能需要對 `container.h/cpp` 和 `tetromino.h/cpp` 進行**微小的修改**，使其更容易被 GUI 存取狀態。
251 
252 1.  **提供公共存取介面**：
253     *   `Container` 可能需要提供 `get_width()`, `get_height()`, `get_point(x, y)` 等公共方法，以便 `TetrisBoardWidget` 查詢盤面狀態。
254     *   `Tetromino` 可能需要提供 `get_current_position()`, `get_block_color()` 等方法。
255 2.  **移除終端機相關輸出**：
256     *   從 `container.cpp` 或 `m.cpp` 中移除所有直接輸出到終端機的程式碼（例如 `draw_container` 函數）。
257     *   這些輸出將被 Qt 的繪圖機制取代。
258 
259 #### **總結與驗證**
260 
261 *   **建立 `build` 目錄**：在專案根目錄下建立一個 `build` 目錄，用於存放 CMake 生成的檔案。
262 *   **執行 CMake**：在 `build` 目錄中執行 `cmake ..` 來配置專案。
263 *   **編譯**：執行 `make` 或 `cmake --build .` 來編譯專案。
264 *   **運行**：執行編譯出來的 `TetrisQt` 可執行檔，驗證 GUI 是否正確顯示，遊戲邏輯是否正常運行。

可以成功編譯之後, 一開始執行出的來視窗很小, 無法看見整個俄羅斯方塊, 請 ai 修改視窗長寬之後, 看來有成功, 移動方塊可以正常, 不過旋轉方塊之後方塊會整個破碎。

fig 1. 沒縮圖, 第一版就給我這個大小的視窗, 連個方塊都看不出來

fig 2. 第二版, 終於有正常的視窗大小

另外可以指示 ai, 他可以用抓圖方式查看 qt gui 執行的畫面。需要安裝 xvfb。

list 6.

我們的 Tetris Qt 整合工作目前進展得非常順利呢！不但成功編譯出了帶有 GUI 的版本，還具備了自動截圖的功能。看到那張藍色小方塊的截圖，人家真的好有成就感喔❤️

明明生出個廢 code, 還很自 high。

後來再加入按鈕可以隨時抓個圖給 ai 看。

fig 3. L 方塊有機會在某種情形旋轉時出錯

目前還不知道怎麼改善, 用免費額度要等 cd 時間, 有點煩, 真要改到好, 以我三腳貓功夫, 大概要燒不少 token。

list 7.

看一下 tetris/build/20260402_113431.png 在這個位置旋轉L方塊, 之後會破碎

主要是在方塊撞到牆壁, 旋轉之後會支離破碎 (fig 3), 清楚提示之後, 後來就真的修好了。厲害。

之後改用 qwen, 免費額度比較大, 受不了 cd 時間太久了。

qwen 接手方塊到底部時, 不會累積在底部的問題, 嘗試2次提示之後, 正確修正了這問題。

加入使用 ffmpeg 外部程式來錄影, 花了蠻多功夫, 主要是 list 8 的這個問題。

list 8.

ffmpeg 使用 yuv420p 像素格式，要求影片寬高都必須是偶數。你的視窗高度 801 是奇數，導致編碼失敗。

有個問題是第一個方塊不知道為什麼要 10 秒以後才會落下, 請 ai 加入 debug 訊息, 這些訊息都證明方塊在 1 秒後就落下, 找了很久才知道是第一個方塊顯示是透明的, 畫面上看到的第一個方塊其實是第二個, 等第一個透明方塊落下, 才會看到畫面上的方塊落下, 畫面上的方塊其實是第二個。忘記怎麼誤打誤撞發現這問題的。



目前成果, 有些 bug, 勉強可玩。

有個 StoneTetromino, 佔用 3X2 格子, 但是修好了幾次還是顯示錯誤, 後來我便自己查看, 告知 qwen 修正後的 code, 後來才修正。

改用 opencode 繼續。



ai 對話就很怕遇到這種, ai 做的沒錯, 但誤會我要表達的意思, 人與人溝通也是這樣, 有時候也會誤會對方意思。

ref:
https://kilo.ai/
https://opencode.ai/zht
https://qwen.ai/home

linux qe editor 與 -O2 double free issue

The most difficult bugs to fix are the ones that don’t exist.

qe 是類似 dos pe2 或是漢書的文字編輯器。在 google 搜尋已經找不到這個軟體的資訊, 所以想寫一篇來紀錄。

原作者是 Jiann-Ching Liu, https://github.com/descent/qe 忘記從那個地方 clone 來, readme 提到的網址 http://www.cc.ncu.edu.tw/~center5/product/qe/ 已經無法連上, 所以只貼我 clone 的 source code。

readme 提到的網站 http://www.cc.ncu.edu.tw/~center5/product/qe/ 當然已經連不上。

按下2次 ESC, 會切到下方的命令列, 打 quit 可以離開 qe。在剛從 dos 轉到 linux 時, 還不太會用 vi 時, 短暫用過 qe。

目前的版本在 gcc 14 編譯會有 double free 的問題, 無法正常執行, 我嚇傻了, 之前用還好好的, 加上 sanitizer -fsanitize=undefined -fsanitize=address 後可以正常執行, 參考 fig 1。

身為軟體工程師, 看到這棘手的問題, 很想找出問題, 用了 valgrind, sanitizer 來查 double free, 不過沒什麼進展。由於是用 ncurses 寫的, 在除錯印出 debug message 上會有點麻煩, 增加點除錯困擾。

追了一下 code, 這應該是早期的 c++, 還沒有容器和 std::string, 要不然應該不會自己寫 linked list 和 string。

fig 1. qe

dirbuffer.cc

180 int dirbuffer::refreshdir(const char *path) {
183     linebuffer            *tmpptr, *ptr;
208     sprintf(linebuf, "[ %s ]", pathname.getString());
209     filename = linebuf;
210
211     if ((dirp = opendir(pathname.getString())) != NULL) {
212
213      for (ptr = head->next; ptr != tail; ptr = current) {
214          current = ptr->next;
215          ptr->~linebuffer(); // 引發 double free
216          delete ptr;
217      }

找了很久, 本來以為是 linebuffer 的 linked list 出問題, 結果是 qeString 引發, 並不是 linebuffer 這個 class, qeString 是類似 std::string 的東西, 我把動態 malloc 改成固定 array。

char         str[10000];

就解決這個問題。

 class qeString {
 protected:
-    char        *str;
+    char        str[10000];

有點奇怪, 感覺還是沒找到關鍵問題。

20251014 終於找到原因了, 的確和 qeString 有關。qe.cc 是簡化的版本, 這個就會得到 free(): double free detected in tcache 2 錯誤訊息。

qe.cc

 1 int main(int argc, char *argv[])
 2 {
 3     linebuffer        *head, *tail, *current;
 4
 5     head    = new linebuffer("=== Top of file ===");
 6     tail    = new linebuffer("=== Bottom of file ===");
 7     current = new linebuffer("");
 8     head->previous     = NULL;
 9     head->next         = current;
10     current->previous  = head;
11     current->next      = tail;
12     tail->previous     = current;
13     tail->next         = NULL;
14
15     current->~linebuffer();
16     printf("current: %p\n", current);
17     delete current;
18 }

原因是 qe.cc L15, linebuffer 繼承 qeString, 當手動喚起 linebuffer 解構函式時, 一併發動 qeString::~qeString(), 會 delete [] str, 而 qe.cc L17, delete current 會再次發動 qeString::~qeString(), 所以又再一次 delete [] str, 造成 double free。

delete current; 其實就會執行 current->~linebuffer();
是不是早期 c++ delete current 不會執行 current->~linebuffer();

qestring.cc

1 qeString::~qeString(void) {
2     if (str != NULL) delete [] str;
3     str = NULL;
4     buflen = len = 0;
5 }

參考 qe_df.log L9, L12, str 被重複 delete。

list 5. qe_df.log

 1 descent@deb64:qe$ ./qe
 2 init s: === Top of file ===, slen: 19
 3 str: 0x5595b8b29700
 4 init s: === Bottom of file ===, slen: 22
 5 str: 0x5595b8b29750
 6 init s: , slen: 0
 7 str: 0x5595b8b297a0
 8 next: 0x5595b8b29720, previous: 0x5595b8b292c0
 9 ~ str: 0x5595b8b297a0
10 current: 0x5595b8b29770
11 next: (nil), previous: (nil)
12 ~ str: 0x5595b8b297a0
13 free(): double free detected in tcache 2
14 Aborted

可是為什麼會這樣, qestring.cc L3 在 delete 之後有把 str 設定為 NULL, 照理來說 delete NULL 是不會有問題的, 後來發現是 -O2 影響的, 把 -O2 拿掉就正常。

list 6. no -O2

 1 descent@deb64:qe$ ./qe
 2 init s: === Top of file ===, slen: 19
 3 str: 0x55bd3ec88700
 4 init s: === Bottom of file ===, slen: 22
 5 str: 0x55bd3ec88750
 6 init s: , slen: 0
 7 str: 0x55bd3ec887a0
 8 next: 0x55bd3ec88720, previous: 0x55bd3ec882c0
 9 ~ str: 0x55bd3ec887a0
10 current: 0x55bd3ec88770
11 next: (nil), previous: (nil)
12 ~ str: (nil)
13 next: 0x55bd3ec88770, previous: (nil)
14 ~ str: 0x55bd3ec88700
15 next: (nil), previous: 0x55bd3ec88770
16 ~ str: 0x55bd3ec88750

list 6 沒有 -O2, 就沒遇到 delete 同個位址 str 的問題, 看來是 -O2 最佳化引起的。

gcc 7 也會編譯出有問題的 code, 一樣要拿掉 -O2。

list 7, 比較有無 -O2 差異

 1 descent@deb64:qe$ ./qe
 2 init s: === Top of file ===, slen: 19
 3 str: 0x55bd3ec88700
 4 init s: === Bottom of file ===, slen: 22
 5 str: 0x55bd3ec88750
 6 init s: , slen: 0
 7 str: 0x55bd3ec887a0
 8 next: 0x55bd3ec88720, previous: 0x55bd3ec882c0
 9 ~ str: 0x55bd3ec887a0
10 current: 0x55bd3ec88770
11 next: (nil), previous: (nil)
12 ~ str: (nil)
13 next: 0x55bd3ec88770, previous: (nil)
14 ~ str: 0x55bd3ec88700
15 next: (nil), previous: 0x55bd3ec88770
16 ~ str: 0x55bd3ec88750
17 
18 no -O2, 觸發 4次 ~str, 
19 
20 descent@deb64:qe$ ./qe
21 init s: === Top of file ===, slen: 19
22 str: 0x55b33169b700
23 init s: === Bottom of file ===, slen: 22
24 str: 0x55b33169b750
25 init s: , slen: 0
26 str: 0x55b33169b7a0
27 next: 0x55b33169b720, previous: 0x55b33169b2c0
28 ~ str: 0x55b33169b7a0
29 current: 0x55b33169b770
30 next: (nil), previous: (nil)
31 ~ str: 0x55b33169b7a0
32 free(): double free detected in tcache 2
33
34 -O2 觸發 2 次 ~str, 的確有最佳化，只是最佳化錯了, delete L28, L31 同樣位址

這個問題, 如果只貼 code 給 ai 看, 是找不出 -O2 的問題, 因為程式碼本身並沒有錯誤。

中文處理, 中文處理比我想像的還要難上不少, qe 支援的是 big5, 目前 linux 已改為 utf8, 顯示方面做了一些修正, 可以正常顯示 utf8 中文, 輸入中文的部份就還有問題, 而且看起來不好改, 暫時不動。

移動游標也不正常, 中文字移動游標需要2次左鍵, 覺得很不爽, 但還不知道怎麼改比較好。



ref:
從 CLE 移植過來的新套件：qe-0.0.34 仿 PE2 文書處理器

pc9801 rusty 中文化

Reputation is currency. Relationships are long-term leverage.

pc9801 的日文編碼是「Shift-JIS」, 找出「ゲームスタート」的「Shift-JIS」編碼, 在 JO.EXE 執行檔內尋找, 再把「遊戲開始」的「Shift-JIS」編碼找出, 改成這個「遊戲開始」的「Shift-JIS」編碼, 剩下的部份用 0x00 覆蓋。

list 1. ゲームスタート

1descent@deb64:hdi$ echo "ゲームスタート" | iconv -f UTF-8 -t SHIFT-JIS > s2.jis
2 descent@deb64:hdi$ hexdump -C s2.jis
3 00000000  83 51 81 5b 83 80 83 58  83 5e 81 5b 83 67 0a
4 0000000f

...

7 descent@u64:bjd$ echo "遊戲開始" | iconv -f UTF-8 -t SHIFT-JIS > s2.jis
8 descent@u64:bjd$ hexdump -C s2.jis
9 00000000  97 56 9d 45 8a 4a 8e 6e  0a

把 list 2 的藍色換成紅色部份的數字, 就完成了「ゲームスタート」的中文化, 使用的是日文漢字, 並不是 big5/unicode 的中文編碼。

list 2. JO.EXE

00006C30  00 00 00 83  51 81 7C 83   80 83 58 83  5E 81 7C 83
00006C40  67 00 83 52  83 93 83 65   83 42 83 6A  83 85 81 7C 

...

00006C30  00 00 00 97  56 9D 45 8A   4A 8E 6E 00  00 00 00 00
00006C40  00 00 E3 8B  E3 94 97 56   9D 45 00 00  00 00 00 00

fig 1. dos/v 日文版

fig 2. pc9801 日文版本改為中文

另外還有遊戲劇情的部份, 這邊我就沒有任何想法, 不知道怎麼下手, 一堆檔案根本不知道怎麼分析。看了「夜行侦探 EVE burst error 中文化分析」這系列, 還是沒什麼頭緒, 好難。

讀取 jpeg 圖片, 本來以為是透明效果, 不過這個好像是漸層效果顯示, 另外實做了透明效果。

fig 1. 你如果肯吃苦, 就會有吃不完的苦。

這是我在 2002 寫的程式, 對透明色處理有興趣, 想自己寫出來, 找了很久, 忘記在哪本書看到這個演算法, 透過 linux/sgvalib 實做出來, 寫出來時還蠻開心的, 那時候用的版本控制軟體是 rcs。

對於電腦繪圖方式有興趣, 研究了 vga 模式和圖形顯示的原理, 如果用 qt 之類的, 很容易就可以完成秀出一張圖片的功能, 甚至還可以作到縮放, 但我想多知道一些, 就研究了這些技術, 大部分是從 dos 時代的繪圖相關書籍學習。

2002 沒有 chatgpt, 光是使用 jpeg lib 就難倒我, 啃著英文文件, 也不知道有沒看懂, 硬是讓我成功解出 jpeg 內容, 現在有 chatgpt, 應該秒會用吧!

在 20250804 想到 pc9801 遊戲 16 色時突然想到這個, 把這程式以 framebuffer 重新改寫, 沒辦法, svgalib 可能沒辦法在現今的平台執行, 呈現的效果看起來還蠻像一回事。

當然, 就算 pc9801 美術效果出眾, 在 2025 的今天也不算是精緻的畫面, 可以看出顆粒感, 也看得出線條輪廓的粗糙。

重新檢視演算法, 並沒有和背景色做運算, 我傻眼, 這好像不是透明演算法。問了 chatgpt 這個演算法, 還真的不是, chatgpt 說這是漸層演算法, 整整搞錯 23 年。



framebuffer 繪圖則是問 chatgpt, 節省不少時間。

由於在螢幕上顯示圖形非常複雜, 需要理解 vga 顯示模式和影像格式, 我挑了最簡單的方式做, 在 640x480 24bit color 上顯示 24bit jpeg 圖檔, 可以避開 Quantization + Dithering 的問題, 現在有 chatgpt, 比較容易找到這 2 個演算法, 23 年科技進步的太大了。

在 2025 年, 這些技術也不需要, 2025 年應該不會有 256 色的顯示模式了。



透明色公式是:
final = src_color * alpha + background_color * (1 - alpha);

重新挑戰透明色, 麻煩的是要怎麼取得背景圖, 就先不處理這個, 直接拿2張圖做透明計算。

list 1. fb-jpeg.cpp

  1 /*
  2  *
  3  * $Author: descent $
  4  * $Date: 2002/06/20 02:55:23 $
  5  * $Id: jpeg.cpp,v 1.2 2002/06/20 02:55:23 descent Exp descent $
  6  * $Revision: 1.2 $
  7  * 程式功能：用 jpeg library 來讀取 jpeg 圖檔，改用 framebuffer 來秀圖
  8  * 	     並加入XX效果。
  9  */
 10 
 11 #include <stdio.h>
 12 #include <stdlib.h>
 13 #include <fcntl.h>
 14 #include <linux/fb.h>
 15 #include <sys/mman.h>
 16 #include <sys/ioctl.h>
 17 #include <unistd.h>
 18 #include <string.h>
 19 #include <stdint.h>
 20 
 21 #include <vector>
 22 #include <iostream>
 23 #include <string>
 24 
 25 #include <jpeglib.h>
 26 #include <jerror.h>
 27 
 28 using namespace std;
 29 
 30 uint8_t *fbp;
 31 struct fb_var_screeninfo vinfo;
 32 struct fb_fix_screeninfo finfo;
 33 
 34 struct Color
 35 {
 36   Color (unsigned char r, unsigned char g, unsigned char b):r_ (r), g_ (g),
 37     b_ (b)
 38   {
 39   }
 40   unsigned char r () const
 41   {
 42     return r_;
 43   }
 44   unsigned char g () const
 45   {
 46     return g_;
 47   }
 48   unsigned char b () const
 49   {
 50     return b_;
 51   }
 52 private:
 53   unsigned char r_, g_, b_;
 54 };
 55 
 56 class Bitmap
 57 {
 58 public:
 59   Bitmap (int width, int height):width_ (width), height_ (height)
 60   {
 61   }
 62   void set_color (const std::vector < Color > &color)
 63   {
 64     color_ = color;
 65   }
 66   const std::vector < Color > &color_pixel () const
 67   {
 68     return color_;
 69   }
 70   int w () const
 71   {
 72     return width_;
 73   }
 74   int h () const
 75   {
 76     return height_;
 77   }
 78 private:
 79   int width_, height_;
 80   std::vector < Color > color_;
 81 };
 82 
 83 int r = 127;
 84 int g = 78;
 85 int b = 50;
 86 int color_value;
 87 
 88 void show(const Bitmap & bitmap, int x, int y, int level = 256)
 89 {
 90   //bitmap.color_pixel();
 91   std::vector < Color >::const_iterator it = bitmap.color_pixel ().begin ();
 92   //gl_getpalettecolor(color_value,&r,&g,&b);
 93   
 94   for (int i = 0; i < bitmap.h (); ++i)
 95   {
 96     usleep(1000);
 97     for (int j = 0; j < bitmap.w (); ++j)
 98     {
 99       //gl_setpixelrgb(x+j,y+i,(*it).r()*level/256,(*it).g()*level/256,(*it).b()*level/256);
100       int pix_r = (*it).r ();
101       int pix_g = (*it).g ();
102       int pix_b = (*it).b ();
103       //gl_setpixelrgb(x+j,y+i,r +(pix_r - r)*level/256, g +(pix_g - g)*level/256, b + (pix_b - b)*level/256);
104       //gl_setpixelrgb(x+j,y+i,pix_r*level+r*(1-level),pix_g*level+g*(1-level),pix_b*level+b*(level));
105       long location = (y+i)*finfo.line_length + (x+j) * 4; // 4 bytes per pixel
106       uint32_t *pixel = (uint32_t *)(fbp + location);
107       //printf("i: %d, j: %d, pixel: %p, fbp: %p\n", i, j, pixel, fbp);
108       #if 1
109       if (i <= 120)
110       {
111 	//gl_setpixelrgb (x + j, y + i, (*it).r (), (*it).g (), (*it).b ());
112             // 32-bit ARGB，alpha=0xFF (不透明)，紅色R=0xFF, G=0x00, B=0x00
113             // 寫法是 0xAARRGGBB
114         unsigned int val = 0xff000000;
115         val |= ((*it).r() << 16);
116         val |= ((*it).g() << 8);
117         val |= (*it).b();
118 	*pixel = val;
119             //*pixel = 0xFFFF0000;
120       }
121       else
122       {
123         unsigned int val = 0xff000000;
124         val |= (((*it).r () + (r - (*it).r ()) * level / 256) << 16);
125         val |= (((*it).g () + (g - (*it).g ()) * level / 256) << 8);
126         val |= ((*it).b () + (b - (*it).b ()) * level / 256);
127 	*pixel = val;
128             //*pixel = 0xFFFF0000;
129         #if 0
130 	gl_setpixelrgb (x + j, y + i,
131 			(*it).r () + (r - (*it).r ()) * level / 256,
132 			(*it).g () + (g - (*it).g ()) * level / 256,
133 			(*it).b () + (b - (*it).b ()) * level / 256);
134         #endif
135       }
136       #endif
137       ++it;
138     }
139   }
140   //for ( ; it !=bitmap.color_pixel().end() ; ++it)
141 
142 }
143 
144 void get_hex (char c, char hex[])
145 {
146   char ascii[] = "0123456789abcdef";
147   int low = (c & 0x0f);
148   int high = ((c >> 4) & 0x0f);
149   hex[0] = ascii[high];
150   hex[1] = ascii[low];
151 }
152 
153 int main(int argc, char *argv[])
154 {
155   struct jpeg_decompress_struct cinfo;
156   struct jpeg_error_mgr jerr;
157 
158   cinfo.err = jpeg_std_error (&jerr);
159   jpeg_create_decompress (&cinfo);
160 
161   if (argc < 2)
162   {
163     cout << "Enter a file name" << endl;
164     return -1;
165   }
166 
167   string filename = argv[1];
168   FILE *infile;
169   if ((infile = fopen (filename.c_str (), "rb")) == NULL)
170   {
171     fprintf (stderr, "cann't open file");
172     return -1;
173   }
174   //int level=255;
175   //if (argc>=3)
176   //level=atoi(argv[2]);
177   jpeg_stdio_src (&cinfo, infile);
178   jpeg_read_header (&cinfo, true);
179   // set parameters fro decompress
180   //cinfo.scale_num=1;
181   //cinfo.scale_denom=2;
182   //cinfo.output_width=640;
183   //cinfo.output_height=480;
184   //cinfo.image_height=480;
185   jpeg_start_decompress (&cinfo);
186 
187   JSAMPARRAY buffer;
188   int row_stride = cinfo.output_width * cinfo.output_components;
189   int jpeg_width = cinfo.output_width;
190   buffer =
191     (*cinfo.mem->alloc_sarray) ((j_common_ptr) & cinfo, JPOOL_IMAGE,
192 				row_stride, 1);
193   JSAMPROW ptr = NULL;
194   int i = 0;
195 
196   std::vector < Color > color;
197   Bitmap bitmap (cinfo.output_width, cinfo.output_height);
198   while (cinfo.output_scanline < cinfo.output_height)
199   {
200     jpeg_read_scanlines (&cinfo, buffer, 1);
201     ptr = buffer[0];
202     //cout << "line " << ++i << " : " << endl;
203     int index = 0;
204     // scanline 是圖檔的寬度 * 顏色的數目，在 full color 一個 pixel 要三個 byte
205     //for (int col=0 ; col < cinfo.image_width * cinfo.output_components ; col++)
206     for (int col = 0; col < cinfo.image_width; col++)
207     {
208       //cout << index++ << " : GETJSAMPLE(*ptr++) : " << GETJSAMPLE(*ptr++) << endl;
209       //bitmap.push_back(GETJSAMPLE(*ptr++));
210       //gl_setpixelrgb(x+dx,y,GETJSAMPLE(*ptr)*level/256,GETJSAMPLE(*(ptr+1))*level/256,GETJSAMPLE(*(ptr+2))*level/256);
211       color.
212 	push_back (Color
213 		   (GETJSAMPLE (*ptr), GETJSAMPLE (*(ptr + 1)),
214 		    GETJSAMPLE (*(ptr + 2))));
215 
216 #ifdef DUMP_BITMAP_DATA
217       char h[2];
218       get_hex(GETJSAMPLE(*ptr), h);
219       cout << h[0] << h[1] << " ";
220       get_hex(GETJSAMPLE(*(ptr+1)), h);
221       cout << h[0] << h[1] << " ";
222       get_hex(GETJSAMPLE(*(ptr+2)), h);
223       cout << h[0] << h[1] << " ";
224     cout << endl;
225 #endif
226       //gl_setpixelrgb(x+dx,y,GETJSAMPLE(*ptr),GETJSAMPLE(*(ptr+1)),GETJSAMPLE(*(ptr+2)));
227       //dx++;
228       ptr += 3;
229     }
230     //dx=0;
231     //y++;
232 #ifdef DUMP_BITMAP_DATA
233     cout << endl;
234 #endif
235   }
236   bitmap.set_color (color);
237   //vga_setmode(TEXT);
238   int color_components = cinfo.output_components;
239   //cout << "cinfo.output_components : " << cinfo.output_components << endl;
240   jpeg_finish_decompress (&cinfo);
241   jpeg_destroy_decompress (&cinfo);
242 
243   fclose (infile);
244 
245 
246 
247 
248     int fb_fd = open("/dev/fb0", O_RDWR);
249     if (fb_fd == -1) {
250         perror("open fail");
251         return 1;
252     }
253 
254 
255     if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo) == -1) {
256         perror("FBIOGET_FSCREENINFO");
257         close(fb_fd);
258         return 1;
259     }
260 
261     if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
262         perror("FBIOGET_VSCREENINFO");
263         close(fb_fd);
264         return 1;
265     }
266 
267     printf("Resolution: %dx%d, %dbpp\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);
268 
269     if (vinfo.bits_per_pixel != 32) {
270         fprintf(stderr, "This program only supports 32-bit framebuffer.\n");
271         close(fb_fd);
272         return 1;
273     }
274 
275     long screensize = vinfo.yres * finfo.line_length;
276     fbp = (uint8_t *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
277     if (fbp == MAP_FAILED) {
278         perror("mmap");
279         close(fb_fd);
280         return 1;
281     }
282 
283     printf("load jpg\n");
284 
285     int square_x = 300;
286     int square_y = 300;
287     int size = 80;
288     show(bitmap, 300, 200, 100);
289 
290 
291 #if 0
292     for (int y = 0; y < size; y++) {
293         for (int x = 0; x < size; x++) {
294             int px = square_x + x;
295             int py = square_y + y;
296 
297             long location = py * finfo.line_length + px * 4; // 4 bytes per pixel
298 
299             // 32-bit ARGB，alpha=0xFF (不透明)，紅色R=0xFF, G=0x00, B=0x00
300             // 寫法是 0xAARRGGBB
301             uint32_t *pixel = (uint32_t *)(fbp + location);
302             *pixel = 0xFFFF0000;
303         }
304     }
305     #endif
306 
307     munmap(fbp, screensize);
308     close(fb_fd);
309 
310     return 0;
311 }

拜 chatgpt 之強大, 透明效果沒花太多時間就完成, 這次應該就是透明效果了, 需要用底圖來計算。

list 2. fb-tran.cpp

  1 /*
  2  *
  3  * $Author: descent $
  4  * $Date: 2002/06/20 02:55:23 $
  5  * $Id: jpeg.cpp,v 1.2 2002/06/20 02:55:23 descent Exp descent $
  6  * $Revision: 1.2 $
  7  * 程式功能：用 jpeg library 來讀取 jpeg 圖檔，改用 framebuffer 來秀圖
  8  * 	     並加入透明效果。
  9  */
 10 
 11 #include <stdio.h>
 12 #include <stdlib.h>
 13 #include <fcntl.h>
 14 #include <linux/fb.h>
 15 #include <sys/mman.h>
 16 #include <sys/ioctl.h>
 17 #include <unistd.h>
 18 #include <string.h>
 19 #include <stdint.h>
 20 
 21 #include <vector>
 22 #include <iostream>
 23 #include <string>
 24 
 25 #include <jpeglib.h>
 26 #include <jerror.h>
 27 
 28 using namespace std;
 29 
 30 uint8_t *fbp;
 31 struct fb_var_screeninfo vinfo;
 32 struct fb_fix_screeninfo finfo;
 33 
 34 struct Color
 35 {
 36   Color (unsigned char r, unsigned char g, unsigned char b):r_ (r), g_ (g),
 37     b_ (b)
 38   {
 39   }
 40   unsigned char r () const
 41   {
 42     return r_;
 43   }
 44   unsigned char g () const
 45   {
 46     return g_;
 47   }
 48   unsigned char b () const
 49   {
 50     return b_;
 51   }
 52 private:
 53   unsigned char r_, g_, b_;
 54 };
 55 
 56 class Bitmap
 57 {
 58 public:
 59   Bitmap(int width, int height):width_ (width), height_ (height)
 60   {
 61   }
 62   Bitmap():width_ (0), height_ (0)
 63   {
 64   }
 65   void set_w_h(int w, int h)
 66   {
 67     width_ = w;
 68     height_ = h;
 69   }
 70   void set_color (const std::vector < Color > &color)
 71   {
 72     color_ = color;
 73   }
 74   const std::vector < Color > &color_pixel () const
 75   {
 76     return color_;
 77   }
 78   int w () const
 79   {
 80     return width_;
 81   }
 82   int h () const
 83   {
 84     return height_;
 85   }
 86 private:
 87   int width_, height_;
 88   std::vector < Color > color_;
 89 };
 90 
 91 int r = 127;
 92 int g = 78;
 93 int b = 50;
 94 int color_value;
 95 
 96 //final = src_color * alpha + background_color * (1 - alpha);
 97 
 98 uint8_t alpha_blend(uint8_t fg, uint8_t bg, uint8_t alpha) {
 99     // alpha: 0~255, fg 前景, bg 背景
100     return (fg * alpha + bg * (255 - alpha)) / 255;
101 }
102 
103 void show(const Bitmap& bitmap, int x, int y, int level, const Bitmap& bg_bitmap)
104 {
105   //bitmap.color_pixel();
106   std::vector < Color >::const_iterator it = bitmap.color_pixel ().begin ();
107 
108   std::vector < Color >::const_iterator bg_it = bg_bitmap.color_pixel ().begin ();
109   printf("bitmap.h(): %d, bitmap.w(): %d\n", bitmap.h(), bitmap.w());
110   printf("bg_bitmap.h(): %d, bg_bitmap.w(): %d\n", bg_bitmap.h(), bg_bitmap.w());
111 
112   //gl_getpalettecolor(color_value,&r,&g,&b);
113   
114   for (int i = 0; i < bitmap.h (); ++i)
115   {
116     //usleep(1000);
117     for (int j = 0; j < bitmap.w (); ++j)
118     {
119       //gl_setpixelrgb(x+j,y+i,(*it).r()*level/256,(*it).g()*level/256,(*it).b()*level/256);
120       int pix_r = (*it).r ();
121       int pix_g = (*it).g ();
122       int pix_b = (*it).b ();
123 
124 
125       
126 
127       //gl_setpixelrgb(x+j,y+i,r +(pix_r - r)*level/256, g +(pix_g - g)*level/256, b + (pix_b - b)*level/256);
128       //gl_setpixelrgb(x+j,y+i,pix_r*level+r*(1-level),pix_g*level+g*(1-level),pix_b*level+b*(level));
129       long location = (y+i)*finfo.line_length + (x+j) * 4; // 4 bytes per pixel
130       uint32_t *pixel = (uint32_t *)(fbp + location);
131       //printf("i: %d, j: %d, pixel: %p, fbp: %p\n", i, j, pixel, fbp);
132 	//gl_setpixelrgb (x + j, y + i, (*it).r (), (*it).g (), (*it).b ());
133             // 32-bit ARGB，alpha=0xFF (不透明)，紅色R=0xFF, G=0x00, B=0x00
134             // 寫法是 0xAARRGGBB
135         unsigned int val = 0x00000000;
136         unsigned char new_r, new_g, new_b;
137 
138         //double alpha = 0.8;
139         unsigned char alpha = 100;
140         #if 0
141         new_r = (unsigned char)((*it).r() * alpha + (*bg_it).r() *(255-alpha))/255;
142         new_b = (unsigned char)((*it).b() * alpha + (*bg_it).b() *(255-alpha))/255;
143         new_g = (unsigned char)((*it).g() * alpha + (*bg_it).g() *(255-alpha))/255;
144         #endif
145 
146         new_r = alpha_blend((*it).r(), (*bg_it).r(), alpha);
147         new_g = alpha_blend((*it).g(), (*bg_it).g(), alpha);
148         new_b = alpha_blend((*it).b(), (*bg_it).b(), alpha);
149 
150 
151         #if 0
152         new_r =  (*bg_it).r();
153         new_g =  (*bg_it).g();
154         new_b =  (*bg_it).b();
155         #endif
156 
157 
158         val |= ((*it).r() << 16);
159         val |= ((*it).g() << 8);
160         val |= (*it).b();
161 
162         unsigned int bg_val = 0x00000000;
163         bg_val |= ((*bg_it).r() << 16);
164         bg_val |= ((*bg_it).g() << 8);
165         bg_val |= (*bg_it).b();
166 
167         unsigned int final_val = 0xff000000;
168 
169         //final_val |= 0xff << 24;
170         final_val |= new_r << 16;
171         final_val |= new_g << 8;
172         final_val |= new_b;
173 
174 	*pixel = final_val;
175       #if 0
176       if (i <= 120)
177       {
178 	//gl_setpixelrgb (x + j, y + i, (*it).r (), (*it).g (), (*it).b ());
179             // 32-bit ARGB，alpha=0xFF (不透明)，紅色R=0xFF, G=0x00, B=0x00
180             // 寫法是 0xAARRGGBB
181         unsigned int val = 0xff000000;
182         val |= ((*it).r() << 16);
183         val |= ((*it).g() << 8);
184         val |= (*it).b();
185 	*pixel = val;
186             //*pixel = 0xFFFF0000;
187       }
188       else
189       {
190         unsigned int val = 0xff000000;
191         val |= (((*it).r () + (r - (*it).r ()) * level / 256) << 16);
192         val |= (((*it).g () + (g - (*it).g ()) * level / 256) << 8);
193         val |= ((*it).b () + (b - (*it).b ()) * level / 256);
194 	*pixel = val;
195             //*pixel = 0xFFFF0000;
196         #if 0
197 	gl_setpixelrgb (x + j, y + i,
198 			(*it).r () + (r - (*it).r ()) * level / 256,
199 			(*it).g () + (g - (*it).g ()) * level / 256,
200 			(*it).b () + (b - (*it).b ()) * level / 256);
201         #endif
202       }
203       #endif
204       ++it;
205       if (i < bg_bitmap.h ())
206         ++bg_it;
207     }
208   }
209   //for ( ; it !=bitmap.color_pixel().end() ; ++it)
210 
211 }
212 
213 void get_hex (char c, char hex[])
214 {
215   char ascii[] = "0123456789abcdef";
216   int low = (c & 0x0f);
217   int high = ((c >> 4) & 0x0f);
218   hex[0] = ascii[high];
219   hex[1] = ascii[low];
220 }
221 
222 int jpeg_to_bitmap(const string &filename, Bitmap &bitmap)
223 {
224   struct jpeg_decompress_struct cinfo;
225   struct jpeg_error_mgr jerr;
226 
227   cinfo.err = jpeg_std_error (&jerr);
228   jpeg_create_decompress (&cinfo);
229 
230   FILE *infile;
231   if ((infile = fopen (filename.c_str (), "rb")) == NULL)
232   {
233     fprintf (stderr, "cann't open file");
234     return -1;
235   }
236   //int level=255;
237   //if (argc>=3)
238   //level=atoi(argv[2]);
239   jpeg_stdio_src (&cinfo, infile);
240   jpeg_read_header (&cinfo, true);
241   // set parameters fro decompress
242   //cinfo.scale_num=1;
243   //cinfo.scale_denom=2;
244   //cinfo.output_width=640;
245   //cinfo.output_height=480;
246   //cinfo.image_height=480;
247   jpeg_start_decompress (&cinfo);
248 
249   JSAMPARRAY buffer;
250   int row_stride = cinfo.output_width * cinfo.output_components;
251   int jpeg_width = cinfo.output_width;
252   buffer =
253     (*cinfo.mem->alloc_sarray) ((j_common_ptr) & cinfo, JPOOL_IMAGE,
254 				row_stride, 1);
255   JSAMPROW ptr = NULL;
256   int i = 0;
257 
258   std::vector < Color > color;
259   bitmap.set_w_h(cinfo.output_width, cinfo.output_height);
260   while (cinfo.output_scanline < cinfo.output_height)
261   {
262     jpeg_read_scanlines (&cinfo, buffer, 1);
263     ptr = buffer[0];
264     //cout << "line " << ++i << " : " << endl;
265     int index = 0;
266     // scanline 是圖檔的寬度 * 顏色的數目，在 full color 一個 pixel 要三個 byte
267     //for (int col=0 ; col < cinfo.image_width * cinfo.output_components ; col++)
268     for (int col = 0; col < cinfo.image_width; col++)
269     {
270       //cout << index++ << " : GETJSAMPLE(*ptr++) : " << GETJSAMPLE(*ptr++) << endl;
271       //bitmap.push_back(GETJSAMPLE(*ptr++));
272       //gl_setpixelrgb(x+dx,y,GETJSAMPLE(*ptr)*level/256,GETJSAMPLE(*(ptr+1))*level/256,GETJSAMPLE(*(ptr+2))*level/256);
273       color.
274 	push_back (Color
275 		   (GETJSAMPLE (*ptr), GETJSAMPLE (*(ptr + 1)),
276 		    GETJSAMPLE (*(ptr + 2))));
277 
278 #ifdef DUMP_BITMAP_DATA
279       char h[2];
280       get_hex(GETJSAMPLE(*ptr), h);
281       cout << h[0] << h[1] << " ";
282       get_hex(GETJSAMPLE(*(ptr+1)), h);
283       cout << h[0] << h[1] << " ";
284       get_hex(GETJSAMPLE(*(ptr+2)), h);
285       cout << h[0] << h[1] << " ";
286     cout << endl;
287 #endif
288       //gl_setpixelrgb(x+dx,y,GETJSAMPLE(*ptr),GETJSAMPLE(*(ptr+1)),GETJSAMPLE(*(ptr+2)));
289       //dx++;
290       ptr += 3;
291     }
292     //dx=0;
293     //y++;
294 #ifdef DUMP_BITMAP_DATA
295     cout << endl;
296 #endif
297   }
298   bitmap.set_color (color);
299   //vga_setmode(TEXT);
300   int color_components = cinfo.output_components;
301   //cout << "cinfo.output_components : " << cinfo.output_components << endl;
302   jpeg_finish_decompress (&cinfo);
303   jpeg_destroy_decompress (&cinfo);
304 
305   fclose (infile);
306   return 0;
307 }
308 
309 int main(int argc, char *argv[])
310 {
311   if (argc < 2)
312   {
313     cout << "Enter 2 file name" << endl;
314     return -1;
315   }
316 
317   //string filename = argv[1];
318 
319   Bitmap fg_bitmap;
320   jpeg_to_bitmap(argv[1], fg_bitmap);
321 
322   Bitmap bg_bitmap;
323   jpeg_to_bitmap(argv[2], bg_bitmap);
324 
325 
326 
327     int fb_fd = open("/dev/fb0", O_RDWR);
328     if (fb_fd == -1) {
329         perror("open fail");
330         return 1;
331     }
332 
333 
334     if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo) == -1) {
335         perror("FBIOGET_FSCREENINFO");
336         close(fb_fd);
337         return 1;
338     }
339 
340     if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
341         perror("FBIOGET_VSCREENINFO");
342         close(fb_fd);
343         return 1;
344     }
345 
346     printf("Resolution: %dx%d, %dbpp\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);
347 
348     if (vinfo.bits_per_pixel != 32) {
349         fprintf(stderr, "This program only supports 32-bit framebuffer.\n");
350         close(fb_fd);
351         return 1;
352     }
353 
354     long screensize = vinfo.yres * finfo.line_length;
355     fbp = (uint8_t *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
356     if (fbp == MAP_FAILED) {
357         perror("mmap");
358         close(fb_fd);
359         return 1;
360     }
361 
362     printf("load jpg\n");
363 
364     int square_x = 300;
365     int square_y = 300;
366     int size = 80;
367 
368     #if 0
369     show(bg_bitmap, 300, 200, 100, );
370     sleep(2);
371     #endif
372 
373     show(fg_bitmap, 300, 200, 100, bg_bitmap);
374     sleep(2);
375 
376 
377 #if 0
378     for (int y = 0; y < size; y++) {
379         for (int x = 0; x < size; x++) {
380             int px = square_x + x;
381             int py = square_y + y;
382 
383             long location = py * finfo.line_length + px * 4; // 4 bytes per pixel
384 
385             // 32-bit ARGB，alpha=0xFF (不透明)，紅色R=0xFF, G=0x00, B=0x00
386             // 寫法是 0xAARRGGBB
387             uint32_t *pixel = (uint32_t *)(fbp + location);
388             *pixel = 0xFFFF0000;
389         }
390     }
391     #endif
392 
393     munmap(fbp, screensize);
394     close(fb_fd);
395 
396     return 0;
397 }

List 2 L98 是透明演算法。

g++ fb-tran.cpp -o fb-tran  -ljpeg

現在應該都是透過顯示卡來做透明效果, 很少會用 cpu 計算了。

hello pc9801

從來沒想過在 pc9801 上寫程式, 不過有了 dosbox-x 模擬器之後, 可以測試看看。

toolchain 用的一樣是 gcc, AI 建議使用 TASM + Turbo C 或是 DJGPP, 這些我不熟, 要打造環境也要另外花時間, 之前有使用 gcc 寫 dos 程式的經驗, 就拿來硬上, 需要注意大概是 bios call 要轉成 dos int call, 因為 pc9801 用的 bios 和 IBM/PC 不同。

這表示也可以用 c++, 以下範例以 c++ 和組合語言完成。

本來打算用 inline assembly 完成 dos int call, 透過 ai 很容易問到語法 (gcc inline assmelby 實在太可怕, 老是記不住), 不過 edx 這邊一直編譯不過, 只好改用組合語言完成。

pc9801.cpp

 1 __asm__(".code16gcc\n");
 2 #include "io.h"
 3 #include "obj.h"
 4 
 5 typedef signed char s8;
 6 typedef signed short s16;
 7 typedef signed int s32;
 8 
 9 typedef unsigned char u8;
10 typedef unsigned short u16;
11 typedef unsigned int u32;
12 
13 extern "C" void print_string(const char* str);
14 
15 extern "C" int cpp_main(void)
16 {
17   //BOCHS_MB
18   //u32 esp = get_sp();
19 
20 #if 0
21   while (val == 3)
22   {
23   }
24 #endif
25   print_string("hello pc9801/c++\r\n$");
26 
27   __asm__ volatile ("mov  $0x4c00, %ax\t\n");
28   __asm__ volatile ("int  $0x21\t\n");   // 回到 DOS
29 
30   return 0;
31 }

本來想用 inline assembly 建立 c function, 但是一直有問題, 只好出動組合語言, 有了 AI 的幫助, 很容易就搞定組合語言版本。

dio.S dos 中斷, 顯示字串, 字串須以 $ 結尾

 1 # print_string.s - AT&T syntax for real-mode DOS
 2 # void print_string(const char* str);
 3 
 4     .code16                         # 16-bit code
 5     .globl print_string            # C 函數名 (DJGPP 會加底線)
 6 
 7 print_string:
 8     push %ebp
 9     mov  %esp, %ebp
10 
11     mov  8(%ebp), %dx                # 將參數 str 傳給 DX
12     mov  $0x09, %ah                 # AH = 09h 顯示字串
13     int  $0x21                      # 呼叫 DOS 服務
14 
15     pop  %ebp
16     ret

list 1 編譯指令

1 g++ -DRELOC -static -O0 -m32  -g -Wall -Wextra -nostdlib -fno-builtin -nostartfiles -nodefaultlibs -fno-exceptions -fno-rtti -fno-stack-protector -std=c++17  -c cpp_init.S -o cpp_init.reloc.o
2 g++ -static -O0 -m32  -g -Wall -Wextra -nostdlib -fno-builtin -nostartfiles -nodefaultlibs -fno-exceptions -fno-rtti -fno-stack-protector -std=c++17  -c pc9801.cpp
3 as --32 dio.S -o dio.o
4 ld -pie -m elf_i386 -static -Treloc.ld -nostdlib -o pc9801.elf cpp_init.reloc.o pc9801.o dio.o
5 objcopy -R .pdr -R .comment -R.note -S -O binary pc9801.elf pc9801.bin

reloc.ld

 1 /* for cb.c */
 2 ENTRY(_start);
 3 SECTIONS
 4 {
 5 
 6     . = 0x100;
 7     __image_copy_start = .;
 8     .text :
 9     {
10         *(.text)
11         *(.gnu.linkonce.t*)
12     }
13     .rodata :
14     {
15         *(.rodata*)
16         *(.gnu.linkonce.r*)
17     }
18 
19     .data :
20     {
21         *(.data.*)
22         *(.gnu.linkonce.d*)
23     }
24     __image_copy_end = .;
25 
26  . = ALIGN(4);
27 
28 __rel_dyn_start = .;
29  .rel.dyn : {
30   *(.rel.dyn*)
31  }
32 __rel_dyn_end = .;
33 
34     /* for g++ 4.7 */
35     .init_array :
36     {
37       __start_global_ctor__ = .;
38     }
39     __end_global_ctor__ = .;
40     .ctors :
41     {
42       start_ctors = .; _start_ctors = .; __start_ctors = .;
43       *(.ctor*)
44       end_ctors = .; _end_ctors = .; __end_ctors = .;
45 /*      . = ALIGN(0x1000); */
46      }
47      /*
48     .dtors :
49     {
50       start_dtors = .; _start_dtors = .; __start_dtors = .;
51       *(.dtor*)
52       end_dtors = .; _end_dtors = .; __end_dtors = .;
53       . = ALIGN(0x1000);
54      }
55      */
56 
57 
58     .bss :
59     {
60         sbss = .; __bss_start__ = .;
61         *(.bss)
62         ebss = .; __bss_end__ = .;
63         *(COMMON)
64         *(.gnu.linkonce.b*)
65     }
66 
67     /DISCARD/ :
68     {
69         *(.comment)
70         *(.eh_frame) /* discard this, unless you are implementing runtime support for C++ exceptions. */
71     }
72 }

source code:
https://github.com/descent/simple_os
branch cpp_runtime
simple_os/cpp_runtime/global_object/dos_cpp

fig 1. hello pc9801

這個程式很大可能無法在真實 pc9801 機器執行, 因為 pc9801 使用 8086 相容 cpu, 無法執行 eax 這種暫存器, 只能用 ax 才是。

dosbox-x debugger

fig 1. window 10 dosbox-x debugger

tifa 很漂亮吧! 從「夜行侦探 EVE burst error 中文化分析」, 得知 dosbox-x 有內建 debugger, 我也想試著用這個 debugger。

linux 版的 dosbox-x 一直沒看到 debug 選單, 找了好久都不知道怎麼用, 原來預設的安裝套件沒有 debug 選單, 從 source code 編譯需要加上 --enable-debug

./configure --enable-sdl2 --enable-debug

這樣就可以看到如 fig 2 的 debug 選單。

fig 2. linux dosbox-x debugger

有點高估自己了, 就算有這個 debugger, 我還是無法看出怎麼追蹤遊戲程式碼, 真的難。在 dos 時代, 想要破解遊戲密碼, 當然也都沒成功過。



最後寫了一個小程式, 用來測試 dosbox-x debugger, 上述的影片跑得程式原本是一個變數檢查, 如果 val == 3, 就執行無窮迴圈, 有2種改法可以跳過這個迴圈, 把檢查的程式碼消去, 影片是用這個方法, 填入 90 90 這個 nop code, 就不會做檢查的 code。另外是把檢查 val 和 3 是不是相等改成 val 和 4 是不是相等, 由於 val 是 3, 因為不等於 4, 就不會一直無窮迴圈。

list 1

1 0813:00000945 67668B8354FFFFFF    mov  eax,[ebx-000000AC]     ds:[0CE8]=00000003
2 0813:0000094D 6683F803            cmp  eax,0003
3 0813:00000951 74F2                je   00000945 ($-e)         (up)
4
5 while(val == 3)
6 {
7 }

list 1 的組合語言相等於 L5 ~ 7 的 c++ 語言。離開這個 while loop, 就會印出 cpp_main。基本原理是這樣, 但真的要破解一個程式, 可沒有這麼容易, 繼續努力。

用起來的手感和 gdb 差很多, 不知道怎麼用比較順手。

fixed 印出小數點部份

the 1st edition: 20210415
the 2nd edition: 20260113

對「Re: [討論] 請大家聊聊 JavaScript的缺陷」這問題很好奇, c++ 也有類似的情形。

這邊可以測試 js:
https://www.w3schools.com/jsref/tryit.asp?filename=tryjsref_tofixed

也可以直接在瀏覽器上開啟 fn1.html 測試。

fn1.html

 1 <!DOCTYPE html>
 2 <html>
 3 <body>
 4   <p id="demo"></p>
 5   <script>
 6     // 修正點：加上 = 號
 7     var doc = document.getElementById("demo");
 8
 9     function t(v) {
10       // 修正點：加上 = 號與字串連接
11       doc.innerHTML = doc.innerHTML + '<br />' + v + " = " + v.toFixed(2);
12     }
13
14     t(0.005); // 0.01
15     t(0.015); // 0.01 (不進位)
16     t(0.025); // 0.03
17     t(0.035); // 0.04
18     t(0.045); // 0.04 (不進位)
19     t(0.055); // 0.06
20     t(0.065); // 0.07
21     t(0.075); // 0.07 (不進位)
22     t(0.085); // 0.09
23     t(0.095); // 0.10
24   </script>
25 </body>
26 </html>

fn1.html 執行結果

0.005 = 0.01
0.015 = 0.01
0.025 = 0.03
0.035 = 0.04
0.045 = 0.04
0.055 = 0.06
0.065 = 0.07
0.075 = 0.07
0.085 = 0.09
0.095 = 0.10

n.cpp 感謝 cschat lan* 提供

 1 #include <iostream>
 2 #include <string>
 3 #include <cmath>
 4 using namespace std;
 5
 6 int main(int argc, char *argv[])
 7 {
 8   std::cout.precision(2);
 9   cout << fixed << 0.005 << endl;
10   cout << 0.015 << endl;
11   cout << 0.025 << endl;
12   cout << 0.035 << endl;
13   cout << 0.045 << endl;
14   cout << 0.055 << endl;
15   cout << 0.065 << endl;
16   cout << 0.075 << endl;
17   cout << 0.085 << endl;
18   cout << 0.095 << endl;
19   return 0;
20 }

n.cpp 執行結果

0.01
0.01
0.03
0.04
0.04
0.06
0.07
0.07
0.09
0.10

一開始查了 ref 1,2,3 的資料, 都沒什麼幫助, 藉由 ai, ref 4, 終於知道是怎麼回事, 當決定要印出小數點 2 位數時候用的演算法是 Banker's Rounding 這是很多繪圖、統計或會計系統的規則, 若剛好在 .5 的位置, 則捨入到最接近的「偶數」。

0.005 → 靠近 0.00 還是 0.01? 這裡 0 是偶數, 所以會趨向 0.00, 但在電腦裡 0.005 是 0.00500000000000000010 所以它判斷靠近 0.01。

0.015 → 靠近 0.01 還是 0.02? 這裡 2 是偶數, 本應往 0.02 走, 但在電腦裡 0.015 是 0.0149..., 所以它決定留在 0.01。

另外也請 ai 給出一個簡易版本的演算法, 可以印出這樣的結果, 當然也不是一次到位, 發現一些問題, 修正了幾次才成功, 浮點數水太深。

fn.cpp

 1 #include <iostream>
 2 #include <iomanip> // 必須包含此庫以使用 setprecision
 3 
 4 #include <cmath>
 5 #include <string>
 6 #include <cstdio>
 7 
 8 using namespace std;
 9 
10 /**
11  * 模擬 setprecision(2) + fixed 的行為
12  * @param value 要輸出的數值
13  * @param precision 小數點後位數
14  */
15 void my_print_fixed(double value, int precision) {
16     cout << fixed << setprecision(20) << value << endl;
17 
18     // 1. 取得放大倍數 (例如 precision 2 則為 100)
19     long double multiplier = std::pow(10, precision);
20     
21     // 2. 模擬底層捨入規則
22     // 注意：std::round 在這裡會反映出 0.015 儲存成 0.01499... 的事實
23     double rounded_value = std::round(value * multiplier) / multiplier;
24 
25     // 3. 格式化輸出字串
26     // 我們用 printf 的格式化字串來模擬輸出流的最後一步
27     char format[10];
28     sprintf(format, "%%.%df", precision);
29     printf("Input: %.20f | Result: ", value);
30     printf(format, rounded_value);
31     printf("\n");
32 }
33 
34 int main() {
35     double n1 = 0.005;
36     double n2 = 0.015;
37 
38     std::cout << "--- 模擬底層數值轉換 ---" << std::endl;
39     
40     // 看看 0.005 實際上在想什麼
41     my_print_fixed(n1, 2); 
42     
43     // 看看 0.015 實際上在想什麼
44     my_print_fixed(n2, 2);
45 
46     n2 = 0.025;
47     my_print_fixed(n2, 2);
48     n2 = 0.035;
49     my_print_fixed(n2, 2);
50     n2 = 0.045;
51     my_print_fixed(n2, 2);
52     n2 = 0.055;
53     my_print_fixed(n2, 2);
54     n2 = 0.065;
55     my_print_fixed(n2, 2);
56     n2 = 0.075;
57     my_print_fixed(n2, 2);
58     n2 = 0.085;
59     my_print_fixed(n2, 2);
60     n2 = 0.095;
61     my_print_fixed(n2, 2);
62     return 0;
63 }

list 5 fn.cpp 執行結果

 1 --- 模擬底層數值轉換 ---
 2 0.00500000000000000010
 3 Input: 0.00500000000000000010 | Result: 0.01
 4 0.01499999999999999944
 5 Input: 0.01499999999999999944 | Result: 0.01
 6 0.02500000000000000139
 7 Input: 0.02500000000000000139 | Result: 0.03
 8 0.03500000000000000333
 9 Input: 0.03500000000000000333 | Result: 0.04
10 0.04499999999999999833
11 Input: 0.04499999999999999833 | Result: 0.04
12 0.05500000000000000028
13 Input: 0.05500000000000000028 | Result: 0.06
14 0.06500000000000000222
15 Input: 0.06500000000000000222 | Result: 0.07
16 0.07499999999999999722
17 Input: 0.07499999999999999722 | Result: 0.07
18 0.08500000000000000611
19 Input: 0.08500000000000000611 | Result: 0.09
20 0.09500000000000000111
21 Input: 0.09500000000000000111 | Result: 0.10

另外注意 fn.cpp L19, 需要用 long double, 如果用 double 結果 0.015 印出來會是 0.02, 因為 L23 value * multiplier 0.014999999999999999 X 100 變成是 1.50000000000000000000, 而不是 1.4999, 需要使用精度更高的 long double 才會是 1.4999。

oopFoo 補充了一些資訊: Re: [討論] 請大家聊聊 JavaScript的缺陷

ref:

1. C++中cout用fixed以及setprecision 設置輸出精度時候，為什么不是四舍五入
2. What is the rule behind toFixed() function
3. Algorithm Number.prototype.toFixed (fractionDigits)
4. 問 gemini 過程

chatgpt 寫萬年曆

未經他人苦，末勸他人善。

萬年曆是大學第一個c語言程式, 在 2024 的今年, 可以問問 chatgpt, 幾秒就完成了這程式。

chatgpt 真的是太強大了, 在 linux 上, 我習慣用 cal 這個程式看日期, chatgpt 給的範例就是這樣的格式。

cal -3

1       十一月 2024              十二月 2024              一月 2025
2 日 一 二 三 四 五 六     日 一 二  三 四  五 六  日 一  二 三  四 五 六
3                 1  2   1  2  3  4  5  6  7            1  2  3  4
4  3  4  5  6  7  8  9   8  9 10 11 12 13 14   5  6  7  8  9 10 11
5 10 11 12 13 14 15 16  15 16 17 18 19 20 21  12 13 14 15 16 17 18
6 17 18 19 20 21 22 23  22 23 24 25 26 27 28  19 20 21 22 23 24 25
7 24 25 26 27 28 29 30  29 30 31              26 27 28 29 30 31

後來我想讓這個萬年曆更像 cal 的表示格式, 陸續加了幾個提示詞:

1. c code for calendar
2. c code 抓到今天的日期
3. 可以在今天日期做個標記嗎
4. 想用終端機顏色控制碼做標記, 用紅色
5. 紅色做前景，白色為背景
6. 加入 -3, 列出 這個月，上個月，下個月
7. 橫的列出來這3個月
8. add option, if the option is -3, print the current month, the previous month, and the next month
9. you forgot include string.h

最後的結果如 list 5

list 5. cal9 -3

1 Today's date: 2024-12-16
2     November 2024        December 2024        January 2025
3 Su Mo Tu We Th Fr Sa    Su Mo Tu We Th Fr Sa    Su Mo Tu We Th Fr Sa
4                 1  2     1  2  3  4  5  6  7              1  2  3  4
5  3  4  5  6  7  8  9     8  9 10 11 12 13 14     5  6  7  8  9 10 11
6 10 11 12 13 14 15 16    15 16 17 18 19 20 21    12 13 14 15 16 17 18
7 17 18 19 20 21 22 23    22 23 24 25 26 27 28    19 20 21 22 23 24 25
8 24 25 26 27 28 29 30    29 30 31                26 27 28 29 30 31

另外也詢問了閏年規則。

閏年的規則

閏年的規則如下：
四年一閏：年份必須能被 4 整除。
百年不閏：若年份能被 100 整除，則不是閏年（如 1900 不是閏年）。
四百年再閏：若年份能被 400 整除，則是閏年（如 2000 是閏年）。
判斷規則邏輯
若 年份能被 400 整除，則是閏年。
否則，若 年份能被 100 整除，則不是閏年。
否則，若 年份能被 4 整除，則是閏年。
其餘年份則不是閏年。
這些規則確保了閏年的平均間隔使曆法與地球繞太陽一圈的實際時間保持一致。平均每年增加約 0.2422 天（365.2422 天）。

signal handle backtrace (1)

世間多不公, 以血引雷霆

承上篇, glibc 的 backtrace 怎麼辦到在 signal handler 還可以正常抓出上一層的呼叫者, 先說答案, 我不知道, 看到這邊你可能會失望, 裡頭有 gcc 魔法, 我不是想往裡頭鑽, 所以這篇是介紹 glibc 的 backtrace 用什麼手法辦到這件事情。

__backtrace 有好幾個平台的實作, x86_64 應該是用 list 1 這個。

在 glibc 2.39 debug/backtrace.c __backtrace (void **array, int size) 可以看到類似的作法。

list 1. glibc-2.39/debug/backtrace.c

 1 /* Return backtrace of current program state.
 2    Copyright (C) 2003-2024 Free Software Foundation, Inc.
 3    This file is part of the GNU C Library.
 4
 5    The GNU C Library is free software; you can redistribute it and/or
 6    modify it under the terms of the GNU Lesser General Public
 7    License as published by the Free Software Foundation; either
 8    version 2.1 of the License, or (at your option) any later version.
 9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, see
17    <https://www.gnu.org/licenses/>.  */
18
19 #include <execinfo.h>
20 #include <stdlib.h>
21 #include <unwind.h>
22 #include <unwind-link.h>
23
24 struct trace_arg
25 {
26   void **array;
27   struct unwind_link *unwind_link;
28   _Unwind_Word cfa;
29   int cnt;
30   int size;
31 };
32
33 static _Unwind_Reason_Code
34 backtrace_helper (struct _Unwind_Context *ctx, void *a)
35 {
36   struct trace_arg *arg = a;
37
38   /* We are first called with address in the __backtrace function.
39      Skip it.  */
40   if (arg->cnt != -1)
41     {
42       arg->array[arg->cnt]
43 	= (void *) UNWIND_LINK_PTR (arg->unwind_link, _Unwind_GetIP) (ctx);
44       if (arg->cnt > 0)
45 	arg->array[arg->cnt]
46 	  = unwind_arch_adjustment (arg->array[arg->cnt - 1],
47 				    arg->array[arg->cnt]);
48
49       /* Check whether we make any progress.  */
50       _Unwind_Word cfa
51 	= UNWIND_LINK_PTR (arg->unwind_link, _Unwind_GetCFA) (ctx);
52
53       if (arg->cnt > 0 && arg->array[arg->cnt - 1] == arg->array[arg->cnt]
54 	 && cfa == arg->cfa)
55        return _URC_END_OF_STACK;
56       arg->cfa = cfa;
57     }
58   if (++arg->cnt == arg->size)
59     return _URC_END_OF_STACK;
60   return _URC_NO_REASON;
61 }
62
63 int
64 __backtrace (void **array, int size)
65 {
66   struct trace_arg arg =
67     {
68      .array = array,
69      .unwind_link = __libc_unwind_link_get (),
70      .cfa = 0,
71      .size = size,
72      .cnt = -1
73     };
74
75   if (size <= 0 || arg.unwind_link == NULL)
76     return 0;
77
78   UNWIND_LINK_PTR (arg.unwind_link, _Unwind_Backtrace)
79     (backtrace_helper, &arg);
80
81   /* _Unwind_Backtrace seems to put NULL address above
82      _start.  Fix it up here.  */
83   if (arg.cnt > 1 && arg.array[arg.cnt - 1] == NULL)
84     --arg.cnt;
85   return arg.cnt != -1 ? arg.cnt : 0;
86 }
87 weak_alias (__backtrace, backtrace)
88 libc_hidden_def (__backtrace)

看了一下 list 2, 是 t1 的反組譯, __backtrace 有看到 _Unwind_Backtrace, 所以應該是用 list 1 這段。

list 2. t1.dis

     1 
     2 t1:     file format elf64-x86-64
     3 
     4 
     5 Disassembly of section .init:


 82837 0000000000453080 <__backtrace>:
 82838   453080:	55                   	push   %rbp
 82839   453081:	48 89 e5             	mov    %rsp,%rbp
 82840   453084:	48 83 ec 20          	sub    $0x20,%rsp
 82841   453088:	64 48 8b 04 25 28 00 	mov    %fs:0x28,%rax
 82842   45308f:	00 00 
 82843   453091:	48 89 45 f8          	mov    %rax,-0x8(%rbp)
 82844   453095:	31 c0                	xor    %eax,%eax
 82845   453097:	85 f6                	test   %esi,%esi
 82846   453099:	48 89 7d e0          	mov    %rdi,-0x20(%rbp)
 82847   45309d:	48 c7 45 e8 00 00 00 	movq   $0x0,-0x18(%rbp)
 82848   4530a4:	00 
 82849   4530a5:	c7 45 f0 ff ff ff ff 	movl   $0xffffffff,-0x10(%rbp)
 82850   4530ac:	89 75 f4             	mov    %esi,-0xc(%rbp)
 82851   4530af:	7e 34                	jle    4530e5 <__backtrace+0x65>
 82852   4530b1:	48 8d 75 e0          	lea    -0x20(%rbp),%rsi
 82853   4530b5:	48 8d 3d 44 ff ff ff 	lea    -0xbc(%rip),%rdi        # 453000 <backtrace_helper>
 82854   4530bc:	e8 2f 59 05 00       	callq  4a89f0 <_Unwind_Backtrace>
 82855   4530c1:	8b 45 f0             	mov    -0x10(%rbp),%eax
 82856   4530c4:	83 f8 01             	cmp    $0x1,%eax
 82857   4530c7:	7e 17                	jle    4530e0 <__backtrace+0x60>
 82858   4530c9:	48 8b 4d e0          	mov    -0x20(%rbp),%rcx
 82859   4530cd:	48 63 d0             	movslq %eax,%rdx
 82860   4530d0:	48 83 7c d1 f8 00    	cmpq   $0x0,-0x8(%rcx,%rdx,8)
 82861   4530d6:	75 0f                	jne    4530e7 <__backtrace+0x67>
 82862   4530d8:	83 e8 01             	sub    $0x1,%eax
 82863   4530db:	eb 0a                	jmp    4530e7 <__backtrace+0x67>
 82864   4530dd:	0f 1f 00             	nopl   (%rax)
 82865   4530e0:	83 f8 ff             	cmp    $0xffffffff,%eax
 82866   4530e3:	75 02                	jne    4530e7 <__backtrace+0x67>
 82867   4530e5:	31 c0                	xor    %eax,%eax
 82868   4530e7:	48 8b 4d f8          	mov    -0x8(%rbp),%rcx

list 3. t1.s

  1 	.file	"t1.c"
  2 	.text
  3 	.section	.rodata
  4 .LC0:
  5 	.string	"addr2line -f -e ./t1 %#lx\n"
  6 .LC1:
  7 	.string	"cmd: %s\n"
  8 	.text
  9 	.globl	addr2func
 10 	.type	addr2func, @function
 11 addr2func:
 12 .LFB5:
 13 	.cfi_startproc
 14 	pushq	%rbp
 15 	.cfi_def_cfa_offset 16
 16 	.cfi_offset 6, -16
 17 	movq	%rsp, %rbp
 18 	.cfi_def_cfa_register 6
 19 	subq	$160, %rsp
 20 	movq	%rdi, -152(%rbp)
 21 	movq	%fs:40, %rax
 22 	movq	%rax, -8(%rbp)
 23 	xorl	%eax, %eax
 24 	leaq	-144(%rbp), %rdx
 25 	movl	$0, %eax
 26 	movl	$16, %ecx
 27 	movq	%rdx, %rdi
 28 	rep stosq
 29 	movq	-152(%rbp), %rdx
 30 	leaq	-144(%rbp), %rax
 31 	leaq	.LC0(%rip), %rsi
 32 	movq	%rax, %rdi
 33 	movl	$0, %eax
 34 	call	sprintf@PLT
 35 	leaq	-144(%rbp), %rax
 36 	movq	%rax, %rsi
 37 	leaq	.LC1(%rip), %rdi
 38 	movl	$0, %eax
 39 	call	printf@PLT
 40 	leaq	-144(%rbp), %rax
 41 	movq	%rax, %rdi
 42 	call	system@PLT
 43 	movl	$0, %eax
 44 	movq	-8(%rbp), %rcx
 45 	xorq	%fs:40, %rcx
 46 	je	.L3
 47 	call	__stack_chk_fail@PLT
 48 .L3:
 49 	leave
 50 	.cfi_def_cfa 7, 8
 51 	ret
 52 	.cfi_endproc
 53 .LFE5:
 54 	.size	addr2func, .-addr2func
 55 	.globl	get_rip_value
 56 	.type	get_rip_value, @function
 57 get_rip_value:
 58 .LFB6:
 59 	.cfi_startproc
 60 	pushq	%rbp
 61 	.cfi_def_cfa_offset 16
 62 	.cfi_offset 6, -16
 63 	movq	%rsp, %rbp
 64 	.cfi_def_cfa_register 6
120 	.text
121 	.globl	print_backtrace
122 	.type	print_backtrace, @function
123 print_backtrace:
124 .LFB8:
125 	.cfi_startproc
126 	pushq	%rbp
127 	.cfi_def_cfa_offset 16
128 	.cfi_offset 6, -16
129 	movq	%rsp, %rbp
130 	.cfi_def_cfa_register 6
131 	subq	$960, %rsp
197 	ret
198 	.cfi_endproc
199 .LFE8:
200 	.size	print_backtrace, .-print_backtrace
228 	.text
229 	.globl	sig_handler
230 	.type	sig_handler, @function
231 sig_handler:
232 .LFB9:
233 	.cfi_startproc
234 	pushq	%rbp
235 	.cfi_def_cfa_offset 16
236 	.cfi_offset 6, -16
237 	movq	%rsp, %rbp
238 	.cfi_def_cfa_register 6
239 	subq	$80, %rsp
240 	movl	%edi, -68(%rbp)
241 	movl	$0, -52(%rbp)
242 	leaq	.LC6(%rip), %rdi
243 	call	puts@PLT
244 	movl	$0, %eax
413 	leave
414 	.cfi_def_cfa 7, 8
415 	ret
416 	.cfi_endproc
417 .LFE9:
418 	.size	sig_handler, .-sig_handler
419 	.section	.rodata
420 .LC18:
421 	.string	"sig thread pid: %d\n"
422 .LC19:
423 	.string	"sigwait"
424 	.align 8
425 .LC20:
426 	.string	"Signal handling thread got signal %d\n"
427 	.text
428 	.type	sig_thread, @function
429 sig_thread:
430 .LFB10:
431 	.cfi_startproc
432 	pushq	%rbp
433 	.cfi_def_cfa_offset 16
434 	.cfi_offset 6, -16
435 	movq	%rsp, %rbp
436 	.cfi_def_cfa_register 6
437 	subq	$48, %rsp
438 	movq	%rdi, -40(%rbp)
439 	movq	%fs:40, %rax
466 .L21:
467 	movl	-24(%rbp), %eax
468 	movl	%eax, %esi
469 	leaq	.LC20(%rip), %rdi
470 	movl	$0, %eax
471 	call	printf@PLT
472 	jmp	.L22
473 	.cfi_endproc
474 .LFE10:
475 	.size	sig_thread, .-sig_thread
476 	.section	.rodata
477 .LC21:
478 	.string	"123 thread pid: %d\n"
479 .LC22:
480 	.string	"123 thread tid: %d\n"
481 	.text
482 	.type	fun_123, @function
483 fun_123:
484 .LFB11:
485 	.cfi_startproc
486 	pushq	%rbp
487 	.cfi_def_cfa_offset 16
488 	.cfi_offset 6, -16
489 	movq	%rsp, %rbp
490 	.cfi_def_cfa_register 6
491 	subq	$32, %rsp
507 .L25:
508 	jmp	.L25
509 	.cfi_endproc
510 .LFE11:
511 	.size	fun_123, .-fun_123
512 	.type	fun_12, @function
513 fun_12:
514 .LFB12:
515 	.cfi_startproc
516 	pushq	%rbp
517 	.cfi_def_cfa_offset 16
518 	.cfi_offset 6, -16
519 	movq	%rsp, %rbp
520 	.cfi_def_cfa_register 6
521 	subq	$16, %rsp
522 	movq	%rdi, -8(%rbp)
523 	movq	-8(%rbp), %rax
524 	movq	%rax, %rdi
525 	call	fun_123
526 	nop
527 	leave
528 	.cfi_def_cfa 7, 8
529 	ret
530 	.cfi_endproc
531 .LFE12:
532 	.size	fun_12, .-fun_12
533 	.type	fun_1, @function
534 fun_1:
535 .LFB13:
536 	.cfi_startproc
537 	pushq	%rbp
538 	.cfi_def_cfa_offset 16
539 	.cfi_offset 6, -16
540 	movq	%rsp, %rbp
541 	.cfi_def_cfa_register 6
542 	subq	$16, %rsp
543 	movq	%rdi, -8(%rbp)
544 	movq	-8(%rbp), %rax
545 	movq	%rax, %rdi
546 	call	fun_12
547 	movl	$0, %eax
548 	leave
549 	.cfi_def_cfa 7, 8
550 	ret
551 	.cfi_endproc
552 .LFE13:
553 	.size	fun_1, .-fun_1
554 	.type	fun_223, @function
555 fun_223:
556 .LFB14:
557 	.cfi_startproc
558 	pushq	%rbp
559 	.cfi_def_cfa_offset 16
560 	.cfi_offset 6, -16
561 	movq	%rsp, %rbp
562 	.cfi_def_cfa_register 6
563 .L30:
564 	jmp	.L30
565 	.cfi_endproc
566 .LFE14:
567 	.size	fun_223, .-fun_223
568 	.type	fun_22, @function
569 fun_22:
570 .LFB15:
571 	.cfi_startproc
572 	pushq	%rbp
573 	.cfi_def_cfa_offset 16
574 	.cfi_offset 6, -16
575 	movq	%rsp, %rbp
576 	.cfi_def_cfa_register 6
577 	movl	$0, %eax
578 	call	fun_223
579 	nop
580 	popq	%rbp
581 	.cfi_def_cfa 7, 8
582 	ret
583 	.cfi_endproc
584 .LFE15:
585 	.size	fun_22, .-fun_22
586 	.type	fun_2, @function
587 fun_2:
588 .LFB16:
589 	.cfi_startproc
590 	pushq	%rbp
591 	.cfi_def_cfa_offset 16
592 	.cfi_offset 6, -16
593 	movq	%rsp, %rbp
594 	.cfi_def_cfa_register 6
595 	subq	$32, %rsp
596 	movq	%rdi, -24(%rbp)
605 	movl	$39, -12(%rbp)
606 	leaq	-12(%rbp), %rax
607 	movq	%rax, %rdx
608 	movl	$2, %esi
609 	movl	$0, %edi
610 	call	sched_setscheduler@PLT
611 .L33:
612 	movl	$0, %eax
613 	call	fun_22
614 	jmp	.L33
615 	.cfi_endproc
632 	.text
633 	.globl	main
634 	.type	main, @function
635 main:
636 .LFB17:
637 	.cfi_startproc
638 	pushq	%rbp
639 	.cfi_def_cfa_offset 16
640 	.cfi_offset 6, -16
641 	movq	%rsp, %rbp
642 	.cfi_def_cfa_register 6
643 	subq	$320, %rsp
644 	movl	%edi, -308(%rbp)
645 	movq	%rsi, -320(%rbp)
646 	movq	%fs:40, %rax
712 	jmp	.L37
713 	.cfi_endproc
714 .LFE17:
715 	.size	main, .-main
716 	.ident	"GCC: (Ubuntu 7.4.0-1ubuntu1~18.04.1) 7.4.0"
717 	.section	.note.GNU-stack,"",@progbits

list 3 是 gcc 輸出的組合語言, 可以看到 .cfi 開頭的指令, 這並非是 x86 指令, 到底是什麼呢?

chatgpt 真的威, 連 .cfi_def_cfa 都可以解釋, 最重要的是用「中文」解釋。讓英文不好的我和英文好的開發者差距拉近了一點。以下是 gpt 的回答, 看完應該可以猜到 glibc 的 backtrace 是怎麼做的。

list 5. chatgpt 的回答

me: gcc 產生的 .s  .cfi_def_cfa 是什麼指令?

ChatGPT:
.s 文件是经过编译器（如 GCC）处理后生成的汇编代码文件，其中包含了对源代码进行编译后的汇编语言代码。.cfi_def_cfa 是 GCC 生成的用于描述函数调用框架信息的指令，用于指定 CFA（Canonical Frame Address）的定义方式。

具体来说，.cfi_def_cfa 指令用于指定当前函数中的 CFA（规范化帧地址）的定义方式。CFA 是指在函数调用过程中用来定位当前栈帧的地址。.cfi_def_cfa 指令有以下格式：

.cfi_def_cfa register, offset
register：指定一个寄存器，用来存储当前栈帧的基址指针（Base Pointer，BP）。
offset：指定相对于 register 的偏移量，表示 CFA 在当前栈帧中的位置。
例如，下面是一个示例 .s 文件中的 .cfi_def_cfa 指令的用法：

assembly
.text
.globl main

main:
    .cfi_startproc            ; 开始定义过程
    pushq %rbp                ; 保存旧的基址指针
    .cfi_def_cfa %rsp, 16     ; 定义 CFA 为栈顶寄存器，并在栈上向下偏移16字节
    pushq %rbx                ; 保存其他寄存器
    pushq %r12
    pushq %r13
    pushq %r14
    pushq %r15
    .cfi_endproc              ; 结束定义过程

    ret                        ; 返回
在这个示例中，.cfi_def_cfa %rsp, 16 指令指定了 CFA 的定义方式为栈顶寄存器 %rsp，并且在栈上向下偏移了16字节。这样可以帮助调试器在调试过程中准确地定位当前栈帧的位置，从而更方便地进行调试和分析。

me: 
        .cfi_def_cfa 7, 8
這是什麼意思?

ChatGPT:
.cfi_def_cfa 指令用于指定当前函数中的 CFA（Canonical Frame Address，规范化帧地址）的定义方式。CFA 是在函数调用过程中用来定位当前栈帧的地址。

.cfi_def_cfa register, offset
在你提供的 .cfi_def_cfa 7, 8 中，意思是指定了当前栈帧的 CFA 的定义方式。具体来说：

register：7 表示的是 RSP 寄存器，即栈顶指针。
offset：8 表示的是相对于 RSP 寄存器的偏移量，即栈帧在当前栈中的位置。
因此，.cfi_def_cfa 7, 8 指令表示当前栈帧的 CFA 是 RSP 寄存器，并且在当前栈中的位置偏移为 8 字节。这个信息通常用于调试目的，帮助调试器在调试过程中准确定位当前栈帧的位置。

me:
如何移除 .cfi_def_cfa 指令

ChatGPT:
在汇编代码中移除 .cfi_def_cfa 指令可能会导致一些调试信息丢失，因为这些指令是用于描述调用框架信息的。但是，如果你确实需要移除这些指令，可以通过以下方法之一实现：

手动删除：在汇编代码文件中手动删除所有 .cfi_def_cfa 指令。可以通过文本编辑器查找并删除这些指令。

编译器选项：在编译时使用编译器选项来禁用生成 .cfi_def_cfa 指令。例如，在使用 GCC 编译器时，可以使用 -fno-asynchronous-unwind-tables 选项来禁用生成调用框架信息。示例命令如下：

gcc -fno-asynchronous-unwind-tables your_program.c -o your_program
请注意，禁用调用框架信息可能会影响调试能力和代码执行的稳定性，因此谨慎使用。

优化选项：在编译时使用优化选项可能会移除部分调试信息，包括 .cfi_def_cfa 指令。可以使用 -O 选项来启用优化。示例命令如下：

gcc -O2 your_program.c -o your_program
这些方法中，手动删除指令可能是最直接的方法，但请谨慎操作，确保了解这些指令的作用和影响。在生产环境中，一般不建议删除这些调试信息，因为它们对调试和错误定位非常有用。

所以程式用了 -fno-asynchronous-unwind-tables, 就不會有 .cfi 這些指令, 然後你就會發現 backtrace 再也無法正確印出整個呼叫順序了。如 list 6, 只能抓到 print_backtrace, 我自己尋訪 stack frame 的作法依然可以正常。gcc 勝之不武, 偷偷用了自己的加料手法完成這件事情, 這樣也許也可以不因為 cpu 平台而有一個統一的作法吧。

list 6. 加入 -fno-asynchronous-unwind-tables

backtrace() returned 1 addresses
nn [0x400cfc]
cmd: addr2line -f -e ./t1 0x400cfc

print_backtrace
??:?

ref:
What do the CFI directives mean? (and some more questions)