Implement attribute target multiversioning

[erichkeane]

Summary

GCC's attribute 'target', in addition to being an optimization hint,
also allows function multiversioning. We currently have the former
implemented, this is the latter's implementation.

Note that it ends up having to permit redefinition of functions so
that they can all be emitted. Additionally, all versions of the function
must be emitted, so this also manages that.

Function templates are NOT supported (not supported in GCC either).

Options on how to split this patch up would also be particularly solicited,
since this IS a large patch.

[hfinkel]

Can you explain briefly what is required of the system in order to support this (is it just ifunc support in the dynamic linker / loader)?

In general, there are a number of places in this patch, at the Sema layer (including in the error messages), that talk about how this is an x86-only feature. As soon as someone adds support for a second architecture, this will cause unnecessary churn (and perhaps miss places resulting in stale comments). Can you create some callbacks, in TargetInfo or similar, so that we can just naturally make this work on other architectures?

Function templates are NOT supported (not supported in GCC either).

Can you please elaborate on this? I'd like to see this feature, but I don't believe that we should introduce features that artificially force users to choose between good code design and technical capabilities. The fact that GCC does not support this feature on templates seems unfortunate, but not in itself a justification to replicate that restriction. I'm obviously fine with adding template functions in a follow-up commit, but I want to understand whether there's something in the design (of the feature or of your implementation approach) that makes this hard. I wouldn't want this to ship without template support.

lib/Basic/Targets/X86.cpp

1330

How are we expected to maintain this array?

[erichkeane]

In D38596#889682, @hfinkel wrote:

Can you explain briefly what is required of the system in order to support this (is it just ifunc support in the dynamic linker / loader)?

Yep, this feature depends entirely on ifuncs.

In general, there are a number of places in this patch, at the Sema layer (including in the error messages), that talk about how this is an x86-only feature. As soon as someone adds support for a second architecture, this will cause unnecessary churn (and perhaps miss places resulting in stale comments). Can you create some callbacks, in TargetInfo or similar, so that we can just naturally make this work on other architectures?

