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