1 | //===---- TargetInfo.h - Encapsulate target details -------------*- 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 | // These classes wrap the information about a call or function |
10 | // definition used to handle ABI compliancy. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_CLANG_LIB_CODEGEN_TARGETINFO_H |
15 | #define LLVM_CLANG_LIB_CODEGEN_TARGETINFO_H |
16 | |
17 | #include "CGBuilder.h" |
18 | #include "CodeGenModule.h" |
19 | #include "CGValue.h" |
20 | #include "clang/AST/Type.h" |
21 | #include "clang/Basic/LLVM.h" |
22 | #include "clang/Basic/SyncScope.h" |
23 | #include "llvm/ADT/SmallString.h" |
24 | #include "llvm/ADT/StringRef.h" |
25 | |
26 | namespace llvm { |
27 | class Constant; |
28 | class GlobalValue; |
29 | class Type; |
30 | class Value; |
31 | } |
32 | |
33 | namespace clang { |
34 | class Decl; |
35 | |
36 | namespace CodeGen { |
37 | class ABIInfo; |
38 | class CallArgList; |
39 | class CodeGenFunction; |
40 | class CGBlockInfo; |
41 | class SwiftABIInfo; |
42 | |
43 | /// TargetCodeGenInfo - This class organizes various target-specific |
44 | /// codegeneration issues, like target-specific attributes, builtins and so |
45 | /// on. |
46 | class TargetCodeGenInfo { |
47 | std::unique_ptr<ABIInfo> Info; |
48 | |
49 | protected: |
50 | // Target hooks supporting Swift calling conventions. The target must |
51 | // initialize this field if it claims to support these calling conventions |
52 | // by returning true from TargetInfo::checkCallingConvention for them. |
53 | std::unique_ptr<SwiftABIInfo> SwiftInfo; |
54 | |
55 | // Returns ABI info helper for the target. This is for use by derived classes. |
56 | template <typename T> const T &getABIInfo() const { |
57 | return static_cast<const T &>(*Info); |
58 | } |
59 | |
60 | public: |
61 | TargetCodeGenInfo(std::unique_ptr<ABIInfo> Info); |
62 | virtual ~TargetCodeGenInfo(); |
63 | |
64 | /// getABIInfo() - Returns ABI info helper for the target. |
65 | const ABIInfo &getABIInfo() const { return *Info; } |
66 | |
67 | /// Returns Swift ABI info helper for the target. |
68 | const SwiftABIInfo &getSwiftABIInfo() const { |
69 | assert(SwiftInfo && "Swift ABI info has not been initialized" ); |
70 | return *SwiftInfo; |
71 | } |
72 | |
73 | /// setTargetAttributes - Provides a convenient hook to handle extra |
74 | /// target-specific attributes for the given global. |
75 | virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, |
76 | CodeGen::CodeGenModule &M) const {} |
77 | |
78 | /// emitTargetMetadata - Provides a convenient hook to handle extra |
79 | /// target-specific metadata for the given globals. |
80 | virtual void emitTargetMetadata( |
81 | CodeGen::CodeGenModule &CGM, |
82 | const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames) const {} |
83 | |
84 | /// Any further codegen related checks that need to be done on a function call |
85 | /// in a target specific manner. |
86 | virtual void checkFunctionCallABI(CodeGenModule &CGM, SourceLocation CallLoc, |
87 | const FunctionDecl *Caller, |
88 | const FunctionDecl *Callee, |
89 | const CallArgList &Args) const {} |
90 | |
91 | /// Determines the size of struct _Unwind_Exception on this platform, |
92 | /// in 8-bit units. The Itanium ABI defines this as: |
93 | /// struct _Unwind_Exception { |
94 | /// uint64 exception_class; |
95 | /// _Unwind_Exception_Cleanup_Fn exception_cleanup; |
96 | /// uint64 private_1; |
97 | /// uint64 private_2; |
98 | /// }; |
99 | virtual unsigned getSizeOfUnwindException() const; |
100 | |
101 | /// Controls whether __builtin_extend_pointer should sign-extend |
102 | /// pointers to uint64_t or zero-extend them (the default). Has |
103 | /// no effect for targets: |
104 | /// - that have 64-bit pointers, or |
105 | /// - that cannot address through registers larger than pointers, or |
106 | /// - that implicitly ignore/truncate the top bits when addressing |
107 | /// through such registers. |
108 | virtual bool extendPointerWithSExt() const { return false; } |
109 | |
110 | /// Determines the DWARF register number for the stack pointer, for |
111 | /// exception-handling purposes. Implements __builtin_dwarf_sp_column. |
112 | /// |
113 | /// Returns -1 if the operation is unsupported by this target. |
114 | virtual int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const { |
115 | return -1; |
116 | } |
117 | |
118 | /// Initializes the given DWARF EH register-size table, a char*. |
119 | /// Implements __builtin_init_dwarf_reg_size_table. |
120 | /// |
121 | /// Returns true if the operation is unsupported by this target. |
122 | virtual bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, |
123 | llvm::Value *Address) const { |
124 | return true; |
125 | } |
126 | |
127 | /// Performs the code-generation required to convert a return |
128 | /// address as stored by the system into the actual address of the |
129 | /// next instruction that will be executed. |
130 | /// |
131 | /// Used by __builtin_extract_return_addr(). |
132 | virtual llvm::Value *decodeReturnAddress(CodeGen::CodeGenFunction &CGF, |
133 | llvm::Value *Address) const { |
134 | return Address; |
135 | } |
136 | |
137 | /// Performs the code-generation required to convert the address |
138 | /// of an instruction into a return address suitable for storage |
139 | /// by the system in a return slot. |
140 | /// |
141 | /// Used by __builtin_frob_return_addr(). |
142 | virtual llvm::Value *encodeReturnAddress(CodeGen::CodeGenFunction &CGF, |
143 | llvm::Value *Address) const { |
144 | return Address; |
145 | } |
146 | |
147 | /// Performs a target specific test of a floating point value for things |
148 | /// like IsNaN, Infinity, ... Nullptr is returned if no implementation |
149 | /// exists. |
150 | virtual llvm::Value * |
151 | testFPKind(llvm::Value *V, unsigned BuiltinID, CGBuilderTy &Builder, |
152 | CodeGenModule &CGM) const { |
153 | assert(V->getType()->isFloatingPointTy() && "V should have an FP type." ); |
154 | return nullptr; |
155 | } |
156 | |
157 | /// Corrects the low-level LLVM type for a given constraint and "usual" |
158 | /// type. |
159 | /// |
160 | /// \returns A pointer to a new LLVM type, possibly the same as the original |
161 | /// on success; 0 on failure. |
162 | virtual llvm::Type *adjustInlineAsmType(CodeGen::CodeGenFunction &CGF, |
163 | StringRef Constraint, |
164 | llvm::Type *Ty) const { |
165 | return Ty; |
166 | } |
167 | |
168 | /// Target hook to decide whether an inline asm operand can be passed |
169 | /// by value. |
170 | virtual bool isScalarizableAsmOperand(CodeGen::CodeGenFunction &CGF, |
171 | llvm::Type *Ty) const { |
172 | return false; |
173 | } |
174 | |
175 | /// Adds constraints and types for result registers. |
176 | virtual void addReturnRegisterOutputs( |
177 | CodeGen::CodeGenFunction &CGF, CodeGen::LValue ReturnValue, |
178 | std::string &Constraints, std::vector<llvm::Type *> &ResultRegTypes, |
179 | std::vector<llvm::Type *> &ResultTruncRegTypes, |
180 | std::vector<CodeGen::LValue> &ResultRegDests, std::string &AsmString, |
181 | unsigned NumOutputs) const {} |
182 | |
183 | /// doesReturnSlotInterfereWithArgs - Return true if the target uses an |
184 | /// argument slot for an 'sret' type. |
185 | virtual bool doesReturnSlotInterfereWithArgs() const { return true; } |
186 | |
187 | /// Retrieve the address of a function to call immediately before |
188 | /// calling objc_retainAutoreleasedReturnValue. The |
189 | /// implementation of objc_autoreleaseReturnValue sniffs the |
190 | /// instruction stream following its return address to decide |
191 | /// whether it's a call to objc_retainAutoreleasedReturnValue. |
192 | /// This can be prohibitively expensive, depending on the |
193 | /// relocation model, and so on some targets it instead sniffs for |
194 | /// a particular instruction sequence. This functions returns |
195 | /// that instruction sequence in inline assembly, which will be |
196 | /// empty if none is required. |
197 | virtual StringRef getARCRetainAutoreleasedReturnValueMarker() const { |
198 | return "" ; |
199 | } |
200 | |
201 | /// Determine whether a call to objc_retainAutoreleasedReturnValue or |
202 | /// objc_unsafeClaimAutoreleasedReturnValue should be marked as 'notail'. |
203 | virtual bool markARCOptimizedReturnCallsAsNoTail() const { return false; } |
204 | |
205 | /// Return a constant used by UBSan as a signature to identify functions |
206 | /// possessing type information, or 0 if the platform is unsupported. |
207 | /// This magic number is invalid instruction encoding in many targets. |
208 | virtual llvm::Constant * |
209 | getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const { |
210 | return llvm::ConstantInt::get(CGM.Int32Ty, 0xc105cafe); |
211 | } |
212 | |
213 | /// Determine whether a call to an unprototyped functions under |
214 | /// the given calling convention should use the variadic |
215 | /// convention or the non-variadic convention. |
216 | /// |
217 | /// There's a good reason to make a platform's variadic calling |
218 | /// convention be different from its non-variadic calling |
219 | /// convention: the non-variadic arguments can be passed in |
220 | /// registers (better for performance), and the variadic arguments |
221 | /// can be passed on the stack (also better for performance). If |
222 | /// this is done, however, unprototyped functions *must* use the |
223 | /// non-variadic convention, because C99 states that a call |
224 | /// through an unprototyped function type must succeed if the |
225 | /// function was defined with a non-variadic prototype with |
226 | /// compatible parameters. Therefore, splitting the conventions |
227 | /// makes it impossible to call a variadic function through an |
228 | /// unprototyped type. Since function prototypes came out in the |
229 | /// late 1970s, this is probably an acceptable trade-off. |
230 | /// Nonetheless, not all platforms are willing to make it, and in |
231 | /// particularly x86-64 bends over backwards to make the |
232 | /// conventions compatible. |
233 | /// |
234 | /// The default is false. This is correct whenever: |
235 | /// - the conventions are exactly the same, because it does not |
236 | /// matter and the resulting IR will be somewhat prettier in |
237 | /// certain cases; or |
238 | /// - the conventions are substantively different in how they pass |
239 | /// arguments, because in this case using the variadic convention |
240 | /// will lead to C99 violations. |
241 | /// |
242 | /// However, some platforms make the conventions identical except |
243 | /// for passing additional out-of-band information to a variadic |
244 | /// function: for example, x86-64 passes the number of SSE |
245 | /// arguments in %al. On these platforms, it is desirable to |
246 | /// call unprototyped functions using the variadic convention so |
247 | /// that unprototyped calls to varargs functions still succeed. |
248 | /// |
249 | /// Relatedly, platforms which pass the fixed arguments to this: |
250 | /// A foo(B, C, D); |
251 | /// differently than they would pass them to this: |
252 | /// A foo(B, C, D, ...); |
253 | /// may need to adjust the debugger-support code in Sema to do the |
254 | /// right thing when calling a function with no know signature. |
255 | virtual bool isNoProtoCallVariadic(const CodeGen::CallArgList &args, |
256 | const FunctionNoProtoType *fnType) const; |
257 | |
258 | /// Gets the linker options necessary to link a dependent library on this |
259 | /// platform. |
260 | virtual void getDependentLibraryOption(llvm::StringRef Lib, |
261 | llvm::SmallString<24> &Opt) const; |
262 | |
263 | /// Gets the linker options necessary to detect object file mismatches on |
264 | /// this platform. |
265 | virtual void getDetectMismatchOption(llvm::StringRef Name, |
266 | llvm::StringRef Value, |
267 | llvm::SmallString<32> &Opt) const {} |
268 | |
269 | /// Get LLVM calling convention for OpenCL kernel. |
270 | virtual unsigned getOpenCLKernelCallingConv() const; |
271 | |
272 | /// Get target specific null pointer. |
273 | /// \param T is the LLVM type of the null pointer. |
274 | /// \param QT is the clang QualType of the null pointer. |
275 | /// \return ConstantPointerNull with the given type \p T. |
276 | /// Each target can override it to return its own desired constant value. |
277 | virtual llvm::Constant *getNullPointer(const CodeGen::CodeGenModule &CGM, |
278 | llvm::PointerType *T, QualType QT) const; |
279 | |
280 | /// Get target favored AST address space of a global variable for languages |
281 | /// other than OpenCL and CUDA. |
282 | /// If \p D is nullptr, returns the default target favored address space |
283 | /// for global variable. |
284 | virtual LangAS getGlobalVarAddressSpace(CodeGenModule &CGM, |
285 | const VarDecl *D) const; |
286 | |
287 | /// Get the AST address space for alloca. |
288 | virtual LangAS getASTAllocaAddressSpace() const { return LangAS::Default; } |
289 | |
290 | /// Perform address space cast of an expression of pointer type. |
291 | /// \param V is the LLVM value to be casted to another address space. |
292 | /// \param SrcAddr is the language address space of \p V. |
293 | /// \param DestAddr is the targeted language address space. |
294 | /// \param DestTy is the destination LLVM pointer type. |
295 | /// \param IsNonNull is the flag indicating \p V is known to be non null. |
296 | virtual llvm::Value *performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, |
297 | llvm::Value *V, LangAS SrcAddr, |
298 | LangAS DestAddr, llvm::Type *DestTy, |
299 | bool IsNonNull = false) const; |
300 | |
301 | /// Perform address space cast of a constant expression of pointer type. |
302 | /// \param V is the LLVM constant to be casted to another address space. |
303 | /// \param SrcAddr is the language address space of \p V. |
304 | /// \param DestAddr is the targeted language address space. |
305 | /// \param DestTy is the destination LLVM pointer type. |
306 | virtual llvm::Constant *performAddrSpaceCast(CodeGenModule &CGM, |
307 | llvm::Constant *V, |
308 | LangAS SrcAddr, LangAS DestAddr, |
309 | llvm::Type *DestTy) const; |
310 | |
311 | /// Get address space of pointer parameter for __cxa_atexit. |
312 | virtual LangAS getAddrSpaceOfCxaAtexitPtrParam() const { |
313 | return LangAS::Default; |
314 | } |
315 | |
316 | /// Get the syncscope used in LLVM IR. |
317 | virtual llvm::SyncScope::ID getLLVMSyncScopeID(const LangOptions &LangOpts, |
318 | SyncScope Scope, |
319 | llvm::AtomicOrdering Ordering, |
320 | llvm::LLVMContext &Ctx) const; |
321 | |
322 | /// Interface class for filling custom fields of a block literal for OpenCL. |
323 | class TargetOpenCLBlockHelper { |
324 | public: |
325 | typedef std::pair<llvm::Value *, StringRef> ValueTy; |
326 | TargetOpenCLBlockHelper() {} |
327 | virtual ~TargetOpenCLBlockHelper() {} |
328 | /// Get the custom field types for OpenCL blocks. |
329 | virtual llvm::SmallVector<llvm::Type *, 1> getCustomFieldTypes() = 0; |
330 | /// Get the custom field values for OpenCL blocks. |
331 | virtual llvm::SmallVector<ValueTy, 1> |
332 | getCustomFieldValues(CodeGenFunction &CGF, const CGBlockInfo &Info) = 0; |
333 | virtual bool areAllCustomFieldValuesConstant(const CGBlockInfo &Info) = 0; |
334 | /// Get the custom field values for OpenCL blocks if all values are LLVM |
335 | /// constants. |
336 | virtual llvm::SmallVector<llvm::Constant *, 1> |
337 | getCustomFieldValues(CodeGenModule &CGM, const CGBlockInfo &Info) = 0; |
338 | }; |
339 | virtual TargetOpenCLBlockHelper *getTargetOpenCLBlockHelper() const { |
340 | return nullptr; |
341 | } |
342 | |
343 | /// Create an OpenCL kernel for an enqueued block. The kernel function is |
344 | /// a wrapper for the block invoke function with target-specific calling |
345 | /// convention and ABI as an OpenCL kernel. The wrapper function accepts |
346 | /// block context and block arguments in target-specific way and calls |
347 | /// the original block invoke function. |
348 | virtual llvm::Value * |
349 | createEnqueuedBlockKernel(CodeGenFunction &CGF, |
350 | llvm::Function *BlockInvokeFunc, |
351 | llvm::Type *BlockTy) const; |
352 | |
353 | /// \return true if the target supports alias from the unmangled name to the |
354 | /// mangled name of functions declared within an extern "C" region and marked |
355 | /// as 'used', and having internal linkage. |
356 | virtual bool shouldEmitStaticExternCAliases() const { return true; } |
357 | |
358 | /// \return true if annonymous zero-sized bitfields should be emitted to |
359 | /// correctly distinguish between struct types whose memory layout is the |
360 | /// same, but whose layout may differ when used as argument passed by value |
361 | virtual bool shouldEmitDWARFBitFieldSeparators() const { return false; } |
362 | |
363 | virtual void setCUDAKernelCallingConvention(const FunctionType *&FT) const {} |
364 | |
365 | /// Return the device-side type for the CUDA device builtin surface type. |
366 | virtual llvm::Type *getCUDADeviceBuiltinSurfaceDeviceType() const { |
367 | // By default, no change from the original one. |
368 | return nullptr; |
369 | } |
370 | /// Return the device-side type for the CUDA device builtin texture type. |
371 | virtual llvm::Type *getCUDADeviceBuiltinTextureDeviceType() const { |
372 | // By default, no change from the original one. |
373 | return nullptr; |
374 | } |
375 | |
376 | /// Return the WebAssembly externref reference type. |
377 | virtual llvm::Type *getWasmExternrefReferenceType() const { return nullptr; } |
378 | |
379 | /// Return the WebAssembly funcref reference type. |
380 | virtual llvm::Type *getWasmFuncrefReferenceType() const { return nullptr; } |
381 | |
382 | /// Emit the device-side copy of the builtin surface type. |
383 | virtual bool emitCUDADeviceBuiltinSurfaceDeviceCopy(CodeGenFunction &CGF, |
384 | LValue Dst, |
385 | LValue Src) const { |
386 | // DO NOTHING by default. |
387 | return false; |
388 | } |
389 | /// Emit the device-side copy of the builtin texture type. |
390 | virtual bool emitCUDADeviceBuiltinTextureDeviceCopy(CodeGenFunction &CGF, |
391 | LValue Dst, |
392 | LValue Src) const { |
393 | // DO NOTHING by default. |
394 | return false; |
395 | } |
396 | |
397 | /// Return an LLVM type that corresponds to an OpenCL type. |
398 | virtual llvm::Type *getOpenCLType(CodeGenModule &CGM, const Type *T) const { |
399 | return nullptr; |
400 | } |
401 | |
402 | protected: |
403 | static std::string qualifyWindowsLibrary(StringRef Lib); |
404 | |
405 | void addStackProbeTargetAttributes(const Decl *D, llvm::GlobalValue *GV, |
406 | CodeGen::CodeGenModule &CGM) const; |
407 | }; |
408 | |
409 | std::unique_ptr<TargetCodeGenInfo> |
410 | createDefaultTargetCodeGenInfo(CodeGenModule &CGM); |
411 | |
412 | enum class AArch64ABIKind { |
413 | AAPCS = 0, |
414 | DarwinPCS, |
415 | Win64, |
416 | }; |
417 | |
418 | std::unique_ptr<TargetCodeGenInfo> |
419 | createAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind Kind); |
420 | |
421 | std::unique_ptr<TargetCodeGenInfo> |
422 | createWindowsAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind K); |
423 | |
424 | std::unique_ptr<TargetCodeGenInfo> |
425 | createAMDGPUTargetCodeGenInfo(CodeGenModule &CGM); |
426 | |
427 | std::unique_ptr<TargetCodeGenInfo> |
428 | createARCTargetCodeGenInfo(CodeGenModule &CGM); |
429 | |
430 | enum class ARMABIKind { |
431 | APCS = 0, |
432 | AAPCS = 1, |
433 | AAPCS_VFP = 2, |
434 | AAPCS16_VFP = 3, |
435 | }; |
436 | |
437 | std::unique_ptr<TargetCodeGenInfo> |
438 | createARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind Kind); |
439 | |
440 | std::unique_ptr<TargetCodeGenInfo> |
441 | createWindowsARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind K); |
442 | |
443 | std::unique_ptr<TargetCodeGenInfo> |
444 | createAVRTargetCodeGenInfo(CodeGenModule &CGM, unsigned NPR, unsigned NRR); |
445 | |
446 | std::unique_ptr<TargetCodeGenInfo> |
447 | createBPFTargetCodeGenInfo(CodeGenModule &CGM); |
448 | |
449 | std::unique_ptr<TargetCodeGenInfo> |
450 | createCSKYTargetCodeGenInfo(CodeGenModule &CGM, unsigned FLen); |
451 | |
452 | std::unique_ptr<TargetCodeGenInfo> |
453 | createHexagonTargetCodeGenInfo(CodeGenModule &CGM); |
454 | |
455 | std::unique_ptr<TargetCodeGenInfo> |
456 | createLanaiTargetCodeGenInfo(CodeGenModule &CGM); |
457 | |
458 | std::unique_ptr<TargetCodeGenInfo> |
459 | createLoongArchTargetCodeGenInfo(CodeGenModule &CGM, unsigned GRLen, |
460 | unsigned FLen); |
461 | |
462 | std::unique_ptr<TargetCodeGenInfo> |
463 | createM68kTargetCodeGenInfo(CodeGenModule &CGM); |
464 | |
465 | std::unique_ptr<TargetCodeGenInfo> |
466 | createMIPSTargetCodeGenInfo(CodeGenModule &CGM, bool IsOS32); |
467 | |
468 | std::unique_ptr<TargetCodeGenInfo> |
469 | createMSP430TargetCodeGenInfo(CodeGenModule &CGM); |
470 | |
471 | std::unique_ptr<TargetCodeGenInfo> |
472 | createNVPTXTargetCodeGenInfo(CodeGenModule &CGM); |
473 | |
474 | std::unique_ptr<TargetCodeGenInfo> |
475 | createPNaClTargetCodeGenInfo(CodeGenModule &CGM); |
476 | |
477 | enum class PPC64_SVR4_ABIKind { |
478 | ELFv1 = 0, |
479 | ELFv2, |
480 | }; |
481 | |
482 | std::unique_ptr<TargetCodeGenInfo> |
483 | createAIXTargetCodeGenInfo(CodeGenModule &CGM, bool Is64Bit); |
484 | |
485 | std::unique_ptr<TargetCodeGenInfo> |
486 | createPPC32TargetCodeGenInfo(CodeGenModule &CGM, bool SoftFloatABI); |
487 | |
488 | std::unique_ptr<TargetCodeGenInfo> |
489 | createPPC64TargetCodeGenInfo(CodeGenModule &CGM); |
490 | |
491 | std::unique_ptr<TargetCodeGenInfo> |
492 | createPPC64_SVR4_TargetCodeGenInfo(CodeGenModule &CGM, PPC64_SVR4_ABIKind Kind, |
493 | bool SoftFloatABI); |
494 | |
495 | std::unique_ptr<TargetCodeGenInfo> |
496 | createRISCVTargetCodeGenInfo(CodeGenModule &CGM, unsigned XLen, unsigned FLen); |
497 | |
498 | std::unique_ptr<TargetCodeGenInfo> |
499 | createCommonSPIRTargetCodeGenInfo(CodeGenModule &CGM); |
500 | |
501 | std::unique_ptr<TargetCodeGenInfo> |
502 | createSPIRVTargetCodeGenInfo(CodeGenModule &CGM); |
503 | |
504 | std::unique_ptr<TargetCodeGenInfo> |
505 | createSparcV8TargetCodeGenInfo(CodeGenModule &CGM); |
506 | |
507 | std::unique_ptr<TargetCodeGenInfo> |
508 | createSparcV9TargetCodeGenInfo(CodeGenModule &CGM); |
509 | |
510 | std::unique_ptr<TargetCodeGenInfo> |
511 | createSystemZTargetCodeGenInfo(CodeGenModule &CGM, bool HasVector, |
512 | bool SoftFloatABI); |
513 | |
514 | std::unique_ptr<TargetCodeGenInfo> |
515 | createTCETargetCodeGenInfo(CodeGenModule &CGM); |
516 | |
517 | std::unique_ptr<TargetCodeGenInfo> |
518 | createVETargetCodeGenInfo(CodeGenModule &CGM); |
519 | |
520 | enum class WebAssemblyABIKind { |
521 | MVP = 0, |
522 | ExperimentalMV = 1, |
523 | }; |
524 | |
525 | std::unique_ptr<TargetCodeGenInfo> |
526 | createWebAssemblyTargetCodeGenInfo(CodeGenModule &CGM, WebAssemblyABIKind K); |
527 | |
528 | /// The AVX ABI level for X86 targets. |
529 | enum class X86AVXABILevel { |
530 | None, |
531 | AVX, |
532 | AVX512, |
533 | }; |
534 | |
535 | std::unique_ptr<TargetCodeGenInfo> createX86_32TargetCodeGenInfo( |
536 | CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, |
537 | unsigned NumRegisterParameters, bool SoftFloatABI); |
538 | |
539 | std::unique_ptr<TargetCodeGenInfo> |
540 | createWinX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, |
541 | bool Win32StructABI, |
542 | unsigned NumRegisterParameters); |
543 | |
544 | std::unique_ptr<TargetCodeGenInfo> |
545 | createX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel); |
546 | |
547 | std::unique_ptr<TargetCodeGenInfo> |
548 | createWinX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel); |
549 | |
550 | std::unique_ptr<TargetCodeGenInfo> |
551 | createXCoreTargetCodeGenInfo(CodeGenModule &CGM); |
552 | |
553 | } // namespace CodeGen |
554 | } // namespace clang |
555 | |
556 | #endif // LLVM_CLANG_LIB_CODEGEN_TARGETINFO_H |
557 | |