Runtime libraries providing compiler builtins and math functions for the TMS9900 LLVM backend.

libtms9900/
├── builtins/          # Compiler intrinsics (__mulsi3, __addsf3, etc.)
│   ├── mul32.asm      # 32-bit multiply
│   ├── div32.asm      # 32-bit divide/modulo
│   ├── shift32.asm    # 32-bit shifts
│   └── softfloat/     # IEEE 754 soft-float (from compiler-rt)
├── libm/              # Math library
│   ├── sincosf_tiny.c # Compact sin/cos (our implementation)
│   ├── include/       # Configuration headers
│   └── Makefile       # Builds libm.a
└── picolibc/          # Embedded C library (upstream source)

TODO: Convert picolibc to a git submodule pointing to https://github.com/apullin/picolibc

cd libm
make          # Build with -Os (default, smallest)
make clean

To build with different optimization, edit CFLAGS in the Makefile.

Note: -O0 currently fails due to branch relaxation issues in the compiler.

All functions follow the TMS9900 LLVM calling convention:

• Arguments in R0, R1, R2, R3 (first 4 words)
• 32-bit values: high word first (R0:R1 or R2:R3)
• Return in R0 (16-bit) or R0:R1 (32-bit)
• R11 = link register
• Callee-saved: R9, R10 (R10 = stack pointer)

IEEE 754 single-precision floating-point operations, provided by LLVM's compiler-rt.

Located in builtins/softfloat/.

The picolibc/ directory contains upstream picolibc source. We currently use only the libm components, building selected files via libm/Makefile. This will likely expand to include libc components as the project matures.

We provide a size-optimized sinf/cosf that replaces picolibc's 7KB+ implementation with a 1.2KB version.

Standard libm sin/cos implementations use Payne-Hanek range reduction, which requires a ~200 byte table of 2/π digits and complex multi-precision arithmetic to handle sin(1e10) accurately. This pulls in 8KB+ of code.

Our implementation uses Cody-Waite style range reduction with extended-precision π/2 constants:

• pio2_hi = high part of π/2
• pio2_lo = low part (correction term)

When to use full picolibc sin/cos: If you need sin(1e10) to be accurate to full float precision, rebuild with picolibc's sf_sin.c/sf_cos.c instead of sincosf_tiny.c.

For typical embedded use (angles in radians, game physics, signal processing), our compact version is accurate and 6x smaller.

All sizes in bytes. Note: These sizes will change as the compiler improves.

Note: sinf and cosf are both in sincosf_tiny.o; linker pulls the whole object if either is used.

• -Os is the clear winner for size at 20,980 bytes
• -O1, -O2 are nearly identical (~21.5KB) - only ~500 bytes apart
• -O3 explodes to 25.8KB due to aggressive inlining (sqrtf alone: 4.4KB vs 736B)
• Speed is critical on TMS9900; -O3 may be worthwhile once we have cycle-count benchmarks
• powf is surprisingly large at 5.1KB (24% of total library size)

TODO: Benchmark -Os vs -O2 vs -O3 for runtime performance. The eventual cycle-count scheduler (with memory latency modeling) will help determine the best tradeoff.

TODO: Investigate powf size/performance. Proposed improvements:

• Special-case small integer exponents (|y| ≤ 10) with multiply loop (faster AND more precise)
• Handle negative small integers as 1/(x^n)
• Benchmark current implementation to determine if 126 soft-float calls are acceptable

Part of the llvm-99 project. See main project LICENSE. picolibc is BSD-licensed; see picolibc/COPYING.picolibc.