2007-07-11 21:01:13 +04:00
|
|
|
//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 22:59:25 +03:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-07-11 21:01:13 +04:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This coordinates the per-module state used while generating code.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-05-08 12:54:20 +04:00
|
|
|
#include "CGDebugInfo.h"
|
2007-07-11 21:01:13 +04:00
|
|
|
#include "CodeGenModule.h"
|
|
|
|
#include "CodeGenFunction.h"
|
2008-09-09 01:33:45 +04:00
|
|
|
#include "CGCall.h"
|
2008-08-13 04:59:25 +04:00
|
|
|
#include "CGObjCRuntime.h"
|
2007-07-11 21:01:13 +04:00
|
|
|
#include "clang/AST/ASTContext.h"
|
2008-08-11 09:35:13 +04:00
|
|
|
#include "clang/AST/DeclObjC.h"
|
2008-11-04 19:51:42 +03:00
|
|
|
#include "clang/AST/DeclCXX.h"
|
2007-12-02 10:19:18 +03:00
|
|
|
#include "clang/Basic/Diagnostic.h"
|
2008-04-19 08:17:09 +04:00
|
|
|
#include "clang/Basic/SourceManager.h"
|
2007-07-11 21:01:13 +04:00
|
|
|
#include "clang/Basic/TargetInfo.h"
|
2008-03-09 06:09:36 +03:00
|
|
|
#include "llvm/CallingConv.h"
|
2007-08-31 08:31:45 +04:00
|
|
|
#include "llvm/Module.h"
|
2007-07-11 21:01:13 +04:00
|
|
|
#include "llvm/Intrinsics.h"
|
2008-06-01 18:13:53 +04:00
|
|
|
#include "llvm/Target/TargetData.h"
|
2007-07-11 21:01:13 +04:00
|
|
|
using namespace clang;
|
|
|
|
using namespace CodeGen;
|
|
|
|
|
|
|
|
|
2007-11-28 08:34:05 +03:00
|
|
|
CodeGenModule::CodeGenModule(ASTContext &C, const LangOptions &LO,
|
2007-12-02 04:40:18 +03:00
|
|
|
llvm::Module &M, const llvm::TargetData &TD,
|
2008-08-12 01:35:06 +04:00
|
|
|
Diagnostic &diags, bool GenerateDebugInfo)
|
2007-12-02 04:40:18 +03:00
|
|
|
: Context(C), Features(LO), TheModule(M), TheTargetData(TD), Diags(diags),
|
2008-08-11 22:12:00 +04:00
|
|
|
Types(C, M, TD), Runtime(0), MemCpyFn(0), MemMoveFn(0), MemSetFn(0),
|
2008-05-26 16:59:39 +04:00
|
|
|
CFConstantStringClassRef(0) {
|
2008-08-11 22:12:00 +04:00
|
|
|
|
|
|
|
if (Features.ObjC1) {
|
2008-08-12 01:35:06 +04:00
|
|
|
if (Features.NeXTRuntime) {
|
2008-08-11 22:12:00 +04:00
|
|
|
Runtime = CreateMacObjCRuntime(*this);
|
|
|
|
} else {
|
|
|
|
Runtime = CreateGNUObjCRuntime(*this);
|
|
|
|
}
|
2008-08-11 06:45:11 +04:00
|
|
|
}
|
2008-05-08 12:54:20 +04:00
|
|
|
|
|
|
|
// If debug info generation is enabled, create the CGDebugInfo object.
|
2008-08-05 22:50:11 +04:00
|
|
|
DebugInfo = GenerateDebugInfo ? new CGDebugInfo(this) : 0;
|
2008-03-01 11:45:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
CodeGenModule::~CodeGenModule() {
|
2008-08-05 22:50:11 +04:00
|
|
|
delete Runtime;
|
|
|
|
delete DebugInfo;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CodeGenModule::Release() {
|
2008-06-01 18:13:53 +04:00
|
|
|
EmitStatics();
|
2008-09-09 03:44:31 +04:00
|
|
|
EmitAliases();
|
2008-08-11 22:12:00 +04:00
|
|
|
if (Runtime)
|
|
|
|
if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction())
|
|
|
|
AddGlobalCtor(ObjCInitFunction);
|
2008-08-01 04:01:51 +04:00
|
|
|
EmitCtorList(GlobalCtors, "llvm.global_ctors");
|
|
|
|
EmitCtorList(GlobalDtors, "llvm.global_dtors");
|
2008-04-19 03:43:57 +04:00
|
|
|
EmitAnnotations();
|
2008-10-01 04:49:24 +04:00
|
|
|
BindRuntimeFunctions();
|
2008-03-01 11:45:05 +03:00
|
|
|
}
|
2007-07-11 21:01:13 +04:00
|
|
|
|
2008-10-01 04:49:24 +04:00
|
|
|
void CodeGenModule::BindRuntimeFunctions() {
|
|
|
|
// Deal with protecting runtime function names.
|
|
|
|
for (unsigned i = 0, e = RuntimeFunctions.size(); i < e; ++i) {
|
|
|
|
llvm::Function *Fn = RuntimeFunctions[i].first;
|
|
|
|
const std::string &Name = RuntimeFunctions[i].second;
|
|
|
|
|
2008-11-19 09:15:35 +03:00
|
|
|
// Discard unused runtime functions.
|
|
|
|
if (Fn->use_empty()) {
|
|
|
|
Fn->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-10-01 04:49:24 +04:00
|
|
|
// See if there is a conflict against a function.
|
|
|
|
llvm::Function *Conflict = TheModule.getFunction(Name);
|
|
|
|
if (Conflict) {
|
|
|
|
// Decide which version to take. If the conflict is a definition
|
|
|
|
// we are forced to take that, otherwise assume the runtime
|
|
|
|
// knows best.
|
|
|
|
if (!Conflict->isDeclaration()) {
|
|
|
|
llvm::Value *Casted =
|
|
|
|
llvm::ConstantExpr::getBitCast(Conflict, Fn->getType());
|
|
|
|
Fn->replaceAllUsesWith(Casted);
|
|
|
|
Fn->eraseFromParent();
|
|
|
|
} else {
|
|
|
|
Fn->takeName(Conflict);
|
|
|
|
llvm::Value *Casted =
|
|
|
|
llvm::ConstantExpr::getBitCast(Fn, Conflict->getType());
|
|
|
|
Conflict->replaceAllUsesWith(Casted);
|
|
|
|
Conflict->eraseFromParent();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// FIXME: There still may be conflicts with aliases and
|
|
|
|
// variables.
|
|
|
|
Fn->setName(Name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-16 04:56:44 +04:00
|
|
|
/// ErrorUnsupported - Print out an error that codegen doesn't support the
|
2007-12-02 10:19:18 +03:00
|
|
|
/// specified stmt yet.
|
2008-09-04 07:43:08 +04:00
|
|
|
void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
|
|
|
|
bool OmitOnError) {
|
|
|
|
if (OmitOnError && getDiags().hasErrorOccurred())
|
|
|
|
return;
|
2008-08-16 04:56:44 +04:00
|
|
|
unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
|
2007-12-02 10:19:18 +03:00
|
|
|
"cannot codegen this %0 yet");
|
|
|
|
std::string Msg = Type;
|
This reworks some of the Diagnostic interfaces a bit to change how diagnostics
are formed. In particular, a diagnostic with all its strings and ranges is now
packaged up and sent to DiagnosticClients as a DiagnosticInfo instead of as a
ton of random stuff. This has the benefit of simplifying the interface, making
it more extensible, and allowing us to do more checking for things like access
past the end of the various arrays passed in.
In addition to introducing DiagnosticInfo, this also substantially changes how
Diagnostic::Report works. Instead of being passed in all of the info required
to issue a diagnostic, Report now takes only the required info (a location and
ID) and returns a fresh DiagnosticInfo *by value*. The caller is then free to
stuff strings and ranges into the DiagnosticInfo with the << operator. When
the dtor runs on the DiagnosticInfo object (which should happen at the end of
the statement), the diagnostic is actually emitted with all of the accumulated
information. This is a somewhat tricky dance, but it means that the
accumulated DiagnosticInfo is allowed to keep pointers to other expression
temporaries without those pointers getting invalidated.
This is just the minimal change to get this stuff working, but this will allow
us to eliminate the zillions of variant "Diag" methods scattered throughout
(e.g.) sema. For example, instead of calling:
Diag(BuiltinLoc, diag::err_overload_no_match, typeNames,
SourceRange(BuiltinLoc, RParenLoc));
We will soon be able to just do:
Diag(BuiltinLoc, diag::err_overload_no_match)
<< typeNames << SourceRange(BuiltinLoc, RParenLoc));
This scales better to support arbitrary types being passed in (not just
strings) in a type-safe way. Go operator overloading?!
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59502 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-18 10:04:44 +03:00
|
|
|
getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
|
|
|
|
<< Msg << S->getSourceRange();
|
2007-12-02 10:19:18 +03:00
|
|
|
}
|
2007-12-02 09:27:33 +03:00
|
|
|
|
2008-08-16 04:56:44 +04:00
|
|
|
/// ErrorUnsupported - Print out an error that codegen doesn't support the
|
2008-01-12 10:05:38 +03:00
|
|
|
/// specified decl yet.
|
2008-09-04 07:43:08 +04:00
|
|
|
void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
|
|
|
|
bool OmitOnError) {
|
|
|
|
if (OmitOnError && getDiags().hasErrorOccurred())
|
|
|
|
return;
|
2008-08-16 04:56:44 +04:00
|
|
|
unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
|
2008-01-12 10:05:38 +03:00
|
|
|
"cannot codegen this %0 yet");
|
|
|
|
std::string Msg = Type;
|
This reworks some of the Diagnostic interfaces a bit to change how diagnostics
are formed. In particular, a diagnostic with all its strings and ranges is now
packaged up and sent to DiagnosticClients as a DiagnosticInfo instead of as a
ton of random stuff. This has the benefit of simplifying the interface, making
it more extensible, and allowing us to do more checking for things like access
past the end of the various arrays passed in.
In addition to introducing DiagnosticInfo, this also substantially changes how
Diagnostic::Report works. Instead of being passed in all of the info required
to issue a diagnostic, Report now takes only the required info (a location and
ID) and returns a fresh DiagnosticInfo *by value*. The caller is then free to
stuff strings and ranges into the DiagnosticInfo with the << operator. When
the dtor runs on the DiagnosticInfo object (which should happen at the end of
the statement), the diagnostic is actually emitted with all of the accumulated
information. This is a somewhat tricky dance, but it means that the
accumulated DiagnosticInfo is allowed to keep pointers to other expression
temporaries without those pointers getting invalidated.
This is just the minimal change to get this stuff working, but this will allow
us to eliminate the zillions of variant "Diag" methods scattered throughout
(e.g.) sema. For example, instead of calling:
Diag(BuiltinLoc, diag::err_overload_no_match, typeNames,
SourceRange(BuiltinLoc, RParenLoc));
We will soon be able to just do:
Diag(BuiltinLoc, diag::err_overload_no_match)
<< typeNames << SourceRange(BuiltinLoc, RParenLoc));
This scales better to support arbitrary types being passed in (not just
strings) in a type-safe way. Go operator overloading?!
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@59502 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-18 10:04:44 +03:00
|
|
|
getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
|
2008-01-12 10:05:38 +03:00
|
|
|
}
|
|
|
|
|
2008-08-16 03:26:23 +04:00
|
|
|
/// 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) {
|
2008-05-22 04:50:06 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-14 20:18:18 +03:00
|
|
|
/// AddGlobalCtor - Add a function to the list that will be called before
|
|
|
|
/// main() runs.
|
2008-08-01 04:01:51 +04:00
|
|
|
void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
|
2008-03-14 20:18:18 +03:00
|
|
|
// TODO: Type coercion of void()* types.
|
2008-08-01 04:01:51 +04:00
|
|
|
GlobalCtors.push_back(std::make_pair(Ctor, Priority));
|
2008-03-14 20:18:18 +03:00
|
|
|
}
|
|
|
|
|
2008-08-01 04:01:51 +04:00
|
|
|
/// AddGlobalDtor - Add a function to the list that will be called
|
|
|
|
/// when the module is unloaded.
|
|
|
|
void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
|
|
|
|
// TODO: 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 ()* }.
|
2008-03-19 08:24:56 +03:00
|
|
|
llvm::StructType* CtorStructTy =
|
2008-08-01 04:01:51 +04:00
|
|
|
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,
|
2008-03-19 08:24:56 +03:00
|
|
|
llvm::GlobalValue::AppendingLinkage,
|
2008-08-01 04:01:51 +04:00
|
|
|
llvm::ConstantArray::get(AT, Ctors),
|
|
|
|
GlobalName,
|
2008-03-19 08:24:56 +03:00
|
|
|
&TheModule);
|
2008-03-14 20:18:18 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-19 03:43:57 +04:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
|
2008-09-09 01:33:45 +04:00
|
|
|
static void SetGlobalValueAttributes(const Decl *D,
|
|
|
|
bool IsInternal,
|
|
|
|
bool IsInline,
|
2008-09-09 03:44:31 +04:00
|
|
|
llvm::GlobalValue *GV,
|
|
|
|
bool ForDefinition) {
|
2008-06-08 19:45:52 +04:00
|
|
|
// TODO: Set up linkage and many other things. Note, this is a simple
|
|
|
|
// approximation of what we really want.
|
2008-09-09 03:44:31 +04:00
|
|
|
if (!ForDefinition) {
|
|
|
|
// Only a few attributes are set on declarations.
|
2008-12-26 03:52:02 +03:00
|
|
|
if (D->getAttr<DLLImportAttr>()) {
|
|
|
|
// The dllimport attribute is overridden by a subsequent declaration as
|
|
|
|
// dllexport.
|
|
|
|
if (!D->getAttr<DLLExportAttr>())
|
|
|
|
// 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);
|
|
|
|
}
|
2008-09-09 03:44:31 +04:00
|
|
|
} else {
|
|
|
|
if (IsInternal) {
|
|
|
|
GV->setLinkage(llvm::Function::InternalLinkage);
|
|
|
|
} else {
|
2008-12-26 03:52:02 +03:00
|
|
|
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>() || IsInline)
|
2008-09-09 03:44:31 +04:00
|
|
|
GV->setLinkage(llvm::Function::WeakLinkage);
|
|
|
|
}
|
2008-09-09 01:33:45 +04:00
|
|
|
}
|
2008-06-08 19:45:52 +04:00
|
|
|
|
2008-09-09 01:33:45 +04:00
|
|
|
if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>())
|
2008-08-16 03:26:23 +04:00
|
|
|
setGlobalVisibility(GV, attr->getVisibility());
|
2008-06-08 19:45:52 +04:00
|
|
|
// FIXME: else handle -fvisibility
|
2008-08-06 04:03:29 +04:00
|
|
|
|
2008-09-09 01:33:45 +04:00
|
|
|
if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) {
|
2008-08-06 04:03:29 +04:00
|
|
|
// Prefaced with special LLVM marker to indicate that the name
|
|
|
|
// should not be munged.
|
|
|
|
GV->setName("\01" + ALA->getLabel());
|
|
|
|
}
|
2008-06-08 19:45:52 +04:00
|
|
|
}
|
|
|
|
|
2008-09-26 01:02:23 +04:00
|
|
|
void CodeGenModule::SetFunctionAttributes(const Decl *D,
|
2008-09-10 08:01:49 +04:00
|
|
|
const CGFunctionInfo &Info,
|
2008-09-10 04:41:16 +04:00
|
|
|
llvm::Function *F) {
|
2008-09-26 01:02:23 +04:00
|
|
|
AttributeListType AttributeList;
|
|
|
|
ConstructAttributeList(D, Info.argtypes_begin(), Info.argtypes_end(),
|
|
|
|
AttributeList);
|
2008-06-04 23:41:28 +04:00
|
|
|
|
2008-09-26 01:02:23 +04:00
|
|
|
F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
|
|
|
|
AttributeList.size()));
|
2008-06-01 19:54:49 +04:00
|
|
|
|
|
|
|
// Set the appropriate calling convention for the Function.
|
2008-09-10 08:01:49 +04:00
|
|
|
if (D->getAttr<FastCallAttr>())
|
2008-11-11 23:21:14 +03:00
|
|
|
F->setCallingConv(llvm::CallingConv::X86_FastCall);
|
|
|
|
|
|
|
|
if (D->getAttr<StdCallAttr>())
|
|
|
|
F->setCallingConv(llvm::CallingConv::X86_StdCall);
|
2008-09-05 03:41:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/// SetFunctionAttributesForDefinition - Set function attributes
|
|
|
|
/// specific to a function definition.
|
2008-09-09 03:44:31 +04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-09-05 03:41:35 +04:00
|
|
|
if (!Features.Exceptions)
|
2008-09-27 11:16:42 +04:00
|
|
|
F->addFnAttr(llvm::Attribute::NoUnwind);
|
2008-10-28 03:17:57 +03:00
|
|
|
|
|
|
|
if (D->getAttr<AlwaysInlineAttr>())
|
|
|
|
F->addFnAttr(llvm::Attribute::AlwaysInline);
|
2008-09-05 03:41:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void CodeGenModule::SetMethodAttributes(const ObjCMethodDecl *MD,
|
|
|
|
llvm::Function *F) {
|
2008-09-26 01:02:23 +04:00
|
|
|
SetFunctionAttributes(MD, CGFunctionInfo(MD, Context), F);
|
2008-09-05 03:41:35 +04:00
|
|
|
|
2008-09-09 03:44:31 +04:00
|
|
|
SetFunctionAttributesForDefinition(MD, F);
|
2008-09-05 03:41:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD,
|
|
|
|
llvm::Function *F) {
|
2008-09-26 01:02:23 +04:00
|
|
|
SetFunctionAttributes(FD, CGFunctionInfo(FD), F);
|
2008-09-10 08:01:49 +04:00
|
|
|
|
2008-09-09 03:44:31 +04:00
|
|
|
SetGlobalValueAttributes(FD, FD->getStorageClass() == FunctionDecl::Static,
|
|
|
|
FD->isInline(), F, false);
|
|
|
|
}
|
|
|
|
|
2008-09-10 08:01:49 +04:00
|
|
|
|
2008-09-09 03:44:31 +04:00
|
|
|
void CodeGenModule::EmitAliases() {
|
|
|
|
for (unsigned i = 0, e = Aliases.size(); i != e; ++i) {
|
|
|
|
const FunctionDecl *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::Function *aliasee = getModule().getFunction(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;
|
|
|
|
}
|
|
|
|
|
|
|
|
llvm::GlobalValue *GA =
|
|
|
|
new llvm::GlobalAlias(aliasee->getType(),
|
|
|
|
llvm::Function::ExternalLinkage,
|
2008-11-24 08:29:24 +03:00
|
|
|
D->getNameAsString(), aliasee, &getModule());
|
2008-09-09 03:44:31 +04:00
|
|
|
|
|
|
|
llvm::GlobalValue *&Entry = GlobalDeclMap[D->getIdentifier()];
|
|
|
|
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();
|
2008-06-01 19:54:49 +04:00
|
|
|
|
2008-09-09 03:44:31 +04:00
|
|
|
Entry = GA;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Alias should never be internal or inline.
|
|
|
|
SetGlobalValueAttributes(D, false, false, GA, true);
|
|
|
|
}
|
2008-06-01 19:54:49 +04:00
|
|
|
}
|
|
|
|
|
2008-04-20 10:29:50 +04:00
|
|
|
void CodeGenModule::EmitStatics() {
|
|
|
|
// Emit code for each used static decl encountered. Since a previously unused
|
|
|
|
// static decl may become used during the generation of code for a static
|
|
|
|
// function, iterate until no changes are made.
|
|
|
|
bool Changed;
|
|
|
|
do {
|
|
|
|
Changed = false;
|
2009-01-04 05:08:04 +03:00
|
|
|
|
|
|
|
for (std::list<const ValueDecl*>::iterator i = StaticDecls.begin(),
|
|
|
|
e = StaticDecls.end(); i != e; ) {
|
|
|
|
const ValueDecl *D = *i;
|
|
|
|
|
2008-05-27 08:58:01 +04:00
|
|
|
// Check if we have used a decl with the same name
|
|
|
|
// FIXME: The AST should have some sort of aggregate decls or
|
|
|
|
// global symbol map.
|
2008-09-09 03:44:31 +04:00
|
|
|
// FIXME: This is missing some important cases. For example, we
|
|
|
|
// need to check for uses in an alias and in a constructor.
|
2009-01-04 05:08:04 +03:00
|
|
|
if (!GlobalDeclMap.count(D->getIdentifier())) {
|
|
|
|
i++;
|
2008-08-06 04:03:29 +04:00
|
|
|
continue;
|
2009-01-04 05:08:04 +03:00
|
|
|
}
|
|
|
|
|
2008-07-30 03:18:29 +04:00
|
|
|
// Emit the definition.
|
|
|
|
EmitGlobalDefinition(D);
|
|
|
|
|
2008-04-20 10:29:50 +04:00
|
|
|
// Erase the used decl from the list.
|
2009-01-04 05:08:04 +03:00
|
|
|
i = StaticDecls.erase(i);
|
|
|
|
|
2008-04-20 10:29:50 +04:00
|
|
|
// Remember that we made a change.
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
} while (Changed);
|
2007-07-11 21:01:13 +04:00
|
|
|
}
|
|
|
|
|
2008-04-19 08:17:09 +04:00
|
|
|
/// 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
|
2008-08-06 03:31:02 +04:00
|
|
|
/// GlobalValue being annotated. The second field is the constant string
|
2008-04-19 08:17:09 +04:00
|
|
|
/// 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);
|
|
|
|
}
|
|
|
|
|
2008-07-30 03:18:29 +04:00
|
|
|
void CodeGenModule::EmitGlobal(const ValueDecl *Global) {
|
|
|
|
bool isDef, isStatic;
|
|
|
|
|
|
|
|
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
|
2008-09-09 03:44:31 +04:00
|
|
|
// Aliases are deferred until code for everything else has been
|
|
|
|
// emitted.
|
|
|
|
if (FD->getAttr<AliasAttr>()) {
|
|
|
|
assert(!FD->isThisDeclarationADefinition() &&
|
|
|
|
"Function alias cannot have a definition!");
|
|
|
|
Aliases.push_back(FD);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
isDef = FD->isThisDeclarationADefinition();
|
2008-07-30 03:18:29 +04:00
|
|
|
isStatic = FD->getStorageClass() == FunctionDecl::Static;
|
|
|
|
} else if (const VarDecl *VD = cast<VarDecl>(Global)) {
|
|
|
|
assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
|
|
|
|
|
|
|
|
isDef = !(VD->getStorageClass() == VarDecl::Extern && VD->getInit() == 0);
|
|
|
|
isStatic = VD->getStorageClass() == VarDecl::Static;
|
|
|
|
} else {
|
|
|
|
assert(0 && "Invalid argument to EmitGlobal");
|
2008-04-20 10:29:50 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-07-30 03:18:29 +04:00
|
|
|
// Forward declarations are emitted lazily on first use.
|
|
|
|
if (!isDef)
|
2007-07-13 09:13:43 +04:00
|
|
|
return;
|
2008-07-30 03:18:29 +04:00
|
|
|
|
|
|
|
// If the global is a static, defer code generation until later so
|
|
|
|
// we can easily omit unused statics.
|
|
|
|
if (isStatic) {
|
|
|
|
StaticDecls.push_back(Global);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise emit the definition.
|
|
|
|
EmitGlobalDefinition(Global);
|
2008-04-20 10:29:50 +04:00
|
|
|
}
|
|
|
|
|
2008-07-30 03:18:29 +04:00
|
|
|
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()");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-30 20:32:24 +04:00
|
|
|
llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D) {
|
2008-05-30 23:50:47 +04:00
|
|
|
assert(D->hasGlobalStorage() && "Not a global variable");
|
|
|
|
|
2008-07-30 03:18:29 +04:00
|
|
|
QualType ASTTy = D->getType();
|
|
|
|
const llvm::Type *Ty = getTypes().ConvertTypeForMem(ASTTy);
|
2008-07-30 20:32:24 +04:00
|
|
|
const llvm::Type *PTy = llvm::PointerType::get(Ty, ASTTy.getAddressSpace());
|
2008-07-30 03:18:29 +04:00
|
|
|
|
2008-08-06 03:31:02 +04:00
|
|
|
// Lookup the entry, lazily creating it if necessary.
|
2008-08-25 10:18:57 +04:00
|
|
|
llvm::GlobalValue *&Entry = GlobalDeclMap[D->getIdentifier()];
|
2008-08-06 03:31:02 +04:00
|
|
|
if (!Entry)
|
|
|
|
Entry = new llvm::GlobalVariable(Ty, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
2008-11-24 08:29:24 +03:00
|
|
|
0, D->getNameAsString(), &getModule(), 0,
|
2008-08-06 03:31:02 +04:00
|
|
|
ASTTy.getAddressSpace());
|
|
|
|
|
2008-07-30 20:32:24 +04:00
|
|
|
// Make sure the result is of the correct type.
|
|
|
|
return llvm::ConstantExpr::getBitCast(Entry, PTy);
|
2008-07-30 03:18:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
|
2007-07-14 04:23:28 +04:00
|
|
|
llvm::Constant *Init = 0;
|
2008-05-30 23:50:47 +04:00
|
|
|
QualType ASTTy = D->getType();
|
|
|
|
const llvm::Type *VarTy = getTypes().ConvertTypeForMem(ASTTy);
|
|
|
|
|
2007-07-14 04:23:28 +04:00
|
|
|
if (D->getInit() == 0) {
|
2008-05-31 00:39:54 +04:00
|
|
|
// This is a tentative definition; tentative definitions are
|
|
|
|
// implicitly initialized with { 0 }
|
|
|
|
const llvm::Type* InitTy;
|
|
|
|
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>(VarTy);
|
|
|
|
InitTy = llvm::ArrayType::get(ATy->getElementType(), 1);
|
|
|
|
} else {
|
|
|
|
InitTy = VarTy;
|
|
|
|
}
|
|
|
|
Init = llvm::Constant::getNullValue(InitTy);
|
2008-05-30 23:50:47 +04:00
|
|
|
} else {
|
2008-07-30 03:18:29 +04:00
|
|
|
Init = EmitConstantExpr(D->getInit());
|
2007-07-14 04:23:28 +04:00
|
|
|
}
|
2008-05-30 23:50:47 +04:00
|
|
|
const llvm::Type* InitType = Init->getType();
|
2007-10-26 20:31:40 +04:00
|
|
|
|
2008-08-25 10:18:57 +04:00
|
|
|
llvm::GlobalValue *&Entry = GlobalDeclMap[D->getIdentifier()];
|
2008-08-06 03:31:02 +04:00
|
|
|
llvm::GlobalVariable *GV = cast_or_null<llvm::GlobalVariable>(Entry);
|
|
|
|
|
2008-05-30 23:50:47 +04:00
|
|
|
if (!GV) {
|
|
|
|
GV = new llvm::GlobalVariable(InitType, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
2008-11-24 08:29:24 +03:00
|
|
|
0, D->getNameAsString(), &getModule(), 0,
|
2008-05-30 23:50:47 +04:00
|
|
|
ASTTy.getAddressSpace());
|
2008-08-06 03:31:02 +04:00
|
|
|
} else if (GV->getType() !=
|
|
|
|
llvm::PointerType::get(InitType, ASTTy.getAddressSpace())) {
|
2008-05-30 23:50:47 +04:00
|
|
|
// We have a definition after a prototype 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).
|
2008-05-31 00:39:54 +04:00
|
|
|
//
|
|
|
|
// FIXME: This also ends up happening if there's a definition followed by
|
|
|
|
// a tentative definition! (Although Sema rejects that construct
|
|
|
|
// at the moment.)
|
2008-05-30 23:50:47 +04:00
|
|
|
|
|
|
|
// Save the old global
|
|
|
|
llvm::GlobalVariable *OldGV = GV;
|
|
|
|
|
|
|
|
// Make a new global with the correct type
|
|
|
|
GV = new llvm::GlobalVariable(InitType, false,
|
|
|
|
llvm::GlobalValue::ExternalLinkage,
|
2008-11-24 08:29:24 +03:00
|
|
|
0, D->getNameAsString(), &getModule(), 0,
|
2008-05-30 23:50:47 +04:00
|
|
|
ASTTy.getAddressSpace());
|
|
|
|
// Steal the name of the old global
|
|
|
|
GV->takeName(OldGV);
|
|
|
|
|
|
|
|
// Replace all uses of the old global with the new global
|
|
|
|
llvm::Constant *NewPtrForOldDecl =
|
|
|
|
llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
|
|
|
|
OldGV->replaceAllUsesWith(NewPtrForOldDecl);
|
|
|
|
|
|
|
|
// Erase the old global, since it is no longer used.
|
|
|
|
OldGV->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
2008-08-06 03:31:02 +04:00
|
|
|
Entry = GV;
|
2007-10-31 00:27:20 +03:00
|
|
|
|
2008-04-19 08:17:09 +04:00
|
|
|
if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
|
|
|
|
SourceManager &SM = Context.getSourceManager();
|
|
|
|
AddAnnotation(EmitAnnotateAttr(GV, AA,
|
|
|
|
SM.getLogicalLineNumber(D->getLocation())));
|
|
|
|
}
|
|
|
|
|
2007-07-13 09:13:43 +04:00
|
|
|
GV->setInitializer(Init);
|
2008-09-01 15:33:04 +04:00
|
|
|
GV->setConstant(D->getType().isConstant(Context));
|
2008-03-03 06:28:21 +03:00
|
|
|
|
2008-05-31 00:39:54 +04:00
|
|
|
// FIXME: This is silly; getTypeAlign should just work for incomplete arrays
|
|
|
|
unsigned Align;
|
2008-08-04 11:31:14 +04:00
|
|
|
if (const IncompleteArrayType* IAT =
|
|
|
|
Context.getAsIncompleteArrayType(D->getType()))
|
2008-05-31 00:39:54 +04:00
|
|
|
Align = Context.getTypeAlign(IAT->getElementType());
|
|
|
|
else
|
|
|
|
Align = Context.getTypeAlign(D->getType());
|
2008-05-29 15:10:27 +04:00
|
|
|
if (const AlignedAttr* AA = D->getAttr<AlignedAttr>()) {
|
|
|
|
Align = std::max(Align, AA->getAlignment());
|
|
|
|
}
|
|
|
|
GV->setAlignment(Align / 8);
|
|
|
|
|
2008-03-03 06:28:21 +03:00
|
|
|
if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>())
|
2008-08-16 03:26:23 +04:00
|
|
|
setGlobalVisibility(GV, attr->getVisibility());
|
2008-03-03 06:28:21 +03:00
|
|
|
// FIXME: else handle -fvisibility
|
2008-08-06 04:03:29 +04:00
|
|
|
|
|
|
|
if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) {
|
|
|
|
// Prefaced with special LLVM marker to indicate that the name
|
|
|
|
// should not be munged.
|
|
|
|
GV->setName("\01" + ALA->getLabel());
|
|
|
|
}
|
2007-07-13 09:13:43 +04:00
|
|
|
|
|
|
|
// Set the llvm linkage type as appropriate.
|
2008-05-04 05:44:26 +04:00
|
|
|
if (D->getStorageClass() == VarDecl::Static)
|
|
|
|
GV->setLinkage(llvm::Function::InternalLinkage);
|
|
|
|
else if (D->getAttr<DLLImportAttr>())
|
2008-03-03 06:28:21 +03:00
|
|
|
GV->setLinkage(llvm::Function::DLLImportLinkage);
|
|
|
|
else if (D->getAttr<DLLExportAttr>())
|
|
|
|
GV->setLinkage(llvm::Function::DLLExportLinkage);
|
2008-05-04 05:44:26 +04:00
|
|
|
else if (D->getAttr<WeakAttr>())
|
2008-03-03 06:28:21 +03:00
|
|
|
GV->setLinkage(llvm::GlobalVariable::WeakLinkage);
|
2008-05-04 05:44:26 +04:00
|
|
|
else {
|
2008-03-03 06:28:21 +03:00
|
|
|
// FIXME: This isn't right. This should handle common linkage and other
|
|
|
|
// stuff.
|
|
|
|
switch (D->getStorageClass()) {
|
2008-05-04 05:44:26 +04:00
|
|
|
case VarDecl::Static: assert(0 && "This case handled above");
|
2008-03-03 06:28:21 +03:00
|
|
|
case VarDecl::Auto:
|
|
|
|
case VarDecl::Register:
|
|
|
|
assert(0 && "Can't have auto or register globals");
|
|
|
|
case VarDecl::None:
|
|
|
|
if (!D->getInit())
|
2008-05-29 15:03:17 +04:00
|
|
|
GV->setLinkage(llvm::GlobalVariable::CommonLinkage);
|
2008-12-03 08:51:23 +03:00
|
|
|
else
|
|
|
|
GV->setLinkage(llvm::GlobalVariable::ExternalLinkage);
|
2008-03-03 06:28:21 +03:00
|
|
|
break;
|
|
|
|
case VarDecl::Extern:
|
|
|
|
case VarDecl::PrivateExtern:
|
|
|
|
// todo: common
|
|
|
|
break;
|
|
|
|
}
|
2007-07-13 09:13:43 +04:00
|
|
|
}
|
2008-06-05 12:59:10 +04:00
|
|
|
|
|
|
|
// Emit global variable debug information.
|
|
|
|
CGDebugInfo *DI = getDebugInfo();
|
|
|
|
if(DI) {
|
2008-10-17 20:15:48 +04:00
|
|
|
DI->setLocation(D->getLocation());
|
2008-06-05 12:59:10 +04:00
|
|
|
DI->EmitGlobalVariable(GV, D);
|
|
|
|
}
|
2007-07-13 09:13:43 +04:00
|
|
|
}
|
2007-07-11 21:01:13 +04:00
|
|
|
|
2008-07-30 03:18:29 +04:00
|
|
|
llvm::GlobalValue *
|
|
|
|
CodeGenModule::EmitForwardFunctionDefinition(const FunctionDecl *D) {
|
2008-09-09 03:44:31 +04:00
|
|
|
const llvm::Type *Ty = getTypes().ConvertType(D->getType());
|
|
|
|
llvm::Function *F = llvm::Function::Create(cast<llvm::FunctionType>(Ty),
|
|
|
|
llvm::Function::ExternalLinkage,
|
2008-11-24 08:29:24 +03:00
|
|
|
D->getNameAsString(),&getModule());
|
2008-09-09 03:44:31 +04:00
|
|
|
SetFunctionAttributes(D, F);
|
|
|
|
return F;
|
2008-07-30 03:18:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
llvm::Constant *CodeGenModule::GetAddrOfFunction(const FunctionDecl *D) {
|
2008-07-30 20:32:24 +04:00
|
|
|
QualType ASTTy = D->getType();
|
|
|
|
const llvm::Type *Ty = getTypes().ConvertTypeForMem(ASTTy);
|
|
|
|
const llvm::Type *PTy = llvm::PointerType::get(Ty, ASTTy.getAddressSpace());
|
2008-08-06 03:31:02 +04:00
|
|
|
|
|
|
|
// Lookup the entry, lazily creating it if necessary.
|
2008-08-25 10:18:57 +04:00
|
|
|
llvm::GlobalValue *&Entry = GlobalDeclMap[D->getIdentifier()];
|
2008-08-06 03:31:02 +04:00
|
|
|
if (!Entry)
|
|
|
|
Entry = EmitForwardFunctionDefinition(D);
|
2008-07-30 03:18:29 +04:00
|
|
|
|
2008-07-30 20:32:24 +04:00
|
|
|
return llvm::ConstantExpr::getBitCast(Entry, PTy);
|
2008-07-30 03:18:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void CodeGenModule::EmitGlobalFunctionDefinition(const FunctionDecl *D) {
|
2008-08-25 10:18:57 +04:00
|
|
|
llvm::GlobalValue *&Entry = GlobalDeclMap[D->getIdentifier()];
|
2008-08-06 03:31:02 +04:00
|
|
|
if (!Entry) {
|
2008-07-30 03:18:29 +04:00
|
|
|
Entry = EmitForwardFunctionDefinition(D);
|
|
|
|
} else {
|
2008-08-06 03:31:02 +04:00
|
|
|
// If the types mismatch then we have to rewrite the definition.
|
|
|
|
const llvm::Type *Ty = getTypes().ConvertType(D->getType());
|
|
|
|
if (Entry->getType() != llvm::PointerType::getUnqual(Ty)) {
|
2008-07-30 03:18:29 +04:00
|
|
|
// 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.
|
2008-08-06 03:31:02 +04:00
|
|
|
llvm::GlobalValue *NewFn = EmitForwardFunctionDefinition(D);
|
|
|
|
NewFn->takeName(Entry);
|
2008-07-30 03:18:29 +04:00
|
|
|
|
|
|
|
// Replace uses of F with the Function we will endow with a body.
|
|
|
|
llvm::Constant *NewPtrForOldDecl =
|
2008-08-06 03:31:02 +04:00
|
|
|
llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
|
|
|
|
Entry->replaceAllUsesWith(NewPtrForOldDecl);
|
|
|
|
|
2008-07-30 03:18:29 +04:00
|
|
|
// Ok, delete the old function now, which is dead.
|
2008-08-06 03:31:02 +04:00
|
|
|
assert(Entry->isDeclaration() && "Shouldn't replace non-declaration");
|
2008-09-09 03:44:31 +04:00
|
|
|
Entry->eraseFromParent();
|
2008-07-30 03:18:29 +04:00
|
|
|
|
|
|
|
Entry = NewFn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-09 03:44:31 +04:00
|
|
|
llvm::Function *Fn = cast<llvm::Function>(Entry);
|
|
|
|
CodeGenFunction(*this).GenerateCode(D, Fn);
|
2008-08-11 21:36:14 +04:00
|
|
|
|
2008-09-09 03:44:31 +04:00
|
|
|
SetFunctionAttributesForDefinition(D, Fn);
|
|
|
|
|
|
|
|
if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) {
|
|
|
|
AddGlobalCtor(Fn, CA->getPriority());
|
|
|
|
} else if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) {
|
|
|
|
AddGlobalDtor(Fn, DA->getPriority());
|
2008-07-30 03:18:29 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-01 04:49:24 +04:00
|
|
|
llvm::Function *
|
|
|
|
CodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy,
|
|
|
|
const std::string &Name) {
|
|
|
|
llvm::Function *Fn = llvm::Function::Create(FTy,
|
|
|
|
llvm::Function::ExternalLinkage,
|
|
|
|
"", &TheModule);
|
|
|
|
RuntimeFunctions.push_back(std::make_pair(Fn, Name));
|
|
|
|
return Fn;
|
|
|
|
}
|
|
|
|
|
2008-02-06 08:08:19 +03:00
|
|
|
void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
|
|
|
|
// Make sure that this type is translated.
|
|
|
|
Types.UpdateCompletedType(TD);
|
2008-02-05 11:06:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-08-31 08:31:45 +04:00
|
|
|
/// getBuiltinLibFunction
|
|
|
|
llvm::Function *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) {
|
2007-12-13 03:38:03 +03:00
|
|
|
if (BuiltinID > BuiltinFunctions.size())
|
|
|
|
BuiltinFunctions.resize(BuiltinID);
|
2007-08-31 08:31:45 +04:00
|
|
|
|
2007-12-13 03:38:03 +03:00
|
|
|
// Cache looked up functions. Since builtin id #0 is invalid we don't reserve
|
|
|
|
// a slot for it.
|
|
|
|
assert(BuiltinID && "Invalid Builtin ID");
|
|
|
|
llvm::Function *&FunctionSlot = BuiltinFunctions[BuiltinID-1];
|
2007-08-31 08:31:45 +04:00
|
|
|
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.
|
2007-08-31 08:44:06 +04:00
|
|
|
if (llvm::Function *Existing = getModule().getFunction(Name)) {
|
|
|
|
if (Existing->getFunctionType() == Ty && Existing->hasExternalLinkage())
|
|
|
|
return FunctionSlot = Existing;
|
|
|
|
assert(Existing == 0 && "FIXME: Name collision");
|
|
|
|
}
|
2007-08-31 08:31:45 +04:00
|
|
|
|
|
|
|
// FIXME: param attributes for sext/zext etc.
|
2008-04-20 10:29:50 +04:00
|
|
|
return FunctionSlot =
|
|
|
|
llvm::Function::Create(Ty, llvm::Function::ExternalLinkage, Name,
|
|
|
|
&getModule());
|
2007-08-31 08:31:45 +04:00
|
|
|
}
|
|
|
|
|
2007-12-18 03:25:38 +03:00
|
|
|
llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys,
|
|
|
|
unsigned NumTys) {
|
|
|
|
return llvm::Intrinsic::getDeclaration(&getModule(),
|
|
|
|
(llvm::Intrinsic::ID)IID, Tys, NumTys);
|
|
|
|
}
|
2007-08-31 08:31:45 +04:00
|
|
|
|
2007-07-11 21:01:13 +04:00
|
|
|
llvm::Function *CodeGenModule::getMemCpyFn() {
|
|
|
|
if (MemCpyFn) return MemCpyFn;
|
2008-11-21 19:43:15 +03:00
|
|
|
const llvm::Type *IntPtr = TheTargetData.getIntPtrType();
|
|
|
|
return MemCpyFn = getIntrinsic(llvm::Intrinsic::memcpy, &IntPtr, 1);
|
2007-07-11 21:01:13 +04:00
|
|
|
}
|
2007-08-21 04:21:21 +04:00
|
|
|
|
2008-05-26 16:59:39 +04:00
|
|
|
llvm::Function *CodeGenModule::getMemMoveFn() {
|
|
|
|
if (MemMoveFn) return MemMoveFn;
|
2008-11-21 19:43:15 +03:00
|
|
|
const llvm::Type *IntPtr = TheTargetData.getIntPtrType();
|
|
|
|
return MemMoveFn = getIntrinsic(llvm::Intrinsic::memmove, &IntPtr, 1);
|
2008-05-26 16:59:39 +04:00
|
|
|
}
|
|
|
|
|
2008-02-20 01:01:01 +03:00
|
|
|
llvm::Function *CodeGenModule::getMemSetFn() {
|
|
|
|
if (MemSetFn) return MemSetFn;
|
2008-11-21 19:43:15 +03:00
|
|
|
const llvm::Type *IntPtr = TheTargetData.getIntPtrType();
|
|
|
|
return MemSetFn = getIntrinsic(llvm::Intrinsic::memset, &IntPtr, 1);
|
2008-02-20 01:01:01 +03:00
|
|
|
}
|
2007-12-18 03:25:38 +03:00
|
|
|
|
2008-11-15 21:54:24 +03:00
|
|
|
static void appendFieldAndPadding(CodeGenModule &CGM,
|
|
|
|
std::vector<llvm::Constant*>& Fields,
|
2008-12-11 19:49:14 +03:00
|
|
|
FieldDecl *FieldD, FieldDecl *NextFieldD,
|
|
|
|
llvm::Constant* Field,
|
2008-11-15 21:54:24 +03:00
|
|
|
RecordDecl* RD, const llvm::StructType *STy)
|
|
|
|
{
|
|
|
|
// Append the field.
|
|
|
|
Fields.push_back(Field);
|
|
|
|
|
2008-12-11 19:49:14 +03:00
|
|
|
int StructFieldNo = CGM.getTypes().getLLVMFieldNo(FieldD);
|
2008-11-15 21:54:24 +03:00
|
|
|
|
|
|
|
int NextStructFieldNo;
|
2008-12-11 19:49:14 +03:00
|
|
|
if (!NextFieldD) {
|
2008-11-15 21:54:24 +03:00
|
|
|
NextStructFieldNo = STy->getNumElements();
|
|
|
|
} else {
|
2008-12-11 19:49:14 +03:00
|
|
|
NextStructFieldNo = CGM.getTypes().getLLVMFieldNo(NextFieldD);
|
2008-11-15 21:54:24 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Append padding
|
|
|
|
for (int i = StructFieldNo + 1; i < NextStructFieldNo; i++) {
|
|
|
|
llvm::Constant *C =
|
|
|
|
llvm::Constant::getNullValue(STy->getElementType(StructFieldNo + 1));
|
|
|
|
|
|
|
|
Fields.push_back(C);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-23 22:37:06 +04:00
|
|
|
// We still need to work out the details of handling UTF-16.
|
|
|
|
// See: <rdr://2996215>
|
2007-08-31 08:31:45 +04:00
|
|
|
llvm::Constant *CodeGenModule::
|
|
|
|
GetAddrOfConstantCFString(const std::string &str) {
|
2007-08-21 04:21:21 +04:00
|
|
|
llvm::StringMapEntry<llvm::Constant *> &Entry =
|
|
|
|
CFConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
|
|
|
|
|
|
|
|
if (Entry.getValue())
|
|
|
|
return Entry.getValue();
|
|
|
|
|
2008-08-23 22:37:06 +04:00
|
|
|
llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
|
|
|
|
llvm::Constant *Zeros[] = { Zero, Zero };
|
2007-08-21 04:21:21 +04:00
|
|
|
|
|
|
|
if (!CFConstantStringClassRef) {
|
|
|
|
const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
|
|
|
|
Ty = llvm::ArrayType::get(Ty, 0);
|
2008-08-23 22:37:06 +04:00
|
|
|
|
|
|
|
// FIXME: This is fairly broken if
|
|
|
|
// __CFConstantStringClassReference is already defined, in that it
|
|
|
|
// will get renamed and the user will most likely see an opaque
|
|
|
|
// error message. This is a general issue with relying on
|
|
|
|
// particular names.
|
|
|
|
llvm::GlobalVariable *GV =
|
2007-08-21 04:21:21 +04:00
|
|
|
new llvm::GlobalVariable(Ty, false,
|
|
|
|
llvm::GlobalVariable::ExternalLinkage, 0,
|
|
|
|
"__CFConstantStringClassReference",
|
|
|
|
&getModule());
|
2008-08-23 22:37:06 +04:00
|
|
|
|
|
|
|
// Decay array -> ptr
|
|
|
|
CFConstantStringClassRef =
|
|
|
|
llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
|
2007-08-21 04:21:21 +04:00
|
|
|
}
|
|
|
|
|
2008-11-15 21:54:24 +03:00
|
|
|
QualType CFTy = getContext().getCFConstantStringType();
|
|
|
|
RecordDecl *CFRD = CFTy->getAsRecordType()->getDecl();
|
2008-08-23 22:37:06 +04:00
|
|
|
|
2008-11-15 21:54:24 +03:00
|
|
|
const llvm::StructType *STy =
|
|
|
|
cast<llvm::StructType>(getTypes().ConvertType(CFTy));
|
|
|
|
|
|
|
|
std::vector<llvm::Constant*> Fields;
|
2008-12-11 19:49:14 +03:00
|
|
|
RecordDecl::field_iterator Field = CFRD->field_begin();
|
|
|
|
|
2007-08-21 04:21:21 +04:00
|
|
|
// Class pointer.
|
2008-12-11 19:49:14 +03:00
|
|
|
FieldDecl *CurField = *Field++;
|
|
|
|
FieldDecl *NextField = *Field++;
|
|
|
|
appendFieldAndPadding(*this, Fields, CurField, NextField,
|
|
|
|
CFConstantStringClassRef, CFRD, STy);
|
2007-08-21 04:21:21 +04:00
|
|
|
|
|
|
|
// Flags.
|
2008-12-11 19:49:14 +03:00
|
|
|
CurField = NextField;
|
|
|
|
NextField = *Field++;
|
2008-08-23 22:37:06 +04:00
|
|
|
const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
|
2008-12-11 19:49:14 +03:00
|
|
|
appendFieldAndPadding(*this, Fields, CurField, NextField,
|
|
|
|
llvm::ConstantInt::get(Ty, 0x07C8), CFRD, STy);
|
2007-08-21 04:21:21 +04:00
|
|
|
|
|
|
|
// String pointer.
|
2008-12-11 19:49:14 +03:00
|
|
|
CurField = NextField;
|
|
|
|
NextField = *Field++;
|
2008-08-23 22:37:06 +04:00
|
|
|
llvm::Constant *C = llvm::ConstantArray::get(str);
|
2007-08-21 04:21:21 +04:00
|
|
|
C = new llvm::GlobalVariable(C->getType(), true,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
2008-11-15 21:54:24 +03:00
|
|
|
C, ".str", &getModule());
|
2008-12-11 19:49:14 +03:00
|
|
|
appendFieldAndPadding(*this, Fields, CurField, NextField,
|
2008-11-15 21:54:24 +03:00
|
|
|
llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2),
|
|
|
|
CFRD, STy);
|
2007-08-21 04:21:21 +04:00
|
|
|
|
|
|
|
// String length.
|
2008-12-11 19:49:14 +03:00
|
|
|
CurField = NextField;
|
|
|
|
NextField = 0;
|
2007-08-21 04:21:21 +04:00
|
|
|
Ty = getTypes().ConvertType(getContext().LongTy);
|
2008-12-11 19:49:14 +03:00
|
|
|
appendFieldAndPadding(*this, Fields, CurField, NextField,
|
|
|
|
llvm::ConstantInt::get(Ty, str.length()), CFRD, STy);
|
2007-08-21 04:21:21 +04:00
|
|
|
|
|
|
|
// The struct.
|
2008-11-15 21:54:24 +03:00
|
|
|
C = llvm::ConstantStruct::get(STy, Fields);
|
2007-11-01 03:41:52 +03:00
|
|
|
llvm::GlobalVariable *GV =
|
|
|
|
new llvm::GlobalVariable(C->getType(), true,
|
|
|
|
llvm::GlobalVariable::InternalLinkage,
|
|
|
|
C, "", &getModule());
|
2008-08-23 22:37:06 +04:00
|
|
|
|
2007-11-01 03:41:52 +03:00
|
|
|
GV->setSection("__DATA,__cfstring");
|
|
|
|
Entry.setValue(GV);
|
2008-08-23 22:37:06 +04:00
|
|
|
|
2007-11-01 03:41:52 +03:00
|
|
|
return GV;
|
2007-08-21 04:21:21 +04:00
|
|
|
}
|
2007-11-28 08:34:05 +03:00
|
|
|
|
2008-08-14 03:20:05 +04:00
|
|
|
/// GetStringForStringLiteral - Return the appropriate bytes for a
|
2008-08-11 00:25:57 +04:00
|
|
|
/// string literal, properly padded to match the literal type.
|
2008-08-14 03:20:05 +04:00
|
|
|
std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) {
|
2008-08-29 21:28:43 +04:00
|
|
|
if (E->isWide()) {
|
|
|
|
ErrorUnsupported(E, "wide string");
|
|
|
|
return "FIXME";
|
|
|
|
}
|
|
|
|
|
2008-08-11 00:25:57 +04:00
|
|
|
const char *StrData = E->getStrData();
|
|
|
|
unsigned Len = E->getByteLength();
|
|
|
|
|
|
|
|
const ConstantArrayType *CAT =
|
|
|
|
getContext().getAsConstantArrayType(E->getType());
|
|
|
|
assert(CAT && "String isn't pointer or array!");
|
|
|
|
|
|
|
|
// Resize the string to the right size
|
|
|
|
// FIXME: What about wchar_t strings?
|
|
|
|
std::string Str(StrData, StrData+Len);
|
|
|
|
uint64_t RealLen = CAT->getSize().getZExtValue();
|
|
|
|
Str.resize(RealLen, '\0');
|
|
|
|
|
|
|
|
return Str;
|
|
|
|
}
|
|
|
|
|
2008-08-14 03:20:05 +04:00
|
|
|
/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
|
|
|
|
/// constant array for the given string literal.
|
|
|
|
llvm::Constant *
|
|
|
|
CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
|
|
|
|
// FIXME: This can be more efficient.
|
|
|
|
return GetAddrOfConstantString(GetStringForStringLiteral(S));
|
|
|
|
}
|
|
|
|
|
2008-02-11 03:02:17 +03:00
|
|
|
/// GenerateWritableString -- Creates storage for a string literal.
|
2007-11-28 08:34:05 +03:00
|
|
|
static llvm::Constant *GenerateStringLiteral(const std::string &str,
|
|
|
|
bool constant,
|
2008-10-18 01:56:50 +04:00
|
|
|
CodeGenModule &CGM,
|
|
|
|
const char *GlobalName) {
|
2008-08-14 03:20:05 +04:00
|
|
|
// Create Constant for this string literal. Don't add a '\0'.
|
|
|
|
llvm::Constant *C = llvm::ConstantArray::get(str, false);
|
2007-11-28 08:34:05 +03:00
|
|
|
|
|
|
|
// Create a global variable for this string
|
|
|
|
C = new llvm::GlobalVariable(C->getType(), constant,
|
|
|
|
llvm::GlobalValue::InternalLinkage,
|
2008-10-18 01:56:50 +04:00
|
|
|
C,
|
|
|
|
GlobalName ? GlobalName : ".str",
|
|
|
|
&CGM.getModule());
|
2008-08-14 03:20:05 +04:00
|
|
|
|
2007-11-28 08:34:05 +03:00
|
|
|
return C;
|
|
|
|
}
|
|
|
|
|
2008-08-14 03:20:05 +04:00
|
|
|
/// GetAddrOfConstantString - Returns a pointer to a character array
|
|
|
|
/// containing the literal. This contents are exactly that of the
|
|
|
|
/// given string, i.e. it will not be null terminated automatically;
|
|
|
|
/// see GetAddrOfConstantCString. Note that whether the result is
|
|
|
|
/// actually a pointer to an LLVM constant depends on
|
|
|
|
/// Feature.WriteableStrings.
|
|
|
|
///
|
|
|
|
/// The result has pointer to array type.
|
2008-10-18 01:56:50 +04:00
|
|
|
llvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str,
|
|
|
|
const char *GlobalName) {
|
2007-11-28 08:34:05 +03:00
|
|
|
// Don't share any string literals if writable-strings is turned on.
|
|
|
|
if (Features.WritableStrings)
|
2008-10-18 01:56:50 +04:00
|
|
|
return GenerateStringLiteral(str, false, *this, GlobalName);
|
2007-11-28 08:34:05 +03:00
|
|
|
|
|
|
|
llvm::StringMapEntry<llvm::Constant *> &Entry =
|
|
|
|
ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
|
|
|
|
|
|
|
|
if (Entry.getValue())
|
|
|
|
return Entry.getValue();
|
|
|
|
|
|
|
|
// Create a global variable for this.
|
2008-10-18 01:56:50 +04:00
|
|
|
llvm::Constant *C = GenerateStringLiteral(str, true, *this, GlobalName);
|
2007-11-28 08:34:05 +03:00
|
|
|
Entry.setValue(C);
|
|
|
|
return C;
|
|
|
|
}
|
2008-08-14 03:20:05 +04:00
|
|
|
|
|
|
|
/// GetAddrOfConstantCString - Returns a pointer to a character
|
|
|
|
/// array containing the literal and a terminating '\-'
|
|
|
|
/// character. The result has pointer to array type.
|
2008-10-18 01:56:50 +04:00
|
|
|
llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &str,
|
|
|
|
const char *GlobalName){
|
2008-12-09 22:10:54 +03:00
|
|
|
return GetAddrOfConstantString(str + '\0', GlobalName);
|
2008-08-14 03:20:05 +04:00
|
|
|
}
|
2008-08-16 03:26:23 +04:00
|
|
|
|
2008-08-26 12:29:31 +04:00
|
|
|
/// EmitObjCPropertyImplementations - Emit information for synthesized
|
|
|
|
/// properties for an implementation.
|
|
|
|
void CodeGenModule::EmitObjCPropertyImplementations(const
|
|
|
|
ObjCImplementationDecl *D) {
|
|
|
|
for (ObjCImplementationDecl::propimpl_iterator i = D->propimpl_begin(),
|
|
|
|
e = D->propimpl_end(); i != e; ++i) {
|
|
|
|
ObjCPropertyImplDecl *PID = *i;
|
|
|
|
|
|
|
|
// Dynamic is just for type-checking.
|
|
|
|
if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
|
|
|
|
ObjCPropertyDecl *PD = PID->getPropertyDecl();
|
|
|
|
|
|
|
|
// Determine which methods need to be implemented, some may have
|
|
|
|
// been overridden. Note that ::isSynthesized is not the method
|
|
|
|
// we want, that just indicates if the decl came from a
|
|
|
|
// property. What we want to know is if the method is defined in
|
|
|
|
// this implementation.
|
|
|
|
if (!D->getInstanceMethod(PD->getGetterName()))
|
2008-12-09 23:23:04 +03:00
|
|
|
CodeGenFunction(*this).GenerateObjCGetter(
|
|
|
|
const_cast<ObjCImplementationDecl *>(D), PID);
|
2008-08-26 12:29:31 +04:00
|
|
|
if (!PD->isReadOnly() &&
|
|
|
|
!D->getInstanceMethod(PD->getSetterName()))
|
2008-12-09 23:23:04 +03:00
|
|
|
CodeGenFunction(*this).GenerateObjCSetter(
|
|
|
|
const_cast<ObjCImplementationDecl *>(D), PID);
|
2008-08-26 12:29:31 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-16 03:26:23 +04:00
|
|
|
/// EmitTopLevelDecl - Emit code for a single top level declaration.
|
|
|
|
void CodeGenModule::EmitTopLevelDecl(Decl *D) {
|
|
|
|
// If an error has occurred, stop code generation, but continue
|
|
|
|
// parsing and semantic analysis (to ensure all warnings and errors
|
|
|
|
// are emitted).
|
|
|
|
if (Diags.hasErrorOccurred())
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (D->getKind()) {
|
|
|
|
case Decl::Function:
|
|
|
|
case Decl::Var:
|
|
|
|
EmitGlobal(cast<ValueDecl>(D));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Decl::Namespace:
|
2008-08-29 21:28:43 +04:00
|
|
|
ErrorUnsupported(D, "namespace");
|
2008-08-16 03:26:23 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
// Objective-C Decls
|
|
|
|
|
|
|
|
// Forward declarations, no (immediate) code generation.
|
|
|
|
case Decl::ObjCClass:
|
|
|
|
case Decl::ObjCCategory:
|
|
|
|
case Decl::ObjCForwardProtocol:
|
|
|
|
case Decl::ObjCInterface:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Decl::ObjCProtocol:
|
|
|
|
Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Decl::ObjCCategoryImpl:
|
2008-08-26 12:29:31 +04:00
|
|
|
// Categories have properties but don't support synthesize so we
|
|
|
|
// can ignore them here.
|
|
|
|
|
2008-08-16 03:26:23 +04:00
|
|
|
Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
|
|
|
|
break;
|
|
|
|
|
2008-08-26 12:29:31 +04:00
|
|
|
case Decl::ObjCImplementation: {
|
|
|
|
ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
|
|
|
|
EmitObjCPropertyImplementations(OMD);
|
|
|
|
Runtime->GenerateClass(OMD);
|
2008-08-16 03:26:23 +04:00
|
|
|
break;
|
2008-08-26 12:29:31 +04:00
|
|
|
}
|
2008-08-16 03:26:23 +04:00
|
|
|
case Decl::ObjCMethod: {
|
|
|
|
ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
|
|
|
|
// If this is not a prototype, emit the body.
|
|
|
|
if (OMD->getBody())
|
|
|
|
CodeGenFunction(*this).GenerateObjCMethod(OMD);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Decl::ObjCCompatibleAlias:
|
2008-08-29 21:28:43 +04:00
|
|
|
ErrorUnsupported(D, "Objective-C compatible alias");
|
2008-08-16 03:26:23 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Decl::LinkageSpec: {
|
|
|
|
LinkageSpecDecl *LSD = cast<LinkageSpecDecl>(D);
|
|
|
|
if (LSD->getLanguage() == LinkageSpecDecl::lang_cxx)
|
2008-08-16 04:56:44 +04:00
|
|
|
ErrorUnsupported(LSD, "linkage spec");
|
2008-08-16 03:26:23 +04:00
|
|
|
// FIXME: implement C++ linkage, C linkage works mostly by C
|
|
|
|
// language reuse already.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Decl::FileScopeAsm: {
|
|
|
|
FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
|
|
|
|
std::string AsmString(AD->getAsmString()->getStrData(),
|
|
|
|
AD->getAsmString()->getByteLength());
|
|
|
|
|
|
|
|
const std::string &S = getModule().getModuleInlineAsm();
|
|
|
|
if (S.empty())
|
|
|
|
getModule().setModuleInlineAsm(AsmString);
|
|
|
|
else
|
|
|
|
getModule().setModuleInlineAsm(S + '\n' + AsmString);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
// Make sure we handled everything we should, every other kind is
|
|
|
|
// a non-top-level decl. FIXME: Would be nice to have an
|
|
|
|
// isTopLevelDeclKind function. Need to recode Decl::Kind to do
|
|
|
|
// that easily.
|
|
|
|
assert(isa<TypeDecl>(D) && "Unsupported decl kind");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|