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