clang  16.0.0git
SPIR.h
Go to the documentation of this file.
1 //===--- SPIR.h - Declare SPIR and SPIR-V target feature support *- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares SPIR and SPIR-V TargetInfo objects.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_SPIR_H
14 #define LLVM_CLANG_LIB_BASIC_TARGETS_SPIR_H
15 
16 #include "clang/Basic/TargetInfo.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/Support/Compiler.h"
20 
21 namespace clang {
22 namespace targets {
23 
24 // Used by both the SPIR and SPIR-V targets.
25 static const unsigned SPIRDefIsPrivMap[] = {
26  0, // Default
27  1, // opencl_global
28  3, // opencl_local
29  2, // opencl_constant
30  0, // opencl_private
31  4, // opencl_generic
32  5, // opencl_global_device
33  6, // opencl_global_host
34  0, // cuda_device
35  0, // cuda_constant
36  0, // cuda_shared
37  // SYCL address space values for this map are dummy
38  0, // sycl_global
39  0, // sycl_global_device
40  0, // sycl_global_host
41  0, // sycl_local
42  0, // sycl_private
43  0, // ptr32_sptr
44  0, // ptr32_uptr
45  0 // ptr64
46 };
47 
48 // Used by both the SPIR and SPIR-V targets.
49 static const unsigned SPIRDefIsGenMap[] = {
50  4, // Default
51  // OpenCL address space values for this map are dummy and they can't be used
52  0, // opencl_global
53  0, // opencl_local
54  0, // opencl_constant
55  0, // opencl_private
56  0, // opencl_generic
57  0, // opencl_global_device
58  0, // opencl_global_host
59  // cuda_* address space mapping is intended for HIPSPV (HIP to SPIR-V
60  // translation). This mapping is enabled when the language mode is HIP.
61  1, // cuda_device
62  // cuda_constant pointer can be casted to default/"flat" pointer, but in
63  // SPIR-V casts between constant and generic pointers are not allowed. For
64  // this reason cuda_constant is mapped to SPIR-V CrossWorkgroup.
65  1, // cuda_constant
66  3, // cuda_shared
67  1, // sycl_global
68  5, // sycl_global_device
69  6, // sycl_global_host
70  3, // sycl_local
71  0, // sycl_private
72  0, // ptr32_sptr
73  0, // ptr32_uptr
74  0 // ptr64
75 };
76 
77 // Base class for SPIR and SPIR-V target info.
78 class LLVM_LIBRARY_VISIBILITY BaseSPIRTargetInfo : public TargetInfo {
79 protected:
80  BaseSPIRTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
81  : TargetInfo(Triple) {
82  assert((Triple.isSPIR() || Triple.isSPIRV()) &&
83  "Invalid architecture for SPIR or SPIR-V.");
84  assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
85  "SPIR(-V) target must use unknown OS");
86  assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
87  "SPIR(-V) target must use unknown environment type");
88  TLSSupported = false;
89  VLASupported = false;
90  LongWidth = LongAlign = 64;
91  AddrSpaceMap = &SPIRDefIsPrivMap;
92  UseAddrSpaceMapMangling = true;
93  HasLegalHalfType = true;
94  HasFloat16 = true;
95  // Define available target features
96  // These must be defined in sorted order!
97  NoAsmVariants = true;
98  }
99 
100 public:
101  // SPIR supports the half type and the only llvm intrinsic allowed in SPIR is
102  // memcpy as per section 3 of the SPIR spec.
103  bool useFP16ConversionIntrinsics() const override { return false; }
104 
105  ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
106 
107  const char *getClobbers() const override { return ""; }
108 
109  ArrayRef<const char *> getGCCRegNames() const override { return None; }
110 
111  bool validateAsmConstraint(const char *&Name,
112  TargetInfo::ConstraintInfo &info) const override {
113  return true;
114  }
115 
117  return None;
118  }
119 
122  }
123 
125  getDWARFAddressSpace(unsigned AddressSpace) const override {
126  return AddressSpace;
127  }
128 
130  return (CC == CC_SpirFunction || CC == CC_OpenCLKernel) ? CCCR_OK
131  : CCCR_Warning;
132  }
133 
135  return CC_SpirFunction;
136  }
137 
138  void setAddressSpaceMap(bool DefaultIsGeneric) {
139  AddrSpaceMap = DefaultIsGeneric ? &SPIRDefIsGenMap : &SPIRDefIsPrivMap;
140  }
141 
142  void adjust(DiagnosticsEngine &Diags, LangOptions &Opts) override {
143  TargetInfo::adjust(Diags, Opts);
144  // FIXME: SYCL specification considers unannotated pointers and references
145  // to be pointing to the generic address space. See section 5.9.3 of
146  // SYCL 2020 specification.
147  // Currently, there is no way of representing SYCL's and HIP/CUDA's default
148  // address space language semantic along with the semantics of embedded C's
149  // default address space in the same address space map. Hence the map needs
150  // to be reset to allow mapping to the desired value of 'Default' entry for
151  // SYCL and HIP/CUDA.
152  setAddressSpaceMap(
153  /*DefaultIsGeneric=*/Opts.SYCLIsDevice ||
154  // The address mapping from HIP/CUDA language for device code is only
155  // defined for SPIR-V.
156  (getTriple().isSPIRV() && Opts.CUDAIsDevice));
157  }
158 
159  void setSupportedOpenCLOpts() override {
160  // Assume all OpenCL extensions and optional core features are supported
161  // for SPIR and SPIR-V since they are generic targets.
162  supportAllOpenCLOpts();
163  }
164 
165  bool hasBitIntType() const override { return true; }
166 
167  bool hasInt128Type() const override { return false; }
168 };
169 
170 class LLVM_LIBRARY_VISIBILITY SPIRTargetInfo : public BaseSPIRTargetInfo {
171 public:
172  SPIRTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
173  : BaseSPIRTargetInfo(Triple, Opts) {
174  assert(Triple.isSPIR() && "Invalid architecture for SPIR.");
175  assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
176  "SPIR target must use unknown OS");
177  assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
178  "SPIR target must use unknown environment type");
179  }
180 
181  void getTargetDefines(const LangOptions &Opts,
182  MacroBuilder &Builder) const override;
183 
184  bool hasFeature(StringRef Feature) const override {
185  return Feature == "spir";
186  }
187 };
188 
189 class LLVM_LIBRARY_VISIBILITY SPIR32TargetInfo : public SPIRTargetInfo {
190 public:
191  SPIR32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
192  : SPIRTargetInfo(Triple, Opts) {
193  assert(Triple.getArch() == llvm::Triple::spir &&
194  "Invalid architecture for 32-bit SPIR.");
195  PointerWidth = PointerAlign = 32;
196  SizeType = TargetInfo::UnsignedInt;
197  PtrDiffType = IntPtrType = TargetInfo::SignedInt;
198  resetDataLayout("e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
199  "v96:128-v192:256-v256:256-v512:512-v1024:1024");
200  }
201 
202  void getTargetDefines(const LangOptions &Opts,
203  MacroBuilder &Builder) const override;
204 };
205 
206 class LLVM_LIBRARY_VISIBILITY SPIR64TargetInfo : public SPIRTargetInfo {
207 public:
208  SPIR64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
209  : SPIRTargetInfo(Triple, Opts) {
210  assert(Triple.getArch() == llvm::Triple::spir64 &&
211  "Invalid architecture for 64-bit SPIR.");
212  PointerWidth = PointerAlign = 64;
213  SizeType = TargetInfo::UnsignedLong;
214  PtrDiffType = IntPtrType = TargetInfo::SignedLong;
215  resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-"
216  "v96:128-v192:256-v256:256-v512:512-v1024:1024");
217  }
218 
219  void getTargetDefines(const LangOptions &Opts,
220  MacroBuilder &Builder) const override;
221 };
222 
223 class LLVM_LIBRARY_VISIBILITY SPIRVTargetInfo : public BaseSPIRTargetInfo {
224 public:
225  SPIRVTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
226  : BaseSPIRTargetInfo(Triple, Opts) {
227  assert(Triple.isSPIRV() && "Invalid architecture for SPIR-V.");
228  assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
229  "SPIR-V target must use unknown OS");
230  assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
231  "SPIR-V target must use unknown environment type");
232  }
233 
234  void getTargetDefines(const LangOptions &Opts,
235  MacroBuilder &Builder) const override;
236 
237  bool hasFeature(StringRef Feature) const override {
238  return Feature == "spirv";
239  }
240 };
241 
242 class LLVM_LIBRARY_VISIBILITY SPIRV32TargetInfo : public SPIRVTargetInfo {
243 public:
244  SPIRV32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
245  : SPIRVTargetInfo(Triple, Opts) {
246  assert(Triple.getArch() == llvm::Triple::spirv32 &&
247  "Invalid architecture for 32-bit SPIR-V.");
248  PointerWidth = PointerAlign = 32;
249  SizeType = TargetInfo::UnsignedInt;
250  PtrDiffType = IntPtrType = TargetInfo::SignedInt;
251  resetDataLayout("e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
252  "v96:128-v192:256-v256:256-v512:512-v1024:1024");
253  }
254 
255  void getTargetDefines(const LangOptions &Opts,
256  MacroBuilder &Builder) const override;
257 };
258 
259 class LLVM_LIBRARY_VISIBILITY SPIRV64TargetInfo : public SPIRVTargetInfo {
260 public:
261  SPIRV64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
262  : SPIRVTargetInfo(Triple, Opts) {
263  assert(Triple.getArch() == llvm::Triple::spirv64 &&
264  "Invalid architecture for 64-bit SPIR-V.");
265  PointerWidth = PointerAlign = 64;
266  SizeType = TargetInfo::UnsignedLong;
267  PtrDiffType = IntPtrType = TargetInfo::SignedLong;
268  resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-"
269  "v96:128-v192:256-v256:256-v512:512-v1024:1024");
270  }
271 
272  void getTargetDefines(const LangOptions &Opts,
273  MacroBuilder &Builder) const override;
274 };
275 
276 } // namespace targets
277 } // namespace clang
278 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_SPIR_H
clang::targets::SPIR32TargetInfo::SPIR32TargetInfo
SPIR32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: SPIR.h:191
clang::targets::SPIR64TargetInfo
Definition: SPIR.h:206
clang::targets::SPIR32TargetInfo
Definition: SPIR.h:189
clang::targets::BaseSPIRTargetInfo::adjust
void adjust(DiagnosticsEngine &Diags, LangOptions &Opts) override
Set forced language options.
Definition: SPIR.h:142
clang::targets::BaseSPIRTargetInfo::getGCCRegNames
ArrayRef< const char * > getGCCRegNames() const override
Definition: SPIR.h:109
clang::targets::BaseSPIRTargetInfo::validateAsmConstraint
bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &info) const override
Definition: SPIR.h:111
TargetInfo.h
clang::targets::SPIRVTargetInfo
Definition: SPIR.h:223
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
clang::targets::BaseSPIRTargetInfo::getBuiltinVaListKind
BuiltinVaListKind getBuiltinVaListKind() const override
Returns the kind of __builtin_va_list type that should be used with this target.
Definition: SPIR.h:120
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:191
clang::TargetInfo::VoidPtrBuiltinVaList
@ VoidPtrBuiltinVaList
typedef void* __builtin_va_list;
Definition: TargetInfo.h:279
clang::TargetInfo::adjust
virtual void adjust(DiagnosticsEngine &Diags, LangOptions &Opts)
Set forced language options.
Definition: TargetInfo.cpp:365
llvm::Optional< unsigned >
clang::targets::SPIRVTargetInfo::SPIRVTargetInfo
SPIRVTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: SPIR.h:225
clang::targets::BaseSPIRTargetInfo::getDWARFAddressSpace
Optional< unsigned > getDWARFAddressSpace(unsigned AddressSpace) const override
Definition: SPIR.h:125
clang::targets::BaseSPIRTargetInfo::hasBitIntType
bool hasBitIntType() const override
Determine whether the _BitInt type is supported on this target.
Definition: SPIR.h:165
clang::TargetInfo::BuiltinVaListKind
BuiltinVaListKind
The different kinds of __builtin_va_list types defined by the target implementation.
Definition: TargetInfo.h:274
clang::CC_OpenCLKernel
@ CC_OpenCLKernel
Definition: Specifiers.h:278
clang::targets::SPIRTargetInfo::SPIRTargetInfo
SPIRTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: SPIR.h:172
clang::targets::SPIRTargetInfo
Definition: SPIR.h:170
clang::targets::SPIRVTargetInfo::hasFeature
bool hasFeature(StringRef Feature) const override
Determine whether the given target has the given feature.
Definition: SPIR.h:237
clang::targets::BaseSPIRTargetInfo::useFP16ConversionIntrinsics
bool useFP16ConversionIntrinsics() const override
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
Definition: SPIR.h:103
clang::targets::SPIRDefIsGenMap
static const unsigned SPIRDefIsGenMap[]
Definition: SPIR.h:49
clang::CallingConv
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:264
clang::targets::SPIRV64TargetInfo::SPIRV64TargetInfo
SPIRV64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: SPIR.h:261
clang::targets::SPIRV64TargetInfo
Definition: SPIR.h:259
clang::targets::BaseSPIRTargetInfo::hasInt128Type
bool hasInt128Type() const override
Determine whether the __int128 type is supported on this target.
Definition: SPIR.h:167
clang::targets::BaseSPIRTargetInfo::getGCCRegAliases
ArrayRef< TargetInfo::GCCRegAlias > getGCCRegAliases() const override
Definition: SPIR.h:116
clang::targets::SPIR64TargetInfo::SPIR64TargetInfo
SPIR64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: SPIR.h:208
clang::targets::BaseSPIRTargetInfo::setSupportedOpenCLOpts
void setSupportedOpenCLOpts() override
Set supported OpenCL extensions and optional core features.
Definition: SPIR.h:159
clang::CC_SpirFunction
@ CC_SpirFunction
Definition: Specifiers.h:277
clang::targets::BaseSPIRTargetInfo::setAddressSpaceMap
void setAddressSpaceMap(bool DefaultIsGeneric)
Definition: SPIR.h:138
TargetOptions.h
clang::targets::BaseSPIRTargetInfo::getClobbers
const char * getClobbers() const override
Returns a string of target-specific clobbers, in LLVM format.
Definition: SPIR.h:107
llvm::ArrayRef
Definition: LLVM.h:34
clang::targets::BaseSPIRTargetInfo::getTargetBuiltins
ArrayRef< Builtin::Info > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
Definition: SPIR.h:105
clang::TargetInfo::ConstraintInfo
Definition: TargetInfo.h:1008
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:78
clang::targets::SPIRTargetInfo::hasFeature
bool hasFeature(StringRef Feature) const override
Determine whether the given target has the given feature.
Definition: SPIR.h:184
clang
Definition: CalledOnceCheck.h:17
clang::TransferrableTargetInfo::SignedInt
@ SignedInt
Definition: TargetInfo.h:127
clang::TransferrableTargetInfo::UnsignedLong
@ UnsignedLong
Definition: TargetInfo.h:130
clang::targets::SPIRDefIsPrivMap
static const unsigned SPIRDefIsPrivMap[]
Definition: SPIR.h:25
clang::targets::SPIRV32TargetInfo
Definition: SPIR.h:242
clang::targets::BaseSPIRTargetInfo::checkCallingConvention
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override
Determines whether a given calling convention is valid for the target.
Definition: SPIR.h:129
clang::targets::BaseSPIRTargetInfo
Definition: SPIR.h:78
clang::targets::SPIRV32TargetInfo::SPIRV32TargetInfo
SPIRV32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: SPIR.h:244
clang::TargetOptions
Options for controlling the target.
Definition: TargetOptions.h:26
clang::targets::BaseSPIRTargetInfo::BaseSPIRTargetInfo
BaseSPIRTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
Definition: SPIR.h:80
clang::TargetInfo::CallingConvCheckResult
CallingConvCheckResult
Definition: TargetInfo.h:1521
clang::MacroBuilder
Definition: MacroBuilder.h:23
clang::TransferrableTargetInfo::UnsignedInt
@ UnsignedInt
Definition: TargetInfo.h:128
clang::TransferrableTargetInfo::SignedLong
@ SignedLong
Definition: TargetInfo.h:129
clang::targets::BaseSPIRTargetInfo::getDefaultCallingConv
CallingConv getDefaultCallingConv() const override
Gets the default calling convention for the given target and declaration context.
Definition: SPIR.h:134