[Annotation] Allows annotation to carry some additional constant arguments.

[Tyker]

Summary

This allows using annotation in a much more contexts than it currently has.
especially when annotation with template or constexpr.

[aaron.ballman]

clang/lib/CodeGen/CodeGenModule.cpp

2338

Exprs.empty() would be more concise.

2354–2356

You can return the expression directly, which removes a somewhat questionable use of auto.

clang/lib/Sema/SemaDeclAttr.cpp

3683

Just curious, but is the ?: actually necessary? I would have assumed that an empty ArrayRef would return nullptr from data().

3688

auto * since the type is spelled out in the initialization.

Also, I think this is unsafe -- it looks like during template instantiation, any arguments that have a substitution failure will come through as nullptr, and this will crash.

What should happen on template instantiation failure for these arguments? I think the whole attribute should probably be dropped with appropriate diagnostics rather than emitting a partial attribute, but perhaps you have different ideas.

3691

This is unfortunate -- you should be passing in the ParsedAttr object so that the diagnostic engine can take care of properly formatting the diagnostic. For instance, this will incorrectly name the attribute 'annotate' instead of clang::annotate' if that's how the user spelled the attribute. I don't recall whether it will work on an AttributeCommonInfo though.

3694

E->getDependence() smells a bit fishy because this will early bail on any kind of dependency, including an error dependency. Do you mean to care only about type and/or value dependence here?

3704–3705

Under what circumstances would we want the constant expressions to be lvalues? I would have guessed you would want to call Expr::EvaluateAsConstantExpr() instead of either of these.

3730

Hmm, I think you should assert that you never get an identifier at this point -- the parser should be treating all of these as expressions and not simple identifiers.

clang/test/SemaCXX/attr-annotate.cpp

1

Do you mean to emit llvm here? I think that should probably be -fsyntax-only

[Tyker]

addressed comments.

[Tyker]

clang/lib/Sema/SemaDeclAttr.cpp

3683

maybe it was(in a previous version of the code) but not anymore since there is always at least one argument.

3688

When template instantation fails nullptr is put in the Expr arguments and AddAnnotationAttr will emit a diagnostic and not associate the attribut to the declaration.

3704–3705

Expr::EvaluateAsConstantExpr will evaluate expression in there value category.
this can be quite surprising in some situations like:

const int g_i = 0;
[[clang::annotate("test", g_i)]] void t() {} // annotation carries a pointer/reference on g_i
[[clang::annotate("test", (int)g_i)]] void t1() {} // annotation carries the value 0
[[clang::annotate("test", g_i + 0)]] void t1() {} // annotation carries the value 0

with EvaluateAsRValue in all of the cases above the annotation will carry the value 0.

optionally we could wrap expression with an LValue to RValue cast and call EvaluateAsConstantExpr this should also work.

clang/test/SemaCXX/attr-annotate.cpp

1

The reason i put an -emit-llvm is to also test the asserts in IRgen on more complex code.

[jdoerfert]

(Drive By: This is cool)

[aaron.ballman]

In D88645#2321980, @jdoerfert wrote:

(Drive By: This is cool)

I didn't say this before, but yeah, I agree -- this is really quite neat, thank you for working on it!

clang/include/clang/Sema/ParsedAttr.h

1077

as only argument -> as its only argument

1081

The comment can probably be re-flowed so "ambiguity" is on the preceding line?

clang/lib/Sema/SemaDeclAttr.cpp

3688

Great, thank you for the fix!

3693

What is the rationale for bailing out when the constant expression has an APValue result?

3704–3705

Thank you for the explanation. I think wrapping with an lvalue to rvalue conversion may make more sense -- EvaluateAsRValue() tries really hard to get an rvalue out of something even if the standard says that's not okay. It'll automatically apply the lvalue to rvalue conversion if appropriate, but it'll also do more than that (such as evaluating side effects).

clang/test/SemaCXX/attr-annotate.cpp

1

Tests in sema shouldn't typically run codegen, so I'd rather this was -fsyntax-only and test the assertions more explicitly in a codegen-specific test.

[keryell]

Great feature for all the weird pieces of hardware all around the world! :-)

clang/lib/CodeGen/CodeGenFunction.cpp

2229–2233

Curious reindenting with mix-and-match of spaces & tabulations?

clang/lib/CodeGen/CodeGenModule.cpp

2387–2391

Same curious reindenting.

clang/lib/Sema/SemaDeclAttr.cpp

3688

Perhaps a few comments on this clarification would be useful in the code for the plain mortals...

3704–3705

This needs some motivating comments and explanations in the code.
Also the variations on g_i annotation above are quite interesting and should appear in the unit tests. I am unsure they are now.
Perhaps more interesting with other values than 0 in the example. :-)
I guess we can still use [[clang::annotate("test", &g_i)]] void t() {} to have a pointer on g_i and (int&)g_i for reference? To add to the unit tests if not already checked.

[Tyker]

addressed comments.

[keryell]

@erichkeane @alexandre.isoard @Naghasan: any feedback in the context of SYCL & HLS C++ about this feature extension?

[Tyker]

clang/lib/CodeGen/CodeGenFunction.cpp

2229–2233

these are not tabs i believe this is just how phabricator shows indentation changes.

clang/lib/Sema/SemaDeclAttr.cpp

3693

the intent was that during nested template instantiation arguement will be evaluated as soon as they are neither value nor type dependent and the result will be stored in the ConstantExpr. if an arguement has already been evaluated in a previous instantiation we don't want to evaluate it again.
but because of SubstExpr ConstantExpr are getting removed so it removed it.

3704–3705

i changed to use EvaluateAsConstantExpr + LValueToRvalue cast.

This needs some motivating comments and explanations in the code.
Also the variations on g_i annotation above are quite interesting and should appear in the unit tests. I am unsure they are now.

they are tested not as expressively as above but they are tested.

Perhaps more interesting with other values than 0 in the example. :-)
I guess we can still use [[clang::annotate("test", &g_i)]] void t() {} to have a pointer on g_i

yes this is how it is working.

(int&)g_i for reference? To add to the unit tests if not already checked.

(int&)g_i has the salve value category and same type as g_i it just has a noop cast around it.
pointer an reference are indistinguishable in an APValue the only difference is the c++ type of what they represent.
and they are of course lowered to the same thing. so we only need the pointer case.

[keryell]

clang/lib/Sema/SemaDeclAttr.cpp

3704–3705

I see. Thanks for the clarification.

[aaron.ballman]

clang/lib/Sema/SemaDeclAttr.cpp

3693

Ah, thank you for the explanation and change.

3696–3697

Should this move up above the point where we're checking whether the expression has an array type?

3706

I'm surprised that the presence of notes alone would mean the attribute argument has an error and should be skipped. Are there circumstances under which Result is true but Notes is non-empty?

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

195

No else after a return.

clang/test/SemaCXX/attr-annotate.cpp

97

Some more tests for various constant expression situations that may be weird:

int n = 10;
int vla[n];

[[clang::annotate("vlas are awful", sizeof(vla[++n]))] int i = 0; // reject, the sizeof is not unevaluated

[[clang::annotate("_Generic selection expression should be fine", _Generic(n, int : 0, default : 1))]] int j = 0; // second arg should resolve to 0 fine

void designator();
[[clang::annotate("function designators?", designator)]] int k = 0; // Should work?

[Tyker]

addressed comments.

[Tyker]

clang/lib/Sema/SemaDeclAttr.cpp

3706

AFAIK
Result means the expression can be folded to a constant.
Note.empty() means the expression is a valid constant expression in the current language mode.

the difference is observable in code like:

constexpr int foldable_but_invalid() {
  int *A = new int(0);
  return *A;
}

[[clang::annotate("", foldable_but_invalid())]] void f1() {}

foldable_but_invalid retruns a constant but any constant evaluation of this function is invalid because it doesn't desallocate A.
with !Notes.empty() this fails, without it no errors occurs.

i think it is desirable that attributes don't diverge from the language mode.
I added a test for this.

clang/test/SemaCXX/attr-annotate.cpp

97

added CK_FunctionToPointerDecay cast when needed
the rest was working as is.

[aaron.ballman]

LGTM aside from a request for a comment to be added. Thank you!

clang/lib/Sema/SemaDeclAttr.cpp

3706

Ah, thank you for explaining that! Can you add a comment to the code to make that clear for others who may run across it?

[Tyker]

In D88645#2347050, @aaron.ballman wrote:

LGTM aside from a request for a comment to be added. Thank you!

do you mean an RFC on llvm-dev/cfe-dev ?

[erichkeane]

In D88645#2347725, @Tyker wrote:

In D88645#2347050, @aaron.ballman wrote:

LGTM aside from a request for a comment to be added. Thank you!

do you mean an RFC on llvm-dev/cfe-dev ?

He means this review comment he made requesting a comment in the code: >Ah, thank you for explaining that! Can you add a comment to the code to make that clear for others who may run across it?

[aaron.ballman]

In D88645#2347725, @Tyker wrote:

In D88645#2347050, @aaron.ballman wrote:

LGTM aside from a request for a comment to be added. Thank you!

do you mean an RFC on llvm-dev/cfe-dev ?

Oh gosh no! I just meant I was asking for a comment to be added in SemaDeclAttr.td before you commit. Sorry for the confusion! :-)

[Tyker]

In D88645#2347731, @aaron.ballman wrote:

In D88645#2347725, @Tyker wrote:

In D88645#2347050, @aaron.ballman wrote:

LGTM aside from a request for a comment to be added. Thank you!

do you mean an RFC on llvm-dev/cfe-dev ?

Oh gosh no! I just meant I was asking for a comment to be added in SemaDeclAttr.td before you commit. Sorry for the confusion! :-)

