added basic printing from ptx

builtins.cpp

@@ -415,6 +415,7 @@ lSetInternalFunctions(llvm::Module *module) {
         "__do_assert_uniform",
         "__do_assert_varying",
         "__do_print",
+        "__do_print_nvptx",
         "__doublebits_uniform_int64",
         "__doublebits_varying_int64",
         "__exclusive_scan_add_double",

builtins/builtins.c

@@ -185,6 +185,77 @@ void __do_print(const char *format, const char *types, int width, uint64_t mask,
     fflush(stdout);
 }
 
+/* this is print for PTX target only */
+int __puts_nvptx(const char *);
+void __do_print_nvptx(const char *format, const char *types, int width, uint64_t mask,
+                void **args) {
+    char printString[PRINT_BUF_SIZE+1]; // +1 for trailing NUL
+    char *bufp = &printString[0];
+    char tmpBuf[256];
+
+    int argCount = 0;
+    while (*format && bufp < &printString[PRINT_BUF_SIZE]) {
+        // Format strings are just single percent signs.
+        if (*format != '%') {
+            *bufp++ = *format;
+        }
+        else {
+            if (*types) {
+                void *ptr = args[argCount++];
+                // Based on the encoding in the types string, cast the
+                // value appropriately and print it with a reasonable
+                // printf() formatting string.
+                switch (*types) {
+                case 'b': {
+                    sprintf(tmpBuf, "%s", *((Bool *)ptr) ? "true" : "false");
+                    APPEND(tmpBuf);
+                    break;
+                }
+                case 'B': {
+                    *bufp++ = '[';
+                    if (bufp == &printString[PRINT_BUF_SIZE])
+                        break;
+                    for (int i = 0; i < width; ++i) {
+                        if (mask & (1ull << i)) {
+                            sprintf(tmpBuf, "%s", ((Bool *)ptr)[i] ? "true" : "false");
+                            APPEND(tmpBuf);
+                        }
+                        else
+                            APPEND("_________");
+                        *bufp++ = (i != width-1) ? ',' : ']';
+                    }
+                    break;
+                }
+                case 'i': PRINT_SCALAR("%d", int);
+                case 'I': PRINT_VECTOR("%d", int);
+                case 'u': PRINT_SCALAR("%u", unsigned int);
+                case 'U': PRINT_VECTOR("%u", unsigned int);
+                case 'f': PRINT_SCALAR("%f", float);
+                case 'F': PRINT_VECTOR("%f", float);
+                case 'l': PRINT_SCALAR("%lld", long long);
+                case 'L': PRINT_VECTOR("%lld", long long);
+                case 'v': PRINT_SCALAR("%llu", unsigned long long);
+                case 'V': PRINT_VECTOR("%llu", unsigned long long);
+                case 'd': PRINT_SCALAR("%f", double);
+                case 'D': PRINT_VECTOR("%f", double);
+                case 'p': PRINT_SCALAR("%p", void *);
+                case 'P': PRINT_VECTOR("%p", void *);
+                default:
+                    APPEND("UNKNOWN TYPE ");
+                    *bufp++ = *types;
+                }
+                ++types;
+            }
+        }
+        ++format;
+    }
+
+ done:
+    *bufp = '\n'; bufp++;
+    *bufp = '\0';
+    __puts_nvptx(printString);
+}
+
 
 int __num_cores() {
 #if defined(_MSC_VER) || defined(__MINGW32__)

builtins/target-nvptx.ll

@@ -1396,11 +1396,11 @@ define i32 @__puts_nvptx(i8*) alwaysinline
   %str   = ptrtoint i8* %0 to i64
   %parm  = or i64 0, 0
   %call  = call i32 @vprintf(i64 %str, i64 %parm)
-  %cr    = alloca <2 x i8>
+;;  %cr    = alloca <3 x i8>
-  store <2 x i8> <i8 10, i8 0>, <2 x i8>* %cr
+;;  store <3 x i8> <i8 13, i8 10, i8 0>, <3 x i8>* %cr
-  %cr1   = ptrtoint <2 x i8>* %cr to i64
+;;  %cr1   = ptrtoint <3 x i8>* %cr to i64
-  %call1 = call i32 @vprintf(i64 %cr1, i64 %parm)
+;;  %call1 = call i32 @vprintf(i64 %cr1, i64 %parm)
-  ret i32 %call1;
+  ret i32 %call;
 }
 define void @__abort_nvptx(i8* %str) noreturn
 {

stmt.cpp

@@ -3352,7 +3352,8 @@ PrintStmt::EmitCode(FunctionEmitContext *ctx) const {
     }
 
     // Now we can emit code to call __do_print()
-    llvm::Function *printFunc = m->module->getFunction("__do_print");
+    llvm::Function *printFunc = g->target->getISA() != Target::NVPTX ?
+      m->module->getFunction("__do_print") : m->module->getFunction("__do_print_nvptx");
     AssertPos(pos, printFunc);
 
     llvm::Value *mask = ctx->GetFullMask();