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