Thank for the review.

[thakis]

Looks like this broke tests: http://45.33.8.238/linux/31159/step_12.txt

Please take a look, and revert for now if it takes a while to fix.

[john.brawn]

This also causes the AnnotateFunctions example to no longer build:

/home/jb/work/llvm-project/clang/examples/AnnotateFunctions/AnnotateFunctions.cpp: In member function ‘virtual bool {anonymous}::AnnotateFunctionsConsumer::HandleTopLevelDecl(clang::DeclGroupRef)’:
/home/jb/work/llvm-project/clang/examples/AnnotateFunctions/AnnotateFunctions.cpp:36:70: error: no matching function for call to ‘clang::AnnotateAttr::CreateImplicit(clang::ASTContext&, const char [19])’
                                                  "example_annotation"));
                                                                      ^

it looks like it needs to be adjusted for the extra variadic arg that the attribute now has.

[Tyker]

In D88645#2353152, @thakis wrote:

Looks like this broke tests: http://45.33.8.238/linux/31159/step_12.txt

Please take a look, and revert for now if it takes a while to fix.

this is fixed by 4afa077899b

In D88645#2354196, @john.brawn wrote:

This also causes the AnnotateFunctions example to no longer build:

/home/jb/work/llvm-project/clang/examples/AnnotateFunctions/AnnotateFunctions.cpp: In member function ‘virtual bool {anonymous}::AnnotateFunctionsConsumer::HandleTopLevelDecl(clang::DeclGroupRef)’:
/home/jb/work/llvm-project/clang/examples/AnnotateFunctions/AnnotateFunctions.cpp:36:70: error: no matching function for call to ‘clang::AnnotateAttr::CreateImplicit(clang::ASTContext&, const char [19])’
                                                  "example_annotation"));
                                                                      ^

it looks like it needs to be adjusted for the extra variadic arg that the attribute now has.

this is fixed by 2618247c61c

[vhscampos]

@Tyker This is causing another build failure in another example:

[2858/4034] Building CXX object tools/clang/examples/Attribute/CMakeFiles/Attribute.dir/Attribute.cpp.o
/Attribute.cpp:73:16: error: no matching function for call to 'Create'
    D->addAttr(AnnotateAttr::Create(S.Context, "example(" + Str.str() + ")",
               ^~~~~~~~~~~~~~~~~~~~
tools/clang/include/clang/AST/Attrs.inc:885:24: note: candidate function not viable: requires at least 4 arguments, but 3 were provided
  static AnnotateAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo = {SourceRange{}});
                       ^
tools/clang/include/clang/AST/Attrs.inc:887:24: note: candidate function not viable: requires 6 arguments, but 3 were provided
  static AnnotateAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, SourceRange Range, AttributeCommonInfo::Syntax Syntax);
                       ^
1 error generated.

Please build with -DCLANG_BUILD_EXAMPLES=ON to check if all bugs are gone.

[jdoerfert]

The lang ref needs to reflect the new type https://llvm.org/docs/LangRef.html#llvm-var-annotation-intrinsic
Please also review the auto-upgrade patch for this: https://reviews.llvm.org/D95993

[jdoerfert]

status change, see last message

[Tyker]

I added the changes to the langref in https://reviews.llvm.org/D96646

clang/include/clang/Basic/Attr.td

def AnalyzerNoReturn : InheritableAttr {
   // analyzer?
   let Spellings = [GNU<"analyzer_noreturn">];
   // TODO: Add subject list.
   let Documentation = [Undocumented];
 }
 
 def Annotate : InheritableParamAttr {
   let Spellings = [Clang<"annotate">];
-  let Args = [StringArgument<"Annotation">];
+  let Args = [StringArgument<"Annotation">, VariadicExprArgument<"Args">];
   // Ensure that the annotate attribute can be used with
   // '#pragma clang attribute' even though it has no subject list.
   let PragmaAttributeSupport = 1;
   let Documentation = [Undocumented];
 }
 
 def ARMInterrupt : InheritableAttr, TargetSpecificAttr<TargetARM> {
   // NOTE: If you add any additional spellings, MSP430Interrupt's,

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_alignas_mismatch : Error<
   "redeclaration has different alignment requirement (%1 vs %0)">;
 def err_alignas_underaligned : Error<
   "requested alignment is less than minimum alignment of %1 for type %0">;
 def err_attribute_sizeless_type : Error<
   "%0 attribute cannot be applied to sizeless type %1">;
 def err_attribute_argument_n_type : Error<
   "%0 attribute requires parameter %1 to be %select{int or bool|an integer "
-  "constant|a string|an identifier}2">;
+  "constant|a string|an identifier|a constant expression}2">;
 def err_attribute_argument_type : Error<
   "%0 attribute requires %select{int or bool|an integer "
   "constant|a string|an identifier}1">;
 def err_attribute_argument_out_of_range : Error<
   "%0 attribute requires integer constant between %1 and %2 inclusive">;
 def err_init_priority_object_attr : Error<
   "can only use 'init_priority' attribute on file-scope definitions "
   "of objects of class type">;

clang/include/clang/Sema/ParsedAttr.h

 };
 
 /// These constants match the enumerated choices of
 /// err_attribute_argument_n_type and err_attribute_argument_type.
 enum AttributeArgumentNType {
   AANT_ArgumentIntOrBool,
   AANT_ArgumentIntegerConstant,
   AANT_ArgumentString,
-  AANT_ArgumentIdentifier
+  AANT_ArgumentIdentifier,
+  AANT_ArgumentConstantExpr,
 };
 
 /// These constants match the enumerated choices of
 /// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type.
 enum AttributeDeclKind {
   ExpectedFunction,
   ExpectedUnion,
   ExpectedVariableOrFunction,

 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                            const ParsedAttr *At) {
   PD.AddTaggedVal(reinterpret_cast<intptr_t>(At->getAttrName()),
                   DiagnosticsEngine::ak_identifierinfo);
   return PD;
 }
 
 } // namespace clang
 
 #endif // LLVM_CLANG_SEMA_ATTRIBUTELIST_H

clang/include/clang/Sema/Sema.h

   /// declaration.
   void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI,
                          Expr *ParamExpr);
 
   /// AddAlignValueAttr - Adds an align_value attribute to a particular
   /// declaration.
   void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);
 
+  /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.
+  void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,
+                         StringRef Annot, MutableArrayRef<Expr *> Args);
+
   /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
   /// declaration.
   void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI,
                            Expr *MaxThreads, Expr *MinBlocks);
 
   /// AddModeAttr - Adds a mode attribute to a particular declaration.
   void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name,
                    bool InInstantiation = false);

clang/lib/CodeGen/CGBuiltin.cpp

case Builtin::BI__builtin_annotation: {
     llvm::Value *AnnVal = EmitScalarExpr(E->getArg(0));
     llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::annotation,
                                       AnnVal->getType());
 
     // Get the annotation string, go through casts. Sema requires this to be a
     // non-wide string literal, potentially casted, so the cast<> is safe.
     const Expr *AnnotationStrExpr = E->getArg(1)->IgnoreParenCasts();
     StringRef Str = cast<StringLiteral>(AnnotationStrExpr)->getString();
-    return RValue::get(EmitAnnotationCall(F, AnnVal, Str, E->getExprLoc()));
+    return RValue::get(
+        EmitAnnotationCall(F, AnnVal, Str, E->getExprLoc(), nullptr));
   }
   case Builtin::BI__builtin_addcb:
   case Builtin::BI__builtin_addcs:
   case Builtin::BI__builtin_addc:
   case Builtin::BI__builtin_addcl:
   case Builtin::BI__builtin_addcll:
   case Builtin::BI__builtin_subcb:
   case Builtin::BI__builtin_subcs:

clang/lib/CodeGen/CodeGenFunction.h

public:
   //===--------------------------------------------------------------------===//
   //                         Annotations Emission
   //===--------------------------------------------------------------------===//
 
   /// Emit an annotation call (intrinsic).
   llvm::Value *EmitAnnotationCall(llvm::Function *AnnotationFn,
                                   llvm::Value *AnnotatedVal,
                                   StringRef AnnotationStr,
-                                  SourceLocation Location);
+                                  SourceLocation Location,
+                                  const AnnotateAttr *Attr);
 
   /// Emit local annotations for the local variable V, declared by D.
   void EmitVarAnnotations(const VarDecl *D, llvm::Value *V);
 
   /// Emit field annotations for the given field & value. Returns the
   /// annotation result.
   Address EmitFieldAnnotations(const FieldDecl *D, Address V);
 

clang/lib/CodeGen/CodeGenFunction.cpp

void CodeGenFunction::emitAlignmentAssumption(llvm::Value *PtrValue,
 
   emitAlignmentAssumption(PtrValue, Ty, Loc, AssumptionLoc, Alignment,
                           OffsetValue);
 }
 
 llvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Function *AnnotationFn,
                                                  llvm::Value *AnnotatedVal,
                                                  StringRef AnnotationStr,
-                                                 SourceLocation Location) {
-  llvm::Value *Args[4] = {
+                                                 SourceLocation Location,
+                                                 const AnnotateAttr *Attr) {
+  SmallVector<llvm::Value *, 5> Args = {
       AnnotatedVal,
       Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy),
       Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy),
-    CGM.EmitAnnotationLineNo(Location)
+      CGM.EmitAnnotationLineNo(Location),
   };
+  if (Attr)
+    Args.push_back(CGM.EmitAnnotationArgs(Attr));
   return Builder.CreateCall(AnnotationFn, Args);
 }
 
 void CodeGenFunction::EmitVarAnnotations(const VarDecl *D, llvm::Value *V) {
   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
   // FIXME We create a new bitcast for every annotation because that's what
   // llvm-gcc was doing.
   for (const auto *I : D->specific_attrs<AnnotateAttr>())
     EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation),
                        Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
