mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-04 10:46:07 +00:00
23fd462f48
collisions. - Provide CodeGenModule::CreateRuntimeFunction which guarantees that the function it creates will have the provided name in the final module. This allows the runtime to have its functions protected from declarations of the same name in the source code. - One could argue that this is a reason to abuse the llvm::Module namespace for dealing with function redeclarations. However, that approach seems conceptually flawed to me. This one also happens to be somewhat more efficient. No functionality change. llvm-svn: 56899
284 lines
10 KiB
C++
284 lines
10 KiB
C++
//===--- CodeGenModule.h - Per-Module state for LLVM CodeGen ----*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This is the internal per-translation-unit state used for llvm translation.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef CLANG_CODEGEN_CODEGENMODULE_H
|
|
#define CLANG_CODEGEN_CODEGENMODULE_H
|
|
|
|
#include "CodeGenTypes.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
|
|
#include "CGCall.h"
|
|
|
|
namespace llvm {
|
|
class Module;
|
|
class Constant;
|
|
class Function;
|
|
class GlobalValue;
|
|
class TargetData;
|
|
class FunctionType;
|
|
}
|
|
|
|
namespace clang {
|
|
class ASTContext;
|
|
class FunctionDecl;
|
|
class IdentifierInfo;
|
|
class ObjCMethodDecl;
|
|
class ObjCImplementationDecl;
|
|
class ObjCCategoryImplDecl;
|
|
class ObjCProtocolDecl;
|
|
class Decl;
|
|
class Expr;
|
|
class Stmt;
|
|
class StringLiteral;
|
|
class NamedDecl;
|
|
class ValueDecl;
|
|
class VarDecl;
|
|
struct LangOptions;
|
|
class Diagnostic;
|
|
class AnnotateAttr;
|
|
|
|
namespace CodeGen {
|
|
|
|
class CodeGenFunction;
|
|
class CGDebugInfo;
|
|
class CGObjCRuntime;
|
|
|
|
/// CodeGenModule - This class organizes the cross-function state that
|
|
/// is used while generating LLVM code.
|
|
class CodeGenModule {
|
|
typedef std::vector< std::pair<llvm::Constant*, int> > CtorList;
|
|
|
|
ASTContext &Context;
|
|
const LangOptions &Features;
|
|
llvm::Module &TheModule;
|
|
const llvm::TargetData &TheTargetData;
|
|
Diagnostic &Diags;
|
|
CodeGenTypes Types;
|
|
CGObjCRuntime* Runtime;
|
|
CGDebugInfo* DebugInfo;
|
|
|
|
llvm::Function *MemCpyFn;
|
|
llvm::Function *MemMoveFn;
|
|
llvm::Function *MemSetFn;
|
|
|
|
/// RuntimeFunctions - List of runtime functions whose names must be
|
|
/// protected from introducing conflicts. These functions should be
|
|
/// created unnamed, we will name them and patch up conflicts when
|
|
/// we release the module.
|
|
std::vector< std::pair<llvm::Function*, std::string> > RuntimeFunctions;
|
|
|
|
/// GlobalDeclMap - Mapping of decl names global variables we have
|
|
/// already emitted. Note that the entries in this map are the
|
|
/// actual globals and therefore may not be of the same type as the
|
|
/// decl, they should be bitcasted on retrieval. Also note that the
|
|
/// globals are keyed on their source name, not the global name
|
|
/// (which may change with attributes such as asm-labels).
|
|
llvm::DenseMap<IdentifierInfo*, llvm::GlobalValue*> GlobalDeclMap;
|
|
|
|
/// Aliases - List of aliases in module. These cannot be emitted
|
|
/// until all the code has been seen, as they reference things by
|
|
/// name instead of directly and may reference forward.
|
|
std::vector<const FunctionDecl*> Aliases;
|
|
|
|
/// StaticDecls - List of static global for which code generation is
|
|
/// delayed. When the translation unit has been fully processed we
|
|
/// will lazily emit definitions for only the decls that were
|
|
/// actually used. This should contain only Function and Var decls,
|
|
/// and only those which actually define something.
|
|
std::vector<const ValueDecl*> StaticDecls;
|
|
|
|
/// GlobalCtors - Store the list of global constructors and their
|
|
/// respective priorities to be emitted when the translation unit is
|
|
/// complete.
|
|
CtorList GlobalCtors;
|
|
|
|
/// GlobalDtors - Store the list of global destructors and their
|
|
/// respective priorities to be emitted when the translation unit is
|
|
/// complete.
|
|
CtorList GlobalDtors;
|
|
|
|
std::vector<llvm::Constant*> Annotations;
|
|
|
|
llvm::StringMap<llvm::Constant*> CFConstantStringMap;
|
|
llvm::StringMap<llvm::Constant*> ConstantStringMap;
|
|
|
|
/// CFConstantStringClassRef - Cached reference to the class for
|
|
/// constant strings. This value has type int * but is actually an
|
|
/// Obj-C class pointer.
|
|
llvm::Constant *CFConstantStringClassRef;
|
|
|
|
std::vector<llvm::Function *> BuiltinFunctions;
|
|
public:
|
|
CodeGenModule(ASTContext &C, const LangOptions &Features, llvm::Module &M,
|
|
const llvm::TargetData &TD, Diagnostic &Diags,
|
|
bool GenerateDebugInfo);
|
|
|
|
~CodeGenModule();
|
|
|
|
/// Release - Finalize LLVM code generation.
|
|
void Release();
|
|
|
|
/// getObjCRuntime() - Return a reference to the configured
|
|
/// Objective-C runtime.
|
|
CGObjCRuntime &getObjCRuntime() {
|
|
assert(Runtime && "No Objective-C runtime has been configured.");
|
|
return *Runtime;
|
|
}
|
|
|
|
/// hasObjCRuntime() - Return true iff an Objective-C runtime has
|
|
/// been configured.
|
|
bool hasObjCRuntime() { return !!Runtime; }
|
|
|
|
CGDebugInfo *getDebugInfo() { return DebugInfo; }
|
|
ASTContext &getContext() const { return Context; }
|
|
const LangOptions &getLangOptions() const { return Features; }
|
|
llvm::Module &getModule() const { return TheModule; }
|
|
CodeGenTypes &getTypes() { return Types; }
|
|
Diagnostic &getDiags() const { return Diags; }
|
|
const llvm::TargetData &getTargetData() const { return TheTargetData; }
|
|
|
|
/// GetAddrOfGlobalVar - Return the llvm::Constant for the address
|
|
/// of the given global variable.
|
|
llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D);
|
|
|
|
/// GetAddrOfFunction - Return the llvm::Constant for the address
|
|
/// of the given function.
|
|
llvm::Constant *GetAddrOfFunction(const FunctionDecl *D);
|
|
|
|
/// GetStringForStringLiteral - Return the appropriate bytes for a
|
|
/// string literal, properly padded to match the literal type. If
|
|
/// only the address of a constant is needed consider using
|
|
/// GetAddrOfConstantStringLiteral.
|
|
std::string GetStringForStringLiteral(const StringLiteral *E);
|
|
|
|
/// GetAddrOfConstantCFString - Return a pointer to a
|
|
/// constant CFString object for the given string.
|
|
llvm::Constant *GetAddrOfConstantCFString(const std::string& str);
|
|
|
|
/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
|
|
/// constant array for the given string literal.
|
|
llvm::Constant *GetAddrOfConstantStringFromLiteral(const StringLiteral *S);
|
|
|
|
/// 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.
|
|
llvm::Constant *GetAddrOfConstantString(const std::string& str);
|
|
|
|
/// GetAddrOfConstantCString - Returns a pointer to a character
|
|
/// array containing the literal and a terminating '\-'
|
|
/// character. The result has pointer to array type.
|
|
llvm::Constant *GetAddrOfConstantCString(const std::string &str);
|
|
|
|
/// getBuiltinLibFunction - Given a builtin id for a function like
|
|
/// "__builtin_fabsf", return a Function* for "fabsf".
|
|
llvm::Function *getBuiltinLibFunction(unsigned BuiltinID);
|
|
|
|
llvm::Function *getMemCpyFn();
|
|
llvm::Function *getMemMoveFn();
|
|
llvm::Function *getMemSetFn();
|
|
llvm::Function *getIntrinsic(unsigned IID, const llvm::Type **Tys = 0,
|
|
unsigned NumTys = 0);
|
|
|
|
/// EmitTopLevelDecl - Emit code for a single top level declaration.
|
|
void EmitTopLevelDecl(Decl *D);
|
|
|
|
void AddAnnotation(llvm::Constant *C) { Annotations.push_back(C); }
|
|
|
|
/// CreateRuntimeFunction - Create a new runtime function whose name
|
|
/// must be protected from collisions.
|
|
llvm::Function *CreateRuntimeFunction(const llvm::FunctionType *Ty,
|
|
const std::string &Name);
|
|
|
|
void UpdateCompletedType(const TagDecl *D);
|
|
llvm::Constant *EmitConstantExpr(const Expr *E, CodeGenFunction *CGF = 0);
|
|
llvm::Constant *EmitAnnotateAttr(llvm::GlobalValue *GV,
|
|
const AnnotateAttr *AA, unsigned LineNo);
|
|
|
|
/// ErrorUnsupported - Print out an error that codegen doesn't support the
|
|
/// specified stmt yet.
|
|
/// \param OmitOnError - If true, then this error should only be
|
|
/// emitted if no other errors have been reported.
|
|
void ErrorUnsupported(const Stmt *S, const char *Type,
|
|
bool OmitOnError=false);
|
|
|
|
/// ErrorUnsupported - Print out an error that codegen doesn't support the
|
|
/// specified decl yet.
|
|
/// \param OmitOnError - If true, then this error should only be
|
|
/// emitted if no other errors have been reported.
|
|
void ErrorUnsupported(const Decl *D, const char *Type,
|
|
bool OmitOnError=false);
|
|
|
|
void SetMethodAttributes(const ObjCMethodDecl *MD,
|
|
llvm::Function *F);
|
|
|
|
void SetFunctionAttributes(const Decl *D,
|
|
const CGFunctionInfo &Info,
|
|
llvm::Function *F);
|
|
|
|
/// ReturnTypeUsesSret - Return true iff the given type uses 'sret'
|
|
/// when used as a return type.
|
|
bool ReturnTypeUsesSret(QualType RetTy);
|
|
|
|
void ConstructAttributeList(const Decl *TargetDecl,
|
|
const ArgTypeIterator begin,
|
|
const ArgTypeIterator end,
|
|
AttributeListType &PAL);
|
|
|
|
private:
|
|
/// SetFunctionAttributesForDefinition - Set function attributes
|
|
/// specific to a function definition.
|
|
/// \param D - The ObjCMethodDecl or FunctionDecl defining \arg F.
|
|
void SetFunctionAttributesForDefinition(const Decl *D,
|
|
llvm::Function *F);
|
|
|
|
void SetFunctionAttributes(const FunctionDecl *FD,
|
|
llvm::Function *F);
|
|
|
|
/// EmitGlobal - Emit code for a singal global function or var
|
|
/// decl. Forward declarations are emitted lazily.
|
|
void EmitGlobal(const ValueDecl *D);
|
|
|
|
void EmitGlobalDefinition(const ValueDecl *D);
|
|
llvm::GlobalValue *EmitForwardFunctionDefinition(const FunctionDecl *D);
|
|
void EmitGlobalFunctionDefinition(const FunctionDecl *D);
|
|
void EmitGlobalVarDefinition(const VarDecl *D);
|
|
void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);
|
|
|
|
// FIXME: Hardcoding priority here is gross.
|
|
void AddGlobalCtor(llvm::Function * Ctor, int Priority=65535);
|
|
void AddGlobalDtor(llvm::Function * Dtor, int Priority=65535);
|
|
|
|
/// EmitCtorList - Generates a global array of functions and
|
|
/// priorities using the given list and name. This array will have
|
|
/// appending linkage and is suitable for use as a LLVM constructor
|
|
/// or destructor array.
|
|
void EmitCtorList(const CtorList &Fns, const char *GlobalName);
|
|
|
|
void EmitAliases(void);
|
|
void EmitAnnotations(void);
|
|
void EmitStatics(void);
|
|
|
|
void BindRuntimeFunctions();
|
|
};
|
|
} // end namespace CodeGen
|
|
} // end namespace clang
|
|
|
|
#endif
|