CodeGenFunction.cpp revision 3081c6fe13fbefc398e685a34fe7ba644c209ecd 
1//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//
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-function state used while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CGCUDARuntime.h"
16#include "CGCXXABI.h"
17#include "CGDebugInfo.h"
18#include "CodeGenModule.h"
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/Decl.h"
21#include "clang/AST/DeclCXX.h"
22#include "clang/AST/StmtCXX.h"
23#include "clang/Basic/OpenCL.h"
24#include "clang/Basic/TargetInfo.h"
25#include "clang/Frontend/CodeGenOptions.h"
26#include "llvm/IR/DataLayout.h"
27#include "llvm/IR/Intrinsics.h"
28#include "llvm/IR/MDBuilder.h"
29#include "llvm/IR/Operator.h"
30using namespace clang;
31using namespace CodeGen;
32
33CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
34  : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),
35    Builder(cgm.getModule().getContext()),
36    CapturedStmtInfo(0),
37    SanitizePerformTypeCheck(CGM.getSanOpts().Null |
38                             CGM.getSanOpts().Alignment |
39                             CGM.getSanOpts().ObjectSize |
40                             CGM.getSanOpts().Vptr),
41    SanOpts(&CGM.getSanOpts()),
42    AutoreleaseResult(false), BlockInfo(0), BlockPointer(0),
43    LambdaThisCaptureField(0), NormalCleanupDest(0), NextCleanupDestIndex(1),
44    FirstBlockInfo(0), EHResumeBlock(0), ExceptionSlot(0), EHSelectorSlot(0),
45    DebugInfo(0), DisableDebugInfo(false), CalleeWithThisReturn(0),
46    DidCallStackSave(false),
47    IndirectBranch(0), SwitchInsn(0), CaseRangeBlock(0), UnreachableBlock(0),
48    NumReturnExprs(0), NumSimpleReturnExprs(0),
49    CXXABIThisDecl(0), CXXABIThisValue(0), CXXThisValue(0),
50    CXXDefaultInitExprThis(0),
51    CXXStructorImplicitParamDecl(0), CXXStructorImplicitParamValue(0),
52    OutermostConditional(0), CurLexicalScope(0), TerminateLandingPad(0),
53    TerminateHandler(0), TrapBB(0) {
54  if (!suppressNewContext)
55    CGM.getCXXABI().getMangleContext().startNewFunction();
56
57  llvm::FastMathFlags FMF;
58  if (CGM.getLangOpts().FastMath)
59    FMF.setUnsafeAlgebra();
60  if (CGM.getLangOpts().FiniteMathOnly) {
61    FMF.setNoNaNs();
62    FMF.setNoInfs();
63  }
64  Builder.SetFastMathFlags(FMF);
65}
66
67CodeGenFunction::~CodeGenFunction() {
68  // If there are any unclaimed block infos, go ahead and destroy them
69  // now.  This can happen if IR-gen gets clever and skips evaluating
70  // something.
71  if (FirstBlockInfo)
72    destroyBlockInfos(FirstBlockInfo);
73}
74
75
76llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
77  return CGM.getTypes().ConvertTypeForMem(T);
78}
79
80llvm::Type *CodeGenFunction::ConvertType(QualType T) {
81  return CGM.getTypes().ConvertType(T);
82}
83
84TypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) {
85  type = type.getCanonicalType();
86  while (true) {
87    switch (type->getTypeClass()) {
88#define TYPE(name, parent)
89#define ABSTRACT_TYPE(name, parent)
90#define NON_CANONICAL_TYPE(name, parent) case Type::name:
91#define DEPENDENT_TYPE(name, parent) case Type::name:
92#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
93#include "clang/AST/TypeNodes.def"
94      llvm_unreachable("non-canonical or dependent type in IR-generation");
95
96    case Type::Auto:
97      llvm_unreachable("undeduced auto type in IR-generation");
98
99    // Various scalar types.
100    case Type::Builtin:
101    case Type::Pointer:
102    case Type::BlockPointer:
103    case Type::LValueReference:
104    case Type::RValueReference:
105    case Type::MemberPointer:
106    case Type::Vector:
107    case Type::ExtVector:
108    case Type::FunctionProto:
109    case Type::FunctionNoProto:
110    case Type::Enum:
111    case Type::ObjCObjectPointer:
112      return TEK_Scalar;
113
114    // Complexes.
115    case Type::Complex:
116      return TEK_Complex;
117
118    // Arrays, records, and Objective-C objects.
119    case Type::ConstantArray:
120    case Type::IncompleteArray:
121    case Type::VariableArray:
122    case Type::Record:
123    case Type::ObjCObject:
124    case Type::ObjCInterface:
125      return TEK_Aggregate;
126
127    // We operate on atomic values according to their underlying type.
128    case Type::Atomic:
129      type = cast<AtomicType>(type)->getValueType();
130      continue;
131    }
132    llvm_unreachable("unknown type kind!");
133  }
134}
135
136void CodeGenFunction::EmitReturnBlock() {
137  // For cleanliness, we try to avoid emitting the return block for
138  // simple cases.
139  llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
140
141  if (CurBB) {
142    assert(!CurBB->getTerminator() && "Unexpected terminated block.");
143
144    // We have a valid insert point, reuse it if it is empty or there are no
145    // explicit jumps to the return block.
146    if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) {
147      ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);
148      delete ReturnBlock.getBlock();
149    } else
150      EmitBlock(ReturnBlock.getBlock());
151    return;
152  }
153
154  // Otherwise, if the return block is the target of a single direct
155  // branch then we can just put the code in that block instead. This
156  // cleans up functions which started with a unified return block.
157  if (ReturnBlock.getBlock()->hasOneUse()) {
158    llvm::BranchInst *BI =
159      dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin());
160    if (BI && BI->isUnconditional() &&
161        BI->getSuccessor(0) == ReturnBlock.getBlock()) {
162      // Reset insertion point, including debug location, and delete the
163      // branch.  This is really subtle and only works because the next change
164      // in location will hit the caching in CGDebugInfo::EmitLocation and not
165      // override this.
166      Builder.SetCurrentDebugLocation(BI->getDebugLoc());
167      Builder.SetInsertPoint(BI->getParent());
168      BI->eraseFromParent();
169      delete ReturnBlock.getBlock();
170      return;
171    }
172  }
173
174  // FIXME: We are at an unreachable point, there is no reason to emit the block
175  // unless it has uses. However, we still need a place to put the debug
176  // region.end for now.
177
178  EmitBlock(ReturnBlock.getBlock());
179}
180
181static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
182  if (!BB) return;
183  if (!BB->use_empty())
184    return CGF.CurFn->getBasicBlockList().push_back(BB);
185  delete BB;
186}
187
188void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
189  assert(BreakContinueStack.empty() &&
190         "mismatched push/pop in break/continue stack!");
191
192  bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
193    && NumSimpleReturnExprs == NumReturnExprs;
194  // If the function contains only a simple return statement, the
195  // location before the cleanup code becomes the last useful
196  // breakpoint in the function, because the simple return expression
197  // will be evaluated after the cleanup code. To be safe, set the
198  // debug location for cleanup code to the location of the return
199  // statement. Otherwise the cleanup code should be at the end of the
200  // function's lexical scope.
201  if (CGDebugInfo *DI = getDebugInfo()) {
202    if (OnlySimpleReturnStmts)
203       DI->EmitLocation(Builder, LastStopPoint);
204    else
205      DI->EmitLocation(Builder, EndLoc);
206  }
207
208  // Pop any cleanups that might have been associated with the
209  // parameters.  Do this in whatever block we're currently in; it's
210  // important to do this before we enter the return block or return
211  // edges will be *really* confused.
212  bool EmitRetDbgLoc = true;
213  if (EHStack.stable_begin() != PrologueCleanupDepth) {
214    PopCleanupBlocks(PrologueCleanupDepth);
215
216    // Make sure the line table doesn't jump back into the body for
217    // the ret after it's been at EndLoc.
218    EmitRetDbgLoc = false;
219
220    if (CGDebugInfo *DI = getDebugInfo())
221      if (OnlySimpleReturnStmts)
222        DI->EmitLocation(Builder, EndLoc);
223  }
224
225  // Emit function epilog (to return).
226  EmitReturnBlock();
227
228  if (ShouldInstrumentFunction())
229    EmitFunctionInstrumentation("__cyg_profile_func_exit");
230
231  // Emit debug descriptor for function end.
232  if (CGDebugInfo *DI = getDebugInfo()) {
233    DI->EmitFunctionEnd(Builder);
234  }
235
236  EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc);
237  EmitEndEHSpec(CurCodeDecl);
238
239  assert(EHStack.empty() &&
240         "did not remove all scopes from cleanup stack!");
241
242  // If someone did an indirect goto, emit the indirect goto block at the end of
243  // the function.
244  if (IndirectBranch) {
245    EmitBlock(IndirectBranch->getParent());
246    Builder.ClearInsertionPoint();
247  }
248
249  // Remove the AllocaInsertPt instruction, which is just a convenience for us.
250  llvm::Instruction *Ptr = AllocaInsertPt;
251  AllocaInsertPt = 0;
252  Ptr->eraseFromParent();
253
254  // If someone took the address of a label but never did an indirect goto, we
255  // made a zero entry PHI node, which is illegal, zap it now.
256  if (IndirectBranch) {
257    llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
258    if (PN->getNumIncomingValues() == 0) {
259      PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
260      PN->eraseFromParent();
261    }
262  }
263
264  EmitIfUsed(*this, EHResumeBlock);
265  EmitIfUsed(*this, TerminateLandingPad);
266  EmitIfUsed(*this, TerminateHandler);
267  EmitIfUsed(*this, UnreachableBlock);
268
269  if (CGM.getCodeGenOpts().EmitDeclMetadata)
270    EmitDeclMetadata();
271}
272
273/// ShouldInstrumentFunction - Return true if the current function should be
274/// instrumented with __cyg_profile_func_* calls
275bool CodeGenFunction::ShouldInstrumentFunction() {
276  if (!CGM.getCodeGenOpts().InstrumentFunctions)
277    return false;
278  if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
279    return false;
280  return true;
281}
282
283/// EmitFunctionInstrumentation - Emit LLVM code to call the specified
284/// instrumentation function with the current function and the call site, if
285/// function instrumentation is enabled.
286void CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) {
287  // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site);
288  llvm::PointerType *PointerTy = Int8PtrTy;
289  llvm::Type *ProfileFuncArgs[] = { PointerTy, PointerTy };
290  llvm::FunctionType *FunctionTy =
291    llvm::FunctionType::get(VoidTy, ProfileFuncArgs, false);
292
293  llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn);
294  llvm::CallInst *CallSite = Builder.CreateCall(
295    CGM.getIntrinsic(llvm::Intrinsic::returnaddress),
296    llvm::ConstantInt::get(Int32Ty, 0),
297    "callsite");
298
299  llvm::Value *args[] = {
300    llvm::ConstantExpr::getBitCast(CurFn, PointerTy),
301    CallSite
302  };
303
304  EmitNounwindRuntimeCall(F, args);
305}
306
307void CodeGenFunction::EmitMCountInstrumentation() {
308  llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
309
310  llvm::Constant *MCountFn =
311    CGM.CreateRuntimeFunction(FTy, getTarget().getMCountName());
312  EmitNounwindRuntimeCall(MCountFn);
313}
314
315// OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument
316// information in the program executable. The argument information stored
317// includes the argument name, its type, the address and access qualifiers used.
318static void GenOpenCLArgMetadata(const FunctionDecl *FD, llvm::Function *Fn,
319                                 CodeGenModule &CGM,llvm::LLVMContext &Context,
320                                 SmallVector <llvm::Value*, 5> &kernelMDArgs,
321                                 CGBuilderTy& Builder, ASTContext &ASTCtx) {
322  // Create MDNodes that represent the kernel arg metadata.
323  // Each MDNode is a list in the form of "key", N number of values which is
324  // the same number of values as their are kernel arguments.
325
326  // MDNode for the kernel argument address space qualifiers.
327  SmallVector<llvm::Value*, 8> addressQuals;
328  addressQuals.push_back(llvm::MDString::get(Context, "kernel_arg_addr_space"));
329
330  // MDNode for the kernel argument access qualifiers (images only).
331  SmallVector<llvm::Value*, 8> accessQuals;
332  accessQuals.push_back(llvm::MDString::get(Context, "kernel_arg_access_qual"));
333
334  // MDNode for the kernel argument type names.
335  SmallVector<llvm::Value*, 8> argTypeNames;
336  argTypeNames.push_back(llvm::MDString::get(Context, "kernel_arg_type"));
337
338  // MDNode for the kernel argument type qualifiers.
339  SmallVector<llvm::Value*, 8> argTypeQuals;
340  argTypeQuals.push_back(llvm::MDString::get(Context, "kernel_arg_type_qual"));
341
342  // MDNode for the kernel argument names.
343  SmallVector<llvm::Value*, 8> argNames;
344  argNames.push_back(llvm::MDString::get(Context, "kernel_arg_name"));
345
346  for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
347    const ParmVarDecl *parm = FD->getParamDecl(i);
348    QualType ty = parm->getType();
349    std::string typeQuals;
350
351    if (ty->isPointerType()) {
352      QualType pointeeTy = ty->getPointeeType();
353
354      // Get address qualifier.
355      addressQuals.push_back(Builder.getInt32(ASTCtx.getTargetAddressSpace(
356        pointeeTy.getAddressSpace())));
357
358      // Get argument type name.
359      std::string typeName = pointeeTy.getUnqualifiedType().getAsString() + "*";
360
361      // Turn "unsigned type" to "utype"
362      std::string::size_type pos = typeName.find("unsigned");
363      if (pos != std::string::npos)
364        typeName.erase(pos+1, 8);
365
366      argTypeNames.push_back(llvm::MDString::get(Context, typeName));
367
368      // Get argument type qualifiers:
369      if (ty.isRestrictQualified())
370        typeQuals = "restrict";
371      if (pointeeTy.isConstQualified() ||
372          (pointeeTy.getAddressSpace() == LangAS::opencl_constant))
373        typeQuals += typeQuals.empty() ? "const" : " const";
374      if (pointeeTy.isVolatileQualified())
375        typeQuals += typeQuals.empty() ? "volatile" : " volatile";
376    } else {
377      addressQuals.push_back(Builder.getInt32(0));
378
379      // Get argument type name.
380      std::string typeName = ty.getUnqualifiedType().getAsString();
381
382      // Turn "unsigned type" to "utype"
383      std::string::size_type pos = typeName.find("unsigned");
384      if (pos != std::string::npos)
385        typeName.erase(pos+1, 8);
386
387      argTypeNames.push_back(llvm::MDString::get(Context, typeName));
388
389      // Get argument type qualifiers:
390      if (ty.isConstQualified())
391        typeQuals = "const";
392      if (ty.isVolatileQualified())
393        typeQuals += typeQuals.empty() ? "volatile" : " volatile";
394    }
395
396    argTypeQuals.push_back(llvm::MDString::get(Context, typeQuals));
397
398    // Get image access qualifier:
399    if (ty->isImageType()) {
400      if (parm->hasAttr<OpenCLImageAccessAttr>() &&
401          parm->getAttr<OpenCLImageAccessAttr>()->getAccess() == CLIA_write_only)
402        accessQuals.push_back(llvm::MDString::get(Context, "write_only"));
403      else
404        accessQuals.push_back(llvm::MDString::get(Context, "read_only"));
405    } else
406      accessQuals.push_back(llvm::MDString::get(Context, "none"));
407
408    // Get argument name.
409    argNames.push_back(llvm::MDString::get(Context, parm->getName()));
410  }
411
412  kernelMDArgs.push_back(llvm::MDNode::get(Context, addressQuals));
413  kernelMDArgs.push_back(llvm::MDNode::get(Context, accessQuals));
414  kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeNames));
415  kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeQuals));
416  kernelMDArgs.push_back(llvm::MDNode::get(Context, argNames));
417}
418
419void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
420                                               llvm::Function *Fn)
421{
422  if (!FD->hasAttr<OpenCLKernelAttr>())
423    return;
424
425  llvm::LLVMContext &Context = getLLVMContext();
426
427  SmallVector <llvm::Value*, 5> kernelMDArgs;
428  kernelMDArgs.push_back(Fn);
429
430  if (CGM.getCodeGenOpts().EmitOpenCLArgMetadata)
431    GenOpenCLArgMetadata(FD, Fn, CGM, Context, kernelMDArgs,
432                         Builder, getContext());
433
434  if (FD->hasAttr<VecTypeHintAttr>()) {
435    VecTypeHintAttr *attr = FD->getAttr<VecTypeHintAttr>();
436    QualType hintQTy = attr->getTypeHint();
437    const ExtVectorType *hintEltQTy = hintQTy->getAs<ExtVectorType>();
438    bool isSignedInteger =
439        hintQTy->isSignedIntegerType() ||
440        (hintEltQTy && hintEltQTy->getElementType()->isSignedIntegerType());
441    llvm::Value *attrMDArgs[] = {
442      llvm::MDString::get(Context, "vec_type_hint"),
443      llvm::UndefValue::get(CGM.getTypes().ConvertType(attr->getTypeHint())),
444      llvm::ConstantInt::get(
445          llvm::IntegerType::get(Context, 32),
446          llvm::APInt(32, (uint64_t)(isSignedInteger ? 1 : 0)))
447    };
448    kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
449  }
450
451  if (FD->hasAttr<WorkGroupSizeHintAttr>()) {
452    WorkGroupSizeHintAttr *attr = FD->getAttr<WorkGroupSizeHintAttr>();
453    llvm::Value *attrMDArgs[] = {
454      llvm::MDString::get(Context, "work_group_size_hint"),
455      Builder.getInt32(attr->getXDim()),
456      Builder.getInt32(attr->getYDim()),
457      Builder.getInt32(attr->getZDim())
458    };
459    kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
460  }
461
462  if (FD->hasAttr<ReqdWorkGroupSizeAttr>()) {
463    ReqdWorkGroupSizeAttr *attr = FD->getAttr<ReqdWorkGroupSizeAttr>();
464    llvm::Value *attrMDArgs[] = {
465      llvm::MDString::get(Context, "reqd_work_group_size"),
466      Builder.getInt32(attr->getXDim()),
467      Builder.getInt32(attr->getYDim()),
468      Builder.getInt32(attr->getZDim())
469    };
470    kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
471  }
472
473  llvm::MDNode *kernelMDNode = llvm::MDNode::get(Context, kernelMDArgs);
474  llvm::NamedMDNode *OpenCLKernelMetadata =
475    CGM.getModule().getOrInsertNamedMetadata("opencl.kernels");
476  OpenCLKernelMetadata->addOperand(kernelMDNode);
477}
478
479void CodeGenFunction::StartFunction(GlobalDecl GD,
480                                    QualType RetTy,
481                                    llvm::Function *Fn,
482                                    const CGFunctionInfo &FnInfo,
483                                    const FunctionArgList &Args,
484                                    SourceLocation StartLoc) {
485  const Decl *D = GD.getDecl();
486
487  DidCallStackSave = false;
488  CurCodeDecl = D;
489  CurFuncDecl = (D ? D->getNonClosureContext() : 0);
490  FnRetTy = RetTy;
491  CurFn = Fn;
492  CurFnInfo = &FnInfo;
493  assert(CurFn->isDeclaration() && "Function already has body?");
494
495  if (CGM.getSanitizerBlacklist().isIn(*Fn)) {
496    SanOpts = &SanitizerOptions::Disabled;
497    SanitizePerformTypeCheck = false;
498  }
499
500  // Pass inline keyword to optimizer if it appears explicitly on any
501  // declaration.
502  if (!CGM.getCodeGenOpts().NoInline)
503    if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
504      for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(),
505             RE = FD->redecls_end(); RI != RE; ++RI)
506        if (RI->isInlineSpecified()) {
507          Fn->addFnAttr(llvm::Attribute::InlineHint);
508          break;
509        }
510
511  if (getLangOpts().OpenCL) {
512    // Add metadata for a kernel function.
513    if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
514      EmitOpenCLKernelMetadata(FD, Fn);
515  }
516
517  llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
518
519  // Create a marker to make it easy to insert allocas into the entryblock
520  // later.  Don't create this with the builder, because we don't want it
521  // folded.
522  llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);
523  AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB);
524  if (Builder.isNamePreserving())
525    AllocaInsertPt->setName("allocapt");
526
527  ReturnBlock = getJumpDestInCurrentScope("return");
528
529  Builder.SetInsertPoint(EntryBB);
530
531  // Emit subprogram debug descriptor.
532  if (CGDebugInfo *DI = getDebugInfo()) {
533    SmallVector<QualType, 16> ArgTypes;
534    for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
535	 i != e; ++i) {
536      ArgTypes.push_back((*i)->getType());
537    }
538
539    QualType FnType =
540      getContext().getFunctionType(RetTy, ArgTypes,
541                                   FunctionProtoType::ExtProtoInfo());
542
543    DI->setLocation(StartLoc);
544    DI->EmitFunctionStart(GD, FnType, CurFn, Builder);
545  }
546
547  if (ShouldInstrumentFunction())
548    EmitFunctionInstrumentation("__cyg_profile_func_enter");
549
550  if (CGM.getCodeGenOpts().InstrumentForProfiling)
551    EmitMCountInstrumentation();
552
553  if (RetTy->isVoidType()) {
554    // Void type; nothing to return.
555    ReturnValue = 0;
556  } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect &&
557             !hasScalarEvaluationKind(CurFnInfo->getReturnType())) {
558    // Indirect aggregate return; emit returned value directly into sret slot.
559    // This reduces code size, and affects correctness in C++.
560    ReturnValue = CurFn->arg_begin();
561  } else {
562    ReturnValue = CreateIRTemp(RetTy, "retval");
563
564    // Tell the epilog emitter to autorelease the result.  We do this
565    // now so that various specialized functions can suppress it
566    // during their IR-generation.
567    if (getLangOpts().ObjCAutoRefCount &&
568        !CurFnInfo->isReturnsRetained() &&
569        RetTy->isObjCRetainableType())
570      AutoreleaseResult = true;
571  }
572
573  EmitStartEHSpec(CurCodeDecl);
574
575  PrologueCleanupDepth = EHStack.stable_begin();
576  EmitFunctionProlog(*CurFnInfo, CurFn, Args);
577
578  if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) {
579    CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
580    const CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
581    if (MD->getParent()->isLambda() &&
582        MD->getOverloadedOperator() == OO_Call) {
583      // We're in a lambda; figure out the captures.
584      MD->getParent()->getCaptureFields(LambdaCaptureFields,
585                                        LambdaThisCaptureField);
586      if (LambdaThisCaptureField) {
587        // If this lambda captures this, load it.
588        LValue ThisLValue = EmitLValueForLambdaField(LambdaThisCaptureField);
589        CXXThisValue = EmitLoadOfLValue(ThisLValue).getScalarVal();
590      }
591    } else {
592      // Not in a lambda; just use 'this' from the method.
593      // FIXME: Should we generate a new load for each use of 'this'?  The
594      // fast register allocator would be happier...
595      CXXThisValue = CXXABIThisValue;
596    }
597  }
598
599  // If any of the arguments have a variably modified type, make sure to
600  // emit the type size.
601  for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
602       i != e; ++i) {
603    const VarDecl *VD = *i;
604
605    // Dig out the type as written from ParmVarDecls; it's unclear whether
606    // the standard (C99 6.9.1p10) requires this, but we're following the
607    // precedent set by gcc.
608    QualType Ty;
609    if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
610      Ty = PVD->getOriginalType();
611    else
612      Ty = VD->getType();
613
614    if (Ty->isVariablyModifiedType())
615      EmitVariablyModifiedType(Ty);
616  }
617  // Emit a location at the end of the prologue.
618  if (CGDebugInfo *DI = getDebugInfo())
619    DI->EmitLocation(Builder, StartLoc);
620}
621
622void CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) {
623  const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl());
624  assert(FD->getBody());
625  if (const CompoundStmt *S = dyn_cast<CompoundStmt>(FD->getBody()))
626    EmitCompoundStmtWithoutScope(*S);
627  else
628    EmitStmt(FD->getBody());
629}
630
631/// Tries to mark the given function nounwind based on the
632/// non-existence of any throwing calls within it.  We believe this is
633/// lightweight enough to do at -O0.
634static void TryMarkNoThrow(llvm::Function *F) {
635  // LLVM treats 'nounwind' on a function as part of the type, so we
636  // can't do this on functions that can be overwritten.
637  if (F->mayBeOverridden()) return;
638
639  for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI)
640    for (llvm::BasicBlock::iterator
641           BI = FI->begin(), BE = FI->end(); BI != BE; ++BI)
642      if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) {
643        if (!Call->doesNotThrow())
644          return;
645      } else if (isa<llvm::ResumeInst>(&*BI)) {
646        return;
647      }
648  F->setDoesNotThrow();
649}
650
651void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
652                                   const CGFunctionInfo &FnInfo) {
653  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
654
655  // Check if we should generate debug info for this function.
656  if (!FD->hasAttr<NoDebugAttr>())
657    maybeInitializeDebugInfo();
658
659  FunctionArgList Args;
660  QualType ResTy = FD->getResultType();
661
662  CurGD = GD;
663  if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance())
664    CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args);
665
666  for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i)
667    Args.push_back(FD->getParamDecl(i));
668
669  SourceRange BodyRange;
670  if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange();
671  CurEHLocation = BodyRange.getEnd();
672
673  // CalleeWithThisReturn keeps track of the last callee inside this function
674  // that returns 'this'. Before starting the function, we set it to null.
675  CalleeWithThisReturn = 0;
676
677  // Emit the standard function prologue.
678  StartFunction(GD, ResTy, Fn, FnInfo, Args, BodyRange.getBegin());
679
680  // Generate the body of the function.
681  if (isa<CXXDestructorDecl>(FD))
682    EmitDestructorBody(Args);
683  else if (isa<CXXConstructorDecl>(FD))
684    EmitConstructorBody(Args);
685  else if (getLangOpts().CUDA &&
686           !CGM.getCodeGenOpts().CUDAIsDevice &&
687           FD->hasAttr<CUDAGlobalAttr>())
688    CGM.getCUDARuntime().EmitDeviceStubBody(*this, Args);
689  else if (isa<CXXConversionDecl>(FD) &&
690           cast<CXXConversionDecl>(FD)->isLambdaToBlockPointerConversion()) {
691    // The lambda conversion to block pointer is special; the semantics can't be
692    // expressed in the AST, so IRGen needs to special-case it.
693    EmitLambdaToBlockPointerBody(Args);
694  } else if (isa<CXXMethodDecl>(FD) &&
695             cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) {
696    // The lambda "__invoke" function is special, because it forwards or
697    // clones the body of the function call operator (but is actually static).
698    EmitLambdaStaticInvokeFunction(cast<CXXMethodDecl>(FD));
699  } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&
700             cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator()) {
701    // Implicit copy-assignment gets the same special treatment as implicit
702    // copy-constructors.
703    emitImplicitAssignmentOperatorBody(Args);
704  }
705  else
706    EmitFunctionBody(Args);
707
708  // C++11 [stmt.return]p2:
709  //   Flowing off the end of a function [...] results in undefined behavior in
710  //   a value-returning function.
711  // C11 6.9.1p12:
712  //   If the '}' that terminates a function is reached, and the value of the
713  //   function call is used by the caller, the behavior is undefined.
714  if (getLangOpts().CPlusPlus && !FD->hasImplicitReturnZero() &&
715      !FD->getResultType()->isVoidType() && Builder.GetInsertBlock()) {
716    if (SanOpts->Return)
717      EmitCheck(Builder.getFalse(), "missing_return",
718                EmitCheckSourceLocation(FD->getLocation()),
719                ArrayRef<llvm::Value *>(), CRK_Unrecoverable);
720    else if (CGM.getCodeGenOpts().OptimizationLevel == 0)
721      Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::trap));
722    Builder.CreateUnreachable();
723    Builder.ClearInsertionPoint();
724  }
725
726  // Emit the standard function epilogue.
727  FinishFunction(BodyRange.getEnd());
728  // CalleeWithThisReturn keeps track of the last callee inside this function
729  // that returns 'this'. After finishing the function, we set it to null.
730  CalleeWithThisReturn = 0;
731
732  // If we haven't marked the function nothrow through other means, do
733  // a quick pass now to see if we can.
734  if (!CurFn->doesNotThrow())
735    TryMarkNoThrow(CurFn);
736}
737
738/// ContainsLabel - Return true if the statement contains a label in it.  If
739/// this statement is not executed normally, it not containing a label means
740/// that we can just remove the code.
741bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
742  // Null statement, not a label!
743  if (S == 0) return false;
744
745  // If this is a label, we have to emit the code, consider something like:
746  // if (0) {  ...  foo:  bar(); }  goto foo;
747  //
748  // TODO: If anyone cared, we could track __label__'s, since we know that you
749  // can't jump to one from outside their declared region.
750  if (isa<LabelStmt>(S))
751    return true;
752
753  // If this is a case/default statement, and we haven't seen a switch, we have
754  // to emit the code.
755  if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
756    return true;
757
758  // If this is a switch statement, we want to ignore cases below it.
759  if (isa<SwitchStmt>(S))
760    IgnoreCaseStmts = true;
761
762  // Scan subexpressions for verboten labels.
763  for (Stmt::const_child_range I = S->children(); I; ++I)
764    if (ContainsLabel(*I, IgnoreCaseStmts))
765      return true;
766
767  return false;
768}
769
770/// containsBreak - Return true if the statement contains a break out of it.
771/// If the statement (recursively) contains a switch or loop with a break
772/// inside of it, this is fine.
773bool CodeGenFunction::containsBreak(const Stmt *S) {
774  // Null statement, not a label!
775  if (S == 0) return false;
776
777  // If this is a switch or loop that defines its own break scope, then we can
778  // include it and anything inside of it.
779  if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) ||
780      isa<ForStmt>(S))
781    return false;
782
783  if (isa<BreakStmt>(S))
784    return true;
785
786  // Scan subexpressions for verboten breaks.
787  for (Stmt::const_child_range I = S->children(); I; ++I)
788    if (containsBreak(*I))
789      return true;
790
791  return false;
792}
793
794
795/// ConstantFoldsToSimpleInteger - If the specified expression does not fold
796/// to a constant, or if it does but contains a label, return false.  If it
797/// constant folds return true and set the boolean result in Result.
798bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
799                                                   bool &ResultBool) {
800  llvm::APSInt ResultInt;
801  if (!ConstantFoldsToSimpleInteger(Cond, ResultInt))
802    return false;
803
804  ResultBool = ResultInt.getBoolValue();
805  return true;
806}
807
808/// ConstantFoldsToSimpleInteger - If the specified expression does not fold
809/// to a constant, or if it does but contains a label, return false.  If it
810/// constant folds return true and set the folded value.
811bool CodeGenFunction::
812ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &ResultInt) {
813  // FIXME: Rename and handle conversion of other evaluatable things
814  // to bool.
815  llvm::APSInt Int;
816  if (!Cond->EvaluateAsInt(Int, getContext()))
817    return false;  // Not foldable, not integer or not fully evaluatable.
818
819  if (CodeGenFunction::ContainsLabel(Cond))
820    return false;  // Contains a label.
821
822  ResultInt = Int;
823  return true;
824}
825
826
827
828/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
829/// statement) to the specified blocks.  Based on the condition, this might try
830/// to simplify the codegen of the conditional based on the branch.
831///
832void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
833                                           llvm::BasicBlock *TrueBlock,
834                                           llvm::BasicBlock *FalseBlock) {
835  Cond = Cond->IgnoreParens();
836
837  if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
838    // Handle X && Y in a condition.
839    if (CondBOp->getOpcode() == BO_LAnd) {
840      // If we have "1 && X", simplify the code.  "0 && X" would have constant
841      // folded if the case was simple enough.
842      bool ConstantBool = false;
843      if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
844          ConstantBool) {
845        // br(1 && X) -> br(X).
846        return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
847      }
848
849      // If we have "X && 1", simplify the code to use an uncond branch.
850      // "X && 0" would have been constant folded to 0.
851      if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
852          ConstantBool) {
853        // br(X && 1) -> br(X).
854        return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
855      }
856
857      // Emit the LHS as a conditional.  If the LHS conditional is false, we
858      // want to jump to the FalseBlock.
859      llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
860
861      ConditionalEvaluation eval(*this);
862      EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock);
863      EmitBlock(LHSTrue);
864
865      // Any temporaries created here are conditional.
866      eval.begin(*this);
867      EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
868      eval.end(*this);
869
870      return;
871    }
872
873    if (CondBOp->getOpcode() == BO_LOr) {
874      // If we have "0 || X", simplify the code.  "1 || X" would have constant
875      // folded if the case was simple enough.
876      bool ConstantBool = false;
877      if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
878          !ConstantBool) {
879        // br(0 || X) -> br(X).
880        return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
881      }
882
883      // If we have "X || 0", simplify the code to use an uncond branch.
884      // "X || 1" would have been constant folded to 1.
885      if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
886          !ConstantBool) {
887        // br(X || 0) -> br(X).
888        return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock);
889      }
890
891      // Emit the LHS as a conditional.  If the LHS conditional is true, we
892      // want to jump to the TrueBlock.
893      llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
894
895      ConditionalEvaluation eval(*this);
896      EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse);
897      EmitBlock(LHSFalse);
898
899      // Any temporaries created here are conditional.
900      eval.begin(*this);
901      EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock);
902      eval.end(*this);
903
904      return;
905    }
906  }
907
908  if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
909    // br(!x, t, f) -> br(x, f, t)
910    if (CondUOp->getOpcode() == UO_LNot)
911      return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock);
912  }
913
914  if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
915    // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
916    llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
917    llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
918
919    ConditionalEvaluation cond(*this);
920    EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock);
921
922    cond.begin(*this);
923    EmitBlock(LHSBlock);
924    EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock);
925    cond.end(*this);
926
927    cond.begin(*this);
928    EmitBlock(RHSBlock);
929    EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock);
930    cond.end(*this);
931
932    return;
933  }
934
935  if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
936    // Conditional operator handling can give us a throw expression as a
937    // condition for a case like:
938    //   br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f)
939    // Fold this to:
940    //   br(c, throw x, br(y, t, f))
941    EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false);
942    return;
943  }
944
945  // Emit the code with the fully general case.
946  llvm::Value *CondV = EvaluateExprAsBool(Cond);
947  Builder.CreateCondBr(CondV, TrueBlock, FalseBlock);
948}
949
950/// ErrorUnsupported - Print out an error that codegen doesn't support the
951/// specified stmt yet.
952void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type,
953                                       bool OmitOnError) {
954  CGM.ErrorUnsupported(S, Type, OmitOnError);
955}
956
957/// emitNonZeroVLAInit - Emit the "zero" initialization of a
958/// variable-length array whose elements have a non-zero bit-pattern.
959///
960/// \param baseType the inner-most element type of the array
961/// \param src - a char* pointing to the bit-pattern for a single
962/// base element of the array
963/// \param sizeInChars - the total size of the VLA, in chars
964static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType,
965                               llvm::Value *dest, llvm::Value *src,
966                               llvm::Value *sizeInChars) {
967  std::pair<CharUnits,CharUnits> baseSizeAndAlign
968    = CGF.getContext().getTypeInfoInChars(baseType);
969
970  CGBuilderTy &Builder = CGF.Builder;
971
972  llvm::Value *baseSizeInChars
973    = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity());
974
975  llvm::Type *i8p = Builder.getInt8PtrTy();
976
977  llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin");
978  llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end");
979
980  llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock();
981  llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop");
982  llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont");
983
984  // Make a loop over the VLA.  C99 guarantees that the VLA element
985  // count must be nonzero.
986  CGF.EmitBlock(loopBB);
987
988  llvm::PHINode *cur = Builder.CreatePHI(i8p, 2, "vla.cur");
989  cur->addIncoming(begin, originBB);
990
991  // memcpy the individual element bit-pattern.
992  Builder.CreateMemCpy(cur, src, baseSizeInChars,
993                       baseSizeAndAlign.second.getQuantity(),
994                       /*volatile*/ false);
995
996  // Go to the next element.
997  llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next");
998
999  // Leave if that's the end of the VLA.
1000  llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone");
1001  Builder.CreateCondBr(done, contBB, loopBB);
1002  cur->addIncoming(next, loopBB);
1003
1004  CGF.EmitBlock(contBB);
1005}
1006
1007void
1008CodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) {
1009  // Ignore empty classes in C++.
1010  if (getLangOpts().CPlusPlus) {
1011    if (const RecordType *RT = Ty->getAs<RecordType>()) {
1012      if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
1013        return;
1014    }
1015  }
1016
1017  // Cast the dest ptr to the appropriate i8 pointer type.
1018  unsigned DestAS =
1019    cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace();
1020  llvm::Type *BP = Builder.getInt8PtrTy(DestAS);
1021  if (DestPtr->getType() != BP)
1022    DestPtr = Builder.CreateBitCast(DestPtr, BP);
1023
1024  // Get size and alignment info for this aggregate.
1025  std::pair<CharUnits, CharUnits> TypeInfo =
1026    getContext().getTypeInfoInChars(Ty);
1027  CharUnits Size = TypeInfo.first;
1028  CharUnits Align = TypeInfo.second;
1029
1030  llvm::Value *SizeVal;
1031  const VariableArrayType *vla;
1032
1033  // Don't bother emitting a zero-byte memset.
1034  if (Size.isZero()) {
1035    // But note that getTypeInfo returns 0 for a VLA.
1036    if (const VariableArrayType *vlaType =
1037          dyn_cast_or_null<VariableArrayType>(
1038                                          getContext().getAsArrayType(Ty))) {
1039      QualType eltType;
1040      llvm::Value *numElts;
1041      llvm::tie(numElts, eltType) = getVLASize(vlaType);
1042
1043      SizeVal = numElts;
1044      CharUnits eltSize = getContext().getTypeSizeInChars(eltType);
1045      if (!eltSize.isOne())
1046        SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize));
1047      vla = vlaType;
1048    } else {
1049      return;
1050    }
1051  } else {
1052    SizeVal = CGM.getSize(Size);
1053    vla = 0;
1054  }
1055
1056  // If the type contains a pointer to data member we can't memset it to zero.
1057  // Instead, create a null constant and copy it to the destination.
1058  // TODO: there are other patterns besides zero that we can usefully memset,
1059  // like -1, which happens to be the pattern used by member-pointers.
1060  if (!CGM.getTypes().isZeroInitializable(Ty)) {
1061    // For a VLA, emit a single element, then splat that over the VLA.
1062    if (vla) Ty = getContext().getBaseElementType(vla);
1063
1064    llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
1065
1066    llvm::GlobalVariable *NullVariable =
1067      new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
1068                               /*isConstant=*/true,
1069                               llvm::GlobalVariable::PrivateLinkage,
1070                               NullConstant, Twine());
1071    llvm::Value *SrcPtr =
1072      Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy());
1073
1074    if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal);
1075
1076    // Get and call the appropriate llvm.memcpy overload.
1077    Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity(), false);
1078    return;
1079  }
1080
1081  // Otherwise, just memset the whole thing to zero.  This is legal
1082  // because in LLVM, all default initializers (other than the ones we just
1083  // handled above) are guaranteed to have a bit pattern of all zeros.
1084  Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal,
1085                       Align.getQuantity(), false);
1086}
1087
1088llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) {
1089  // Make sure that there is a block for the indirect goto.
1090  if (IndirectBranch == 0)
1091    GetIndirectGotoBlock();
1092
1093  llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
1094
1095  // Make sure the indirect branch includes all of the address-taken blocks.
1096  IndirectBranch->addDestination(BB);
1097  return llvm::BlockAddress::get(CurFn, BB);
1098}
1099
1100llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() {
1101  // If we already made the indirect branch for indirect goto, return its block.
1102  if (IndirectBranch) return IndirectBranch->getParent();
1103
1104  CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto"));
1105
1106  // Create the PHI node that indirect gotos will add entries to.
1107  llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0,
1108                                              "indirect.goto.dest");
1109
1110  // Create the indirect branch instruction.
1111  IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
1112  return IndirectBranch->getParent();
1113}
1114
1115/// Computes the length of an array in elements, as well as the base
1116/// element type and a properly-typed first element pointer.
1117llvm::Value *CodeGenFunction::emitArrayLength(const ArrayType *origArrayType,
1118                                              QualType &baseType,
1119                                              llvm::Value *&addr) {
1120  const ArrayType *arrayType = origArrayType;
1121
1122  // If it's a VLA, we have to load the stored size.  Note that
1123  // this is the size of the VLA in bytes, not its size in elements.
1124  llvm::Value *numVLAElements = 0;
1125  if (isa<VariableArrayType>(arrayType)) {
1126    numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).first;
1127
1128    // Walk into all VLAs.  This doesn't require changes to addr,
1129    // which has type T* where T is the first non-VLA element type.
1130    do {
1131      QualType elementType = arrayType->getElementType();
1132      arrayType = getContext().getAsArrayType(elementType);
1133
1134      // If we only have VLA components, 'addr' requires no adjustment.
1135      if (!arrayType) {
1136        baseType = elementType;
1137        return numVLAElements;
1138      }
1139    } while (isa<VariableArrayType>(arrayType));
1140
1141    // We get out here only if we find a constant array type
1142    // inside the VLA.
1143  }
1144
1145  // We have some number of constant-length arrays, so addr should
1146  // have LLVM type [M x [N x [...]]]*.  Build a GEP that walks
1147  // down to the first element of addr.
1148  SmallVector<llvm::Value*, 8> gepIndices;
1149
1150  // GEP down to the array type.
1151  llvm::ConstantInt *zero = Builder.getInt32(0);
1152  gepIndices.push_back(zero);
1153
1154  uint64_t countFromCLAs = 1;
1155  QualType eltType;
1156
1157  llvm::ArrayType *llvmArrayType =
1158    dyn_cast<llvm::ArrayType>(
1159      cast<llvm::PointerType>(addr->getType())->getElementType());
1160  while (llvmArrayType) {
1161    assert(isa<ConstantArrayType>(arrayType));
1162    assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue()
1163             == llvmArrayType->getNumElements());
1164
1165    gepIndices.push_back(zero);
1166    countFromCLAs *= llvmArrayType->getNumElements();
1167    eltType = arrayType->getElementType();
1168
1169    llvmArrayType =
1170      dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
1171    arrayType = getContext().getAsArrayType(arrayType->getElementType());
1172    assert((!llvmArrayType || arrayType) &&
1173           "LLVM and Clang types are out-of-synch");
1174  }
1175
1176  if (arrayType) {
1177    // From this point onwards, the Clang array type has been emitted
1178    // as some other type (probably a packed struct). Compute the array
1179    // size, and just emit the 'begin' expression as a bitcast.
1180    while (arrayType) {
1181      countFromCLAs *=
1182          cast<ConstantArrayType>(arrayType)->getSize().getZExtValue();
1183      eltType = arrayType->getElementType();
1184      arrayType = getContext().getAsArrayType(eltType);
1185    }
1186
1187    unsigned AddressSpace = addr->getType()->getPointerAddressSpace();
1188    llvm::Type *BaseType = ConvertType(eltType)->getPointerTo(AddressSpace);
1189    addr = Builder.CreateBitCast(addr, BaseType, "array.begin");
1190  } else {
1191    // Create the actual GEP.
1192    addr = Builder.CreateInBoundsGEP(addr, gepIndices, "array.begin");
1193  }
1194
1195  baseType = eltType;
1196
1197  llvm::Value *numElements
1198    = llvm::ConstantInt::get(SizeTy, countFromCLAs);
1199
1200  // If we had any VLA dimensions, factor them in.
1201  if (numVLAElements)
1202    numElements = Builder.CreateNUWMul(numVLAElements, numElements);
1203
1204  return numElements;
1205}
1206
1207std::pair<llvm::Value*, QualType>
1208CodeGenFunction::getVLASize(QualType type) {
1209  const VariableArrayType *vla = getContext().getAsVariableArrayType(type);
1210  assert(vla && "type was not a variable array type!");
1211  return getVLASize(vla);
1212}
1213
1214std::pair<llvm::Value*, QualType>
1215CodeGenFunction::getVLASize(const VariableArrayType *type) {
1216  // The number of elements so far; always size_t.
1217  llvm::Value *numElements = 0;
1218
1219  QualType elementType;
1220  do {
1221    elementType = type->getElementType();
1222    llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()];
1223    assert(vlaSize && "no size for VLA!");
1224    assert(vlaSize->getType() == SizeTy);
1225
1226    if (!numElements) {
1227      numElements = vlaSize;
1228    } else {
1229      // It's undefined behavior if this wraps around, so mark it that way.
1230      // FIXME: Teach -fcatch-undefined-behavior to trap this.
1231      numElements = Builder.CreateNUWMul(numElements, vlaSize);
1232    }
1233  } while ((type = getContext().getAsVariableArrayType(elementType)));
1234
1235  return std::pair<llvm::Value*,QualType>(numElements, elementType);
1236}
1237
1238void CodeGenFunction::EmitVariablyModifiedType(QualType type) {
1239  assert(type->isVariablyModifiedType() &&
1240         "Must pass variably modified type to EmitVLASizes!");
1241
1242  EnsureInsertPoint();
1243
1244  // We're going to walk down into the type and look for VLA
1245  // expressions.
1246  do {
1247    assert(type->isVariablyModifiedType());
1248
1249    const Type *ty = type.getTypePtr();
1250    switch (ty->getTypeClass()) {
1251
1252#define TYPE(Class, Base)
1253#define ABSTRACT_TYPE(Class, Base)
1254#define NON_CANONICAL_TYPE(Class, Base)
1255#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1256#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
1257#include "clang/AST/TypeNodes.def"
1258      llvm_unreachable("unexpected dependent type!");
1259
1260    // These types are never variably-modified.
1261    case Type::Builtin:
1262    case Type::Complex:
1263    case Type::Vector:
1264    case Type::ExtVector:
1265    case Type::Record:
1266    case Type::Enum:
1267    case Type::Elaborated:
1268    case Type::TemplateSpecialization:
1269    case Type::ObjCObject:
1270    case Type::ObjCInterface:
1271    case Type::ObjCObjectPointer:
1272      llvm_unreachable("type class is never variably-modified!");
1273
1274    case Type::Pointer:
1275      type = cast<PointerType>(ty)->getPointeeType();
1276      break;
1277
1278    case Type::BlockPointer:
1279      type = cast<BlockPointerType>(ty)->getPointeeType();
1280      break;
1281
1282    case Type::LValueReference:
1283    case Type::RValueReference:
1284      type = cast<ReferenceType>(ty)->getPointeeType();
1285      break;
1286
1287    case Type::MemberPointer:
1288      type = cast<MemberPointerType>(ty)->getPointeeType();
1289      break;
1290
1291    case Type::ConstantArray:
1292    case Type::IncompleteArray:
1293      // Losing element qualification here is fine.
1294      type = cast<ArrayType>(ty)->getElementType();
1295      break;
1296
1297    case Type::VariableArray: {
1298      // Losing element qualification here is fine.
1299      const VariableArrayType *vat = cast<VariableArrayType>(ty);
1300
1301      // Unknown size indication requires no size computation.
1302      // Otherwise, evaluate and record it.
1303      if (const Expr *size = vat->getSizeExpr()) {
1304        // It's possible that we might have emitted this already,
1305        // e.g. with a typedef and a pointer to it.
1306        llvm::Value *&entry = VLASizeMap[size];
1307        if (!entry) {
1308          llvm::Value *Size = EmitScalarExpr(size);
1309
1310          // C11 6.7.6.2p5:
1311          //   If the size is an expression that is not an integer constant
1312          //   expression [...] each time it is evaluated it shall have a value
1313          //   greater than zero.
1314          if (SanOpts->VLABound &&
1315              size->getType()->isSignedIntegerType()) {
1316            llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType());
1317            llvm::Constant *StaticArgs[] = {
1318              EmitCheckSourceLocation(size->getLocStart()),
1319              EmitCheckTypeDescriptor(size->getType())
1320            };
1321            EmitCheck(Builder.CreateICmpSGT(Size, Zero),
1322                      "vla_bound_not_positive", StaticArgs, Size,
1323                      CRK_Recoverable);
1324          }
1325
1326          // Always zexting here would be wrong if it weren't
1327          // undefined behavior to have a negative bound.
1328          entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false);
1329        }
1330      }
1331      type = vat->getElementType();
1332      break;
1333    }
1334
1335    case Type::FunctionProto:
1336    case Type::FunctionNoProto:
1337      type = cast<FunctionType>(ty)->getResultType();
1338      break;
1339
1340    case Type::Paren:
1341    case Type::TypeOf:
1342    case Type::UnaryTransform:
1343    case Type::Attributed:
1344    case Type::SubstTemplateTypeParm:
1345      // Keep walking after single level desugaring.
1346      type = type.getSingleStepDesugaredType(getContext());
1347      break;
1348
1349    case Type::Typedef:
1350    case Type::Decltype:
1351    case Type::Auto:
1352      // Stop walking: nothing to do.
1353      return;
1354
1355    case Type::TypeOfExpr:
1356      // Stop walking: emit typeof expression.
1357      EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr());
1358      return;
1359
1360    case Type::Atomic:
1361      type = cast<AtomicType>(ty)->getValueType();
1362      break;
1363    }
1364  } while (type->isVariablyModifiedType());
1365}
1366
1367llvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) {
1368  if (getContext().getBuiltinVaListType()->isArrayType())
1369    return EmitScalarExpr(E);
1370  return EmitLValue(E).getAddress();
1371}
1372
1373void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E,
1374                                              llvm::Constant *Init) {
1375  assert (Init && "Invalid DeclRefExpr initializer!");
1376  if (CGDebugInfo *Dbg = getDebugInfo())
1377    if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
1378      Dbg->EmitGlobalVariable(E->getDecl(), Init);
1379}
1380
1381CodeGenFunction::PeepholeProtection
1382CodeGenFunction::protectFromPeepholes(RValue rvalue) {
1383  // At the moment, the only aggressive peephole we do in IR gen
1384  // is trunc(zext) folding, but if we add more, we can easily
1385  // extend this protection.
1386
1387  if (!rvalue.isScalar()) return PeepholeProtection();
1388  llvm::Value *value = rvalue.getScalarVal();
1389  if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection();
1390
1391  // Just make an extra bitcast.
1392  assert(HaveInsertPoint());
1393  llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "",
1394                                                  Builder.GetInsertBlock());
1395
1396  PeepholeProtection protection;
1397  protection.Inst = inst;
1398  return protection;
1399}
1400
1401void CodeGenFunction::unprotectFromPeepholes(PeepholeProtection protection) {
1402  if (!protection.Inst) return;
1403
1404  // In theory, we could try to duplicate the peepholes now, but whatever.
1405  protection.Inst->eraseFromParent();
1406}
1407
1408llvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Value *AnnotationFn,
1409                                                 llvm::Value *AnnotatedVal,
1410                                                 StringRef AnnotationStr,
1411                                                 SourceLocation Location) {
1412  llvm::Value *Args[4] = {
1413    AnnotatedVal,
1414    Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy),
1415    Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy),
1416    CGM.EmitAnnotationLineNo(Location)
1417  };
1418  return Builder.CreateCall(AnnotationFn, Args);
1419}
1420
1421void CodeGenFunction::EmitVarAnnotations(const VarDecl *D, llvm::Value *V) {
1422  assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1423  // FIXME We create a new bitcast for every annotation because that's what
1424  // llvm-gcc was doing.
1425  for (specific_attr_iterator<AnnotateAttr>
1426       ai = D->specific_attr_begin<AnnotateAttr>(),
1427       ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
1428    EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation),
1429                       Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
1430                       (*ai)->getAnnotation(), D->getLocation());
1431}
1432
1433llvm::Value *CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D,
1434                                                   llvm::Value *V) {
1435  assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1436  llvm::Type *VTy = V->getType();
1437  llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
1438                                    CGM.Int8PtrTy);
1439
1440  for (specific_attr_iterator<AnnotateAttr>
1441       ai = D->specific_attr_begin<AnnotateAttr>(),
1442       ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) {
1443    // FIXME Always emit the cast inst so we can differentiate between
1444    // annotation on the first field of a struct and annotation on the struct
1445    // itself.
1446    if (VTy != CGM.Int8PtrTy)
1447      V = Builder.Insert(new llvm::BitCastInst(V, CGM.Int8PtrTy));
1448    V = EmitAnnotationCall(F, V, (*ai)->getAnnotation(), D->getLocation());
1449    V = Builder.CreateBitCast(V, VTy);
1450  }
1451
1452  return V;
1453}
1454
1455CodeGenFunction::CGCapturedStmtInfo::~CGCapturedStmtInfo() { }
1456