-                       I->getAnnotation(), D->getLocation());
+                       I->getAnnotation(), D->getLocation(), I);
 }
 
 Address CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D,
                                               Address Addr) {
   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
   llvm::Value *V = Addr.getPointer();
   llvm::Type *VTy = V->getType();
   llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
                                     CGM.Int8PtrTy);
 
   for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
     // FIXME Always emit the cast inst so we can differentiate between
     // annotation on the first field of a struct and annotation on the struct
     // itself.
     if (VTy != CGM.Int8PtrTy)
       V = Builder.CreateBitCast(V, CGM.Int8PtrTy);
-    V = EmitAnnotationCall(F, V, I->getAnnotation(), D->getLocation());
+    V = EmitAnnotationCall(F, V, I->getAnnotation(), D->getLocation(), I);
     V = Builder.CreateBitCast(V, VTy);
   }
 
   return Address(V, Addr.getAlignment());
 }
 
 CodeGenFunction::CGCapturedStmtInfo::~CGCapturedStmtInfo() { }
 

clang/lib/CodeGen/CodeGenModule.h

llvm::StringMap<std::pair<GlobalDecl, unsigned>, llvm::BumpPtrAllocator>
       CPUSpecificManglings;
 
   /// Global annotations.
   std::vector<llvm::Constant*> Annotations;
 
   /// Map used to get unique annotation strings.
   llvm::StringMap<llvm::Constant*> AnnotationStrings;
 
+  /// Used for uniquing of annotation arguments.
+  llvm::DenseMap<unsigned, llvm::Constant *> AnnotationArgs;
+
   llvm::StringMap<llvm::GlobalVariable *> CFConstantStringMap;
 
   llvm::DenseMap<llvm::Constant *, llvm::GlobalVariable *> ConstantStringMap;
   llvm::DenseMap<const Decl*, llvm::Constant *> StaticLocalDeclMap;
   llvm::DenseMap<const Decl*, llvm::GlobalVariable*> StaticLocalDeclGuardMap;
   llvm::DenseMap<const Expr*, llvm::Constant *> MaterializedGlobalTemporaryMap;
 
   llvm::DenseMap<QualType, llvm::Constant *> AtomicSetterHelperFnMap;
public:
   llvm::Constant *EmitAnnotationString(StringRef Str);
 
   /// Emit the annotation's translation unit.
   llvm::Constant *EmitAnnotationUnit(SourceLocation Loc);
 
   /// Emit the annotation line number.
   llvm::Constant *EmitAnnotationLineNo(SourceLocation L);
 
+  /// Emit additional args of the annotation.
+  llvm::Constant *EmitAnnotationArgs(const AnnotateAttr *Attr);
+
   /// Generate the llvm::ConstantStruct which contains the annotation
   /// information for a given GlobalValue. The annotation struct is
   /// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the
   /// GlobalValue being annotated. The second field is the constant string
   /// created from the AnnotateAttr's annotation. The third field is a constant
   /// string containing the name of the translation unit. The fourth field is
   /// the line number in the file of the annotated value declaration.
   llvm::Constant *EmitAnnotateAttr(llvm::GlobalValue *GV,

clang/lib/CodeGen/CodeGenModule.cpp

 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
   SourceManager &SM = getContext().getSourceManager();
   PresumedLoc PLoc = SM.getPresumedLoc(L);
   unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
     SM.getExpansionLineNumber(L);
   return llvm::ConstantInt::get(Int32Ty, LineNo);
 }
 
+llvm::Constant *CodeGenModule::EmitAnnotationArgs(const AnnotateAttr *Attr) {
+  ArrayRef<Expr *> Exprs = {Attr->args_begin(), Attr->args_size()};
+  Exprs = Exprs.drop_front();
+  if (Exprs.size() == 0)
+    return llvm::ConstantPointerNull::get(Int8PtrTy);
+
+  llvm::FoldingSetNodeID ID;
+  for (Expr *E : Exprs) {
+    ID.Add(cast<clang::ConstantExpr>(E)->getAPValueResult());
+  }
+  llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
+  if (Lookup)
+    return Lookup;
+
+  llvm::SmallVector<llvm::Constant *, 4> LLVMArgs;
+  LLVMArgs.reserve(Exprs.size());
+  ConstantEmitter ConstEmiter(*this);
+  llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](const Expr *E) {
+    const auto *CE = cast<clang::ConstantExpr>(E);
+    auto *Constant = ConstEmiter.emitAbstract(
+        CE->getBeginLoc(), CE->getAPValueResult(), CE->getType());
+    return Constant;
+  });
+  auto *Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
+  auto *GV = new llvm::GlobalVariable(getModule(), Struct->getType(), true,
+                                      llvm::GlobalValue::PrivateLinkage, Struct,
+                                      ".args");
+  GV->setSection(AnnotationSection);
+  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
+  auto *Bitcasted = llvm::ConstantExpr::getBitCast(GV, Int8PtrTy);
+
+  Lookup = Bitcasted;
+  return Bitcasted;
+}
+
 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
                                                 const AnnotateAttr *AA,
                                                 SourceLocation L) {
   // Get the globals for file name, annotation, and the line number.
   llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
                  *UnitGV = EmitAnnotationUnit(L),
-                 *LineNoCst = EmitAnnotationLineNo(L);
+                 *LineNoCst = EmitAnnotationLineNo(L),
+                 *Args = EmitAnnotationArgs(AA);
 
   llvm::Constant *ASZeroGV = GV;
   if (GV->getAddressSpace() != 0) {
     ASZeroGV = llvm::ConstantExpr::getAddrSpaceCast(
                    GV, GV->getValueType()->getPointerTo(0));
   }
 
   // Create the ConstantStruct for the global annotation.
-  llvm::Constant *Fields[4] = {
+  llvm::Constant *Fields[] = {
       llvm::ConstantExpr::getBitCast(ASZeroGV, Int8PtrTy),
       llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
       llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
-    LineNoCst
+      LineNoCst,
+      Args,
   };
   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.

clang/lib/Sema/SemaDeclAttr.cpp

if (S.Context.getTypeSize(FieldType) != FirstSize ||
           << isSize << FirstBits;
       return;
     }
   }
 
   RD->addAttr(::new (S.Context) TransparentUnionAttr(S.Context, AL));
 }
 
+void Sema::AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,
+                             StringRef Str, MutableArrayRef<Expr *> Args) {
+  auto *Attr =
+      AnnotateAttr::Create(Context, Str, Args.empty() ? nullptr : Args.data(),
+                           Args.size(), CI.getRange(), CI.getSyntax());
+  llvm::SmallVector<PartialDiagnosticAt, 8> Notes;
+  for (unsigned Idx = 1; Idx < Attr->args_size(); Idx++) {
+    Expr *&E = Attr->args_begin()[Idx];
+    ConstantExpr *CE = dyn_cast<ConstantExpr>(E);
+    if (!E) {
+      Diag(CI.getLoc(), diag::err_attribute_argument_n_type)
+          << "'annotate'" << Idx << AANT_ArgumentConstantExpr;
+      return;
+    }
+    if (E->getDependence() || (CE && CE->hasAPValueResult()))
+      continue;
+    Expr::EvalResult Eval;
+    Notes.clear();
+    Eval.Diag = &Notes;
+
+    bool Result;
+
+    if (!E->getType()->isArrayType()) // To properly deal with string literals.
+      Result = E->EvaluateAsRValue(Eval, Context, true);
+    else
+      Result = E->EvaluateAsLValue(Eval, Context, true);
+
+    if (!Result || !Notes.empty()) {
+      Diag(E->getBeginLoc(), diag::err_attribute_argument_n_type)
+          << "'annotate'" << Idx << AANT_ArgumentConstantExpr;
+      for (auto &Note : Notes)
+        Diag(Note.first, Note.second);
+      return;
+    }
+    assert(Eval.Val.hasValue());
+    E = ConstantExpr::Create(Context, E, Eval.Val);
+  }
+  D->addAttr(Attr);
+}
+
 static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
-  // Make sure that there is a string literal as the annotation's single
+  // Make sure that there is a string literal as the annotation's first
   // argument.
   StringRef Str;
   if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
     return;
 
-  // Don't duplicate annotations that are already set.
-  for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
-    if (I->getAnnotation() == Str)
-      return;
+  llvm::SmallVector<Expr *, 4> Args;
+  Args.reserve(AL.getNumArgs());
+  for (unsigned Idx = 0; Idx < AL.getNumArgs(); Idx++) {
+    if (AL.isArgIdent(Idx))
+      Args.push_back(nullptr);
+    else
+      Args.push_back(AL.getArgAsExpr(Idx));
   }
 
