Newer
Older
//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
//
// The LLVM Compiler Infrastructure
//
// This file 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 "CGDebugInfo.h"
#include "CodeGenModule.h"
#include "CodeGenFunction.h"
#include "CGObjCRuntime.h"
#include "Mangle.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclCXX.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
Nate Begeman
committed
#include "llvm/CallingConv.h"
Chris Lattner
committed
#include "llvm/Module.h"
#include "llvm/Intrinsics.h"
Anton Korobeynikov
committed
#include "llvm/Target/TargetData.h"
using namespace clang;
using namespace CodeGen;
CodeGenModule::CodeGenModule(ASTContext &C, const LangOptions &LO,
llvm::Module &M, const llvm::TargetData &TD,
: BlockModule(C, M, TD, Types, *this), Context(C), Features(LO), TheModule(M),
TheTargetData(TD), Diags(diags), Types(C, M, TD), Runtime(0),
MemCpyFn(0), MemMoveFn(0), MemSetFn(0), CFConstantStringClassRef(0) {
if (!Features.ObjC1)
Runtime = 0;
else if (!Features.NeXTRuntime)
Runtime = CreateGNUObjCRuntime(*this);
else if (Features.ObjCNonFragileABI)
Runtime = CreateMacNonFragileABIObjCRuntime(*this);
else
Runtime = CreateMacObjCRuntime(*this);
// If debug info generation is enabled, create the CGDebugInfo object.
DebugInfo = GenerateDebugInfo ? new CGDebugInfo(this) : 0;
}
CodeGenModule::~CodeGenModule() {
Ted Kremenek
committed
delete Runtime;
delete DebugInfo;
}
void CodeGenModule::Release() {
EmitDeferred();
EmitAliases();
if (Runtime)
if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction())
AddGlobalCtor(ObjCInitFunction);
EmitCtorList(GlobalCtors, "llvm.global_ctors");
EmitCtorList(GlobalDtors, "llvm.global_dtors");
EmitAnnotations();
EmitLLVMUsed();
/// ErrorUnsupported - Print out an error that codegen doesn't support the
/// specified stmt yet.
void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
bool OmitOnError) {
if (OmitOnError && getDiags().hasErrorOccurred())
return;
unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
"cannot compile this %0 yet");
std::string Msg = Type;
Chris Lattner
committed
getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
<< Msg << S->getSourceRange();
/// ErrorUnsupported - Print out an error that codegen doesn't support the
/// specified decl yet.
void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
bool OmitOnError) {
if (OmitOnError && getDiags().hasErrorOccurred())
return;
unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
"cannot compile this %0 yet");
std::string Msg = Type;
Chris Lattner
committed
getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
/// setGlobalVisibility - Set the visibility for the given LLVM
/// GlobalValue according to the given clang AST visibility value.
static void setGlobalVisibility(llvm::GlobalValue *GV,
VisibilityAttr::VisibilityTypes Vis) {
switch (Vis) {
default: assert(0 && "Unknown visibility!");
case VisibilityAttr::DefaultVisibility:
GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
break;
case VisibilityAttr::HiddenVisibility:
GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
break;
case VisibilityAttr::ProtectedVisibility:
GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
break;
}
}
/// \brief Retrieves the mangled name for the given declaration.
///
/// If the given declaration requires a mangled name, returns an
Chris Lattner
committed
/// const char* containing the mangled name. Otherwise, returns
/// the unmangled name.
///
/// FIXME: Returning an IdentifierInfo* here is a total hack. We
/// really need some kind of string abstraction that either stores a
/// mangled name or stores an IdentifierInfo*. This will require
/// changes to the GlobalDeclMap, too. (I disagree, I think what we
/// actually need is for Sema to provide some notion of which Decls
/// refer to the same semantic decl. We shouldn't need to mangle the
/// names and see what comes out the same to figure this out. - DWD)
///
/// FIXME: Performance here is going to be terribly until we start
/// caching mangled names. However, we should fix the problem above
/// first.
const char *CodeGenModule::getMangledName(const NamedDecl *ND) {
Chris Lattner
committed
// In C, functions with no attributes never need to be mangled. Fastpath them.
if (!getLangOptions().CPlusPlus && !ND->hasAttrs()) {
assert(ND->getIdentifier() && "Attempt to mangle unnamed decl.");
Chris Lattner
committed
}
llvm::SmallString<256> Name;
llvm::raw_svector_ostream Out(Name);
if (!mangleName(ND, Context, Out)) {
assert(ND->getIdentifier() && "Attempt to mangle unnamed decl.");
return MangledNames.GetOrCreateValue(Name.begin(), Name.end()).getKeyData();
}
Chris Lattner
committed
/// AddGlobalCtor - Add a function to the list that will be called before
/// main() runs.
void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
// FIXME: Type coercion of void()* types.
GlobalCtors.push_back(std::make_pair(Ctor, Priority));
Chris Lattner
committed
}
/// AddGlobalDtor - Add a function to the list that will be called
/// when the module is unloaded.
void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
// FIXME: Type coercion of void()* types.
GlobalDtors.push_back(std::make_pair(Dtor, Priority));
}
void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
// Ctor function type is void()*.
llvm::FunctionType* CtorFTy =
llvm::FunctionType::get(llvm::Type::VoidTy,
std::vector<const llvm::Type*>(),
false);
llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
// Get the type of a ctor entry, { i32, void ()* }.
llvm::StructType* CtorStructTy =
llvm::StructType::get(llvm::Type::Int32Ty,
llvm::PointerType::getUnqual(CtorFTy), NULL);
// Construct the constructor and destructor arrays.
std::vector<llvm::Constant*> Ctors;
for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
std::vector<llvm::Constant*> S;
S.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, I->second, false));
S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy));
Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
}
if (!Ctors.empty()) {
llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
new llvm::GlobalVariable(AT, false,
llvm::GlobalValue::AppendingLinkage,
llvm::ConstantArray::get(AT, Ctors),
GlobalName,
&TheModule);
Chris Lattner
committed
}
}
void CodeGenModule::EmitAnnotations() {
if (Annotations.empty())
return;
// Create a new global variable for the ConstantStruct in the Module.
llvm::Constant *Array =
llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(),
Annotations.size()),
Annotations);
llvm::GlobalValue *gv =
new llvm::GlobalVariable(Array->getType(), false,
llvm::GlobalValue::AppendingLinkage, Array,
"llvm.global.annotations", &TheModule);
gv->setSection("llvm.metadata");
}
void CodeGenModule::SetGlobalValueAttributes(const Decl *D,
bool IsInternal,
bool IsInline,
llvm::GlobalValue *GV,
bool ForDefinition) {
// FIXME: Set up linkage and many other things. Note, this is a simple
// approximation of what we really want.
if (!ForDefinition) {
// Only a few attributes are set on declarations.
if (D->getAttr<DLLImportAttr>()) {
// The dllimport attribute is overridden by a subsequent declaration as
// dllexport.
// dllimport attribute can be applied only to function decls, not to
// definitions.
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
if (!FD->getBody())
GV->setLinkage(llvm::Function::DLLImportLinkage);
} else
GV->setLinkage(llvm::Function::DLLImportLinkage);
} else if (D->getAttr<WeakAttr>() ||
D->getAttr<WeakImportAttr>()) {
// "extern_weak" is overloaded in LLVM; we probably should have
// separate linkage types for this.
GV->setLinkage(llvm::Function::ExternalWeakLinkage);
} else {
if (IsInternal) {
GV->setLinkage(llvm::Function::InternalLinkage);
} else {
if (D->getAttr<DLLExportAttr>()) {
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
// The dllexport attribute is ignored for undefined symbols.
if (FD->getBody())
GV->setLinkage(llvm::Function::DLLExportLinkage);
} else
GV->setLinkage(llvm::Function::DLLExportLinkage);
} else if (D->getAttr<WeakAttr>() || D->getAttr<WeakImportAttr>() ||
IsInline)
Mike Stump
committed
GV->setLinkage(llvm::Function::WeakAnyLinkage);
// FIXME: Figure out the relative priority of the attribute,
// -fvisibility, and private_extern.
if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>())
setGlobalVisibility(GV, attr->getVisibility());
// FIXME: else handle -fvisibility
if (const SectionAttr *SA = D->getAttr<SectionAttr>())
GV->setSection(SA->getName());
// Only add to llvm.used when we see a definition, otherwise we
// might add multiple times or risk the value being replaced by a
// subsequent RAUW.
if (ForDefinition) {
if (D->getAttr<UsedAttr>())
AddUsedGlobal(GV);
}
void CodeGenModule::SetFunctionAttributes(const Decl *D,
const CGFunctionInfo &Info,
F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
AttributeList.size()));
// Set the appropriate calling convention for the Function.
if (D->getAttr<FastCallAttr>())
F->setCallingConv(llvm::CallingConv::X86_FastCall);
if (D->getAttr<StdCallAttr>())
F->setCallingConv(llvm::CallingConv::X86_StdCall);
}
/// SetFunctionAttributesForDefinition - Set function attributes
/// specific to a function definition.
void CodeGenModule::SetFunctionAttributesForDefinition(const Decl *D,
llvm::Function *F) {
if (isa<ObjCMethodDecl>(D)) {
SetGlobalValueAttributes(D, true, false, F, true);
} else {
const FunctionDecl *FD = cast<FunctionDecl>(D);
SetGlobalValueAttributes(FD, FD->getStorageClass() == FunctionDecl::Static,
FD->isInline(), F, true);
}
if (!Features.Exceptions && !Features.ObjCNonFragileABI)
F->addFnAttr(llvm::Attribute::NoUnwind);
if (D->getAttr<AlwaysInlineAttr>())
F->addFnAttr(llvm::Attribute::AlwaysInline);
if (D->getAttr<NoinlineAttr>())
F->addFnAttr(llvm::Attribute::NoInline);
}
void CodeGenModule::SetMethodAttributes(const ObjCMethodDecl *MD,
llvm::Function *F) {
SetFunctionAttributes(MD, getTypes().getFunctionInfo(MD), F);
SetFunctionAttributesForDefinition(MD, F);
}
void CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD,
llvm::Function *F) {
SetFunctionAttributes(FD, getTypes().getFunctionInfo(FD), F);
SetGlobalValueAttributes(FD, FD->getStorageClass() == FunctionDecl::Static,
FD->isInline(), F, false);
}
void CodeGenModule::EmitAliases() {
for (unsigned i = 0, e = Aliases.size(); i != e; ++i) {
const ValueDecl *D = Aliases[i];
const AliasAttr *AA = D->getAttr<AliasAttr>();
// This is something of a hack, if the FunctionDecl got overridden
// then its attributes will be moved to the new declaration. In
// this case the current decl has no alias attribute, but we will
// eventually see it.
if (!AA)
continue;
const std::string& aliaseeName = AA->getAliasee();
llvm::GlobalValue *aliasee = getModule().getNamedValue(aliaseeName);
if (!aliasee) {
// FIXME: This isn't unsupported, this is just an error, which
// sema should catch, but...
ErrorUnsupported(D, "alias referencing a missing function");
continue;
}
const char *MangledName = getMangledName(D);
llvm::GlobalValue *GA =
new llvm::GlobalAlias(aliasee->getType(),
llvm::Function::ExternalLinkage,
MangledName, aliasee, &getModule());
llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
if (Entry) {
// If we created a dummy function for this then replace it.
GA->takeName(Entry);
llvm::Value *Casted =
llvm::ConstantExpr::getBitCast(GA, Entry->getType());
Entry->replaceAllUsesWith(Casted);
Entry->eraseFromParent();
Entry = GA;
}
// Alias should never be internal or inline.
SetGlobalValueAttributes(D, false, false, GA, true);
}
}
void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
assert(!GV->isDeclaration() &&
"Only globals with definition can force usage.");
llvm::Type *i8PTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
LLVMUsed.push_back(llvm::ConstantExpr::getBitCast(GV, i8PTy));
}
void CodeGenModule::EmitLLVMUsed() {
// Don't create llvm.used if there is no need.
if (LLVMUsed.empty())
return;
llvm::ArrayType *ATy = llvm::ArrayType::get(LLVMUsed[0]->getType(),
LLVMUsed.size());
llvm::GlobalVariable *GV =
new llvm::GlobalVariable(ATy, false,
llvm::GlobalValue::AppendingLinkage,
llvm::ConstantArray::get(ATy, LLVMUsed),
"llvm.used", &getModule());
GV->setSection("llvm.metadata");
}
void CodeGenModule::EmitDeferred() {
// Emit code for any potentially referenced deferred decls. Since a
// previously unused static decl may become used during the generation of code
// for a static function, iterate until no changes are made.
while (!DeferredDeclsToEmit.empty()) {
const ValueDecl *D = DeferredDeclsToEmit.back();
DeferredDeclsToEmit.pop_back();
// The mangled name for the decl must have been emitted in GlobalDeclMap.
// Look it up to see if it was defined with a stronger definition (e.g. an
// extern inline function with a strong function redefinition). If so,
// just ignore the deferred decl.
llvm::GlobalValue *CGRef = GlobalDeclMap[getMangledName(D)];
assert(CGRef && "Deferred decl wasn't referenced?");
if (!CGRef->isDeclaration())
continue;
// Otherwise, emit the definition and move on to the next one.
EmitGlobalDefinition(D);
}
/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the
/// annotation information for a given GlobalValue. The annotation struct is
/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the
/// GlobalValue being annotated. The second field is the constant string
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
/// created from the AnnotateAttr's annotation. The third field is a constant
/// string containing the name of the translation unit. The fourth field is
/// the line number in the file of the annotated value declaration.
///
/// FIXME: this does not unique the annotation string constants, as llvm-gcc
/// appears to.
///
llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
const AnnotateAttr *AA,
unsigned LineNo) {
llvm::Module *M = &getModule();
// get [N x i8] constants for the annotation string, and the filename string
// which are the 2nd and 3rd elements of the global annotation structure.
const llvm::Type *SBP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
llvm::Constant *anno = llvm::ConstantArray::get(AA->getAnnotation(), true);
llvm::Constant *unit = llvm::ConstantArray::get(M->getModuleIdentifier(),
true);
// Get the two global values corresponding to the ConstantArrays we just
// created to hold the bytes of the strings.
llvm::GlobalValue *annoGV =
new llvm::GlobalVariable(anno->getType(), false,
llvm::GlobalValue::InternalLinkage, anno,
GV->getName() + ".str", M);
// translation unit name string, emitted into the llvm.metadata section.
llvm::GlobalValue *unitGV =
new llvm::GlobalVariable(unit->getType(), false,
llvm::GlobalValue::InternalLinkage, unit, ".str", M);
// Create the ConstantStruct that is the global annotion.
llvm::Constant *Fields[4] = {
llvm::ConstantExpr::getBitCast(GV, SBP),
llvm::ConstantExpr::getBitCast(annoGV, SBP),
llvm::ConstantExpr::getBitCast(unitGV, SBP),
llvm::ConstantInt::get(llvm::Type::Int32Ty, LineNo)
};
return llvm::ConstantStruct::get(Fields, 4, false);
}
bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
// Never defer when EmitAllDecls is specified or the decl has
// attribute used.
if (Features.EmitAllDecls || Global->getAttr<UsedAttr>())
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
// Constructors and destructors should never be deferred.
if (FD->getAttr<ConstructorAttr>() || FD->getAttr<DestructorAttr>())
return false;
// FIXME: What about inline, and/or extern inline?
if (FD->getStorageClass() != FunctionDecl::Static)
return false;
} else {
const VarDecl *VD = cast<VarDecl>(Global);
if (VD->getStorageClass() != VarDecl::Static)
return false;
}
return true;
}
void CodeGenModule::EmitGlobal(const ValueDecl *Global) {
// Aliases are deferred until code for everything else has been
// emitted.
if (Global->getAttr<AliasAttr>()) {
Aliases.push_back(Global);
return;
}
// Ignore declarations, they will be emitted on their first use.
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
// Forward declarations are emitted lazily on first use.
if (!FD->isThisDeclarationADefinition())
return;
} else {
const VarDecl *VD = cast<VarDecl>(Global);
assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
// Forward declarations are emitted lazily on first use.
Nate Begeman
committed
}
// Defer code generation when possible if this is a static definition, inline
// function etc. These we only want to emit if they are used.
if (MayDeferGeneration(Global)) {
// If the value has already been used, add it directly to the
// DeferredDeclsToEmit list.
const char *MangledName = getMangledName(Global);
if (GlobalDeclMap.count(MangledName))
DeferredDeclsToEmit.push_back(Global);
else {
// Otherwise, remember that we saw a deferred decl with this name. The
// first use of the mangled name will cause it to move into
// DeferredDeclsToEmit.
DeferredDecls[MangledName] = Global;
}
return;
}
// Otherwise emit the definition.
EmitGlobalDefinition(Global);
Nate Begeman
committed
}
void CodeGenModule::EmitGlobalDefinition(const ValueDecl *D) {
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
EmitGlobalFunctionDefinition(FD);
} else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
EmitGlobalVarDefinition(VD);
} else {
assert(0 && "Invalid argument to EmitGlobalDefinition()");
}
}
Chris Lattner
committed
/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
/// module, create and return an llvm Function with the specified type. If there
/// is something in the module with the specified name, return it potentially
/// bitcasted to the right type.
///
/// If D is non-null, it specifies a decl that correspond to this. This is used
/// to set the attributes on the function when it is first created.
llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(const char *MangledName,
const llvm::Type *Ty,
const FunctionDecl *D) {
// Lookup the entry, lazily creating it if necessary.
llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
if (Entry) {
if (Entry->getType()->getElementType() == Ty)
return Entry;
// Make sure the result is of the correct type.
const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
return llvm::ConstantExpr::getBitCast(Entry, PTy);
}
// This is the first use or definition of a mangled name. If there is a
// deferred decl with this name, remember that we need to emit it at the end
// of the file.
llvm::DenseMap<const char*, const ValueDecl*>::iterator DDI =
Chris Lattner
committed
DeferredDecls.find(MangledName);
if (DDI != DeferredDecls.end()) {
// Move the potentially referenced deferred decl to the DeferredDeclsToEmit
// list, and remove it from DeferredDecls (since we don't need it anymore).
DeferredDeclsToEmit.push_back(DDI->second);
DeferredDecls.erase(DDI);
}
// This function doesn't have a complete type (for example, the return
// type is an incomplete struct). Use a fake type instead, and make
// sure not to try to set attributes.
bool ShouldSetAttributes = true;
if (!isa<llvm::FunctionType>(Ty)) {
Ty = llvm::FunctionType::get(llvm::Type::VoidTy,
std::vector<const llvm::Type*>(), false);
ShouldSetAttributes = false;
}
llvm::Function *F = llvm::Function::Create(cast<llvm::FunctionType>(Ty),
llvm::Function::ExternalLinkage,
"", &getModule());
F->setName(MangledName);
Chris Lattner
committed
if (D && ShouldSetAttributes)
SetFunctionAttributes(D, F);
Entry = F;
return F;
}
Chris Lattner
committed
/// GetAddrOfFunction - Return the address of the given function. If Ty is
/// non-null, then this function will use the specified type if it has to
/// create it (this occurs when we see a definition of the function).
llvm::Constant *CodeGenModule::GetAddrOfFunction(const FunctionDecl *D,
const llvm::Type *Ty) {
// If there was no specific requested type, just convert it now.
if (!Ty)
Ty = getTypes().ConvertType(D->getType());
return GetOrCreateLLVMFunction(getMangledName(D), Ty, D);
}
Chris Lattner
committed
/// CreateRuntimeFunction - Create a new runtime function with the specified
/// type and name.
llvm::Constant *
CodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy,
const char *Name) {
// Convert Name to be a uniqued string from the IdentifierInfo table.
Name = getContext().Idents.get(Name).getName();
return GetOrCreateLLVMFunction(Name, FTy, 0);
}
Chris Lattner
committed
/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
/// create and return an llvm GlobalVariable with the specified type. If there
/// is something in the module with the specified name, return it potentially
/// bitcasted to the right type.
///
/// If D is non-null, it specifies a decl that correspond to this. This is used
/// to set the attributes on the global when it is first created.
llvm::Constant *CodeGenModule::GetOrCreateLLVMGlobal(const char *MangledName,
const llvm::PointerType*Ty,
const VarDecl *D) {
// Lookup the entry, lazily creating it if necessary.
llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
Chris Lattner
committed
if (Entry->getType() == Ty)
return Entry;
// Make sure the result is of the correct type.
Chris Lattner
committed
return llvm::ConstantExpr::getBitCast(Entry, Ty);
// This is the first use or definition of a mangled name. If there is a
// deferred decl with this name, remember that we need to emit it at the end
// of the file.
llvm::DenseMap<const char*, const ValueDecl*>::iterator DDI =
DeferredDecls.find(MangledName);
if (DDI != DeferredDecls.end()) {
// Move the potentially referenced deferred decl to the DeferredDeclsToEmit
// list, and remove it from DeferredDecls (since we don't need it anymore).
DeferredDeclsToEmit.push_back(DDI->second);
DeferredDecls.erase(DDI);
}
Chris Lattner
committed
new llvm::GlobalVariable(Ty->getElementType(), false,
0, "", &getModule(),
Chris Lattner
committed
0, Ty->getAddressSpace());
GV->setName(MangledName);
// Handle things which are present even on external declarations.
Chris Lattner
committed
if (D) {
// FIXME: This code is overly simple and should be merged with
// other global handling.
GV->setConstant(D->getType().isConstant(Context));
Chris Lattner
committed
// FIXME: Merge with other attribute handling code.
if (D->getStorageClass() == VarDecl::PrivateExtern)
setGlobalVisibility(GV, VisibilityAttr::HiddenVisibility);
Chris Lattner
committed
if (D->getAttr<WeakAttr>() || D->getAttr<WeakImportAttr>())
GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
}
return Entry = GV;
}
Chris Lattner
committed
/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
/// given global variable. If Ty is non-null and if the global doesn't exist,
/// then it will be greated with the specified type instead of whatever the
/// normal requested type would be.
llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
const llvm::Type *Ty) {
assert(D->hasGlobalStorage() && "Not a global variable");
QualType ASTTy = D->getType();
if (Ty == 0)
Ty = getTypes().ConvertTypeForMem(ASTTy);
const llvm::PointerType *PTy =
llvm::PointerType::get(Ty, ASTTy.getAddressSpace());
return GetOrCreateLLVMGlobal(getMangledName(D), PTy, D);
}
Chris Lattner
committed
/// CreateRuntimeVariable - Create a new runtime global variable with the
/// specified type and name.
llvm::Constant *
CodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty,
const char *Name) {
// Convert Name to be a uniqued string from the IdentifierInfo table.
Name = getContext().Idents.get(Name).getName();
return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0);
}
void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
llvm::Constant *Init = 0;
QualType ASTTy = D->getType();
if (D->getInit() == 0) {
// This is a tentative definition; tentative definitions are
// implicitly initialized with { 0 }
const llvm::Type *InitTy = getTypes().ConvertTypeForMem(ASTTy);
if (ASTTy->isIncompleteArrayType()) {
// An incomplete array is normally [ TYPE x 0 ], but we need
// to fix it to [ TYPE x 1 ].
const llvm::ArrayType* ATy = cast<llvm::ArrayType>(InitTy);
InitTy = llvm::ArrayType::get(ATy->getElementType(), 1);
}
Init = llvm::Constant::getNullValue(InitTy);
Init = EmitConstantExpr(D->getInit());
if (!Init) {
ErrorUnsupported(D, "static initializer");
QualType T = D->getInit()->getType();
Init = llvm::UndefValue::get(getTypes().ConvertType(T));
}
llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
// Strip off a bitcast if we got one back.
if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
assert(CE->getOpcode() == llvm::Instruction::BitCast);
Entry = CE->getOperand(0);
}
// Entry is now either a Function or GlobalVariable.
llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
// If we already have this global and it has an initializer, then
// we are in the rare situation where we emitted the defining
// declaration of the global and are now being asked to emit a
// definition which would be common. This occurs, for example, in
// the following situation because statics can be emitted out of
// order:
//
// static int x;
// static int *y = &x;
// static int x = 10;
// int **z = &y;
//
// Bail here so we don't blow away the definition. Note that if we
// can't distinguish here if we emitted a definition with a null
// initializer, but this case is safe.
if (GV && GV->hasInitializer() && !GV->getInitializer()->isNullValue()) {
assert(!D->getInit() && "Emitting multiple definitions of a decl!");
return;
}
// We have a definition after a declaration with the wrong type.
// We must make a new GlobalVariable* and update everything that used OldGV
// (a declaration or tentative definition) 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];"). This also happens when an initializer has a different type
// from the type of the global (this happens with unions).
//
// FIXME: This also ends up happening if there's a definition followed by
// a tentative definition! (Although Sema rejects that construct
// at the moment.)
if (GV == 0 ||
GV->getType()->getElementType() != InitType ||
GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) {
// Remove the old entry from GlobalDeclMap so that we'll create a new one.
GlobalDeclMap.erase(getMangledName(D));
// Make a new global with the correct type, this is now guaranteed to work.
GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
GV->takeName(cast<llvm::GlobalValue>(Entry));
// Replace all uses of the old global with the new global
llvm::Constant *NewPtrForOldDecl =
llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Entry->replaceAllUsesWith(NewPtrForOldDecl);
// Erase the old global, since it is no longer used.
// FIXME: What if it was attribute used? Dangling pointer from LLVMUsed.
cast<llvm::GlobalValue>(Entry)->eraseFromParent();
if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
SourceManager &SM = Context.getSourceManager();
AddAnnotation(EmitAnnotateAttr(GV, AA,
SM.getInstantiationLineNumber(D->getLocation())));
Chris Lattner
committed
GV->setInitializer(Init);
GV->setConstant(D->getType().isConstant(Context));
GV->setAlignment(getContext().getDeclAlignInBytes(D));
if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>())
setGlobalVisibility(GV, attr->getVisibility());
// FIXME: else handle -fvisibility
Chris Lattner
committed
// Set the llvm linkage type as appropriate.
if (D->getStorageClass() == VarDecl::Static)
GV->setLinkage(llvm::Function::InternalLinkage);
else if (D->getAttr<DLLImportAttr>())
GV->setLinkage(llvm::Function::DLLImportLinkage);
else if (D->getAttr<DLLExportAttr>())
GV->setLinkage(llvm::Function::DLLExportLinkage);
else if (D->getAttr<WeakAttr>() || D->getAttr<WeakImportAttr>())
Mike Stump
committed
GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
else {
// FIXME: This isn't right. This should handle common linkage and other
// stuff.
switch (D->getStorageClass()) {
case VarDecl::Static: assert(0 && "This case handled above");
case VarDecl::Auto:
case VarDecl::Register:
assert(0 && "Can't have auto or register globals");
case VarDecl::None:
if (!D->getInit())
GV->setLinkage(llvm::GlobalVariable::CommonLinkage);
Anders Carlsson
committed
else
GV->setLinkage(llvm::GlobalVariable::ExternalLinkage);
break;
case VarDecl::Extern:
// FIXME: common
break;
case VarDecl::PrivateExtern:
GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
// FIXME: common
Chris Lattner
committed
}
if (const SectionAttr *SA = D->getAttr<SectionAttr>())
GV->setSection(SA->getName());
if (D->getAttr<UsedAttr>())
AddUsedGlobal(GV);
// Emit global variable debug information.
DI->setLocation(D->getLocation());
DI->EmitGlobalVariable(GV, D);
}
Chris Lattner
committed
}
void CodeGenModule::EmitGlobalFunctionDefinition(const FunctionDecl *D) {
const llvm::FunctionType *Ty =
cast<llvm::FunctionType>(getTypes().ConvertType(D->getType()));
// As a special case, make sure that definitions of K&R function
// "type foo()" aren't declared as varargs (which forces the backend
// to do unnecessary work).
Chris Lattner
committed
if (D->getType()->isFunctionNoProtoType()) {
assert(Ty->isVarArg() && "Didn't lower type as expected");
// Due to stret, the lowered function could have arguments. Just create the
// same type as was lowered by ConvertType but strip off the varargs bit.
std::vector<const llvm::Type*> Args(Ty->param_begin(), Ty->param_end());
Ty = llvm::FunctionType::get(Ty->getReturnType(), Args, false);
}
// Get or create the prototype for teh function.
llvm::Constant *Entry = GetAddrOfFunction(D, Ty);
// Strip off a bitcast if we got one back.
if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
assert(CE->getOpcode() == llvm::Instruction::BitCast);
Entry = CE->getOperand(0);
}
if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
// If the types mismatch then we have to rewrite the definition.
assert(cast<llvm::GlobalValue>(Entry)->isDeclaration() &&
"Shouldn't replace non-declaration");
// 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.
GlobalDeclMap.erase(getMangledName(D));
llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(D, Ty));
NewFn->takeName(cast<llvm::GlobalValue>(Entry));
// Replace uses of F with the Function we will endow with a body.
llvm::Constant *NewPtrForOldDecl =
llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
Entry->replaceAllUsesWith(NewPtrForOldDecl);
// Ok, delete the old function now, which is dead.
// FIXME: If it was attribute(used) the pointer will dangle from the
// LLVMUsed array!
cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Entry = NewFn;
llvm::Function *Fn = cast<llvm::Function>(Entry);
CodeGenFunction(*this).GenerateCode(D, Fn);
SetFunctionAttributesForDefinition(D, Fn);
if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
AddGlobalCtor(Fn, CA->getPriority());
if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
AddGlobalDtor(Fn, DA->getPriority());
void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
// Make sure that this type is translated.
Types.UpdateCompletedType(TD);
}
Chris Lattner
committed
/// getBuiltinLibFunction
llvm::Value *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) {
if (BuiltinID > BuiltinFunctions.size())
BuiltinFunctions.resize(BuiltinID);
Chris Lattner
committed
// Cache looked up functions. Since builtin id #0 is invalid we don't reserve
// a slot for it.
assert(BuiltinID && "Invalid Builtin ID");
llvm::Value *&FunctionSlot = BuiltinFunctions[BuiltinID-1];
Chris Lattner
committed
if (FunctionSlot)
return FunctionSlot;
assert((Context.BuiltinInfo.isLibFunction(BuiltinID) ||
Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) &&
"isn't a lib fn");
Chris Lattner
committed
// Get the name, skip over the __builtin_ prefix (if necessary).
const char *Name = Context.BuiltinInfo.GetName(BuiltinID);
if (Context.BuiltinInfo.isLibFunction(BuiltinID))
Name += 10;
Chris Lattner
committed
// Get the type for the builtin.
Builtin::Context::GetBuiltinTypeError Error;
QualType Type = Context.BuiltinInfo.GetBuiltinType(BuiltinID, Context, Error);
assert(Error == Builtin::Context::GE_None && "Can't get builtin type");
Chris Lattner
committed
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
llvm::GlobalValue *&ExistingFn =
GlobalDeclMap[getContext().Idents.get(Name).getName()];
Chris Lattner
committed
assert(!ExistingFn && "Asking for the same builtin multiple times?");
Chris Lattner
committed
// FIXME: param attributes for sext/zext etc.
Nate Begeman
committed
llvm::Function::Create(Ty, llvm::Function::ExternalLinkage, Name,
&getModule());
Chris Lattner
committed
}
llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys,
unsigned NumTys) {
return llvm::Intrinsic::getDeclaration(&getModule(),
(llvm::Intrinsic::ID)IID, Tys, NumTys);
}
Chris Lattner
committed
llvm::Function *CodeGenModule::getMemCpyFn() {
if (MemCpyFn) return MemCpyFn;
Chris Lattner
committed
const llvm::Type *IntPtr = TheTargetData.getIntPtrType();
return MemCpyFn = getIntrinsic(llvm::Intrinsic::memcpy, &IntPtr, 1);
llvm::Function *CodeGenModule::getMemMoveFn() {
if (MemMoveFn) return MemMoveFn;
Chris Lattner
committed
const llvm::Type *IntPtr = TheTargetData.getIntPtrType();
return MemMoveFn = getIntrinsic(llvm::Intrinsic::memmove, &IntPtr, 1);
}
llvm::Function *CodeGenModule::getMemSetFn() {
if (MemSetFn) return MemSetFn;
Chris Lattner
committed
const llvm::Type *IntPtr = TheTargetData.getIntPtrType();
return MemSetFn = getIntrinsic(llvm::Intrinsic::memset, &IntPtr, 1);
static void appendFieldAndPadding(CodeGenModule &CGM,
std::vector<llvm::Constant*>& Fields,
FieldDecl *FieldD, FieldDecl *NextFieldD,