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.

llvm-svn: 129065

1 files changed, 49 insertions, 1 deletions

diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 34f594e..fe8462b 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/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);
 }