-  D->addAttr(::new (S.Context) AnnotateAttr(S.Context, AL, Str));
+  S.AddAnnotationAttr(D, AL, Str, Args);
 }
 
 static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   S.AddAlignValueAttr(D, AL, AL.getArgAsExpr(0));
 }
 
 void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {
   AlignValueAttr TmpAttr(Context, CI, E);

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

static void instantiateDependentAllocAlignAttr(
     const AllocAlignAttr *Align, Decl *New) {
   Expr *Param = IntegerLiteral::Create(
       S.getASTContext(),
       llvm::APInt(64, Align->getParamIndex().getSourceIndex()),
       S.getASTContext().UnsignedLongLongTy, Align->getLocation());
   S.AddAllocAlignAttr(New, *Align, Param);
 }
 
+static void instantiateDependentAnnotationAttr(
+    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
+    const AnnotateAttr *Attr, Decl *New) {
+  EnterExpressionEvaluationContext Unevaluated(
+      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+  SmallVector<Expr *, 4> Args;
+  Args.reserve(Attr->args_size());
+  for (auto *E : Attr->args()) {
+    ExprResult Result = S.SubstExpr(E, TemplateArgs);
+    if (Result.isInvalid())
+      Args.push_back(nullptr);
+    else
+      Args.push_back(Result.get());
+  }
+  S.AddAnnotationAttr(New, *Attr, Attr->getAnnotation(), Args);
+}
+
 static Expr *instantiateDependentFunctionAttrCondition(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
     const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
   Expr *Cond = nullptr;
   {
     Sema::ContextRAII SwitchContext(S, New);
     EnterExpressionEvaluationContext Unevaluated(
         S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
if (const auto *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr)) {
       continue;
     }
 
     if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
       instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New);
       continue;
     }
 
+    if (const auto *Annotate = dyn_cast<AnnotateAttr>(TmplAttr)) {
+      instantiateDependentAnnotationAttr(*this, TemplateArgs, Annotate, New);
+      continue;
+    }
 
     if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
       instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
                                        cast<FunctionDecl>(New));
       continue;
     }
 
     if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {

clang/test/AST/ast-dump-attr.cpp

 // CHECK: FunctionDecl{{.*}} mergeAttrTest
 // CHECK-NEXT: DeprecatedAttr
 // CHECK-NEXT: WarnUnusedResultAttr
 
 // CHECK: FunctionDecl{{.*}} mergeAttrTest
 // CHECK-NEXT: DeprecatedAttr{{.*}} Inherited
 // CHECK-NEXT: WarnUnusedResultAttr{{.*}} Inherited
 // CHECK-NEXT: AnnotateAttr{{.*}}
+// CHECK-NEXT: StringLiteral
 
 // CHECK: FunctionDecl{{.*}} mergeAttrTest
 // CHECK-NEXT: DeprecatedAttr{{.*}} Inherited
 // CHECK-NEXT: WarnUnusedResultAttr{{.*}} Inherited
 // CHECK-NEXT: AnnotateAttr{{.*}} Inherited
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: UnusedAttr
 // CHECK-NEXT: NoThreadSafetyAnalysisAttr

clang/test/CodeGen/annotations-field.c

 
 static struct foo gf;
 
 int main(int argc, char **argv) {
     struct foo f;
     f.v = argc;
 // CHECK: getelementptr inbounds %struct.foo, %struct.foo* %f, i32 0, i32 0
 // CHECK-NEXT: bitcast i32* {{.*}} to i8*
-// CHECK-NEXT: call i8* @llvm.ptr.annotation.p0i8({{.*}}str{{.*}}str{{.*}}i32 8)
+// CHECK-NEXT: call i8* @llvm.ptr.annotation.p0i8({{.*}}str{{.*}}str{{.*}}i32 8, i8* null)
 // CHECK-NEXT: bitcast i8* {{.*}} to i32*
 // CHECK-NEXT: bitcast i32* {{.*}} to i8*
-// CHECK-NEXT: call i8* @llvm.ptr.annotation.p0i8({{.*}}str{{.*}}str{{.*}}i32 8)
+// CHECK-NEXT: call i8* @llvm.ptr.annotation.p0i8({{.*}}str{{.*}}str{{.*}}i32 8, i8* null)
 // CHECK-NEXT: bitcast i8* {{.*}} to i32*
     gf.v = argc;
-// CHECK: call i8* @llvm.ptr.annotation.p0i8(i8* bitcast (%struct.foo* @gf to i8*), {{.*}}str{{.*}}str{{.*}}i32 8)
+// CHECK: call i8* @llvm.ptr.annotation.p0i8(i8* bitcast (%struct.foo* @gf to i8*), {{.*}}str{{.*}}str{{.*}}i32 8, i8* null)
     return 0;
 }

clang/test/CodeGen/annotations-global.c

 }
 
 __attribute((address_space(1))) __attribute__((annotate("addrspace1_ann"))) char addrspace1_var;
 
 // FOOS: target triple
 // FOOS: private unnamed_addr constant [7 x i8] c"sfoo_{{.}}\00", section "llvm.metadata"
 // FOOS: private unnamed_addr constant [7 x i8] c"sfoo_{{.}}\00", section "llvm.metadata"
 // FOOS-NOT: sfoo_
-// FOOS: @llvm.global.annotations = appending global [11 x { i8*, i8*, i8*, i32 }] {{.*}}i8* @sfoo{{.*}}i8* @sfoo{{.*}}, section "llvm.metadata"
+// FOOS: @llvm.global.annotations = appending global [11 x { i8*, i8*, i8*, i32, i8* }] {{.*}}i8* @sfoo{{.*}}i8* @sfoo{{.*}}, section "llvm.metadata"
 
 // FOO: target triple
 // FOO: private unnamed_addr constant [6 x i8] c"foo_{{.}}\00", section "llvm.metadata"
 // FOO: private unnamed_addr constant [6 x i8] c"foo_{{.}}\00", section "llvm.metadata"
 // FOO-NOT: foo_
-// FOO: @llvm.global.annotations = appending global [11 x { i8*, i8*, i8*, i32 }] {{.*}}i8* @foo{{.*}}i8* @foo{{.*}}, section "llvm.metadata"
+// FOO: @llvm.global.annotations = appending global [11 x { i8*, i8*, i8*, i32, i8* }] {{.*}}i8* @foo{{.*}}i8* @foo{{.*}}, section "llvm.metadata"
 
 // A: target triple
 // A: private unnamed_addr constant [8 x i8] c"ann_a_{{.}}\00", section "llvm.metadata"
 // A: private unnamed_addr constant [8 x i8] c"ann_a_{{.}}\00", section "llvm.metadata"
 // A: private unnamed_addr constant [8 x i8] c"ann_a_{{.}}\00", section "llvm.metadata"
 // A: private unnamed_addr constant [8 x i8] c"ann_a_{{.}}\00", section "llvm.metadata"
 // A-NOT: ann_a_
-// A: @llvm.global.annotations = appending global [11 x { i8*, i8*, i8*, i32 }] {{.*}}i8* bitcast (void (i8*)* @a to i8*){{.*}}i8* bitcast (void (i8*)* @a to i8*){{.*}}i8* bitcast (void (i8*)* @a to i8*){{.*}}i8* bitcast (void (i8*)* @a to i8*){{.*}}, section "llvm.metadata"
+// A: @llvm.global.annotations = appending global [11 x { i8*, i8*, i8*, i32, i8* }] {{.*}}i8* bitcast (void (i8*)* @a to i8*){{.*}}i8* bitcast (void (i8*)* @a to i8*){{.*}}i8* bitcast (void (i8*)* @a to i8*){{.*}}i8* bitcast (void (i8*)* @a to i8*){{.*}}, section "llvm.metadata"
 
 // BAR: target triple
 // BAR: private unnamed_addr constant [6 x i8] c"bar_{{.}}\00", section "llvm.metadata"
 // BAR: private unnamed_addr constant [6 x i8] c"bar_{{.}}\00", section "llvm.metadata"
 // BAR-NOT: bar_
-// BAR: @llvm.global.annotations = appending global [11 x { i8*, i8*, i8*, i32 }] {{.*}}i8* @a.bar{{.*}}i8* @a.bar{{.*}}, section "llvm.metadata"
+// BAR: @llvm.global.annotations = appending global [11 x { i8*, i8*, i8*, i32, i8* }] {{.*}}i8* @a.bar{{.*}}i8* @a.bar{{.*}}, section "llvm.metadata"
 
 // ADDRSPACE: target triple
 // ADDRSPACE: @llvm.global.annotations = appending global {{.*}} addrspacecast (i8 addrspace(1)* @addrspace1_var to i8*), {{.*}}

clang/test/CodeGen/annotations-loc.c

 // RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
 // END.
 # 1 "t.c"
 # 1 "<built-in>"
 # 1 "<command-line>"
 # 1 "t.c"
 int __attribute((annotate("foo"))) foo(void) { return 0; }
 
 // CHECK: private unnamed_addr constant [4 x i8] c"t.c\00"
-// CHECK: @llvm.global.annotations = {{.*}}, i32 1 }
+// CHECK: @llvm.global.annotations = {{.*}}, i32 1, i8* null }

clang/test/CodeGen/annotations-var.c

 // PARAM-NEXT: call void @llvm.var.annotation(
 }
 
 void local(void) {
     int localvar __attribute__((annotate("localvar_ann_0"))) __attribute__((annotate("localvar_ann_1"))) = 3;
 // LOCAL-LABEL: define void @local()
 // LOCAL:      [[LOCALVAR:%.*]] = alloca i32,
 // LOCAL-NEXT: [[T0:%.*]] = bitcast i32* [[LOCALVAR]] to i8*
-// LOCAL-NEXT: call void @llvm.var.annotation(i8* [[T0]], i8* getelementptr inbounds ([15 x i8], [15 x i8]* @{{.*}}), i8* getelementptr inbounds ({{.*}}), i32 33)
+// LOCAL-NEXT: call void @llvm.var.annotation(i8* [[T0]], i8* getelementptr inbounds ([15 x i8], [15 x i8]* @{{.*}}), i8* getelementptr inbounds ({{.*}}), i32 33, i8* null)
 // LOCAL-NEXT: [[T0:%.*]] = bitcast i32* [[LOCALVAR]] to i8*
-// LOCAL-NEXT: call void @llvm.var.annotation(i8* [[T0]], i8* getelementptr inbounds ([15 x i8], [15 x i8]* @{{.*}}), i8* getelementptr inbounds ({{.*}}), i32 33)
+// LOCAL-NEXT: call void @llvm.var.annotation(i8* [[T0]], i8* getelementptr inbounds ([15 x i8], [15 x i8]* @{{.*}}), i8* getelementptr inbounds ({{.*}}), i32 33, i8* null)
 }
 
 void local_after_return(void) {
     return;
     int localvar __attribute__((annotate("localvar_after_return"))) = 3;
 // Test we are not emitting instructions like bitcast or call outside of a basic block.
 // LOCAL-LABEL: define void @local_after_return()
 // LOCAL:      [[LOCALVAR:%.*]] = alloca i32,
 // LOCAL-NEXT: ret void
 }
 
 void undef(void) {
     int undefvar __attribute__((annotate("undefvar_ann_0")));
 // UNDEF-LABEL: define void @undef()
 // UNDEF:      [[UNDEFVAR:%.*]] = alloca i32,
 // UNDEF-NEXT: [[T0:%.*]] = bitcast i32* [[UNDEFVAR]] to i8*
-// UNDEF-NEXT: call void @llvm.var.annotation(i8* [[T0]], i8* getelementptr inbounds ([15 x i8], [15 x i8]* @{{.*}}), i8* getelementptr inbounds ({{.*}}), i32 52)
+// UNDEF-NEXT: call void @llvm.var.annotation(i8* [[T0]], i8* getelementptr inbounds ([15 x i8], [15 x i8]* @{{.*}}), i8* getelementptr inbounds ({{.*}}), i32 52, i8* null)
 }

