Emit annotate attributes for function declarations

[jobnoorman]

Summary

This patch makes sure annotation attributes are emitted for declarations. It does this by applying two changes.

First, AddGlobalAnnotations is called from SetFunctionAttributes instead of from EmitGlobalFunctionDefinition. This makes sure these annotations are emitted for declarations but makes code like the following crash:

__attribute__((annotate("foo"))) void foo();
void bar(){foo();}
void foo() {}

I will try to explain what I think happens when this code is compiled:

1. A declaration is created for a function foo having an unspecified number of arguments. This declaration is not emitted but queued for deferred emission. My patch did create an annotation referring to this declaration, though.
2. The call site triggers emission of the declaration of foo.
3. Now foo has zero arguments and the original declaration is replaced by a new function. Since the added annotation still refers to the deleted declaration, this causes a crash.

Therefore, my patch also changes AddGlobalAnnotations to not create the annotation right away. Instead, annotations are created in EmitGlobalAnnotations.

[jobnoorman]

This is the same patch but based on current trunk.

lib/CodeGen/CodeGenModule.h

class CodeGenModule : public CodeGenTypeCache {
   /// priorities to be emitted when the translation unit is complete.
   CtorList GlobalDtors;
 
   /// MangledDeclNames - A map of canonical GlobalDecls to their mangled names.
   llvm::DenseMap<GlobalDecl, StringRef> MangledDeclNames;
   llvm::BumpPtrAllocator MangledNamesAllocator;
   
   /// Global annotations.
-  std::vector<llvm::Constant*> Annotations;
+  typedef std::map<const ValueDecl*, llvm::WeakVH> AnnotationMap;
+  AnnotationMap NeededAnnotations;
 
   /// Map used to get unique annotation strings.
   llvm::StringMap<llvm::Constant*> AnnotationStrings;
 
   llvm::StringMap<llvm::Constant*> CFConstantStringMap;
   llvm::StringMap<llvm::GlobalVariable*> ConstantStringMap;
   llvm::DenseMap<const Decl*, llvm::Constant *> StaticLocalDeclMap;
   llvm::DenseMap<const Decl*, llvm::GlobalVariable*> StaticLocalDeclGuardMap;

lib/CodeGen/CodeGenModule.cpp

if (FD->hasAttr<DLLImportAttr>()) {
     LinkageInfo LV = FD->getLinkageAndVisibility();
     if (LV.getLinkage() == ExternalLinkage && LV.isVisibilityExplicit()) {
       F->setVisibility(GetLLVMVisibility(LV.getVisibility()));
     }
   }
 
   if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
     F->setSection(SA->getName());
+  if (FD->hasAttr<AnnotateAttr>())
+    AddGlobalAnnotations(FD, F);
 }
 
 void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
   assert(!GV->isDeclaration() &&
          "Only globals with definition can force usage.");
   LLVMUsed.push_back(GV);
 }
 
if (isa<llvm::GlobalAlias>(CGRef))
       continue;
 
     // Otherwise, emit the definition and move on to the next one.
     EmitGlobalDefinition(D);
   }
 }
 
 void CodeGenModule::EmitGlobalAnnotations() {
-  if (Annotations.empty())
+  if (NeededAnnotations.empty())
     return;
 
+  std::vector<llvm::Constant*> Annotations;
+
+  for (AnnotationMap::const_iterator it = NeededAnnotations.begin(),
+       end = NeededAnnotations.end(); it != end; ++it) {
+    llvm::Value* V = it->second;
+    if (!V)
+      continue;
+    llvm::GlobalValue* GV = cast<llvm::GlobalValue>(V);
+    const ValueDecl* D = it->first;
+    // Get the struct elements for these annotations.
+    for (specific_attr_iterator<AnnotateAttr>
+        ai = D->specific_attr_begin<AnnotateAttr>(),
+        ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
+      Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
+  }
+
   // Create a new global variable for the ConstantStruct in the Module.
   llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
     Annotations[0]->getType(), Annotations.size()), Annotations);
   llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
     Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
     "llvm.global.annotations");
   gv->setSection(AnnotationSection);
 }
llvm::Constant *Fields[4] = {
     LineNoCst
   };
   return llvm::ConstantStruct::getAnon(Fields);
 }
 
 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
                                          llvm::GlobalValue *GV) {
   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
-  // Get the struct elements for these annotations.
-  for (specific_attr_iterator<AnnotateAttr>
-       ai = D->specific_attr_begin<AnnotateAttr>(),
-       ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
-    Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
+  NeededAnnotations[D] = GV;
 }
 
 bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
   // Never defer when EmitAllDecls is specified.
   if (LangOpts.EmitAllDecls)
     return false;
 
   return !getContext().DeclMustBeEmitted(Global);
void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
 
   SetFunctionDefinitionAttributes(D, Fn);
   SetLLVMFunctionAttributesForDefinition(D, Fn);
 
   if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
     AddGlobalCtor(Fn, CA->getPriority());
   if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
     AddGlobalDtor(Fn, DA->getPriority());
-  if (D->hasAttr<AnnotateAttr>())
-    AddGlobalAnnotations(D, Fn);
 }
 
 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
   const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
   const AliasAttr *AA = D->getAttr<AliasAttr>();
   assert(AA && "Not an alias?");
 
   StringRef MangledName = getMangledName(GD);

test/CodeGen/annotations-forward-declaration-crash.c

+// RUN: %clang_cc1 %s -o - -emit-llvm | FileCheck %s
+
+// CHECK: private unnamed_addr constant [4 x i8] c"foo\00", section "llvm.metadata"
+// CHECK: @llvm.global.annotations = appending global [1 x { i8*, i8*, i8*, i32 }] [{ i8*, i8*, i8*, i32 } { i8* bitcast (void ()* @foo to i8*), i8* getelementptr inbounds ([4 x i8]* {{.+}}, i32 0, i32 0), i8* getelementptr inbounds ([{{.+}} x i8]* {{.+}}, i32 0, i32 0), i32 8 }], section "llvm.metadata"
+
+__attribute__((annotate("foo"))) void foo();
+void bar(){foo();}
+void foo() {}

test/CodeGen/annotations-forward-declaration.c

+// RUN: %clang_cc1 %s -o - -emit-llvm | FileCheck %s
+
+// CHECK: private unnamed_addr constant [4 x i8] c"foo\00", section "llvm.metadata"
+// CHECK: @llvm.global.annotations = appending global [1 x { i8*, i8*, i8*, i32 }] [{ i8*, i8*, i8*, i32 } { i8* bitcast (void ()* @foo to i8*), i8* getelementptr inbounds ([4 x i8]* {{.+}}, i32 0, i32 0), i8* getelementptr inbounds ([{{.+}} x i8]* {{.+}}, i32 0, i32 0), i32 6 }], section "llvm.metadata"
+
+__attribute__((annotate("foo"))) void foo(void);
+void bar(){foo();}