Add CI/CD workflows for releases and playground deployment

cs01 · cs01 · commit 56075ed46154 · 2025-11-24T17:12:20.000-08:00
- Add build-clang.yml: Builds Linux and macOS binaries on version tags
- Update build-playground.yml: Builds WASM with EXIT_RUNTIME=0 and ALLOW_MEMORY_GROWTH flags
  to enable multiple callMain() invocations (fixes signal handler issue)
- Playground deploys automatically on push to null-safe-c-dev
- Binaries only released when explicitly tagged (v* for binaries, playground-v* for WASM)
diff --git a/.github/workflows/build-clang.yml b/.github/workflows/build-clang.yml
@@ -0,0 +1,151 @@
+name: Build Null-Safe Clang Binaries
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ninja-build cmake build-essential
+
+      - name: Configure build
+        run: |
+          mkdir -p build
+          cd build
+          cmake -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DLLVM_ENABLE_PROJECTS="clang" \
+            -DLLVM_TARGETS_TO_BUILD="X86" \
+            -DLLVM_ENABLE_ASSERTIONS=OFF \
+            -DCMAKE_INSTALL_PREFIX=../install \
+            ../llvm
+
+      - name: Build Clang
+        run: |
+          cd build
+          ninja clang
+
+      - name: Install Clang
+        run: |
+          cd build
+          ninja install-clang
+          ninja install-clang-headers
+
+      - name: Package binaries
+        run: |
+          cd install
+          tar -czf clang-nullsafe-linux-x86_64.tar.gz bin/ lib/clang/
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: clang-nullsafe-linux-x86_64
+          path: install/clang-nullsafe-linux-x86_64.tar.gz
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: install/clang-nullsafe-linux-x86_64.tar.gz
+          body: |
+            ## Null-Safe Clang Binary Release
+
+            This release contains the Null-Safe Clang compiler for Linux x86_64.
+
+            ### Installation:
+            ```bash
+            tar -xzf clang-nullsafe-linux-x86_64.tar.gz
+            export PATH=$PWD/bin:$PATH
+            clang --version
+            ```
+
+            ### Usage:
+            ```bash
+            # Compile with null-safety warnings (default)
+            clang mycode.c
+
+            # Promote warnings to errors
+            clang -Werror=nullability mycode.c
+
+            # Disable null-safety checking
+            clang -fno-strict-nullability mycode.c
+            ```
+
+            See the [README](https://github.com/cs01/llvm-project/blob/null-safe-c-dev/README.md) for full documentation.
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  build-macos:
+    runs-on: macos-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          brew install ninja cmake
+
+      - name: Configure build
+        run: |
+          mkdir -p build
+          cd build
+          cmake -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DLLVM_ENABLE_PROJECTS="clang" \
+            -DLLVM_TARGETS_TO_BUILD="AArch64;X86" \
+            -DLLVM_ENABLE_ASSERTIONS=OFF \
+            -DCMAKE_INSTALL_PREFIX=../install \
+            ../llvm
+
+      - name: Build Clang
+        run: |
+          cd build
+          ninja clang
+
+      - name: Install Clang
+        run: |
+          cd build
+          ninja install-clang
+          ninja install-clang-headers
+
+      - name: Package binaries
+        run: |
+          cd install
+          tar -czf clang-nullsafe-macos-universal.tar.gz bin/ lib/clang/
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: clang-nullsafe-macos-universal
+          path: install/clang-nullsafe-macos-universal.tar.gz
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: install/clang-nullsafe-macos-universal.tar.gz
+          body: |
+            ## Null-Safe Clang Binary Release (macOS)
+
+            This release contains the Null-Safe Clang compiler for macOS (Intel and Apple Silicon).
+
+            ### Installation:
+            ```bash
+            tar -xzf clang-nullsafe-macos-universal.tar.gz
+            export PATH=$PWD/bin:$PATH
+            clang --version
+            ```
+
+            See the [README](https://github.com/cs01/llvm-project/blob/null-safe-c-dev/README.md) for usage instructions.
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/build-playground.yml b/.github/workflows/build-playground.yml
@@ -44,7 +44,7 @@ jobs:
             -DLLVM_ENABLE_TERMINFO=OFF \
             -DLLVM_ENABLE_ZLIB=OFF \
             -DLLVM_ENABLE_LIBXML2=OFF \
-            -DCMAKE_EXE_LINKER_FLAGS="-sEXPORTED_RUNTIME_METHODS=callMain" \
+            -DCMAKE_EXE_LINKER_FLAGS="-sEXPORTED_RUNTIME_METHODS=callMain -sEXIT_RUNTIME=0 -sALLOW_MEMORY_GROWTH=1" \
             ../llvm
 
       - name: Build Null-Safe Clang WASM
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -1,16 +1,50 @@
-# Contributing to LLVM
+# Contributing to Null-Safe Clang
 
-Thank you for your interest in contributing to LLVM! There are many ways to
-contribute, and we appreciate all contributions.
+Development branch: `null-safe-c-dev`
 
-To get started with contributing, please take a look at the
-[Contributing to LLVM](https://llvm.org/docs/Contributing.html) guide. It
-describes how to get involved, raise issues and submit patches.
+## Building
 
-## Getting in touch
+### Standard (x86)
+```bash
+mkdir build && cd build
+cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS="clang" ../llvm
+ninja clang clangd
+```
 
-Join the [LLVM Discourse forums](https://discourse.llvm.org/) or [Discord
-chat](https://discord.gg/xS7Z362).
+### WASM (playground)
+```bash
+# Clone and setup Emscripten (first time only)
+git clone https://github.com/emscripten-core/emsdk.git
+cd emsdk
+./emsdk install latest
+./emsdk activate latest
+source ./emsdk_env.sh
+cd ..
 
-The LLVM project has adopted a [code of conduct](https://llvm.org/docs/CodeOfConduct.html) for
-participants to all modes of communication within the project.
+# Build WASM
+mkdir build-wasm && cd build-wasm
+export PATH="/path/to/emsdk/upstream/emscripten:$PATH"
+emcmake cmake -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DLLVM_ENABLE_PROJECTS="clang" -DLLVM_TARGETS_TO_BUILD="WebAssembly" \
+  -DLLVM_ENABLE_THREADS=OFF \
+  -DCMAKE_EXE_LINKER_FLAGS="-sEXPORTED_RUNTIME_METHODS=callMain -sEXIT_RUNTIME=0 -sALLOW_MEMORY_GROWTH=1" \
+  ../llvm
+ninja clang
+
+# Output: bin/clang.wasm and bin/clang.js
+```
+
+## Testing
+```bash
+build/bin/llvm-lit -v clang/test/Sema/strict-nullability.c
+```
+
+## Releases
+
+**Playground:** Push to `null-safe-c-dev` → deploys GitHub Pages automatically.
+
+**WASM files:** `git tag playground-v1.0 && git push origin playground-v1.0`
+
+**Binaries:** `git tag v1.0.0 && git push origin v1.0.0`
+
+Downloads: https://github.com/cs01/llvm-project/releases
diff --git a/README.md b/README.md
@@ -147,131 +147,25 @@ Many standard library functions already have these attributes in GNU libc header
 
 ## Null-Safe C Standard Library
 
-The `clang/nullsafe-headers/` directory contains nullability-annotated standard library headers. Currently includes:
-- `string.h` - String manipulation functions (`strlen`, `strcpy`, `strdup`, etc.)
-- `stdlib.h` - Memory allocation and utilities (`malloc`, `free`, `getenv`, etc.)
-- `stdio.h` - File and I/O operations (`fopen`, `fclose`, `fprintf`, etc.)
-
-These headers tell the compiler which functions can return NULL and which parameters can be NULL—information missing from system headers.
-
-Functions like `malloc`, `strdup`, `getenv` are annotated to return `_Nullable` pointers (can be NULL), while parameters like `strlen`'s input are marked `_Nonnull` (must not be NULL).
-
-Without null-safe headers (using system headers):
-```c
-#include <string.h>  // System headers - no parameter nullability info
-
-void example(const char* input) {
-    char* result = strdup(input);  // No warning - compiler doesn't know strdup needs nonnull
-    result[0] = 'x';                // ⚠️  Warning: result might be NULL (all pointers nullable by default)
-}
-```
-You get warnings about dereferencing nullable return values, but not about passing NULL to functions.
-
-With null-safe headers:
-```c
-#include "string.h"  // From clang/nullsafe-headers - strdup parameter is _Nonnull
-
-void example(const char* input) {
-    char* result = strdup(input);  // ⚠️  Warning: passing nullable 'input' to nonnull parameter!
-    result[0] = 'x';                // ⚠️  Warning: dereferencing nullable pointer!
-
-    // Fix both issues:
-    if (input) {
-        char* result = strdup(input);  // ✓ OK - input is non-null
-        if (result) {
-            result[0] = 'x';            // ✓ OK - result is non-null
-            free(result);
-        }
-    }
-}
-```
-Now you get warnings for BOTH nullable returns AND passing NULL to nonnull parameters.
-
-The headers catch both directions:
-
-```c
-#include "string.h"
-
-void test_returns(void) {
-    char* str = malloc(100);  // malloc returns _Nullable
-    str[0] = 'x';             // ⚠️  Warning: str might be NULL!
-}
-
-void test_params(char* str) {
-    strlen(str);              // ⚠️  Warning: str is nullable, strlen expects nonnull!
-
-    if (str) {
-        strlen(str);          // ✓ OK - str is non-null here
-    }
-}
-```
-
-### Using Null-Safe Headers
+Nullability-annotated headers for `string.h`, `stdlib.h`, and `stdio.h` are available in `clang/nullsafe-headers/`. These tell the compiler which functions return nullable pointers and which parameters must be non-null.
 
 ```bash
 # Compile with null-safe headers
 clang -Iclang/nullsafe-headers/include mycode.c
 ```
 
-Example code:
 ```c
 #include "string.h"
 #include "stdlib.h"
 
-void safe_code(const char* input) {
-    if (!input) return;  // Early return for null check
-
-    // After the check, strict nullability knows input is non-null
-    size_t len = strlen(input);  // OK - strlen expects non-null
-    char* copy = malloc(len + 1);
-
-    if (copy) {  // Check malloc result (returns _Nullable)
-        strcpy(copy, input);  // OK - both non-null
+void example(const char* input) {
+    if (!input) return;
+    char* copy = malloc(strlen(input) + 1);  // malloc returns _Nullable
+    if (copy) {
+        strcpy(copy, input);  // Both parameters narrowed to non-null
         free(copy);
     }
 }
 ```
 
-See [`clang/nullsafe-headers/README.md`](clang/nullsafe-headers/README.md) for complete documentation.
-
-
----
-
-# The LLVM Compiler Infrastructure
-
-This repository contains the source code for LLVM, a toolkit for the
-construction of highly optimized compilers, optimizers, and run-time
-environments.
-
-The LLVM project has multiple components. The core of the project is
-itself called "LLVM". This contains all of the tools, libraries, and header
-files needed to process intermediate representations and convert them into
-object files. Tools include an assembler, disassembler, bitcode analyzer, and
-bitcode optimizer.
-
-C-like languages use the [Clang](https://clang.llvm.org/) frontend. This
-component compiles C, C++, Objective-C, and Objective-C++ code into LLVM bitcode
--- and from there into object files, using LLVM.
-
-Other components include:
-the [libc++ C++ standard library](https://libcxx.llvm.org),
-the [LLD linker](https://lld.llvm.org), and more.
-
-## Getting the Source Code and Building LLVM
-
-Consult the
-[Getting Started with LLVM](https://llvm.org/docs/GettingStarted.html#getting-the-source-code-and-building-llvm)
-page for information on building and running LLVM.
-
-For information on how to contribute to the LLVM project, please take a look at
-the [Contributing to LLVM](https://llvm.org/docs/Contributing.html) guide.
-
-## Getting in touch
-
-Join the [LLVM Discourse forums](https://discourse.llvm.org/), [Discord
-chat](https://discord.gg/xS7Z362),
-[LLVM Office Hours](https://llvm.org/docs/GettingInvolved.html#office-hours) or
-[Regular sync-ups](https://llvm.org/docs/GettingInvolved.html#online-sync-ups).
-
-The LLVM project has adopted a [code of conduct](https://llvm.org/docs/CodeOfConduct.html) for
-participants to all modes of communication within the project.
+See [`clang/nullsafe-headers/README.md`](clang/nullsafe-headers/README.md) for details.