clang/test/CodeGenCXX/attr-annotate.cpp

+// RUN: %clangxx -emit-llvm -S %s -o - | FileCheck %s
+
+//CHECK: @[[STR1:.*]] = private unnamed_addr constant [{{.*}} x i8] c"{{.*}}attr-annotate.cpp\00", section "llvm.metadata"
+//CHECK: @[[STR2:.*]] = private unnamed_addr constant [4 x i8] c"abc\00", align 1
+//CHECK: @[[STR:.*]] = private unnamed_addr constant [5 x i8] c"test\00", section "llvm.metadata"
+//CHECK: @[[ARGS:.*]] = private unnamed_addr constant { i32, i8*, i32 } { i32 9, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @[[STR2:.*]], i32 0, i32 0), i32 8 }, section "llvm.metadata"
+//CHECK: @llvm.global.annotations = appending global [1 x { i8*, i8*, i8*, i32, i8* }] [{ i8*, i8*, i8*, i32, i8* } { i8* bitcast (void (%struct.A*)* @_ZN1AIjLj9EE4testILi8EEEvv to i8*), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @[[STR:.*]], i32 0, i32 0), i8* getelementptr inbounds ([{{.*}} x i8], [{{.*}} x i8]* @[[STR1:.*]], i32 0, i32 0), i32 {{.*}}, i8* bitcast ({ i32, i8*, i32 }* @[[ARGS:.*]] to i8*) }]
+
+constexpr const char* str() {
+  return "abc";
+}
+
+template<typename T, T V>
+struct A {
+  template <int I> __attribute__((annotate("test", V, str(), I))) void test() {}
+};
+
+void t() {
+  A<unsigned, 9> a;
+  a.test<8>();
+}
+
+template<typename T, T V>
+struct B {
+template<typename T1, T1 V1>
+struct foo {
+  int v __attribute__((annotate("v_ann_0", str(), 90, V))) __attribute__((annotate("v_ann_1", V1)));
+};
+};
+
+static B<int long, -1>::foo<unsigned, 9> gf;
+
+// CHECK-LABEL: @main(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[ARGC_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[ARGV_ADDR:%.*]] = alloca i8**, align 8
+// CHECK-NEXT:    [[F:%.*]] = alloca %"struct.B<int, 7>::foo", align 4
+// CHECK-NEXT:    store i32 0, i32* [[RETVAL]], align 4
+// CHECK-NEXT:    store i32 [[ARGC:%.*]], i32* [[ARGC_ADDR]], align 4
+// CHECK-NEXT:    store i8** [[ARGV:%.*]], i8*** [[ARGV_ADDR]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[ARGC_ADDR]], align 4
+// CHECK-NEXT:    [[V:%.*]] = getelementptr inbounds %"struct.B<int, 7>::foo", %"struct.B<int, 7>::foo"* [[F]], i32 0, i32 0
+// CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32* [[V]] to i8*
+// CHECK-NEXT:    [[TMP2:%.*]] = call i8* @llvm.ptr.annotation.p0i8(i8* [[TMP1]], i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([{{.*}} x i8], [{{.*}} x i8]* @.str.1, i32 0, i32 0), i32 {{.*}}, i8* bitcast ({ i8*, i32, i32 }* @.args to i8*))
+// CHECK-NEXT:    [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32*
+// CHECK-NEXT:    [[TMP4:%.*]] = bitcast i32* [[TMP3]] to i8*
+// CHECK-NEXT:    [[TMP5:%.*]] = call i8* @llvm.ptr.annotation.p0i8(i8* [[TMP4]], i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([{{.*}} x i8], [{{.*}} x i8]* @.str.1, i32 0, i32 0), i32 {{.*}}, i8* bitcast ({ i32 }* @.args.4 to i8*))
+// CHECK-NEXT:    [[TMP6:%.*]] = bitcast i8* [[TMP5]] to i32*
+// CHECK-NEXT:    store i32 [[TMP0]], i32* [[TMP6]], align 4
+// CHECK-NEXT:    [[TMP7:%.*]] = load i32, i32* [[ARGC_ADDR]], align 4
+// CHECK-NEXT:    [[TMP8:%.*]] = call i8* @llvm.ptr.annotation.p0i8(i8* bitcast (%"struct.B<long, -1>::foo"* @_ZL2gf to i8*), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([{{.*}} x i8], [{{.*}} x i8]* @.str.1, i32 0, i32 0), i32 {{.*}}, i8* bitcast ({ i8*, i32, i64 }* @.args.5 to i8*))
+// CHECK-NEXT:    [[TMP9:%.*]] = bitcast i8* [[TMP8]] to i32*
+// CHECK-NEXT:    [[TMP10:%.*]] = bitcast i32* [[TMP9]] to i8*
+// CHECK-NEXT:    [[TMP11:%.*]] = call i8* @llvm.ptr.annotation.p0i8(i8* [[TMP10]], i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([{{.*}} x i8], [{{.*}} x i8]* @.str.1, i32 0, i32 0), i32 {{.*}}, i8* bitcast ({ i32 }* @.args.4 to i8*))
+// CHECK-NEXT:    [[TMP12:%.*]] = bitcast i8* [[TMP11]] to i32*
+// CHECK-NEXT:    store i32 [[TMP7]], i32* [[TMP12]], align 4
+// CHECK-NEXT:    ret i32 0
+//
+int main(int argc, char **argv) {
+    B<int, 7>::foo<unsigned, 9> f;
+    f.v = argc;
+    gf.v = argc;
+    return 0;
+}

clang/test/Misc/pragma-attribute-cxx.cpp

class testClass2 {
 
   testClass2 *operator -> ();
 };
 // CHECK-LABEL: CXXRecordDecl{{.*}} testClass2
 // CHECK: AnnotateAttr{{.*}} "test"
 // CHECK: CXXMethodDecl{{.*}} testMethod1
 // CHECK-NEXT: ParmVarDecl{{.*}} param
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: CXXConstructorDecl
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: CXXMethodDecl{{.*}} operator->
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 
 #pragma clang attribute push (__attribute__((annotate("method"))), apply_to=any(record, field, variable, function, namespace, type_alias))
 
 void testClass2::testMethod1(int param) {
 
 #pragma clang attribute pop
 }
 // CHECK-LABEL: CXXMethodDecl{{.*}}prev{{.*}} testMethod1
 // CHECK-NEXT: ParmVarDecl{{.*}} param
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: AnnotateAttr{{.*}} "method"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: CompoundStmt
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: AnnotateAttr{{.*}} "method"
+// CHECK-NEXT: StringLiteral
 
 namespace testNamespace {
 }
 // CHECK-LABEL: NamespaceDecl{{.*}} testNamespace
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 
 class testClassForward;
 // CHECK-LABEL: CXXRecordDecl{{.*}} testClassForward
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 
 namespace testNamespaceAlias = testNamespace;
 // CHECK-LABEL: NamespaceAliasDecl{{.*}} testNamespaceAlias
 // CHECK-NOT: AnnotateAttr
 
 using testTypeAlias = testClass2;
 // CHECK-LABEL: TypeAliasDecl{{.*}} testTypeAlias
 // CHECK: AnnotateAttr{{.*}} "test"
 
 void testCatchVariable() {
   try {
   } catch (int testCatch) {
   }
   testCatchVariable();
 }
 // CHECK-LABEL: FunctionDecl{{.*}} testCatchVariable
 // CHECK: CXXCatchStmt
 // CHECK-NEXT: VarDecl{{.*}} testCatch
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 
 void testLambdaMethod() {
   auto l = [] () { };
   testLambdaMethod();
 }
 // CHECK-LABEL: FunctionDecl{{.*}} testLambdaMethod
 // CHECK: LambdaExpr
 // CHECK-NEXT: CXXRecordDecl
 // CHECK: CXXMethodDecl{{.*}} operator()
 // CHECK-NEXT: CompoundStmt
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 
 #pragma clang attribute pop
 
 #pragma clang attribute push (__attribute__((require_constant_initialization)), apply_to=variable(is_global))
 
 int testCI1 = 1;
 // CHECK-LABEL: VarDecl{{.*}} testCI1
 // CHECK-NEXT: IntegerLiteral

