clang  3.9.0
lib/CodeGen/TargetInfo.h
Go to the documentation of this file.
1 //===---- TargetInfo.h - Encapsulate target details -------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // These classes wrap the information about a call or function
11 // definition used to handle ABI compliancy.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_LIB_CODEGEN_TARGETINFO_H
16 #define LLVM_CLANG_LIB_CODEGEN_TARGETINFO_H
17 
18 #include "CGValue.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/LLVM.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/StringRef.h"
23 
24 namespace llvm {
25 class Constant;
26 class GlobalValue;
27 class Type;
28 class Value;
29 }
30 
31 namespace clang {
32 class Decl;
33 
34 namespace CodeGen {
35 class ABIInfo;
36 class CallArgList;
37 class CodeGenModule;
38 class CodeGenFunction;
39 class CGFunctionInfo;
40 
41 /// TargetCodeGenInfo - This class organizes various target-specific
42 /// codegeneration issues, like target-specific attributes, builtins and so
43 /// on.
45  ABIInfo *Info;
46 
47 public:
48  // WARNING: Acquires the ownership of ABIInfo.
49  TargetCodeGenInfo(ABIInfo *info = nullptr) : Info(info) {}
50  virtual ~TargetCodeGenInfo();
51 
52  /// getABIInfo() - Returns ABI info helper for the target.
53  const ABIInfo &getABIInfo() const { return *Info; }
54 
55  /// setTargetAttributes - Provides a convenient hook to handle extra
56  /// target-specific attributes for the given global.
57  virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
58  CodeGen::CodeGenModule &M) const {}
59 
60  /// emitTargetMD - Provides a convenient hook to handle extra
61  /// target-specific metadata for the given global.
62  virtual void emitTargetMD(const Decl *D, llvm::GlobalValue *GV,
63  CodeGen::CodeGenModule &M) const {}
64 
65  /// Determines the size of struct _Unwind_Exception on this platform,
66  /// in 8-bit units. The Itanium ABI defines this as:
67  /// struct _Unwind_Exception {
68  /// uint64 exception_class;
69  /// _Unwind_Exception_Cleanup_Fn exception_cleanup;
70  /// uint64 private_1;
71  /// uint64 private_2;
72  /// };
73  virtual unsigned getSizeOfUnwindException() const;
74 
75  /// Controls whether __builtin_extend_pointer should sign-extend
76  /// pointers to uint64_t or zero-extend them (the default). Has
77  /// no effect for targets:
78  /// - that have 64-bit pointers, or
79  /// - that cannot address through registers larger than pointers, or
80  /// - that implicitly ignore/truncate the top bits when addressing
81  /// through such registers.
82  virtual bool extendPointerWithSExt() const { return false; }
83 
84  /// Determines the DWARF register number for the stack pointer, for
85  /// exception-handling purposes. Implements __builtin_dwarf_sp_column.
86  ///
87  /// Returns -1 if the operation is unsupported by this target.
89  return -1;
90  }
91 
92  /// Initializes the given DWARF EH register-size table, a char*.
93  /// Implements __builtin_init_dwarf_reg_size_table.
94  ///
95  /// Returns true if the operation is unsupported by this target.
97  llvm::Value *Address) const {
98  return true;
99  }
100 
101  /// Performs the code-generation required to convert a return
102  /// address as stored by the system into the actual address of the
103  /// next instruction that will be executed.
104  ///
105  /// Used by __builtin_extract_return_addr().
107  llvm::Value *Address) const {
108  return Address;
109  }
110 
111  /// Performs the code-generation required to convert the address
112  /// of an instruction into a return address suitable for storage
113  /// by the system in a return slot.
114  ///
115  /// Used by __builtin_frob_return_addr().
117  llvm::Value *Address) const {
118  return Address;
119  }
120 
121  /// Corrects the low-level LLVM type for a given constraint and "usual"
122  /// type.
123  ///
124  /// \returns A pointer to a new LLVM type, possibly the same as the original
125  /// on success; 0 on failure.
127  StringRef Constraint,
128  llvm::Type *Ty) const {
129  return Ty;
130  }
131 
132  /// Adds constraints and types for result registers.
134  CodeGen::CodeGenFunction &CGF, CodeGen::LValue ReturnValue,
135  std::string &Constraints, std::vector<llvm::Type *> &ResultRegTypes,
136  std::vector<llvm::Type *> &ResultTruncRegTypes,
137  std::vector<CodeGen::LValue> &ResultRegDests, std::string &AsmString,
138  unsigned NumOutputs) const {}
139 
140  /// doesReturnSlotInterfereWithArgs - Return true if the target uses an
141  /// argument slot for an 'sret' type.
142  virtual bool doesReturnSlotInterfereWithArgs() const { return true; }
143 
144  /// Retrieve the address of a function to call immediately before
145  /// calling objc_retainAutoreleasedReturnValue. The
146  /// implementation of objc_autoreleaseReturnValue sniffs the
147  /// instruction stream following its return address to decide
148  /// whether it's a call to objc_retainAutoreleasedReturnValue.
149  /// This can be prohibitively expensive, depending on the
150  /// relocation model, and so on some targets it instead sniffs for
151  /// a particular instruction sequence. This functions returns
152  /// that instruction sequence in inline assembly, which will be
153  /// empty if none is required.
154  virtual StringRef getARCRetainAutoreleasedReturnValueMarker() const {
155  return "";
156  }
157 
158  /// Return a constant used by UBSan as a signature to identify functions
159  /// possessing type information, or 0 if the platform is unsupported.
160  virtual llvm::Constant *
162  return nullptr;
163  }
164 
165  /// Determine whether a call to an unprototyped functions under
166  /// the given calling convention should use the variadic
167  /// convention or the non-variadic convention.
168  ///
169  /// There's a good reason to make a platform's variadic calling
170  /// convention be different from its non-variadic calling
171  /// convention: the non-variadic arguments can be passed in
172  /// registers (better for performance), and the variadic arguments
173  /// can be passed on the stack (also better for performance). If
174  /// this is done, however, unprototyped functions *must* use the
175  /// non-variadic convention, because C99 states that a call
176  /// through an unprototyped function type must succeed if the
177  /// function was defined with a non-variadic prototype with
178  /// compatible parameters. Therefore, splitting the conventions
179  /// makes it impossible to call a variadic function through an
180  /// unprototyped type. Since function prototypes came out in the
181  /// late 1970s, this is probably an acceptable trade-off.
182  /// Nonetheless, not all platforms are willing to make it, and in
183  /// particularly x86-64 bends over backwards to make the
184  /// conventions compatible.
185  ///
186  /// The default is false. This is correct whenever:
187  /// - the conventions are exactly the same, because it does not
188  /// matter and the resulting IR will be somewhat prettier in
189  /// certain cases; or
190  /// - the conventions are substantively different in how they pass
191  /// arguments, because in this case using the variadic convention
192  /// will lead to C99 violations.
193  ///
194  /// However, some platforms make the conventions identical except
195  /// for passing additional out-of-band information to a variadic
196  /// function: for example, x86-64 passes the number of SSE
197  /// arguments in %al. On these platforms, it is desirable to
198  /// call unprototyped functions using the variadic convention so
199  /// that unprototyped calls to varargs functions still succeed.
200  ///
201  /// Relatedly, platforms which pass the fixed arguments to this:
202  /// A foo(B, C, D);
203  /// differently than they would pass them to this:
204  /// A foo(B, C, D, ...);
205  /// may need to adjust the debugger-support code in Sema to do the
206  /// right thing when calling a function with no know signature.
207  virtual bool isNoProtoCallVariadic(const CodeGen::CallArgList &args,
208  const FunctionNoProtoType *fnType) const;
209 
210  /// Gets the linker options necessary to link a dependent library on this
211  /// platform.
212  virtual void getDependentLibraryOption(llvm::StringRef Lib,
213  llvm::SmallString<24> &Opt) const;
214 
215  /// Gets the linker options necessary to detect object file mismatches on
216  /// this platform.
217  virtual void getDetectMismatchOption(llvm::StringRef Name,
218  llvm::StringRef Value,
219  llvm::SmallString<32> &Opt) const {}
220 
221  /// Get LLVM calling convention for OpenCL kernel.
222  virtual unsigned getOpenCLKernelCallingConv() const;
223 };
224 
225 } // namespace CodeGen
226 } // namespace clang
227 
228 #endif // LLVM_CLANG_LIB_CODEGEN_TARGETINFO_H
const ABIInfo & getABIInfo() const
getABIInfo() - Returns ABI info helper for the target.
C Language Family Type Representation.
virtual bool isNoProtoCallVariadic(const CodeGen::CallArgList &args, const FunctionNoProtoType *fnType) const
Determine whether a call to an unprototyped functions under the given calling convention should use t...
virtual llvm::Value * decodeReturnAddress(CodeGen::CodeGenFunction &CGF, llvm::Value *Address) const
Performs the code-generation required to convert a return address as stored by the system into the ac...
virtual void getDependentLibraryOption(llvm::StringRef Lib, llvm::SmallString< 24 > &Opt) const
Gets the linker options necessary to link a dependent library on this platform.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
virtual llvm::Type * adjustInlineAsmType(CodeGen::CodeGenFunction &CGF, StringRef Constraint, llvm::Type *Ty) const
Corrects the low-level LLVM type for a given constraint and "usual" type.
virtual bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, llvm::Value *Address) const
Initializes the given DWARF EH register-size table, a char*.
virtual void emitTargetMD(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const
emitTargetMD - Provides a convenient hook to handle extra target-specific metadata for the given glob...
virtual unsigned getOpenCLKernelCallingConv() const
Get LLVM calling convention for OpenCL kernel.
virtual int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const
Determines the DWARF register number for the stack pointer, for exception-handling purposes...
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
virtual llvm::Constant * getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const
Return a constant used by UBSan as a signature to identify functions possessing type information...
virtual bool extendPointerWithSExt() const
Controls whether __builtin_extend_pointer should sign-extend pointers to uint64_t or zero-extend them...
virtual bool doesReturnSlotInterfereWithArgs() const
doesReturnSlotInterfereWithArgs - Return true if the target uses an argument slot for an 'sret' type...
Represents a K&R-style 'int foo()' function, which has no information available about its arguments...
Definition: Type.h:3039
The l-value was considered opaque, so the alignment was determined from a type.
An aligned address.
Definition: Address.h:25
TargetCodeGenInfo - This class organizes various target-specific codegeneration issues, like target-specific attributes, builtins and so on.
This class organizes the cross-function state that is used while generating LLVM code.
virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const
setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...
virtual StringRef getARCRetainAutoreleasedReturnValueMarker() const
Retrieve the address of a function to call immediately before calling objc_retainAutoreleasedReturnVa...
virtual void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, llvm::SmallString< 32 > &Opt) const
Gets the linker options necessary to detect object file mismatches on this platform.
ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions...
Definition: ABIInfo.h:49
virtual llvm::Value * encodeReturnAddress(CodeGen::CodeGenFunction &CGF, llvm::Value *Address) const
Performs the code-generation required to convert the address of an instruction into a return address ...
virtual unsigned getSizeOfUnwindException() const
Determines the size of struct _Unwind_Exception on this platform, in 8-bit units. ...
LValue - This represents an lvalue references.
Definition: CGValue.h:152
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:56
virtual void addReturnRegisterOutputs(CodeGen::CodeGenFunction &CGF, CodeGen::LValue ReturnValue, std::string &Constraints, std::vector< llvm::Type * > &ResultRegTypes, std::vector< llvm::Type * > &ResultTruncRegTypes, std::vector< CodeGen::LValue > &ResultRegDests, std::string &AsmString, unsigned NumOutputs) const
Adds constraints and types for result registers.