[clang] NFC: Preparation for merging code to emit target and target_clones resolvers.

[tahonermann]

Summary

This change modifies CodeGenModule::emitMultiVersionFunctions() in preparation
for a change that will merge support for emitting target_clones resolvers into
this function. This change mostly serves to isolate indentation changes from
later behavior modifying changes.

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::EmitTargetClonesResolver(GlobalDecl GD) {
   CodeGenFunction CGF(*this);
   CGF.EmitMultiVersionResolver(ResolverFunc, Options);
 }
 
 void CodeGenModule::emitMultiVersionFunctions() {
   std::vector<GlobalDecl> MVFuncsToEmit;
   MultiVersionFuncs.swap(MVFuncsToEmit);
   for (GlobalDecl GD : MVFuncsToEmit) {
+    const auto *FD = cast<FunctionDecl>(GD.getDecl());
+    assert(FD && "Expected a FunctionDecl");
+
     SmallVector<CodeGenFunction::MultiVersionResolverOption, 10> Options;
-    const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
+    if (FD->isTargetMultiVersion()) {
       getContext().forEachMultiversionedFunctionVersion(
           FD, [this, &GD, &Options](const FunctionDecl *CurFD) {
             GlobalDecl CurGD{
                 (CurFD->isDefined() ? CurFD->getDefinition() : CurFD)};
             StringRef MangledName = getMangledName(CurGD);
             llvm::Constant *Func = GetGlobalValue(MangledName);
             if (!Func) {
               if (CurFD->isDefined()) {
                 EmitGlobalFunctionDefinition(CurGD, nullptr);
                 Func = GetGlobalValue(MangledName);
               } else {
                 const CGFunctionInfo &FI =
                     getTypes().arrangeGlobalDeclaration(GD);
                 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
                 Func = GetAddrOfFunction(CurGD, Ty, /*ForVTable=*/false,
                                          /*DontDefer=*/false, ForDefinition);
               }
               assert(Func && "This should have just been created");
             }
 
             const auto *TA = CurFD->getAttr<TargetAttr>();
             llvm::SmallVector<StringRef, 8> Feats;
             TA->getAddedFeatures(Feats);
 
             Options.emplace_back(cast<llvm::Function>(Func),
                                  TA->getArchitecture(), Feats);
           });
+    } else {
+      assert(0 && "Expected a target multiversion function");
+      continue;
+    }
 
     llvm::Function *ResolverFunc;
     const TargetInfo &TI = getTarget();
 
     if (TI.supportsIFunc() || FD->isTargetMultiVersion()) {
       ResolverFunc = cast<llvm::Function>(
           GetGlobalValue((getMangledName(GD) + ".resolver").str()));
       ResolverFunc->setLinkage(getMultiversionLinkage(*this, GD));