clang/test/Misc/pragma-attribute-objc.m

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
 // RUN: %clang_cc1 -fsyntax-only -Wno-objc-root-class -ast-dump -ast-dump-filter test %s | FileCheck %s
 
 #pragma clang attribute push (__attribute__((annotate("test"))), apply_to = any(objc_interface, objc_protocol, objc_property, field, objc_method, variable))
 #pragma clang attribute push (__attribute__((objc_subclassing_restricted)), apply_to = objc_interface)
 
 @interface testInterface1
 // CHECK-LABEL: ObjCInterfaceDecl{{.*}}testInterface1
 // CHECK-NEXT: ObjCImplementation
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: ObjCSubclassingRestrictedAttr{{.*}}
 
 // CHECK-NOT: AnnotateAttr
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 {
   int testIvar1;
   // CHECK-LABEL: ObjCIvarDecl{{.*}} testIvar1
   // CHECK-NEXT: AnnotateAttr{{.*}} "test"
-  // CHECK-NOT: ObjCSubclassingRestrictedAttr
+  // CHECK-NEXT: StringLiteral
 }
 
 @property int testProp1;
 // CHECK-LABEL: ObjCPropertyDecl{{.*}} testProp1
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 - (void)testIm:(int) x;
 // CHECK-LABEL: ObjCMethodDecl{{.*}}testIm
 // CHECK-NEXT: ParmVarDecl{{.*}} x
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 + (void)testCm;
 // CHECK-LABEL: ObjCMethodDecl{{.*}}testCm
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 // Implicit getters/setters shouldn't receive the attributes.
 // CHECK-LABEL: ObjCMethodDecl{{.*}}testProp1
 // CHECK-NOT: AnnotateAttr
 // CHECK-LABEL: ObjCMethodDecl{{.*}}setTestProp1
 // CHECK-NOT: AnnotateAttr
 
 @end
 
 // @implementation can't receive explicit attributes, so don't add the pragma
 // attributes to them.
 @implementation testInterface1
 // CHECK-LABEL: ObjCImplementationDecl{{.*}}testInterface1
 // CHECK-NOT: AnnotateAttr
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 {
   int testIvar2;
   // CHECK-LABEL: ObjCIvarDecl{{.*}} testIvar2
   // CHECK-NEXT: AnnotateAttr{{.*}} "test"
-  // CHECK-NOT: ObjCSubclassingRestrictedAttr
+  // CHECK-NEXT: StringLiteral
 }
 
 // Don't add attributes to implicit parameters!
 - (void)testIm:(int) x {
 // CHECK-LABEL: ObjCMethodDecl{{.*}}testIm
 // CHECK-NEXT: ImplicitParamDecl
 // CHECK-NEXT: ImplicitParamDecl
 // CHECK-NEXT: ParmVarDecl{{.*}} x
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: CompoundStmt
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 }
 
 + (void)testCm {
 // CHECK-LABEL: ObjCMethodDecl{{.*}}testCm
 // CHECK: AnnotateAttr{{.*}} "test"
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 // CHECK-NOT: AnnotateAttr
   _Pragma("clang attribute push (__attribute__((annotate(\"applied at container start\"))), apply_to=objc_interface)");
 }
 
 // Implicit ivars shouldn't receive the attributes.
 // CHECK-LABEL: ObjCIvarDecl{{.*}}_testProp1
 // CHECK-NOT: AnnotateAttr
 
 @end
 
 @implementation testImplWithoutInterface // expected-warning {{cannot find interface declaration for 'testImplWithoutInterface'}}
 // CHECK-LABEL: ObjCInterfaceDecl{{.*}}testImplWithoutInterface
 // CHECK-NEXT: ObjCImplementation
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NEXT: ObjCSubclassingRestrictedAttr
 // CHECK-NEXT: AnnotateAttr{{.*}} "applied at container start"
+// CHECK-NEXT: StringLiteral
 
 // CHECK-LABEL: ObjCImplementationDecl{{.*}}testImplWithoutInterface
 // CHECK-NOT: AnnotateAttr
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 @end
 
 #pragma clang attribute pop
 
 @protocol testProtocol
 // CHECK-LABEL: ObjCProtocolDecl{{.*}}testProtocol
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 // CHECK-NOT: AnnotateAttr
 
 - (void)testProtIm;
 // CHECK-LABEL: ObjCMethodDecl{{.*}}testProtIm
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 @end
 
 @protocol testForwardProtocol;
 // CHECK-LABEL: ObjCProtocolDecl{{.*}}testForwardProtocol
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 
 // Categories can't receive explicit attributes, so don't add pragma attributes
 // to them.
 @interface testInterface1(testCat)
 // CHECK-LABEL: ObjCCategoryDecl{{.*}}testCat
 // CHECK-NOT: AnnotateAttr

 // CHECK-NOT: AnnotateAttr
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 
 #pragma clang attribute pop // objc_subclassing_restricted
 
 @interface testInterface3
 // CHECK-LABEL: ObjCInterfaceDecl{{.*}}testInterface3
 // CHECK-NEXT: AnnotateAttr{{.*}} "test"
+// CHECK-NEXT: StringLiteral
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 @end
 
 #pragma clang attribute pop // annotate("test")
 
 @interface testInterface4
 // CHECK-LABEL: ObjCInterfaceDecl{{.*}}testInterface4
 // CHECK-NOT: AnnotateAttr
 // CHECK-NOT: ObjCSubclassingRestrictedAttr
 @end

clang/test/Parser/access-spec-attrs.cpp

 // RUN: %clang_cc1 %s -fsyntax-only -verify
 
 struct X {
 public __attribute__((unavailable)): // expected-error {{access specifier can only have annotation attributes}}
   void foo();
 private __attribute__((annotate("foobar"))):
     void bar();
-private __attribute__((annotate())): // expected-error {{'annotate' attribute takes one argument}}
+private __attribute__((annotate())): // expected-error {{'annotate' attribute takes at least 1 argument}}
 };
 
 void f(X x) {
   x.foo();
 }

clang/test/Parser/objc-implementation-attrs.m

 @implementation I5 {
   unavail_int x;
 }
 @end
 #pragma clang attribute pop
 
 I5 *i5;
 
-// expected-error@+1 2 {{'annotate' attribute takes one argument}}
+// expected-error@+1 2 {{'annotate' attribute takes at least 1 argument}}
 #pragma clang attribute push (__attribute__((annotate)), apply_to=objc_implementation)
 @interface I6 @end
 @interface I6 (MyCat) @end
 @interface I6 () @end
 
 @implementation I6 @end // expected-note {{when applied to this declaration}}
 @implementation I6 (MyCat) @end // expected-note {{when applied to this declaration}}
 
 #pragma clang attribute pop

clang/test/Sema/annotate.c

 // RUN: %clang_cc1 %s -fsyntax-only -fdouble-square-bracket-attributes -verify
 
 void __attribute__((annotate("foo"))) foo(float *a) {
   __attribute__((annotate("bar"))) int x;
   [[clang::annotate("bar")]] int x2;
   __attribute__((annotate(1))) int y; // expected-error {{'annotate' attribute requires a string}}
   [[clang::annotate(1)]] int y2; // expected-error {{'annotate' attribute requires a string}}
-  __attribute__((annotate("bar", 1))) int z; // expected-error {{'annotate' attribute takes one argument}}
-  [[clang::annotate("bar", 1)]] int z2; // expected-error {{'annotate' attribute takes one argument}}
+  __attribute__((annotate("bar", 1))) int z;
+  [[clang::annotate("bar", 1)]] int z2;
 
   int u = __builtin_annotation(z, (char*) 0); // expected-error {{second argument to __builtin_annotation must be a non-wide string constant}}
   int v = __builtin_annotation(z, (char*) L"bar"); // expected-error {{second argument to __builtin_annotation must be a non-wide string constant}}
   int w = __builtin_annotation(z, "foo");
   float b = __builtin_annotation(*a, "foo"); // expected-error {{first argument to __builtin_annotation must be an integer}}
 }

clang/test/Sema/pragma-attribute.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 #pragma clang attribute pop // expected-error {{'#pragma clang attribute pop' with no matching '#pragma clang attribute push'}}
 
 // Don't verify unused attributes.
 #pragma clang attribute push (__attribute__((annotate)), apply_to = function) // expected-warning {{unused attribute 'annotate' in '#pragma clang attribute push' region}}
 #pragma clang attribute pop // expected-note {{'#pragma clang attribute push' regions ends here}}
 
 // Ensure we only report any errors once.
-#pragma clang attribute push (__attribute__((annotate)), apply_to = function) // expected-error 4 {{'annotate' attribute takes one argument}}
+#pragma clang attribute push (__attribute__((annotate)), apply_to = function) // expected-error 4 {{'annotate' attribute takes at least 1 argument}}
 
 void test5_begin(); // expected-note {{when applied to this declaration}}
 void test5_1(); // expected-note {{when applied to this declaration}}
 
-#pragma clang attribute push (__attribute__((annotate())), apply_to = function) // expected-error 2 {{'annotate' attribute takes one argument}}
+#pragma clang attribute push (__attribute__((annotate())), apply_to = function) // expected-error 2 {{'annotate' attribute takes at least 1 argument}}
 
 void test5_2(); // expected-note 2 {{when applied to this declaration}}
 
-#pragma clang attribute push (__attribute__((annotate("hello", "world"))), apply_to = function) // expected-error {{'annotate' attribute takes one argument}}
+#pragma clang attribute push (__attribute__((annotate("hello", "world"))), apply_to = function)
 
