Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 1 | //===--- CodeGenModule.h - Per-Module state for LLVM CodeGen ----*- C++ -*-===// |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 0bc735f | 2007-12-29 19:59:25 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 10 | // This is the internal per-translation-unit state used for llvm translation. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Chris Lattner | ef52a2f | 2008-02-29 17:10:38 +0000 | [diff] [blame] | 14 | #ifndef CLANG_CODEGEN_CODEGENMODULE_H |
| 15 | #define CLANG_CODEGEN_CODEGENMODULE_H |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 16 | |
| 17 | #include "CodeGenTypes.h" |
Dan Gohman | 4f8d123 | 2008-05-22 00:50:06 +0000 | [diff] [blame] | 18 | #include "clang/AST/Attr.h" |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/DenseMap.h" |
Anders Carlsson | c9e2091 | 2007-08-21 00:21:21 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/StringMap.h" |
Douglas Gregor | 6ec3668 | 2009-02-18 23:53:56 +0000 | [diff] [blame] | 21 | #include "llvm/ADT/StringSet.h" |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 22 | |
Mike Stump | 96bd13a | 2009-03-04 15:32:52 +0000 | [diff] [blame] | 23 | #include "CGBlocks.h" |
Daniel Dunbar | b768807 | 2008-09-10 00:41:16 +0000 | [diff] [blame] | 24 | #include "CGCall.h" |
| 25 | |
Anders Carlsson | b723f75 | 2009-01-04 02:08:04 +0000 | [diff] [blame] | 26 | #include <list> |
| 27 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 28 | namespace llvm { |
| 29 | class Module; |
| 30 | class Constant; |
| 31 | class Function; |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 32 | class GlobalValue; |
Devang Patel | 7a4718e | 2007-10-31 20:01:01 +0000 | [diff] [blame] | 33 | class TargetData; |
Eli Friedman | ff4a2d9 | 2008-06-01 15:54:49 +0000 | [diff] [blame] | 34 | class FunctionType; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 35 | } |
| 36 | |
| 37 | namespace clang { |
| 38 | class ASTContext; |
| 39 | class FunctionDecl; |
Daniel Dunbar | 90db882 | 2008-08-25 06:18:57 +0000 | [diff] [blame] | 40 | class IdentifierInfo; |
Chris Lattner | 391d77a | 2008-03-30 23:03:07 +0000 | [diff] [blame] | 41 | class ObjCMethodDecl; |
Anton Korobeynikov | 20ff310 | 2008-06-01 14:13:53 +0000 | [diff] [blame] | 42 | class ObjCImplementationDecl; |
| 43 | class ObjCCategoryImplDecl; |
| 44 | class ObjCProtocolDecl; |
Chris Lattner | eaf2bb8 | 2009-02-24 22:18:39 +0000 | [diff] [blame] | 45 | class ObjCEncodeExpr; |
Anders Carlsson | d5cab54 | 2009-02-12 17:55:02 +0000 | [diff] [blame] | 46 | class BlockExpr; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 47 | class Decl; |
Oliver Hunt | 2824723 | 2007-12-02 00:11:25 +0000 | [diff] [blame] | 48 | class Expr; |
Chris Lattner | 2c8569d | 2007-12-02 07:19:18 +0000 | [diff] [blame] | 49 | class Stmt; |
Daniel Dunbar | 1e04976 | 2008-08-10 20:25:57 +0000 | [diff] [blame] | 50 | class StringLiteral; |
Nate Begeman | 1a1d92a | 2008-04-20 20:38:08 +0000 | [diff] [blame] | 51 | class NamedDecl; |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 52 | class ValueDecl; |
Chris Lattner | 2b9d2ca | 2007-12-18 08:16:44 +0000 | [diff] [blame] | 53 | class VarDecl; |
Chris Lattner | 45e8cbd | 2007-11-28 05:34:05 +0000 | [diff] [blame] | 54 | struct LangOptions; |
Chris Lattner | fb97b03 | 2007-12-02 01:40:18 +0000 | [diff] [blame] | 55 | class Diagnostic; |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 56 | class AnnotateAttr; |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 57 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 58 | namespace CodeGen { |
| 59 | |
Lauro Ramos Venancio | 8137335 | 2008-02-26 21:41:45 +0000 | [diff] [blame] | 60 | class CodeGenFunction; |
Sanjiv Gupta | e8b9f5b | 2008-05-08 08:54:20 +0000 | [diff] [blame] | 61 | class CGDebugInfo; |
Daniel Dunbar | af2f62c | 2008-08-13 00:59:25 +0000 | [diff] [blame] | 62 | class CGObjCRuntime; |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 63 | |
| 64 | /// CodeGenModule - This class organizes the cross-function state that is used |
| 65 | /// while generating LLVM code. |
Mike Stump | 96bd13a | 2009-03-04 15:32:52 +0000 | [diff] [blame] | 66 | class CodeGenModule : public BlockModule { |
Anders Carlsson | 8a219ce | 2009-02-24 04:21:31 +0000 | [diff] [blame] | 67 | CodeGenModule(const CodeGenModule&); // DO NOT IMPLEMENT |
| 68 | void operator=(const CodeGenModule&); // DO NOT IMPLEMENT |
| 69 | |
Daniel Dunbar | 6bfed7e | 2008-08-01 00:01:51 +0000 | [diff] [blame] | 70 | typedef std::vector< std::pair<llvm::Constant*, int> > CtorList; |
| 71 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 72 | ASTContext &Context; |
Chris Lattner | 45e8cbd | 2007-11-28 05:34:05 +0000 | [diff] [blame] | 73 | const LangOptions &Features; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 74 | llvm::Module &TheModule; |
Devang Patel | 7a4718e | 2007-10-31 20:01:01 +0000 | [diff] [blame] | 75 | const llvm::TargetData &TheTargetData; |
Chris Lattner | fb97b03 | 2007-12-02 01:40:18 +0000 | [diff] [blame] | 76 | Diagnostic &Diags; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 77 | CodeGenTypes Types; |
Ted Kremenek | 815c78f | 2008-08-05 18:50:11 +0000 | [diff] [blame] | 78 | CGObjCRuntime* Runtime; |
| 79 | CGDebugInfo* DebugInfo; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 80 | |
| 81 | llvm::Function *MemCpyFn; |
Eli Friedman | 0c99509 | 2008-05-26 12:59:39 +0000 | [diff] [blame] | 82 | llvm::Function *MemMoveFn; |
Lauro Ramos Venancio | 41ef30e | 2008-02-19 22:01:01 +0000 | [diff] [blame] | 83 | llvm::Function *MemSetFn; |
Daniel Dunbar | 9986eab | 2008-07-30 16:32:24 +0000 | [diff] [blame] | 84 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 85 | /// RuntimeFunctions - List of runtime functions whose names must be protected |
| 86 | /// from introducing conflicts. These functions should be created unnamed, we |
| 87 | /// will name them and patch up conflicts when we release the module. |
Daniel Dunbar | f1968f2 | 2008-10-01 00:49:24 +0000 | [diff] [blame] | 88 | std::vector< std::pair<llvm::Function*, std::string> > RuntimeFunctions; |
| 89 | |
Douglas Gregor | 6ec3668 | 2009-02-18 23:53:56 +0000 | [diff] [blame] | 90 | /// GlobalDeclMap - Mapping of decl names (represented as unique |
| 91 | /// character pointers from either the identifier table or the set |
| 92 | /// of mangled names) to global variables we have already |
| 93 | /// emitted. Note that the entries in this map are the actual |
| 94 | /// globals and therefore may not be of the same type as the decl, |
| 95 | /// they should be bitcasted on retrieval. Also note that the |
| 96 | /// globals are keyed on their source name, not the global name |
| 97 | /// (which may change with attributes such as asm-labels). This key |
| 98 | /// to this map should be generated using getMangledName(). |
| 99 | llvm::DenseMap<const char*, llvm::GlobalValue*> GlobalDeclMap; |
| 100 | |
| 101 | /// \brief Contains the strings used for mangled names. |
| 102 | /// |
| 103 | /// FIXME: Eventually, this should map from the semantic/canonical |
| 104 | /// declaration for each global entity to its mangled name (if it |
| 105 | /// has one). |
| 106 | llvm::StringSet<> MangledNames; |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 107 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 108 | /// Aliases - List of aliases in module. These cannot be emitted until all the |
| 109 | /// code has been seen, as they reference things by name instead of directly |
| 110 | /// and may reference forward. |
Daniel Dunbar | 219df66 | 2008-09-08 23:44:31 +0000 | [diff] [blame] | 111 | std::vector<const FunctionDecl*> Aliases; |
| 112 | |
Daniel Dunbar | 0269871 | 2009-02-13 20:29:50 +0000 | [diff] [blame] | 113 | /// DeferredDecls - List of decls for which code generation has been |
| 114 | /// deferred. When the translation unit has been fully processed we |
| 115 | /// will lazily emit definitions for only the decls that were |
| 116 | /// actually used. This should contain only Function and Var decls, |
| 117 | /// and only those which actually define something. |
| 118 | std::list<const ValueDecl*> DeferredDecls; |
| 119 | |
| 120 | /// LLVMUsed - List of global values which are required to be |
| 121 | /// present in the object file; bitcast to i8*. This is used for |
| 122 | /// forcing visibility of symbols which may otherwise be optimized |
| 123 | /// out. |
| 124 | std::vector<llvm::Constant*> LLVMUsed; |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 125 | |
| 126 | /// GlobalCtors - Store the list of global constructors and their respective |
| 127 | /// priorities to be emitted when the translation unit is complete. |
Daniel Dunbar | 6bfed7e | 2008-08-01 00:01:51 +0000 | [diff] [blame] | 128 | CtorList GlobalCtors; |
| 129 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 130 | /// GlobalDtors - Store the list of global destructors and their respective |
| 131 | /// priorities to be emitted when the translation unit is complete. |
Daniel Dunbar | 6bfed7e | 2008-08-01 00:01:51 +0000 | [diff] [blame] | 132 | CtorList GlobalDtors; |
| 133 | |
Nate Begeman | 532485c | 2008-04-18 23:43:57 +0000 | [diff] [blame] | 134 | std::vector<llvm::Constant*> Annotations; |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 135 | |
Anders Carlsson | c9e2091 | 2007-08-21 00:21:21 +0000 | [diff] [blame] | 136 | llvm::StringMap<llvm::Constant*> CFConstantStringMap; |
Chris Lattner | 45e8cbd | 2007-11-28 05:34:05 +0000 | [diff] [blame] | 137 | llvm::StringMap<llvm::Constant*> ConstantStringMap; |
Daniel Dunbar | 3e9df99 | 2008-08-23 18:37:06 +0000 | [diff] [blame] | 138 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 139 | /// CFConstantStringClassRef - Cached reference to the class for constant |
| 140 | /// strings. This value has type int * but is actually an Obj-C class pointer. |
Anders Carlsson | c9e2091 | 2007-08-21 00:21:21 +0000 | [diff] [blame] | 141 | llvm::Constant *CFConstantStringClassRef; |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 142 | |
| 143 | /// NSConcreteGlobalBlock - Cached reference to the class pointer for global |
| 144 | /// blocks. |
Anders Carlsson | d5cab54 | 2009-02-12 17:55:02 +0000 | [diff] [blame] | 145 | llvm::Constant *NSConcreteGlobalBlock; |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 146 | |
Mike Stump | 59c5b11 | 2009-02-13 19:29:27 +0000 | [diff] [blame] | 147 | /// NSConcreteStackBlock - Cached reference to the class poinnter for stack |
| 148 | /// blocks. |
| 149 | llvm::Constant *NSConcreteStackBlock; |
| 150 | |
Mike Stump | ab69514 | 2009-02-13 15:16:56 +0000 | [diff] [blame] | 151 | const llvm::Type *BlockDescriptorType; |
Mike Stump | 3246991 | 2009-02-13 19:36:03 +0000 | [diff] [blame] | 152 | const llvm::Type *GenericBlockLiteralType; |
Mike Stump | bd65cac | 2009-02-19 01:01:04 +0000 | [diff] [blame] | 153 | const llvm::Type *GenericExtendedBlockLiteralType; |
Mike Stump | 26efc33 | 2009-02-13 18:36:05 +0000 | [diff] [blame] | 154 | struct { |
| 155 | int GlobalUniqueCount; |
| 156 | } Block; |
Mike Stump | ab69514 | 2009-02-13 15:16:56 +0000 | [diff] [blame] | 157 | |
Mike Stump | c136e6c | 2009-02-27 22:42:30 +0000 | [diff] [blame] | 158 | std::vector<llvm::Value *> BuiltinFunctions; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 159 | public: |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 160 | CodeGenModule(ASTContext &C, const LangOptions &Features, llvm::Module &M, |
Sanjiv Gupta | e8b9f5b | 2008-05-08 08:54:20 +0000 | [diff] [blame] | 161 | const llvm::TargetData &TD, Diagnostic &Diags, |
Daniel Dunbar | f77ac86 | 2008-08-11 21:35:06 +0000 | [diff] [blame] | 162 | bool GenerateDebugInfo); |
Ted Kremenek | 815c78f | 2008-08-05 18:50:11 +0000 | [diff] [blame] | 163 | |
Chris Lattner | 2b94fe3 | 2008-03-01 08:45:05 +0000 | [diff] [blame] | 164 | ~CodeGenModule(); |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 165 | |
Ted Kremenek | 815c78f | 2008-08-05 18:50:11 +0000 | [diff] [blame] | 166 | /// Release - Finalize LLVM code generation. |
| 167 | void Release(); |
Daniel Dunbar | 208ff5e | 2008-08-11 18:12:00 +0000 | [diff] [blame] | 168 | |
Mike Stump | f99f1d0 | 2009-02-13 17:23:42 +0000 | [diff] [blame] | 169 | llvm::Constant *getNSConcreteGlobalBlock(); |
Mike Stump | 59c5b11 | 2009-02-13 19:29:27 +0000 | [diff] [blame] | 170 | llvm::Constant *getNSConcreteStackBlock(); |
Mike Stump | 26efc33 | 2009-02-13 18:36:05 +0000 | [diff] [blame] | 171 | int getGlobalUniqueCount() { return ++Block.GlobalUniqueCount; } |
Mike Stump | ab69514 | 2009-02-13 15:16:56 +0000 | [diff] [blame] | 172 | const llvm::Type *getBlockDescriptorType(); |
| 173 | |
Mike Stump | 9b8a797 | 2009-02-13 15:25:34 +0000 | [diff] [blame] | 174 | const llvm::Type *getGenericBlockLiteralType(); |
Mike Stump | bd65cac | 2009-02-19 01:01:04 +0000 | [diff] [blame] | 175 | const llvm::Type *getGenericExtendedBlockLiteralType(); |
Mike Stump | 9b8a797 | 2009-02-13 15:25:34 +0000 | [diff] [blame] | 176 | |
Daniel Dunbar | 208ff5e | 2008-08-11 18:12:00 +0000 | [diff] [blame] | 177 | /// getObjCRuntime() - Return a reference to the configured |
| 178 | /// Objective-C runtime. |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 179 | CGObjCRuntime &getObjCRuntime() { |
Daniel Dunbar | 208ff5e | 2008-08-11 18:12:00 +0000 | [diff] [blame] | 180 | assert(Runtime && "No Objective-C runtime has been configured."); |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 181 | return *Runtime; |
Daniel Dunbar | 208ff5e | 2008-08-11 18:12:00 +0000 | [diff] [blame] | 182 | } |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 183 | |
Daniel Dunbar | 208ff5e | 2008-08-11 18:12:00 +0000 | [diff] [blame] | 184 | /// hasObjCRuntime() - Return true iff an Objective-C runtime has |
| 185 | /// been configured. |
| 186 | bool hasObjCRuntime() { return !!Runtime; } |
| 187 | |
Sanjiv Gupta | e8b9f5b | 2008-05-08 08:54:20 +0000 | [diff] [blame] | 188 | CGDebugInfo *getDebugInfo() { return DebugInfo; } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 189 | ASTContext &getContext() const { return Context; } |
Chris Lattner | 45e8cbd | 2007-11-28 05:34:05 +0000 | [diff] [blame] | 190 | const LangOptions &getLangOptions() const { return Features; } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 191 | llvm::Module &getModule() const { return TheModule; } |
| 192 | CodeGenTypes &getTypes() { return Types; } |
Chris Lattner | fb97b03 | 2007-12-02 01:40:18 +0000 | [diff] [blame] | 193 | Diagnostic &getDiags() const { return Diags; } |
Chris Lattner | 8f92528 | 2008-01-03 06:36:51 +0000 | [diff] [blame] | 194 | const llvm::TargetData &getTargetData() const { return TheTargetData; } |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 195 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 196 | /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the |
| 197 | /// given global variable. |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 198 | llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D); |
| 199 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 200 | /// GetAddrOfFunction - Return the llvm::Constant for the address of the given |
| 201 | /// function. |
| 202 | llvm::Constant *GetAddrOfFunction(const FunctionDecl *D); |
Daniel Dunbar | 6143293 | 2008-08-13 23:20:05 +0000 | [diff] [blame] | 203 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 204 | /// GetStringForStringLiteral - Return the appropriate bytes for a string |
| 205 | /// literal, properly padded to match the literal type. If only the address of |
| 206 | /// a constant is needed consider using GetAddrOfConstantStringLiteral. |
Daniel Dunbar | 6143293 | 2008-08-13 23:20:05 +0000 | [diff] [blame] | 207 | std::string GetStringForStringLiteral(const StringLiteral *E); |
| 208 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 209 | /// GetAddrOfConstantCFString - Return a pointer to a constant CFString object |
| 210 | /// for the given string. |
Anders Carlsson | c9e2091 | 2007-08-21 00:21:21 +0000 | [diff] [blame] | 211 | llvm::Constant *GetAddrOfConstantCFString(const std::string& str); |
Chris Lattner | a7ad98f | 2008-02-11 00:02:17 +0000 | [diff] [blame] | 212 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 213 | /// GetAddrOfConstantStringFromLiteral - Return a pointer to a constant array |
| 214 | /// for the given string literal. |
Daniel Dunbar | 6143293 | 2008-08-13 23:20:05 +0000 | [diff] [blame] | 215 | llvm::Constant *GetAddrOfConstantStringFromLiteral(const StringLiteral *S); |
Daniel Dunbar | 1e04976 | 2008-08-10 20:25:57 +0000 | [diff] [blame] | 216 | |
Chris Lattner | eaf2bb8 | 2009-02-24 22:18:39 +0000 | [diff] [blame] | 217 | /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant |
| 218 | /// array for the given ObjCEncodeExpr node. |
| 219 | llvm::Constant *GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *); |
| 220 | |
Daniel Dunbar | 6143293 | 2008-08-13 23:20:05 +0000 | [diff] [blame] | 221 | /// GetAddrOfConstantString - Returns a pointer to a character array |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 222 | /// containing the literal. This contents are exactly that of the given |
| 223 | /// string, i.e. it will not be null terminated automatically; see |
| 224 | /// GetAddrOfConstantCString. Note that whether the result is actually a |
| 225 | /// pointer to an LLVM constant depends on Feature.WriteableStrings. |
Daniel Dunbar | 6143293 | 2008-08-13 23:20:05 +0000 | [diff] [blame] | 226 | /// |
| 227 | /// The result has pointer to array type. |
Daniel Dunbar | 5fabf9d | 2008-10-17 21:56:50 +0000 | [diff] [blame] | 228 | /// |
| 229 | /// \param GlobalName If provided, the name to use for the global |
| 230 | /// (if one is created). |
| 231 | llvm::Constant *GetAddrOfConstantString(const std::string& str, |
| 232 | const char *GlobalName=0); |
Daniel Dunbar | 6143293 | 2008-08-13 23:20:05 +0000 | [diff] [blame] | 233 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 234 | /// GetAddrOfConstantCString - Returns a pointer to a character array |
| 235 | /// containing the literal and a terminating '\0' character. The result has |
| 236 | /// pointer to array type. |
Daniel Dunbar | 5fabf9d | 2008-10-17 21:56:50 +0000 | [diff] [blame] | 237 | /// |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 238 | /// \param GlobalName If provided, the name to use for the global (if one is |
| 239 | /// created). |
Daniel Dunbar | 5fabf9d | 2008-10-17 21:56:50 +0000 | [diff] [blame] | 240 | llvm::Constant *GetAddrOfConstantCString(const std::string &str, |
| 241 | const char *GlobalName=0); |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 242 | |
Mike Stump | 30395dd | 2009-02-14 22:49:33 +0000 | [diff] [blame] | 243 | llvm::Constant *GetAddrOfGlobalBlock(const BlockExpr *BE, const char *); |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 244 | |
Daniel Dunbar | 41071de | 2008-08-15 23:26:23 +0000 | [diff] [blame] | 245 | /// getBuiltinLibFunction - Given a builtin id for a function like |
| 246 | /// "__builtin_fabsf", return a Function* for "fabsf". |
Mike Stump | c136e6c | 2009-02-27 22:42:30 +0000 | [diff] [blame] | 247 | llvm::Value *getBuiltinLibFunction(unsigned BuiltinID); |
Daniel Dunbar | 6143293 | 2008-08-13 23:20:05 +0000 | [diff] [blame] | 248 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 249 | llvm::Function *getMemCpyFn(); |
Eli Friedman | 0c99509 | 2008-05-26 12:59:39 +0000 | [diff] [blame] | 250 | llvm::Function *getMemMoveFn(); |
Lauro Ramos Venancio | 41ef30e | 2008-02-19 22:01:01 +0000 | [diff] [blame] | 251 | llvm::Function *getMemSetFn(); |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 252 | llvm::Function *getIntrinsic(unsigned IID, const llvm::Type **Tys = 0, |
Chris Lattner | 7acda7c | 2007-12-18 00:25:38 +0000 | [diff] [blame] | 253 | unsigned NumTys = 0); |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 254 | |
Daniel Dunbar | 41071de | 2008-08-15 23:26:23 +0000 | [diff] [blame] | 255 | /// EmitTopLevelDecl - Emit code for a single top level declaration. |
| 256 | void EmitTopLevelDecl(Decl *D); |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 257 | |
Daniel Dunbar | 0269871 | 2009-02-13 20:29:50 +0000 | [diff] [blame] | 258 | /// AddUsedGlobal - Add a global which should be forced to be |
| 259 | /// present in the object file; these are emitted to the llvm.used |
| 260 | /// metadata global. |
| 261 | void AddUsedGlobal(llvm::GlobalValue *GV); |
| 262 | |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 263 | void AddAnnotation(llvm::Constant *C) { Annotations.push_back(C); } |
| 264 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 265 | /// CreateRuntimeFunction - Create a new runtime function whose name must be |
| 266 | /// protected from collisions. |
| 267 | llvm::Function *CreateRuntimeFunction(const llvm::FunctionType *Ty, |
Daniel Dunbar | f1968f2 | 2008-10-01 00:49:24 +0000 | [diff] [blame] | 268 | const std::string &Name); |
| 269 | |
Chris Lattner | c5b8806 | 2008-02-06 05:08:19 +0000 | [diff] [blame] | 270 | void UpdateCompletedType(const TagDecl *D); |
Daniel Dunbar | d60f2fb | 2009-02-17 18:43:32 +0000 | [diff] [blame] | 271 | |
| 272 | /// EmitConstantExpr - Try to emit the given expression as a |
| 273 | /// constant; returns 0 if the expression cannot be emitted as a |
| 274 | /// constant. |
Lauro Ramos Venancio | 8137335 | 2008-02-26 21:41:45 +0000 | [diff] [blame] | 275 | llvm::Constant *EmitConstantExpr(const Expr *E, CodeGenFunction *CGF = 0); |
Daniel Dunbar | d60f2fb | 2009-02-17 18:43:32 +0000 | [diff] [blame] | 276 | |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 277 | llvm::Constant *EmitAnnotateAttr(llvm::GlobalValue *GV, |
| 278 | const AnnotateAttr *AA, unsigned LineNo); |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 279 | |
Daniel Dunbar | 488e993 | 2008-08-16 00:56:44 +0000 | [diff] [blame] | 280 | /// ErrorUnsupported - Print out an error that codegen doesn't support the |
Daniel Dunbar | 90df4b6 | 2008-09-04 03:43:08 +0000 | [diff] [blame] | 281 | /// specified stmt yet. |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 282 | /// \param OmitOnError - If true, then this error should only be emitted if no |
| 283 | /// other errors have been reported. |
| 284 | void ErrorUnsupported(const Stmt *S, const char *Type, |
Daniel Dunbar | 90df4b6 | 2008-09-04 03:43:08 +0000 | [diff] [blame] | 285 | bool OmitOnError=false); |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 286 | |
Daniel Dunbar | 488e993 | 2008-08-16 00:56:44 +0000 | [diff] [blame] | 287 | /// ErrorUnsupported - Print out an error that codegen doesn't support the |
Chris Lattner | c6fdc34 | 2008-01-12 07:05:38 +0000 | [diff] [blame] | 288 | /// specified decl yet. |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 289 | /// \param OmitOnError - If true, then this error should only be emitted if no |
| 290 | /// other errors have been reported. |
Daniel Dunbar | 90df4b6 | 2008-09-04 03:43:08 +0000 | [diff] [blame] | 291 | void ErrorUnsupported(const Decl *D, const char *Type, |
| 292 | bool OmitOnError=false); |
Dan Gohman | 4f8d123 | 2008-05-22 00:50:06 +0000 | [diff] [blame] | 293 | |
Daniel Dunbar | f80519b | 2008-09-04 23:41:35 +0000 | [diff] [blame] | 294 | void SetMethodAttributes(const ObjCMethodDecl *MD, |
| 295 | llvm::Function *F); |
| 296 | |
Devang Patel | 761d7f7 | 2008-09-25 21:02:23 +0000 | [diff] [blame] | 297 | void SetFunctionAttributes(const Decl *D, |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 298 | const CGFunctionInfo &Info, |
Daniel Dunbar | b768807 | 2008-09-10 00:41:16 +0000 | [diff] [blame] | 299 | llvm::Function *F); |
| 300 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 301 | /// ReturnTypeUsesSret - Return true iff the given type uses 'sret' when used |
| 302 | /// as a return type. |
Daniel Dunbar | 88b5396 | 2009-02-02 22:03:45 +0000 | [diff] [blame] | 303 | bool ReturnTypeUsesSret(const CGFunctionInfo &FI); |
Daniel Dunbar | b768807 | 2008-09-10 00:41:16 +0000 | [diff] [blame] | 304 | |
Daniel Dunbar | 88b5396 | 2009-02-02 22:03:45 +0000 | [diff] [blame] | 305 | void ConstructAttributeList(const CGFunctionInfo &Info, |
| 306 | const Decl *TargetDecl, |
Devang Patel | 761d7f7 | 2008-09-25 21:02:23 +0000 | [diff] [blame] | 307 | AttributeListType &PAL); |
Daniel Dunbar | b768807 | 2008-09-10 00:41:16 +0000 | [diff] [blame] | 308 | |
Douglas Gregor | 6ec3668 | 2009-02-18 23:53:56 +0000 | [diff] [blame] | 309 | const char *getMangledName(const NamedDecl *ND); |
Douglas Gregor | 5f2bfd4 | 2009-02-13 00:10:09 +0000 | [diff] [blame] | 310 | |
| 311 | |
Chris Lattner | 9cd4fe4 | 2007-12-02 07:09:19 +0000 | [diff] [blame] | 312 | private: |
Daniel Dunbar | 5c61d97 | 2009-02-13 22:08:43 +0000 | [diff] [blame] | 313 | /// SetGlobalValueAttributes - Set attributes for a global decl. |
| 314 | void SetGlobalValueAttributes(const Decl *D, |
| 315 | bool IsInternal, |
| 316 | bool IsInline, |
| 317 | llvm::GlobalValue *GV, |
| 318 | bool ForDefinition); |
| 319 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 320 | /// SetFunctionAttributesForDefinition - Set function attributes specific to a |
| 321 | /// function definition. |
Daniel Dunbar | 219df66 | 2008-09-08 23:44:31 +0000 | [diff] [blame] | 322 | /// \param D - The ObjCMethodDecl or FunctionDecl defining \arg F. |
| 323 | void SetFunctionAttributesForDefinition(const Decl *D, |
| 324 | llvm::Function *F); |
Daniel Dunbar | f80519b | 2008-09-04 23:41:35 +0000 | [diff] [blame] | 325 | |
Eli Friedman | ff4a2d9 | 2008-06-01 15:54:49 +0000 | [diff] [blame] | 326 | void SetFunctionAttributes(const FunctionDecl *FD, |
Daniel Dunbar | f80519b | 2008-09-04 23:41:35 +0000 | [diff] [blame] | 327 | llvm::Function *F); |
Nuno Lopes | d4cbda6 | 2008-06-08 15:45:52 +0000 | [diff] [blame] | 328 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 329 | /// EmitGlobal - Emit code for a singal global function or var decl. Forward |
| 330 | /// declarations are emitted lazily. |
Daniel Dunbar | 41071de | 2008-08-15 23:26:23 +0000 | [diff] [blame] | 331 | void EmitGlobal(const ValueDecl *D); |
| 332 | |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 333 | void EmitGlobalDefinition(const ValueDecl *D); |
Daniel Dunbar | d5d3180 | 2009-02-19 07:15:39 +0000 | [diff] [blame] | 334 | |
| 335 | /// EmitForwardFunctionDefinition - Create a new function for the |
| 336 | /// given decl and set attributes as appropriate. |
| 337 | /// |
| 338 | /// \arg Ty - If non-null the LLVM function type to use for the |
| 339 | /// decl; it is the callers responsibility to make sure this is |
| 340 | /// compatible with the correct type. |
| 341 | llvm::GlobalValue *EmitForwardFunctionDefinition(const FunctionDecl *D, |
| 342 | const llvm::Type *Ty); |
| 343 | |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 344 | void EmitGlobalFunctionDefinition(const FunctionDecl *D); |
| 345 | void EmitGlobalVarDefinition(const VarDecl *D); |
Daniel Dunbar | af05bb9 | 2008-08-26 08:29:31 +0000 | [diff] [blame] | 346 | void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D); |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 347 | |
Daniel Dunbar | 6bfed7e | 2008-08-01 00:01:51 +0000 | [diff] [blame] | 348 | // FIXME: Hardcoding priority here is gross. |
| 349 | void AddGlobalCtor(llvm::Function * Ctor, int Priority=65535); |
| 350 | void AddGlobalDtor(llvm::Function * Dtor, int Priority=65535); |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 351 | |
Mike Stump | ecc90e9 | 2009-02-13 19:12:34 +0000 | [diff] [blame] | 352 | /// EmitCtorList - Generates a global array of functions and priorities using |
| 353 | /// the given list and name. This array will have appending linkage and is |
| 354 | /// suitable for use as a LLVM constructor or destructor array. |
Daniel Dunbar | 6bfed7e | 2008-08-01 00:01:51 +0000 | [diff] [blame] | 355 | void EmitCtorList(const CtorList &Fns, const char *GlobalName); |
| 356 | |
Daniel Dunbar | 219df66 | 2008-09-08 23:44:31 +0000 | [diff] [blame] | 357 | void EmitAliases(void); |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 358 | void EmitAnnotations(void); |
Daniel Dunbar | 0269871 | 2009-02-13 20:29:50 +0000 | [diff] [blame] | 359 | |
| 360 | /// EmitDeferred - Emit any needed decls for which code generation |
| 361 | /// was deferred. |
| 362 | void EmitDeferred(void); |
| 363 | |
| 364 | /// EmitLLVMUsed - Emit the llvm.used metadata used to force |
| 365 | /// references to global which may otherwise be optimized out. |
| 366 | void EmitLLVMUsed(void); |
Daniel Dunbar | f1968f2 | 2008-10-01 00:49:24 +0000 | [diff] [blame] | 367 | |
| 368 | void BindRuntimeFunctions(); |
Daniel Dunbar | 73241df | 2009-02-13 21:18:01 +0000 | [diff] [blame] | 369 | |
| 370 | /// MayDeferGeneration - Determine if the given decl can be emitted |
| 371 | /// lazily; this is only relevant for definitions. The given decl |
| 372 | /// must be either a function or var decl. |
| 373 | bool MayDeferGeneration(const ValueDecl *D); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 374 | }; |
| 375 | } // end namespace CodeGen |
| 376 | } // end namespace clang |
| 377 | |
| 378 | #endif |