mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-05 10:56:06 +00:00
75ef2f0b45
Make target info available to clang code generator. This is far from complete but this helps clang codegen module make progress. At the moment target triplet and target description strings are hard coded in clang::TargetInfo llvm-svn: 43572
257 lines
9.0 KiB
C++
257 lines
9.0 KiB
C++
//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by Chris Lattner and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This coordinates the per-module state used while generating code.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CodeGenModule.h"
|
|
#include "CodeGenFunction.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/Basic/TargetInfo.h"
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/Intrinsics.h"
|
|
using namespace clang;
|
|
using namespace CodeGen;
|
|
|
|
|
|
CodeGenModule::CodeGenModule(ASTContext &C, llvm::Module &M,
|
|
const llvm::TargetData &TD)
|
|
: Context(C), TheModule(M), TheTargetData(TD),
|
|
Types(C, M, TD), MemCpyFn(0), CFConstantStringClassRef(0) {}
|
|
|
|
llvm::Constant *CodeGenModule::GetAddrOfGlobalDecl(const ValueDecl *D) {
|
|
// See if it is already in the map.
|
|
llvm::Constant *&Entry = GlobalDeclMap[D];
|
|
if (Entry) return Entry;
|
|
|
|
QualType ASTTy = cast<ValueDecl>(D)->getType();
|
|
const llvm::Type *Ty = getTypes().ConvertType(ASTTy);
|
|
if (isa<FunctionDecl>(D)) {
|
|
const llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
|
|
// FIXME: param attributes for sext/zext etc.
|
|
return Entry = new llvm::Function(FTy, llvm::Function::ExternalLinkage,
|
|
D->getName(), &getModule());
|
|
}
|
|
|
|
assert(isa<FileVarDecl>(D) && "Unknown global decl!");
|
|
|
|
return Entry = new llvm::GlobalVariable(Ty, false,
|
|
llvm::GlobalValue::ExternalLinkage,
|
|
0, D->getName(), &getModule());
|
|
}
|
|
|
|
void CodeGenModule::EmitFunction(const FunctionDecl *FD) {
|
|
// If this is not a prototype, emit the body.
|
|
if (FD->getBody())
|
|
CodeGenFunction(*this).GenerateCode(FD);
|
|
}
|
|
|
|
llvm::Constant *CodeGenModule::EmitGlobalInit(const FileVarDecl *D,
|
|
llvm::GlobalVariable *GV) {
|
|
|
|
const InitListExpr *ILE = dyn_cast<InitListExpr>(D->getInit());
|
|
if (!ILE)
|
|
return 0;
|
|
|
|
unsigned NumInitElements = ILE->getNumInits();
|
|
|
|
assert ( ILE->getType()->isArrayType()
|
|
&& "FIXME: Only Array initializers are supported");
|
|
|
|
std::vector<llvm::Constant*> ArrayElts;
|
|
const llvm::PointerType *APType = cast<llvm::PointerType>(GV->getType());
|
|
const llvm::ArrayType *AType =
|
|
cast<llvm::ArrayType>(APType->getElementType());
|
|
|
|
// Copy initializer elements.
|
|
unsigned i = 0;
|
|
for (i = 0; i < NumInitElements; ++i) {
|
|
assert (ILE->getInit(i)->getType()->isIntegerType()
|
|
&& "Only IntegerType global array initializers are supported");
|
|
llvm::APSInt
|
|
Value(static_cast<uint32_t>
|
|
(getContext().getTypeSize(ILE->getInit(i)->getType(),
|
|
SourceLocation())));
|
|
if (ILE->getInit(i)->isIntegerConstantExpr(Value, Context)) {
|
|
llvm::Constant *C = llvm::ConstantInt::get(Value);
|
|
ArrayElts.push_back(C);
|
|
}
|
|
}
|
|
|
|
// Initialize remaining array elements.
|
|
unsigned NumArrayElements = AType->getNumElements();
|
|
const llvm::Type *AElemTy = AType->getElementType();
|
|
for (; i < NumArrayElements; ++i)
|
|
ArrayElts.push_back(llvm::Constant::getNullValue(AElemTy));
|
|
|
|
return llvm::ConstantArray::get(AType, ArrayElts);
|
|
}
|
|
|
|
void CodeGenModule::EmitGlobalVar(const FileVarDecl *D) {
|
|
llvm::GlobalVariable *GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalDecl(D));
|
|
|
|
// If the storage class is external and there is no initializer, just leave it
|
|
// as a declaration.
|
|
if (D->getStorageClass() == VarDecl::Extern && D->getInit() == 0)
|
|
return;
|
|
|
|
// Otherwise, convert the initializer, or use zero if appropriate.
|
|
llvm::Constant *Init = 0;
|
|
if (D->getInit() == 0) {
|
|
Init = llvm::Constant::getNullValue(GV->getType()->getElementType());
|
|
} else if (D->getType()->isIntegerType()) {
|
|
llvm::APSInt Value(static_cast<uint32_t>(
|
|
getContext().getTypeSize(D->getInit()->getType(), SourceLocation())));
|
|
if (D->getInit()->isIntegerConstantExpr(Value, Context))
|
|
Init = llvm::ConstantInt::get(Value);
|
|
}
|
|
|
|
if (!Init)
|
|
Init = EmitGlobalInit(D, GV);
|
|
|
|
assert(Init && "FIXME: Global variable initializers unimp!");
|
|
|
|
GV->setInitializer(Init);
|
|
|
|
// Set the llvm linkage type as appropriate.
|
|
// FIXME: This isn't right. This should handle common linkage and other
|
|
// stuff.
|
|
switch (D->getStorageClass()) {
|
|
case VarDecl::Auto:
|
|
case VarDecl::Register:
|
|
assert(0 && "Can't have auto or register globals");
|
|
case VarDecl::None:
|
|
case VarDecl::Extern:
|
|
// todo: common
|
|
break;
|
|
case VarDecl::Static:
|
|
GV->setLinkage(llvm::GlobalVariable::InternalLinkage);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// EmitGlobalVarDeclarator - Emit all the global vars attached to the specified
|
|
/// declarator chain.
|
|
void CodeGenModule::EmitGlobalVarDeclarator(const FileVarDecl *D) {
|
|
for (; D; D = cast_or_null<FileVarDecl>(D->getNextDeclarator()))
|
|
EmitGlobalVar(D);
|
|
}
|
|
|
|
/// getBuiltinLibFunction
|
|
llvm::Function *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) {
|
|
if (BuiltinFunctions.size() <= BuiltinID)
|
|
BuiltinFunctions.resize(BuiltinID);
|
|
|
|
// Already available?
|
|
llvm::Function *&FunctionSlot = BuiltinFunctions[BuiltinID];
|
|
if (FunctionSlot)
|
|
return FunctionSlot;
|
|
|
|
assert(Context.BuiltinInfo.isLibFunction(BuiltinID) && "isn't a lib fn");
|
|
|
|
// Get the name, skip over the __builtin_ prefix.
|
|
const char *Name = Context.BuiltinInfo.GetName(BuiltinID)+10;
|
|
|
|
// Get the type for the builtin.
|
|
QualType Type = Context.BuiltinInfo.GetBuiltinType(BuiltinID, Context);
|
|
const llvm::FunctionType *Ty =
|
|
cast<llvm::FunctionType>(getTypes().ConvertType(Type));
|
|
|
|
// FIXME: This has a serious problem with code like this:
|
|
// void abs() {}
|
|
// ... __builtin_abs(x);
|
|
// The two versions of abs will collide. The fix is for the builtin to win,
|
|
// and for the existing one to be turned into a constantexpr cast of the
|
|
// builtin. In the case where the existing one is a static function, it
|
|
// should just be renamed.
|
|
if (llvm::Function *Existing = getModule().getFunction(Name)) {
|
|
if (Existing->getFunctionType() == Ty && Existing->hasExternalLinkage())
|
|
return FunctionSlot = Existing;
|
|
assert(Existing == 0 && "FIXME: Name collision");
|
|
}
|
|
|
|
// FIXME: param attributes for sext/zext etc.
|
|
return FunctionSlot = new llvm::Function(Ty, llvm::Function::ExternalLinkage,
|
|
Name, &getModule());
|
|
}
|
|
|
|
|
|
llvm::Function *CodeGenModule::getMemCpyFn() {
|
|
if (MemCpyFn) return MemCpyFn;
|
|
llvm::Intrinsic::ID IID;
|
|
uint64_t Size; unsigned Align;
|
|
Context.Target.getPointerInfo(Size, Align, SourceLocation());
|
|
switch (Size) {
|
|
default: assert(0 && "Unknown ptr width");
|
|
case 32: IID = llvm::Intrinsic::memcpy_i32; break;
|
|
case 64: IID = llvm::Intrinsic::memcpy_i64; break;
|
|
}
|
|
return MemCpyFn = llvm::Intrinsic::getDeclaration(&TheModule, IID);
|
|
}
|
|
|
|
llvm::Constant *CodeGenModule::
|
|
GetAddrOfConstantCFString(const std::string &str) {
|
|
llvm::StringMapEntry<llvm::Constant *> &Entry =
|
|
CFConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
|
|
|
|
if (Entry.getValue())
|
|
return Entry.getValue();
|
|
|
|
std::vector<llvm::Constant*> Fields;
|
|
|
|
if (!CFConstantStringClassRef) {
|
|
const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
|
|
Ty = llvm::ArrayType::get(Ty, 0);
|
|
|
|
CFConstantStringClassRef =
|
|
new llvm::GlobalVariable(Ty, false,
|
|
llvm::GlobalVariable::ExternalLinkage, 0,
|
|
"__CFConstantStringClassReference",
|
|
&getModule());
|
|
}
|
|
|
|
// Class pointer.
|
|
llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
|
|
llvm::Constant *Zeros[] = { Zero, Zero };
|
|
llvm::Constant *C =
|
|
llvm::ConstantExpr::getGetElementPtr(CFConstantStringClassRef, Zeros, 2);
|
|
Fields.push_back(C);
|
|
|
|
// Flags.
|
|
const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
|
|
Fields.push_back(llvm::ConstantInt::get(Ty, 1992));
|
|
|
|
// String pointer.
|
|
C = llvm::ConstantArray::get(str);
|
|
C = new llvm::GlobalVariable(C->getType(), true,
|
|
llvm::GlobalValue::InternalLinkage,
|
|
C, ".str", &getModule());
|
|
|
|
C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2);
|
|
Fields.push_back(C);
|
|
|
|
// String length.
|
|
Ty = getTypes().ConvertType(getContext().LongTy);
|
|
Fields.push_back(llvm::ConstantInt::get(Ty, str.length()));
|
|
|
|
// The struct.
|
|
Ty = getTypes().ConvertType(getContext().getCFConstantStringType());
|
|
C = llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Fields);
|
|
C = new llvm::GlobalVariable(C->getType(), true,
|
|
llvm::GlobalVariable::InternalLinkage,
|
|
C, "", &getModule());
|
|
|
|
Entry.setValue(C);
|
|
return C;
|
|
}
|