Fix a couple of bugs, add some new cool stuff.
1. Fix a todo in Parser::ParseTag, to recover better. On code like
that in test/Sema/decl-invalid.c it causes us to return a single
error instead of multiple.
2. Fix an error in Sema::ParseDeclarator, where it would crash if the
declarator didn't have an identifier. Instead, diagnose the problem.
3. Start adding infrastructure to track the range of locations covered
by a declspec or declarator. This is mostly implemented for declspec,
but could be improved, it is missing for declarator.
Thanks to Neil for pointing out this crash.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@40482 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/CodeGen/CodeGenModule.cpp b/CodeGen/CodeGenModule.cpp
new file mode 100644
index 0000000..a1a498b
--- /dev/null
+++ b/CodeGen/CodeGenModule.cpp
@@ -0,0 +1,115 @@
+//===--- 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/Function.h"
+#include "llvm/GlobalVariable.h"
+#include "llvm/Intrinsics.h"
+using namespace clang;
+using namespace CodeGen;
+
+
+CodeGenModule::CodeGenModule(ASTContext &C, llvm::Module &M)
+ : Context(C), TheModule(M), Types(C) {}
+
+llvm::Constant *CodeGenModule::GetAddrOfGlobalDecl(const Decl *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);
+}
+
+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(getContext().getTypeSize(D->getInit()->getType(),
+ SourceLocation()));
+ if (D->getInit()->isIntegerConstantExpr(Value, Context))
+ Init = llvm::ConstantInt::get(Value);
+ }
+ 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);
+}
+
+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);
+}