xref: /llvm-project/clang/lib/CodeGen/CodeGenModule.cpp (revision 87ab27d42fd78139031bcc873537a8608408c7fe)
1 //===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
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 // This coordinates the per-module state used while generating code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CGDebugInfo.h"
15 #include "CodeGenModule.h"
16 #include "CodeGenFunction.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/Basic/Diagnostic.h"
20 #include "clang/Basic/LangOptions.h"
21 #include "clang/Basic/SourceManager.h"
22 #include "clang/Basic/TargetInfo.h"
23 #include "llvm/CallingConv.h"
24 #include "llvm/Constants.h"
25 #include "llvm/DerivedTypes.h"
26 #include "llvm/Module.h"
27 #include "llvm/Intrinsics.h"
28 #include "llvm/Target/TargetData.h"
29 #include "llvm/Analysis/Verifier.h"
30 #include <algorithm>
31 using namespace clang;
32 using namespace CodeGen;
33 
34 
35 CodeGenModule::CodeGenModule(ASTContext &C, const LangOptions &LO,
36                              llvm::Module &M, const llvm::TargetData &TD,
37                              Diagnostic &diags, bool GenerateDebugInfo)
38   : Context(C), Features(LO), TheModule(M), TheTargetData(TD), Diags(diags),
39     Types(C, M, TD), MemCpyFn(0), MemMoveFn(0), MemSetFn(0),
40     CFConstantStringClassRef(0) {
41   //TODO: Make this selectable at runtime
42   Runtime = CreateObjCRuntime(*this);
43 
44   // If debug info generation is enabled, create the CGDebugInfo object.
45   if (GenerateDebugInfo)
46     DebugInfo = new CGDebugInfo(this);
47   else
48     DebugInfo = NULL;
49 }
50 
51 CodeGenModule::~CodeGenModule() {
52   EmitStatics();
53   llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction();
54   if (ObjCInitFunction)
55     AddGlobalCtor(ObjCInitFunction);
56   EmitGlobalCtors();
57   EmitAnnotations();
58   delete Runtime;
59   delete DebugInfo;
60   // Run the verifier to check that the generated code is consistent.
61   assert(!verifyModule(TheModule));
62 }
63 
64 /// WarnUnsupported - Print out a warning that codegen doesn't support the
65 /// specified stmt yet.
66 void CodeGenModule::WarnUnsupported(const Stmt *S, const char *Type) {
67   unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Warning,
68                                                "cannot codegen this %0 yet");
69   SourceRange Range = S->getSourceRange();
70   std::string Msg = Type;
71   getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID,
72                     &Msg, 1, &Range, 1);
73 }
74 
75 /// WarnUnsupported - Print out a warning that codegen doesn't support the
76 /// specified decl yet.
77 void CodeGenModule::WarnUnsupported(const Decl *D, const char *Type) {
78   unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Warning,
79                                                "cannot codegen this %0 yet");
80   std::string Msg = Type;
81   getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID,
82                     &Msg, 1);
83 }
84 
85 /// setVisibility - Set the visibility for the given LLVM GlobalValue
86 /// according to the given clang AST visibility value.
87 void CodeGenModule::setVisibility(llvm::GlobalValue *GV,
88                                   VisibilityAttr::VisibilityTypes Vis) {
89   switch (Vis) {
90   default: assert(0 && "Unknown visibility!");
91   case VisibilityAttr::DefaultVisibility:
92     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
93     break;
94   case VisibilityAttr::HiddenVisibility:
95     GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
96     break;
97   case VisibilityAttr::ProtectedVisibility:
98     GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
99     break;
100   }
101 }
102 
103 /// AddGlobalCtor - Add a function to the list that will be called before
104 /// main() runs.
105 void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor) {
106   // TODO: Type coercion of void()* types.
107   GlobalCtors.push_back(Ctor);
108 }
109 
110 /// EmitGlobalCtors - Generates the array of contsturctor functions to be
111 /// called on module load, if any have been registered with AddGlobalCtor.
112 void CodeGenModule::EmitGlobalCtors() {
113   if (GlobalCtors.empty()) return;
114 
115   // Get the type of @llvm.global_ctors
116   std::vector<const llvm::Type*> CtorFields;
117   CtorFields.push_back(llvm::IntegerType::get(32));
118   // Constructor function type
119   std::vector<const llvm::Type*> VoidArgs;
120   llvm::FunctionType* CtorFuncTy =
121     llvm::FunctionType::get(llvm::Type::VoidTy, VoidArgs, false);
122 
123   // i32, function type pair
124   const llvm::Type *FPType = llvm::PointerType::getUnqual(CtorFuncTy);
125   llvm::StructType* CtorStructTy =
126   llvm::StructType::get(llvm::Type::Int32Ty, FPType, NULL);
127   // Array of fields
128   llvm::ArrayType* GlobalCtorsTy =
129     llvm::ArrayType::get(CtorStructTy, GlobalCtors.size());
130 
131   // Define the global variable
132   llvm::GlobalVariable *GlobalCtorsVal =
133     new llvm::GlobalVariable(GlobalCtorsTy, false,
134                              llvm::GlobalValue::AppendingLinkage,
135                              (llvm::Constant*)0, "llvm.global_ctors",
136                              &TheModule);
137 
138   // Populate the array
139   std::vector<llvm::Constant*> CtorValues;
140   llvm::Constant *MagicNumber =
141     llvm::ConstantInt::get(llvm::Type::Int32Ty, 65535, false);
142   std::vector<llvm::Constant*> StructValues;
143   for (std::vector<llvm::Constant*>::iterator I = GlobalCtors.begin(),
144        E = GlobalCtors.end(); I != E; ++I) {
145     StructValues.clear();
146     StructValues.push_back(MagicNumber);
147     StructValues.push_back(*I);
148 
149     CtorValues.push_back(llvm::ConstantStruct::get(CtorStructTy, StructValues));
150   }
151 
152   GlobalCtorsVal->setInitializer(llvm::ConstantArray::get(GlobalCtorsTy,
153                                                           CtorValues));
154 }
155 
156 
157 
158 void CodeGenModule::EmitAnnotations() {
159   if (Annotations.empty())
160     return;
161 
162   // Create a new global variable for the ConstantStruct in the Module.
163   llvm::Constant *Array =
164   llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(),
165                                                 Annotations.size()),
166                            Annotations);
167   llvm::GlobalValue *gv =
168   new llvm::GlobalVariable(Array->getType(), false,
169                            llvm::GlobalValue::AppendingLinkage, Array,
170                            "llvm.global.annotations", &TheModule);
171   gv->setSection("llvm.metadata");
172 }
173 
174 /// ReplaceMapValuesWith - This is a really slow and bad function that
175 /// searches for any entries in GlobalDeclMap that point to OldVal, changing
176 /// them to point to NewVal.  This is badbadbad, FIXME!
177 void CodeGenModule::ReplaceMapValuesWith(llvm::Constant *OldVal,
178                                          llvm::Constant *NewVal) {
179   for (llvm::DenseMap<const Decl*, llvm::Constant*>::iterator
180        I = GlobalDeclMap.begin(), E = GlobalDeclMap.end(); I != E; ++I)
181     if (I->second == OldVal) I->second = NewVal;
182 }
183 
184 bool hasAggregateLLVMType(QualType T) {
185   return !T->isRealType() && !T->isPointerLikeType() &&
186          !T->isVoidType() && !T->isVectorType() && !T->isFunctionType();
187 }
188 
189 void CodeGenModule::SetGlobalValueAttributes(const FunctionDecl *FD,
190                                              llvm::GlobalValue *GV) {
191   // TODO: Set up linkage and many other things.  Note, this is a simple
192   // approximation of what we really want.
193   if (FD->getStorageClass() == FunctionDecl::Static)
194     GV->setLinkage(llvm::Function::InternalLinkage);
195   else if (FD->getAttr<DLLImportAttr>())
196     GV->setLinkage(llvm::Function::DLLImportLinkage);
197   else if (FD->getAttr<DLLExportAttr>())
198     GV->setLinkage(llvm::Function::DLLExportLinkage);
199   else if (FD->getAttr<WeakAttr>() || FD->isInline())
200     GV->setLinkage(llvm::Function::WeakLinkage);
201 
202   if (const VisibilityAttr *attr = FD->getAttr<VisibilityAttr>())
203     CodeGenModule::setVisibility(GV, attr->getVisibility());
204   // FIXME: else handle -fvisibility
205 }
206 
207 void CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD,
208                                           llvm::Function *F,
209                                           const llvm::FunctionType *FTy) {
210   unsigned FuncAttrs = 0;
211   if (FD->getAttr<NoThrowAttr>())
212     FuncAttrs |= llvm::ParamAttr::NoUnwind;
213   if (FD->getAttr<NoReturnAttr>())
214     FuncAttrs |= llvm::ParamAttr::NoReturn;
215 
216   llvm::SmallVector<llvm::ParamAttrsWithIndex, 8> ParamAttrList;
217   if (FuncAttrs)
218     ParamAttrList.push_back(llvm::ParamAttrsWithIndex::get(0, FuncAttrs));
219   // Note that there is parallel code in CodeGenFunction::EmitCallExpr
220   bool AggregateReturn = hasAggregateLLVMType(FD->getResultType());
221   if (AggregateReturn)
222     ParamAttrList.push_back(
223         llvm::ParamAttrsWithIndex::get(1, llvm::ParamAttr::StructRet));
224   unsigned increment = AggregateReturn ? 2 : 1;
225   const FunctionTypeProto* FTP = dyn_cast<FunctionTypeProto>(FD->getType());
226   if (FTP) {
227     for (unsigned i = 0; i < FTP->getNumArgs(); i++) {
228       QualType ParamType = FTP->getArgType(i);
229       unsigned ParamAttrs = 0;
230       if (ParamType->isRecordType())
231         ParamAttrs |= llvm::ParamAttr::ByVal;
232       if (ParamType->isSignedIntegerType() && ParamType->isPromotableIntegerType())
233         ParamAttrs |= llvm::ParamAttr::SExt;
234       if (ParamType->isUnsignedIntegerType() && ParamType->isPromotableIntegerType())
235         ParamAttrs |= llvm::ParamAttr::ZExt;
236       if (ParamAttrs)
237         ParamAttrList.push_back(llvm::ParamAttrsWithIndex::get(i + increment,
238                                                                ParamAttrs));
239     }
240   }
241 
242   F->setParamAttrs(llvm::PAListPtr::get(ParamAttrList.begin(),
243                                         ParamAttrList.size()));
244 
245   // Set the appropriate calling convention for the Function.
246   if (FD->getAttr<FastCallAttr>())
247     F->setCallingConv(llvm::CallingConv::Fast);
248 
249   SetGlobalValueAttributes(FD, F);
250 }
251 
252 
253 
254 llvm::Constant *CodeGenModule::GetAddrOfFunctionDecl(const FunctionDecl *D,
255                                                      bool isDefinition) {
256   // See if it is already in the map.  If so, just return it.
257   llvm::Constant *&Entry = GlobalDeclMap[D];
258   if (!isDefinition && Entry) return Entry;
259 
260   const llvm::Type *Ty = getTypes().ConvertType(D->getType());
261 
262   // Check to see if the function already exists.
263   llvm::Function *F = getModule().getFunction(D->getName());
264   const llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
265 
266   // If it doesn't already exist, just create and return an entry.
267   if (F == 0) {
268     // FIXME: param attributes for sext/zext etc.
269     if (D->getBody() || !D->getAttr<AliasAttr>())
270       F = llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
271                                  D->getName(), &getModule());
272     else {
273       const std::string& aliaseeName = D->getAttr<AliasAttr>()->getAliasee();
274       llvm::Function *aliasee = getModule().getFunction(aliaseeName);
275       llvm::GlobalValue *alias = new llvm::GlobalAlias(aliasee->getType(),
276                                                        llvm::Function::ExternalLinkage,
277                                                        D->getName(),
278                                                        aliasee,
279                                                        &getModule());
280       SetGlobalValueAttributes(D, alias);
281       return Entry = alias;
282     }
283 
284     SetFunctionAttributes(D, F, FTy);
285     return Entry = F;
286   }
287 
288   // If the pointer type matches, just return it.
289   llvm::Type *PFTy = llvm::PointerType::getUnqual(Ty);
290   if (PFTy == F->getType()) return Entry = F;
291 
292   // If this isn't a definition, just return it casted to the right type.
293   if (!isDefinition)
294     return Entry = llvm::ConstantExpr::getBitCast(F, PFTy);
295 
296   // Otherwise, we have a definition after a prototype with the wrong type.
297   // F is the Function* for the one with the wrong type, we must make a new
298   // Function* and update everything that used F (a declaration) with the new
299   // Function* (which will be a definition).
300   //
301   // This happens if there is a prototype for a function (e.g. "int f()") and
302   // then a definition of a different type (e.g. "int f(int x)").  Start by
303   // making a new function of the correct type, RAUW, then steal the name.
304   llvm::Function *NewFn = llvm::Function::Create(FTy,
305                                              llvm::Function::ExternalLinkage,
306                                              "", &getModule());
307   NewFn->takeName(F);
308 
309   // Replace uses of F with the Function we will endow with a body.
310   llvm::Constant *NewPtrForOldDecl =
311     llvm::ConstantExpr::getBitCast(NewFn, F->getType());
312   F->replaceAllUsesWith(NewPtrForOldDecl);
313 
314   // FIXME: Update the globaldeclmap for the previous decl of this name.  We
315   // really want a way to walk all of these, but we don't have it yet.  This
316   // is incredibly slow!
317   ReplaceMapValuesWith(F, NewPtrForOldDecl);
318 
319   // Ok, delete the old function now, which is dead.
320   assert(F->isDeclaration() && "Shouldn't replace non-declaration");
321   F->eraseFromParent();
322 
323   SetFunctionAttributes(D, NewFn, FTy);
324   // Return the new function which has the right type.
325   return Entry = NewFn;
326 }
327 
328 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
329                                                   bool isDefinition) {
330   assert(D->hasGlobalStorage() && "Not a global variable");
331   assert(!isDefinition && "This shouldn't be called for definitions!");
332 
333   // See if it is already in the map.
334   llvm::Constant *&Entry = GlobalDeclMap[D];
335   if (Entry) return Entry;
336 
337   QualType ASTTy = D->getType();
338   const llvm::Type *Ty = getTypes().ConvertTypeForMem(ASTTy);
339 
340   // Check to see if the global already exists.
341   llvm::GlobalVariable *GV = getModule().getGlobalVariable(D->getName(), true);
342 
343   // If it doesn't already exist, just create and return an entry.
344   if (GV == 0) {
345     return Entry = new llvm::GlobalVariable(Ty, false,
346                                             llvm::GlobalValue::ExternalLinkage,
347                                             0, D->getName(), &getModule(), 0,
348                                             ASTTy.getAddressSpace());
349   }
350 
351   // Otherwise, it already exists; return the existing version
352   llvm::PointerType *PTy = llvm::PointerType::get(Ty, ASTTy.getAddressSpace());
353   return Entry = llvm::ConstantExpr::getBitCast(GV, PTy);
354 }
355 
356 void CodeGenModule::EmitObjCMethod(const ObjCMethodDecl *OMD) {
357   // If this is not a prototype, emit the body.
358   if (OMD->getBody())
359     CodeGenFunction(*this).GenerateObjCMethod(OMD);
360 }
361 void CodeGenModule::EmitObjCProtocolImplementation(const ObjCProtocolDecl *PD){
362   llvm::SmallVector<std::string, 16> Protocols;
363   for (unsigned i = 0, e = PD->getNumReferencedProtocols() ; i < e ; i++)
364     Protocols.push_back(PD->getReferencedProtocols()[i]->getName());
365   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodNames;
366   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
367   for (ObjCProtocolDecl::instmeth_iterator iter = PD->instmeth_begin(),
368       endIter = PD->instmeth_end() ; iter != endIter ; iter++) {
369     std::string TypeStr;
370     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
371     InstanceMethodNames.push_back(
372         GetAddrOfConstantString((*iter)->getSelector().getName()));
373     InstanceMethodTypes.push_back(GetAddrOfConstantString(TypeStr));
374   }
375   // Collect information about class methods:
376   llvm::SmallVector<llvm::Constant*, 16> ClassMethodNames;
377   llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
378   for (ObjCProtocolDecl::classmeth_iterator iter = PD->classmeth_begin(),
379       endIter = PD->classmeth_end() ; iter != endIter ; iter++) {
380     std::string TypeStr;
381     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
382     ClassMethodNames.push_back(
383         GetAddrOfConstantString((*iter)->getSelector().getName()));
384     ClassMethodTypes.push_back(GetAddrOfConstantString(TypeStr));
385   }
386   Runtime->GenerateProtocol(PD->getName(), Protocols, InstanceMethodNames,
387       InstanceMethodTypes, ClassMethodNames, ClassMethodTypes);
388 }
389 
390 void CodeGenModule::EmitObjCCategoryImpl(const ObjCCategoryImplDecl *OCD) {
391 
392   // Collect information about instance methods
393   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodNames;
394   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
395   for (ObjCCategoryDecl::instmeth_iterator iter = OCD->instmeth_begin(),
396       endIter = OCD->instmeth_end() ; iter != endIter ; iter++) {
397     std::string TypeStr;
398     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
399     InstanceMethodNames.push_back(
400         GetAddrOfConstantString((*iter)->getSelector().getName()));
401     InstanceMethodTypes.push_back(GetAddrOfConstantString(TypeStr));
402   }
403 
404   // Collect information about class methods
405   llvm::SmallVector<llvm::Constant*, 16> ClassMethodNames;
406   llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
407   for (ObjCCategoryDecl::classmeth_iterator iter = OCD->classmeth_begin(),
408       endIter = OCD->classmeth_end() ; iter != endIter ; iter++) {
409     std::string TypeStr;
410     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
411     ClassMethodNames.push_back(
412         GetAddrOfConstantString((*iter)->getSelector().getName()));
413     ClassMethodTypes.push_back(GetAddrOfConstantString(TypeStr));
414   }
415 
416   // Collect the names of referenced protocols
417   llvm::SmallVector<std::string, 16> Protocols;
418   ObjCInterfaceDecl * ClassDecl = (ObjCInterfaceDecl*)OCD->getClassInterface();
419   for (unsigned i=0 ; i<ClassDecl->getNumIntfRefProtocols() ; i++)
420     Protocols.push_back(ClassDecl->getReferencedProtocols()[i]->getName());
421 
422   // Generate the category
423   Runtime->GenerateCategory(OCD->getClassInterface()->getName(),
424       OCD->getName(), InstanceMethodNames, InstanceMethodTypes,
425       ClassMethodNames, ClassMethodTypes, Protocols);
426 }
427 
428 void CodeGenModule::EmitObjCClassImplementation(
429     const ObjCImplementationDecl *OID) {
430   // Get the superclass name.
431   const ObjCInterfaceDecl * SCDecl = OID->getClassInterface()->getSuperClass();
432   const char * SCName = NULL;
433   if (SCDecl) {
434     SCName = SCDecl->getName();
435   }
436 
437   // Get the class name
438   ObjCInterfaceDecl * ClassDecl = (ObjCInterfaceDecl*)OID->getClassInterface();
439   const char * ClassName = ClassDecl->getName();
440 
441   // Get the size of instances.  For runtimes that support late-bound instances
442   // this should probably be something different (size just of instance
443   // varaibles in this class, not superclasses?).
444   int instanceSize = 0;
445   const llvm::Type *ObjTy;
446   if (!Runtime->LateBoundIVars()) {
447     ObjTy = getTypes().ConvertType(Context.getObjCInterfaceType(ClassDecl));
448     instanceSize = TheTargetData.getABITypeSize(ObjTy);
449   }
450 
451   // Collect information about instance variables.
452   llvm::SmallVector<llvm::Constant*, 16> IvarNames;
453   llvm::SmallVector<llvm::Constant*, 16> IvarTypes;
454   llvm::SmallVector<llvm::Constant*, 16> IvarOffsets;
455   const llvm::StructLayout *Layout =
456     TheTargetData.getStructLayout(cast<llvm::StructType>(ObjTy));
457   ObjTy = llvm::PointerType::getUnqual(ObjTy);
458   for (ObjCInterfaceDecl::ivar_iterator iter = ClassDecl->ivar_begin(),
459       endIter = ClassDecl->ivar_end() ; iter != endIter ; iter++) {
460       // Store the name
461       IvarNames.push_back(GetAddrOfConstantString((*iter)->getName()));
462       // Get the type encoding for this ivar
463       std::string TypeStr;
464       llvm::SmallVector<const RecordType *, 8> EncodingRecordTypes;
465       Context.getObjCEncodingForType((*iter)->getType(), TypeStr,
466                                      EncodingRecordTypes);
467       IvarTypes.push_back(GetAddrOfConstantString(TypeStr));
468       // Get the offset
469       int offset =
470         (int)Layout->getElementOffset(getTypes().getLLVMFieldNo(*iter));
471       IvarOffsets.push_back(
472           llvm::ConstantInt::get(llvm::Type::Int32Ty, offset));
473   }
474 
475   // Collect information about instance methods
476   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodNames;
477   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
478   for (ObjCImplementationDecl::instmeth_iterator iter = OID->instmeth_begin(),
479       endIter = OID->instmeth_end() ; iter != endIter ; iter++) {
480     std::string TypeStr;
481     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
482     InstanceMethodNames.push_back(
483         GetAddrOfConstantString((*iter)->getSelector().getName()));
484     InstanceMethodTypes.push_back(GetAddrOfConstantString(TypeStr));
485   }
486 
487   // Collect information about class methods
488   llvm::SmallVector<llvm::Constant*, 16> ClassMethodNames;
489   llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
490   for (ObjCImplementationDecl::classmeth_iterator iter = OID->classmeth_begin(),
491       endIter = OID->classmeth_end() ; iter != endIter ; iter++) {
492     std::string TypeStr;
493     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
494     ClassMethodNames.push_back(
495         GetAddrOfConstantString((*iter)->getSelector().getName()));
496     ClassMethodTypes.push_back(GetAddrOfConstantString(TypeStr));
497   }
498   // Collect the names of referenced protocols
499   llvm::SmallVector<std::string, 16> Protocols;
500   for (unsigned i = 0, e = ClassDecl->getNumIntfRefProtocols() ; i < e ; i++)
501     Protocols.push_back(ClassDecl->getReferencedProtocols()[i]->getName());
502 
503   // Generate the category
504   Runtime->GenerateClass(ClassName, SCName, instanceSize, IvarNames, IvarTypes,
505       IvarOffsets, InstanceMethodNames, InstanceMethodTypes, ClassMethodNames,
506       ClassMethodTypes, Protocols);
507 }
508 
509 
510 void CodeGenModule::EmitFunction(const FunctionDecl *FD) {
511   // If this is not a prototype, emit the body.
512   if (!FD->isThisDeclarationADefinition()) {
513     if (FD->getAttr<AliasAttr>())
514       GetAddrOfFunctionDecl(FD, true);
515     return;
516   }
517 
518   // If the function is a static, defer code generation until later so we can
519   // easily omit unused statics.
520   if (FD->getStorageClass() != FunctionDecl::Static) {
521     CodeGenFunction(*this).GenerateCode(FD);
522     return;
523   }
524 
525   StaticDecls.push_back(FD);
526 }
527 
528 void CodeGenModule::EmitStatics() {
529   // Emit code for each used static decl encountered.  Since a previously unused
530   // static decl may become used during the generation of code for a static
531   // function, iterate until no changes are made.
532   bool Changed;
533   do {
534     Changed = false;
535     for (unsigned i = 0, e = StaticDecls.size(); i != e; ++i) {
536       const Decl *D = StaticDecls[i];
537 
538       // Check if we have used a decl with the same name
539       // FIXME: The AST should have some sort of aggregate decls or
540       // global symbol map.
541       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
542         if (!getModule().getFunction(FD->getName()))
543           continue;
544       } else {
545         if (!getModule().getNamedGlobal(cast<VarDecl>(D)->getName()))
546           continue;
547       }
548 
549       // If this is a function decl, generate code for the static function if it
550       // has a body.  Otherwise, we must have a var decl for a static global
551       // variable.
552       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
553         if (FD->getBody())
554           CodeGenFunction(*this).GenerateCode(FD);
555         else if (FD->getAttr<AliasAttr>())
556           GetAddrOfFunctionDecl(FD, true);
557       } else {
558         EmitGlobalVarInit(cast<VarDecl>(D));
559       }
560       // Erase the used decl from the list.
561       StaticDecls[i] = StaticDecls.back();
562       StaticDecls.pop_back();
563       --i;
564       --e;
565 
566       // Remember that we made a change.
567       Changed = true;
568     }
569   } while (Changed);
570 }
571 
572 llvm::Constant *CodeGenModule::EmitGlobalInit(const Expr *Expr) {
573   return EmitConstantExpr(Expr);
574 }
575 
576 /// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the
577 /// annotation information for a given GlobalValue.  The annotation struct is
578 /// {i8 *, i8 *, i8 *, i32}.  The first field is a constant expression, the
579 /// GlobalValue being annotated.  The second filed is thee constant string
580 /// created from the AnnotateAttr's annotation.  The third field is a constant
581 /// string containing the name of the translation unit.  The fourth field is
582 /// the line number in the file of the annotated value declaration.
583 ///
584 /// FIXME: this does not unique the annotation string constants, as llvm-gcc
585 ///        appears to.
586 ///
587 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
588                                                 const AnnotateAttr *AA,
589                                                 unsigned LineNo) {
590   llvm::Module *M = &getModule();
591 
592   // get [N x i8] constants for the annotation string, and the filename string
593   // which are the 2nd and 3rd elements of the global annotation structure.
594   const llvm::Type *SBP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
595   llvm::Constant *anno = llvm::ConstantArray::get(AA->getAnnotation(), true);
596   llvm::Constant *unit = llvm::ConstantArray::get(M->getModuleIdentifier(),
597                                                   true);
598 
599   // Get the two global values corresponding to the ConstantArrays we just
600   // created to hold the bytes of the strings.
601   llvm::GlobalValue *annoGV =
602   new llvm::GlobalVariable(anno->getType(), false,
603                            llvm::GlobalValue::InternalLinkage, anno,
604                            GV->getName() + ".str", M);
605   // translation unit name string, emitted into the llvm.metadata section.
606   llvm::GlobalValue *unitGV =
607   new llvm::GlobalVariable(unit->getType(), false,
608                            llvm::GlobalValue::InternalLinkage, unit, ".str", M);
609 
610   // Create the ConstantStruct that is the global annotion.
611   llvm::Constant *Fields[4] = {
612     llvm::ConstantExpr::getBitCast(GV, SBP),
613     llvm::ConstantExpr::getBitCast(annoGV, SBP),
614     llvm::ConstantExpr::getBitCast(unitGV, SBP),
615     llvm::ConstantInt::get(llvm::Type::Int32Ty, LineNo)
616   };
617   return llvm::ConstantStruct::get(Fields, 4, false);
618 }
619 
620 void CodeGenModule::EmitGlobalVar(const VarDecl *D) {
621   // If the VarDecl is a static, defer code generation until later so we can
622   // easily omit unused statics.
623   if (D->getStorageClass() == VarDecl::Static) {
624     StaticDecls.push_back(D);
625     return;
626   }
627 
628   // If this is just a forward declaration of the variable, don't emit it now,
629   // allow it to be emitted lazily on its first use.
630   if (D->getStorageClass() == VarDecl::Extern && D->getInit() == 0)
631     return;
632 
633   EmitGlobalVarInit(D);
634 }
635 
636 void CodeGenModule::EmitGlobalVarInit(const VarDecl *D) {
637   assert(D->hasGlobalStorage() && "Not a global variable");
638 
639   llvm::Constant *Init = 0;
640   QualType ASTTy = D->getType();
641   const llvm::Type *VarTy = getTypes().ConvertTypeForMem(ASTTy);
642   const llvm::Type *VarPtrTy =
643       llvm::PointerType::get(VarTy, ASTTy.getAddressSpace());
644 
645   if (D->getInit() == 0) {
646     // This is a tentative definition; tentative definitions are
647     // implicitly initialized with { 0 }
648     const llvm::Type* InitTy;
649     if (ASTTy->isIncompleteArrayType()) {
650       // An incomplete array is normally [ TYPE x 0 ], but we need
651       // to fix it to [ TYPE x 1 ].
652       const llvm::ArrayType* ATy = cast<llvm::ArrayType>(VarTy);
653       InitTy = llvm::ArrayType::get(ATy->getElementType(), 1);
654     } else {
655       InitTy = VarTy;
656     }
657     Init = llvm::Constant::getNullValue(InitTy);
658   } else {
659     Init = EmitGlobalInit(D->getInit());
660   }
661   const llvm::Type* InitType = Init->getType();
662 
663   llvm::GlobalVariable *GV = getModule().getGlobalVariable(D->getName(), true);
664 
665   if (!GV) {
666     GV = new llvm::GlobalVariable(InitType, false,
667                                   llvm::GlobalValue::ExternalLinkage,
668                                   0, D->getName(), &getModule(), 0,
669                                   ASTTy.getAddressSpace());
670   } else if (GV->getType()->getElementType() != InitType ||
671              GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) {
672     // We have a definition after a prototype with the wrong type.
673     // We must make a new GlobalVariable* and update everything that used OldGV
674     // (a declaration or tentative definition) with the new GlobalVariable*
675     // (which will be a definition).
676     //
677     // This happens if there is a prototype for a global (e.g. "extern int x[];")
678     // and then a definition of a different type (e.g. "int x[10];"). This also
679     // happens when an initializer has a different type from the type of the
680     // global (this happens with unions).
681     //
682     // FIXME: This also ends up happening if there's a definition followed by
683     // a tentative definition!  (Although Sema rejects that construct
684     // at the moment.)
685 
686     // Save the old global
687     llvm::GlobalVariable *OldGV = GV;
688 
689     // Make a new global with the correct type
690     GV = new llvm::GlobalVariable(InitType, false,
691                                   llvm::GlobalValue::ExternalLinkage,
692                                   0, D->getName(), &getModule(), 0,
693                                   ASTTy.getAddressSpace());
694     // Steal the name of the old global
695     GV->takeName(OldGV);
696 
697     // Replace all uses of the old global with the new global
698     llvm::Constant *NewPtrForOldDecl =
699         llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
700     OldGV->replaceAllUsesWith(NewPtrForOldDecl);
701     // Make sure we don't keep around any stale references to globals
702     // FIXME: This is really slow; we need a better way to walk all
703     // the decls with the same name
704     ReplaceMapValuesWith(OldGV, NewPtrForOldDecl);
705 
706     // Erase the old global, since it is no longer used.
707     OldGV->eraseFromParent();
708   }
709 
710   GlobalDeclMap[D] = llvm::ConstantExpr::getBitCast(GV, VarPtrTy);
711 
712   if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
713     SourceManager &SM = Context.getSourceManager();
714     AddAnnotation(EmitAnnotateAttr(GV, AA,
715                                    SM.getLogicalLineNumber(D->getLocation())));
716   }
717 
718   GV->setInitializer(Init);
719 
720   // FIXME: This is silly; getTypeAlign should just work for incomplete arrays
721   unsigned Align;
722   if (const IncompleteArrayType* IAT = D->getType()->getAsIncompleteArrayType())
723     Align = Context.getTypeAlign(IAT->getElementType());
724   else
725     Align = Context.getTypeAlign(D->getType());
726   if (const AlignedAttr* AA = D->getAttr<AlignedAttr>()) {
727     Align = std::max(Align, AA->getAlignment());
728   }
729   GV->setAlignment(Align / 8);
730 
731   if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>())
732     setVisibility(GV, attr->getVisibility());
733   // FIXME: else handle -fvisibility
734 
735   // Set the llvm linkage type as appropriate.
736   if (D->getStorageClass() == VarDecl::Static)
737     GV->setLinkage(llvm::Function::InternalLinkage);
738   else if (D->getAttr<DLLImportAttr>())
739     GV->setLinkage(llvm::Function::DLLImportLinkage);
740   else if (D->getAttr<DLLExportAttr>())
741     GV->setLinkage(llvm::Function::DLLExportLinkage);
742   else if (D->getAttr<WeakAttr>())
743     GV->setLinkage(llvm::GlobalVariable::WeakLinkage);
744   else {
745     // FIXME: This isn't right.  This should handle common linkage and other
746     // stuff.
747     switch (D->getStorageClass()) {
748     case VarDecl::Static: assert(0 && "This case handled above");
749     case VarDecl::Auto:
750     case VarDecl::Register:
751       assert(0 && "Can't have auto or register globals");
752     case VarDecl::None:
753       if (!D->getInit())
754         GV->setLinkage(llvm::GlobalVariable::CommonLinkage);
755       break;
756     case VarDecl::Extern:
757     case VarDecl::PrivateExtern:
758       // todo: common
759       break;
760     }
761   }
762 
763   // Emit global variable debug information.
764   CGDebugInfo *DI = getDebugInfo();
765   if(DI) {
766     if(D->getLocation().isValid())
767       DI->setLocation(D->getLocation());
768     DI->EmitGlobalVariable(GV, D);
769   }
770 }
771 
772 /// EmitGlobalVarDeclarator - Emit all the global vars attached to the specified
773 /// declarator chain.
774 void CodeGenModule::EmitGlobalVarDeclarator(const VarDecl *D) {
775   for (; D; D = cast_or_null<VarDecl>(D->getNextDeclarator()))
776     if (D->isFileVarDecl())
777       EmitGlobalVar(D);
778 }
779 
780 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
781   // Make sure that this type is translated.
782   Types.UpdateCompletedType(TD);
783 }
784 
785 
786 /// getBuiltinLibFunction
787 llvm::Function *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) {
788   if (BuiltinID > BuiltinFunctions.size())
789     BuiltinFunctions.resize(BuiltinID);
790 
791   // Cache looked up functions.  Since builtin id #0 is invalid we don't reserve
792   // a slot for it.
793   assert(BuiltinID && "Invalid Builtin ID");
794   llvm::Function *&FunctionSlot = BuiltinFunctions[BuiltinID-1];
795   if (FunctionSlot)
796     return FunctionSlot;
797 
798   assert(Context.BuiltinInfo.isLibFunction(BuiltinID) && "isn't a lib fn");
799 
800   // Get the name, skip over the __builtin_ prefix.
801   const char *Name = Context.BuiltinInfo.GetName(BuiltinID)+10;
802 
803   // Get the type for the builtin.
804   QualType Type = Context.BuiltinInfo.GetBuiltinType(BuiltinID, Context);
805   const llvm::FunctionType *Ty =
806     cast<llvm::FunctionType>(getTypes().ConvertType(Type));
807 
808   // FIXME: This has a serious problem with code like this:
809   //  void abs() {}
810   //    ... __builtin_abs(x);
811   // The two versions of abs will collide.  The fix is for the builtin to win,
812   // and for the existing one to be turned into a constantexpr cast of the
813   // builtin.  In the case where the existing one is a static function, it
814   // should just be renamed.
815   if (llvm::Function *Existing = getModule().getFunction(Name)) {
816     if (Existing->getFunctionType() == Ty && Existing->hasExternalLinkage())
817       return FunctionSlot = Existing;
818     assert(Existing == 0 && "FIXME: Name collision");
819   }
820 
821   // FIXME: param attributes for sext/zext etc.
822   return FunctionSlot =
823     llvm::Function::Create(Ty, llvm::Function::ExternalLinkage, Name,
824                            &getModule());
825 }
826 
827 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys,
828                                             unsigned NumTys) {
829   return llvm::Intrinsic::getDeclaration(&getModule(),
830                                          (llvm::Intrinsic::ID)IID, Tys, NumTys);
831 }
832 
833 llvm::Function *CodeGenModule::getMemCpyFn() {
834   if (MemCpyFn) return MemCpyFn;
835   llvm::Intrinsic::ID IID;
836   switch (Context.Target.getPointerWidth(0)) {
837   default: assert(0 && "Unknown ptr width");
838   case 32: IID = llvm::Intrinsic::memcpy_i32; break;
839   case 64: IID = llvm::Intrinsic::memcpy_i64; break;
840   }
841   return MemCpyFn = getIntrinsic(IID);
842 }
843 
844 llvm::Function *CodeGenModule::getMemMoveFn() {
845   if (MemMoveFn) return MemMoveFn;
846   llvm::Intrinsic::ID IID;
847   switch (Context.Target.getPointerWidth(0)) {
848   default: assert(0 && "Unknown ptr width");
849   case 32: IID = llvm::Intrinsic::memmove_i32; break;
850   case 64: IID = llvm::Intrinsic::memmove_i64; break;
851   }
852   return MemMoveFn = getIntrinsic(IID);
853 }
854 
855 llvm::Function *CodeGenModule::getMemSetFn() {
856   if (MemSetFn) return MemSetFn;
857   llvm::Intrinsic::ID IID;
858   switch (Context.Target.getPointerWidth(0)) {
859   default: assert(0 && "Unknown ptr width");
860   case 32: IID = llvm::Intrinsic::memset_i32; break;
861   case 64: IID = llvm::Intrinsic::memset_i64; break;
862   }
863   return MemSetFn = getIntrinsic(IID);
864 }
865 
866 // FIXME: This needs moving into an Apple Objective-C runtime class
867 llvm::Constant *CodeGenModule::
868 GetAddrOfConstantCFString(const std::string &str) {
869   llvm::StringMapEntry<llvm::Constant *> &Entry =
870     CFConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
871 
872   if (Entry.getValue())
873     return Entry.getValue();
874 
875   std::vector<llvm::Constant*> Fields;
876 
877   if (!CFConstantStringClassRef) {
878     const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
879     Ty = llvm::ArrayType::get(Ty, 0);
880 
881     CFConstantStringClassRef =
882       new llvm::GlobalVariable(Ty, false,
883                                llvm::GlobalVariable::ExternalLinkage, 0,
884                                "__CFConstantStringClassReference",
885                                &getModule());
886   }
887 
888   // Class pointer.
889   llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
890   llvm::Constant *Zeros[] = { Zero, Zero };
891   llvm::Constant *C =
892     llvm::ConstantExpr::getGetElementPtr(CFConstantStringClassRef, Zeros, 2);
893   Fields.push_back(C);
894 
895   // Flags.
896   const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
897   Fields.push_back(llvm::ConstantInt::get(Ty, 1992));
898 
899   // String pointer.
900   C = llvm::ConstantArray::get(str);
901   C = new llvm::GlobalVariable(C->getType(), true,
902                                llvm::GlobalValue::InternalLinkage,
903                                C, ".str", &getModule());
904 
905   C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2);
906   Fields.push_back(C);
907 
908   // String length.
909   Ty = getTypes().ConvertType(getContext().LongTy);
910   Fields.push_back(llvm::ConstantInt::get(Ty, str.length()));
911 
912   // The struct.
913   Ty = getTypes().ConvertType(getContext().getCFConstantStringType());
914   C = llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Fields);
915   llvm::GlobalVariable *GV =
916     new llvm::GlobalVariable(C->getType(), true,
917                              llvm::GlobalVariable::InternalLinkage,
918                              C, "", &getModule());
919   GV->setSection("__DATA,__cfstring");
920   Entry.setValue(GV);
921   return GV;
922 }
923 
924 /// GenerateWritableString -- Creates storage for a string literal.
925 static llvm::Constant *GenerateStringLiteral(const std::string &str,
926                                              bool constant,
927                                              CodeGenModule &CGM) {
928   // Create Constant for this string literal
929   llvm::Constant *C=llvm::ConstantArray::get(str);
930 
931   // Create a global variable for this string
932   C = new llvm::GlobalVariable(C->getType(), constant,
933                                llvm::GlobalValue::InternalLinkage,
934                                C, ".str", &CGM.getModule());
935   return C;
936 }
937 
938 /// CodeGenModule::GetAddrOfConstantString -- returns a pointer to the character
939 /// array containing the literal.  The result is pointer to array type.
940 llvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str) {
941   // Don't share any string literals if writable-strings is turned on.
942   if (Features.WritableStrings)
943     return GenerateStringLiteral(str, false, *this);
944 
945   llvm::StringMapEntry<llvm::Constant *> &Entry =
946   ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
947 
948   if (Entry.getValue())
949       return Entry.getValue();
950 
951   // Create a global variable for this.
952   llvm::Constant *C = GenerateStringLiteral(str, true, *this);
953   Entry.setValue(C);
954   return C;
955 }
956