begin low-level runtime implementation

llrtc/lib/Makefile

@@ -0,0 +1,44 @@
+OUTPUT = llrt
+SOURCES = udivmod64.c
+
+CLANG = clang
+CF = -Wall -ansi
+CF_TEST = $(CF) -ftrapv
+CF_BUILD = $(CF) -O0 -emit-llvm
+OUTDIR = ..
+
+all: ir
+
+ir: $(SOURCES)
+	$(CLANG) -m32 $(CF_BUILD) -S -o $(OUTDIR)/$(OUTPUT)_x86.ll -c $(SOURCES)
+	python ../tools/striptriple.py $(OUTDIR)/$(OUTPUT)_x86.ll
+	$(CLANG) -m64 $(CF_BUILD) -S -o $(OUTDIR)/$(OUTPUT)_x86_64.ll -c $(SOURCES)
+	python ../tools/striptriple.py $(OUTDIR)/$(OUTPUT)_x86_64.ll
+
+lib$(OUTPUT).a: $(SOURCES)
+	$(CLANG) $(CF) -o $@ -c $+
+
+build-test:  lib$(OUTPUT).a
+	for src in $(SOURCES); do \
+		$(CLANG) $(CF_TEST) -o test_$${src%.*} test_$$src -L. -lllrt; \
+	done;
+
+test: build-test
+	for src in $(SOURCES); do \
+		echo "testing $${src%.*}";				 \
+		python test_$${src%.*}.py > test_$${src%.*}.out;	 \
+	done;
+
+clean-test:
+	rm -f *.out
+	rm -f *.a
+	for src in $(SOURCES); do \
+		rm -f test_$${src%.*}	;\
+	done;
+
+clean-dist:
+	rm $(OUTDIR)/*.ll
+
+clean: clean-test clean-dist
+
+udivmod64.c: udivmod64.h

llrtc/lib/test_udivmod64.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdint.h>
+
+extern uint64_t
+udivmod64(uint64_t dividend, uint64_t divisor, uint64_t *remainder);
+
+int main(int argc, char * argv[]){
+    uint64_t n, d, q, r;
+    if (argc != 3) {
+        printf("invalid argument: %s dividend divisor", argv[0]);
+        return 1;
+    }
+    sscanf(argv[1], "%llu", &n);
+    sscanf(argv[2], "%llu", &d);
+
+    q = udivmod64(n, d, &r);
+
+    printf("%llu\n", q);
+    printf("%llu\n", r);
+
+    return 0;
+}

llrtc/lib/test_udivmod64.py

@@ -0,0 +1,53 @@
+import math
+import os
+import subprocess
+udt = os.path.join('.', 'test_udivmod64')
+
+def testcase(dividend, divisor):
+    print 'divmod64(%d, %d)' % (dividend, divisor)
+
+    procargs = ('%s %s %s' % (udt, dividend, divisor)).split()
+    result = subprocess.check_output(procargs)
+    gotQ, gotR = map(int, result.splitlines())
+
+    expectQ = dividend // divisor
+    expectR = dividend % divisor
+
+    print 'Q = %d, R = %d' % (gotQ, gotR)
+
+    if expectQ != gotQ:
+        raise ValueError("invalid quotient: got=%d but expect=%d" %
+                         (gotQ, expectQ))
+    if expectR != gotR:
+        raise ValueError("invalid remainder: got=%d but expect=%d" %
+                         (gotR, expectR))
+    print 'OK'
+
+def testsequence():
+    subjects = [
+        (0, 1),
+        (0, 0xffffffffffffffff),
+        (1, 2),
+        (1, 983219),
+        (2, 2),
+        (3, 2),
+        (1024, 2),
+        (2048, 512),
+        (21321, 512),
+        (9329189, 1031),
+        (0xffffffff, 2),
+        (0xffffffff, 0xffff),
+        (0x1ffffffff, 2),
+        (0x1ffffffff, 0xffff),
+        (0xffff, 0xffffffff),
+        (0xffffffffffffffff, 0xffff),
+        (0xffffffffffffffff, 0x7fffffffffffffff),
+        (0xffffffffffffffff, 0xfffffffffffffff0),
+        (0xffffffffffffffff, 87655678587161901),
+    ]
+
+    for dvd, dvr in subjects:
+        testcase(dvd, dvr)
+
+if __name__ == '__main__':
+    testsequence()

llrtc/lib/udivmod64.c

@@ -0,0 +1,84 @@
+/*
+Implements unsigned divmod using for platform missing 64-bit division and/or
+modulo functions.
+*/
+#include "udivmod64.h"
+
+/*
+count left zero for 64-bit words
+
+*/
+static
+int clz64(uint64_t x)
+{
+    const int total_bits = sizeof(x) * BITS_PER_BYTE;
+    int zc = 0;
+
+    while (zc < total_bits && ((x >> (total_bits - zc - 1)) & 1) == 0) {
+        ++zc;
+    }
+    return zc;
+}
+
+typedef struct div_state_
+{
+    uint64_t tmp, dvd;
+} div_state;
+
+/*
+Left shift div_state by 1 bit
+*/
+static
+void div_state_lshift(div_state *state)
+{
+    state->tmp = (state->tmp << 1) | (state->dvd >> 63);
+    state->dvd = state->dvd << 1;
+}
+
+/*
+Division of unsigned 64-bit word using 64-bit addition and subtration following
+the shift-restore division algorithm.
+For those interested in 32-bit implementation,
+mapping of 64-bit addition and subtraction to 32-bit should be trivial.
+
+Reference: 
+    - IBM. The PowerPC Compiler Writer's Guide
+    - LLVM compiler-rt
+
+Assumptions:
+    - all operands and results are positive
+    - unsigned wrapped around
+*/
+uint64_t udivmod64(uint64_t dividend, uint64_t divisor, uint64_t *remainder)
+{
+    div_state state = {0, dividend};
+    uint64_t quotient = 0;
+    int i;
+    int skipahead;
+
+    if (divisor == 0) {
+        return 1 / 0;               /* intentionally div by zero */
+    }
+
+    /*
+    skipahead to reduce iteration
+    */
+    skipahead = clz64(dividend);
+
+    for (i = 0; i < skipahead; ++i) {
+        div_state_lshift(&state);
+    }
+
+    /*
+    division loop
+    */
+    for (i = skipahead; i < 64; ++i) {
+        div_state_lshift(&state);
+        if (state.tmp >= divisor) {
+            state.tmp = state.tmp - divisor;
+            quotient |= 1ull << (63 - i);
+        }
+    }
+    *remainder = state.tmp;
+    return quotient;
+}

llrtc/lib/udivmod64.h

@@ -0,0 +1,11 @@
+#ifndef LLRT_UDIVMOD_H_
+#define LLRT_UDIVMOD_H_
+
+#include <stdint.h>
+
+#define BITS_PER_BYTE 8
+
+uint64_t udivmod64(uint64_t dividend, uint64_t divisor, uint64_t *remainder);
+
+#endif /* LLRT_UDIVMOD_H_ */
+