-void test5_3(); // expected-note 3 {{when applied to this declaration}}
+void test5_3(); // expected-note 2 {{when applied to this declaration}}
 
 #pragma clang attribute pop
 #pragma clang attribute pop
 #pragma clang attribute pop
 
 // Verify that the warnings are reported for each receiver declaration
 
 #pragma clang attribute push (__attribute__((optnone)), apply_to = function) // expected-note 2 {{conflicting attribute is here}}
 
 __attribute__((always_inline)) void optnone1() { } // expected-warning {{'always_inline' attribute ignored}}
 // expected-note@-1 {{when applied to this declaration}}
 
 void optnone2() { }
 
 __attribute__((always_inline)) void optnone3() { } // expected-warning {{'always_inline' attribute ignored}}
 // expected-note@-1 {{when applied to this declaration}}
 
 #pragma clang attribute pop
 
-#pragma clang attribute push (__attribute__((annotate())), apply_to = function) // expected-error{{'annotate' attribute takes one argument}}
-#pragma clang attribute (__attribute__((annotate())), apply_to = function) // expected-error{{'annotate' attribute takes one argument}}
+#pragma clang attribute push (__attribute__((annotate())), apply_to = function) // expected-error{{'annotate' attribute takes at least 1 argument}}
+#pragma clang attribute (__attribute__((annotate())), apply_to = function) // expected-error{{'annotate' attribute takes at least 1 argument}}
 
 void fun(); // expected-note 2 {{when applied to this declaration}}
 
 #pragma clang attribute pop
 #pragma clang attribute pop // expected-error{{'#pragma clang attribute pop' with no matching '#pragma clang attribute push'}}
 
 
 #pragma clang attribute push
-#pragma clang attribute (__attribute__((annotate())), apply_to = function) // expected-error 2 {{'annotate' attribute takes one argument}}
+#pragma clang attribute (__attribute__((annotate())), apply_to = function) // expected-error 2 {{'annotate' attribute takes at least 1 argument}}
 
 void fun2(); // expected-note {{when applied to this declaration}}
 
-#pragma clang attribute push (__attribute__((annotate())), apply_to = function) // expected-error{{'annotate' attribute takes one argument}}
+#pragma clang attribute push (__attribute__((annotate())), apply_to = function) // expected-error{{'annotate' attribute takes at least 1 argument}}
 void fun3(); // expected-note 2 {{when applied to this declaration}}
 #pragma clang attribute pop
 
 #pragma clang attribute pop
 #pragma clang attribute pop // expected-error{{'#pragma clang attribute pop' with no matching '#pragma clang attribute push'}}
 
 #pragma clang attribute (__attribute__((annotate)), apply_to = function) // expected-error{{'#pragma clang attribute' attribute with no matching '#pragma clang attribute push}}
 
 #pragma clang attribute push ([[]], apply_to = function) // A noop
 
 #pragma clang attribute pop // expected-error {{'#pragma clang attribute pop' with no matching '#pragma clang attribute push'}}
 
 #pragma clang attribute push (__attribute__((annotate("func"))), apply_to = function) // expected-error {{unterminated '#pragma clang attribute push' at end of file}}
 
 void function();

clang/test/SemaCXX/attr-annotate.cpp

+// RUN: %clang_cc1 -std=c++11 -emit-llvm -verify %s
+
+constexpr const char *str() {
+  return "abc";
+}
+
+namespace test1 {
+int g_i; // expected-note {{declared here}}
+
+template <typename T, T V>
+struct B {
+  static T b; // expected-note {{declared here}}
+  static constexpr T cb = V;
+  template <typename T1, T1 V1>
+  struct foo {
+    static T1 f; // expected-note {{declared here}}
+    static constexpr T1 cf = V1;
+    int v __attribute__((annotate("v_ann_0", str(), 90, V, g_i))) __attribute__((annotate("v_ann_1", V1)));
+    // expected-error@-1 {{'annotate' attribute requires parameter 4 to be a constant expression}}
+    // expected-note@-2 {{is not allowed in a constant expression}}
+    [[clang::annotate("qdwqwd", cf, cb)]] void t() {}
+    [[clang::annotate("qdwqwd", f, cb)]] void t1() {}
+    // expected-error@-1 {{'annotate' attribute requires parameter 1 to be a constant expression}}
+    // expected-note@-2 {{is not allowed in a constant expression}}
+    [[clang::annotate("jui", b, cf)]] void t2() {}
+    // expected-error@-1 {{'annotate' attribute requires parameter 1 to be a constant expression}}
+    // expected-note@-2 {{is not allowed in a constant expression}}
+    [[clang::annotate("jui", (b, 0), cf)]] [[clang::annotate("jui", &b, cf, &foo::t2, str())]] void t3() {}
+  };
+};
+
+static B<int long, -1>::foo<unsigned, 9> gf; // expected-note {{in instantiation of}}
+static B<int long, -2> gf1;
+
+} // namespace test1
+
+namespace test2 {
+
+template<int I>
+int f() {
+  [[clang::annotate("test", I)]] int v = 0; // expected-note {{declared here}}
+  [[clang::annotate("test", v)]] int v2 = 0;
+  // expected-error@-1 {{'annotate' attribute requires parameter 1 to be a constant expression}}
+  // expected-note@-2 {{is not allowed in a constant expression}}
+  [[clang::annotate("test", rtyui)]] int v3 = 0;
+    // expected-error@-1 {{use of undeclared identifier 'rtyui'}}
+}
+
+void test() {}
+}
+

llvm/include/llvm/IR/Intrinsics.td

 def int_eh_sjlj_setjmp          : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty]>;
 def int_eh_sjlj_longjmp         : Intrinsic<[], [llvm_ptr_ty], [IntrNoReturn]>;
 def int_eh_sjlj_setup_dispatch  : Intrinsic<[], []>;
 
 //===---------------- Generic Variable Attribute Intrinsics----------------===//
 //
 def int_var_annotation : Intrinsic<[],
                                    [llvm_ptr_ty, llvm_ptr_ty,
-                                    llvm_ptr_ty, llvm_i32_ty],
+                                    llvm_ptr_ty, llvm_i32_ty, llvm_ptr_ty],
                                    [IntrWillReturn], "llvm.var.annotation">;
 def int_ptr_annotation : Intrinsic<[LLVMAnyPointerType<llvm_anyint_ty>],
                                    [LLVMMatchType<0>, llvm_ptr_ty, llvm_ptr_ty,
-                                    llvm_i32_ty],
+                                    llvm_i32_ty, llvm_ptr_ty],
                                    [IntrWillReturn], "llvm.ptr.annotation">;
 def int_annotation : Intrinsic<[llvm_anyint_ty],
                                [LLVMMatchType<0>, llvm_ptr_ty,
                                 llvm_ptr_ty, llvm_i32_ty],
                                [IntrWillReturn], "llvm.annotation">;
 
 // Annotates the current program point with metadata strings which are emitted
 // as CodeView debug info records. This is expensive, as it disables inlining

llvm/test/Analysis/CostModel/X86/free-intrinsics.ll

 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a4 = call i1 @llvm.is.constant.i32(i32 undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 true, i1 true, i1 true)
-; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 undef
 ;
 ; CHECK-THROUGHPUT-LABEL: 'trivially_free'
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a0 = call i32 @llvm.annotation.i32(i32 undef, i8* undef, i8* undef, i32 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.assume(i1 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.sideeffect()
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a4 = call i1 @llvm.is.constant.i32(i32 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 true, i1 true, i1 true)
-; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i32 undef
 ;
   %a0 = call i32 @llvm.annotation.i32(i32 undef, i8* undef, i8* undef, i32 undef)
   call void @llvm.assume(i1 undef)
   call void @llvm.sideeffect()
   call void @llvm.dbg.declare(metadata i8** undef, metadata !0, metadata !DIExpression())
   call void @llvm.dbg.value(metadata i64 undef, i64 undef, metadata !DIExpression(), metadata !DIExpression())
   call void @llvm.dbg.label(metadata !2)
   %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
   call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
   %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
   %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
   %a4 = call i1 @llvm.is.constant.i32(i32 undef)
   call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
   call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
   %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 1, i1 1, i1 1)
-  %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-  call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+  %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+  call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
   ret i32 undef
 }
 
 declare i32 @llvm.annotation.i32(i32, i8*, i8*, i32)
 declare void @llvm.assume(i1)
 declare void @llvm.sideeffect()
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 declare void @llvm.dbg.label(metadata)
 declare {}* @llvm.invariant.start.p0i8(i64, i8*)
 declare void @llvm.invariant.end.p0i8({}*, i64, i8*)
 declare i8* @llvm.launder.invariant.group.p0i8(i8*)
 declare i8* @llvm.strip.invariant.group.p0i8(i8*)
 declare i1 @llvm.is.constant.i32(i32)
 declare void @llvm.lifetime.start.p0i8(i64, i8*)
 declare void @llvm.lifetime.end.p0i8(i64, i8*)
 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1)
-declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32)
-declare void @llvm.var.annotation(i8*, i8*, i8*, i32)
+declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32, i8*)
+declare void @llvm.var.annotation(i8*, i8*, i8*, i32, i8*)
 
 
 !0 = !DILocalVariable(scope: !1)
 !1 = distinct !DISubprogram(name: "dummy", line: 79, isLocal: true, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: true)
 !2 = !DILabel(scope: !1, name: "label", file: !3, line: 7)
 !3 = !DIFile(filename: "debug-label.c", directory: "./")

llvm/test/Analysis/CostModel/free-intrinsics-datalayout.ll

 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a4 = call i1 @llvm.is.constant.i32(i32 undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 true, i1 true, i1 true)
-; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 undef
 ;
 ; CHECK-THROUGHPUT-LABEL: 'trivially_free'
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a0 = call i32 @llvm.annotation.i32(i32 undef, i8* undef, i8* undef, i32 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.assume(i1 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.sideeffect()
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a4 = call i1 @llvm.is.constant.i32(i32 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 true, i1 true, i1 true)
-; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 undef
 ;
   %a0 = call i32 @llvm.annotation.i32(i32 undef, i8* undef, i8* undef, i32 undef)
   call void @llvm.assume(i1 undef)
   call void @llvm.sideeffect()
   call void @llvm.dbg.declare(metadata i8** undef, metadata !0, metadata !DIExpression())
   call void @llvm.dbg.value(metadata i64 undef, i64 undef, metadata !DIExpression(), metadata !DIExpression())
   call void @llvm.dbg.label(metadata !2)
   %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
   call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
   %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
   %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
   %a4 = call i1 @llvm.is.constant.i32(i32 undef)
   call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
   call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
   %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 1, i1 1, i1 1)
-  %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-  call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+  %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+  call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
   ret i32 undef
 }
 
 declare i32 @llvm.annotation.i32(i32, i8*, i8*, i32)
 declare void @llvm.assume(i1)
 declare void @llvm.sideeffect()
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 declare void @llvm.dbg.label(metadata)
 declare {}* @llvm.invariant.start.p0i8(i64, i8*)
 declare void @llvm.invariant.end.p0i8({}*, i64, i8*)
 declare i8* @llvm.launder.invariant.group.p0i8(i8*)
 declare i8* @llvm.strip.invariant.group.p0i8(i8*)
 declare i1 @llvm.is.constant.i32(i32)
 declare void @llvm.lifetime.start.p0i8(i64, i8*)
 declare void @llvm.lifetime.end.p0i8(i64, i8*)
 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1)
-declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32)
-declare void @llvm.var.annotation(i8*, i8*, i8*, i32)
+declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32, i8*)
+declare void @llvm.var.annotation(i8*, i8*, i8*, i32, i8*)
 
 
 !0 = !DILocalVariable(scope: !1)
 !1 = distinct !DISubprogram(name: "dummy", line: 79, isLocal: true, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: true)
 !2 = !DILabel(scope: !1, name: "label", file: !3, line: 7)
 !3 = !DIFile(filename: "debug-label.c", directory: "./")

llvm/test/Analysis/CostModel/free-intrinsics-no_info.ll

 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a4 = call i1 @llvm.is.constant.i32(i32 undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 true, i1 true, i1 true)
-; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
 ; CHECK-SIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 undef
 ;
 ; CHECK-THROUGHPUT-LABEL: 'trivially_free'
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a0 = call i32 @llvm.annotation.i32(i32 undef, i8* undef, i8* undef, i32 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.assume(i1 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.sideeffect()
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a4 = call i1 @llvm.is.constant.i32(i32 undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 true, i1 true, i1 true)
-; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
 ; CHECK-THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 undef
 ;
   %a0 = call i32 @llvm.annotation.i32(i32 undef, i8* undef, i8* undef, i32 undef)
   call void @llvm.assume(i1 undef)
   call void @llvm.sideeffect()
   call void @llvm.dbg.declare(metadata i8** undef, metadata !0, metadata !DIExpression())
   call void @llvm.dbg.value(metadata i64 undef, i64 undef, metadata !DIExpression(), metadata !DIExpression())
   call void @llvm.dbg.label(metadata !2)
   %a1 = call {}* @llvm.invariant.start.p0i8(i64 1, i8* undef)
   call void @llvm.invariant.end.p0i8({}* undef, i64 1, i8* undef)
   %a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
   %a3 = call i8* @llvm.strip.invariant.group.p0i8(i8* undef)
   %a4 = call i1 @llvm.is.constant.i32(i32 undef)
   call void @llvm.lifetime.start.p0i8(i64 1, i8* undef)
   call void @llvm.lifetime.end.p0i8(i64 1, i8* undef)
   %a5 = call i64 @llvm.objectsize.i64.p0i8(i8* undef, i1 1, i1 1, i1 1)
-  %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef)
-  call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef)
+  %a6 = call i8* @llvm.ptr.annotation.p0i8(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
+  call void @llvm.var.annotation(i8* undef, i8* undef, i8* undef, i32 undef, i8* undef)
   ret i32 undef
 }
 
 declare i32 @llvm.annotation.i32(i32, i8*, i8*, i32)
 declare void @llvm.assume(i1)
 declare void @llvm.sideeffect()
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 declare void @llvm.dbg.label(metadata)
 declare {}* @llvm.invariant.start.p0i8(i64, i8*)
 declare void @llvm.invariant.end.p0i8({}*, i64, i8*)
 declare i8* @llvm.launder.invariant.group.p0i8(i8*)
 declare i8* @llvm.strip.invariant.group.p0i8(i8*)
 declare i1 @llvm.is.constant.i32(i32)
 declare void @llvm.lifetime.start.p0i8(i64, i8*)
 declare void @llvm.lifetime.end.p0i8(i64, i8*)
 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1, i1)
-declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32)
-declare void @llvm.var.annotation(i8*, i8*, i8*, i32)
+declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32, i8*)
+declare void @llvm.var.annotation(i8*, i8*, i8*, i32, i8*)
 
 
 !0 = !DILocalVariable(scope: !1)
 !1 = distinct !DISubprogram(name: "dummy", line: 79, isLocal: true, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: true)
 !2 = !DILabel(scope: !1, name: "label", file: !3, line: 7)
 !3 = !DIFile(filename: "debug-label.c", directory: "./")

llvm/test/CodeGen/Generic/ptr-annotate.ll

 ; RUN: llc < %s
 
 ; PR15253
 
 %struct.mystruct = type { i32 }
 
 @.str = private unnamed_addr constant [4 x i8] c"sth\00", section "llvm.metadata"
 @.str1 = private unnamed_addr constant [4 x i8] c"t.c\00", section "llvm.metadata"
 
 define void @foo() {
 entry:
   %m = alloca i8, align 4
-  %0 = call i8* @llvm.ptr.annotation.p0i8(i8* %m, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i32 0, i32 0), i32 2)
+  %0 = call i8* @llvm.ptr.annotation.p0i8(i8* %m, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i32 0, i32 0), i32 2, i8* null)
   store i8 1, i8* %0, align 4
   ret void
 }
 
-declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32) #1
+declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32, i8*) #1

llvm/test/Transforms/InstCombine/assume_inevitable.ll

 ; CHECK-NEXT:    [[M:%.*]] = alloca i64, align 8
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[A:%.*]], align 32
 ; CHECK-NEXT:    [[LOADRES:%.*]] = load i32, i32* [[B:%.*]], align 4
 ; CHECK-NEXT:    [[LOADRES2:%.*]] = call i32 @llvm.annotation.i32(i32 [[LOADRES]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i64 0, i64 0), i32 2)
 ; CHECK-NEXT:    store i32 [[LOADRES2]], i32* [[A]], align 32
 ; CHECK-NEXT:    [[DUMMY_EQ:%.*]] = icmp ugt i32 [[LOADRES]], 42
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[DUMMY_EQ]])
 ; CHECK-NEXT:    [[M_I8:%.*]] = bitcast i64* [[M]] to i8*
-; CHECK-NEXT:    [[M_A:%.*]] = call i8* @llvm.ptr.annotation.p0i8(i8* nonnull [[M_I8]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i64 0, i64 0), i32 2)
+; CHECK-NEXT:    [[M_A:%.*]] = call i8* @llvm.ptr.annotation.p0i8(i8* nonnull [[M_I8]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i64 0, i64 0), i32 2, i8* null)
 ; CHECK-NEXT:    [[M_X:%.*]] = bitcast i8* [[M_A]] to i64*
 ; CHECK-NEXT:    [[OBJSZ:%.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* [[C:%.*]], i1 false, i1 false, i1 false)
 ; CHECK-NEXT:    store i64 [[OBJSZ]], i64* [[M_X]], align 4
 ; CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[A]] to i64
 ; CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
 ; CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[MASKCOND]])
 ; CHECK-NEXT:    ret i32 [[TMP0]]
entry:
   tail call void @llvm.assume(i1 %dummy_eq)
 
   call void @llvm.lifetime.start.p0i8(i64 1, i8* %dummy)
   %i = call {}* @llvm.invariant.start.p0i8(i64 1, i8* %dummy)
   call void @llvm.invariant.end.p0i8({}* %i, i64 1, i8* %dummy)
   call void @llvm.lifetime.end.p0i8(i64 1, i8* %dummy)
 
   %m_i8 = bitcast i64* %m to i8*
-  %m_a = call i8* @llvm.ptr.annotation.p0i8(i8* %m_i8, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i32 0, i32 0), i32 2)
+  %m_a = call i8* @llvm.ptr.annotation.p0i8(i8* %m_i8, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i32 0, i32 0), i32 2, i8* null)
   %m_x = bitcast i8* %m_a to i64*
   %objsz = call i64 @llvm.objectsize.i64.p0i8(i8* %c, i1 false)
   store i64 %objsz, i64* %m_x
   ; END perform a bunch of inevitable operations
 
   ; AND here's the assume:
   %ptrint = ptrtoint i32* %a to i64
   %maskedptr = and i64 %ptrint, 31
   %maskcond = icmp eq i64 %maskedptr, 0
   tail call void @llvm.assume(i1 %maskcond)
 
   ret i32 %0
 }
 
 @.str = private unnamed_addr constant [4 x i8] c"sth\00", section "llvm.metadata"
 @.str1 = private unnamed_addr constant [4 x i8] c"t.c\00", section "llvm.metadata"
 
 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1)
 declare i32 @llvm.annotation.i32(i32, i8*, i8*, i32)
-declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32)
+declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32, i8*)
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
 
 declare {}* @llvm.invariant.start.p0i8(i64, i8* nocapture)
 declare void @llvm.invariant.end.p0i8({}*, i64, i8* nocapture)
 declare void @llvm.assume(i1)