CodeGenFunction.cpp revision 4111024be81e7c0525e42dadcc126d27e5bf2425 
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 "CodeGenModule.h"
16#include "CGDebugInfo.h"
17#include "clang/Basic/TargetInfo.h"
18#include "clang/AST/AST.h"
19#include "llvm/CallingConv.h"
20#include "llvm/Constants.h"
21#include "llvm/DerivedTypes.h"
22#include "llvm/Function.h"
23#include "llvm/Analysis/Verifier.h"
24#include "llvm/Support/CFG.h"
25using namespace clang;
26using namespace CodeGen;
27
28CodeGenFunction::CodeGenFunction(CodeGenModule &cgm)
29  : CGM(cgm), Target(CGM.getContext().Target), SwitchInsn(NULL),
30    CaseRangeBlock(NULL) {
31    LLVMIntTy = ConvertType(getContext().IntTy);
32    LLVMPointerWidth = Target.getPointerWidth(0);
33}
34
35ASTContext &CodeGenFunction::getContext() const {
36  return CGM.getContext();
37}
38
39
40llvm::BasicBlock *CodeGenFunction::getBasicBlockForLabel(const LabelStmt *S) {
41  llvm::BasicBlock *&BB = LabelMap[S];
42  if (BB) return BB;
43
44  // Create, but don't insert, the new block.
45  return BB = llvm::BasicBlock::Create(S->getName());
46}
47
48llvm::Constant *
49CodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) {
50  return cast<llvm::Constant>(LocalDeclMap[BVD]);
51}
52
53const llvm::Type *CodeGenFunction::ConvertType(QualType T) {
54  return CGM.getTypes().ConvertType(T);
55}
56
57bool CodeGenFunction::isObjCPointerType(QualType T) {
58  // All Objective-C types are pointers.
59  return T->isObjCInterfaceType() ||
60    T->isObjCQualifiedInterfaceType() || T->isObjCQualifiedIdType();
61}
62
63bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
64  return !isObjCPointerType(T) &&!T->isRealType() && !T->isPointerLikeType() &&
65    !T->isVoidType() && !T->isVectorType() && !T->isFunctionType();
66}
67
68void CodeGenFunction::GenerateFunction(const Stmt *Body) {
69  // Emit the function body.
70  EmitStmt(Body);
71
72  // Emit a return for code that falls off the end. If insert point
73  // is a dummy block with no predecessors then remove the block itself.
74  llvm::BasicBlock *BB = Builder.GetInsertBlock();
75  if (isDummyBlock(BB))
76    BB->eraseFromParent();
77  else {
78    // FIXME: if this is C++ main, this should return 0.
79    if (CurFn->getReturnType() == llvm::Type::VoidTy)
80      Builder.CreateRetVoid();
81    else
82      Builder.CreateRet(llvm::UndefValue::get(CurFn->getReturnType()));
83  }
84  assert(BreakContinueStack.empty() &&
85         "mismatched push/pop in break/continue stack!");
86
87  // Remove the AllocaInsertPt instruction, which is just a convenience for us.
88  AllocaInsertPt->eraseFromParent();
89  AllocaInsertPt = 0;
90
91  // Verify that the function is well formed.
92  assert(!verifyFunction(*CurFn) && "Generated function is not well formed.");
93}
94
95void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
96  CurFuncDecl = FD;
97  FnRetTy = FD->getResultType();
98  CurFn = cast<llvm::Function>(CGM.GetAddrOfFunctionDecl(FD, true));
99  assert(CurFn->isDeclaration() && "Function already has body?");
100
101  llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
102
103  // Create a marker to make it easy to insert allocas into the entryblock
104  // later.  Don't create this with the builder, because we don't want it
105  // folded.
106  llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
107  AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
108                                         EntryBB);
109
110  Builder.SetInsertPoint(EntryBB);
111
112  // Emit allocs for param decls.  Give the LLVM Argument nodes names.
113  llvm::Function::arg_iterator AI = CurFn->arg_begin();
114
115  // Name the struct return argument.
116  if (hasAggregateLLVMType(FD->getResultType())) {
117    AI->setName("agg.result");
118    ++AI;
119  }
120
121  for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i, ++AI) {
122    assert(AI != CurFn->arg_end() && "Argument mismatch!");
123    EmitParmDecl(*FD->getParamDecl(i), AI);
124  }
125  GenerateFunction(FD->getBody());
126}
127
128/// isDummyBlock - Return true if BB is an empty basic block
129/// with no predecessors.
130bool CodeGenFunction::isDummyBlock(const llvm::BasicBlock *BB) {
131  if (BB->empty() && pred_begin(BB) == pred_end(BB))
132    return true;
133  return false;
134}
135
136/// StartBlock - Start new block named N. If insert block is a dummy block
137/// then reuse it.
138void CodeGenFunction::StartBlock(const char *N) {
139  llvm::BasicBlock *BB = Builder.GetInsertBlock();
140  if (!isDummyBlock(BB))
141    EmitBlock(llvm::BasicBlock::Create(N));
142  else
143    BB->setName(N);
144}
145
146/// getCGRecordLayout - Return record layout info.
147const CGRecordLayout *CodeGenFunction::getCGRecordLayout(CodeGenTypes &CGT,
148                                                         QualType Ty) {
149  const RecordType *RTy = Ty->getAsRecordType();
150  assert (RTy && "Unexpected type. RecordType expected here.");
151
152  return CGT.getCGRecordLayout(RTy->getDecl());
153}
154
155/// WarnUnsupported - Print out a warning that codegen doesn't support the
156/// specified stmt yet.
157void CodeGenFunction::WarnUnsupported(const Stmt *S, const char *Type) {
158  CGM.WarnUnsupported(S, Type);
159}
160
161