blob: 8c7571fd642ec44d8d907933c9a9c746fe3935f0 [file] [log] [blame]
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001//===--- CodeGenModule.h - Per-Module state for LLVM CodeGen ----*- C++ -*-===//
Reid Spencer5f016e22007-07-11 17:01:13 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Mike Stumpecc90e92009-02-13 19:12:34 +000010// This is the internal per-translation-unit state used for llvm translation.
Reid Spencer5f016e22007-07-11 17:01:13 +000011//
12//===----------------------------------------------------------------------===//
13
Chris Lattneref52a2f2008-02-29 17:10:38 +000014#ifndef CLANG_CODEGEN_CODEGENMODULE_H
15#define CLANG_CODEGEN_CODEGENMODULE_H
Reid Spencer5f016e22007-07-11 17:01:13 +000016
Dan Gohman4f8d1232008-05-22 00:50:06 +000017#include "clang/AST/Attr.h"
Chris Lattnerbd360642009-03-26 05:00:52 +000018#include "CGBlocks.h"
19#include "CGCall.h"
20#include "CodeGenTypes.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000021#include "llvm/ADT/DenseMap.h"
Anders Carlssonc9e20912007-08-21 00:21:21 +000022#include "llvm/ADT/StringMap.h"
Douglas Gregor6ec36682009-02-18 23:53:56 +000023#include "llvm/ADT/StringSet.h"
Chris Lattner35f38a22009-03-31 22:37:52 +000024#include "llvm/Support/ValueHandle.h"
Anders Carlssonb723f752009-01-04 02:08:04 +000025#include <list>
26
Reid Spencer5f016e22007-07-11 17:01:13 +000027namespace llvm {
28 class Module;
29 class Constant;
30 class Function;
Nate Begeman8bd4afe2008-04-19 04:17:09 +000031 class GlobalValue;
Devang Patel7a4718e2007-10-31 20:01:01 +000032 class TargetData;
Eli Friedmanff4a2d92008-06-01 15:54:49 +000033 class FunctionType;
Reid Spencer5f016e22007-07-11 17:01:13 +000034}
35
36namespace clang {
37 class ASTContext;
38 class FunctionDecl;
Daniel Dunbar90db8822008-08-25 06:18:57 +000039 class IdentifierInfo;
Chris Lattner391d77a2008-03-30 23:03:07 +000040 class ObjCMethodDecl;
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000041 class ObjCImplementationDecl;
42 class ObjCCategoryImplDecl;
43 class ObjCProtocolDecl;
Chris Lattnereaf2bb82009-02-24 22:18:39 +000044 class ObjCEncodeExpr;
Anders Carlssond5cab542009-02-12 17:55:02 +000045 class BlockExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +000046 class Decl;
Oliver Hunt28247232007-12-02 00:11:25 +000047 class Expr;
Chris Lattner2c8569d2007-12-02 07:19:18 +000048 class Stmt;
Daniel Dunbar1e049762008-08-10 20:25:57 +000049 class StringLiteral;
Nate Begeman1a1d92a2008-04-20 20:38:08 +000050 class NamedDecl;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +000051 class ValueDecl;
Chris Lattner2b9d2ca2007-12-18 08:16:44 +000052 class VarDecl;
Sebastian Redl43af76e2009-03-07 12:16:37 +000053 class LangOptions;
Chris Lattnerbd360642009-03-26 05:00:52 +000054 class CompileOptions;
Chris Lattnerfb97b032007-12-02 01:40:18 +000055 class Diagnostic;
Nate Begeman8bd4afe2008-04-19 04:17:09 +000056 class AnnotateAttr;
Mike Stumpecc90e92009-02-13 19:12:34 +000057
Reid Spencer5f016e22007-07-11 17:01:13 +000058namespace CodeGen {
59
Lauro Ramos Venancio81373352008-02-26 21:41:45 +000060 class CodeGenFunction;
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000061 class CGDebugInfo;
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000062 class CGObjCRuntime;
Mike Stumpecc90e92009-02-13 19:12:34 +000063
64/// CodeGenModule - This class organizes the cross-function state that is used
65/// while generating LLVM code.
Mike Stump2a998142009-03-04 18:17:45 +000066class CodeGenModule : public BlockModule {
Anders Carlsson8a219ce2009-02-24 04:21:31 +000067 CodeGenModule(const CodeGenModule&); // DO NOT IMPLEMENT
68 void operator=(const CodeGenModule&); // DO NOT IMPLEMENT
69
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +000070 typedef std::vector< std::pair<llvm::Constant*, int> > CtorList;
71
Reid Spencer5f016e22007-07-11 17:01:13 +000072 ASTContext &Context;
Chris Lattner45e8cbd2007-11-28 05:34:05 +000073 const LangOptions &Features;
Chris Lattnerbd360642009-03-26 05:00:52 +000074 const CompileOptions &CompileOpts;
Reid Spencer5f016e22007-07-11 17:01:13 +000075 llvm::Module &TheModule;
Devang Patel7a4718e2007-10-31 20:01:01 +000076 const llvm::TargetData &TheTargetData;
Chris Lattnerfb97b032007-12-02 01:40:18 +000077 Diagnostic &Diags;
Reid Spencer5f016e22007-07-11 17:01:13 +000078 CodeGenTypes Types;
Ted Kremenek815c78f2008-08-05 18:50:11 +000079 CGObjCRuntime* Runtime;
80 CGDebugInfo* DebugInfo;
Reid Spencer5f016e22007-07-11 17:01:13 +000081
82 llvm::Function *MemCpyFn;
Eli Friedman0c995092008-05-26 12:59:39 +000083 llvm::Function *MemMoveFn;
Lauro Ramos Venancio41ef30e2008-02-19 22:01:01 +000084 llvm::Function *MemSetFn;
Daniel Dunbar9986eab2008-07-30 16:32:24 +000085
Douglas Gregor6ec36682009-02-18 23:53:56 +000086 /// GlobalDeclMap - Mapping of decl names (represented as unique
87 /// character pointers from either the identifier table or the set
88 /// of mangled names) to global variables we have already
89 /// emitted. Note that the entries in this map are the actual
90 /// globals and therefore may not be of the same type as the decl,
91 /// they should be bitcasted on retrieval. Also note that the
Chris Lattnere21c4b82009-03-21 07:48:31 +000092 /// globals are keyed on their source mangled name, not the global name
Chris Lattner67b00522009-03-21 09:44:56 +000093 /// (which may change with attributes such as asm-labels). The key
Douglas Gregor6ec36682009-02-18 23:53:56 +000094 /// to this map should be generated using getMangledName().
Chris Lattner67b00522009-03-21 09:44:56 +000095 ///
96 /// Note that this map always lines up exactly with the contents of the LLVM
97 /// IR symbol table, but this is quicker to query since it is doing uniqued
98 /// pointer lookups instead of full string lookups.
Douglas Gregor6ec36682009-02-18 23:53:56 +000099 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 Dunbarbd012ff2008-07-29 23:18:29 +0000107
Chris Lattner67b00522009-03-21 09:44:56 +0000108 /// DeferredDecls - This contains all the decls which have definitions but
109 /// which are deferred for emission and therefore should only be output if
110 /// they are actually used. If a decl is in this, then it is known to have
111 /// not been referenced yet. The key to this map is a uniqued mangled name.
112 llvm::DenseMap<const char*, const ValueDecl*> DeferredDecls;
Daniel Dunbar02698712009-02-13 20:29:50 +0000113
Chris Lattner67b00522009-03-21 09:44:56 +0000114 /// DeferredDeclsToEmit - This is a list of deferred decls which we have seen
115 /// that *are* actually referenced. These get code generated when the module
116 /// is done.
117 std::vector<const ValueDecl*> DeferredDeclsToEmit;
118
Daniel Dunbar02698712009-02-13 20:29:50 +0000119 /// LLVMUsed - List of global values which are required to be
120 /// present in the object file; bitcast to i8*. This is used for
121 /// forcing visibility of symbols which may otherwise be optimized
122 /// out.
Chris Lattner35f38a22009-03-31 22:37:52 +0000123 std::vector<llvm::WeakVH> LLVMUsed;
Mike Stumpecc90e92009-02-13 19:12:34 +0000124
125 /// GlobalCtors - Store the list of global constructors and their respective
126 /// priorities to be emitted when the translation unit is complete.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000127 CtorList GlobalCtors;
128
Mike Stumpecc90e92009-02-13 19:12:34 +0000129 /// GlobalDtors - Store the list of global destructors and their respective
130 /// priorities to be emitted when the translation unit is complete.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000131 CtorList GlobalDtors;
132
Nate Begeman532485c2008-04-18 23:43:57 +0000133 std::vector<llvm::Constant*> Annotations;
Mike Stumpecc90e92009-02-13 19:12:34 +0000134
Anders Carlssonc9e20912007-08-21 00:21:21 +0000135 llvm::StringMap<llvm::Constant*> CFConstantStringMap;
Chris Lattner45e8cbd2007-11-28 05:34:05 +0000136 llvm::StringMap<llvm::Constant*> ConstantStringMap;
Daniel Dunbar3e9df992008-08-23 18:37:06 +0000137
Mike Stumpecc90e92009-02-13 19:12:34 +0000138 /// CFConstantStringClassRef - Cached reference to the class for constant
139 /// strings. This value has type int * but is actually an Obj-C class pointer.
Anders Carlssonc9e20912007-08-21 00:21:21 +0000140 llvm::Constant *CFConstantStringClassRef;
Reid Spencer5f016e22007-07-11 17:01:13 +0000141public:
Chris Lattnerbd360642009-03-26 05:00:52 +0000142 CodeGenModule(ASTContext &C, const CompileOptions &CompileOpts,
143 llvm::Module &M, const llvm::TargetData &TD, Diagnostic &Diags);
Ted Kremenek815c78f2008-08-05 18:50:11 +0000144
Chris Lattner2b94fe32008-03-01 08:45:05 +0000145 ~CodeGenModule();
Mike Stumpecc90e92009-02-13 19:12:34 +0000146
Ted Kremenek815c78f2008-08-05 18:50:11 +0000147 /// Release - Finalize LLVM code generation.
148 void Release();
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000149
150 /// getObjCRuntime() - Return a reference to the configured
151 /// Objective-C runtime.
Mike Stumpecc90e92009-02-13 19:12:34 +0000152 CGObjCRuntime &getObjCRuntime() {
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000153 assert(Runtime && "No Objective-C runtime has been configured.");
Mike Stumpecc90e92009-02-13 19:12:34 +0000154 return *Runtime;
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000155 }
Mike Stumpecc90e92009-02-13 19:12:34 +0000156
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000157 /// hasObjCRuntime() - Return true iff an Objective-C runtime has
158 /// been configured.
159 bool hasObjCRuntime() { return !!Runtime; }
160
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +0000161 CGDebugInfo *getDebugInfo() { return DebugInfo; }
Reid Spencer5f016e22007-07-11 17:01:13 +0000162 ASTContext &getContext() const { return Context; }
Devang Patel07739032009-03-27 23:16:32 +0000163 const CompileOptions &getCompileOpts() const { return CompileOpts; }
Chris Lattner45e8cbd2007-11-28 05:34:05 +0000164 const LangOptions &getLangOptions() const { return Features; }
Reid Spencer5f016e22007-07-11 17:01:13 +0000165 llvm::Module &getModule() const { return TheModule; }
166 CodeGenTypes &getTypes() { return Types; }
Chris Lattnerfb97b032007-12-02 01:40:18 +0000167 Diagnostic &getDiags() const { return Diags; }
Chris Lattner8f925282008-01-03 06:36:51 +0000168 const llvm::TargetData &getTargetData() const { return TheTargetData; }
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000169
Mike Stumpecc90e92009-02-13 19:12:34 +0000170 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
Chris Lattner570585c2009-03-21 09:16:30 +0000171 /// given global variable. If Ty is non-null and if the global doesn't exist,
172 /// then it will be greated with the specified type instead of whatever the
173 /// normal requested type would be.
174 llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D,
175 const llvm::Type *Ty = 0);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000176
Chris Lattner34809502009-03-21 08:53:37 +0000177 /// GetAddrOfFunction - Return the address of the given function. If Ty is
178 /// non-null, then this function will use the specified type if it has to
179 /// create it.
Chris Lattner0558e792009-03-21 09:25:43 +0000180 llvm::Constant *GetAddrOfFunction(const FunctionDecl *D,
Chris Lattner34809502009-03-21 08:53:37 +0000181 const llvm::Type *Ty = 0);
Daniel Dunbar61432932008-08-13 23:20:05 +0000182
Mike Stumpecc90e92009-02-13 19:12:34 +0000183 /// GetStringForStringLiteral - Return the appropriate bytes for a string
184 /// literal, properly padded to match the literal type. If only the address of
185 /// a constant is needed consider using GetAddrOfConstantStringLiteral.
Daniel Dunbar61432932008-08-13 23:20:05 +0000186 std::string GetStringForStringLiteral(const StringLiteral *E);
187
Mike Stumpecc90e92009-02-13 19:12:34 +0000188 /// GetAddrOfConstantCFString - Return a pointer to a constant CFString object
189 /// for the given string.
Anders Carlssonc9e20912007-08-21 00:21:21 +0000190 llvm::Constant *GetAddrOfConstantCFString(const std::string& str);
Chris Lattnera7ad98f2008-02-11 00:02:17 +0000191
Mike Stumpecc90e92009-02-13 19:12:34 +0000192 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a constant array
193 /// for the given string literal.
Daniel Dunbar61432932008-08-13 23:20:05 +0000194 llvm::Constant *GetAddrOfConstantStringFromLiteral(const StringLiteral *S);
Daniel Dunbar1e049762008-08-10 20:25:57 +0000195
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000196 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
197 /// array for the given ObjCEncodeExpr node.
198 llvm::Constant *GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *);
199
Daniel Dunbar61432932008-08-13 23:20:05 +0000200 /// GetAddrOfConstantString - Returns a pointer to a character array
Mike Stumpecc90e92009-02-13 19:12:34 +0000201 /// containing the literal. This contents are exactly that of the given
202 /// string, i.e. it will not be null terminated automatically; see
203 /// GetAddrOfConstantCString. Note that whether the result is actually a
204 /// pointer to an LLVM constant depends on Feature.WriteableStrings.
Daniel Dunbar61432932008-08-13 23:20:05 +0000205 ///
206 /// The result has pointer to array type.
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +0000207 ///
208 /// \param GlobalName If provided, the name to use for the global
209 /// (if one is created).
210 llvm::Constant *GetAddrOfConstantString(const std::string& str,
211 const char *GlobalName=0);
Daniel Dunbar61432932008-08-13 23:20:05 +0000212
Mike Stumpecc90e92009-02-13 19:12:34 +0000213 /// GetAddrOfConstantCString - Returns a pointer to a character array
214 /// containing the literal and a terminating '\0' character. The result has
215 /// pointer to array type.
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +0000216 ///
Mike Stumpecc90e92009-02-13 19:12:34 +0000217 /// \param GlobalName If provided, the name to use for the global (if one is
218 /// created).
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +0000219 llvm::Constant *GetAddrOfConstantCString(const std::string &str,
220 const char *GlobalName=0);
Mike Stumpecc90e92009-02-13 19:12:34 +0000221
Daniel Dunbar41071de2008-08-15 23:26:23 +0000222 /// getBuiltinLibFunction - Given a builtin id for a function like
223 /// "__builtin_fabsf", return a Function* for "fabsf".
Mike Stumpc136e6c2009-02-27 22:42:30 +0000224 llvm::Value *getBuiltinLibFunction(unsigned BuiltinID);
Daniel Dunbar61432932008-08-13 23:20:05 +0000225
Reid Spencer5f016e22007-07-11 17:01:13 +0000226 llvm::Function *getMemCpyFn();
Eli Friedman0c995092008-05-26 12:59:39 +0000227 llvm::Function *getMemMoveFn();
Lauro Ramos Venancio41ef30e2008-02-19 22:01:01 +0000228 llvm::Function *getMemSetFn();
Mike Stumpecc90e92009-02-13 19:12:34 +0000229 llvm::Function *getIntrinsic(unsigned IID, const llvm::Type **Tys = 0,
Chris Lattner7acda7c2007-12-18 00:25:38 +0000230 unsigned NumTys = 0);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000231
Daniel Dunbar41071de2008-08-15 23:26:23 +0000232 /// EmitTopLevelDecl - Emit code for a single top level declaration.
233 void EmitTopLevelDecl(Decl *D);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000234
Daniel Dunbar02698712009-02-13 20:29:50 +0000235 /// AddUsedGlobal - Add a global which should be forced to be
236 /// present in the object file; these are emitted to the llvm.used
237 /// metadata global.
238 void AddUsedGlobal(llvm::GlobalValue *GV);
239
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000240 void AddAnnotation(llvm::Constant *C) { Annotations.push_back(C); }
241
Chris Lattner74391b42009-03-22 21:03:39 +0000242 /// CreateRuntimeFunction - Create a new runtime function with the specified
243 /// type and name.
244 llvm::Constant *CreateRuntimeFunction(const llvm::FunctionType *Ty,
245 const char *Name);
246 /// CreateRuntimeVariable - Create a new runtime global variable with the
247 /// specified type and name.
248 llvm::Constant *CreateRuntimeVariable(const llvm::Type *Ty,
249 const char *Name);
Daniel Dunbarf1968f22008-10-01 00:49:24 +0000250
Chris Lattner5ad0f672009-04-01 02:08:13 +0000251 void UpdateCompletedType(const TagDecl *TD) {
252 // Make sure that this type is translated.
253 Types.UpdateCompletedType(TD);
254 }
Daniel Dunbard60f2fb2009-02-17 18:43:32 +0000255
256 /// EmitConstantExpr - Try to emit the given expression as a
257 /// constant; returns 0 if the expression cannot be emitted as a
258 /// constant.
Lauro Ramos Venancio81373352008-02-26 21:41:45 +0000259 llvm::Constant *EmitConstantExpr(const Expr *E, CodeGenFunction *CGF = 0);
Daniel Dunbard60f2fb2009-02-17 18:43:32 +0000260
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000261 llvm::Constant *EmitAnnotateAttr(llvm::GlobalValue *GV,
262 const AnnotateAttr *AA, unsigned LineNo);
Mike Stumpecc90e92009-02-13 19:12:34 +0000263
Daniel Dunbar488e9932008-08-16 00:56:44 +0000264 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000265 /// specified stmt yet.
Mike Stumpecc90e92009-02-13 19:12:34 +0000266 /// \param OmitOnError - If true, then this error should only be emitted if no
267 /// other errors have been reported.
268 void ErrorUnsupported(const Stmt *S, const char *Type,
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000269 bool OmitOnError=false);
Mike Stumpecc90e92009-02-13 19:12:34 +0000270
Daniel Dunbar488e9932008-08-16 00:56:44 +0000271 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000272 /// specified decl yet.
Mike Stumpecc90e92009-02-13 19:12:34 +0000273 /// \param OmitOnError - If true, then this error should only be emitted if no
274 /// other errors have been reported.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000275 void ErrorUnsupported(const Decl *D, const char *Type,
276 bool OmitOnError=false);
Dan Gohman4f8d1232008-05-22 00:50:06 +0000277
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000278 void SetMethodAttributes(const ObjCMethodDecl *MD,
279 llvm::Function *F);
280
Devang Patel761d7f72008-09-25 21:02:23 +0000281 void SetFunctionAttributes(const Decl *D,
Mike Stumpecc90e92009-02-13 19:12:34 +0000282 const CGFunctionInfo &Info,
Daniel Dunbarb7688072008-09-10 00:41:16 +0000283 llvm::Function *F);
284
Mike Stumpecc90e92009-02-13 19:12:34 +0000285 /// ReturnTypeUsesSret - Return true iff the given type uses 'sret' when used
286 /// as a return type.
Daniel Dunbar88b53962009-02-02 22:03:45 +0000287 bool ReturnTypeUsesSret(const CGFunctionInfo &FI);
Daniel Dunbarb7688072008-09-10 00:41:16 +0000288
Daniel Dunbar88b53962009-02-02 22:03:45 +0000289 void ConstructAttributeList(const CGFunctionInfo &Info,
290 const Decl *TargetDecl,
Devang Patel761d7f72008-09-25 21:02:23 +0000291 AttributeListType &PAL);
Daniel Dunbarb7688072008-09-10 00:41:16 +0000292
Douglas Gregor6ec36682009-02-18 23:53:56 +0000293 const char *getMangledName(const NamedDecl *ND);
Douglas Gregor5f2bfd42009-02-13 00:10:09 +0000294
295
Chris Lattner9cd4fe42007-12-02 07:09:19 +0000296private:
Chris Lattner74391b42009-03-22 21:03:39 +0000297 llvm::Constant *GetOrCreateLLVMFunction(const char *MangledName,
298 const llvm::Type *Ty,
299 const FunctionDecl *D);
300 llvm::Constant *GetOrCreateLLVMGlobal(const char *MangledName,
301 const llvm::PointerType *PTy,
302 const VarDecl *D);
303
Daniel Dunbar5c61d972009-02-13 22:08:43 +0000304 /// SetGlobalValueAttributes - Set attributes for a global decl.
305 void SetGlobalValueAttributes(const Decl *D,
306 bool IsInternal,
307 bool IsInline,
308 llvm::GlobalValue *GV,
309 bool ForDefinition);
310
Mike Stumpecc90e92009-02-13 19:12:34 +0000311 /// SetFunctionAttributesForDefinition - Set function attributes specific to a
312 /// function definition.
Daniel Dunbar219df662008-09-08 23:44:31 +0000313 /// \param D - The ObjCMethodDecl or FunctionDecl defining \arg F.
314 void SetFunctionAttributesForDefinition(const Decl *D,
315 llvm::Function *F);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000316
Eli Friedmanff4a2d92008-06-01 15:54:49 +0000317 void SetFunctionAttributes(const FunctionDecl *FD,
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000318 llvm::Function *F);
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000319
Mike Stumpecc90e92009-02-13 19:12:34 +0000320 /// EmitGlobal - Emit code for a singal global function or var decl. Forward
321 /// declarations are emitted lazily.
Daniel Dunbar41071de2008-08-15 23:26:23 +0000322 void EmitGlobal(const ValueDecl *D);
323
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000324 void EmitGlobalDefinition(const ValueDecl *D);
Daniel Dunbard5d31802009-02-19 07:15:39 +0000325
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000326 void EmitGlobalFunctionDefinition(const FunctionDecl *D);
327 void EmitGlobalVarDefinition(const VarDecl *D);
Chris Lattnerbd532712009-03-22 21:47:11 +0000328 void EmitAliasDefinition(const ValueDecl *D);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000329 void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);
Anders Carlsson984e0682009-04-01 00:58:25 +0000330 void EmitNamespace(const NamespaceDecl *D);
331
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000332 // FIXME: Hardcoding priority here is gross.
333 void AddGlobalCtor(llvm::Function * Ctor, int Priority=65535);
334 void AddGlobalDtor(llvm::Function * Dtor, int Priority=65535);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000335
Mike Stumpecc90e92009-02-13 19:12:34 +0000336 /// EmitCtorList - Generates a global array of functions and priorities using
337 /// the given list and name. This array will have appending linkage and is
338 /// suitable for use as a LLVM constructor or destructor array.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000339 void EmitCtorList(const CtorList &Fns, const char *GlobalName);
340
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000341 void EmitAnnotations(void);
Daniel Dunbar02698712009-02-13 20:29:50 +0000342
Daniel Dunbar42745812009-03-09 23:53:08 +0000343 /// EmitDeferred - Emit any needed decls for which code generation
344 /// was deferred.
Daniel Dunbar02698712009-02-13 20:29:50 +0000345 void EmitDeferred(void);
346
Daniel Dunbar42745812009-03-09 23:53:08 +0000347 /// EmitLLVMUsed - Emit the llvm.used metadata used to force
348 /// references to global which may otherwise be optimized out.
Daniel Dunbar02698712009-02-13 20:29:50 +0000349 void EmitLLVMUsed(void);
Daniel Dunbarf1968f22008-10-01 00:49:24 +0000350
Daniel Dunbar42745812009-03-09 23:53:08 +0000351 /// MayDeferGeneration - Determine if the given decl can be emitted
352 /// lazily; this is only relevant for definitions. The given decl
353 /// must be either a function or var decl.
Daniel Dunbar73241df2009-02-13 21:18:01 +0000354 bool MayDeferGeneration(const ValueDecl *D);
Reid Spencer5f016e22007-07-11 17:01:13 +0000355};
356} // end namespace CodeGen
357} // end namespace clang
358
359#endif