diff options
author | John McCall <rjmccall@apple.com> | 2011-04-07 08:22:57 +0000 |
---|---|---|
committer | John McCall <rjmccall@apple.com> | 2011-04-07 08:22:57 +0000 |
commit | 1de4d4e8cb2e9c88809fea8092bc6e835a5473d2 (patch) | |
tree | 882a7f7c98e0dd8f015d2d7364c941026ecd19c2 /lib/CodeGen/CodeGenModule.cpp | |
parent | 1a7f7526b7fd817e3f49c210302d189eff981b5e (diff) |
Basic, untested implementation for an "unknown any" type requested by LLDB.
The idea is that you can create a VarDecl with an unknown type, or a
FunctionDecl with an unknown return type, and it will still be valid to
access that object as long as you explicitly cast it at every use. I'm
still going back and forth about how I want to test this effectively, but
I wanted to go ahead and provide a skeletal implementation for the LLDB
folks' benefit and because it also improves some diagnostic goodness for
placeholder expressions.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@129065 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/CodeGen/CodeGenModule.cpp')
-rw-r--r-- | lib/CodeGen/CodeGenModule.cpp | 50 |
1 files changed, 49 insertions, 1 deletions
diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp index 34f594ecaa..fe8462bc7c 100644 --- a/lib/CodeGen/CodeGenModule.cpp +++ b/lib/CodeGen/CodeGenModule.cpp @@ -1072,12 +1072,60 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, return GetOrCreateLLVMGlobal(MangledName, PTy, D); } +/// getAddrOfUnknownAnyDecl - Return an llvm::Constant for the address +/// of a global which was declared with unknown type. It is possible +/// for a VarDecl to end up getting resolved to have function type, +/// which complicates this substantially; on the other hand, these are +/// always external references, which does simplify the logic a lot. +llvm::Constant * +CodeGenModule::getAddrOfUnknownAnyDecl(const NamedDecl *decl, QualType type) { + GlobalDecl global; + + // FunctionDecls will always end up with function types, but + // VarDecls can end up with them too. + if (isa<FunctionDecl>(decl)) + global = GlobalDecl(cast<FunctionDecl>(decl)); + else + global = GlobalDecl(cast<VarDecl>(decl)); + llvm::StringRef mangledName = getMangledName(global); + + const llvm::Type *ty = getTypes().ConvertTypeForMem(type); + const llvm::PointerType *pty = + llvm::PointerType::get(ty, getContext().getTargetAddressSpace(type)); + + + // Check for an existing global value with this name. + llvm::GlobalValue *entry = GetGlobalValue(mangledName); + if (entry) + return llvm::ConstantExpr::getBitCast(entry, pty); + + // If we're creating something with function type, go ahead and + // create a function. + if (const llvm::FunctionType *fnty = dyn_cast<llvm::FunctionType>(ty)) { + llvm::Function *fn = llvm::Function::Create(fnty, + llvm::Function::ExternalLinkage, + mangledName, &getModule()); + return fn; + + // Otherwise, make a global variable. + } else { + llvm::GlobalVariable *var + = new llvm::GlobalVariable(getModule(), ty, false, + llvm::GlobalValue::ExternalLinkage, + 0, mangledName, 0, + false, pty->getAddressSpace()); + if (isa<VarDecl>(decl) && cast<VarDecl>(decl)->isThreadSpecified()) + var->setThreadLocal(true); + return var; + } +} + /// CreateRuntimeVariable - Create a new runtime global variable with the /// specified type and name. llvm::Constant * CodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty, llvm::StringRef Name) { - return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0, + return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0, true); } |