Implement target_clones multiversioning

[erichkeane]

Summary

As discussed here: https://lwn.net/Articles/691932/

GCC6.0 adds target_clones multiversioning. This functionality is
an odd cross between the cpu_dispatch and 'target' MV, but is compatible
with neither.

This attribute allows you to list all options, then emits a separately
optimized version of each function per-option (similar to the
cpu_specific attribute). It automatically generates a resolver, just
like the other two.

The mangling however, is... ODD to say the least. The mangling format is:
<normal_mangling>.<option string>.<option ordinal>.

However, the 'option ordinal' is where it gets strange. When parsing the
list, 'default' is moved to the end, so "foo,default,bar", foo is 0, bar is 1,
and default is 2.

Otherwise, emission rules should be the same as 'target'.

[aaron.ballman]

Thank you for this! I have some cursory review comments, and possibly more later.

include/clang/Basic/AttrDocs.td

1600 ↗

(On Diff #163880)

It supports the C++ style as well, so perhaps "Clang supports the `target_clones("OPTIONS")` attribute." instead?

1601 ↗

(On Diff #163880)

It can be on a declaration too, can't it?

1602 ↗

(On Diff #163880)

Extraneous space between "versions of"

1607 ↗

(On Diff #163880)

You should probably explain the options a bit more thoroughly around here; nothing explains that the options are architectures, for instance.

1612 ↗

(On Diff #163880)

typo: disregarding

lib/CodeGen/CodeGenModule.cpp

2394 ↗

(On Diff #163880)

Spurious newline?

2559 ↗

(On Diff #163880)

const auto *

lib/Sema/SemaDecl.cpp

9428 ↗

(On Diff #163880)

Rather than repeat this expression in multiple places, I prefer a named local variable.

lib/Sema/SemaDeclAttr.cpp

3014 ↗

(On Diff #163880)

remove -> Remove

[erichkeane]

fix aaron's comments.

[erichkeane]

Based on feedback from @rsmith I've been trying to get this to work with Lambdas like GCC does, though I'm quite confused about how to go about it here. It seems that the lambda definition call operator is deferred, however I'm having a hard time making sure that this happens in the "IFunc" case. I'm still working on it, but it might be a bit.

[rsmith]

include/clang/Basic/Attr.td

2031–2042 ↗

(On Diff #164251)

Sorry, I don't think it's acceptable from a design perspective to have mutable state in an Attr object, even if you can ensure that only one client of the Attr will be using the state at a time. CodeGen is going to need to track its own index into the attribute's list of clones.

include/clang/Basic/AttrDocs.td

1619–1621 ↗

(On Diff #164251)

Can we warn on attributes that contain multiple strings where one or more such strings contains a comma? That seems like it would always be user error.

I think I'd then prefer to document this as: "The versions can either be listed as a comma-separated sequence of string literals or as a single string literal containing a comma-separated list of versions. For compatibility with GCC, the two formats can be mixed. For example, the following will emit 4 versions of the function:"

lib/CodeGen/CodeGenModule.cpp

961–970 ↗

(On Diff #164251)

This chain of ifs and similar things elsewhere make me think we're missing an abstraction. Perhaps FunctionDecl should have a getMultiVersionAttr() and/or getMultiVersionKind() functions?

1043 ↗

(On Diff #164251)

This target index should be part of the GlobalDecl, not tracked alongside it, because it identifies which global we're talking about.

lib/Sema/SemaDecl.cpp

9800–9807 ↗

(On Diff #164251)

We should also disallow multiple TargetClonesAttrs on the same declaration. GCC allows this and then ignores all but the last such attribute; we can do better.

9811–9812 ↗

(On Diff #164251)

Why can't main be multiversioned? That seems like an arbitrary restriction.

9839 ↗

(On Diff #164251)

I would expect the plain English term to not have interior capitalization.

lib/Sema/SemaDeclAttr.cpp

3011 ↗

(On Diff #164251)

Should be something like checkTargetClonesAttrStr to indicate that this is checking one specific string, not the entire attribute.

3018–3029 ↗

(On Diff #164251)

When looping through comma-delimited strings, it's easier to use StringRef::split:

std::pair<StringRef, StringRef> Parts = {{}, Str};
while (!Parts.second.empty()) {
  Parts = Parts.second.split(',');
  StringRef Cur = Parts.first.trim();
  // ...
}

3035–3043 ↗

(On Diff #164251)

Rather than just repeating the problematic portion of the string textually in the diagnostic, pass the StringLiteral into here and use StringLiteral::getLocationOfByte to highlight the problematic source range within the string.

3068–3071 ↗

(On Diff #164251)

Do we need any other validation here? What if there are duplicate versions?

test/CodeGen/attr-cpuspecific.c

14–15 ↗

(On Diff #164251)

Should this really have external linkage? These . suffixes are reserved for vendor-specific manglings that typically should only be used for symbols with internal linkage.

If you really want to give these symbols external linkage, I think they should at least be put in a COMDAT keyed off the primary symbol so that we don't get a mishmash of different suffix combinations from different compilers.

[erichkeane]

Thanks for the feedback @rsmith! I'm working through the lambda issue and a few other things, but will get to this as soon as I can.

include/clang/Basic/Attr.td

2031–2042 ↗

(On Diff #164251)

Alright, I'll see if I can figure that out. I should probably do something similar for the cpu-dispatch, since it actually uses a very similar mechanism.

include/clang/Basic/AttrDocs.td

1619–1621 ↗

(On Diff #164251)

I don't see why not, the warning should be a fairly trivial addition.

lib/CodeGen/CodeGenModule.cpp

961–970 ↗

(On Diff #164251)

I'm not super sure what either buys us... The multiversion attributes are all somewhat different unfortunately, so they would need to be dispatched separately later. The 'getMultiVersionKind' is perhaps useful, though its essentially what isXXXMultiVersion does. I'll think on it, I agree that there is likely an abstraction somewhere between that can improve this...

1043 ↗

(On Diff #164251)

I see. I can definitely do that, I was concerned that adding an int to the GlobalDecl would be an unacceptable increase in size.

lib/Sema/SemaDecl.cpp

9811–9812 ↗

(On Diff #164251)

At the time of implementing 'target', I was unsure of (and still am) how to accomplish this. It would seem that I'd need to make the entry point a wrapper that calls the ifunc. GCC seems to improperly call this (it doesn't emit the 'main' fucntion as far as I can tell).

lib/Sema/SemaDeclAttr.cpp

3068–3071 ↗

(On Diff #164251)

GCC has this annoying feature of just IGNORING duplicate versions. I likely could/should warn about this, but for GCC compat we probably want to support this.

test/CodeGen/attr-cpuspecific.c

14–15 ↗

(On Diff #164251)

I guess I don't really have a good reason to not just pick up the linkage from the original. I'll check to see if I can figure out how I got external linkage in the first place.

[rsmith]

lib/CodeGen/CodeGenModule.cpp

961–970 ↗

(On Diff #164251)

The idea would be that we have an enum that we can perform a covered switch over, so we don't need to remember to update all the relevant places when we add another kind of multiversioning. You already have the code to work out the kind of multiversioning; moving it from SemaDecl.cpp to FunctionDecl then using it where it makes sense in this patch would help, I think.

lib/Sema/SemaDecl.cpp

9811–9812 ↗

(On Diff #164251)

OK, if there's actually a problem with having the main symbol be an ifunc, that seems like a perfectly legitimate reason for the restriction.

[erichkeane]

Fix @rsmith s comments, rebase on the big CPUDispatch refactor.

[lebedev.ri]

In D51650#1305509, @erichkeane wrote:

Fix @rsmith s comments, rebase on the big CPUDispatch refactor.

Ping. What's the status here?

[erichkeane]

In D51650#2418749, @lebedev.ri wrote:

In D51650#1305509, @erichkeane wrote:

Fix @rsmith s comments, rebase on the big CPUDispatch refactor.

Ping. What's the status here?

I haven't looked at it since then :) I thought it was about ready, and just needed review but this never got sufficient attention to get review. It likely needs a rebase (and I'm not sure what other changes have been made in the meantime).

[erichkeane]

Since there seems to be at least a little renewed interest in this from a handful of people lately, I spend the time to rebase this and do some minor cleanup tasks.

[lebedev.ri]

In D51650#2454830, @erichkeane wrote:

Since there seems to be at least a little renewed interest in this from a handful of people lately, I spend the time to rebase this and do some minor cleanup tasks.

FWIW yes, i'm being asked about this periodically (https://github.com/darktable-org/darktable/pull/7075, https://github.com/darktable-org/darktable/pull/7337#discussion_r544925151, etc)
It would be pretty good to be compatible with GCC in this.

[danielkiss]

Hi @erichkeane,

At Arm we are going to add the multiversioning support for Arm targets[1][2]. It would be nice to land this change because we could build top of it.
Please let me know how can I help.

[1] https://github.com/ARM-software/acle/pull/21
[2] https://bugs.llvm.org/show_bug.cgi?id=50400

[erichkeane]

In D51650#3095997, @danielkiss wrote:

Hi @erichkeane,

At Arm we are going to add the multiversioning support for Arm targets[1][2]. It would be nice to land this change because we could build top of it.
Please let me know how can I help.

[1] https://github.com/ARM-software/acle/pull/21
[2] https://bugs.llvm.org/show_bug.cgi?id=50400

Hi Daniel-
This patch initially required that I refactor some stuff with the existing two multiversioning mechanisms (cpu-specific and target) which happened. At a point after that, @lebedev.ri asked for me to rebase it, and I did. However, it never gained attention from reviewers, and life got in the way :)

This needs rebasing/probably some cleanup, plus code review. If you have active/proficient CFE code reviewers who could take a look, I'd be willing to spend some time rebasing.

[danielkiss]

In D51650#3096487, @erichkeane wrote:

This needs rebasing/probably some cleanup, plus code review. If you have active/proficient CFE code reviewers who could take a look, I'd be willing to spend some time rebasing.

Thank you, I will help with the review and ask around here for more eyes.

[erichkeane]

Another rebase, as requested. I am not particularly familiar with this code anymore, so my responses to reviews might not be particularly well informed, but I'm hoping that rust shakes off through the review :)

[echristo]

FWIW I'm a bit rusty in this area myself, but thanks for doing this. Let's see if we can't get Aaron to continue reviewing :)

[erichkeane]

Sadly, I think _I_ am the multiversioning expert (or at least, past-me was), so I'm hoping some of the reviewers @danielkiss can get to join will be able to read/understand this stuff for a quality review.

[echristo]

I think you are these days too :) My offer was "past-past-me". I think
you're probably ok here, I did a rough scan, but getting someone like Aaron
for the attribute support would be good.

[danielkiss]

Thanks for the rebase!

Looks got to me,

-march may make the default same as one of the clone, in this case maybe we don't need to create two versions of the function. This could be solved later IMHO.

clang/lib/Sema/SemaDecl.cpp

10669

[erichkeane]

For the rest of multiversioning we count on the optimizer to remove variants made irrelevant, but I'm not sure opt can do anything like that yet :) But nit made.

[danielkiss]

In D51650#3121789, @erichkeane wrote:

But nit made.

NIT: clang-format issues still present. Maybe you need to update your local clang-format.

In D51650#3121789, @erichkeane wrote:

For the rest of multiversioning we count on the optimizer to remove variants made irrelevant, but I'm not sure opt can do anything like that yet :)

I think removing the duplicated in opt is harder than just eliminate them here. At the end maybe the function does not need ifunc.

LGTM

[aaron.ballman]

Overall, I think this LGTM, but I did find a few nits. Can you fix the clang-format issues? Also, I'd like to see some C++ test coverage that shows how this works on template (partial) specializations, lambdas (with GNU-style syntax), and overloaded functions. If we deviate from the GCC behavior in any cases, it'd be great to capture it in comments (unless you think the deviation is intentional, at which point we should document it in AttrDocs.td, or you think the deviation needs to be fixed before we land it).

clang/include/clang/Basic/Attr.td

2706

clang/include/clang/Basic/DiagnosticSemaKinds.td

11299

Should this ad hoc group be listed within the FunctionMultiVersioning group?

clang/lib/Sema/SemaDeclAttr.cpp

1968–1972

This should be handled in Attr.td via a def : MutualExclusions<[....]>; if possible.

3290

Same here.

3360

And here

[erichkeane]

Did all the things Aaron asked for, but required adding 'lambda not supported yet' logic for this.

[aaron.ballman]

In D51650#3124859, @erichkeane wrote:

Did all the things Aaron asked for, but required adding 'lambda not supported yet' logic for this.

I don't see the .cpp test file, did it get dropped by accident?

Also, pre-commit isn't able to apply the patch, so it'd be good to resolve that to get the CI testing.

clang/lib/Sema/SemaDeclAttr.cpp

1970

This diagnostic behavior is a bit unfortunate because we'll issue a diagnostic like:

// expected-error@+2 {{'target_clones' and 'target_clones' attributes are not compatible}}

Maybe we should add err_duplicate_attribute and steal its text from warn_duplicate_attribute and use getAttr() directly here?

[erichkeane]

added C++ tests this time, changed how dupes are diagnosed.

[aaron.ballman]

LGTM aside from a nit with naming/wording. Feel free to land without additional review (unless you want more review, of course!).

clang/include/clang/Basic/DiagnosticSemaKinds.td

9868–9869

We typically don't use distinct wording for err_foo and warn_foo diagnostics -- folks tend to assume they've got the same wording and the only difference is the severity.

Potential ways forward:

• Rename to err_duplicate_attribute_exact and use the same wording as the warning version)
• Leave wording alone, rename to something else (perhaps err_repeated_multiversion_attribute) to make it specific to this usage

I don't insist on a particular path (or a change at all, if you have strong attachment), but I think it'd be nice to fix it before landing.

[jgorbe]

This breaks some existing code (we have found this issue building the JPEG XL library at github.com/libjxl). This is a very simplified version of the problem:

#pragma clang attribute push(__attribute__((target("sse2,ssse3"))), apply_to = function)
__attribute__((target("sse2"))) void f() {
}
#pragma clang attribute pop

This used to build before this patch, but now fails with

$ clang -c a.cc
a.cc:1:45: error: attribute 'target' cannot appear more than once on a declaration
#pragma clang attribute push(__attribute__((target("sse2,ssse3"))), apply_to = function)
                                            ^
a.cc:2:1: note: when applied to this declaration
__attribute__((target("sse2"))) void f() {
^
a.cc:2:16: note: conflicting attribute is here
__attribute__((target("sse2"))) void f() {
               ^
1 error generated.

Before this patch, the function-level attribute would win. Here's the relevant part of the generated IR for that example:

; Function Attrs: mustprogress noinline nounwind optnone uwtable
define dso_local void @_Z1fv() #0 {
  ret void
}

attributes #0 = { mustprogress noinline nounwind optnone uwtable "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }

Note how there's sse2 (which was in the function-level attribute) but no ssse3 (which wasn't).

Was this semantic change intentional?

[akuegel]

Since it is not clear whether the semantic change was intended, I think it makes sense to revert the patch for now. If it is intended, it might be good to mention it in the change description, so that people are warned.

[aaron.ballman]

In D51650#3126569, @akuegel wrote:

Since it is not clear whether the semantic change was intended, I think it makes sense to revert the patch for now. If it is intended, it might be good to mention it in the change description, so that people are warned.

That looks like an unintended change to me, likely due to the new mutual exclusion checks. Thanks for letting us know!

[danielkiss]

clang/lib/Sema/SemaDeclAttr.cpp

3290–3296

This caused the breakage. This check could be dropped for the reland.
target attributes seems can be combined, others shouldn't.

[erichkeane]

In D51650#3127097, @aaron.ballman wrote:

In D51650#3126569, @akuegel wrote:

Since it is not clear whether the semantic change was intended, I think it makes sense to revert the patch for now. If it is intended, it might be good to mention it in the change description, so that people are warned.

That looks like an unintended change to me, likely due to the new mutual exclusion checks. Thanks for letting us know!

It was SORTA intended, I was going for 'conservative fix' here, but the 'target' change was more of a 'while I was there' bit. I'm away for the next two weeks, but can re-land this without that plus a test to validate a winner (as that wasn't really the case before IIRC).

That said, the above example gives me some willies with regards to setting up multiversioning.... The interaction of two declarations here, 1 which adds a 'target' to the pragma-push seems fishy/confusing.

[erichkeane]

Relanded: fc53eb69c26cdd7efa6b629c187d04326f0448ca

clang/include/clang/AST/Decl.h

private:
   void setParameterIndexLarge(unsigned parameterIndex);
   unsigned getParameterIndexLarge() const;
 };
 
 enum class MultiVersionKind {
   None,
   Target,
   CPUSpecific,
-  CPUDispatch
+  CPUDispatch,
+  TargetClones
 };
 
 /// Represents a function declaration or definition.
 ///
 /// Since a given function can be declared several times in a program,
 /// there may be several FunctionDecls that correspond to that
 /// function. Only one of those FunctionDecls will be found when
 /// traversing the list of declarations in the context of the
public:
   /// True if this function is a multiversioned processor specific function as a
   /// part of the cpu_specific/cpu_dispatch functionality.
   bool isCPUSpecificMultiVersion() const;
 
   /// True if this function is a multiversioned dispatch function as a part of
   /// the target functionality.
   bool isTargetMultiVersion() const;
 
+  /// True if this function is a multiversioned dispatch function as a part of
+  /// the target-clones functionality.
+  bool isTargetClonesMultiVersion() const;
+
   /// \brief Get the associated-constraints of this function declaration.
   /// Currently, this will either be a vector of size 1 containing the
   /// trailing-requires-clause or an empty vector.
   ///
   /// Use this instead of getTrailingRequiresClause for concepts APIs that
   /// accept an ArrayRef of constraint expressions.
   void getAssociatedConstraints(SmallVectorImpl<const Expr *> &AC) const {
     if (auto *TRC = getTrailingRequiresClause())

clang/include/clang/Basic/Attr.td

static ParsedTargetAttr parse(StringRef Features) {
         else
           Ret.Features.push_back("+" + Feature.str());
       }
       return Ret;
     }
   }];
 }
 
+def TargetClones : InheritableAttr {
+  let Spellings = [GCC<"target_clones">];
+  let Args = [VariadicStringArgument<"featuresStrs">];
+  let Documentation = [TargetClonesDocs];
+  let Subjects = SubjectList<[Function], ErrorDiag>;
+  let AdditionalMembers = [{
+    StringRef getFeatureStr(unsigned Index) const {
+      return *(featuresStrs_begin() + Index);
+    }
+    // 'default' is always moved to the end, so it isn't considered
+    // when mangling the index.
+    unsigned getMangledIndex(unsigned Index) const {
+      if (getFeatureStr(Index) == "default")
+        return std::count_if(featuresStrs_begin(), featuresStrs_end(),
+                              [](StringRef S) { return S != "default"; });
+
+      return std::count_if(featuresStrs_begin(), featuresStrs_begin() + Index,
+                           [](StringRef S) { return S != "default"; });
+    }
+
+    // True if this is the first of this version to appear in the config string.
+    // This is used to make sure we don't try to emit this function multiple
+    // times.
+    bool isFirstOfVersion(unsigned Index) const {
+      StringRef FeatureStr(getFeatureStr(Index));
+      return 0 == std::count_if(
+                      featuresStrs_begin(), featuresStrs_begin() + Index,
+                      [FeatureStr](StringRef S) { return S == FeatureStr; });
+    }
+  }];
+}
+
+def : MutualExclusions<[TargetClones, Target, CPUDispatch, CPUSpecific]>;
+
 def MinVectorWidth : InheritableAttr {
   let Spellings = [Clang<"min_vector_width">];
   let Args = [UnsignedArgument<"VectorWidth">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [MinVectorWidthDocs];
 }
 
 def TransparentUnion : InheritableAttr {

clang/include/clang/Basic/AttrDocs.td

.. code-block:: c++
     void foo() {} // will be called on any other processors.
 
 All multiversioned functions must contain a ``default`` (fallback)
 implementation, otherwise usages of the function are considered invalid.
 Additionally, a function may not become multiversioned after its first use.
 }];
 }
 
+def TargetClonesDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+Clang supports the ``target_clones("OPTIONS")`` attribute. This attribute may be
+attached to a function declaration and causes function multiversioning, where
+multiple versions of the function will be emitted with different code
+generation options.  Additionally, these versions will be resolved at runtime
+based on the priority of their attribute options. All ``target_clone`` functions
+are considered multiversioned functions.
+
+All multiversioned functions must contain a ``default`` (fallback)
+implementation, otherwise usages of the function are considered invalid.
+Additionally, a function may not become multiversioned after its first use.
+
+The options to ``target_clones`` can either be a target-specific architecture
+(specified as ``arch=CPU``), or one of a list of subtarget features.
+
+Example "subtarget features" from the x86 backend include: "mmx", "sse", "sse4.2",
+"avx", "xop" and largely correspond to the machine specific options handled by
+the front end.
+
+The versions can either be listed as a comma-separated sequence of string
+literals or as a single string literal containing a comma-separated list of
+versions.  For compatibility with GCC, the two formats can be mixed.  For
+example, the following will emit 4 versions of the function:
+
+  .. code-block:: c++
+
+    __attribute__((target_clones("arch=atom,avx2","arch=ivybridge","default")))
+    void foo() {}
+
+}];
+}
+
 def MinVectorWidthDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the ``__attribute__((min_vector_width(width)))`` attribute. This
 attribute may be attached to a function and informs the backend that this
 function desires vectors of at least this width to be generated. Target-specific
 maximum vector widths still apply. This means even if you ask for something
 larger than the target supports, you will only get what the target supports.

clang/include/clang/Basic/DiagnosticGroups.td

 // A warning group for warnings about code that clang accepts when
 // compiling OpenCL C/C++ but which is not compatible with the SPIR(-V) spec.
 def SpirCompat : DiagGroup<"spir-compat">;
 def : DiagGroup<"spirv-compat", [SpirCompat]>; // Alias.
 
 // Warning for the GlobalISel options.
 def GlobalISel : DiagGroup<"global-isel">;
 
+// A warning group for the GNU extension to allow mixed specifier types for
+// target-clones multiversioning.
+def TargetClonesMixedSpecifiers : DiagGroup<"target-clones-mixed-specifiers">;
+
 // A warning group specifically for warnings related to function
 // multiversioning.
-def FunctionMultiVersioning : DiagGroup<"function-multiversion">;
+def FunctionMultiVersioning
+    : DiagGroup<"function-multiversion", [TargetClonesMixedSpecifiers]>;
 
 def NoDeref : DiagGroup<"noderef">;
 
 // A group for cross translation unit static analysis related warnings.
 def CrossTU : DiagGroup<"ctu">;
 
 def CTADMaybeUnsupported : DiagGroup<"ctad-maybe-unsupported">;
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_attribute_requires_positive_integer : Error<
   "%0 attribute requires a %select{positive|non-negative}1 "
   "integral compile time constant expression">;
 def err_attribute_requires_opencl_version : Error<
   "attribute %0 is supported in the OpenCL version %1%select{| onwards}2">;
 def err_invalid_branch_protection_spec : Error<
   "invalid or misplaced branch protection specification '%0'">;
 def warn_unsupported_target_attribute
     : Warning<"%select{unsupported|duplicate|unknown}0%select{| architecture|"
-              " tune CPU}1 '%2' in the 'target' attribute string; 'target' "
+              " tune CPU}1 '%2' in the '%select{target|target_clones}3' "
+              "attribute string; '%select{target|target_clones}3' "
               "attribute ignored">,
       InGroup<IgnoredAttributes>;
 def err_attribute_unsupported
     : Error<"%0 attribute is not supported on targets missing %1;"
             " specify an appropriate -march= or -mcpu=">;
 // The err_*_attribute_argument_not_int are separate because they're used by
 // VerifyIntegerConstantExpression.
 def err_aligned_attribute_argument_not_int : Error<
def err_invalid_conversion_between_ext_vectors : Error<
   "invalid conversion between ext-vector type %0 and %1">;
 
 def warn_duplicate_attribute_exact : Warning<
   "attribute %0 is already applied">, InGroup<IgnoredAttributes>;
 
 def warn_duplicate_attribute : Warning<
   "attribute %0 is already applied with different arguments">,
   InGroup<IgnoredAttributes>;
+def err_disallowed_duplicate_attribute : Error<
+  "attribute %0 cannot appear more than once on a declaration">;
 
 def warn_sync_fetch_and_nand_semantics_change : Warning<
   "the semantics of this intrinsic changed with GCC "
   "version 4.4 - the newer semantics are provided here">,
   InGroup<DiagGroup<"sync-fetch-and-nand-semantics-changed">>;
 
 // Type
 def ext_wchar_t_sign_spec : ExtWarn<"'%0' cannot be signed or unsigned">,
def err_multiversion_after_used : Error<
   "usage">;
 def err_bad_multiversion_option : Error<
   "function multiversioning doesn't support %select{feature|architecture}0 "
   "'%1'">;
 def err_multiversion_duplicate : Error<
   "multiversioned function redeclarations require identical target attributes">;
 def err_multiversion_noproto : Error<
   "multiversioned function must have a prototype">;
-def err_multiversion_disallowed_other_attr : Error<
-  "attribute '%select{target|cpu_specific|cpu_dispatch}0' multiversioning cannot be combined"
+def err_multiversion_disallowed_other_attr
+    : Error<"attribute "
+            "'%select{|target|cpu_specific|cpu_dispatch|target_clones}0' "
+            "multiversioning cannot be combined"
             " with attribute %1">;
 def err_multiversion_mismatched_attrs
     : Error<"attributes on multiversioned functions must all match, attribute "
             "%0 %select{is missing|has different arguments}1">;
 def err_multiversion_diff : Error<
   "multiversioned function declaration has a different %select{calling convention"
   "|return type|constexpr specification|inline specification|linkage|"
   "language linkage}0">;
-def err_multiversion_doesnt_support : Error<
-  "attribute '%select{target|cpu_specific|cpu_dispatch}0' multiversioned functions do not "
+def err_multiversion_doesnt_support
+    : Error<"attribute "
+            "'%select{|target|cpu_specific|cpu_dispatch|target_clones}0' "
+            "multiversioned functions do not "
             "yet support %select{function templates|virtual functions|"
             "deduced return types|constructors|destructors|deleted functions|"
-  "defaulted functions|constexpr functions|consteval function}1">;
+            "defaulted functions|constexpr functions|consteval "
+            "function|lambdas}1">;
 def err_multiversion_not_allowed_on_main : Error<
   "'main' cannot be a multiversioned function">;
 def err_multiversion_not_supported : Error<
  "function multiversioning is not supported on the current target">;
 def err_multiversion_types_mixed : Error<
   "multiversioning attributes cannot be combined">;
 def err_cpu_dispatch_mismatch : Error<
  "'cpu_dispatch' function redeclared with different CPUs">;
 def err_cpu_specific_multiple_defs : Error<
  "multiple 'cpu_specific' functions cannot specify the same CPU: %0">;
 def warn_multiversion_duplicate_entries : Warning<
  "CPU list contains duplicate entries; attribute ignored">,
   InGroup<FunctionMultiVersioning>;
 def warn_dispatch_body_ignored : Warning<
   "body of cpu_dispatch function will be ignored">,
   InGroup<FunctionMultiVersioning>;
+def err_target_clone_must_have_default
+    : Error<"'target_clones' multiversioning requires a default target">;
+def err_target_clone_doesnt_match
+    : Error<"'target_clones' attribute does not match previous declaration">;
+def warn_target_clone_mixed_values
+    : ExtWarn<
+          "mixing 'target_clones' specifier mechanisms is permitted for GCC "
+          "compatibility; use a comma separated sequence of string literals, "
+          "or a string literal containing a comma-separated list of versions">,
+      InGroup<TargetClonesMixedSpecifiers>;
+def warn_target_clone_duplicate_options
+    : Warning<"version list contains duplicate entries">,
+      InGroup<FunctionMultiVersioning>;
 
 // three-way comparison operator diagnostics
 def err_implied_comparison_category_type_not_found : Error<
   "cannot %select{use builtin operator '<=>'|default 'operator<=>'}1 "
   "because type '%0' was not found; include <compare>">;
 def err_spaceship_argument_narrowing : Error<
   "argument to 'operator<=>' "
   "%select{cannot be narrowed from type %1 to %2|"

clang/include/clang/Sema/Sema.h

public:
   bool CheckAttrTarget(const ParsedAttr &CurrAttr);
   bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);
   bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum,
                                       StringRef &Str,
                                       SourceLocation *ArgLocation = nullptr);
   llvm::Error isValidSectionSpecifier(StringRef Str);
   bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
   bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
+  bool checkTargetClonesAttrString(SourceLocation LiteralLoc, StringRef Str,
+                                   const StringLiteral *Literal,
+                                   bool &HasDefault, bool &HasCommas,
+                                   SmallVectorImpl<StringRef> &Strings);
   bool checkMSInheritanceAttrOnDefinition(
       CXXRecordDecl *RD, SourceRange Range, bool BestCase,
       MSInheritanceModel SemanticSpelling);
 
   void CheckAlignasUnderalignment(Decl *D);
 
   /// Adjust the calling convention of a method to be the ABI default if it
   /// wasn't specified explicitly.  This handles method types formed from

clang/lib/AST/ASTContext.cpp

if (const auto *TD = FD->getAttr<TargetAttr>()) {
     llvm::SmallVector<StringRef, 32> FeaturesTmp;
     Target->getCPUSpecificCPUDispatchFeatures(
         SD->getCPUName(GD.getMultiVersionIndex())->getName(), FeaturesTmp);
     std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end());
     Features.insert(Features.begin(),
                     Target->getTargetOpts().FeaturesAsWritten.begin(),
                     Target->getTargetOpts().FeaturesAsWritten.end());
     Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU, Features);
+  } else if (const auto *TC = FD->getAttr<TargetClonesAttr>()) {
+    std::vector<std::string> Features;
+    StringRef VersionStr = TC->getFeatureStr(GD.getMultiVersionIndex());
+    if (VersionStr.startswith("arch="))
+      TargetCPU = VersionStr.drop_front(sizeof("arch=") - 1);
+    else if (VersionStr != "default")
+      Features.push_back((StringRef{"+"} + VersionStr).str());
+
+    Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU, Features);
   } else {
     FeatureMap = Target->getTargetOpts().FeatureMap;
   }
 }
 
 OMPTraitInfo &ASTContext::getNewOMPTraitInfo() {
   OMPTraitInfoVector.emplace_back(new OMPTraitInfo());
   return *OMPTraitInfoVector.back();

clang/lib/AST/Decl.cpp

 
 MultiVersionKind FunctionDecl::getMultiVersionKind() const {
   if (hasAttr<TargetAttr>())
     return MultiVersionKind::Target;
   if (hasAttr<CPUDispatchAttr>())
     return MultiVersionKind::CPUDispatch;
   if (hasAttr<CPUSpecificAttr>())
     return MultiVersionKind::CPUSpecific;
+  if (hasAttr<TargetClonesAttr>())
+    return MultiVersionKind::TargetClones;
   return MultiVersionKind::None;
 }
 
 bool FunctionDecl::isCPUDispatchMultiVersion() const {
   return isMultiVersion() && hasAttr<CPUDispatchAttr>();
 }
 
 bool FunctionDecl::isCPUSpecificMultiVersion() const {
   return isMultiVersion() && hasAttr<CPUSpecificAttr>();
 }
 
 bool FunctionDecl::isTargetMultiVersion() const {
   return isMultiVersion() && hasAttr<TargetAttr>();
 }
 
+bool FunctionDecl::isTargetClonesMultiVersion() const {
+  return isMultiVersion() && hasAttr<TargetClonesAttr>();
+}
+
 void
 FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) {
   redeclarable_base::setPreviousDecl(PrevDecl);
 
   if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
     FunctionTemplateDecl *PrevFunTmpl
       = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
     assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");

clang/lib/CodeGen/CodeGenModule.h

private:
   void EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);
   void EmitMultiVersionFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);
 
   void EmitGlobalVarDefinition(const VarDecl *D, bool IsTentative = false);
   void EmitExternalVarDeclaration(const VarDecl *D);
   void EmitAliasDefinition(GlobalDecl GD);
   void emitIFuncDefinition(GlobalDecl GD);
   void emitCPUDispatchDefinition(GlobalDecl GD);
+  void EmitTargetClonesResolver(GlobalDecl GD);
   void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);
   void EmitObjCIvarInitializations(ObjCImplementationDecl *D);
 
   // C++ related functions.
 
   void EmitDeclContext(const DeclContext *DC);
   void EmitLinkageSpec(const LinkageSpecDecl *D);
 

clang/lib/CodeGen/CodeGenModule.cpp

 // needs a unique suffix after the mangled name.
 static bool isUniqueInternalLinkageDecl(GlobalDecl GD,
                                         CodeGenModule &CGM) {
   const Decl *D = GD.getDecl();
   return !CGM.getModuleNameHash().empty() && isa<FunctionDecl>(D) &&
          (CGM.getFunctionLinkage(GD) == llvm::GlobalValue::InternalLinkage);
 }
 
+static void AppendTargetClonesMangling(const CodeGenModule &CGM,
+                                       const TargetClonesAttr *Attr,
+                                       unsigned VersionIndex,
+                                       raw_ostream &Out) {
+  Out << '.';
+  StringRef FeatureStr = Attr->getFeatureStr(VersionIndex);
+  if (FeatureStr.startswith("arch="))
+    Out << "arch_" << FeatureStr.substr(sizeof("arch=") - 1);
+  else
+    Out << FeatureStr;
+
+  Out << '.' << Attr->getMangledIndex(VersionIndex);
+}
+
 static std::string getMangledNameImpl(CodeGenModule &CGM, GlobalDecl GD,
                                       const NamedDecl *ND,
                                       bool OmitMultiVersionMangling = false) {
   SmallString<256> Buffer;
   llvm::raw_svector_ostream Out(Buffer);
   MangleContext &MC = CGM.getCXXABI().getMangleContext();
   if (!CGM.getModuleNameHash().empty())
     MC.needsUniqueInternalLinkageNames();
if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
       case MultiVersionKind::CPUSpecific:
         AppendCPUSpecificCPUDispatchMangling(CGM,
                                              FD->getAttr<CPUSpecificAttr>(),
                                              GD.getMultiVersionIndex(), Out);
         break;
       case MultiVersionKind::Target:
         AppendTargetMangling(CGM, FD->getAttr<TargetAttr>(), Out);
         break;
+      case MultiVersionKind::TargetClones:
+        AppendTargetClonesMangling(CGM, FD->getAttr<TargetClonesAttr>(),
+                                   GD.getMultiVersionIndex(), Out);
+        break;
       case MultiVersionKind::None:
         llvm_unreachable("None multiversion type isn't valid here");
       }
     }
 
   // Make unique name for device side static file-scope variable for HIP.
   if (CGM.getContext().shouldExternalizeStaticVar(ND) &&
       CGM.getLangOpts().GPURelocatableDeviceCode &&
bool CodeGenModule::GetCPUAndFeaturesAttributes(GlobalDecl GD,
   // parse that and add it to the feature set.
   StringRef TargetCPU = getTarget().getTargetOpts().CPU;
   StringRef TuneCPU = getTarget().getTargetOpts().TuneCPU;
   std::vector<std::string> Features;
   const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.getDecl());
   FD = FD ? FD->getMostRecentDecl() : FD;
   const auto *TD = FD ? FD->getAttr<TargetAttr>() : nullptr;
   const auto *SD = FD ? FD->getAttr<CPUSpecificAttr>() : nullptr;
+  const auto *TC = FD ? FD->getAttr<TargetClonesAttr>() : nullptr;
   bool AddedAttr = false;
-  if (TD || SD) {
+  if (TD || SD || TC) {
     llvm::StringMap<bool> FeatureMap;
     getContext().getFunctionFeatureMap(FeatureMap, GD);
 
     // Produce the canonical string for this set of features.
     for (const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
       Features.push_back((Entry.getValue() ? "+" : "-") + Entry.getKey().str());
 
     // Now add the target-cpu and target-features to the function.
void CodeGenModule::EmitMultiVersionFunctionDefinition(GlobalDecl GD,
                                                        llvm::GlobalValue *GV) {
   const auto *FD = cast<FunctionDecl>(GD.getDecl());
 
   if (FD->isCPUSpecificMultiVersion()) {
     auto *Spec = FD->getAttr<CPUSpecificAttr>();
     for (unsigned I = 0; I < Spec->cpus_size(); ++I)
       EmitGlobalFunctionDefinition(GD.getWithMultiVersionIndex(I), nullptr);
     // Requires multiple emits.
+  } else if (FD->isTargetClonesMultiVersion()) {
+    auto *Clone = FD->getAttr<TargetClonesAttr>();
+    for (unsigned I = 0; I < Clone->featuresStrs_size(); ++I)
+      if (Clone->isFirstOfVersion(I))
+        EmitGlobalFunctionDefinition(GD.getWithMultiVersionIndex(I), nullptr);
+    EmitTargetClonesResolver(GD);
   } else
     EmitGlobalFunctionDefinition(GD, GV);
 }
 
 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
   const auto *D = cast<ValueDecl>(GD.getDecl());
 
   PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),

 llvm::GlobalValue::LinkageTypes getMultiversionLinkage(CodeGenModule &CGM,
                                                        GlobalDecl GD) {
   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
   if (FD->getFormalLinkage() == InternalLinkage)
     return llvm::GlobalValue::InternalLinkage;
   return llvm::GlobalValue::WeakODRLinkage;
 }
 
+void CodeGenModule::EmitTargetClonesResolver(GlobalDecl GD) {
+  const auto *FD = cast<FunctionDecl>(GD.getDecl());
+  assert(FD && "Not a FunctionDecl?");
+  const auto *TC = FD->getAttr<TargetClonesAttr>();
+  assert(TC && "Not a target_clones Function?");
+
+  QualType CanonTy = Context.getCanonicalType(FD->getType());
+  llvm::Type *DeclTy = getTypes().ConvertType(CanonTy);
+
+  if (const auto *CXXFD = dyn_cast<CXXMethodDecl>(FD)) {
+    const CGFunctionInfo &FInfo = getTypes().arrangeCXXMethodDeclaration(CXXFD);
+    DeclTy = getTypes().GetFunctionType(FInfo);
+  }
+
+  llvm::Function *ResolverFunc;
+  if (getTarget().supportsIFunc()) {
+    auto *IFunc = cast<llvm::GlobalIFunc>(
+        GetOrCreateMultiVersionResolver(GD, DeclTy, FD));
+    ResolverFunc = cast<llvm::Function>(IFunc->getResolver());
+  } else
+    ResolverFunc =
+        cast<llvm::Function>(GetOrCreateMultiVersionResolver(GD, DeclTy, FD));
+
+  SmallVector<CodeGenFunction::MultiVersionResolverOption, 10> Options;
+  for (unsigned VersionIndex = 0; VersionIndex < TC->featuresStrs_size();
+       ++VersionIndex) {
+    if (!TC->isFirstOfVersion(VersionIndex))
+      continue;
+    StringRef Version = TC->getFeatureStr(VersionIndex);
+    StringRef MangledName =
+        getMangledName(GD.getWithMultiVersionIndex(VersionIndex));
+    llvm::Constant *Func = GetGlobalValue(MangledName);
+    assert(Func &&
+           "Should have already been created before calling resolver emit");
+
+    StringRef Architecture;
+    llvm::SmallVector<StringRef, 1> Feature;
+
+    if (Version.startswith("arch="))
+      Architecture = Version.drop_front(sizeof("arch=") - 1);
+    else if (Version != "default")
+      Feature.push_back(Version);
+
+    Options.emplace_back(cast<llvm::Function>(Func), Architecture, Feature);
+  }
+
+  const TargetInfo &TI = getTarget();
+  std::stable_sort(
+      Options.begin(), Options.end(),
+      [&TI](const CodeGenFunction::MultiVersionResolverOption &LHS,
+            const CodeGenFunction::MultiVersionResolverOption &RHS) {
+        return TargetMVPriority(TI, LHS) > TargetMVPriority(TI, RHS);
+      });
+  CodeGenFunction CGF(*this);
+  CGF.EmitMultiVersionResolver(ResolverFunc, Options);
+}
+
 void CodeGenModule::emitMultiVersionFunctions() {
   std::vector<GlobalDecl> MVFuncsToEmit;
   MultiVersionFuncs.swap(MVFuncsToEmit);
   for (GlobalDecl GD : MVFuncsToEmit) {
     SmallVector<CodeGenFunction::MultiVersionResolverOption, 10> Options;
     const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
     getContext().forEachMultiversionedFunctionVersion(
         FD, [this, &GD, &Options](const FunctionDecl *CurFD) {
llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(
 
   // If this already exists, just return that one.
   if (llvm::GlobalValue *ResolverGV = GetGlobalValue(ResolverName))
     return ResolverGV;
 
   // 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 if necessary (target multiversioning only).
-  if (!FD->isCPUDispatchMultiVersion() && !FD->isCPUSpecificMultiVersion())
+  if (FD->isTargetMultiVersion())
     MultiVersionFuncs.push_back(GD);
+  else if (FD->isTargetClonesMultiVersion()) {
+    // In target_clones multiversioning, make sure we emit this if used.
+    auto DDI =
+        DeferredDecls.find(getMangledName(GD.getWithMultiVersionIndex(0)));
+    if (DDI != DeferredDecls.end()) {
+      addDeferredDeclToEmit(GD);
+      DeferredDecls.erase(DDI);
+    } else {
+      // Emit the symbol of the 1st variant, so that the deferred decls know we
+      // need it, otherwise the only global value will be the resolver/ifunc,
+      // which end up getting broken if we search for them with GetGlobalValue'.
+      GetOrCreateLLVMFunction(
+          getMangledName(GD.getWithMultiVersionIndex(0)), DeclTy, FD,
+          /*ForVTable=*/false, /*DontDefer=*/true,
+          /*IsThunk=*/false, llvm::AttributeList(), ForDefinition);
+    }
+  }
 
   if (getTarget().supportsIFunc()) {
     llvm::Type *ResolverType = llvm::FunctionType::get(
         llvm::PointerType::get(
             DeclTy, getContext().getTargetAddressSpace(FD->getType())),
         false);
     llvm::Constant *Resolver = GetOrCreateLLVMFunction(
         MangledName + ".resolver", ResolverType, GlobalDecl{},

clang/lib/Sema/SemaDecl.cpp

case attr::NoThrow:
     return true;
   }
 }
 
 static bool checkNonMultiVersionCompatAttributes(Sema &S,
                                                  const FunctionDecl *FD,
                                                  const FunctionDecl *CausedFD,
                                                  MultiVersionKind MVType) {
-  bool IsCPUSpecificCPUDispatchMVType =
-      MVType == MultiVersionKind::CPUDispatch ||
-      MVType == MultiVersionKind::CPUSpecific;
-  const auto Diagnose = [FD, CausedFD, IsCPUSpecificCPUDispatchMVType](
-                            Sema &S, const Attr *A) {
+  const auto Diagnose = [FD, CausedFD, MVType](Sema &S, const Attr *A) {
     S.Diag(FD->getLocation(), diag::err_multiversion_disallowed_other_attr)
-        << IsCPUSpecificCPUDispatchMVType << A;
+        << static_cast<unsigned>(MVType) << A;
     if (CausedFD)
       S.Diag(CausedFD->getLocation(), diag::note_multiversioning_caused_here);
     return true;
   };
 
   for (const Attr *A : FD->attrs()) {
     switch (A->getKind()) {
     case attr::CPUDispatch:
     case attr::CPUSpecific:
       if (MVType != MultiVersionKind::CPUDispatch &&
           MVType != MultiVersionKind::CPUSpecific)
         return Diagnose(S, A);
       break;
     case attr::Target:
       if (MVType != MultiVersionKind::Target)
         return Diagnose(S, A);
       break;
+    case attr::TargetClones:
+      if (MVType != MultiVersionKind::TargetClones)
+        return Diagnose(S, A);
+      break;
     default:
       if (!AttrCompatibleWithMultiVersion(A->getKind(), MVType))
         return Diagnose(S, A);
       break;
     }
   }
   return false;
 }
enum DoesntSupport {
     VirtFuncs = 1,
     DeducedReturn = 2,
     Constructors = 3,
     Destructors = 4,
     DeletedFuncs = 5,
     DefaultedFuncs = 6,
     ConstexprFuncs = 7,
     ConstevalFuncs = 8,
+    Lambda = 9,
   };
   enum Different {
     CallingConv = 0,
     ReturnType = 1,
     ConstexprSpec = 2,
     InlineSpec = 3,
     Linkage = 4,
     LanguageLinkage = 5,
if (OldFD && CausesMV && OldFD->isUsed(false))
     return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
 
   return S.areMultiversionVariantFunctionsCompatible(
       OldFD, NewFD, S.PDiag(diag::err_multiversion_noproto),
       PartialDiagnosticAt(NewFD->getLocation(),
                           S.PDiag(diag::note_multiversioning_caused_here)),
       PartialDiagnosticAt(NewFD->getLocation(),
                           S.PDiag(diag::err_multiversion_doesnt_support)
-                              << IsCPUSpecificCPUDispatchMVType),
+                              << static_cast<unsigned>(MVType)),
       PartialDiagnosticAt(NewFD->getLocation(),
                           S.PDiag(diag::err_multiversion_diff)),
       /*TemplatesSupported=*/false,
       /*ConstexprSupported=*/!IsCPUSpecificCPUDispatchMVType,
       /*CLinkageMayDiffer=*/false);
 }
 
 /// Check the validity of a multiversion function declaration that is the
static bool CheckTargetCausesMultiVersioning(
   NewFD->setIsMultiVersion();
   Redeclaration = false;
   MergeTypeWithPrevious = false;
   OldDecl = nullptr;
   Previous.clear();
   return false;
 }
 
+static bool MultiVersionTypesCompatible(MultiVersionKind Old,
+                                        MultiVersionKind New) {
+  if (Old == New || Old == MultiVersionKind::None ||
+      New == MultiVersionKind::None)
+    return true;
+
+  return (Old == MultiVersionKind::CPUDispatch &&
+          New == MultiVersionKind::CPUSpecific) ||
+         (Old == MultiVersionKind::CPUSpecific &&
+          New == MultiVersionKind::CPUDispatch);
+}
+
 /// Check the validity of a new function declaration being added to an existing
 /// multiversioned declaration collection.
 static bool CheckMultiVersionAdditionalDecl(
     Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD,
     MultiVersionKind NewMVType, const TargetAttr *NewTA,
     const CPUDispatchAttr *NewCPUDisp, const CPUSpecificAttr *NewCPUSpec,
-    bool &Redeclaration, NamedDecl *&OldDecl, bool &MergeTypeWithPrevious,
-    LookupResult &Previous) {
+    const TargetClonesAttr *NewClones, bool &Redeclaration, NamedDecl *&OldDecl,
+    bool &MergeTypeWithPrevious, LookupResult &Previous) {
 
   MultiVersionKind OldMVType = OldFD->getMultiVersionKind();
   // Disallow mixing of multiversioning types.
-  if ((OldMVType == MultiVersionKind::Target &&
-       NewMVType != MultiVersionKind::Target) ||
-      (NewMVType == MultiVersionKind::Target &&
-       OldMVType != MultiVersionKind::Target)) {
+  if (!MultiVersionTypesCompatible(OldMVType, NewMVType)) {
     S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed);
     S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
     NewFD->setInvalidDecl();
     return true;
   }
 
   ParsedTargetAttr NewParsed;
   if (NewTA) {
     NewParsed = NewTA->parse();
     llvm::sort(NewParsed.Features);
   }
 
   bool UseMemberUsingDeclRules =
       S.CurContext->isRecord() && !NewFD->getFriendObjectKind();
 
   // Next, check ALL non-overloads to see if this is a redeclaration of a
   // previous member of the MultiVersion set.
   for (NamedDecl *ND : Previous) {
     FunctionDecl *CurFD = ND->getAsFunction();
     if (!CurFD)
       continue;
     if (S.IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
       continue;
 
-    if (NewMVType == MultiVersionKind::Target) {
+    switch (NewMVType) {
+    case MultiVersionKind::None:
+      assert(OldMVType == MultiVersionKind::TargetClones &&
+             "Only target_clones can be omitted in subsequent declarations");
+      break;
+    case MultiVersionKind::Target: {
       const auto *CurTA = CurFD->getAttr<TargetAttr>();
       if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
         NewFD->setIsMultiVersion();
         Redeclaration = true;
         OldDecl = ND;
         return false;
       }
 
       ParsedTargetAttr CurParsed = CurTA->parse(std::less<std::string>());
       if (CurParsed == NewParsed) {
         S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
         S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
         NewFD->setInvalidDecl();
         return true;
       }
-    } else {
+      break;
+    }
+    case MultiVersionKind::TargetClones: {
+      const auto *CurClones = CurFD->getAttr<TargetClonesAttr>();
+      Redeclaration = true;
+      OldDecl = CurFD;
+      MergeTypeWithPrevious = true;
+      NewFD->setIsMultiVersion();
+
+      if (CurClones && NewClones &&
+          (CurClones->featuresStrs_size() != NewClones->featuresStrs_size() ||
+           !std::equal(CurClones->featuresStrs_begin(),
+                       CurClones->featuresStrs_end(),
+                       NewClones->featuresStrs_begin()))) {
+        S.Diag(NewFD->getLocation(), diag::err_target_clone_doesnt_match);
+        S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
+        NewFD->setInvalidDecl();
+        return true;
+      }
+
+      return false;
+    }
+    case MultiVersionKind::CPUSpecific:
+    case MultiVersionKind::CPUDispatch: {
       const auto *CurCPUSpec = CurFD->getAttr<CPUSpecificAttr>();
       const auto *CurCPUDisp = CurFD->getAttr<CPUDispatchAttr>();
       // Handle CPUDispatch/CPUSpecific versions.
       // Only 1 CPUDispatch function is allowed, this will make it go through
       // the redeclaration errors.
       if (NewMVType == MultiVersionKind::CPUDispatch &&
           CurFD->hasAttr<CPUDispatchAttr>()) {
         if (CurCPUDisp->cpus_size() == NewCPUDisp->cpus_size() &&
case MultiVersionKind::CPUDispatch: {
                   << NewII;
               S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
               NewFD->setInvalidDecl();
               return true;
             }
           }
         }
       }
-      // If the two decls aren't the same MVType, there is no possible error
-      // condition.
+      break;
+    }
     }
   }
 
   // Else, this is simply a non-redecl case.  Checking the 'value' is only
   // necessary in the Target case, since The CPUSpecific/Dispatch cases are
   // handled in the attribute adding step.
   if (NewMVType == MultiVersionKind::Target &&
       CheckMultiVersionValue(S, NewFD)) {
static bool CheckMultiVersionAdditionalDecl(
   NewFD->setIsMultiVersion();
   Redeclaration = false;
   MergeTypeWithPrevious = false;
   OldDecl = nullptr;
   Previous.clear();
   return false;
 }
 
-
 /// Check the validity of a mulitversion function declaration.
 /// Also sets the multiversion'ness' of the function itself.
 ///
 /// This sets NewFD->isInvalidDecl() to true if there was an error.
 ///
 /// Returns true if there was an error, false otherwise.
 static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD,
                                       bool &Redeclaration, NamedDecl *&OldDecl,
                                       bool &MergeTypeWithPrevious,
                                       LookupResult &Previous) {
   const auto *NewTA = NewFD->getAttr<TargetAttr>();
   const auto *NewCPUDisp = NewFD->getAttr<CPUDispatchAttr>();
   const auto *NewCPUSpec = NewFD->getAttr<CPUSpecificAttr>();
-
-  // Mixing Multiversioning types is prohibited.
-  if ((NewTA && NewCPUDisp) || (NewTA && NewCPUSpec) ||
-      (NewCPUDisp && NewCPUSpec)) {
-    S.Diag(NewFD->getLocation(), diag::err_multiversion_types_mixed);
-    NewFD->setInvalidDecl();
-    return true;
-  }
-
-  MultiVersionKind  MVType = NewFD->getMultiVersionKind();
+  const auto *NewClones = NewFD->getAttr<TargetClonesAttr>();
+  MultiVersionKind MVType = NewFD->getMultiVersionKind();
 
   // Main isn't allowed to become a multiversion function, however it IS
   // permitted to have 'main' be marked with the 'target' optimization hint.
   if (NewFD->isMain()) {
-    if ((MVType == MultiVersionKind::Target && NewTA->isDefaultVersion()) ||
-        MVType == MultiVersionKind::CPUDispatch ||
-        MVType == MultiVersionKind::CPUSpecific) {
+    if (MVType != MultiVersionKind::None &&
+        !(MVType == MultiVersionKind::Target && !NewTA->isDefaultVersion())) {
       S.Diag(NewFD->getLocation(), diag::err_multiversion_not_allowed_on_main);
       NewFD->setInvalidDecl();
       return true;
     }
     return false;
   }
 
   if (!OldDecl || !OldDecl->getAsFunction() ||
       OldDecl->getDeclContext()->getRedeclContext() !=
           NewFD->getDeclContext()->getRedeclContext()) {
     // If there's no previous declaration, AND this isn't attempting to cause
     // multiversioning, this isn't an error condition.
     if (MVType == MultiVersionKind::None)
       return false;
     return CheckMultiVersionFirstFunction(S, NewFD, MVType, NewTA);
   }
 
   FunctionDecl *OldFD = OldDecl->getAsFunction();
 
   if (!OldFD->isMultiVersion() && MVType == MultiVersionKind::None)
     return false;
 
-  if (OldFD->isMultiVersion() && MVType == MultiVersionKind::None) {
+  // Multiversioned redeclarations aren't allowed to omit the attribute, except
+  // for target_clones.
+  if (OldFD->isMultiVersion() && MVType == MultiVersionKind::None &&
+      OldFD->getMultiVersionKind() != MultiVersionKind::TargetClones) {
     S.Diag(NewFD->getLocation(), diag::err_multiversion_required_in_redecl)
         << (OldFD->getMultiVersionKind() != MultiVersionKind::Target);
     NewFD->setInvalidDecl();
     return true;
   }
 
+  if (!OldFD->isMultiVersion()) {
+    switch (MVType) {
+    case MultiVersionKind::Target:
+      return CheckTargetCausesMultiVersioning(S, OldFD, NewFD, NewTA,
+                                              Redeclaration, OldDecl,
+                                              MergeTypeWithPrevious, Previous);
+    case MultiVersionKind::TargetClones:
+      if (OldFD->isUsed(false)) {
+        NewFD->setInvalidDecl();
+        return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
+      }
+      OldFD->setIsMultiVersion();
+      break;
+    case MultiVersionKind::CPUDispatch:
+    case MultiVersionKind::CPUSpecific:
+    case MultiVersionKind::None:
+      break;
+    }
+  }
   // Handle the target potentially causes multiversioning case.
   if (!OldFD->isMultiVersion() && MVType == MultiVersionKind::Target)
     return CheckTargetCausesMultiVersioning(S, OldFD, NewFD, NewTA,
                                             Redeclaration, OldDecl,
                                             MergeTypeWithPrevious, Previous);
 
   // At this point, we have a multiversion function decl (in OldFD) AND an
   // appropriate attribute in the current function decl.  Resolve that these are
   // still compatible with previous declarations.
   return CheckMultiVersionAdditionalDecl(
-      S, OldFD, NewFD, MVType, NewTA, NewCPUDisp, NewCPUSpec, Redeclaration,
-      OldDecl, MergeTypeWithPrevious, Previous);
+      S, OldFD, NewFD, MVType, NewTA, NewCPUDisp, NewCPUSpec, NewClones,
+      Redeclaration, OldDecl, MergeTypeWithPrevious, Previous);
 }
 
 /// 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

clang/lib/Sema/SemaDeclAttr.cpp

if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
     return;
   }
 
   S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
       << AL << getFunctionOrMethodResultSourceRange(D);
 }
 
 static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  // Ensure we don't combine these with themselves, since that causes some
+  // confusing behavior.
+  if (AL.getParsedKind() == ParsedAttr::AT_CPUDispatch) {
+    if (checkAttrMutualExclusion<CPUSpecificAttr>(S, D, AL))
+      return;
+
+    if (const auto *Other = D->getAttr<CPUDispatchAttr>()) {
+      S.Diag(AL.getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
+      S.Diag(Other->getLocation(), diag::note_conflicting_attribute);
+      return;
+    }
+  } else if (AL.getParsedKind() == ParsedAttr::AT_CPUSpecific) {
+    if (checkAttrMutualExclusion<CPUDispatchAttr>(S, D, AL))
+      return;
+
+    if (const auto *Other = D->getAttr<CPUSpecificAttr>()) {
+      S.Diag(AL.getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
+      S.Diag(Other->getLocation(), diag::note_conflicting_attribute);
+      return;
+    }
+  }
+
   FunctionDecl *FD = cast<FunctionDecl>(D);
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
     if (MD->getParent()->isLambda()) {
       S.Diag(AL.getLoc(), diag::err_attribute_dll_lambda) << AL;
       return;
     }
   }
if (CodeSegAttr *CSA = S.mergeCodeSegAttr(D, AL, Str))
     D->addAttr(CSA);
 }
 
 // Check for things we'd like to warn about. Multiversioning issues are
 // handled later in the process, once we know how many exist.
 bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
   enum FirstParam { Unsupported, Duplicate, Unknown };
   enum SecondParam { None, Architecture, Tune };
+  enum ThirdParam { Target, TargetClones };
   if (AttrStr.contains("fpmath="))
     return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
-           << Unsupported << None << "fpmath=";
+           << Unsupported << None << "fpmath=" << Target;
 
   // Diagnose use of tune if target doesn't support it.
   if (!Context.getTargetInfo().supportsTargetAttributeTune() &&
       AttrStr.contains("tune="))
     return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
-           << Unsupported << None << "tune=";
+           << Unsupported << None << "tune=" << Target;
 
   ParsedTargetAttr ParsedAttrs = TargetAttr::parse(AttrStr);
 
   if (!ParsedAttrs.Architecture.empty() &&
       !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Architecture))
     return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
-           << Unknown << Architecture << ParsedAttrs.Architecture;
+           << Unknown << Architecture << ParsedAttrs.Architecture << Target;
 
   if (!ParsedAttrs.Tune.empty() &&
       !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Tune))
     return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
-           << Unknown << Tune << ParsedAttrs.Tune;
+           << Unknown << Tune << ParsedAttrs.Tune << Target;
 
   if (ParsedAttrs.DuplicateArchitecture)
     return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
-           << Duplicate << None << "arch=";
+           << Duplicate << None << "arch=" << Target;
   if (ParsedAttrs.DuplicateTune)
     return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
-           << Duplicate << None << "tune=";
+           << Duplicate << None << "tune=" << Target;
 
   for (const auto &Feature : ParsedAttrs.Features) {
     auto CurFeature = StringRef(Feature).drop_front(); // remove + or -.
     if (!Context.getTargetInfo().isValidFeatureName(CurFeature))
       return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
-             << Unsupported << None << CurFeature;
+             << Unsupported << None << CurFeature << Target;
   }
 
   TargetInfo::BranchProtectionInfo BPI;
   StringRef Error;
   if (!ParsedAttrs.BranchProtection.empty() &&
       !Context.getTargetInfo().validateBranchProtection(
           ParsedAttrs.BranchProtection, BPI, Error)) {
     if (Error.empty())
       return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
-             << Unsupported << None << "branch-protection";
+             << Unsupported << None << "branch-protection" << Target;
     else
       return Diag(LiteralLoc, diag::err_invalid_branch_protection_spec)
              << Error;
   }
 
   return false;
 }
 
 static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  // Ensure we don't combine these with themselves, since that causes some
+  // confusing behavior.
+  if (const auto *Other = D->getAttr<TargetAttr>()) {
+    S.Diag(AL.getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
+    S.Diag(Other->getLocation(), diag::note_conflicting_attribute);
+    return;
+  }
+
   StringRef Str;
   SourceLocation LiteralLoc;
   if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
       S.checkTargetAttr(LiteralLoc, Str))
     return;
 
   TargetAttr *NewAttr = ::new (S.Context) TargetAttr(S.Context, AL, Str);
   D->addAttr(NewAttr);
 }
 
+bool Sema::checkTargetClonesAttrString(SourceLocation LiteralLoc, StringRef Str,
+                                       const StringLiteral *Literal,
+                                       bool &HasDefault, bool &HasCommas,
+                                       SmallVectorImpl<StringRef> &Strings) {
+  enum FirstParam { Unsupported, Duplicate, Unknown };
+  enum SecondParam { None, Architecture, Tune };
+  enum ThirdParam { Target, TargetClones };
+  HasCommas = HasCommas || Str.contains(',');
+  // Warn on empty at the beginning of a string.
+  if (Str.size() == 0)
+    return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
+           << Unsupported << None << "" << TargetClones;
+
+  std::pair<StringRef, StringRef> Parts = {{}, Str};
+  while (!Parts.second.empty()) {
+    Parts = Parts.second.split(',');
+    StringRef Cur = Parts.first.trim();
+    SourceLocation CurLoc = Literal->getLocationOfByte(
+        Cur.data() - Literal->getString().data(), getSourceManager(),
+        getLangOpts(), Context.getTargetInfo());
+
+    bool DefaultIsDupe = false;
+    if (Cur.empty())
+      return Diag(CurLoc, diag::warn_unsupported_target_attribute)
+             << Unsupported << None << "" << TargetClones;
+
+    if (Cur.startswith("arch=")) {
+      if (!Context.getTargetInfo().isValidCPUName(
+              Cur.drop_front(sizeof("arch=") - 1)))
+        return Diag(CurLoc, diag::warn_unsupported_target_attribute)
+               << Unsupported << Architecture
+               << Cur.drop_front(sizeof("arch=") - 1) << TargetClones;
+    } else if (Cur == "default") {
+      DefaultIsDupe = HasDefault;
+      HasDefault = true;
+    } else if (!Context.getTargetInfo().isValidFeatureName(Cur))
+      return Diag(CurLoc, diag::warn_unsupported_target_attribute)
+             << Unsupported << None << Cur << TargetClones;
+
+    if (llvm::find(Strings, Cur) != Strings.end() || DefaultIsDupe)
+      Diag(CurLoc, diag::warn_target_clone_duplicate_options);
+    // Note: Add even if there are duplicates, since it changes name mangling.
+    Strings.push_back(Cur);
+  }
+
+  if (Str.rtrim().endswith(","))
+    return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
+           << Unsupported << None << "" << TargetClones;
+  return false;
+}
+
+static void handleTargetClonesAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  // Ensure we don't combine these with themselves, since that causes some
+  // confusing behavior.
+  if (const auto *Other = D->getAttr<TargetClonesAttr>()) {
+    S.Diag(AL.getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
+    S.Diag(Other->getLocation(), diag::note_conflicting_attribute);
+    return;
+  }
+  if (checkAttrMutualExclusion<TargetClonesAttr>(S, D, AL))
+    return;
+
+  SmallVector<StringRef, 2> Strings;
+  bool HasCommas = false, HasDefault = false;
+
+  for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
+    StringRef CurStr;
+    SourceLocation LiteralLoc;
+    if (!S.checkStringLiteralArgumentAttr(AL, I, CurStr, &LiteralLoc) ||
+        S.checkTargetClonesAttrString(
+            LiteralLoc, CurStr,
+            cast<StringLiteral>(AL.getArgAsExpr(I)->IgnoreParenCasts()),
+            HasDefault, HasCommas, Strings))
+      return;
+  }
+
+  if (HasCommas && AL.getNumArgs() > 1)
+    S.Diag(AL.getLoc(), diag::warn_target_clone_mixed_values);
+
+  if (!HasDefault) {
+    S.Diag(AL.getLoc(), diag::err_target_clone_must_have_default);
+    return;
+  }
+
+  // FIXME: We could probably figure out how to get this to work for lambdas
+  // someday.
+  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
+    if (MD->getParent()->isLambda()) {
+      S.Diag(D->getLocation(), diag::err_multiversion_doesnt_support)
+          << static_cast<unsigned>(MultiVersionKind::TargetClones)
+          << /*Lambda*/ 9;
+      return;
+    }
+  }
+
+  cast<FunctionDecl>(D)->setIsMultiVersion();
+  TargetClonesAttr *NewAttr = ::new (S.Context)
+      TargetClonesAttr(S.Context, AL, Strings.data(), Strings.size());
+  D->addAttr(NewAttr);
+}
+
 static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   Expr *E = AL.getArgAsExpr(0);
   uint32_t VecWidth;
   if (!checkUInt32Argument(S, AL, E, VecWidth)) {
     AL.setInvalid();
     return;
   }
 
case ParsedAttr::AT_Section:
     handleSectionAttr(S, D, AL);
     break;
   case ParsedAttr::AT_CodeSeg:
     handleCodeSegAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Target:
     handleTargetAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_TargetClones:
+    handleTargetClonesAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_MinVectorWidth:
     handleMinVectorWidthAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Unavailable:
     handleAttrWithMessage<UnavailableAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_Assumption:
     handleAssumumptionAttr(S, D, AL);

clang/test/CodeGen/attr-target-clones.c

+// RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefixes=LINUX,CHECK
+// RUN: %clang_cc1 -triple x86_64-windows-pc -emit-llvm %s -o - | FileCheck %s --check-prefixes=WINDOWS,CHECK
+
+// LINUX: @foo.ifunc = weak_odr ifunc i32 (), i32 ()* ()* @foo.resolver
+// LINUX: @foo_dupes.ifunc = weak_odr ifunc void (), void ()* ()* @foo_dupes.resolver
+// LINUX: @unused.ifunc = weak_odr ifunc void (), void ()* ()* @unused.resolver
+// LINUX: @foo_inline.ifunc = weak_odr ifunc i32 (), i32 ()* ()* @foo_inline.resolver
+// LINUX: @foo_inline2.ifunc = weak_odr ifunc i32 (), i32 ()* ()* @foo_inline2.resolver
+
+int __attribute__((target_clones("sse4.2, default"))) foo(void) { return 0; }
+// LINUX: define {{.*}}i32 @foo.sse4.2.0()
+// LINUX: define {{.*}}i32 @foo.default.1()
+// LINUX: define i32 ()* @foo.resolver()
+// LINUX: ret i32 ()* @foo.sse4.2.0
+// LINUX: ret i32 ()* @foo.default.1
+
+// WINDOWS: define dso_local i32 @foo.sse4.2.0()
+// WINDOWS: define dso_local i32 @foo.default.1()
+// WINDOWS: define dso_local i32 @foo()
+// WINDOWS: musttail call i32 @foo.sse4.2.0
+// WINDOWS: musttail call i32 @foo.default.1
+
+__attribute__((target_clones("default,default ,sse4.2"))) void foo_dupes(void) {}
+// LINUX: define {{.*}}void @foo_dupes.default.1()
+// LINUX: define {{.*}}void @foo_dupes.sse4.2.0()
+// LINUX: define void ()* @foo_dupes.resolver()
+// LINUX: ret void ()* @foo_dupes.sse4.2.0
+// LINUX: ret void ()* @foo_dupes.default.1
+
+// WINDOWS: define dso_local void @foo_dupes.default.1()
+// WINDOWS: define dso_local void @foo_dupes.sse4.2.0()
+// WINDOWS: define dso_local void @foo_dupes()
+// WINDOWS: musttail call void @foo_dupes.sse4.2.0
+// WINDOWS: musttail call void @foo_dupes.default.1
+
+void bar2() {
+  // LINUX: define {{.*}}void @bar2()
+  // WINDOWS: define dso_local void @bar2()
+  foo_dupes();
+  // LINUX: call void @foo_dupes.ifunc()
+  // WINDOWS: call void @foo_dupes()
+}
+
+int bar() {
+  // LINUX: define {{.*}}i32 @bar() #[[DEF:[0-9]+]]
+  // WINDOWS: define dso_local i32 @bar() #[[DEF:[0-9]+]]
+  return foo();
+  // LINUX: call i32 @foo.ifunc()
+  // WINDOWS: call i32 @foo()
+}
+
+void __attribute__((target_clones("default, arch=ivybridge"))) unused(void) {}
+// LINUX: define {{.*}}void @unused.default.1()
+// LINUX: define {{.*}}void @unused.arch_ivybridge.0()
+// LINUX: define void ()* @unused.resolver()
+// LINUX: ret void ()* @unused.arch_ivybridge.0
+// LINUX: ret void ()* @unused.default.1
+
+// WINDOWS: define dso_local void @unused.default.1()
+// WINDOWS: define dso_local void @unused.arch_ivybridge.0()
+// WINDOWS: define dso_local void @unused()
+// WINDOWS: musttail call void @unused.arch_ivybridge.0
+// WINDOWS: musttail call void @unused.default.1
+
+
+inline int __attribute__((target_clones("arch=sandybridge,default,sse4.2")))
+foo_inline(void) { return 0; }
+inline int __attribute__((target_clones("arch=sandybridge,default,sse4.2")))
+foo_inline2(void);
+
+int bar3() {
+  // LINUX: define {{.*}}i32 @bar3()
+  // WINDOWS: define dso_local i32 @bar3()
+  return foo_inline() + foo_inline2();
+  // LINUX: call i32 @foo_inline.ifunc()
+  // LINUX: call i32 @foo_inline2.ifunc()
+  // WINDOWS: call i32 @foo_inline()
+  // WINDOWS: call i32 @foo_inline2()
+}
+
+// Deferred emission of foo_inline, which got delayed because it is inline.
+// LINUX: define i32 ()* @foo_inline.resolver()
+// LINUX: ret i32 ()* @foo_inline.arch_sandybridge.0
+// LINUX: ret i32 ()* @foo_inline.sse4.2.1
+// LINUX: ret i32 ()* @foo_inline.default.2
+
+// WINDOWS: define dso_local i32 @foo_inline()
+// WINDOWS: musttail call i32 @foo_inline.arch_sandybridge.0
+// WINDOWS: musttail call i32 @foo_inline.sse4.2.1
+// WINDOWS: musttail call i32 @foo_inline.default.2
+
+inline int __attribute__((target_clones("arch=sandybridge,default,sse4.2")))
+foo_inline2(void){ return 0; }
+// LINUX: define linkonce i32 @foo_inline2.arch_sandybridge.0() #[[SB:[0-9]+]]
+// LINUX: define i32 ()* @foo_inline2.resolver()
+// LINUX: ret i32 ()* @foo_inline2.arch_sandybridge.0
+// LINUX: ret i32 ()* @foo_inline2.sse4.2.1
+// LINUX: ret i32 ()* @foo_inline2.default.2
+
+// WINDOWS: define linkonce_odr dso_local i32 @foo_inline2.arch_sandybridge.0() #[[SB:[0-9]+]]
+// WINDOWS: define dso_local i32 @foo_inline2()
+// WINDOWS: musttail call i32 @foo_inline2.arch_sandybridge.0
+// WINDOWS: musttail call i32 @foo_inline2.sse4.2.1
+// WINDOWS: musttail call i32 @foo_inline2.default.2
+
+// LINUX: define linkonce i32 @foo_inline.arch_sandybridge.0() #[[SB]]
+// LINUX: define linkonce i32 @foo_inline.default.2() #[[DEF]]
+// LINUX: define linkonce i32 @foo_inline.sse4.2.1() #[[SSE42:[0-9]+]]
+
+// WINDOWS: define linkonce_odr dso_local i32 @foo_inline.arch_sandybridge.0() #[[SB]]
+// WINDOWS: define linkonce_odr dso_local i32 @foo_inline.default.2() #[[DEF]]
+// WINDOWS: define linkonce_odr dso_local i32 @foo_inline.sse4.2.1() #[[SSE42:[0-9]+]]
+
+
+// LINUX: define linkonce i32 @foo_inline2.default.2() #[[DEF]]
+// LINUX: define linkonce i32 @foo_inline2.sse4.2.1() #[[SSE42]]
+
+// WINDOWS: define linkonce_odr dso_local i32 @foo_inline2.default.2() #[[DEF]]
+// WINDOWS: define linkonce_odr dso_local i32 @foo_inline2.sse4.2.1() #[[SSE42]]
+
+// CHECK: attributes #[[SSE42]] =
+// CHECK-SAME: "target-features"="+crc32,+cx8,+mmx,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87"
+// CHECK: attributes #[[DEF]] =
+// Don't bother checking features, we verified it is the same as a normal function.
+// CHECK: attributes #[[SB]] =
+// CHECK-SAME: "target-features"="+avx,+crc32,+cx16,+cx8,+fxsr,+mmx,+pclmul,+popcnt,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt"

clang/test/CodeGenCXX/attr-target-clones.cpp

+// RUN: %clang_cc1 -std=c++11 -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix=LINUX
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-windows-pc -emit-llvm %s -o - | FileCheck %s --check-prefix=WINDOWS
+
+// Overloaded ifuncs
+// LINUX: @_Z10overloadedi.ifunc = weak_odr ifunc i32 (i32), i32 (i32)* ()* @_Z10overloadedi.resolver
+// LINUX: @_Z10overloadedPKc.ifunc = weak_odr ifunc i32 (i8*), i32 (i8*)* ()* @_Z10overloadedPKc.resolver
+// struct 'C' ifuncs, note the 'float, U' one doesn't get one.
+// LINUX: @_ZN1CIssE3fooEv.ifunc = weak_odr ifunc i32 (%struct.C*), i32 (%struct.C*)* ()* @_ZN1CIssE3fooEv.resolver
+// LINUX: @_ZN1CIisE3fooEv.ifunc = weak_odr ifunc i32 (%struct.C.0*), i32 (%struct.C.0*)* ()* @_ZN1CIisE3fooEv.resolver
+// LINUX: @_ZN1CIdfE3fooEv.ifunc = weak_odr ifunc i32 (%struct.C.2*), i32 (%struct.C.2*)* ()* @_ZN1CIdfE3fooEv.resolver
+
+int __attribute__((target_clones("sse4.2", "default"))) overloaded(int) { return 1; }
+// LINUX: define {{.*}}i32 @_Z10overloadedi.sse4.2.0(i32{{.+}})
+// LINUX: define {{.*}}i32 @_Z10overloadedi.default.1(i32{{.+}})
+// LINUX: define i32 (i32)* @_Z10overloadedi.resolver
+// LINUX: ret i32 (i32)* @_Z10overloadedi.sse4.2.0
+// LINUX: ret i32 (i32)* @_Z10overloadedi.default.1
+
+// WINDOWS: define dso_local i32 @"?overloaded@@[e-mail]4.2.0"(i32{{.+}})
+// WINDOWS: define dso_local i32 @"?overloaded@@[e-mail].1"(i32{{.+}})
+// WINDOWS: define dso_local i32 @"?overloaded@@YAHH@Z"(i32{{.+}})
+// WINDOWS: call i32 @"?overloaded@@[e-mail]4.2.0"
+// WINDOWS: call i32 @"?overloaded@@[e-mail].1"
+
+int __attribute__((target_clones("arch=ivybridge", "default"))) overloaded(const char *) { return 2; }
+// LINUX: define {{.*}}i32 @_Z10overloadedPKc.arch_ivybridge.0(i8*{{.+}})
+// LINUX: define {{.*}}i32 @_Z10overloadedPKc.default.1(i8*{{.+}})
+// LINUX: define i32 (i8*)* @_Z10overloadedPKc.resolver
+// LINUX: ret i32 (i8*)* @_Z10overloadedPKc.arch_ivybridge.0
+// LINUX: ret i32 (i8*)* @_Z10overloadedPKc.default.1
+
+// WINDOWS: define dso_local i32 @"?overloaded@@[e-mail]_ivybridge.0"(i8*{{.+}})
+// WINDOWS: define dso_local i32 @"?overloaded@@[e-mail].1"(i8*{{.+}})
+// WINDOWS: define dso_local i32 @"?overloaded@@YAHPEBD@Z"(i8*{{.+}})
+// WINDOWS: call i32 @"?overloaded@@[e-mail]_ivybridge.0"
+// WINDOWS: call i32 @"?overloaded@@[e-mail].1"
+//
+void use_overloaded() {
+  overloaded(1);
+  // LINUX: call i32 @_Z10overloadedi.ifunc
+  // WINDOWS: call i32 @"?overloaded@@YAHH@Z"
+  overloaded(nullptr);
+  // LINUX: call i32 @_Z10overloadedPKc.ifunc 
+  // WINDOWS: call i32 @"?overloaded@@YAHPEBD@Z"
+}
+
+template<typename T, typename U>
+struct C {
+int __attribute__((target_clones("sse4.2", "default"))) foo(){ return 1;}
+};
+template<typename U>
+struct C<int, U> {
+int __attribute__((target_clones("sse4.2", "default"))) foo(){ return 2;}
+};
+template<typename U>
+struct C<float, U> {
+int foo(){ return 2;}
+};
+template<>
+struct C<double, float> {
+int __attribute__((target_clones("sse4.2", "default"))) foo(){ return 3;}
+};
+
+void uses_specialized() {
+  C<short, short> c;
+  c.foo();
+  // LINUX: call i32 @_ZN1CIssE3fooEv.ifunc(%struct.C
+  // WINDOWS: call i32 @"?foo@?$C@FF@@QEAAHXZ"(%struct.C
+  C<int, short> c2;
+  c2.foo();
+  // LINUX: call i32 @_ZN1CIisE3fooEv.ifunc(%struct.C
+  // WINDOWS: call i32 @"?foo@?$C@HF@@QEAAHXZ"(%struct.C
+  C<float, short> c3;
+  c3.foo();
+  // Note this is not an ifunc/mv
+  // LINUX: call i32 @_ZN1CIfsE3fooEv(%struct.C
+  // WINDOWS: call i32 @"?foo@?$C@MF@@QEAAHXZ"(%struct.C
+  C<double, float> c4;
+  c4.foo();
+  // LINUX: call i32 @_ZN1CIdfE3fooEv.ifunc(%struct.C
+  // WINDOWS: call i32 @"?foo@?$C@NM@@QEAAHXZ"(%struct.C
+}
+
+// LINUX: define {{.*}}i32 @_ZN1CIssE3fooEv.sse4.2.0(%struct.C{{.+}})
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@FF@@QEAAHXZ.sse4.2.0"(%struct.C{{.+}})
+// LINUX: define i32 (%struct.C*)* @_ZN1CIssE3fooEv.resolver
+// LINUX: ret i32 (%struct.C*)* @_ZN1CIssE3fooEv.sse4.2.0
+// LINUX: ret i32 (%struct.C*)* @_ZN1CIssE3fooEv.default.1
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@FF@@QEAAHXZ"(%struct.C{{.+}})
+// WINDOWS: call i32 @"?foo@?$C@FF@@QEAAHXZ.sse4.2.0"
+// WINDOWS: call i32 @"?foo@?$C@FF@@QEAAHXZ.default.1"
+
+// LINUX: define {{.*}}i32 @_ZN1CIisE3fooEv.sse4.2.0(%struct.C{{.+}})
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@HF@@QEAAHXZ.sse4.2.0"(%struct.C{{.+}})
+// LINUX: define i32 (%struct.C{{.+}})* @_ZN1CIisE3fooEv.resolver
+// LINUX: ret i32 (%struct.C{{.+}})* @_ZN1CIisE3fooEv.sse4.2.0
+// LINUX: ret i32 (%struct.C{{.+}})* @_ZN1CIisE3fooEv.default.1
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@HF@@QEAAHXZ"(%struct.C{{.+}})
+// WINDOWS: call i32 @"?foo@?$C@HF@@QEAAHXZ.sse4.2.0"
+// WINDOWS: call i32 @"?foo@?$C@HF@@QEAAHXZ.default.1"
+
+// LINUX: define i32 (%struct.C{{.+}})* @_ZN1CIdfE3fooEv.resolver
+// LINUX: ret i32 (%struct.C{{.+}})* @_ZN1CIdfE3fooEv.sse4.2.0
+// LINUX: ret i32 (%struct.C{{.+}})* @_ZN1CIdfE3fooEv.default.1
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@NM@@QEAAHXZ"(%struct.C{{.+}})
+// WINDOWS: call i32 @"?foo@?$C@NM@@QEAAHXZ.sse4.2.0"
+// WINDOWS: call i32 @"?foo@?$C@NM@@QEAAHXZ.default.1"
+
+// LINUX: define {{.*}}i32 @_ZN1CIdfE3fooEv.sse4.2.0(%struct.C{{.+}})
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@NM@@QEAAHXZ.sse4.2.0"(%struct.C{{.+}})
+// LINUX: define {{.*}}i32 @_ZN1CIdfE3fooEv.default.1(%struct.C{{.+}})
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@NM@@QEAAHXZ.default.1"(%struct.C{{.+}})
+// LINUX: define {{.*}}i32 @_ZN1CIssE3fooEv.default.1(%struct.C{{.+}})
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@FF@@QEAAHXZ.default.1"(%struct.C{{.+}})
+// LINUX: define {{.*}}i32 @_ZN1CIisE3fooEv.default.1(%struct.C{{.+}})
+// WINDOWS: define {{.*}}i32 @"?foo@?$C@HF@@QEAAHXZ.default.1"(%struct.C{{.+}})

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: SwiftContext (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: SwiftError (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: SwiftErrorResult (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: SwiftIndirectResult (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: SwiftNewType (SubjectMatchRule_type_alias)
 // CHECK-NEXT: SwiftObjCMembers (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: TLSModel (SubjectMatchRule_variable_is_thread_local)
 // CHECK-NEXT: Target (SubjectMatchRule_function)
+// CHECK-NEXT: TargetClones (SubjectMatchRule_function)
 // CHECK-NEXT: TestTypestate (SubjectMatchRule_function_is_member)
 // CHECK-NEXT: TrivialABI (SubjectMatchRule_record)
 // CHECK-NEXT: Uninitialized (SubjectMatchRule_variable_is_local)
 // CHECK-NEXT: UseHandle (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: VecReturn (SubjectMatchRule_record)
 // CHECK-NEXT: VecTypeHint (SubjectMatchRule_function)
 // CHECK-NEXT: WarnUnused (SubjectMatchRule_record)
 // CHECK-NEXT: WarnUnusedResult (SubjectMatchRule_objc_method, SubjectMatchRule_enum, SubjectMatchRule_record, SubjectMatchRule_hasType_functionType)

clang/test/Sema/attr-cpuspecific.c

 //expected-error@+1 {{attribute 'cpu_specific' multiversioning cannot be combined with attribute 'used'}}
 void __attribute__((used,cpu_specific(sandybridge)))  addtl_attrs(void);
 
 void __attribute__((target("default"))) addtl_attrs2(void);
 // expected-error@+2 {{multiversioning attributes cannot be combined}}
 // expected-note@-2 {{previous declaration is here}}
 void __attribute__((cpu_specific(sandybridge))) addtl_attrs2(void);
 
-// expected-error@+2 {{multiversioning attributes cannot be combined}}
+// expected-error@+2 {{'cpu_dispatch' and 'cpu_specific' attributes are not compatible}}
+// expected-note@+1 {{conflicting attribute is here}}
 void __attribute((cpu_specific(sandybridge), cpu_dispatch(atom, sandybridge)))
 combine_attrs(void);
 
 int __attribute__((cpu_dispatch(ivybridge))) diff_cc(void){}
 // expected-error@+1 {{multiversioned function declaration has a different calling convention}}
 __vectorcall int __attribute__((cpu_specific(sandybridge))) diff_cc(void);
 
 // expected-warning@+2 {{body of cpu_dispatch function will be ignored}}

clang/test/Sema/attr-target-clones.c

+// RUN: %clang_cc1 -triple x86_64-linux-gnu  -fsyntax-only -verify %s
+
+// expected-error@+1 {{'target_clones' multiversioning requires a default target}}
+void __attribute__((target_clones("sse4.2", "arch=sandybridge")))
+no_default(void);
+
+// expected-error@+2 {{'target_clones' and 'target' attributes are not compatible}}
+// expected-note@+1 {{conflicting attribute is here}}
+void __attribute__((target("sse4.2"), target_clones("arch=sandybridge")))
+ignored_attr(void);
+// expected-error@+2 {{'target' and 'target_clones' attributes are not compatible}}
+// expected-note@+1 {{conflicting attribute is here}}
+void __attribute__((target_clones("arch=sandybridge,default"), target("sse4.2")))
+ignored_attr2(void);
+
+int redecl(void);
+int __attribute__((target_clones("sse4.2", "default"))) redecl(void) { return 1; }
+
+int __attribute__((target_clones("sse4.2", "default"))) redecl2(void);
+int __attribute__((target_clones("sse4.2", "default"))) redecl2(void) { return 1; }
+
+int __attribute__((target_clones("sse4.2", "default"))) redecl3(void);
+int redecl3(void);
+
+int __attribute__((target_clones("sse4.2", "arch=atom", "default"))) redecl4(void);
+// expected-error@+3 {{'target_clones' attribute does not match previous declaration}}
+// expected-note@-2 {{previous declaration is here}}
+int __attribute__((target_clones("sse4.2", "arch=sandybridge", "default")))
+redecl4(void) { return 1; }
+
+int __attribute__((target("sse4.2"))) redef2(void) { return 1; }
+// expected-error@+2 {{multiversioning attributes cannot be combined}}
+// expected-note@-2 {{previous declaration is here}}
+int __attribute__((target_clones("sse4.2", "default"))) redef2(void) { return 1; }
+
+int __attribute__((target_clones("sse4.2,default"))) redef3(void) { return 1; }
+// expected-error@+2 {{redefinition of 'redef3'}}
+// expected-note@-2 {{previous definition is here}}
+int __attribute__((target_clones("sse4.2,default"))) redef3(void) { return 1; }
+
+int __attribute__((target_clones("sse4.2,default"))) redef4(void) { return 1; }
+// expected-error@+2 {{redefinition of 'redef4'}}
+// expected-note@-2 {{previous definition is here}}
+int __attribute__((target_clones("sse4.2,default"))) redef4(void) { return 1; }
+
+// Duplicates are allowed, however they alter name mangling.
+// expected-warning@+2 {{mixing 'target_clones' specifier mechanisms is permitted for GCC compatibility}}
+// expected-warning@+1 2 {{version list contains duplicate entries}}
+int __attribute__((target_clones("arch=atom,arch=atom", "arch=atom,default")))
+dupes(void) { return 1; }
+
+// expected-warning@+1 {{unsupported '' in the 'target_clones' attribute string;}}
+void __attribute__((target_clones("")))
+empty_target_1(void);
+// expected-warning@+1 {{unsupported '' in the 'target_clones' attribute string;}}
+void __attribute__((target_clones(",default")))
+empty_target_2(void);
+// expected-warning@+1 {{unsupported '' in the 'target_clones' attribute string;}}
+void __attribute__((target_clones("default,")))
+empty_target_3(void);
+// expected-warning@+1 {{unsupported '' in the 'target_clones' attribute string;}}
+void __attribute__((target_clones("default, ,avx2")))
+empty_target_4(void);
+
+// expected-warning@+1 {{unsupported '' in the 'target_clones' attribute string;}}
+void __attribute__((target_clones("default,avx2", "")))
+empty_target_5(void);
+
+// expected-warning@+1 {{version list contains duplicate entries}}
+void __attribute__((target_clones("default", "default")))
+dupe_default(void);
+
+// expected-warning@+1 {{version list contains duplicate entries}}
+void __attribute__((target_clones("avx2,avx2,default")))
+dupe_normal(void);
+
+// expected-error@+2 {{attribute 'target_clones' cannot appear more than once on a declaration}}
+// expected-note@+1 {{conflicting attribute is here}}
+void __attribute__((target_clones("avx2,default"), target_clones("arch=atom,default")))
+dupe_normal2(void);
+
+int mv_after_use(void);
+int useage() {
+  return mv_after_use();
+}
+// expected-error@+1 {{function declaration cannot become a multiversioned function after first usage}}
+int __attribute__((target_clones("sse4.2", "default"))) mv_after_use(void) { return 1; }
+

clang/test/SemaCXX/attr-target-clones.cpp

+// RUN: %clang_cc1 -triple x86_64-linux-gnu  -fsyntax-only -verify -fexceptions -fcxx-exceptions %s -std=c++14
+
+// expected-error@+2 {{attribute 'target_clones' multiversioned functions do not yet support function templates}}
+template<typename T, typename U>
+int __attribute__((target_clones("sse4.2", "default"))) foo(){ return 1;}
+
+void uses_lambda() {
+  // expected-error@+1 {{attribute 'target_clones' multiversioned functions do not yet support lambdas}}
+  auto x = []()__attribute__((target_clones("sse4.2", "arch=ivybridge", "default"))) {};
+  x();
+}