Newer
Older
//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Chris Lattner and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This coordinates the per-module state used while generating code.
//
//===----------------------------------------------------------------------===//
#include "CodeGenModule.h"
#include "CodeGenFunction.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
Chris Lattner
committed
#include "llvm/Module.h"
#include "llvm/Intrinsics.h"
using namespace clang;
using namespace CodeGen;
CodeGenModule::CodeGenModule(ASTContext &C, const LangOptions &LO,
llvm::Module &M, const llvm::TargetData &TD,
Diagnostic &diags)
: Context(C), Features(LO), TheModule(M), TheTargetData(TD), Diags(diags),
/// ReplaceMapValuesWith - This is a really slow and bad function that
/// searches for any entries in GlobalDeclMap that point to OldVal, changing
/// them to point to NewVal. This is badbadbad, FIXME!
void CodeGenModule::ReplaceMapValuesWith(llvm::Constant *OldVal,
llvm::Constant *NewVal) {
for (llvm::DenseMap<const Decl*, llvm::Constant*>::iterator
I = GlobalDeclMap.begin(), E = GlobalDeclMap.end(); I != E; ++I)
if (I->second == OldVal) I->second = NewVal;
}
Chris Lattner
committed
llvm::Constant *CodeGenModule::GetAddrOfFunctionDecl(const FunctionDecl *D,
bool isDefinition) {
// See if it is already in the map. If so, just return it.
llvm::Constant *&Entry = GlobalDeclMap[D];
if (Entry) return Entry;
Chris Lattner
committed
const llvm::Type *Ty = getTypes().ConvertType(D->getType());
// Check to see if the function already exists.
llvm::Function *F = getModule().getFunction(D->getName());
const llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
// If it doesn't already exist, just create and return an entry.
if (F == 0) {
// FIXME: param attributes for sext/zext etc.
return Entry = new llvm::Function(FTy, llvm::Function::ExternalLinkage,
D->getName(), &getModule());
}
Chris Lattner
committed
// If the pointer type matches, just return it.
llvm::Type *PFTy = llvm::PointerType::get(Ty);
if (PFTy == F->getType()) return Entry = F;
Chris Lattner
committed
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
// If this isn't a definition, just return it casted to the right type.
if (!isDefinition)
return Entry = llvm::ConstantExpr::getBitCast(F, PFTy);
// Otherwise, we have a definition after a prototype with the wrong type.
// F is the Function* for the one with the wrong type, we must make a new
// Function* and update everything that used F (a declaration) with the new
// Function* (which will be a definition).
//
// This happens if there is a prototype for a function (e.g. "int f()") and
// then a definition of a different type (e.g. "int f(int x)"). Start by
// making a new function of the correct type, RAUW, then steal the name.
llvm::Function *NewFn = new llvm::Function(FTy,
llvm::Function::ExternalLinkage,
"", &getModule());
NewFn->takeName(F);
// Replace uses of F with the Function we will endow with a body.
llvm::Constant *NewPtrForOldDecl =
llvm::ConstantExpr::getBitCast(NewFn, F->getType());
F->replaceAllUsesWith(NewPtrForOldDecl);
// FIXME: Update the globaldeclmap for the previous decl of this name. We
// really want a way to walk all of these, but we don't have it yet. This
// is incredibly slow!
ReplaceMapValuesWith(F, NewPtrForOldDecl);
// Ok, delete the old function now, which is dead.
assert(F->isDeclaration() && "Shouldn't replace non-declaration");
F->eraseFromParent();
// Return the new function which has the right type.
return Entry = NewFn;
}
llvm::Constant *CodeGenModule::GetAddrOfFileVarDecl(const FileVarDecl *D,
bool isDefinition) {
// See if it is already in the map.
llvm::Constant *&Entry = GlobalDeclMap[D];
if (Entry) return Entry;
const llvm::Type *Ty = getTypes().ConvertType(D->getType());
// Check to see if the global already exists.
llvm::GlobalVariable *GV = getModule().getGlobalVariable(D->getName());
// If it doesn't already exist, just create and return an entry.
if (GV == 0) {
return Entry = new llvm::GlobalVariable(Ty, false,
llvm::GlobalValue::ExternalLinkage,
0, D->getName(), &getModule());
Chris Lattner
committed
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
// If the pointer type matches, just return it.
llvm::Type *PTy = llvm::PointerType::get(Ty);
if (PTy == GV->getType()) return Entry = GV;
// If this isn't a definition, just return it casted to the right type.
if (!isDefinition)
return Entry = llvm::ConstantExpr::getBitCast(GV, PTy);
// Otherwise, we have a definition after a prototype with the wrong type.
// GV is the GlobalVariable* for the one with the wrong type, we must make a
/// new GlobalVariable* and update everything that used GV (a declaration)
// with the new GlobalVariable* (which will be a definition).
//
// This happens if there is a prototype for a global (e.g. "extern int x[];")
// and then a definition of a different type (e.g. "int x[10];"). Start by
// making a new global of the correct type, RAUW, then steal the name.
llvm::GlobalVariable *NewGV =
new llvm::GlobalVariable(Ty, false, llvm::GlobalValue::ExternalLinkage,
0, D->getName(), &getModule());
NewGV->takeName(GV);
// Replace uses of GV with the globalvalue we will endow with a body.
llvm::Constant *NewPtrForOldDecl =
llvm::ConstantExpr::getBitCast(NewGV, GV->getType());
GV->replaceAllUsesWith(NewPtrForOldDecl);
// FIXME: Update the globaldeclmap for the previous decl of this name. We
// really want a way to walk all of these, but we don't have it yet. This
// is incredibly slow!
ReplaceMapValuesWith(GV, NewPtrForOldDecl);
// Ok, delete the old global now, which is dead.
assert(GV->isDeclaration() && "Shouldn't replace non-declaration");
GV->eraseFromParent();
// Return the new global which has the right type.
return Entry = NewGV;
}
Chris Lattner
committed
Chris Lattner
committed
void CodeGenModule::EmitFunction(const FunctionDecl *FD) {
// If this is not a prototype, emit the body.
if (FD->getBody())
CodeGenFunction(*this).GenerateCode(FD);
static llvm::Constant *GenerateConstantExpr(const Expr *Expression,
CodeGenModule& CGModule);
/// GenerateConversionToBool - Generate comparison to zero for conversion to
/// bool
static llvm::Constant *GenerateConversionToBool(llvm::Constant *Expression,
QualType Source) {
if (Source->isRealFloatingType()) {
// Compare against 0.0 for fp scalars.
llvm::Constant *Zero = llvm::Constant::getNullValue(Expression->getType());
return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Expression,
Zero);
}
assert((Source->isIntegerType() || Source->isPointerType()) &&
"Unknown scalar type to convert");
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
// Compare against an integer or pointer null.
llvm::Constant *Zero = llvm::Constant::getNullValue(Expression->getType());
return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Expression, Zero);
}
/// GenerateConstantCast - Generates a constant cast to convert the Expression
/// into the Target type.
static llvm::Constant *GenerateConstantCast(const Expr *Expression,
QualType Target,
CodeGenModule& CGModule) {
CodeGenTypes& Types = CGModule.getTypes();
QualType Source = Expression->getType().getCanonicalType();
Target = Target.getCanonicalType();
assert (!Target->isVoidType());
llvm::Constant *SubExpr = GenerateConstantExpr(Expression, CGModule);
if (Source == Target)
return SubExpr;
// Handle conversions to bool first, they are special: comparisons against 0.
if (Target->isBooleanType())
return GenerateConversionToBool(SubExpr, Source);
const llvm::Type *SourceType = Types.ConvertType(Source);
const llvm::Type *TargetType = Types.ConvertType(Target);
// Ignore conversions like int -> uint.
if (SubExpr->getType() == TargetType)
return SubExpr;
// Handle pointer conversions next: pointers can only be converted to/from
// other pointers and integers.
if (isa<llvm::PointerType>(TargetType)) {
// The source value may be an integer, or a pointer.
if (isa<llvm::PointerType>(SubExpr->getType()))
return llvm::ConstantExpr::getBitCast(SubExpr, TargetType);
assert(Source->isIntegerType() && "Not ptr->ptr or int->ptr conversion?");
return llvm::ConstantExpr::getIntToPtr(SubExpr, TargetType);
}
if (isa<llvm::PointerType>(SourceType)) {
// Must be an ptr to int cast.
assert(isa<llvm::IntegerType>(TargetType) && "not ptr->int?");
return llvm::ConstantExpr::getPtrToInt(SubExpr, TargetType);
}
if (Source->isRealFloatingType() && Target->isRealFloatingType()) {
return llvm::ConstantExpr::getFPCast(SubExpr, TargetType);
}
// Finally, we have the arithmetic types: real int/float.
if (isa<llvm::IntegerType>(SourceType)) {
bool InputSigned = Source->isSignedIntegerType();
if (isa<llvm::IntegerType>(TargetType))
return llvm::ConstantExpr::getIntegerCast(SubExpr, TargetType,
InputSigned);
else if (InputSigned)
return llvm::ConstantExpr::getSIToFP(SubExpr, TargetType);
else
return llvm::ConstantExpr::getUIToFP(SubExpr, TargetType);
}
assert(SubExpr->getType()->isFloatingPoint() && "Unknown real conversion");
if (isa<llvm::IntegerType>(TargetType)) {
if (Target->isSignedIntegerType())
return llvm::ConstantExpr::getFPToSI(SubExpr, TargetType);
else
return llvm::ConstantExpr::getFPToUI(SubExpr, TargetType);
}
assert(TargetType->isFloatingPoint() && "Unknown real conversion");
if (TargetType->getTypeID() < SubExpr->getType()->getTypeID())
return llvm::ConstantExpr::getFPTrunc(SubExpr, TargetType);
else
return llvm::ConstantExpr::getFPExtend(SubExpr, TargetType);
assert (!"Unsupported cast type in global intialiser.");
return 0;
}
/// GenerateAggregateInit - Generate a Constant initaliser for global array or
/// struct typed variables.
static llvm::Constant *GenerateAggregateInit(const InitListExpr *ILE,
CodeGenModule& CGModule) {
assert (ILE->getType()->isArrayType() || ILE->getType()->isStructureType());
CodeGenTypes& Types = CGModule.getTypes();
unsigned NumInitElements = ILE->getNumInits();
const llvm::CompositeType *CType =
cast<llvm::CompositeType>(Types.ConvertType(ILE->getType()));
assert(CType);
std::vector<llvm::Constant*> Elts;
// Copy initializer elements.
unsigned i = 0;
for (i = 0; i < NumInitElements; ++i) {
llvm::Constant *C = GenerateConstantExpr(ILE->getInit(i), CGModule);
assert (C && "Failed to create initialiser expression");
Elts.push_back(C);
if (ILE->getType()->isStructureType())
return llvm::ConstantStruct::get(cast<llvm::StructType>(CType), Elts);
// Initialising an array requires us to automatically initialise any
// elements that have not been initialised explicitly
const llvm::ArrayType *AType = cast<llvm::ArrayType>(CType);
assert(AType);
const llvm::Type *AElemTy = AType->getElementType();
unsigned NumArrayElements = AType->getNumElements();
// Initialize remaining array elements.
Elts.push_back(llvm::Constant::getNullValue(AElemTy));
return llvm::ConstantArray::get(AType, Elts);
}
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
/// GenerateConstantExpr - Recursively builds a constant initialiser for the
/// given expression.
static llvm::Constant *GenerateConstantExpr(const Expr* Expression,
CodeGenModule& CGModule) {
CodeGenTypes& Types = CGModule.getTypes();
ASTContext& Context = CGModule.getContext();
assert ((Expression->isConstantExpr(Context, 0) ||
Expression->getStmtClass() == Stmt::InitListExprClass) &&
"Only constant global initialisers are supported.");
QualType type = Expression->getType().getCanonicalType();
if (type->isIntegerType()) {
llvm::APSInt
Value(static_cast<uint32_t>(Context.getTypeSize(type, SourceLocation())));
if (Expression->isIntegerConstantExpr(Value, Context)) {
return llvm::ConstantInt::get(Value);
}
}
switch (Expression->getStmtClass()) {
// Generate constant for floating point literal values.
case Stmt::FloatingLiteralClass: {
const FloatingLiteral *FLiteral = cast<FloatingLiteral>(Expression);
return llvm::ConstantFP::get(Types.ConvertType(type), FLiteral->getValue());
}
// Generate constant for string literal values.
case Stmt::StringLiteralClass: {
const StringLiteral *SLiteral = cast<StringLiteral>(Expression);
const char *StrData = SLiteral->getStrData();
unsigned Len = SLiteral->getByteLength();
return CGModule.GetAddrOfConstantString(std::string(StrData,
StrData + Len));
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
}
// Elide parenthesis.
case Stmt::ParenExprClass:
return GenerateConstantExpr(cast<ParenExpr>(Expression)->getSubExpr(),
CGModule);
// Generate constant for sizeof operator.
// FIXME: Need to support AlignOf
case Stmt::SizeOfAlignOfTypeExprClass: {
const SizeOfAlignOfTypeExpr *SOExpr =
cast<SizeOfAlignOfTypeExpr>(Expression);
assert (SOExpr->isSizeOf());
return llvm::ConstantExpr::getSizeOf(Types.ConvertType(type));
}
// Generate constant cast expressions.
case Stmt::CastExprClass:
return GenerateConstantCast(cast<CastExpr>(Expression)->getSubExpr(), type,
CGModule);
case Stmt::ImplicitCastExprClass: {
const ImplicitCastExpr *ICExpr = cast<ImplicitCastExpr>(Expression);
return GenerateConstantCast(ICExpr->getSubExpr(), type, CGModule);
}
// Generate a constant array access expression
// FIXME: Clang's semantic analysis incorrectly prevents array access in
// global initialisers, preventing us from testing this.
case Stmt::ArraySubscriptExprClass: {
const ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(Expression);
llvm::Constant *Base = GenerateConstantExpr(ASExpr->getBase(), CGModule);
llvm::Constant *Index = GenerateConstantExpr(ASExpr->getIdx(), CGModule);
return llvm::ConstantExpr::getExtractElement(Base, Index);
}
// Generate a constant expression to initialise an aggregate type, such as
// an array or struct.
case Stmt::InitListExprClass:
return GenerateAggregateInit(cast<InitListExpr>(Expression), CGModule);
default:
assert (!"Unsupported expression in global initialiser.");
}
return 0;
}
llvm::Constant *CodeGenModule::EmitGlobalInit(const Expr *Expression) {
return GenerateConstantExpr(Expression, *this);
Chris Lattner
committed
void CodeGenModule::EmitGlobalVar(const FileVarDecl *D) {
Chris Lattner
committed
// If this is just a forward declaration of the variable, don't emit it now,
// allow it to be emitted lazily on its first use.
Chris Lattner
committed
if (D->getStorageClass() == VarDecl::Extern && D->getInit() == 0)
return;
Chris Lattner
committed
// Get the global, forcing it to be a direct reference.
llvm::GlobalVariable *GV =
cast<llvm::GlobalVariable>(GetAddrOfFileVarDecl(D, true));
// Convert the initializer, or use zero if appropriate.
llvm::Constant *Init = 0;
if (D->getInit() == 0) {
Chris Lattner
committed
Init = llvm::Constant::getNullValue(GV->getType()->getElementType());
} else if (D->getType()->isIntegerType()) {
getContext().getTypeSize(D->getInit()->getType(), SourceLocation())));
if (D->getInit()->isIntegerConstantExpr(Value, Context))
Init = llvm::ConstantInt::get(Value);
}
Init = EmitGlobalInit(D->getInit());
assert(Init && "FIXME: Global variable initializers unimp!");
Chris Lattner
committed
GV->setInitializer(Init);
// Set the llvm linkage type as appropriate.
// FIXME: This isn't right. This should handle common linkage and other
// stuff.
switch (D->getStorageClass()) {
case VarDecl::Auto:
case VarDecl::Register:
assert(0 && "Can't have auto or register globals");
case VarDecl::None:
case VarDecl::Extern:
// todo: common
break;
case VarDecl::Static:
GV->setLinkage(llvm::GlobalVariable::InternalLinkage);
break;
}
}
/// EmitGlobalVarDeclarator - Emit all the global vars attached to the specified
/// declarator chain.
void CodeGenModule::EmitGlobalVarDeclarator(const FileVarDecl *D) {
for (; D; D = cast_or_null<FileVarDecl>(D->getNextDeclarator()))
EmitGlobalVar(D);
}
Chris Lattner
committed
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
/// getBuiltinLibFunction
llvm::Function *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) {
if (BuiltinFunctions.size() <= BuiltinID)
BuiltinFunctions.resize(BuiltinID);
// Already available?
llvm::Function *&FunctionSlot = BuiltinFunctions[BuiltinID];
if (FunctionSlot)
return FunctionSlot;
assert(Context.BuiltinInfo.isLibFunction(BuiltinID) && "isn't a lib fn");
// Get the name, skip over the __builtin_ prefix.
const char *Name = Context.BuiltinInfo.GetName(BuiltinID)+10;
// Get the type for the builtin.
QualType Type = Context.BuiltinInfo.GetBuiltinType(BuiltinID, Context);
const llvm::FunctionType *Ty =
cast<llvm::FunctionType>(getTypes().ConvertType(Type));
// FIXME: This has a serious problem with code like this:
// void abs() {}
// ... __builtin_abs(x);
// The two versions of abs will collide. The fix is for the builtin to win,
// and for the existing one to be turned into a constantexpr cast of the
// builtin. In the case where the existing one is a static function, it
// should just be renamed.
Chris Lattner
committed
if (llvm::Function *Existing = getModule().getFunction(Name)) {
if (Existing->getFunctionType() == Ty && Existing->hasExternalLinkage())
return FunctionSlot = Existing;
assert(Existing == 0 && "FIXME: Name collision");
}
Chris Lattner
committed
// FIXME: param attributes for sext/zext etc.
return FunctionSlot = new llvm::Function(Ty, llvm::Function::ExternalLinkage,
Name, &getModule());
}
llvm::Function *CodeGenModule::getMemCpyFn() {
if (MemCpyFn) return MemCpyFn;
llvm::Intrinsic::ID IID;
uint64_t Size; unsigned Align;
Context.Target.getPointerInfo(Size, Align, SourceLocation());
switch (Size) {
default: assert(0 && "Unknown ptr width");
case 32: IID = llvm::Intrinsic::memcpy_i32; break;
case 64: IID = llvm::Intrinsic::memcpy_i64; break;
}
return MemCpyFn = llvm::Intrinsic::getDeclaration(&TheModule, IID);
}
Chris Lattner
committed
llvm::Constant *CodeGenModule::
GetAddrOfConstantCFString(const std::string &str) {
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
llvm::StringMapEntry<llvm::Constant *> &Entry =
CFConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
if (Entry.getValue())
return Entry.getValue();
std::vector<llvm::Constant*> Fields;
if (!CFConstantStringClassRef) {
const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Ty = llvm::ArrayType::get(Ty, 0);
CFConstantStringClassRef =
new llvm::GlobalVariable(Ty, false,
llvm::GlobalVariable::ExternalLinkage, 0,
"__CFConstantStringClassReference",
&getModule());
}
// Class pointer.
llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
llvm::Constant *Zeros[] = { Zero, Zero };
llvm::Constant *C =
llvm::ConstantExpr::getGetElementPtr(CFConstantStringClassRef, Zeros, 2);
Fields.push_back(C);
// Flags.
const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Fields.push_back(llvm::ConstantInt::get(Ty, 1992));
// String pointer.
C = llvm::ConstantArray::get(str);
C = new llvm::GlobalVariable(C->getType(), true,
llvm::GlobalValue::InternalLinkage,
C, ".str", &getModule());
C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2);
Fields.push_back(C);
// String length.
Ty = getTypes().ConvertType(getContext().LongTy);
Fields.push_back(llvm::ConstantInt::get(Ty, str.length()));
// The struct.
Ty = getTypes().ConvertType(getContext().getCFConstantStringType());
C = llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Fields);
llvm::GlobalVariable *GV =
new llvm::GlobalVariable(C->getType(), true,
llvm::GlobalVariable::InternalLinkage,
C, "", &getModule());
GV->setSection("__DATA,__cfstring");
Entry.setValue(GV);
return GV;
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
/// GenerateWritableString -- Creates storage for a string literal
static llvm::Constant *GenerateStringLiteral(const std::string &str,
bool constant,
CodeGenModule& CGModule) {
// Create Constant for this string literal
llvm::Constant *C=llvm::ConstantArray::get(str);
// Create a global variable for this string
C = new llvm::GlobalVariable(C->getType(), constant,
llvm::GlobalValue::InternalLinkage,
C, ".str", &CGModule.getModule());
llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
llvm::Constant *Zeros[] = { Zero, Zero };
C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2);
return C;
}
/// CodeGenModule::GetAddrOfConstantString -- returns a pointer to the first
/// element of a character array containing the literal.
llvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str) {
// Don't share any string literals if writable-strings is turned on.
if (Features.WritableStrings)
return GenerateStringLiteral(str, false, *this);
llvm::StringMapEntry<llvm::Constant *> &Entry =
ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
if (Entry.getValue())
return Entry.getValue();
// Create a global variable for this.
llvm::Constant *C = GenerateStringLiteral(str, true, *this);
Entry.setValue(C);
return C;
}