1 //===--- CGDecl.cpp - Emit LLVM Code for declarations ---------------------===//
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 contains code to emit Decl nodes as LLVM code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CGDebugInfo.h"
15 #include "CodeGenFunction.h"
16 #include "CodeGenModule.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/Basic/SourceManager.h"
21 #include "clang/Basic/TargetInfo.h"
22 #include "llvm/GlobalVariable.h"
23 #include "llvm/Intrinsics.h"
24 #include "llvm/Target/TargetData.h"
25 #include "llvm/Type.h"
26 using namespace clang;
27 using namespace CodeGen;
28 
29 
30 void CodeGenFunction::EmitDecl(const Decl &D) {
31   switch (D.getKind()) {
32   default: assert(0 && "Unknown decl kind!");
33   case Decl::ParmVar:
34     assert(0 && "Parmdecls should not be in declstmts!");
35   case Decl::Function:  // void X();
36   case Decl::Record:    // struct/union/class X;
37   case Decl::Enum:      // enum X;
38   case Decl::EnumConstant: // enum ? { X = ? }
39   case Decl::CXXRecord: // struct/union/class X; [C++]
40     // None of these decls require codegen support.
41     return;
42 
43   case Decl::Var: {
44     const VarDecl &VD = cast<VarDecl>(D);
45     assert(VD.isBlockVarDecl() &&
46            "Should not see file-scope variables inside a function!");
47     return EmitBlockVarDecl(VD);
48   }
49 
50   case Decl::Typedef: {   // typedef int X;
51     const TypedefDecl &TD = cast<TypedefDecl>(D);
52     QualType Ty = TD.getUnderlyingType();
53 
54     if (Ty->isVariablyModifiedType())
55       EmitVLASize(Ty);
56   }
57   }
58 }
59 
60 /// EmitBlockVarDecl - This method handles emission of any variable declaration
61 /// inside a function, including static vars etc.
62 void CodeGenFunction::EmitBlockVarDecl(const VarDecl &D) {
63   if (D.hasAttr<AsmLabelAttr>())
64     CGM.ErrorUnsupported(&D, "__asm__");
65 
66   switch (D.getStorageClass()) {
67   case VarDecl::None:
68   case VarDecl::Auto:
69   case VarDecl::Register:
70     return EmitLocalBlockVarDecl(D);
71   case VarDecl::Static:
72     return EmitStaticBlockVarDecl(D);
73   case VarDecl::Extern:
74   case VarDecl::PrivateExtern:
75     // Don't emit it now, allow it to be emitted lazily on its first use.
76     return;
77   }
78 
79   assert(0 && "Unknown storage class");
80 }
81 
82 llvm::GlobalVariable *
83 CodeGenFunction::CreateStaticBlockVarDecl(const VarDecl &D,
84                                           const char *Separator,
85                                           llvm::GlobalValue::LinkageTypes
86                                           Linkage) {
87   QualType Ty = D.getType();
88   assert(Ty->isConstantSizeType() && "VLAs can't be static");
89 
90   std::string Name;
91   if (getContext().getLangOptions().CPlusPlus) {
92     Name = CGM.getMangledName(&D);
93   } else {
94     std::string ContextName;
95     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurFuncDecl))
96       ContextName = CGM.getMangledName(FD);
97     else if (isa<ObjCMethodDecl>(CurFuncDecl))
98       ContextName = std::string(CurFn->getNameStart(),
99                                 CurFn->getNameStart() + CurFn->getNameLen());
100     else
101       assert(0 && "Unknown context for block var decl");
102 
103     Name = ContextName + Separator + D.getNameAsString();
104   }
105 
106   const llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(Ty);
107   return new llvm::GlobalVariable(CGM.getModule(), LTy,
108                                   Ty.isConstant(getContext()), Linkage,
109                                   llvm::Constant::getNullValue(LTy), Name,
110                                   0, D.isThreadSpecified(),
111                                   Ty.getAddressSpace());
112 }
113 
114 void CodeGenFunction::EmitStaticBlockVarDecl(const VarDecl &D) {
115 
116   llvm::Value *&DMEntry = LocalDeclMap[&D];
117   assert(DMEntry == 0 && "Decl already exists in localdeclmap!");
118 
119   llvm::GlobalVariable *GV =
120     CreateStaticBlockVarDecl(D, ".", llvm::GlobalValue::InternalLinkage);
121 
122   // Store into LocalDeclMap before generating initializer to handle
123   // circular references.
124   DMEntry = GV;
125 
126   // Make sure to evaluate VLA bounds now so that we have them for later.
127   if (D.getType()->isVariablyModifiedType())
128     EmitVLASize(D.getType());
129 
130   if (D.getType()->isReferenceType()) {
131     CGM.ErrorUnsupported(&D, "static declaration with reference type");
132     return;
133   }
134 
135   if (D.getInit()) {
136     llvm::Constant *Init = CGM.EmitConstantExpr(D.getInit(), D.getType(), this);
137 
138     // If constant emission failed, then this should be a C++ static
139     // initializer.
140     if (!Init) {
141       if (!getContext().getLangOptions().CPlusPlus)
142         CGM.ErrorUnsupported(D.getInit(), "constant l-value expression");
143       else
144         GenerateStaticCXXBlockVarDeclInit(D, GV);
145     } else {
146       // The initializer may differ in type from the global. Rewrite
147       // the global to match the initializer.  (We have to do this
148       // because some types, like unions, can't be completely represented
149       // in the LLVM type system.)
150       if (GV->getType() != Init->getType()) {
151         llvm::GlobalVariable *OldGV = GV;
152 
153         GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
154                                       OldGV->isConstant(),
155                                       OldGV->getLinkage(), Init, "",
156                                       0, D.isThreadSpecified(),
157                                       D.getType().getAddressSpace());
158 
159         // Steal the name of the old global
160         GV->takeName(OldGV);
161 
162         // Replace all uses of the old global with the new global
163         llvm::Constant *NewPtrForOldDecl =
164           llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
165         OldGV->replaceAllUsesWith(NewPtrForOldDecl);
166 
167         // Erase the old global, since it is no longer used.
168         OldGV->eraseFromParent();
169       }
170 
171       GV->setInitializer(Init);
172     }
173   }
174 
175   // FIXME: Merge attribute handling.
176   if (const AnnotateAttr *AA = D.getAttr<AnnotateAttr>()) {
177     SourceManager &SM = CGM.getContext().getSourceManager();
178     llvm::Constant *Ann =
179       CGM.EmitAnnotateAttr(GV, AA,
180                            SM.getInstantiationLineNumber(D.getLocation()));
181     CGM.AddAnnotation(Ann);
182   }
183 
184   if (const SectionAttr *SA = D.getAttr<SectionAttr>())
185     GV->setSection(SA->getName());
186 
187   if (D.hasAttr<UsedAttr>())
188     CGM.AddUsedGlobal(GV);
189 
190   // We may have to cast the constant because of the initializer
191   // mismatch above.
192   //
193   // FIXME: It is really dangerous to store this in the map; if anyone
194   // RAUW's the GV uses of this constant will be invalid.
195   const llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(D.getType());
196   const llvm::Type *LPtrTy =
197     llvm::PointerType::get(LTy, D.getType().getAddressSpace());
198   DMEntry = llvm::ConstantExpr::getBitCast(GV, LPtrTy);
199 
200   // Emit global variable debug descriptor for static vars.
201   CGDebugInfo *DI = getDebugInfo();
202   if (DI) {
203     DI->setLocation(D.getLocation());
204     DI->EmitGlobalVariable(static_cast<llvm::GlobalVariable *>(GV), &D);
205   }
206 }
207 
208 /// BuildByRefType - This routine changes a __block variable declared as T x
209 ///   into:
210 ///
211 ///      struct {
212 ///        void *__isa;
213 ///        void *__forwarding;
214 ///        int32_t __flags;
215 ///        int32_t __size;
216 ///        void *__copy_helper;
217 ///        void *__destroy_helper;
218 ///        T x;
219 ///      } x
220 ///
221 /// Align is the alignment needed in bytes for x.
222 const llvm::Type *CodeGenFunction::BuildByRefType(QualType Ty,
223                                                   uint64_t Align) {
224   const llvm::Type *LTy = ConvertType(Ty);
225   bool needsCopyDispose = BlockRequiresCopying(Ty);
226   std::vector<const llvm::Type *> Types(needsCopyDispose*2+5);
227   const llvm::PointerType *PtrToInt8Ty
228     = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
229   Types[0] = PtrToInt8Ty;
230   Types[1] = PtrToInt8Ty;
231   Types[2] = llvm::Type::Int32Ty;
232   Types[3] = llvm::Type::Int32Ty;
233   if (needsCopyDispose) {
234     Types[4] = PtrToInt8Ty;
235     Types[5] = PtrToInt8Ty;
236   }
237   // FIXME: Align this on at least an Align boundary, assert if we can't.
238   assert((Align <= unsigned(Target.getPointerAlign(0))/8)
239          && "Can't align more than pointer yet");
240   Types[needsCopyDispose*2 + 4] = LTy;
241   return llvm::StructType::get(Types, false);
242 }
243 
244 /// EmitLocalBlockVarDecl - Emit code and set up an entry in LocalDeclMap for a
245 /// variable declaration with auto, register, or no storage class specifier.
246 /// These turn into simple stack objects, or GlobalValues depending on target.
247 void CodeGenFunction::EmitLocalBlockVarDecl(const VarDecl &D) {
248   QualType Ty = D.getType();
249   bool isByRef = D.hasAttr<BlocksAttr>();
250   bool needsDispose = false;
251   unsigned Align = 0;
252 
253   llvm::Value *DeclPtr;
254   if (Ty->isConstantSizeType()) {
255     if (!Target.useGlobalsForAutomaticVariables()) {
256       // A normal fixed sized variable becomes an alloca in the entry block.
257       const llvm::Type *LTy = ConvertTypeForMem(Ty);
258       Align = getContext().getDeclAlignInBytes(&D);
259       if (isByRef)
260         LTy = BuildByRefType(Ty, Align);
261       llvm::AllocaInst *Alloc = CreateTempAlloca(LTy);
262       Alloc->setName(D.getNameAsString().c_str());
263 
264       if (isByRef)
265         Align = std::max(Align, unsigned(Target.getPointerAlign(0) / 8));
266       Alloc->setAlignment(Align);
267       DeclPtr = Alloc;
268     } else {
269       // Targets that don't support recursion emit locals as globals.
270       const char *Class =
271         D.getStorageClass() == VarDecl::Register ? ".reg." : ".auto.";
272       DeclPtr = CreateStaticBlockVarDecl(D, Class,
273                                          llvm::GlobalValue
274                                          ::InternalLinkage);
275     }
276 
277     if (Ty->isVariablyModifiedType())
278       EmitVLASize(Ty);
279   } else {
280     if (!DidCallStackSave) {
281       // Save the stack.
282       const llvm::Type *LTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
283       llvm::Value *Stack = CreateTempAlloca(LTy, "saved_stack");
284 
285       llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave);
286       llvm::Value *V = Builder.CreateCall(F);
287 
288       Builder.CreateStore(V, Stack);
289 
290       DidCallStackSave = true;
291 
292       {
293         // Push a cleanup block and restore the stack there.
294         CleanupScope scope(*this);
295 
296         V = Builder.CreateLoad(Stack, "tmp");
297         llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
298         Builder.CreateCall(F, V);
299       }
300     }
301 
302     // Get the element type.
303     const llvm::Type *LElemTy = ConvertTypeForMem(Ty);
304     const llvm::Type *LElemPtrTy =
305       llvm::PointerType::get(LElemTy, D.getType().getAddressSpace());
306 
307     llvm::Value *VLASize = EmitVLASize(Ty);
308 
309     // Downcast the VLA size expression
310     VLASize = Builder.CreateIntCast(VLASize, llvm::Type::Int32Ty, false, "tmp");
311 
312     // Allocate memory for the array.
313     llvm::Value *VLA = Builder.CreateAlloca(llvm::Type::Int8Ty, VLASize, "vla");
314     DeclPtr = Builder.CreateBitCast(VLA, LElemPtrTy, "tmp");
315   }
316 
317   llvm::Value *&DMEntry = LocalDeclMap[&D];
318   assert(DMEntry == 0 && "Decl already exists in localdeclmap!");
319   DMEntry = DeclPtr;
320 
321   // Emit debug info for local var declaration.
322   if (CGDebugInfo *DI = getDebugInfo()) {
323     DI->setLocation(D.getLocation());
324     if (Target.useGlobalsForAutomaticVariables()) {
325       DI->EmitGlobalVariable(static_cast<llvm::GlobalVariable *>(DeclPtr), &D);
326     }
327     else if (isByRef) {
328       llvm::Value *Loc;
329       bool needsCopyDispose = BlockRequiresCopying(Ty);
330       Loc = Builder.CreateStructGEP(DeclPtr, 1, "forwarding");
331       Loc = Builder.CreateLoad(Loc, false);
332       Loc = Builder.CreateBitCast(Loc, DeclPtr->getType());
333       Loc = Builder.CreateStructGEP(Loc, needsCopyDispose*2+4, "x");
334       DI->EmitDeclareOfAutoVariable(&D, Loc, Builder);
335     } else
336       DI->EmitDeclareOfAutoVariable(&D, DeclPtr, Builder);
337   }
338 
339   // If this local has an initializer, emit it now.
340   if (const Expr *Init = D.getInit()) {
341     llvm::Value *Loc = DeclPtr;
342     if (isByRef) {
343       bool needsCopyDispose = BlockRequiresCopying(Ty);
344       Loc = Builder.CreateStructGEP(DeclPtr, needsCopyDispose*2+4, "x");
345     }
346     if (Ty->isReferenceType()) {
347       llvm::Value *V = EmitReferenceBindingToExpr(Init, Ty).getScalarVal();
348       EmitStoreOfScalar(V, Loc, false, Ty);
349     } else if (!hasAggregateLLVMType(Init->getType())) {
350       llvm::Value *V = EmitScalarExpr(Init);
351       EmitStoreOfScalar(V, Loc, D.getType().isVolatileQualified(),
352                         D.getType());
353     } else if (Init->getType()->isAnyComplexType()) {
354       EmitComplexExprIntoAddr(Init, Loc, D.getType().isVolatileQualified());
355     } else {
356       EmitAggExpr(Init, Loc, D.getType().isVolatileQualified());
357     }
358   }
359   if (isByRef) {
360     const llvm::PointerType *PtrToInt8Ty
361       = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
362 
363     llvm::Value *isa_field = Builder.CreateStructGEP(DeclPtr, 0);
364     llvm::Value *forwarding_field = Builder.CreateStructGEP(DeclPtr, 1);
365     llvm::Value *flags_field = Builder.CreateStructGEP(DeclPtr, 2);
366     llvm::Value *size_field = Builder.CreateStructGEP(DeclPtr, 3);
367     llvm::Value *V;
368     int flag = 0;
369     int flags = 0;
370 
371     needsDispose = true;
372 
373     if (Ty->isBlockPointerType()) {
374       flag |= BLOCK_FIELD_IS_BLOCK;
375       flags |= BLOCK_HAS_COPY_DISPOSE;
376     } else if (BlockRequiresCopying(Ty)) {
377       flag |= BLOCK_FIELD_IS_OBJECT;
378       flags |= BLOCK_HAS_COPY_DISPOSE;
379     }
380 
381     // FIXME: Someone double check this.
382     if (Ty.isObjCGCWeak())
383       flag |= BLOCK_FIELD_IS_WEAK;
384 
385     int isa = 0;
386     if (flag&BLOCK_FIELD_IS_WEAK)
387       isa = 1;
388     V = llvm::ConstantInt::get(llvm::Type::Int32Ty, isa);
389     V = Builder.CreateIntToPtr(V, PtrToInt8Ty, "isa");
390     Builder.CreateStore(V, isa_field);
391 
392     V = Builder.CreateBitCast(DeclPtr, PtrToInt8Ty, "forwarding");
393     Builder.CreateStore(V, forwarding_field);
394 
395     V = llvm::ConstantInt::get(llvm::Type::Int32Ty, flags);
396     Builder.CreateStore(V, flags_field);
397 
398     const llvm::Type *V1;
399     V1 = cast<llvm::PointerType>(DeclPtr->getType())->getElementType();
400     V = llvm::ConstantInt::get(llvm::Type::Int32Ty,
401                                (CGM.getTargetData().getTypeStoreSizeInBits(V1)
402                                 / 8));
403     Builder.CreateStore(V, size_field);
404 
405     if (flags & BLOCK_HAS_COPY_DISPOSE) {
406       BlockHasCopyDispose = true;
407       llvm::Value *copy_helper = Builder.CreateStructGEP(DeclPtr, 4);
408       Builder.CreateStore(BuildbyrefCopyHelper(DeclPtr->getType(), flag, Align),
409                           copy_helper);
410 
411       llvm::Value *destroy_helper = Builder.CreateStructGEP(DeclPtr, 5);
412       Builder.CreateStore(BuildbyrefDestroyHelper(DeclPtr->getType(), flag,
413                                                   Align),
414                           destroy_helper);
415     }
416   }
417 
418   // Handle the cleanup attribute
419   if (const CleanupAttr *CA = D.getAttr<CleanupAttr>()) {
420     const FunctionDecl *FD = CA->getFunctionDecl();
421 
422     llvm::Constant* F = CGM.GetAddrOfFunction(GlobalDecl(FD));
423     assert(F && "Could not find function!");
424 
425     CleanupScope scope(*this);
426 
427     const CGFunctionInfo &Info = CGM.getTypes().getFunctionInfo(FD);
428 
429     // In some cases, the type of the function argument will be different from
430     // the type of the pointer. An example of this is
431     // void f(void* arg);
432     // __attribute__((cleanup(f))) void *g;
433     //
434     // To fix this we insert a bitcast here.
435     QualType ArgTy = Info.arg_begin()->type;
436     DeclPtr = Builder.CreateBitCast(DeclPtr, ConvertType(ArgTy));
437 
438     CallArgList Args;
439     Args.push_back(std::make_pair(RValue::get(DeclPtr),
440                                   getContext().getPointerType(D.getType())));
441 
442     EmitCall(Info, F, Args);
443   }
444 
445   if (needsDispose && CGM.getLangOptions().getGCMode() != LangOptions::GCOnly) {
446     CleanupScope scope(*this);
447     llvm::Value *V = Builder.CreateStructGEP(DeclPtr, 1, "forwarding");
448     V = Builder.CreateLoad(V, false);
449     BuildBlockRelease(V);
450   }
451 }
452 
453 /// Emit an alloca (or GlobalValue depending on target)
454 /// for the specified parameter and set up LocalDeclMap.
455 void CodeGenFunction::EmitParmDecl(const VarDecl &D, llvm::Value *Arg) {
456   // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl?
457   assert((isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) &&
458          "Invalid argument to EmitParmDecl");
459   QualType Ty = D.getType();
460 
461   llvm::Value *DeclPtr;
462   if (!Ty->isConstantSizeType()) {
463     // Variable sized values always are passed by-reference.
464     DeclPtr = Arg;
465   } else {
466     // A fixed sized single-value variable becomes an alloca in the entry block.
467     const llvm::Type *LTy = ConvertTypeForMem(Ty);
468     if (LTy->isSingleValueType()) {
469       // TODO: Alignment
470       std::string Name = D.getNameAsString();
471       Name += ".addr";
472       DeclPtr = CreateTempAlloca(LTy);
473       DeclPtr->setName(Name.c_str());
474 
475       // Store the initial value into the alloca.
476       EmitStoreOfScalar(Arg, DeclPtr, Ty.isVolatileQualified(), Ty);
477     } else {
478       // Otherwise, if this is an aggregate, just use the input pointer.
479       DeclPtr = Arg;
480     }
481     Arg->setName(D.getNameAsString());
482   }
483 
484   llvm::Value *&DMEntry = LocalDeclMap[&D];
485   assert(DMEntry == 0 && "Decl already exists in localdeclmap!");
486   DMEntry = DeclPtr;
487 
488   // Emit debug info for param declaration.
489   if (CGDebugInfo *DI = getDebugInfo()) {
490     DI->setLocation(D.getLocation());
491     DI->EmitDeclareOfArgVariable(&D, DeclPtr, Builder);
492   }
493 }
494 
495