From 285dc6530b37d632cd858bac444d29044de4d283 Mon Sep 17 00:00:00 2001 From: Justin Holewinski Date: Wed, 20 Apr 2011 19:34:15 +0000 Subject: [PATCH] PTX: Add PTX intrinsics as builtins and add ptx32 and ptx64 as valid architectures for triples, e.g. ptx32-unknown-unknown git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@129870 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/BuiltinsPTX.def | 62 +++++++++++++++++ include/clang/Basic/TargetBuiltins.h | 11 ++++ lib/Basic/Targets.cpp | 86 ++++++++++++++++++++++++ test/CodeGen/builtins-ptx.c | 99 ++++++++++++++++++++++++++++ 4 files changed, 258 insertions(+) create mode 100644 include/clang/Basic/BuiltinsPTX.def create mode 100644 test/CodeGen/builtins-ptx.c diff --git a/include/clang/Basic/BuiltinsPTX.def b/include/clang/Basic/BuiltinsPTX.def new file mode 100644 index 0000000000..f90a43f7f4 --- /dev/null +++ b/include/clang/Basic/BuiltinsPTX.def @@ -0,0 +1,62 @@ +//===--- BuiltinsPTX.def - PTX Builtin function database ----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the PTX-specific builtin function database. Users of +// this file must define the BUILTIN macro to make use of this information. +// +//===----------------------------------------------------------------------===// + +// The format of this database matches clang/Basic/Builtins.def. + +BUILTIN(__builtin_ptx_read_tid_x, "i", "nc") +BUILTIN(__builtin_ptx_read_tid_y, "i", "nc") +BUILTIN(__builtin_ptx_read_tid_z, "i", "nc") +BUILTIN(__builtin_ptx_read_tid_w, "i", "nc") + +BUILTIN(__builtin_ptx_read_ntid_x, "i", "nc") +BUILTIN(__builtin_ptx_read_ntid_y, "i", "nc") +BUILTIN(__builtin_ptx_read_ntid_z, "i", "nc") +BUILTIN(__builtin_ptx_read_ntid_w, "i", "nc") + +BUILTIN(__builtin_ptx_read_ctaid_x, "i", "nc") +BUILTIN(__builtin_ptx_read_ctaid_y, "i", "nc") +BUILTIN(__builtin_ptx_read_ctaid_z, "i", "nc") +BUILTIN(__builtin_ptx_read_ctaid_w, "i", "nc") + +BUILTIN(__builtin_ptx_read_nctaid_x, "i", "nc") +BUILTIN(__builtin_ptx_read_nctaid_y, "i", "nc") +BUILTIN(__builtin_ptx_read_nctaid_z, "i", "nc") +BUILTIN(__builtin_ptx_read_nctaid_w, "i", "nc") + +BUILTIN(__builtin_ptx_read_laneid, "i", "nc") +BUILTIN(__builtin_ptx_read_warpid, "i", "nc") +BUILTIN(__builtin_ptx_read_nwarpid, "i", "nc") + +BUILTIN(__builtin_ptx_read_smid, "i", "nc") +BUILTIN(__builtin_ptx_read_nsmid, "i", "nc") +BUILTIN(__builtin_ptx_read_gridid, "i", "nc") + +BUILTIN(__builtin_ptx_read_lanemask_eq, "i", "nc") +BUILTIN(__builtin_ptx_read_lanemask_le, "i", "nc") +BUILTIN(__builtin_ptx_read_lanemask_lt, "i", "nc") +BUILTIN(__builtin_ptx_read_lanemask_ge, "i", "nc") +BUILTIN(__builtin_ptx_read_lanemask_gt, "i", "nc") + +BUILTIN(__builtin_ptx_read_clock, "i", "n") +BUILTIN(__builtin_ptx_read_clock64, "Li", "n") + +BUILTIN(__builtin_ptx_read_pm0, "i", "n") +BUILTIN(__builtin_ptx_read_pm1, "i", "n") +BUILTIN(__builtin_ptx_read_pm2, "i", "n") +BUILTIN(__builtin_ptx_read_pm3, "i", "n") + +BUILTIN(__builtin_ptx_bar_sync, "vi", "n") + + +#undef BUILTIN diff --git a/include/clang/Basic/TargetBuiltins.h b/include/clang/Basic/TargetBuiltins.h index f1edd1d451..8bc60ff538 100644 --- a/include/clang/Basic/TargetBuiltins.h +++ b/include/clang/Basic/TargetBuiltins.h @@ -35,6 +35,17 @@ namespace clang { }; } + /// PTX builtins + namespace PTX { + enum { + LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1, +#define BUILTIN(ID, TYPE, ATTRS) BI##ID, +#include "clang/Basic/BuiltinsPTX.def" + LastTSBuiltin + }; + } + + /// X86 builtins namespace X86 { enum { diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp index f331c50a21..fd7168d16c 100644 --- a/lib/Basic/Targets.cpp +++ b/lib/Basic/Targets.cpp @@ -844,6 +844,87 @@ public: }; } // end anonymous namespace. +namespace { + class PTXTargetInfo : public TargetInfo { + static const char * const GCCRegNames[]; + static const Builtin::Info BuiltinInfo[]; + public: + PTXTargetInfo(const std::string& triple) : TargetInfo(triple) { + TLSSupported = false; + LongWidth = LongAlign = 64; + } + virtual void getTargetDefines(const LangOptions &Opts, + MacroBuilder &Builder) const { + Builder.defineMacro("__PTX__"); + } + virtual void getTargetBuiltins(const Builtin::Info *&Records, + unsigned &NumRecords) const { + Records = BuiltinInfo; + NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin; + } + + virtual void getGCCRegNames(const char * const *&Names, + unsigned &NumNames) const; + virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, + unsigned &NumAliases) const { + // No aliases. + Aliases = 0; + NumAliases = 0; + } + virtual bool validateAsmConstraint(const char *&Name, + TargetInfo::ConstraintInfo &info) const { + // FIXME: implement + return true; + } + virtual const char *getClobbers() const { + // FIXME: Is this really right? + return ""; + } + virtual const char *getVAListDeclaration() const { + // FIXME: implement + return "typedef char* __builtin_va_list;"; + } + }; + + const Builtin::Info PTXTargetInfo::BuiltinInfo[] = { +#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false }, +#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ + ALL_LANGUAGES, false }, +#include "clang/Basic/BuiltinsPTX.def" + }; + + const char * const PTXTargetInfo::GCCRegNames[] = { + "r0" + }; + + void PTXTargetInfo::getGCCRegNames(const char * const *&Names, + unsigned &NumNames) const { + Names = GCCRegNames; + NumNames = llvm::array_lengthof(GCCRegNames); + } + + + class PTX32TargetInfo : public PTXTargetInfo { + public: + PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) { + PointerWidth = PointerAlign = 32; + SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt; + DescriptionString + = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64"; + } + }; + + class PTX64TargetInfo : public PTXTargetInfo { + public: + PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) { + PointerWidth = PointerAlign = 64; + SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong; + DescriptionString + = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64"; + } + }; +} + namespace { // MBlaze abstract base class class MBlazeTargetInfo : public TargetInfo { @@ -2659,6 +2740,11 @@ static TargetInfo *AllocateTarget(const std::string &T) { return new FreeBSDTargetInfo(T); return new PPC64TargetInfo(T); + case llvm::Triple::ptx32: + return new PTX32TargetInfo(T); + case llvm::Triple::ptx64: + return new PTX64TargetInfo(T); + case llvm::Triple::mblaze: return new MBlazeTargetInfo(T); diff --git a/test/CodeGen/builtins-ptx.c b/test/CodeGen/builtins-ptx.c new file mode 100644 index 0000000000..6dd10188e9 --- /dev/null +++ b/test/CodeGen/builtins-ptx.c @@ -0,0 +1,99 @@ +// RUN: %clang_cc1 -triple ptx32-unknown-unknown -emit-llvm -o %t %s +// RUN: %clang_cc1 -triple ptx64-unknown-unknown -emit-llvm -o %t %s + + +int read_tid() { + + int x = __builtin_ptx_read_tid_x(); + int y = __builtin_ptx_read_tid_y(); + int z = __builtin_ptx_read_tid_z(); + int w = __builtin_ptx_read_tid_w(); + + return x + y + z + w; + +} + +int read_ntid() { + + int x = __builtin_ptx_read_ntid_x(); + int y = __builtin_ptx_read_ntid_y(); + int z = __builtin_ptx_read_ntid_z(); + int w = __builtin_ptx_read_ntid_w(); + + return x + y + z + w; + +} + +int read_ctaid() { + + int x = __builtin_ptx_read_ctaid_x(); + int y = __builtin_ptx_read_ctaid_y(); + int z = __builtin_ptx_read_ctaid_z(); + int w = __builtin_ptx_read_ctaid_w(); + + return x + y + z + w; + +} + +int read_nctaid() { + + int x = __builtin_ptx_read_nctaid_x(); + int y = __builtin_ptx_read_nctaid_y(); + int z = __builtin_ptx_read_nctaid_z(); + int w = __builtin_ptx_read_nctaid_w(); + + return x + y + z + w; + +} + +int read_ids() { + + int a = __builtin_ptx_read_laneid(); + int b = __builtin_ptx_read_warpid(); + int c = __builtin_ptx_read_nwarpid(); + int d = __builtin_ptx_read_smid(); + int e = __builtin_ptx_read_nsmid(); + int f = __builtin_ptx_read_gridid(); + + return a + b + c + d + e + f; + +} + +int read_lanemasks() { + + int a = __builtin_ptx_read_lanemask_eq(); + int b = __builtin_ptx_read_lanemask_le(); + int c = __builtin_ptx_read_lanemask_lt(); + int d = __builtin_ptx_read_lanemask_ge(); + int e = __builtin_ptx_read_lanemask_gt(); + + return a + b + c + d + e; + +} + + +long read_clocks() { + + int a = __builtin_ptx_read_clock(); + long b = __builtin_ptx_read_clock64(); + + return (long)a + b; + +} + +int read_pms() { + + int a = __builtin_ptx_read_pm0(); + int b = __builtin_ptx_read_pm1(); + int c = __builtin_ptx_read_pm2(); + int d = __builtin_ptx_read_pm3(); + + return a + b + c + d; + +} + +void sync() { + + __builtin_ptx_bar_sync(0); + +}