Yep, I have that enforced, with the hope that it would make it easier to identify all the places that this change needs to be made. Currently, there are a few 'TargetInfo' features that need to be supported (isValidCPUName/isValidCPUFeature/compareCpusAndFeatures), the SEMA check relaxed (though I could perhaps add a TargetInfo::IsFunctionMultiVersioningSupported function if thats what you're saying?), and CodeGenFunction::FormResolverCondition/CodeGenFunction::EmitMultiVersionResolver ( which could easily have FormResolverCondition moved to TargetInfo, assuming we OK with a CodeGen file calling into a TargetInfo?). Are these the changes you mean?

Function templates are NOT supported (not supported in GCC either).

Can you please elaborate on this? I'd like to see this feature, but I don't believe that we should introduce features that artificially force users to choose between good code design and technical capabilities. The fact that GCC does not support this feature on templates seems unfortunate, but not in itself a justification to replicate that restriction. I'm obviously fine with adding template functions in a follow-up commit, but I want to understand whether there's something in the design (of the feature or of your implementation approach) that makes this hard. I wouldn't want this to ship without template support.

I don't think there are limitations beyond my understanding of the code around redefinitions of templates. I investigated for a while and was unable to figure it out over a few days, but that doesn't mean terribly much. I gave up temporarily in exchange for getting the rest of the feature in (and the fact that GCC doesn't support it made it an explainable stopping point; additionally, none of our users of 'attribute-target' actually have C++ codebases). I believe I'd be able to add function-template support with some additional work, and am definitely willing to do so.

Thanks Hal, I appreciate your advice/feedback! I realize this is a huge patch, so anything I can get to make this more acceptable is greatly appreciated.

lib/Basic/Targets/X86.cpp

1330

Ugg... I know. I have no idea, it is ANOTHER implementation of this foolish list, just in a slightly different order. We NEED to know the order, so we know how to order the comparisons. They are generally arbitrary orderings, so I have no idea besides "with hard work". If you have a suggestion, or perhaps a way to reorder one of the OTHER lists, I'd love to hear it.

[hfinkel]

In D38596#889697, @erichkeane wrote:

In D38596#889682, @hfinkel wrote:

Can you explain briefly what is required of the system in order to support this (is it just ifunc support in the dynamic linker / loader)?

Yep, this feature depends entirely on ifuncs.

In general, there are a number of places in this patch, at the Sema layer (including in the error messages), that talk about how this is an x86-only feature. As soon as someone adds support for a second architecture, this will cause unnecessary churn (and perhaps miss places resulting in stale comments). Can you create some callbacks, in TargetInfo or similar, so that we can just naturally make this work on other architectures?

Yep, I have that enforced, with the hope that it would make it easier to identify all the places that this change needs to be made. Currently, there are a few 'TargetInfo' features that need to be supported (isValidCPUName/isValidCPUFeature/compareCpusAndFeatures), the SEMA check relaxed (though I could perhaps add a TargetInfo::IsFunctionMultiVersioningSupported function if thats what you're saying?), and CodeGenFunction::FormResolverCondition/CodeGenFunction::EmitMultiVersionResolver ( which could easily have FormResolverCondition moved to TargetInfo, assuming we OK with a CodeGen file calling into a TargetInfo?). Are these the changes you mean?

I added some comments inline.

Function templates are NOT supported (not supported in GCC either).

Can you please elaborate on this? I'd like to see this feature, but I don't believe that we should introduce features that artificially force users to choose between good code design and technical capabilities. The fact that GCC does not support this feature on templates seems unfortunate, but not in itself a justification to replicate that restriction. I'm obviously fine with adding template functions in a follow-up commit, but I want to understand whether there's something in the design (of the feature or of your implementation approach) that makes this hard. I wouldn't want this to ship without template support.

I don't think there are limitations beyond my understanding of the code around redefinitions of templates. I investigated for a while and was unable to figure it out over a few days, but that doesn't mean terribly much. I gave up temporarily in exchange for getting the rest of the feature in (and the fact that GCC doesn't support it made it an explainable stopping point; additionally, none of our users of 'attribute-target' actually have C++ codebases).

I anticipate this will change.

I believe I'd be able to add function-template support with some additional work, and am definitely willing to do so.

Great, thanks!

Thanks Hal, I appreciate your advice/feedback! I realize this is a huge patch, so anything I can get to make this more acceptable is greatly appreciated.

include/clang/Basic/DiagnosticSemaKinds.td

9305

I'd not mention x86 here. As soon as we add support for another architecture, we'll need to reword this anyway.

: Error<"function multiversioning with 'target' is not supported on this architecture and platform">;

lib/Basic/Targets/X86.cpp

1295

Can you please separate out these changes adding the amdfam10 target strings into a separate patch?

1330

At the risk of a comment that will become stale at some point, is it possible to say something here like:

// This list has to match the list in GCC. In GCC 6.whatever, the list is in path/to/file/in/gcc.c

At least that would give someone a clue of how to update this list if necessary.

lib/Sema/SemaDecl.cpp

9249

No need to mention x86 in this comment.

9279

No need to have x86 here in the comment or the check. Just add some function to TargetInfo:

if (!Context.getTargetInfo().supportsFuncMultiversioning()) {
  Diag(

test/CodeGenCXX/attr-target-multiversion.cpp

20

Tests for interactions with function pointers and virtual functions?

[echristo]

This generally works for me modulo the things that Hal has mentioned. You'll probably want to add Richard to the review list for the Sema bits as well.

Thanks!

lib/Sema/SemaDecl.cpp

3214

Extra whitespace.

[aaron.ballman]

include/clang/AST/Decl.h

2226

Drop the this->

2229

Same

include/clang/Basic/Attr.td

1847

operator== instead of operator ==

1852

Same

1898

Don't use auto here.

include/clang/Basic/DiagnosticSemaKinds.td

9301

'causes' seems a bit strange; how about function redeclaration declares a multiversioned function,? (Or something else, I'm not tied to my wording.)

include/clang/Sema/Sema.h

1937

It's a bit strange that this function is called "Check" but it mutates the arguments.

lib/Basic/Targets/X86.cpp

1402

const auto &

lib/CodeGen/CodeGenFunction.h

3707

The comment doesn't inspire confidence with the trailing question mark. ;-)

lib/Sema/SemaDecl.cpp

9241

const auto *

9245

Don't use auto here.

9259

const auto &

9281

Don't use auto here.

9287

Should be named Result

9295

Remove the comma after case.

9297–9300

Might be more succinctly written with ?: (unsure which looks better, try it and see).

9304

const auto * -- might as well hoist this to the top of the function and remove the call to hasAttr<>() above.

9306

I suspect this will give warnings about having a default label in a fully-covered switch.

9344

a 'all' -> an 'all'

9366

Attribute -> attribute

9372

MV -> MultiVersion

9524

Can use dyn_cast_or_null<>() instead.

12184

const auto *

12185

Don't use auto here.

12189

const auto *.

[erichkeane]

Weew... I think I got everything. Thanks for the review you three! I've got another patch coming momentarily with what I believe is all your suggestions.

include/clang/Basic/DiagnosticSemaKinds.td

9301

Thats as good as anything I can think of. I'll change to yours for now, but if someone else comes up with something that sounds better, I'll consider us open to it.

lib/Basic/Targets/X86.cpp

1295

Talked to Craig on this... apparently the rules for amdfam10/amdfam15/amdfam10h/amdfam15h are a bit more complicated (-march supports ONLY the amdfam10, validateCpuIs only supports the "h" versions (of both), and only the 'march' version is supported in this feature. I may have to toss another function to mess with these strings to make it work.

lib/CodeGen/CodeGenFunction.cpp

2279

There IS a "CodeGen/TargetInfo" here, but it isn't as comprehensive as the Basic/TargetInfo types. I wonder if there would be value in creating a 'TargetCodeGenInfo::EmitCpuIs' and TargetCodeGenInfo::EmitCpuSupports to replace the X86 version of these, and suppressing this?

It might be valuable to simply replace the 'EmitTargetArchBuiltinExpr' with something to do this as well. Those handful of target-arch-builtins are a little messy, and are pretty messy in CGFunction.

Probably will have to ask @rnk if he's got a good thought here. I mentioned trying to break up this target info at one point, and he thought it wasn't a great idea.

lib/CodeGen/CodeGenFunction.h

3707

Woops! Personal review comment was left in :)

lib/Sema/SemaDecl.cpp

9297–9300

It does actually... Clang format makes this look really nice.

9306

I didn't see any, but I have no problem removing it anyway.

test/CodeGenCXX/attr-target-multiversion.cpp

20

Looking into it, I'm not sure how virtual functions should LOOK in this case (and GCC doesn't actually implement it either!). I might punt for now while the rest of the patch is in shape, and add it in with function templates/etc.

[erichkeane]

All requested changes AFAIK. Also, discovered that I wasn't calling cpu-init at the beginning of my resolver, so added that.

Note: Virtual functions seem to have a bunch of complexity involved, so I'm going to punt on that for now. GCC also doesn't support it, so I feel ok doing that later while dealing with function templates.

[aaron.ballman]

The attribute and sema bits look good to me, but I agree that you might want Richard's opinions before committing.

lib/Sema/SemaDecl.cpp

9249

const auto *

[erichkeane]

In D38596#891603, @aaron.ballman wrote:

The attribute and sema bits look good to me, but I agree that you might want Richard's opinions before committing.

Oh, definitely! I actually put this up for @echristo to take a look at as a sanity check. I realized it was a big patch so didn't want to spam a bunch of people. @rsmith was definitely on the list! I'll get this last const-auto fix (FWIW, I'm seeing the benefits now of for (X: Xs) being the same as for (const auto &&X : Xs)...) and add him and @rnk to start doing this as a 'final' review.

Thank you very much @echristo, @hfinkel and @aaron.ballman !

[erichkeane]

1 more const-auto. Also noticed I'd missed that removing the 'default' caused the function to fallthrough, so I added llvm_unreachable to the bottom.

[erichkeane]

Craig noticed a pair of ordering issues in the TargetArray list, so fixed htose.

[erichkeane]

@rsmith and @rnk just a quick bump! I'd like to get your thoughts on the SEMA changes here.

Thanks!
-Erich

[erichkeane]

Just a quick rebase, there were a few changes in the area.

[erichkeane]

I note my rebase lost the tests... I'll fix that up soon, sorry guys!

[erichkeane]

Realized I can put variables in an Attribute, so I put MV info in the Attribute rather than at the FD level.

@AaronBallman and @echristo, if you could take another look, I'd appreciate it.

[aaron.ballman]

include/clang/Basic/Attr.td

1917

Align the comments (at least the wrapped part of them)?

lib/Sema/SemaDecl.cpp

9243

OldFD can be const (and that can be propagated to the other decls).

9254

Do you want to assert that TA is not null or handle treat null specially?

9305

Reverse the conditions so the inexpensive bit is checked first, or early-break if Result becomes false.

9307

Reverse conditions.

[erichkeane]

include/clang/Basic/Attr.td

1917

Ugg... I did a ton of work to get these lined up, then format must have had its fun with it. I'll reflow these again.

lib/Sema/SemaDecl.cpp

9305

Ah, right... I think for a while during implementation the "Check" function was doing important work, but this must have been fixed along the way. Fix incoming!

[erichkeane]

Fixes for Aaron's comments.

[erichkeane]

Fix comment in Attr.td that @aaron.ballman brought up on IRC.

[aaron.ballman]

I think the attribute and sema parts look good, but I leave the codegen bits to someone with more experience in that area.

[rsmith]

I'm not entirely happy with the AST representation you're using here. Allowing multiple declarations of the same entity to have (semantically distinct) bodies breaks our AST invariants, and will cause things like our PCH / modules support to fail. This can probably be made to work, but I'd like to see what that looks like before we commit to modeling a multiversioned function this way rather than, say, with different redeclaration chains for each version.

You should add tests for:

• the PCH / Modules case (particularly regarding what happens when merging multiple copies of the same set of functions, for instance when they're defined inline); I would expect this doesn't currently work with this patch, because we only ever load one function body per redeclaration chain
• multiversioned functions declared inline
• constant expression evaluation of calls to such functions (which should -- presumably -- either always use the default version or be rejected as non-constant)

I would also expect that asking a multiversioned FunctionDecl for its definition would only ever give you the target("default") definition or the one-and-only definition, rather than an arbitrary declaration that happens to have a body.

lib/Basic/Targets/X86.cpp

1330

I don't see why this list would need to match the list in some GCC source file. What this list has to match is the set of targets we wish to support, which (for compatibility with GCC) should contain all those that GCC also supports. And it sounds like there are ordering constraints implied by the contents of this list. That's what you should be talking about here.

1331

Where did this table and code actually come from?

1332

Deducing std::initializer_list is an abomination. Use const char *TargetArray[] or similar here instead.

1394

Can you replace this list (and the repetition of it elsewhere in this file) with a .def file carrying the same information?

lib/CodeGen/CodeGenModule.cpp

421–423

I'm not happy with this diagnostic being produced by IR generation. We should diagnose this at the point of first use of the multiversioned function, within Sema.

2121

CodeGen should not be inventing mangled names with external linkage. Please move this to the name mangler. Is this mangling scheme compatible with GCC? How will we avoid name collisions between this and other uses of dot suffixes?

test/CodeGenCXX/attr-target-multiversion.cpp

22

This looks like it has the wrong linkage.

[erichkeane]

Hi Richard, thanks for the review! I'll make another attempt with this based on your feedback, though if you could clarify your suggestion, it would be greatly appreciated.

In D38596#909957, @rsmith wrote:

I'm not entirely happy with the AST representation you're using here. Allowing multiple declarations of the same entity to have (semantically distinct) bodies breaks our AST invariants, and will cause things like our PCH / modules support to fail. This can probably be made to work, but I'd like to see what that looks like before we commit to modeling a multiversioned function this way rather than, say, with different redeclaration chains for each version.

I'd experimented with (but not succeeded with) simply preventing merging of the decls, but had a tough time keeping like-versions together for the purposes of the iFunc. Additionally, clarifying the 'call' later on became quite difficult. I can definitely give that another try though.

You should add tests for:

• the PCH / Modules case (particularly regarding what happens when merging multiple copies of the same set of functions, for instance when they're defined inline); I would expect this doesn't currently work with this patch, because we only ever load one function body per redeclaration chain

I'm not sure I know what one of those looks like... is there a good test that I can use to learn the modules implementation?

• multiversioned functions declared inline

I don't see anything changing for this situation, but I imagine you have an issue in mind that I'm missing?

• constant expression evaluation of calls to such functions (which should -- presumably -- either always use the default version or be rejected as non-constant)

I'd say they should always do the default version, but this isn't something I did any work on. I'll look at that.

I would also expect that asking a multiversioned FunctionDecl for its definition would only ever give you the target("default") definition or the one-and-only definition, rather than an arbitrary declaration that happens to have a body.

Right, this is a big catch that I didn't think about...

lib/Basic/Targets/X86.cpp

1331

I took the list of things recognized by GCC, ran them through godbolt to see the list.

1394

I've been working with Craig trying to do something like this, though not with a .def file. So far I've yet to come up with something signifiantly better, but I'm still working on it.

lib/CodeGen/CodeGenModule.cpp

421–423

Unfortunately, there is no real way to tell there. A usage could happen before the 2nd definition, so it wouldn't know that it IS a multiversioning at that point.

2121

I can definitely extract this over to the name manglers. This mangling scheme is exactly what GCC and ICC do currently. I have no idea how it avoids collisions besides not being able to define the root name with another mechanism.

[rsmith]

In D38596#910035, @erichkeane wrote:

You should add tests for:

• the PCH / Modules case (particularly regarding what happens when merging multiple copies of the same set of functions, for instance when they're defined inline); I would expect this doesn't currently work with this patch, because we only ever load one function body per redeclaration chain

I'm not sure I know what one of those looks like... is there a good test that I can use to learn the modules implementation?

There are a bunch in test/PCH and test/Modules that you could crib from.

• multiversioned functions declared inline

I don't see anything changing for this situation, but I imagine you have an issue in mind that I'm missing?

You need to make sure you use the correct linkage for the versions and for the dispatcher. Your tests seem to demonstrate you're getting this wrong at the moment. Also, this is the case where the mangling of the target-specific definitions would become part of the ABI.

• constant expression evaluation of calls to such functions (which should -- presumably -- either always use the default version or be rejected as non-constant)

I'd say they should always do the default version, but this isn't something I did any work on. I'll look at that.

I would also expect that asking a multiversioned FunctionDecl for its definition would only ever give you the target("default") definition or the one-and-only definition, rather than an arbitrary declaration that happens to have a body.

Right, this is a big catch that I didn't think about...

What I'm essentially thinking here is that a declaration with a body for a multiversioned function, that isn't for the "default" target, would not be treated as being "the definition" at all.

The big pain point here is that we don't know whether a function is multiversioned until we see the *second* version of it (or a declaration with no target attribute or a declaration with a "default" target), and we generally want our AST to be immutable-once-created. I don't see a good way to handle this except by mutating the AST when we see the second version (which leads to complexity, particularly around PCH -- you need to inform AST mutation listeners that this has happened and write a record out into the AST file to indicate you've updated an imported entity) -- or by treating any function with a target attribute as if it were multiversioned, and not treating a declaration with a body as being the definition until / unless we see the first use of it (which, again, leads to an AST mutation of some kind at that point).

Keeping the redeclaration chains separate would avoid this problem, but we'd still need to do *something* to track the set of versions of the function so we can emit them as part of the ifunc.

[rsmith]

lib/Basic/Targets/X86.cpp

1331

OK, that sounds reasonable. Please rephrase this comment; the current wording could be read as suggesting this is in some way derived from the GCC source code, which is clearly not what you did, nor what we're suggesting that people updating this list do.

lib/CodeGen/CodeGenModule.cpp

421–423

I think we should reject any case where new versions of the function are added after the first use. Generally we want our extensions to support eager code generation, even in cases where that means we reject certain setups that GCC copes with.

[erichkeane]

In D38596#913322, @rsmith wrote:

The big pain point here is that we don't know whether a function is multiversioned until we see the *second* version of it (or a declaration with no target attribute or a declaration with a "default" target), and we generally want our AST to be immutable-once-created. I don't see a good way to handle this except by mutating the AST when we see the second version (which leads to complexity, particularly around PCH -- you need to inform AST mutation listeners that this has happened and write a record out into the AST file to indicate you've updated an imported entity) -- or by treating any function with a target attribute as if it were multiversioned, and not treating a declaration with a body as being the definition until / unless we see the first use of it (which, again, leads to an AST mutation of some kind at that point).

Keeping the redeclaration chains separate would avoid this problem, but we'd still need to do *something* to track the set of versions of the function so we can emit them as part of the ifunc.

That is definitely a pain point. The solution I've had bouncing around in my head is the following, but it has some limitations that GCC doesn't have:
1- Convert to multiversion not permitted unless 1 of the 2 is 'default' (since it is required).
2- Convert to multiversion not permitted if the decl has been used.
3- Prevent the 'lookup' from finding the non-default version, this permits things like constexpr to work properly.
4- Add a list of the "Multiversion Decls" to the 'default' FunctionDecl.

My hope being that #2 makes it so that no one would really NOTICE the AST rewriting, since it hasn't been used.
#1 enables #3, so that the only 'user' of the multiversion'ed decls ends up being the CodeGen emitting the ifunc.
#4 of course is to give CodeGen the ability to emit all of the definitions.

Is there a better way to 'downgrade' the non-default FunctionDecl's to 'not lookupable'? Or is this something I would need to add?

Finally, 1 further idea is that "default" automatically creates it as a 'multiversion case'. Since a sole 'default' would be invalid in GCC, I think that makes us OK, right?

Thoughts on the above proposal? I have basically abandoned this review, since the changes are pretty intense. I've also submitted another patch (that Craig Topper is helping me with) to cleanup the CPU/Feature definitions to make that list more sane.

BTW: Just saw your 2nd response: I think the rejection of cases where multiversioning is caused after first-use is the only real way to make this sane.

Thanks again for your input!

[erichkeane]

Completely superceededby this patch here: https://reviews.llvm.org/D40819

Since that one is a complete redesign/reimplementation, I'd prefer to do it separately.

include/clang/AST/Decl.h

public:
   /// \brief The kind of templated function a FunctionDecl can be.
   enum TemplatedKind {
     TK_NonTemplate,
     TK_FunctionTemplate,
     TK_MemberSpecialization,
     TK_FunctionTemplateSpecialization,
     TK_DependentFunctionTemplateSpecialization
   };
+  enum class MultiVersionKind {
+    None = 0, // No Decl of this function has a 'target' attribute.
+    All, // All Decls of this function have a 'target' attribute.  None differ
+         // in contents, so this is the 'hint' case.
+    MultiVersion, // All Decls of this function have a 'target' attribute, some
+                  // with different strings.  This causes a multi-version case.
+    Partial,      // This is NOT a MV case.  All Decls with a 'target' attribute
+                  // match, so this is simply the 'hint' case.
+    Error         // A previous decl caused an invalid MultiVersion, so reject
+                  // all further attempts at multiversioning/target.
+  };
 
 private:
   /// ParamInfo - new[]'d array of pointers to VarDecls for the formal
   /// parameters of this function.  This is null if a prototype or if there are
   /// no formals.
   ParmVarDecl **ParamInfo;
 
   LazyDeclStmtPtr Body;
private:
 
   /// \brief Indicates if the function was a definition but its body was
   /// skipped.
   unsigned HasSkippedBody : 1;
 
   /// Indicates if the function declaration will have a body, once we're done
   /// parsing it.
   unsigned WillHaveBody : 1;
+  unsigned MultiVersion : 3;
 
   /// \brief End part of this FunctionDecl's source range.
   ///
   /// We could compute the full range in getSourceRange(). However, when we're
   /// dealing with a function definition deserialized from a PCH/AST file,
   /// we can only compute the full range once the function body has been
   /// de-serialized, so it's far better to have the (sometimes-redundant)
   /// EndRangeLoc.
FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
         IsInlineSpecified(isInlineSpecified), IsExplicitSpecified(false),
         IsVirtualAsWritten(false), IsPure(false),
         HasInheritedPrototype(false), HasWrittenPrototype(true),
         IsDeleted(false), IsTrivial(false), IsDefaulted(false),
         IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
         IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
         InstantiationIsPending(false),
         UsesSEHTry(false), HasSkippedBody(false), WillHaveBody(false),
+        MultiVersion(static_cast<unsigned>(MultiVersionKind::None)),
         EndRangeLoc(NameInfo.getEndLoc()), TemplateOrSpecialization(),
         DNLoc(NameInfo.getInfo()) {}
 
   typedef Redeclarable<FunctionDecl> redeclarable_base;
   FunctionDecl *getNextRedeclarationImpl() override {
     return getNextRedeclaration();
   }
   FunctionDecl *getPreviousDeclImpl() override {
public:
   /// the FunctionDecl X<T>::A. When a complete definition of
   /// X<int>::A is required, it will be instantiated from the
   /// declaration returned by getInstantiatedFromMemberFunction().
   FunctionDecl *getInstantiatedFromMemberFunction() const;
 
   /// \brief What kind of templated function this is.
   TemplatedKind getTemplatedKind() const;
 
+  /// \brief The multiversion state of this function.
+  MultiVersionKind getMultiVersionKind() const {
+    return static_cast<MultiVersionKind>(this->MultiVersion);
+  }
+  void setMultiVersionKind(MultiVersionKind MV) {
+    this->MultiVersion = static_cast<unsigned>(MV);
+  }
+
   /// \brief If this function is an instantiation of a member function of a
   /// class template specialization, retrieves the member specialization
   /// information.
   MemberSpecializationInfo *getMemberSpecializationInfo() const;
 
   /// \brief Specify that this record is an instantiation of the
   /// member function FD.
   void setInstantiationOfMemberFunction(FunctionDecl *FD,

include/clang/Basic/Attr.td

def Target : InheritableAttr {
   let Args = [StringArgument<"featuresStr">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [TargetDocs];
   let AdditionalMembers = [{
     struct ParsedTargetAttr {
       std::vector<std::string> Features;
       StringRef Architecture;
       bool DuplicateArchitecture = false;
+
+      template <typename Comparer>
+      StringRef getHighestPriority(Comparer &Cmp) const {
+        // Default case.
+        if (Features.empty() && Architecture.empty())
+          return {};
+        StringRef Highest;
+        for (const auto &Feat : Features) {
+          if (Feat[0] == '+' &&
+              (Highest.empty() || Cmp(StringRef{Feat}.substr(1), Highest)))
+            Highest = StringRef{Feat}.substr(1);
+        }
+
+        if (Highest.empty() || Cmp(Architecture, Highest))
+          return Architecture;
+        return Highest;
+      }
+
+      bool operator ==(const ParsedTargetAttr &Other) const {
+        return std::tie(Features, Architecture) ==
+               std::tie(Other.Features, Other.Architecture);
+      }
+
+      bool operator !=(const ParsedTargetAttr &Other) const {
+        return !(*this == Other);
+      }
     };
     ParsedTargetAttr parse() const {
       return parse(getFeaturesStr());
     }
     static ParsedTargetAttr parse(StringRef Features) {
       ParsedTargetAttr Ret;
+      if (Features == "default") return Ret;
       SmallVector<StringRef, 1> AttrFeatures;
       Features.split(AttrFeatures, ",");
 
       // Grab the various features and prepend a "+" to turn on the feature to
       // the backend and add them to our existing set of features.
       for (auto &Feature : AttrFeatures) {
         // Go ahead and trim whitespace rather than either erroring or
         // accepting it weirdly.
continue;
             Ret.Architecture = Feature.split("=").second.trim();
         } else if (Feature.startswith("no-"))
           Ret.Features.push_back("-" + Feature.split("-").second.str());
         else
           Ret.Features.push_back("+" + Feature.str());
       }
       return Ret;
     }
+    std::string multiVersionMangleAddition() const {
+      // Simply 'default' is empty.
+      if (getFeaturesStr() == "default")
+        return "";
+      SmallString<64> Buffer;
+      llvm::raw_svector_ostream OS(Buffer);
+      auto Info = parse();
+
+      // arch= becomes arch_, ',' separator becomes '.'.
+      // Arch goes first, everything else is alphabetical.
+      if (!Info.Architecture.empty())
+        OS << "arch_" << Info.Architecture;
+
+      std::sort(Info.Features.begin(), Info.Features.end());
+      for (auto &&Feat : Info.Features) {
+        if (!Buffer.empty())
+          OS << '_';
+        OS << StringRef{Feat}.substr(1);
+      }
+      return Buffer.str();
+    }
   }];
 }
 
 def TransparentUnion : InheritableAttr {
   let Spellings = [GCC<"transparent_union">];
 //  let Subjects = SubjectList<[Record, TypedefName]>;
   let Documentation = [TransparentUnionDocs];
   let LangOpts = [COnly];
 }
 
 def Unavailable : InheritableAttr {
   let Spellings = [GNU<"unavailable">];
   let Args = [StringArgument<"Message", 1>,

include/clang/Basic/DiagnosticSemaKinds.td

def ext_warn_gnu_final : ExtWarn<
   "__final is a GNU extension, consider using C++11 final">,
   InGroup<GccCompat>;
 
 def warn_shadow_field :
   Warning<"non-static data member '%0' of '%1' shadows member inherited from type '%2'">,
   InGroup<ShadowField>, DefaultIgnore;
 def note_shadow_field : Note<"declared here">;
 
+def err_target_required_in_redecl
+    : Error<"function redeclaration is missing 'target' attribute in a "
+            "multiversioned function">;
+def err_target_causes_illegal_multiversioning
+    : Error<"function redeclaration causes a multiversioned function, but a "
+            "previous declaration lacks a 'target' attribute">;
+def err_target_unimplemented_arch
+    : Error<"function multiversioning with 'target' is only supported on "
+            "X86/x86_64 architectures">;
+def err_bad_multiversion_option
+    : Error<"function multiversioning doesn't support "
+            "%select{feature|architecture}0 '%1'">;
+def err_target_without_default : Error<"function multiversioning with 'target' "
+                                       "requires a 'default' implementation">;
 } // end of sema component.

include/clang/Basic/TargetInfo.h

public:
   // \brief Validate the contents of the __builtin_cpu_supports(const char*)
   // argument.
   virtual bool validateCpuSupports(StringRef Name) const { return false; }
 
   // \brief Validate the contents of the __builtin_cpu_is(const char*)
   // argument.
   virtual bool validateCpuIs(StringRef Name) const { return false; }
 
+  // \brief Provide ordering for the CPU Features and Names such that it can
+  // used for dispatchers.
+  virtual bool compareCpusAndFeatures(StringRef Lhs, StringRef Rhs) const {
+    return false;
+  }
+
   // \brief Returns maximal number of args passed in registers.
   unsigned getRegParmMax() const {
     assert(RegParmMax < 7 && "RegParmMax value is larger than AST can handle");
     return RegParmMax;
   }
 
   /// \brief Whether the target supports thread-local storage.
   bool isTLSSupported() const {

include/clang/Sema/Sema.h

public:
   bool CheckConstexprFunctionDecl(const FunctionDecl *FD);
   bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body);
 
   void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
   void FindHiddenVirtualMethods(CXXMethodDecl *MD,
                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
   void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
+
+  // Checks to see if attribute 'target' results in a valid situation.
+  bool CheckMultiVersionedDecl(FunctionDecl *NewFD, FunctionDecl *OldFD);
+  // Helper function for CheckMultiVersionDecl to ensure that a declaration
+  // causing a Multi-version case doesn't cause invalid options.
+  bool CheckMultiVersionOptions(const FunctionDecl *NewFD,
+                                const FunctionDecl *OldFD);
+  bool CheckMultiVersionOption(const FunctionDecl *FD);
+
   // Returns true if the function declaration is a redeclaration
   bool CheckFunctionDeclaration(Scope *S,
                                 FunctionDecl *NewFD, LookupResult &Previous,
                                 bool IsMemberSpecialization);
   bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
   void CheckMain(FunctionDecl *FD, const DeclSpec &D);
   void CheckMSVCRTEntryPoint(FunctionDecl *FD);
   Decl *ActOnParamDeclarator(Scope *S, Declarator &D);

lib/Basic/Targets/X86.h

public:
   }
 
   ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override;
 
   bool validateCpuSupports(StringRef Name) const override;
 
   bool validateCpuIs(StringRef Name) const override;
 
+  bool compareCpusAndFeatures(StringRef LHS, StringRef RHS) const override;
+
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &info) const override;
 
   bool validateGlobalRegisterVariable(StringRef RegName, unsigned RegSize,
                                       bool &HasSizeMismatch) const override {
     // esp and ebp are the only 32-bit registers the x86 backend can currently
     // handle.
     if (RegName.equals("esp") || RegName.equals("ebp")) {

lib/Basic/Targets/X86.cpp

 // We can't use a generic validation scheme for the cpus accepted here
 // versus subtarget cpus accepted in the target attribute because the
 // variables intitialized by the runtime only support the below currently
 // rather than the full range of cpus.
 bool X86TargetInfo::validateCpuIs(StringRef FeatureStr) const {
   return llvm::StringSwitch<bool>(FeatureStr)
       .Case("amd", true)
       .Case("amdfam10h", true)
+      .Case("amdfam10", true)
       .Case("amdfam15h", true)
+      .Case("amdfam15", true)
       .Case("atom", true)
       .Case("barcelona", true)
       .Case("bdver1", true)
       .Case("bdver2", true)
       .Case("bdver3", true)
       .Case("bdver4", true)
       .Case("bonnell", true)
       .Case("broadwell", true)
return llvm::StringSwitch<bool>(FeatureStr)
       .Case("skylake", true)
       .Case("skylake-avx512", true)
       .Case("slm", true)
       .Case("westmere", true)
       .Case("znver1", true)
       .Default(false);
 }
 
+bool X86TargetInfo::compareCpusAndFeatures(StringRef Lhs, StringRef Rhs) const {
+  // The following are in order from new to old.  These are required for the 
+  // ordering of the GCC Target attribute.
+  const auto TargetArray = {"avx512vpopcntdq",
+                            "avx5124fmaps",
+                            "avx5124vnniw",
+                            "avx512ifma",
+                            "avx512vbmi",
+                            "avx512pf",
+                            "avx512er",
+                            "avx512cd",
+                            "avx512dq",
+                            "avx512bw",
+                            "avx512vl",
+                            "knl",
+                            "avx512f",
+                            "znver1",
+                            "skylake-avx512",
+                            "skylake",
+                            "haswell",
+                            "broadwell",
+                            "bdver4",
+                            "avx2",
+                            "bmi2",
+                            "bdver3",
+                            "bdver2",
+                            "fma",
+                            "bdver1",
+                            "amdfam15h",
+                            "amdfam15",
+                            "xop",
+                            "fma4",
+                            "btver2",
+                            "bmi",
+                            "sandybridge",
+                            "ivybridge",
+                            "avx",
+                            "pclmul",
+                            "aes",
+                            "popcnt",
+                            "westmere",
+                            "slm",
+                            "silvermont",
+                            "nehalem",
+                            "corei7",
+                            "sse4.2",
+                            "sse4.1",
+                            "btver1",
+                            "istanbul",
+                            "shanghai",
+                            "barcelona",
+                            "amdfam10h",
+                            "amdfam10",
+                            "sse4a",
+                            "core2",
+                            "bonnell",
+                            "atom",
+                            "ssse3",
+                            "sse3",
+                            "sse2",
+                            "sse",
+                            "mmx",
+                            "cmov",
+                            "intel",
+                            "amd"};
+
+  if (Lhs == Rhs)
+    return false;
+  // Default location doesn't matter except that sort should be repeatable, but
+  // move default to the end.
+  if (Lhs.empty())
+    return false;
+  if (Rhs.empty())
+    return true;
+
+  for (auto &Str : TargetArray) {
+    if (Lhs == Str)
+      return true;
+    else if (Rhs == Str)
+      return false;
+  }
+  assert(false && "Invalid item passed to compareCpusAndFeatures");
+}
+
 bool X86TargetInfo::validateAsmConstraint(
     const char *&Name, TargetInfo::ConstraintInfo &Info) const {
   switch (*Name) {
   default:
     return false;
   // Constant constraints.
   case 'e': // 32-bit signed integer constant for use with sign-extending x86_64
             // instructions.
return llvm::StringSwitch<CPUKind>(CPU)
       .Case("k6-3", CK_K6_3)
       .Cases("athlon", "athlon-tbird", CK_Athlon)
       .Cases("athlon-xp", "athlon-mp", "athlon-4", CK_AthlonXP)
       .Cases("k8", "athlon64", "athlon-fx", "opteron", CK_K8)
       .Cases("k8-sse3", "athlon64-sse3", "opteron-sse3", CK_K8SSE3)
       .Cases("amdfam10", "barcelona", CK_AMDFAM10)
       .Case("btver1", CK_BTVER1)
       .Case("btver2", CK_BTVER2)
-      .Case("bdver1", CK_BDVER1)
+      .Cases("amdfam15", "bdver1", CK_BDVER1)
       .Case("bdver2", CK_BDVER2)
       .Case("bdver3", CK_BDVER3)
       .Case("bdver4", CK_BDVER4)
       .Case("znver1", CK_ZNVER1)
       .Case("x86-64", CK_x86_64)
       .Case("geode", CK_Geode)
       .Default(CK_Generic);
 }

lib/CodeGen/CodeGenFunction.h

public:
   /// a r-value suitable for passing the given parameter.
   void EmitDelegateCallArg(CallArgList &args, const VarDecl *param,
                            SourceLocation loc);
 
   /// SetFPAccuracy - Set the minimum required accuracy of the given floating
   /// point operation, expressed as the maximum relative error in ulp.
   void SetFPAccuracy(llvm::Value *Val, float Accuracy);
 
+  struct ResolverOption {
+    TargetAttr::ParsedTargetAttr AttrInfo;
+    llvm::Function *Function;
+    ResolverOption(TargetAttr::ParsedTargetAttr &&AttrInfo,// can be moved?
+                   llvm::Function *Function)
+        : AttrInfo(std::move(AttrInfo)), Function(Function) {}
+  };
+  void EmitMultiVersionResolver(llvm::Function *ResolverFunc,
+                                ArrayRef<ResolverOption> ResolverOptions);
+
 private:
   llvm::MDNode *getRangeForLoadFromType(QualType Ty);
   void EmitReturnOfRValue(RValue RV, QualType Ty);
 
   void deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New);
 
   llvm::SmallVector<std::pair<llvm::Instruction *, llvm::Value *>, 4>
   DeferredReplacements;
private:
 
   void AddObjCARCExceptionMetadata(llvm::Instruction *Inst);
 
   llvm::Value *GetValueForARMHint(unsigned BuiltinID);
   llvm::Value *EmitX86CpuIs(const CallExpr *E);
   llvm::Value *EmitX86CpuIs(StringRef CPUStr);
   llvm::Value *EmitX86CpuSupports(const CallExpr *E);
   llvm::Value *EmitX86CpuSupports(ArrayRef<StringRef> FeatureStrs);
+  llvm::Value *FormResolverCondition(const ResolverOption &RO);
 };
 
 /// Helper class with most of the code for saving a value for a
 /// conditional expression cleanup.
 struct DominatingLLVMValue {
   typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
 
   /// Answer whether the given value needs extra work to be saved.

lib/CodeGen/CodeGenFunction.cpp

 }
 
 llvm::DebugLoc CodeGenFunction::SourceLocToDebugLoc(SourceLocation Location) {
   if (CGDebugInfo *DI = getDebugInfo())
     return DI->SourceLocToDebugLoc(Location);
 
   return llvm::DebugLoc();
 }
+
+llvm::Value *
+CodeGenFunction::FormResolverCondition(const ResolverOption &RO) {
+  llvm::Value *TrueCondition = nullptr;
+  if (!RO.AttrInfo.Architecture.empty())
+    TrueCondition = EmitX86CpuIs(RO.AttrInfo.Architecture);
+
+  if (!RO.AttrInfo.Features.empty()) {
+    SmallVector<StringRef, 8> FeatureList;
+    std::for_each(std::begin(RO.AttrInfo.Features),
+                  std::end(RO.AttrInfo.Features),
+                  [&FeatureList](const std::string &Feature) {
+                    FeatureList.push_back(StringRef{Feature}.substr(1));
+                  });
+    llvm::Value *FeatureCmp = EmitX86CpuSupports(FeatureList);
+    TrueCondition = TrueCondition
+                        ? Builder.CreateAnd(TrueCondition, FeatureCmp)
+                        : FeatureCmp;
+  }
+  return TrueCondition;
+}
+
+void CodeGenFunction::EmitMultiVersionResolver(
+    llvm::Function *ResolverFunc, ArrayRef<ResolverOption> ResolverOptions) {
+  assert((getContext().getTargetInfo().getTriple().getArch() ==
+              llvm::Triple::x86 ||
+          getContext().getTargetInfo().getTriple().getArch() ==
+              llvm::Triple::x86_64) &&
+         "Only implemented for x86 targets");
+
+  // Main function's basic block.
+  llvm::BasicBlock *CurBlock = createBasicBlock("entry", ResolverFunc);
+
+  llvm::Function *DefaultFunc = nullptr;
+  for (const ResolverOption &RO : ResolverOptions) {
+    Builder.SetInsertPoint(CurBlock);
+    llvm::Value *TrueCondition = FormResolverCondition(RO);
+
+    if (!TrueCondition) {
+      DefaultFunc = RO.Function;
+    } else {
+      llvm::BasicBlock *RetBlock = createBasicBlock("ro_ret", ResolverFunc);
+      llvm::IRBuilder<> RetBuilder(RetBlock);
+      RetBuilder.CreateRet(RO.Function);
+      CurBlock = createBasicBlock("ro_else", ResolverFunc);
+      Builder.CreateCondBr(TrueCondition, RetBlock, CurBlock);
+    }
+  }
+  assert(DefaultFunc && "No default version?");
+  // Emit return from the 'else-ist' block.
+  Builder.SetInsertPoint(CurBlock);
+  Builder.CreateRet(DefaultFunc);
+}

lib/CodeGen/CodeGenModule.h

private:
   std::vector<GlobalDecl> DeferredDeclsToEmit;
   void addDeferredDeclToEmit(GlobalDecl GD) {
     DeferredDeclsToEmit.emplace_back(GD);
   }
 
   /// List of alias we have emitted. Used to make sure that what they point to
   /// is defined once we get to the end of the of the translation unit.
   std::vector<GlobalDecl> Aliases;
+  std::vector<GlobalDecl> MultiVersionFuncs;
 
   typedef llvm::StringMap<llvm::TrackingVH<llvm::Constant> > ReplacementsTy;
   ReplacementsTy Replacements;
 
   /// List of global values to be replaced with something else. Used when we
   /// want to replace a GlobalValue but can't identify it by its mangled name
   /// anymore (because the name is already taken).
   llvm::SmallVector<std::pair<llvm::GlobalValue *, llvm::Constant *>, 8>
public:
   /// with the specified type instead of whatever the normal requested type
   /// would be. If IsForDefinition is true, it is guranteed that an actual
   /// global with type Ty will be returned, not conversion of a variable with
   /// the same mangled name but some other type.
   llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D,
                                      llvm::Type *Ty = nullptr,
                                      ForDefinition_t IsForDefinition
                                        = NotForDefinition);
+  std::string MakeMultiVersionName(StringRef MangledName, const Decl *D);
 
   /// Return the address of the given function. If Ty is non-null, then this
   /// function will use the specified type if it has to create it.
   llvm::Constant *GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty = nullptr,
                                     bool ForVTable = false,
                                     bool DontDefer = false,
                                     ForDefinition_t IsForDefinition
                                       = NotForDefinition);
public:
   llvm::Constant *getNullPointer(llvm::PointerType *T, QualType QT);
 
 private:
   llvm::Constant *GetOrCreateLLVMFunction(
       StringRef MangledName, llvm::Type *Ty, GlobalDecl D, bool ForVTable,
       bool DontDefer = false, bool IsThunk = false,
       llvm::AttributeList ExtraAttrs = llvm::AttributeList(),
       ForDefinition_t IsForDefinition = NotForDefinition);
+  llvm::Constant *GetOrCreateLLVMFunctionOrMultiVersion(
+      StringRef MangledName, llvm::Type *Ty, GlobalDecl D, bool ForVTable,
+      bool DontDefer = false, bool IsThunk = false,
+      llvm::AttributeList ExtraAttrs = llvm::AttributeList(),
+      ForDefinition_t IsForDefinition = NotForDefinition);
 
   llvm::Constant *GetOrCreateLLVMGlobal(StringRef MangledName,
                                         llvm::PointerType *PTy,
                                         const VarDecl *D,
                                         ForDefinition_t IsForDefinition
                                           = NotForDefinition);
 
   void setNonAliasAttributes(const Decl *D, llvm::GlobalObject *GO);
 
   /// Set function attributes for a function declaration.
   void SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
                              bool IsIncompleteFunction, bool IsThunk,
                              ForDefinition_t IsForDefinition);
 
   void EmitGlobalDefinition(GlobalDecl D, llvm::GlobalValue *GV = nullptr);
+  void EmitMultiVersionResolver(StringRef ResolverName, const FunctionDecl *FD);
 
   void EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);
+  llvm::GlobalValue *GetOrCreateMultiVersionIFunc(GlobalDecl GD,
+                                                  llvm::Type *DeclTy,
+                                                  StringRef MangledName,
+                                                  const FunctionDecl *FD,
+                                                  llvm::GlobalValue *GV);
   void EmitGlobalVarDefinition(const VarDecl *D, bool IsTentative = false);
   void EmitAliasDefinition(GlobalDecl GD);
   void emitIFuncDefinition(GlobalDecl GD);
   void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);
   void EmitObjCIvarInitializations(ObjCImplementationDecl *D);
   
   // C++ related functions.
 
private:
 
   /// Call replaceAllUsesWith on all pairs in Replacements.
   void applyReplacements();
 
   /// Call replaceAllUsesWith on all pairs in GlobalValReplacements.
   void applyGlobalValReplacements();
 
   void checkAliases();
+  void checkMultiversions();
 
   /// Emit any vtables which we deferred and still have a use for.
   void EmitDeferredVTables();
 
   /// Emit a dummy function that reference a CoreFoundation symbol when
   /// @available is used on Darwin.
   void emitAtAvailableLinkGuard();
 

lib/CodeGen/CodeGenModule.cpp

for (;;) {
     if (!GIS2)
       return nullptr;
     if (!Visited.insert(GIS2).second)
       return nullptr;
     C = GIS2->getIndirectSymbol();
   }
 }
 
+void CodeGenModule::EmitMultiVersionResolver(StringRef MangledName,
+                                             const FunctionDecl *FD) {
+  llvm::Function *ResolverFunc =
+      cast<llvm::Function>(GetGlobalValue((MangledName + ".resolver").str()));
+  SmallVector<CodeGenFunction::ResolverOption, 8> ResolverOptions;
+  for (FunctionDecl *CurFD : FD->redecls()) {
+    std::string FuncName = MakeMultiVersionName(MangledName, CurFD);
+    llvm::Constant *Func = GetGlobalValue(FuncName);
+    if (!Func) {
+      GlobalDecl GD{CurFD};
+      if (CurFD->isThisDeclarationADefinition()) {
+        // If the function is defined, make sure we emit it.
+        EmitGlobalDefinition(GD);
+        Func = GetGlobalValue(FuncName);
+      } else {
+        // We still need to create declarations, since the resolver needs them.
+        const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
+        llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
+        Func = GetAddrOfFunction(GD, Ty, /*ForVTable=*/false,
+                                 /*DontDefer=*/false, ForDefinition);
+      }
+      assert(Func && "This should have just been created");
+    }
+
+    ResolverOptions.emplace_back(CurFD->getAttr<TargetAttr>()->parse(),
+                                 cast<llvm::Function>(Func));
+  }
+
+  // Sort resolver options.
+  auto *TargetInfo = &Context.getTargetInfo();
+  auto CmpFunc = [TargetInfo](StringRef LHS, StringRef RHS) {
+    return TargetInfo->compareCpusAndFeatures(LHS, RHS);
+  };
+  std::sort(std::begin(ResolverOptions), std::end(ResolverOptions),
+            [CmpFunc](const CodeGenFunction::ResolverOption &LHS,
+                      const CodeGenFunction::ResolverOption &RHS) {
+              return CmpFunc(LHS.AttrInfo.getHighestPriority(CmpFunc),
+                             RHS.AttrInfo.getHighestPriority(CmpFunc));
+            });
+  CodeGenFunction CGF(*this);
+  CGF.EmitMultiVersionResolver(ResolverFunc, ResolverOptions);
+}
+
 void CodeGenModule::checkAliases() {
   // Check if the constructed aliases are well formed. It is really unfortunate
   // that we have to do this in CodeGen, but we only construct mangled names
   // and aliases during codegen.
   bool Error = false;
   DiagnosticsEngine &Diags = getDiags();
   for (const GlobalDecl &GD : Aliases) {
     const auto *D = cast<ValueDecl>(GD.getDecl());
for (const GlobalDecl &GD : Aliases) {
     StringRef MangledName = getMangledName(GD);
     llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
     auto *Alias = dyn_cast<llvm::GlobalIndirectSymbol>(Entry);
     Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
     Alias->eraseFromParent();
   }
 }
 
+void CodeGenModule::checkMultiversions() {
+  // Cleanup the IFuncs calls for multiversioning.
+  for (const GlobalDecl &GD : MultiVersionFuncs) {
+    bool DefaultFound = false;
+    for (auto *Decl : GD.getDecl()->getMostRecentDecl()->redecls())
+      if (Decl->getAttr<TargetAttr>()->getFeaturesStr() == "default")
+        DefaultFound = true;
+
+    StringRef MangledName = getMangledName(GD);
+    llvm::GlobalValue *BaseFunc = GetGlobalValue(MangledName);
+    llvm::GlobalValue *IFunc = GetGlobalValue((MangledName + ".ifunc").str());
+    assert(IFunc && "Multiversioning not legal without an IFunc");
+    if (!DefaultFound && cast<FunctionDecl>(GD.getDecl())->isDefined()) {
+      Diags.Report(
+          cast<FunctionDecl>(GD.getDecl())->getFirstDecl()->getLocation(),
+          diag::err_target_without_default);
+      // In the error case, replace all uses with an undef.
+      if (BaseFunc) {
+        BaseFunc->replaceAllUsesWith(
+            llvm::UndefValue::get(BaseFunc->getType()));
+        BaseFunc->eraseFromParent();
+      }
+      continue;
+    }
+
+    if (cast<FunctionDecl>(GD.getDecl())->isDefined())
+      EmitMultiVersionResolver(
+          MangledName, cast<FunctionDecl>(GD.getDecl()->getMostRecentDecl()));
+    if (BaseFunc)
+      BaseFunc->replaceAllUsesWith(
+          llvm::ConstantExpr::getBitCast(IFunc, BaseFunc->getType()));
+  }
+}
+
 void CodeGenModule::clear() {
   DeferredDeclsToEmit.clear();
   if (OpenMPRuntime)
     OpenMPRuntime->clear();
 }
 
 void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags,
                                        StringRef MainFile) {

 }
 
 void CodeGenModule::Release() {
   EmitDeferred();
   EmitVTablesOpportunistically();
   applyGlobalValReplacements();
   applyReplacements();
   checkAliases();
+  checkMultiversions();
   EmitCXXGlobalInitFunc();
   EmitCXXGlobalDtorFunc();
   EmitCXXThreadLocalInitFunc();
   if (ObjCRuntime)
     if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
       AddGlobalCtor(ObjCInitFunction);
   if (Context.getLangOpts().CUDA && !Context.getLangOpts().CUDAIsDevice &&
       CUDARuntime) {
if (const auto *VD = dyn_cast<VarDecl>(D))
     return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
   
   llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
 }
 
 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
                                                       llvm::Function *NewFn);
 
+std::string CodeGenModule::MakeMultiVersionName(StringRef MangledName,
+                                                const Decl *D) {
+  assert(D && "Decl cannot be null");
+  const auto *TA = D->getAttr<TargetAttr>();
+  assert(TA && "Decl must have a Target Attribute");
+  auto Append = TA->multiVersionMangleAddition();
+  if (Append.empty())
+    return MangledName;
+  return (MangledName + "." + Append).str();
+}
+
+llvm::GlobalValue *CodeGenModule::GetOrCreateMultiVersionIFunc(
+    GlobalDecl GD, llvm::Type *DeclTy, StringRef MangledName,
+    const FunctionDecl *FD, llvm::GlobalValue *GV) {
+  std::string IFuncName = (MangledName + ".ifunc").str();
+  llvm::GlobalValue *IFuncGV = GetGlobalValue(IFuncName);
+
+  if (IFuncGV)
+    return IFuncGV;
+
+  // Since this is the first time we've created this IFunc, make sure
+  // that we put this multiversioned function into the list to be 
+  // replaced later.
+  MultiVersionFuncs.push_back(GD);
+
+  std::string ResolverName = (MangledName + ".resolver").str();
+  llvm::Type *ResolverType = llvm::FunctionType::get(
+      llvm::PointerType::get(DeclTy,
+                             Context.getTargetAddressSpace(FD->getType())),
+      false);
+  llvm::Constant *Resolver =
+      GetOrCreateLLVMFunction(ResolverName, ResolverType, GlobalDecl{},
+                              /*ForVTable=*/false);
+  llvm::GlobalIFunc *GIF = llvm::GlobalIFunc::create(
+      DeclTy, 0, llvm::Function::ExternalLinkage, "", Resolver, &getModule());
+  GIF->setName(IFuncName);
+  SetCommonAttributes(FD, GIF);
+
+  return GIF;
+}
+
+/// GetOrCreateLLVMFunctionOrMultiVersion - Wrapper for GetOrCreateLLVMFunction
+/// that will also check to see if this is a FunctionDecl that is
+/// multiversioned. In the case where this is NOT for a definition, this will
+/// create the llvm GlobalValue, but return the iFunc. If this FOR definition,
+/// it will return the newly mangled name.
+llvm::Constant *CodeGenModule::GetOrCreateLLVMFunctionOrMultiVersion(
+    StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable,
+    bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs,
+    ForDefinition_t IsForDefinition) {
+  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
+  std::string MVName;
+
+  if (FD->getMultiVersionKind() ==
+      FunctionDecl::MultiVersionKind::MultiVersion) {
+    llvm::GlobalValue *ExistingDef = GetGlobalValue(MangledName);
+    GetOrCreateMultiVersionIFunc(GD, Ty, MangledName, FD, ExistingDef);
+    if (IsForDefinition == ForDefinition) {
+      MVName = MakeMultiVersionName(MangledName, FD);
+      MangledName = MVName;
+    }
+  }
+
+  return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
+                                 IsThunk, ExtraAttrs, IsForDefinition);
+}
+
 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
 /// module, create and return an llvm Function with the specified type. If there
 /// is something in the module with the specified name, return it potentially
 /// bitcasted to the right type.
 ///
 /// If D is non-null, it specifies a decl that correspond to this.  This is used
 /// to set the attributes on the function when it is first created.
 llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
   // If there was no specific requested type, just convert it now.
   if (!Ty) {
     const auto *FD = cast<FunctionDecl>(GD.getDecl());
     auto CanonTy = Context.getCanonicalType(FD->getType());
     Ty = getTypes().ConvertFunctionType(CanonTy, FD);
   }
 
   StringRef MangledName = getMangledName(GD);
-  return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
-                                 /*IsThunk=*/false, llvm::AttributeList(),
-                                 IsForDefinition);
+  return GetOrCreateLLVMFunctionOrMultiVersion(
+      MangledName, Ty, GD, ForVTable, DontDefer,
+      /*IsThunk=*/false, llvm::AttributeList(), IsForDefinition);
 }
 
 static const FunctionDecl *
 GetRuntimeFunctionDecl(ASTContext &C, StringRef Name) {
   TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();
   DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
 
   IdentifierInfo &CII = C.Idents.get(Name);

lib/Sema/SemaDecl.cpp

if (OldMethod && NewMethod) {
       // 2 CXXMethodDecls referring to the same function will be injected.
       // We don't want a redeclaration error.
       bool IsClassScopeExplicitSpecialization =
                               OldMethod->isFunctionTemplateSpecialization() &&
                               NewMethod->isFunctionTemplateSpecialization();
       bool isFriend = NewMethod->getFriendObjectKind();
 
       if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
-          !IsClassScopeExplicitSpecialization) {
+          !IsClassScopeExplicitSpecialization ) {
         //    -- Member function declarations with the same name and the
         //       same parameter types cannot be overloaded if any of them
         //       is a static member function declaration.
         if (OldMethod->isStatic() != NewMethod->isStatic()) {
           Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
           Diag(OldLocation, PrevDiag) << Old << Old->getType();
           return true;
         }
 
+        if (New->getMultiVersionKind() !=
+            FunctionDecl::MultiVersionKind::MultiVersion) {
+          // Multiversioning allows multiple decls.
+
           // C++ [class.mem]p1:
           //   [...] A member shall not be declared twice in the
           //   member-specification, except that a nested class or member
           //   class template can be declared and then later defined.
           if (!inTemplateInstantiation()) {
             unsigned NewDiag;
             if (isa<CXXConstructorDecl>(OldMethod))
               NewDiag = diag::err_constructor_redeclared;
             else if (isa<CXXDestructorDecl>(NewMethod))
               NewDiag = diag::err_destructor_redeclared;
             else if (isa<CXXConversionDecl>(NewMethod))
               NewDiag = diag::err_conv_function_redeclared;
             else
               NewDiag = diag::err_member_redeclared;
 
             Diag(New->getLocation(), NewDiag);
           } else {
-          Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
+            Diag(New->getLocation(),
+                 diag::err_member_redeclared_in_instantiation)
                 << New << New->getType();
           }
           Diag(OldLocation, PrevDiag) << Old << Old->getType();
           return true;
+        }
 
       // Complain if this is an explicit declaration of a special
       // member that was initially declared implicitly.
       //
       // As an exception, it's okay to befriend such methods in order
       // to permit the implicit constructor/destructor/operator calls.
       } else if (OldMethod->isImplicit()) {
         if (isFriend) {
bool Sema::shouldLinkDependentDeclWithPrevious(Decl *D, Decl *PrevDecl) {
   //       template<typename T> class C2 { friend void func() { } };
   //
   // This code snippet is a valid code unless both templates are instantiated.
   return !(D->getLexicalDeclContext()->isDependentContext() &&
            D->getDeclContext()->isFileContext() &&
            D->getFriendObjectKind() != Decl::FOK_None);
 }
 
+static void setMultiVersionKind(FunctionDecl *OldFD, FunctionDecl *NewFD,
+                                FunctionDecl::MultiVersionKind Kind) {
+  for (FunctionDecl *F : OldFD->redecls())
+    F->setMultiVersionKind(Kind);
+  NewFD->setMultiVersionKind(Kind);
+}
+
+bool Sema::CheckMultiVersionOption(const FunctionDecl *FD) {
+  auto *TA = FD->getAttr<TargetAttr>();
+
+  if (TA->getFeaturesStr() == "default")
+    return true;
+  auto ParseInfo = TA->parse();
+
+  enum BadOption { BOFeature = 0, BOArch = 1 };
+
+  // Need to check isValidCPUName since it checks X86 vs X86-64 CPUs.  From
+  // there, the subset of valid ones is captured in validateCpuIs.
+  if (!ParseInfo.Architecture.empty() &&
+      (!Context.getTargetInfo().validateCpuIs(ParseInfo.Architecture) ||
+       !Context.getTargetInfo().isValidCPUName(ParseInfo.Architecture))) {
+    Diag(TA->getLocation(), diag::err_bad_multiversion_option)
+        << BOArch << ParseInfo.Architecture;
+    return false;
+  }
+
+  for (auto &Feature : ParseInfo.Features) {
+    auto BareFeat = StringRef{Feature}.substr(1);
+    // Negative options never allowed.
+    if (Feature[0] == '-') {
+      Diag(TA->getLocation(), diag::err_bad_multiversion_option)
+          << BOFeature << ("no-" + BareFeat).str();
+      return false;
+    }
+    if (!Context.getTargetInfo().validateCpuSupports(BareFeat) ||
+        !Context.getTargetInfo().isValidFeatureName(BareFeat)) {
+      Diag(TA->getLocation(), diag::err_bad_multiversion_option)
+          << BOFeature << BareFeat;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool Sema::CheckMultiVersionOptions(const FunctionDecl *OldFD,
+                                    const FunctionDecl *NewFD) {
+  // FIXME: Implement for more than X86.  Requires CPUIs and CPUSupports
+  // for each new architecture.
+  auto Arch = Context.getTargetInfo().getTriple().getArch();
+  if (Arch != llvm::Triple::x86_64 && Arch != llvm::Triple::x86) {
+    Diag(NewFD->getLocation(), diag::err_target_unimplemented_arch);
+    return false;
+  }
+
+  bool result = true;
+  for (const auto *FD : OldFD->redecls())
+    result = CheckMultiVersionOption(FD) && result;
+
+  return CheckMultiVersionOption(NewFD) && result;
+}
+
+bool Sema::CheckMultiVersionedDecl(FunctionDecl *NewFD, FunctionDecl *OldFD) {
+  // The first Decl is easy, it is either the 'All' case, or 'None'.
+  if (!OldFD) {
+    if (NewFD->hasAttr<TargetAttr>())
+      NewFD->setMultiVersionKind(FunctionDecl::MultiVersionKind::All);
+    else
+      NewFD->setMultiVersionKind(FunctionDecl::MultiVersionKind::None);
+    return true;
+  }
+
+  auto *TA = NewFD->getAttr<TargetAttr>();
+  switch (OldFD->getMultiVersionKind()) {
+  default:
+    llvm_unreachable("Invalid State for Multiversioning.");
+  case FunctionDecl::MultiVersionKind::Error:
+    // An error case stays an error, mark the new Decl as well.
+    NewFD->setMultiVersionKind(FunctionDecl::MultiVersionKind::Error);
+    return false;
+  case FunctionDecl::MultiVersionKind::None:
+    // A previously unmarked function can convert to the "Partial" (hint-only)
+    // case if this one is marked.
+    if (!TA) {
+      // No change to the Previous Decls, set current to correct value.
+      NewFD->setMultiVersionKind(FunctionDecl::MultiVersionKind::None);
+      return true;
+    }
+    setMultiVersionKind(OldFD, NewFD, FunctionDecl::MultiVersionKind::Partial);
+    return true;
+  case FunctionDecl::MultiVersionKind::All:
+    // If all previous Decls have a target attribute, but none are different
+    // this can become a 'partial' if there is no attribute on this Decl, or it
+    // can become a multiversion if this is different.
+    if (!TA) {
+      setMultiVersionKind(OldFD, NewFD,
+                          FunctionDecl::MultiVersionKind::Partial);
+      return true;
+    }
+    // Could potentially convert to a 'MultiVersion' state, check this
+    // case.  Only have to check the last one, since it is the same as the
+    // previous ones.
+    if (TA->parse() != OldFD->getAttr<TargetAttr>()->parse()) {
+      if (!CheckMultiVersionOptions(OldFD, NewFD)) {
+        setMultiVersionKind(OldFD, NewFD,
+                            FunctionDecl::MultiVersionKind::Error);
+        return false;
+      }
+      setMultiVersionKind(OldFD, NewFD,
+                          FunctionDecl::MultiVersionKind::MultiVersion);
+      return true;
+    }
+    // If this doesn't convert it to a multi-version, this is clearly a 'all'
+    // case.
+    NewFD->setMultiVersionKind(FunctionDecl::MultiVersionKind::All);
+    return true;
+  case FunctionDecl::MultiVersionKind::MultiVersion:
+    // If the existing Decls are already in a MultiVersion case, a 'target'
+    // attribute is required on this one. Validate that it is legal on this one.
+    if (!TA) {
+      Diag(NewFD->getLocation(), diag::err_target_required_in_redecl);
+      Diag(OldFD->getFirstDecl()->getLocation(),
+           diag::note_previous_declaration);
+      setMultiVersionKind(OldFD, NewFD, FunctionDecl::MultiVersionKind::Error);
+      return false;
+    } else if (!CheckMultiVersionOption(NewFD)) {
+      setMultiVersionKind(OldFD, NewFD, FunctionDecl::MultiVersionKind::Error);
+      return false;
+    }
+
+    // Otherwise, just continue the multiversion situation.
+    NewFD->setMultiVersionKind(FunctionDecl::MultiVersionKind::MultiVersion);
+    return true;
+  case FunctionDecl::MultiVersionKind::Partial:
+    // A partial not adding a Target Attribute is fine, everything stays as
+    // partial.
+    if (!TA) {
+      NewFD->setMultiVersionKind(FunctionDecl::MultiVersionKind::Partial);
+      return true;
+    }
+    // A partial situation is not allowed to convert to a MV, so ensure that
+    // this target doesn't cause that situation.
+    FunctionDecl *LastFeaturesStr = OldFD;
+    // Note: Null check shouldn't be necessary.
+    while (LastFeaturesStr && !LastFeaturesStr->hasAttr<TargetAttr>())
+      LastFeaturesStr = LastFeaturesStr->getPreviousDecl();
+
+    assert(LastFeaturesStr &&
+           "How can we be 'partial' without an existing target attribute?");
+    if (TA->parse() != LastFeaturesStr->getAttr<TargetAttr>()->parse()) {
+      Diag(NewFD->getLocation(),
+           diag::err_target_causes_illegal_multiversioning);
+      // Note on all previous decls that lack a target attr.
+      for (const auto *Cur : OldFD->redecls())
+        if (!Cur->hasAttr<TargetAttr>() ||
+            Cur->getAttr<TargetAttr>()->isInherited())
+          Diag(Cur->getLocation(), diag::note_previous_declaration);
+      setMultiVersionKind(OldFD, NewFD, FunctionDecl::MultiVersionKind::Error);
+      return false;
+    }
+    NewFD->setMultiVersionKind(FunctionDecl::MultiVersionKind::Partial);
+    return true;
+  }
+}
+
 /// \brief Perform semantic checking of a new function declaration.
 ///
 /// Performs semantic analysis of the new function declaration
 /// NewFD. This routine performs all semantic checking that does not
 /// require the actual declarator involved in the declaration, and is
 /// used both for the declaration of functions as they are parsed
 /// (called via ActOnDeclarator) and for the declaration of functions
 /// that have been instantiated via C++ template instantiation (called
if (!OldMD || !OldMD->isStatic()) {
           AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
 
         Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
           << FixItHint::CreateInsertion(AddConstLoc, " const");
       }
     }
   }
 
+  // Attribute target requires all declarations to have the 'target'
+  // attribute.
+  if (!CheckMultiVersionedDecl(NewFD, OldDecl ? dyn_cast<FunctionDecl>(OldDecl)
+                                              : nullptr))
+    NewFD->setInvalidDecl();
+
   if (Redeclaration) {
     // NewFD and OldDecl represent declarations that need to be
     // merged.
     if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
       NewFD->setInvalidDecl();
       return Redeclaration;
     }
 
for (const FunctionDecl *Prev = FD->getPreviousDecl();
     if (FD->getNumParams() == 0)
       PossibleZeroParamPrototype = Prev;
     break;
   }
 
   return MissingPrototype;
 }
 
+// Check to see if this 'redefinition' should be allowed in order to support
+// attribute 'target' redefinition.
+static bool isValidMultiVersion(FunctionDecl *NewFD,
+                                const FunctionDecl *ExistingFD) {
+  if (NewFD->getMultiVersionKind() !=
+      FunctionDecl::MultiVersionKind::MultiVersion)
+    return false;
+
+  TargetAttr *NewTA = NewFD->getAttr<TargetAttr>();
+  const auto NewTAParsed = NewTA->parse();
+  // Prohibit duplicate definitions.
+  for (const auto *FD : ExistingFD->redecls()) {
+    if (FD->isThisDeclarationADefinition()) {
+      TargetAttr *TA = FD->getAttr<TargetAttr>();
+      if (TA && !TA->isInherited() &&
+          TA->parse() == NewTAParsed)
+        return false;
+    }
+  }
+  return true;
+}
+
 void
 Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
                                    const FunctionDecl *EffectiveDefinition,
                                    SkipBodyInfo *SkipBody) {
   const FunctionDecl *Definition = EffectiveDefinition;
   if (!Definition)
     if (!FD->isDefined(Definition))
       return;
 
   if (canRedefineFunction(Definition, getLangOpts()))
     return;
 
+  if (isValidMultiVersion(FD, Definition))
+    return;
+
   // Don't emit an error when this is redefinition of a typo-corrected
   // definition.
   if (TypoCorrectedFunctionDefinitions.count(Definition))
     return;
 
   // If we don't have a visible definition of the function, and it's inline or
   // a template, skip the new definition.
   if (SkipBody && !hasVisibleDefinition(Definition) &&

test/CodeGen/attr-target-multiversion.c

+// RUN: %clang_cc1 -triple x86_64-linux-gnu -target-cpu x86-64 -emit-llvm %s -o - | FileCheck %s
+
+//CHECK: @foo.ifunc = ifunc i8 (i{{[0-9]+}}), i8 (i{{[0-9]+}})* ()* @foo.resolver
+//CHECK: @bar.ifunc = ifunc i8 (...), i8 (...)* ()* @bar.resolver
+//CHECK: @baz.ifunc = ifunc i8 (), i8 ()* ()* @baz.resolver
+
+__attribute__((target("arch=knl"))) char foo(int);
+
+// This function causes emission of the resolver, check it.
+// CHECK: define i8 (i{{[0-9]+}})* @foo.resolver() {
+// CHECK: ret i8 (i{{[0-9]+}})* @foo.arch_knl
+// AAACHECK: ret i8 (i{{[0-9]+}})* @foo.arch_knl
+// AAACHECK: ret i8 (i{{[0-9]+}})* @foo.arch_skylake
+// AAACHECK: ret i8 (i{{[0-9]+}})* @foo.arch_sse4.2
+// AAACHECK: ret i8 (i{{[0-9]+}})* @foo.arch_amdfam10
+// AAACHECK: ret i8 (i{{[0-9]+}})* @foo.arch_atom
+// AAACHECK: ret i8 (i{{[0-9]+}})* @foo
+
+// CHECK: define signext i8 @foo(
+__attribute__((target("default"))) char foo(int i) {
+  return 0 + i;
+}
+
+// CHECK: define signext i8 @user1()
+// CHECK: call signext i8 @foo.ifunc(i{{[0-9]+}} 1)
+char user1(){
+  return foo(1);
+}
+
+// CHECK: define signext i8 @foo.sse4.2(
+__attribute__((target("sse4.2"))) char foo(int i) {
+  return 1 + i;
+}
+
+// CHECK: define signext i8 @user2()
+// CHECK: call signext i8 @foo.ifunc(i{{[0-9]+}} 2)
+char user2(){
+  return foo(2);
+}
+
+// CHECK: define signext i8 @foo.arch_atom(
+__attribute__((target("arch=atom"))) char foo(int i) {
+  return 2 + i;
+}
+
+__attribute__((target("arch=amdfam10"))) char foo(int);
+
+// CHECK: define signext i8 @user3()
+// CHECK: call signext i8 @foo.ifunc(i{{[0-9]+}} 3)
+char user3() {
+  return foo(3);
+}
+
+__attribute__((target("arch=skylake"))) char foo(int);
+
+__attribute__((target("arch=knl"))) char bar();
+
+__attribute__((target("default"))) char bar();
+
+
+// CHECK: define signext i8 @user4()
+// CHECK: call signext i8 (...) @bar.ifunc()
+char user4() {
+  return bar();
+}
+
+// CHECK: declare i8 (...)* @bar.resolver(){{$}}
+
+__attribute__((target("arch=knl"))) char baz(void);
+
+__attribute__((target("default"))) char baz();
+
+
+// CHECK: define signext i8 @user5()
+// CHECK: call signext i8 @baz.ifunc()
+char user5() {
+  return baz();
+}
+// CHECK: declare i8 ()* @baz.resolver(){{$}}
+
+// Function Declarations are generated later, so ensure that they
+// actually exist.
+// CHECK-DAG: declare signext i8 @foo.arch_knl
+// CHECK-DAG: declare signext i8 @foo.arch_amdfam10
+// CHECK-DAG: declare signext i8 @foo.arch_skylake

test/CodeGenCXX/attr-target-multiversion.cpp

+// RUN: %clang_cc1 -triple x86_64-linux-gnu -target-cpu x86-64 -emit-llvm %s -o - | FileCheck %s
+
+struct S {
+  __attribute__((target("arch=sandybridge")))
+  int mv(){return 3;}
+  __attribute__((target("arch=ivybridge")))
+  int mv(){return 2;}
+  __attribute__((target("default")))
+  int mv(){ return 1;}
+};
+
+// CHECK: @_ZN1S2mvEv.ifunc = ifunc i{{[0-9]+}} (%struct.S*), i{{[0-9]+}} (%struct.S*)* ()* @_ZN1S2mvEv.resolver
+
+// CHECK: define void @_Z3foov()
+// CHECK: call i{{[0-9]+}} @_ZN1S2mvEv.ifunc(%struct.S* %
+void foo() {
+  S s;
+  s.mv();
+}
+
+// CHECK: define i{{[0-9]+}} (%struct.S*)* @_ZN1S2mvEv.resolver
+// CHECK: ret i{{[0-9]+}} (%struct.S*)* @_ZN1S2mvEv.arch_sandybridge
+// CHECK: ret i{{[0-9]+}} (%struct.S*)* @_ZN1S2mvEv.arch_ivybridge
+// CHECK: ret i{{[0-9]+}} (%struct.S*)* @_ZN1S2mvEv
+
+// CHECK-DAG: define linkonce_odr i{{[0-9]+}} @_ZN1S2mvEv.arch_sandybridge(%struct.S* %this)
+// CHECK-DAG: define linkonce_odr i{{[0-9]+}} @_ZN1S2mvEv.arch_ivybridge(%struct.S* %this)
+// CHECK-DAG: define linkonce_odr i{{[0-9]+}} @_ZN1S2mvEv(%struct.S* %this)

test/Sema/attr-target-multiversion.c

+// RUN: %clang_cc1 -triple x86_64-linux -fsyntax-only -verify -emit-llvm-only %s
+// RUN: %clang_cc1 -triple x86_64-linux -fsyntax-only -verify -emit-llvm-only -DCHECK_DEFAULT %s
+
+#if defined(CHECK_DEFAULT)
+__attribute__((target("arch=sandybridge")))
+//expected-error@+1 {{function multiversioning with 'target' requires a 'default' implementation}}
+void no_default(){}
+__attribute__((target("arch=ivybridge")))
+void no_default(){}
+#else
+// Only multiversioning causes issues with redeclaration changing 'target'.
+__attribute__((target("arch=sandybridge")))
+void fine_since_no_mv();
+void fine_since_no_mv();
+
+void also_fine_since_no_mv();
+__attribute__((target("arch=sandybridge")))
+void also_fine_since_no_mv();
+
+__attribute__((target("arch=sandybridge")))
+void also_fine_since_no_mv2();
+__attribute__((target("arch=sandybridge")))
+void also_fine_since_no_mv2();
+void also_fine_since_no_mv2();
+
+__attribute__((target("arch=sandybridge")))
+void mv(){}
+__attribute__((target("arch=ivybridge")))
+void mv(){}
+__attribute__((target("default")))
+void mv(){}
+
+void redecl_causes_mv();
+__attribute__((target("arch=sandybridge")))
+void redecl_causes_mv();
+// expected-error@+3 {{function redeclaration causes a multiversioned function, but a previous declaration lacks a 'target' attribute}}
+// expected-note@-4 {{previous declaration is here}}
+__attribute__((target("arch=ivybridge")))
+void redecl_causes_mv();
+
+__attribute__((target("arch=sandybridge")))
+void redecl_causes_mv2();
+void redecl_causes_mv2();
+// expected-error@+3 {{function redeclaration causes a multiversioned function, but a previous declaration lacks a 'target' attribute}}
+// expected-note@-2 {{previous declaration is here}}
+__attribute__((target("arch=ivybridge")))
+void redecl_causes_mv2();
+
+__attribute__((target("arch=sandybridge")))
+void redecl_without_attr();
+__attribute__((target("arch=ivybridge")))
+void redecl_without_attr();
+// expected-error@+2 {{function redeclaration is missing 'target' attribute in a multiversioned function}}
+// expected-note@-4 {{previous declaration is here}}
+void redecl_without_attr();
+
+__attribute__((target("arch=sandybridge")))
+void multiversion_with_predecl();
+__attribute__((target("default")))
+void multiversion_with_predecl();
+__attribute__((target("arch=sandybridge")))
+void multiversion_with_predecl(){}
+__attribute__((target("default")))
+void multiversion_with_predecl(){}
+//expected-error@+3 {{redefinition of 'multiversion_with_predecl'}}
+//expected-note@-2 {{previous definition is here}}
+__attribute__((target("arch=sandybridge")))
+void multiversion_with_predecl(){}
+
+__attribute__((target("arch=sandybridge")))
+void multiversion_with_predecl2();
+__attribute__((target("arch=sandybridge")))
+void multiversion_with_predecl2(){}
+__attribute__((target("default")))
+void multiversion_with_predecl2();
+//expected-error@+3 {{redefinition of 'multiversion_with_predecl2'}}
+//expected-note@-4 {{previous definition is here}}
+__attribute__((target("arch=sandybridge")))
+void multiversion_with_predecl2(){}
+__attribute__((target("default")))
+void multiversion_with_predecl2(){}
+
+// All the following are fine in normal 'target' mode, but not
+// in multiversion mode.
+// expected-error@+1 {{function multiversioning doesn't support feature 'sgx'}}
+__attribute__((target("sgx")))
+void badMVFeature();
+__attribute__((target("sse")))
+void badMVFeature();
+
+__attribute__((target("mmx")))
+void badMVFeature2();
+// expected-error@+1 {{function multiversioning doesn't support feature 'lwp'}}
+__attribute__((target("lwp")))
+void badMVFeature2();
+
+__attribute__((target("arch=ivybridge,mmx")))
+void badMVFeature3();
+// expected-error@+1 {{function multiversioning doesn't support feature 'lwp'}}
+__attribute__((target("arch=skylake,lwp")))
+void badMVFeature3();
+
+// expected-error@+1 {{function multiversioning doesn't support architecture 'k8'}}
+__attribute__((target("arch=k8")))
+void badMVArch();
+__attribute__((target("arch=nehalem")))
+void badMVArch();
+
+__attribute__((target("arch=nehalem")))
+void badMVArch2();
+// expected-error@+1 {{function multiversioning doesn't support architecture 'k8'}}
+__attribute__((target("arch=k8")))
+void badMVArch2();
+
+__attribute__((target("mmx")))
+void badMVNegate();
+// expected-error@+1 {{function multiversioning doesn't support feature 'no-mmx'}}
+__attribute__((target("no-mmx")))
+void badMVNegate();
+
+#endif

test/SemaCXX/attr-target-multiversion.cpp

+// RUN: %clang_cc1 -triple x86_64-linux -fsyntax-only -verify -emit-llvm-only %s
+
+struct S {
+  __attribute__((target("arch=sandybridge")))
+  void mv(){}
+  __attribute__((target("arch=ivybridge")))
+  void mv(){}
+  __attribute__((target("default")))
+  void mv(){}
+};
+
+// Note: Template attribute 'target' isn't implemented in GCC either, and would
+// end up causing some nasty issues attempting it, so ensure that it still gives
+// the same errors as without the attribute.
+template<typename T>
+__attribute__((target("arch=sandybridge")))
+void mv_temp(){}
+
+template<typename T>
+__attribute__((target("arch=ivybridge")))
+//expected-error@+2 {{redefinition of}}
+//expected-note@-5{{previous definition is here}}
+void mv_temp(){}
+
+template<typename T>
+__attribute__((target("default")))
+void mv_temp(){}
+
+void foo() {
+  //expected-error@+2{{no matching function for call to}}
+  //expected-note@-8{{candidate template ignored}}
+  mv_temp<int>();
+}