diff --git a/Makefile b/Makefile index 72eb98b3..4d3063cd 100644 --- a/Makefile +++ b/Makefile @@ -118,9 +118,14 @@ HEADERS=ast.h builtins.h ctx.h decl.h expr.h func.h ispc.h llvmutil.h module.h \ opt.h stmt.h sym.h type.h util.h TARGETS=avx1 avx1-x2 avx11 avx11-x2 avx2 avx2-x2 sse2 sse2-x2 sse4 sse4-x2 \ generic-4 generic-8 generic-16 generic-32 generic-64 generic-1 -BUILTINS_SRC=$(addprefix builtins/target-, $(addsuffix .ll, $(TARGETS))) \ - builtins/dispatch.ll -BUILTINS_OBJS=$(addprefix builtins-, $(notdir $(BUILTINS_SRC:.ll=.o))) \ +# These files need to be compiled in two versions - 32 and 64 bits. +BUILTINS_SRC_TARGET=$(addprefix builtins/target-, $(addsuffix .ll, $(TARGETS))) +# These are files to be compiled in single version. +BUILTINS_SRC_COMMON=builtins/dispatch.ll +BUILTINS_OBJS_32=$(addprefix builtins-, $(notdir $(BUILTINS_SRC_TARGET:.ll=-32bit.o))) +BUILTINS_OBJS_64=$(addprefix builtins-, $(notdir $(BUILTINS_SRC_TARGET:.ll=-64bit.o))) +BUILTINS_OBJS=$(addprefix builtins-, $(notdir $(BUILTINS_SRC_COMMON:.ll=.o))) \ + $(BUILTINS_OBJS_32) $(BUILTINS_OBJS_64) \ builtins-c-32.cpp builtins-c-64.cpp BISON_SRC=parse.yy FLEX_SRC=lex.ll @@ -212,17 +217,25 @@ objs/lex.o: objs/lex.cpp $(HEADERS) objs/parse.cc @echo Compiling $< @$(CXX) $(CXXFLAGS) -o $@ -c $< -objs/builtins-%.cpp: builtins/%.ll builtins/util.m4 $(wildcard builtins/*common.ll) +objs/builtins-dispatch.cpp: builtins/dispatch.ll builtins/util.m4 $(wildcard builtins/*common.ll) @echo Creating C++ source from builtins definition file $< @m4 -Ibuiltins/ -DLLVM_VERSION=$(LLVM_VERSION) -DBUILD_OS=UNIX $< | python bitcode2cpp.py $< > $@ +objs/builtins-%-32bit.cpp: builtins/%.ll builtins/util.m4 $(wildcard builtins/*common.ll) + @echo Creating C++ source from builtins definition file $< \(32 bit version\) + @m4 -Ibuiltins/ -DLLVM_VERSION=$(LLVM_VERSION) -DBUILD_OS=UNIX -DRUNTIME=32 $< | python bitcode2cpp.py $< 32bit > $@ + +objs/builtins-%-64bit.cpp: builtins/%.ll builtins/util.m4 $(wildcard builtins/*common.ll) + @echo Creating C++ source from builtins definition file $< \(64 bit version\) + @m4 -Ibuiltins/ -DLLVM_VERSION=$(LLVM_VERSION) -DBUILD_OS=UNIX -DRUNTIME=64 $< | python bitcode2cpp.py $< 64bit > $@ + objs/builtins-c-32.cpp: builtins/builtins.c @echo Creating C++ source from builtins definition file $< - @$(CLANG) -m32 -emit-llvm -c $< -o - | llvm-dis - | python bitcode2cpp.py c-32 > $@ + @$(CLANG) -m32 -emit-llvm -c $< -o - | llvm-dis - | python bitcode2cpp.py c 32 > $@ objs/builtins-c-64.cpp: builtins/builtins.c @echo Creating C++ source from builtins definition file $< - @$(CLANG) -m64 -emit-llvm -c $< -o - | llvm-dis - | python bitcode2cpp.py c-64 > $@ + @$(CLANG) -m64 -emit-llvm -c $< -o - | llvm-dis - | python bitcode2cpp.py c 64 > $@ objs/stdlib_generic_ispc.cpp: stdlib.ispc @echo Creating C++ source from $< for generic diff --git a/bitcode2cpp.py b/bitcode2cpp.py index aaeb1f29..10a28153 100755 --- a/bitcode2cpp.py +++ b/bitcode2cpp.py @@ -10,6 +10,8 @@ import os length=0 src=str(sys.argv[1]) +if (len(sys.argv) > 2): + runtime=str(sys.argv[2]) target = re.sub("builtins/target-", "", src) target = re.sub(r"builtins\\target-", "", target) @@ -29,8 +31,11 @@ except IOError: sys.stderr.write("Couldn't open " + src) sys.exit(1) +name = target +if (len(sys.argv) > 2): + name += "_" + runtime; width = 16; -sys.stdout.write("unsigned char builtins_bitcode_" + target + "[] = {\n") +sys.stdout.write("unsigned char builtins_bitcode_" + name + "[] = {\n") data = as_out.stdout.read() for i in range(0, len(data), 1): @@ -40,7 +45,7 @@ for i in range(0, len(data), 1): sys.stdout.write("\n") sys.stdout.write("0x00 };\n\n") -sys.stdout.write("int builtins_bitcode_" + target + "_length = " + str(i+1) + ";\n") +sys.stdout.write("int builtins_bitcode_" + name + "_length = " + str(i+1) + ";\n") as_out.wait() diff --git a/builtins.cpp b/builtins.cpp index 69559b51..085c1ea3 100644 --- a/builtins.cpp +++ b/builtins.cpp @@ -776,169 +776,195 @@ lDefineProgramIndex(llvm::Module *module, SymbolTable *symbolTable) { void DefineStdlib(SymbolTable *symbolTable, llvm::LLVMContext *ctx, llvm::Module *module, bool includeStdlibISPC) { + bool runtime32 = g->target->is32Bit(); + +#define EXPORT_MODULE(export_module) \ + extern unsigned char export_module[]; \ + extern int export_module##_length; \ + AddBitcodeToModule(export_module, export_module##_length, \ + module, symbolTable); + // Add the definitions from the compiled builtins-c.c file - if (g->target->is32Bit()) { - extern unsigned char builtins_bitcode_c_32[]; - extern int builtins_bitcode_c_32_length; - AddBitcodeToModule(builtins_bitcode_c_32, builtins_bitcode_c_32_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_c_32); } else { - extern unsigned char builtins_bitcode_c_64[]; - extern int builtins_bitcode_c_64_length; - AddBitcodeToModule(builtins_bitcode_c_64, builtins_bitcode_c_64_length, - module, symbolTable); + EXPORT_MODULE(builtins_bitcode_c_64); } // Next, add the target's custom implementations of the various needed // builtin functions (e.g. __masked_store_32(), etc). switch (g->target->getISA()) { - case Target::SSE2: - extern unsigned char builtins_bitcode_sse2[]; - extern int builtins_bitcode_sse2_length; - extern unsigned char builtins_bitcode_sse2_x2[]; - extern int builtins_bitcode_sse2_x2_length; + case Target::SSE2: { switch (g->target->getVectorWidth()) { case 4: - AddBitcodeToModule(builtins_bitcode_sse2, builtins_bitcode_sse2_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_sse2_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_sse2_64bit); + } break; case 8: - AddBitcodeToModule(builtins_bitcode_sse2_x2, builtins_bitcode_sse2_x2_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_sse2_x2_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_sse2_x2_64bit); + } break; default: FATAL("logic error in DefineStdlib"); } break; - case Target::SSE4: - extern unsigned char builtins_bitcode_sse4[]; - extern int builtins_bitcode_sse4_length; - extern unsigned char builtins_bitcode_sse4_x2[]; - extern int builtins_bitcode_sse4_x2_length; + } + case Target::SSE4: { switch (g->target->getVectorWidth()) { case 4: - AddBitcodeToModule(builtins_bitcode_sse4, - builtins_bitcode_sse4_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_sse4_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_sse4_64bit); + } break; case 8: - AddBitcodeToModule(builtins_bitcode_sse4_x2, - builtins_bitcode_sse4_x2_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_sse4_x2_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_sse4_x2_64bit); + } break; default: FATAL("logic error in DefineStdlib"); } break; - case Target::AVX: + } + case Target::AVX: { switch (g->target->getVectorWidth()) { case 8: - extern unsigned char builtins_bitcode_avx1[]; - extern int builtins_bitcode_avx1_length; - AddBitcodeToModule(builtins_bitcode_avx1, - builtins_bitcode_avx1_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_avx1_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_avx1_64bit); + } break; case 16: - extern unsigned char builtins_bitcode_avx1_x2[]; - extern int builtins_bitcode_avx1_x2_length; - AddBitcodeToModule(builtins_bitcode_avx1_x2, - builtins_bitcode_avx1_x2_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_avx1_x2_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_avx1_x2_64bit); + } break; default: FATAL("logic error in DefineStdlib"); } break; - case Target::AVX11: + } + case Target::AVX11: { switch (g->target->getVectorWidth()) { case 8: - extern unsigned char builtins_bitcode_avx11[]; - extern int builtins_bitcode_avx11_length; - AddBitcodeToModule(builtins_bitcode_avx11, - builtins_bitcode_avx11_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_avx11_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_avx11_64bit); + } break; case 16: - extern unsigned char builtins_bitcode_avx11_x2[]; - extern int builtins_bitcode_avx11_x2_length; - AddBitcodeToModule(builtins_bitcode_avx11_x2, - builtins_bitcode_avx11_x2_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_avx11_x2_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_avx11_x2_64bit); + } break; default: FATAL("logic error in DefineStdlib"); } break; - case Target::AVX2: + } + case Target::AVX2: { switch (g->target->getVectorWidth()) { case 8: - extern unsigned char builtins_bitcode_avx2[]; - extern int builtins_bitcode_avx2_length; - AddBitcodeToModule(builtins_bitcode_avx2, - builtins_bitcode_avx2_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_avx2_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_avx2_64bit); + } break; case 16: - extern unsigned char builtins_bitcode_avx2_x2[]; - extern int builtins_bitcode_avx2_x2_length; - AddBitcodeToModule(builtins_bitcode_avx2_x2, - builtins_bitcode_avx2_x2_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_avx2_x2_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_avx2_x2_64bit); + } break; default: FATAL("logic error in DefineStdlib"); } break; - case Target::GENERIC: + } + case Target::GENERIC: { switch (g->target->getVectorWidth()) { case 4: - extern unsigned char builtins_bitcode_generic_4[]; - extern int builtins_bitcode_generic_4_length; - AddBitcodeToModule(builtins_bitcode_generic_4, - builtins_bitcode_generic_4_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_generic_4_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_generic_4_64bit); + } break; case 8: - extern unsigned char builtins_bitcode_generic_8[]; - extern int builtins_bitcode_generic_8_length; - AddBitcodeToModule(builtins_bitcode_generic_8, - builtins_bitcode_generic_8_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_generic_8_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_generic_8_64bit); + } break; case 16: - extern unsigned char builtins_bitcode_generic_16[]; - extern int builtins_bitcode_generic_16_length; - AddBitcodeToModule(builtins_bitcode_generic_16, - builtins_bitcode_generic_16_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_generic_16_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_generic_4_64bit); + } break; case 32: - extern unsigned char builtins_bitcode_generic_32[]; - extern int builtins_bitcode_generic_32_length; - AddBitcodeToModule(builtins_bitcode_generic_32, - builtins_bitcode_generic_32_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_generic_32_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_generic_32_64bit); + } break; case 64: - extern unsigned char builtins_bitcode_generic_64[]; - extern int builtins_bitcode_generic_64_length; - AddBitcodeToModule(builtins_bitcode_generic_64, - builtins_bitcode_generic_64_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_generic_64_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_generic_64_64bit); + } break; case 1: - extern unsigned char builtins_bitcode_generic_1[]; - extern int builtins_bitcode_generic_1_length; - AddBitcodeToModule(builtins_bitcode_generic_1, - builtins_bitcode_generic_1_length, - module, symbolTable); + if (runtime32) { + EXPORT_MODULE(builtins_bitcode_generic_1_32bit); + } + else { + EXPORT_MODULE(builtins_bitcode_generic_1_64bit); + } break; default: FATAL("logic error in DefineStdlib"); } break; + } default: FATAL("logic error"); }