Feat/godbolt integration (#24)

* add interative codes

* tidy todos

* feat: enable to modify the compile condition

Author: Charliechen114514

code/examples/compiler_explorer/README.md

@@ -0,0 +1,17 @@
+# Compiler Explorer examples
+
+This directory contains small, single-file snippets used by the VitePress
+`OnlineCompilerDemo` component.
+
+These files should be committed with the documentation changes that reference
+them. The component reads `arm-source-path` from the published repository, and
+keeps a small built-in fallback only so local previews keep working before the
+new files reach the default branch.
+
+Guidelines:
+
+- Keep each file self-contained.
+- Prefer freestanding-friendly headers such as `<cstdint>` and `<cstddef>`.
+- Avoid `iostream`, hosted-only containers, exceptions, dynamic allocation, and
+  board-specific HAL headers in ARM snippets.
+- Use these snippets for assembly inspection, not as full tutorial programs.

code/examples/compiler_explorer/array_vs_carray_arm.cpp

@@ -0,0 +1,32 @@
+// array_vs_carray_arm.cpp
+// ARM freestanding: std::array 与 C 数组的零开销对比
+
+#include <cstddef>
+#include <cstdint>
+
+int sum_raw(const int* data, std::size_t n) {
+    int total = 0;
+    for (std::size_t i = 0; i < n; ++i) {
+        total += data[i];
+    }
+    return total;
+}
+
+template <std::size_t N> int sum_array(const int (&data)[N]) {
+    int total = 0;
+    for (std::size_t i = 0; i < N; ++i) {
+        total += data[i];
+    }
+    return total;
+}
+
+extern "C" {
+int test_raw() {
+    int buf[4] = {1, 2, 3, 4};
+    return sum_raw(buf, 4);
+}
+int test_array() {
+    int buf[4] = {1, 2, 3, 4};
+    return sum_array(buf);
+}
+}

code/examples/compiler_explorer/array_vs_carray_host.cpp

@@ -0,0 +1,50 @@
+// array_vs_carray_host.cpp
+// std::array 与 C 数组的零开销对比
+
+#include <array>
+#include <cstdint>
+#include <iostream>
+
+void size_comparison() {
+    int raw[4] = {1, 2, 3, 4};
+    std::array<int, 4> arr = {1, 2, 3, 4};
+
+    std::cout << "sizeof(raw) = " << sizeof(raw) << "\n";
+    std::cout << "sizeof(arr) = " << sizeof(arr) << "\n";
+    std::cout << "Zero overhead? " << (sizeof(raw) == sizeof(arr) ? "yes" : "no") << "\n";
+}
+
+void pass_raw(int ptr[]) {
+    std::cout << "Inside function: sizeof(ptr) = " << sizeof(ptr) << " (decayed!)\n";
+}
+
+void pass_std_array(const std::array<int, 4>& arr) {
+    std::cout << "Inside function: arr.size() = " << arr.size() << " (safe!)\n";
+}
+
+constexpr std::array<uint16_t, 8> crc_table = [] {
+    std::array<uint16_t, 8> t{};
+    for (std::size_t i = 0; i < t.size(); ++i)
+        t[i] = static_cast<uint16_t>(i * 0x1021);
+    return t;
+}();
+
+int main() {
+    std::cout << "=== std::array vs C array ===\n\n";
+    size_comparison();
+
+    std::cout << "\n--- Decay problem ---\n";
+    int raw[4] = {10, 20, 30, 40};
+    std::array<int, 4> arr = {10, 20, 30, 40};
+    std::cout << "Caller: sizeof(raw) = " << sizeof(raw) << "\n";
+    pass_raw(raw);
+    pass_std_array(arr);
+
+    std::cout << "\n--- Compile-time table ---\n";
+    for (std::size_t i = 0; i < crc_table.size(); ++i) {
+        std::cout << "crc_table[" << i << "] = 0x" << std::hex << crc_table[i] << std::dec << "\n";
+    }
+    static_assert(crc_table.size() == 8);
+
+    return 0;
+}

code/examples/compiler_explorer/compiler_opts_arm.cpp

@@ -0,0 +1,61 @@
+// ARM freestanding: compiler options effect demonstration
+// Uses only freestanding headers for ARM cross-compilation
+// Compare assembly with: -O0, -Os, -O2, -O3
+#include <cstddef>
+#include <cstdint>
+
+// ---- Simple function: inlining candidate ----
+int add_simple(int a, int b) {
+    return a + b;
+}
+
+// ---- Loop: shows loop optimization ----
+int accumulate(const int* data, size_t n) {
+    int sum = 0;
+    for (size_t i = 0; i < n; ++i) {
+        sum += data[i];
+    }
+    return sum;
+}
+
+// ---- Compile-time computation: should disappear at any -O ----
+template <int N> constexpr int factorial() {
+    int result = 1;
+    for (int i = 2; i <= N; ++i)
+        result *= i;
+    return result;
+}
+
+constexpr int f10 = factorial<10>();
+static_assert(f10 == 3628800);
+
+// ---- Struct with ctor: shows ctor optimization ----
+struct TimerConfig {
+    uint32_t period;
+    uint32_t prescaler;
+    uint8_t enabled;
+
+    constexpr TimerConfig(uint32_t p, uint32_t ps, bool e)
+        : period(p), prescaler(ps), enabled(e ? 1u : 0u) {}
+};
+
+constexpr TimerConfig default_cfg{1000, 72, true};
+static_assert(default_cfg.period == 1000);
+
+// ---- Callable wrappers to observe code generation ----
+int call_add() {
+    return add_simple(3, 4);
+}
+
+int call_accumulate() {
+    const int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    return accumulate(data, 10);
+}
+
+int call_factorial() {
+    return f10;
+}
+
+uint32_t call_config() {
+    return default_cfg.period + default_cfg.prescaler;
+}

code/examples/compiler_explorer/constexpr_baud_arm.cpp

@@ -0,0 +1,21 @@
+#include <cstdint>
+
+std::uint32_t calculate_baud_divisor_runtime(std::uint32_t cpu_freq, std::uint32_t baud) {
+    return cpu_freq / (16u * baud);
+}
+
+constexpr std::uint32_t calculate_baud_divisor_constexpr(std::uint32_t cpu_freq,
+                                                         std::uint32_t baud) {
+    return cpu_freq / (16u * baud);
+}
+
+constexpr std::uint32_t divisor = calculate_baud_divisor_constexpr(72000000u, 115200u);
+static_assert(divisor == 39u);
+
+std::uint32_t runtime_divisor(std::uint32_t baud) {
+    return calculate_baud_divisor_runtime(72000000u, baud);
+}
+
+std::uint32_t constexpr_divisor() {
+    return divisor;
+}

code/examples/compiler_explorer/ebo_arm.cpp

@@ -0,0 +1,35 @@
+// ebo_arm.cpp
+// ARM freestanding: 空基类优化 sizeof 对比
+
+#include <cstddef>
+
+struct Empty {};
+
+struct AsMember {
+    Empty e;
+    int x;
+};
+
+struct AsBase : Empty {
+    int x;
+};
+
+struct WithNoUniqueAddress {
+    [[no_unique_address]] Empty e;
+    int x;
+};
+
+extern "C" {
+std::size_t size_empty() {
+    return sizeof(Empty);
+}
+std::size_t size_as_member() {
+    return sizeof(AsMember);
+}
+std::size_t size_as_base() {
+    return sizeof(AsBase);
+}
+std::size_t size_no_unique() {
+    return sizeof(WithNoUniqueAddress);
+}
+}

code/examples/compiler_explorer/ebo_host.cpp

@@ -0,0 +1,33 @@
+// ebo_host.cpp
+// 空基类优化与 C++20 [[no_unique_address]]
+
+#include <iostream>
+
+struct Empty {};
+
+struct AsMember {
+    Empty e; // member: must occupy >= 1 byte
+    int x;
+};
+
+struct AsBase : Empty { // EBO: Empty base costs 0 extra bytes
+    int x;
+};
+
+#if __cplusplus >= 202002L
+struct WithNoUniqueAddress {
+    [[no_unique_address]] Empty e;
+    int x;
+};
+#endif
+
+int main() {
+    std::cout << "sizeof(Empty)        = " << sizeof(Empty) << "\n";
+    std::cout << "sizeof(AsMember)     = " << sizeof(AsMember) << " (Empty as member)\n";
+    std::cout << "sizeof(AsBase)       = " << sizeof(AsBase) << " (Empty as base, EBO)\n";
+#if __cplusplus >= 202002L
+    std::cout << "sizeof(WithNoUnique) = " << sizeof(WithNoUniqueAddress)
+              << " (C++20 [[no_unique_address]])\n";
+#endif
+    return 0;
+}

code/examples/compiler_explorer/fixed_pool_arm.cpp

@@ -0,0 +1,62 @@
+#include <cstddef>
+#include <cstdint>
+
+template <std::size_t BlockSize, std::size_t BlockCount> class FixedPool {
+    struct Block {
+        alignas(std::max_align_t) std::uint8_t data[BlockSize];
+    };
+
+    Block pool_[BlockCount];
+    std::size_t free_list_[BlockCount];
+    std::size_t free_head_;
+    std::size_t used_count_;
+
+  public:
+    FixedPool() : free_head_(0), used_count_(0) {
+        for (std::size_t i = 0; i < BlockCount; ++i) {
+            free_list_[i] = i + 1;
+        }
+        free_list_[BlockCount - 1] = static_cast<std::size_t>(-1);
+    }
+
+    void* allocate() {
+        if (free_head_ == static_cast<std::size_t>(-1)) {
+            return nullptr;
+        }
+
+        const std::size_t index = free_head_;
+        free_head_ = free_list_[index];
+        ++used_count_;
+        return pool_[index].data;
+    }
+
+    void deallocate(void* ptr) {
+        if (!ptr) {
+            return;
+        }
+
+        const auto base = reinterpret_cast<std::uintptr_t>(&pool_[0]);
+        const auto current = reinterpret_cast<std::uintptr_t>(ptr);
+        const std::size_t index = (current - base) / sizeof(Block);
+
+        free_list_[index] = free_head_;
+        free_head_ = index;
+        --used_count_;
+    }
+
+    std::size_t used_count() const { return used_count_; }
+};
+
+FixedPool<32, 8> pool;
+
+void* allocate_packet_buffer() {
+    return pool.allocate();
+}
+
+void release_packet_buffer(void* buffer) {
+    pool.deallocate(buffer);
+}
+
+std::size_t used_packet_buffers() {
+    return pool.used_count();
+}

code/examples/compiler_explorer/gpio_zero_overhead_arm.cpp

@@ -0,0 +1,23 @@
+#include <cstdint>
+
+#define GPIO_PORT_A_C ((volatile std::uint32_t*)0x40020000u)
+#define PIN_5_C (1u << 5)
+
+void set_pin_c() {
+    *GPIO_PORT_A_C |= PIN_5_C;
+}
+
+template <std::uint32_t Address> class GPIO_Port {
+    static volatile std::uint32_t& reg() {
+        return *reinterpret_cast<volatile std::uint32_t*>(Address);
+    }
+
+  public:
+    static void set_pin(std::uint8_t pin) { reg() |= (1u << pin); }
+};
+
+using GPIOA = GPIO_Port<0x40020000u>;
+
+void set_pin_cpp() {
+    GPIOA::set_pin(5);
+}