Fix clang -Wimplicit-fallthrough warnings across llvm, NFC

[rnk]

Summary

This patch should not introduce any behavior changes. It consists of
mostly one of two changes:

1. Replacing fall through comments with the LLVM_FALLTHROUGH macro
2. Inserting 'break' before falling through into a case block consisting of only 'break'.

We were already using this warning with GCC, but its warning behaves
slightly differently. In this patch, the following differences are
relevant:

1. GCC recognizes comments that say "fall through" as annotations, clang doesn't
2. GCC doesn't warn on "case N: foo(); default: break;", clang does
3. GCC doesn't warn when the case contains a switch, but falls through the outer case.

I will enable the warning separately in a follow-up patch so that it can
be cleanly reverted if necessary.

[bogner]

clang-tools-extra/clang-tidy/google/AvoidCStyleCastsCheck.cpp

190 ↗

(On Diff #172020)

Having both LLVM_FALLTHROUGH and the comment is redundant.

clang/lib/AST/ExprConstant.cpp

11146 ↗

(On Diff #172020)

Could you commit this case (and the one below) separately? While most of the changes in this patch are mechanical, this one is arguably a correctness fix.

[rnk]

clang-tools-extra/clang-tidy/google/AvoidCStyleCastsCheck.cpp

190 ↗

(On Diff #172020)

It is, but I made an effort to preserve comments like this everywhere, since I thought it might go down easier for more folks. It's not hard to remove them, of course.

clang/lib/AST/ExprConstant.cpp

11146 ↗

(On Diff #172020)

Sure, there's this and a couple others, like the AArch64ISelLowering one.

[bogner]

lgtm as long as there's general consent to the idea in the llvm-dev thread.

clang-tools-extra/clang-tidy/google/AvoidCStyleCastsCheck.cpp

190 ↗

(On Diff #172020)

I'd prefer them removed, unless someone really wants them for some reason.

[alexfh]

Great! Thanks for picking this up and pushing forward!

clang/lib/Analysis/FormatString.cpp

692 ↗

(On Diff #172020)

None of these comments seem useful.

clang/tools/clang-func-mapping/ClangFnMapGen.cpp

85 ↗

(On Diff #172020)

Incorrect indentation.

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

11039–11040 ↗

(On Diff #172020)

This looks like something that's better to commit separately.

llvm/lib/Target/AMDGPU/SIISelLowering.cpp

5053 ↗

(On Diff #172020)

Maybe remove the braces? There are none in the other cases.

llvm/lib/Target/Hexagon/HexagonConstExtenders.cpp

791 ↗

(On Diff #172020)

Commit bug fixes separately?

1211 ↗

(On Diff #172020)

Invalid indentation.

llvm/lib/Target/Hexagon/HexagonVLIWPacketizer.cpp

1571 ↗

(On Diff #172020)

Incorrect indentation

[MatzeB]

LGTM, thanks for pushing this! Some of the changes here look like things that were just waiting to become an actual problem.

[rnk]

Address comments
Split out all behavior changes

[rnk]

clang/lib/AST/ExprConstant.cpp

11146 ↗

(On Diff #172020)

This became rC345862.

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

11039–11040 ↗

(On Diff #172020)

This became rL345864.

llvm/lib/Target/Hexagon/HexagonConstExtenders.cpp

791 ↗

(On Diff #172020)

This became rL345868.

cfe/trunk/lib/ARCMigrate/TransRetainReleaseDealloc.cpp

case OMF_release:
                 "it is not safe to remove 'retain' "
                 "message on the result of a 'delegate' message; "
                 "the object that was passed to 'setDelegate:' may not be "
                 "properly retained",
                 rec->getBeginLoc());
             return true;
           }
         }
+      break;
     case OMF_dealloc:
       break;
     }
 
     switch (E->getReceiverKind()) {
     default:
       return true;
     case ObjCMessageExpr::SuperInstance: {

cfe/trunk/lib/Analysis/CFG.cpp

void CFGBuilder::findConstructionContexts(
   }
   case Stmt::ImplicitCastExprClass: {
     auto *Cast = cast<ImplicitCastExpr>(Child);
     // Should we support other implicit cast kinds?
     switch (Cast->getCastKind()) {
     case CK_NoOp:
     case CK_ConstructorConversion:
       findConstructionContexts(Layer, Cast->getSubExpr());
+      break;
     default:
       break;
     }
     break;
   }
   case Stmt::CXXBindTemporaryExprClass: {
     auto *BTE = cast<CXXBindTemporaryExpr>(Child);
     findConstructionContexts(withExtraLayer(BTE), BTE->getSubExpr());

cfe/trunk/lib/Analysis/FormatString.cpp

case LengthModifier::AsShort:
           case ConversionSpecifier::sArg:
           case ConversionSpecifier::SArg:
           case ConversionSpecifier::ZArg:
             return true;
           default:
             break;
         }
       }
-      // Fall through.
+      LLVM_FALLTHROUGH;
     case LengthModifier::AsChar:
     case LengthModifier::AsLongLong:
     case LengthModifier::AsQuad:
     case LengthModifier::AsIntMax:
     case LengthModifier::AsSizeT:
     case LengthModifier::AsPtrDiff:
       switch (CS.getKind()) {
         case ConversionSpecifier::dArg:

cfe/trunk/lib/Analysis/ReachableCode.cpp

case Stmt::CallExprClass: {
       const FunctionDecl *Callee =
         dyn_cast_or_null<FunctionDecl>(cast<CallExpr>(S)->getCalleeDecl());
       return Callee ? Callee->isConstexpr() : false;
     }
     case Stmt::DeclRefExprClass:
       return isConfigurationValue(cast<DeclRefExpr>(S)->getDecl(), PP);
     case Stmt::ObjCBoolLiteralExprClass:
       IgnoreYES_NO = true;
-      // Fallthrough.
+      LLVM_FALLTHROUGH;
     case Stmt::CXXBoolLiteralExprClass:
     case Stmt::IntegerLiteralClass: {
       const Expr *E = cast<Expr>(S);
       if (IncludeIntegers) {
         if (SilenceableCondVal && !SilenceableCondVal->getBegin().isValid())
           *SilenceableCondVal = E->getSourceRange();
         return WrappedInParens || isExpandedFromConfigurationMacro(E, PP, IgnoreYES_NO);
       }

cfe/trunk/lib/Basic/IdentifierTable.cpp

case 'd':
       if (startsWithWord(name, "dictionary")) return OIT_Dictionary;
       break;
     case 's':
       if (startsWithWord(name, "shared")) return OIT_ReturnsSelf;
       if (startsWithWord(name, "standard")) return OIT_Singleton;
       break;
     case 'i':
       if (startsWithWord(name, "init")) return OIT_Init;
+      break;
     default:
       break;
   }
   return OIT_None;
 }
 
 ObjCStringFormatFamily Selector::getStringFormatFamilyImpl(Selector sel) {
   IdentifierInfo *first = sel.getIdentifierInfoForSlot(0);

cfe/trunk/lib/Basic/Targets/OSTargets.h

 
 public:
   OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
     switch (Triple.getArch()) {
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       this->HasFloat128 = true;
-      // FALLTHROUGH
+      LLVM_FALLTHROUGH;
     default:
       this->MCountName = "__mcount";
       break;
     case llvm::Triple::mips64:
     case llvm::Triple::mips64el:
     case llvm::Triple::ppc:
     case llvm::Triple::sparcv9:
       this->MCountName = "_mcount";

cfe/trunk/lib/Basic/Targets/X86.h

case 'D':
       return "di";
     // In case the constraint is 'r' we need to return Expression
     case 'r':
       return Expression;
     // Double letters Y<x> constraints
     case 'Y':
       if ((++I != E) && ((*I == '0') || (*I == 'z')))
         return "xmm0";
+      break;
     default:
       break;
     }
     return "";
   }
 
   bool useFP16ConversionIntrinsics() const override {
     return false;

cfe/trunk/lib/CodeGen/CGBuiltin.cpp

case NEON::BI__builtin_neon_vcvtd_f64_s64: {
     if (usgn)
       return Builder.CreateUIToFP(Ops[0], FTy);
     return Builder.CreateSIToFP(Ops[0], FTy);
   }
   case NEON::BI__builtin_neon_vcvth_f16_u16:
   case NEON::BI__builtin_neon_vcvth_f16_u32:
   case NEON::BI__builtin_neon_vcvth_f16_u64:
     usgn = true;
-    // FALL THROUGH
+    LLVM_FALLTHROUGH;
   case NEON::BI__builtin_neon_vcvth_f16_s16:
   case NEON::BI__builtin_neon_vcvth_f16_s32:
   case NEON::BI__builtin_neon_vcvth_f16_s64: {
     Ops.push_back(EmitScalarExpr(E->getArg(0)));
     llvm::Type *FTy = HalfTy;
     llvm::Type *InTy;
     if (Ops[0]->getType()->getPrimitiveSizeInBits() == 64)
       InTy = Int64Ty;
     else if (Ops[0]->getType()->getPrimitiveSizeInBits() == 32)
       InTy = Int32Ty;
     else
       InTy = Int16Ty;
     Ops[0] = Builder.CreateBitCast(Ops[0], InTy);
     if (usgn)
       return Builder.CreateUIToFP(Ops[0], FTy);
     return Builder.CreateSIToFP(Ops[0], FTy);
   }
   case NEON::BI__builtin_neon_vcvth_u16_f16:
     usgn = true;
-    // FALL THROUGH
+    LLVM_FALLTHROUGH;
   case NEON::BI__builtin_neon_vcvth_s16_f16: {
     Ops.push_back(EmitScalarExpr(E->getArg(0)));
     Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
     if (usgn)
       return Builder.CreateFPToUI(Ops[0], Int16Ty);
     return Builder.CreateFPToSI(Ops[0], Int16Ty);
   }
   case NEON::BI__builtin_neon_vcvth_u32_f16:
     usgn = true;
-    // FALL THROUGH
+    LLVM_FALLTHROUGH;
   case NEON::BI__builtin_neon_vcvth_s32_f16: {
     Ops.push_back(EmitScalarExpr(E->getArg(0)));
     Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
     if (usgn)
       return Builder.CreateFPToUI(Ops[0], Int32Ty);
     return Builder.CreateFPToSI(Ops[0], Int32Ty);
   }
   case NEON::BI__builtin_neon_vcvth_u64_f16:
     usgn = true;
-    // FALL THROUGH
+    LLVM_FALLTHROUGH;
   case NEON::BI__builtin_neon_vcvth_s64_f16: {
     Ops.push_back(EmitScalarExpr(E->getArg(0)));
     Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
     if (usgn)
       return Builder.CreateFPToUI(Ops[0], Int64Ty);
     return Builder.CreateFPToSI(Ops[0], Int64Ty);
   }
   case NEON::BI__builtin_neon_vcvtah_u16_f16:

cfe/trunk/lib/CodeGen/CGExprScalar.cpp

public:
   Value *EmitMul(const BinOpInfo &Ops) {
     if (Ops.Ty->isSignedIntegerOrEnumerationType()) {
       switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
       case LangOptions::SOB_Defined:
         return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
       case LangOptions::SOB_Undefined:
         if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
           return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
-        // Fall through.
+        LLVM_FALLTHROUGH;
       case LangOptions::SOB_Trapping:
         if (CanElideOverflowCheck(CGF.getContext(), Ops))
           return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
         return EmitOverflowCheckedBinOp(Ops);
       }
     }
 
     if (Ops.Ty->isUnsignedIntegerType() &&
llvm::Value *Amount =
       llvm::ConstantInt::get(InVal->getType(), IsInc ? 1 : -1, true);
   StringRef Name = IsInc ? "inc" : "dec";
   switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
   case LangOptions::SOB_Defined:
     return Builder.CreateAdd(InVal, Amount, Name);
   case LangOptions::SOB_Undefined:
     if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
       return Builder.CreateNSWAdd(InVal, Amount, Name);
-    // Fall through.
+    LLVM_FALLTHROUGH;
   case LangOptions::SOB_Trapping:
     if (!E->canOverflow())
       return Builder.CreateNSWAdd(InVal, Amount, Name);
     return EmitOverflowCheckedBinOp(createBinOpInfoFromIncDec(E, InVal, IsInc));
   }
   llvm_unreachable("Unknown SignedOverflowBehaviorTy");
 }
 
Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &op) {
 
   if (op.Ty->isSignedIntegerOrEnumerationType()) {
     switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
     case LangOptions::SOB_Defined:
       return Builder.CreateAdd(op.LHS, op.RHS, "add");
     case LangOptions::SOB_Undefined:
       if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
         return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
-      // Fall through.
+      LLVM_FALLTHROUGH;
     case LangOptions::SOB_Trapping:
       if (CanElideOverflowCheck(CGF.getContext(), op))
         return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
       return EmitOverflowCheckedBinOp(op);
     }
   }
 
   if (op.Ty->isUnsignedIntegerType() &&
Value *ScalarExprEmitter::EmitSub(const BinOpInfo &op) {
   if (!op.LHS->getType()->isPointerTy()) {
     if (op.Ty->isSignedIntegerOrEnumerationType()) {
       switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
       case LangOptions::SOB_Defined:
         return Builder.CreateSub(op.LHS, op.RHS, "sub");
       case LangOptions::SOB_Undefined:
         if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
           return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
-        // Fall through.
+        LLVM_FALLTHROUGH;
       case LangOptions::SOB_Trapping:
         if (CanElideOverflowCheck(CGF.getContext(), op))
           return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
         return EmitOverflowCheckedBinOp(op);
       }
     }
 
     if (op.Ty->isUnsignedIntegerType() &&

cfe/trunk/lib/CodeGen/CGObjCRuntime.cpp

void CGObjCRuntime::EmitInitOfCatchParam(CodeGenFunction &CGF,
                                          llvm::Value *exn,
                                          const VarDecl *paramDecl) {
 
   Address paramAddr = CGF.GetAddrOfLocalVar(paramDecl);
 
   switch (paramDecl->getType().getQualifiers().getObjCLifetime()) {
   case Qualifiers::OCL_Strong:
     exn = CGF.EmitARCRetainNonBlock(exn);
-    // fallthrough
+    LLVM_FALLTHROUGH;
 
   case Qualifiers::OCL_None:
   case Qualifiers::OCL_ExplicitNone:
   case Qualifiers::OCL_Autoreleasing:
     CGF.Builder.CreateStore(exn, paramAddr);
     return;
 
   case Qualifiers::OCL_Weak:

cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp

case Type::ObjCObject:
 
     // Handle id and Class.
     if (isa<BuiltinType>(Ty)) {
       VTableName = ClassTypeInfo;
       break;
     }
 
     assert(isa<ObjCInterfaceType>(Ty));
-    // Fall through.
+    LLVM_FALLTHROUGH;
 
   case Type::ObjCInterface:
     if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
       VTableName = SIClassTypeInfo;
     } else {
       VTableName = ClassTypeInfo;
     }
     break;
if (TEK != TEK_Aggregate) {
     // the pointer by value.
     if (CatchType->hasPointerRepresentation()) {
       llvm::Value *CastExn =
         CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
 
       switch (CatchType.getQualifiers().getObjCLifetime()) {
       case Qualifiers::OCL_Strong:
         CastExn = CGF.EmitARCRetainNonBlock(CastExn);
-        // fallthrough
+        LLVM_FALLTHROUGH;
 
       case Qualifiers::OCL_None:
       case Qualifiers::OCL_ExplicitNone:
       case Qualifiers::OCL_Autoreleasing:
         CGF.Builder.CreateStore(CastExn, ParamAddr);
         return;
 
       case Qualifiers::OCL_Weak:

cfe/trunk/lib/CodeGen/VarBypassDetector.cpp

if (const Stmt *Init = cast<SwitchStmt>(S)->getInit()) {
         return false;
       ++StmtsToSkip;
     }
     if (const VarDecl *Var = cast<SwitchStmt>(S)->getConditionVariable()) {
       if (!BuildScopeInformation(Var, ParentScope))
         return false;
       ++StmtsToSkip;
     }
-  // Fall through
+    LLVM_FALLTHROUGH;
 
   case Stmt::GotoStmtClass:
     FromScopes.push_back({S, ParentScope});
     break;
 
   case Stmt::DeclStmtClass: {
     const DeclStmt *DS = cast<DeclStmt>(S);
     for (auto *I : DS->decls())

cfe/trunk/lib/Frontend/CompilerInstance.cpp

while (1) {
     case llvm::LockFileManager::LFS_Error:
       // PCMCache takes care of correctness and locks are only necessary for
       // performance. Fallback to building the module in case of any lock
       // related errors.
       Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
           << Module->Name << Locked.getErrorMessage();
       // Clear out any potential leftover.
       Locked.unsafeRemoveLockFile();
-      // FALLTHROUGH
+      LLVM_FALLTHROUGH;
     case llvm::LockFileManager::LFS_Owned:
       // We're responsible for building the module ourselves.
       if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
                              ModuleFileName)) {
         diagnoseBuildFailure();
         return false;
       }
       break;

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
     case OPT_emit_llvm_only:
       Opts.ProgramAction = frontend::EmitLLVMOnly; break;
     case OPT_emit_codegen_only:
       Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
     case OPT_emit_obj:
       Opts.ProgramAction = frontend::EmitObj; break;
     case OPT_fixit_EQ:
       Opts.FixItSuffix = A->getValue();
-      // fall-through!
+      LLVM_FALLTHROUGH;
     case OPT_fixit:
       Opts.ProgramAction = frontend::FixIt; break;
     case OPT_emit_module:
       Opts.ProgramAction = frontend::GenerateModule; break;
     case OPT_emit_module_interface:
       Opts.ProgramAction = frontend::GenerateModuleInterface; break;
     case OPT_emit_header_module:
       Opts.ProgramAction = frontend::GenerateHeaderModule; break;

cfe/trunk/lib/Frontend/Rewrite/InclusionRewriter.cpp

if (RawToken.is(tok::hash) && RawToken.isAtStartOfLine()) {
               RawLex.LexFromRawLexer(RawToken);
             } while (RawToken.isNot(tok::eod) && RawToken.isNot(tok::eof));
             OutputContentUpTo(FromFile, NextToWrite,
                               SM.getFileOffset(RawToken.getLocation()) +
                                   RawToken.getLength(),
                               LocalEOL, Line, /*EnsureNewline=*/ true);
             WriteLineInfo(FileName, Line, FileType);
             RawLex.SetKeepWhitespaceMode(false);
+            break;
           }
           default:
             break;
         }
       }
       RawLex.setParsingPreprocessorDirective(false);
     }
     RawLex.LexFromRawLexer(RawToken);

cfe/trunk/lib/Index/CommentToXML.cpp

void CommentASTToXMLConverter::visitBlockCommandComment(
   case CommandTraits::KCI_remarks:
   case CommandTraits::KCI_sa:
   case CommandTraits::KCI_see:
   case CommandTraits::KCI_since:
   case CommandTraits::KCI_todo:
   case CommandTraits::KCI_version:
   case CommandTraits::KCI_warning:
     ParagraphKind = C->getCommandName(Traits);
+    break;
   default:
     break;
   }
 
   appendParagraphCommentWithKind(C->getParagraph(), ParagraphKind);
 }
 
 void CommentASTToXMLConverter::visitParamCommandComment(

cfe/trunk/lib/Index/USRGeneration.cpp

case TemplateArgument::Declaration:
     Visit(Arg.getAsDecl());
     break;
 
   case TemplateArgument::NullPtr:
     break;
 
   case TemplateArgument::TemplateExpansion:
     Out << 'P'; // pack expansion of...
-    // Fall through
+    LLVM_FALLTHROUGH;
   case TemplateArgument::Template:
     VisitTemplateName(Arg.getAsTemplateOrTemplatePattern());
     break;
 
   case TemplateArgument::Expression:
     // FIXME: Visit expressions.
     break;
 

cfe/trunk/lib/Lex/LiteralSupport.cpp

case 'I':
             break;
           }
         }
         if (MicrosoftInteger) {
           assert(s <= ThisTokEnd && "didn't maximally munch?");
           break;
         }
       }
-      // fall through.
+      LLVM_FALLTHROUGH;
     case 'j':
     case 'J':
       if (isImaginary) break;   // Cannot be repeated.
       isImaginary = true;
       continue;  // Success.
     }
     // If we reached here, there was an error or a ud-suffix.
     break;

cfe/trunk/lib/Parse/ParseCXXInlineMethods.cpp

case tok::r_brace:
         return false;  // Matches something.
       Toks.push_back(Tok);
       ConsumeBrace();
       break;
 
     case tok::semi:
       if (StopAtSemi)
         return false;
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH;
     default:
       // consume this token.
       Toks.push_back(Tok);
       ConsumeAnyToken(/*ConsumeCodeCompletionTok*/true);
       break;
     }
     isFirstTokenConsumed = false;
   }
case tok::question:
         return false;
       break;
 
     case tok::greatergreatergreater:
       if (!getLangOpts().CPlusPlus11)
         goto consume_token;
       if (AngleCount) --AngleCount;
       if (KnownTemplateCount) --KnownTemplateCount;
-      // Fall through.
+      LLVM_FALLTHROUGH;
     case tok::greatergreater:
       if (!getLangOpts().CPlusPlus11)
         goto consume_token;
       if (AngleCount) --AngleCount;
       if (KnownTemplateCount) --KnownTemplateCount;
-      // Fall through.
+      LLVM_FALLTHROUGH;
     case tok::greater:
       if (AngleCount) --AngleCount;
       if (KnownTemplateCount) --KnownTemplateCount;
       goto consume_token;
 
     case tok::kw_template:
       // 'template' identifier '<' is known to start a template argument list,
       // and can be used to disambiguate the parse.
while (1) {
     case tok::utf16_string_literal:
     case tok::utf32_string_literal:
       Toks.push_back(Tok);
       ConsumeStringToken();
       break;
     case tok::semi:
       if (CIK == CIK_DefaultInitializer)
         return true; // End of the default initializer.
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH;
     default:
     consume_token:
       Toks.push_back(Tok);
       ConsumeToken();
       break;
     }
     IsFirstToken = false;
   }
 }

cfe/trunk/lib/Parse/ParseDecl.cpp

 /// start of a specifier-qualifier-list.
 bool Parser::isTypeSpecifierQualifier() {
   switch (Tok.getKind()) {
   default: return false;
 
   case tok::identifier:   // foo::bar
     if (TryAltiVecVectorToken())
       return true;
-    // Fall through.
+    LLVM_FALLTHROUGH;
   case tok::kw_typename:  // typename T::type
     // Annotate typenames and C++ scope specifiers.  If we get one, just
     // recurse to handle whatever we get.
     if (TryAnnotateTypeOrScopeToken())
       return true;
     if (Tok.is(tok::identifier))
       return false;
     return isTypeSpecifierQualifier();
case tok::kw_pipe:
     return getLangOpts().OpenCL && (getLangOpts().OpenCLVersion >= 200);
 
   case tok::identifier:   // foo::bar
     // Unfortunate hack to support "Class.factoryMethod" notation.
     if (getLangOpts().ObjC && NextToken().is(tok::period))
       return false;
     if (TryAltiVecVectorToken())
       return true;
-    // Fall through.
+    LLVM_FALLTHROUGH;
   case tok::kw_decltype: // decltype(T())::type
   case tok::kw_typename: // typename T::type
     // Annotate typenames and C++ scope specifiers.  If we get one, just
     // recurse to handle whatever we get.
     if (TryAnnotateTypeOrScopeToken())
       return true;
     if (Tok.is(tok::identifier))
       return false;

cfe/trunk/lib/Parse/ParseDeclCXX.cpp

case tok::annot_module_include:
       continue;
 
     case tok::eof:
       break;
 
     case tok::r_brace:
       if (!NestedModules)
         break;
-      // Fall through.
+      LLVM_FALLTHROUGH;
     default:
       ParsedAttributesWithRange attrs(AttrFactory);
       MaybeParseCXX11Attributes(attrs);
       ParseExternalDeclaration(attrs);
       continue;
     }
 
     break;

cfe/trunk/lib/Parse/ParseExpr.cpp

case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
     Res = ParseCastExpression(false);
     if (!Res.isInvalid())
       Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
     return Res;
   }
   case tok::kw__Alignof:   // unary-expression: '_Alignof' '(' type-name ')'
     if (!getLangOpts().C11)
       Diag(Tok, diag::ext_c11_alignment) << Tok.getName();
-    // fallthrough
+    LLVM_FALLTHROUGH;
   case tok::kw_alignof:    // unary-expression: 'alignof' '(' type-id ')'
   case tok::kw___alignof:  // unary-expression: '__alignof' unary-expression
                            // unary-expression: '__alignof' '(' type-name ')'
   case tok::kw_sizeof:     // unary-expression: 'sizeof' unary-expression
                            // unary-expression: 'sizeof' '(' type-name ')'
   case tok::kw_vec_step:   // unary-expression: OpenCL 'vec_step' expression
   // unary-expression: '__builtin_omp_required_simd_align' '(' type-name ')'
   case tok::kw___builtin_omp_required_simd_align:
if (isStartOfObjCClassMessageMissingOpenBracket()) {
       if (Ty.isInvalid())
         break;
 
       ConsumeAnnotationToken();
       Res = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
                                            Ty.get(), nullptr);
       break;
     }
-    // Fall through
+    LLVM_FALLTHROUGH;
 
   case tok::annot_decltype:
   case tok::kw_char:
   case tok::kw_wchar_t:
   case tok::kw_char8_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_bool:
if (getLangOpts().CPlusPlus11) {
       }
       Res = ParseLambdaExpression();
       break;
     }
     if (getLangOpts().ObjC) {
       Res = ParseObjCMessageExpression();
       break;
     }
-    // FALL THROUGH.
+    LLVM_FALLTHROUGH;
   default:
     NotCastExpr = true;
     return ExprError();
   }
 
   // Check to see whether Res is a function designator only. If it is and we
   // are compiling for OpenCL, we need to return an error as this implies
   // that the address of the function is being taken, which is illegal in CL.

cfe/trunk/lib/Parse/ParseTentative.cpp

 /// (potentially) starting a decl-specifier.
 Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
   switch (Tok.getKind()) {
   case tok::kw__Atomic:
     if (NextToken().isNot(tok::l_paren)) {
       ConsumeToken();
       break;
     }
-    // Fall through.
+    LLVM_FALLTHROUGH;
   case tok::kw_typeof:
   case tok::kw___attribute:
   case tok::kw___underlying_type: {
     ConsumeToken();
     if (Tok.isNot(tok::l_paren))
       return TPResult::Error;
     ConsumeParen();
     if (!SkipUntil(tok::r_paren))
case tok::kw_enum:
     else if (Tok.is(tok::annot_template_id))
       ConsumeAnnotationToken();
     else
       return TPResult::Error;
     break;
 
   case tok::annot_cxxscope:
     ConsumeAnnotationToken();
-    // Fall through.
+    LLVM_FALLTHROUGH;
   default:
     ConsumeAnyToken();
 
     if (getLangOpts().ObjC && Tok.is(tok::less))
       return TryParseProtocolQualifiers();
     break;
   }
 
if (TryAnnotateTypeOrScopeToken())
       return TPResult::Error;
     return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
 
   case tok::coloncolon: {    // ::foo::bar
     const Token &Next = NextToken();
     if (Next.isOneOf(tok::kw_new,       // ::new
                      tok::kw_delete))   // ::delete
       return TPResult::False;
+    LLVM_FALLTHROUGH;
   }
-    // Fall through.
   case tok::kw___super:
   case tok::kw_decltype:
     // Annotate typenames and C++ scope specifiers.  If we get one, just
     // recurse to handle whatever we get.
     if (TryAnnotateTypeOrScopeToken())
       return TPResult::Error;
     return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
 

cfe/trunk/lib/Parse/Parser.cpp

case tok::r_brace:
       if (BraceCount && !isFirstTokenSkipped)
         return false;  // Matches something.
       ConsumeBrace();
       break;
 
     case tok::semi:
       if (HasFlagsSet(Flags, StopAtSemi))
         return false;
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH;
     default:
       // Skip this token.
       ConsumeAnyToken();
       break;
     }
     isFirstTokenSkipped = false;
   }
 }
Parser::TryAnnotateName(bool IsAddressOfOperand,
 
   case Sema::NC_TypeTemplate:
     if (Next.isNot(tok::less)) {
       // This may be a type template being used as a template template argument.
       if (SS.isNotEmpty())
         AnnotateScopeToken(SS, !WasScopeAnnotation);
       return ANK_TemplateName;
     }
-    // Fall through.
+    LLVM_FALLTHROUGH;
   case Sema::NC_VarTemplate:
   case Sema::NC_FunctionTemplate: {
     // We have a type, variable or function template followed by '<'.
     ConsumeToken();
     UnqualifiedId Id;
     Id.setIdentifier(Name, NameLoc);
     if (AnnotateTemplateIdToken(
             TemplateTy::make(Classification.getTemplateName()),

cfe/trunk/lib/Rewrite/HTMLRewrite.cpp

case tok::utf8_string_literal:
       // FALL THROUGH to chop the 8
       LLVM_FALLTHROUGH;
     case tok::wide_string_literal:
     case tok::utf16_string_literal:
     case tok::utf32_string_literal:
       // Chop off the L, u, U or 8 prefix
       ++TokOffs;
       --TokLen;
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH;
     case tok::string_literal:
       // FIXME: Exclude the optional ud-suffix from the highlighted range.
       HighlightRange(RB, TokOffs, TokOffs+TokLen, BufferStart,
                      "<span class='string_literal'>", "</span>");
       break;
     case tok::hash: {
       // If this is a preprocessor directive, all tokens to end of line are too.
       if (!Tok.isAtStartOfLine())

cfe/trunk/lib/Sema/SemaTemplateInstantiate.cpp

for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
        ++Active)
   {
     switch (Active->Kind) {
     case CodeSynthesisContext::TemplateInstantiation:
       // An instantiation of an alias template may or may not be a SFINAE
       // context, depending on what else is on the stack.
       if (isa<TypeAliasTemplateDecl>(Active->Entity))
         break;
-      // Fall through.
+      LLVM_FALLTHROUGH;
     case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
     case CodeSynthesisContext::ExceptionSpecInstantiation:
       // This is a template instantiation, so there is no SFINAE.
       return None;
 
     case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
     case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
     case CodeSynthesisContext::DefaultTemplateArgumentChecking:

cfe/trunk/lib/Sema/SemaTemplateVariadic.cpp

if (TypoCorrection Corrected =
             CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
                         llvm::make_unique<ParameterPackValidatorCCC>(),
                         CTK_ErrorRecovery)) {
       diagnoseTypo(Corrected,
                    PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
                    PDiag(diag::note_parameter_pack_here));
       ParameterPack = Corrected.getCorrectionDecl();
     }
+    break;
 
   case LookupResult::FoundOverloaded:
   case LookupResult::FoundUnresolvedValue:
     break;
 
   case LookupResult::Ambiguous:
     DiagnoseAmbiguousLookup(R);
     return ExprError();

cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

case Dealloc:
       break;
 
     case MayEscape:
       if (V.getKind() == RefVal::Owned) {
         V = V ^ RefVal::NotOwned;
         break;
       }
 
-      // Fall-through.
+      LLVM_FALLTHROUGH;
 
     case DoNothing:
       return state;
 
     case Autorelease:
       // Update the autorelease counts.
       V = V.autorelease();
       break;

cfe/trunk/lib/StaticAnalyzer/Core/BugReporter.cpp

static void reversePropagateIntererstingSymbols(BugReport &R,
   SVal V = State->getSVal(Ex, LCtx);
   if (!(R.isInteresting(V) || IE.count(Ex)))
     return;
 
   switch (Ex->getStmtClass()) {
     default:
       if (!isa<CastExpr>(Ex))
         break;
-      // Fall through.
+      LLVM_FALLTHROUGH;
     case Stmt::BinaryOperatorClass:
     case Stmt::UnaryOperatorClass: {
       for (const Stmt *SubStmt : Ex->children()) {
         if (const auto *child = dyn_cast_or_null<Expr>(SubStmt)) {
           IE.insert(child);
           SVal ChildV = State->getSVal(child, LCtx);
           R.markInteresting(ChildV);
         }

cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineC.cpp

case UO_AddrOf: {
         }
       }
       // Explicitly proceed with default handler for this case cascade.
       handleUOExtension(I, U, Bldr);
       break;
     }
     case UO_Plus:
       assert(!U->isGLValue());
-      // FALL-THROUGH.
+      LLVM_FALLTHROUGH;
     case UO_Deref:
     case UO_Extension: {
       handleUOExtension(I, U, Bldr);
       break;
     }
 
     case UO_LNot:
     case UO_Minus:

cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

if (const Stmt *Outer = LCtx->getStackFrame()->getCallSite()) {
           destNodes.Add(Pred);
           return;
         case CXXConstructExpr::CK_Complete:
         case CXXConstructExpr::CK_Delegating:
           break;
         }
       }
     }
-    // FALLTHROUGH
+    LLVM_FALLTHROUGH;
   case CXXConstructExpr::CK_NonVirtualBase:
     // In C++17, classes with non-virtual bases may be aggregates, so they would
     // be initialized as aggregates without a constructor call, so we may have
     // a base class constructed directly into an initializer list without
     // having the derived-class constructor call on the previous stack frame.
     // Initializer lists may be nested into more initializer lists that
     // correspond to surrounding aggregate initializations.
     // FIXME: For now this code essentially bails out. We need to find the
     // correct target region and set it.
     // FIXME: Instead of relying on the ParentMap, we should have the
     // trigger-statement (InitListExpr in this case) passed down from CFG or
     // otherwise always available during construction.
     if (dyn_cast_or_null<InitListExpr>(LCtx->getParentMap().getParent(CE))) {
       MemRegionManager &MRMgr = getSValBuilder().getRegionManager();
       Target = loc::MemRegionVal(MRMgr.getCXXTempObjectRegion(CE, LCtx));
       CallOpts.IsCtorOrDtorWithImproperlyModeledTargetRegion = true;
       break;
     }
-    // FALLTHROUGH
+    LLVM_FALLTHROUGH;
   case CXXConstructExpr::CK_Delegating: {
     const CXXMethodDecl *CurCtor = cast<CXXMethodDecl>(LCtx->getDecl());
     Loc ThisPtr = getSValBuilder().getCXXThis(CurCtor,
                                               LCtx->getStackFrame());
     SVal ThisVal = State->getSVal(ThisPtr);
 
     if (CE->getConstructionKind() == CXXConstructExpr::CK_Delegating) {
       Target = ThisVal;

cfe/trunk/lib/StaticAnalyzer/Core/RegionStore.cpp

RegionStoreManager::invalidateRegions(Store store,
   // For calls, determine which global regions should be invalidated and
   // invalidate them. (Note that function-static and immutable globals are never
   // invalidated by this.)
   // TODO: This could possibly be more precise with modules.
   switch (GlobalsFilter) {
   case GFK_All:
     B = invalidateGlobalRegion(MemRegion::GlobalInternalSpaceRegionKind,
                                Ex, Count, LCtx, B, Invalidated);
-    // FALLTHROUGH
+    LLVM_FALLTHROUGH;
   case GFK_SystemOnly:
     B = invalidateGlobalRegion(MemRegion::GlobalSystemSpaceRegionKind,
                                Ex, Count, LCtx, B, Invalidated);
-    // FALLTHROUGH
+    LLVM_FALLTHROUGH;
   case GFK_None:
     break;
   }
 
   return StoreRef(B.asStore(), *this);
 }
 
 //===----------------------------------------------------------------------===//

cfe/trunk/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp

case nonloc::ConcreteIntKind: {
       // of expression canonicalization).
       // While we're at it, catch some special cases for non-commutative ops.
       switch (op) {
       case BO_LT:
       case BO_GT:
       case BO_LE:
       case BO_GE:
         op = BinaryOperator::reverseComparisonOp(op);
-        // FALL-THROUGH
+        LLVM_FALLTHROUGH;
       case BO_EQ:
       case BO_NE:
       case BO_Add:
       case BO_Mul:
       case BO_And:
       case BO_Xor:
       case BO_Or:
         std::swap(lhs, rhs);
         continue;
       case BO_Shr:
         // (~0)>>a
         if (LHSValue.isAllOnesValue() && LHSValue.isSigned())
           return evalCastFromNonLoc(lhs, resultTy);
-        // FALL-THROUGH
+        LLVM_FALLTHROUGH;
       case BO_Shl:
         // 0<<a and 0>>a
         if (LHSValue == 0)
           return evalCastFromNonLoc(lhs, resultTy);
         return makeSymExprValNN(op, InputLHS, InputRHS, resultTy);
       default:
         return makeSymExprValNN(op, InputLHS, InputRHS, resultTy);
       }

cfe/trunk/tools/clang-func-mapping/ClangFnMapGen.cpp

if (FD->isThisDeclarationADefinition()) {
         }
 
         switch (FD->getLinkageInternal()) {
         case ExternalLinkage:
         case VisibleNoLinkage:
         case UniqueExternalLinkage:
           if (SM.isInMainFile(Body->getBeginLoc()))
             Index[LookupName] = CurrentFileName;
+          break;
         default:
           break;
         }
       }
     }
   }
 
   if (const auto *DC = dyn_cast<DeclContext>(D))

clang-tools-extra/trunk/clang-tidy/google/AvoidCStyleCastsCheck.cpp

if (DestType->isReferenceType()) {
       QualType Source = SourceType.getNonReferenceType();
       if (Source == Dest.withConst() ||
           SourceType.getNonReferenceType() == DestType.getNonReferenceType()) {
         ReplaceWithNamedCast("const_cast");
         return;
       }
       break;
     }
-  // FALLTHROUGH
+    LLVM_FALLTHROUGH;
   case clang::CK_IntegralCast:
     // Convert integral and no-op casts between builtin types and enums to
     // static_cast. A cast from enum to integer may be unnecessary, but it's
     // still retained.
     if ((SourceType->isBuiltinType() || SourceType->isEnumeralType()) &&
         (DestType->isBuiltinType() || DestType->isEnumeralType())) {
       ReplaceWithNamedCast("static_cast");
       return;

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_x86_64.cpp

public:
   /// Used by GOTPass to update GOT References
   void updateReferenceToGOT(const Reference *ref, bool targetNowGOT) override {
     assert(ref->kindNamespace() == Reference::KindNamespace::mach_o);
     assert(ref->kindArch() == Reference::KindArch::x86_64);
 
     switch (ref->kindValue()) {
     case ripRel32Got:
       assert(targetNowGOT && "target must be GOT");
+      LLVM_FALLTHROUGH;
     case ripRel32GotLoad:
       const_cast<Reference *>(ref)
         ->setKindValue(targetNowGOT ? ripRel32 : ripRel32GotLoadNowLea);
       break;
     case imageOffsetGot:
       const_cast<Reference *>(ref)->setKindValue(imageOffset);
       break;
     default:

lld/trunk/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

void MachOLinkingContext::configure(HeaderFileType type, Arch arch, OS os,
   case llvm::MachO::MH_DYLIB:
     setGlobalsAreDeadStripRoots(exportDynamicSymbols);
     break;
   case llvm::MachO::MH_BUNDLE:
     break;
   case llvm::MachO::MH_OBJECT:
     _printRemainingUndefines = false;
     _allowRemainingUndefines = true;
+    break;
   default:
     break;
   }
 
   // Set default segment page sizes based on arch.
   if (arch == arch_arm64)
     _pageSize = 4*4096;
 }

lldb/trunk/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

GetClassOrFunctionParent(const llvm::pdb::PDBSymbol &symbol) {
   case PDB_SymType::Enum:
   case PDB_SymType::FunctionSig:
   case PDB_SymType::Typedef:
   case PDB_SymType::BaseClass:
   case PDB_SymType::VTable: {
     auto class_parent_id = raw.getClassParentId();
     if (auto class_parent = session.getSymbolById(class_parent_id))
       return class_parent;
+    break;
   }
   default:
     break;
   }
 
   // Otherwise, if it is nested inside of a function, return the function.
   // Note that only certain items can be nested inside of functions.
   switch (tag) {

lldb/trunk/tools/lldb-test/lldb-test.cpp

std::string opts::breakpoint::substitute(StringRef Cmd) {
   raw_string_ostream OS(Result);
   while (!Cmd.empty()) {
     switch (Cmd[0]) {
     case '%':
       if (Cmd.consume_front("%p") && (Cmd.empty() || !isalnum(Cmd[0]))) {
         OS << sys::path::parent_path(breakpoint::CommandFile);
         break;
       }
-      // fall through
+      LLVM_FALLTHROUGH;
     default:
       size_t pos = Cmd.find('%');
       OS << Cmd.substr(0, pos);
       Cmd = Cmd.substr(pos);
       break;
     }
   }
   return std::move(OS.str());

llvm/trunk/include/llvm/Demangle/ItaniumDemangle.h

if (SoFar->getKind() == Node::KSpecialSubstitution) {
     switch (SSK) {
     case SpecialSubKind::string:
     case SpecialSubKind::istream:
     case SpecialSubKind::ostream:
     case SpecialSubKind::iostream:
       SoFar = make<ExpandedSpecialSubstitution>(SSK);
       if (!SoFar)
         return nullptr;
+      break;
     default:
       break;
     }
   }
 
   if (consumeIf('C')) {
     bool IsInherited = consumeIf('I');
     if (look() != '1' && look() != '2' && look() != '3' && look() != '5')

llvm/trunk/lib/Analysis/InlineCost.cpp

bool CallAnalyzer::visitCastInst(CastInst &I) {
   case Instruction::FPTrunc:
   case Instruction::FPExt:
   case Instruction::UIToFP:
   case Instruction::SIToFP:
   case Instruction::FPToUI:
   case Instruction::FPToSI:
     if (TTI.getFPOpCost(I.getType()) == TargetTransformInfo::TCC_Expensive)
       Cost += InlineConstants::CallPenalty;
+    break;
   default:
     break;
   }
 
   return TargetTransformInfo::TCC_Free == TTI.getUserCost(&I);
 }
 
 bool CallAnalyzer::visitUnaryInstruction(UnaryInstruction &I) {

llvm/trunk/lib/Demangle/MicrosoftDemangleNodes.cpp

 }
 
 void VariableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
   switch (SC) {
   case StorageClass::PrivateStatic:
   case StorageClass::PublicStatic:
   case StorageClass::ProtectedStatic:
     OS << "static ";
+    break;
   default:
     break;
   }
 
   if (Type) {
     Type->outputPre(OS, Flags);
     outputSpaceIfNecessary(OS);
   }

llvm/trunk/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp

AMDGPURegisterBankInfo::getInstrMapping(const MachineInstr &MI) const {
   case AMDGPU::G_SUB:
   case AMDGPU::G_MUL:
   case AMDGPU::G_AND:
   case AMDGPU::G_OR:
   case AMDGPU::G_XOR:
   case AMDGPU::G_SHL:
     if (isSALUMapping(MI))
       return getDefaultMappingSOP(MI);
-    // Fall-through
+    LLVM_FALLTHROUGH;
 
   case AMDGPU::G_FADD:
   case AMDGPU::G_FPTOSI:
   case AMDGPU::G_FPTOUI:
   case AMDGPU::G_FMUL:
     return getDefaultMappingVOP(MI);
   case AMDGPU::G_IMPLICIT_DEF: {
     unsigned Size = MRI.getType(MI.getOperand(0).getReg()).getSizeInBits();

llvm/trunk/lib/Target/AMDGPU/R600MachineScheduler.cpp

R600SchedStrategy::AluKind R600SchedStrategy::getAluKind(SUnit *SU) const {
   case R600::INTERP_VEC_LOAD:
   case R600::DOT_4:
     return AluT_XYZW;
   case R600::COPY:
     if (MI->getOperand(1).isUndef()) {
       // MI will become a KILL, don't considers it in scheduling
       return AluDiscarded;
     }
+    break;
   default:
     break;
   }
 
   // Does the instruction take a whole IG ?
   // XXX: Is it possible to add a helper function in R600InstrInfo that can
   // be used here and in R600PacketizerList::isSoloInstruction() ?
   if(TII->isVector(*MI) ||

llvm/trunk/lib/Target/AMDGPU/SIISelLowering.cpp

SDValue SITargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
   case Intrinsic::amdgcn_workgroup_id_y:
   case Intrinsic::r600_read_tgid_y:
     return getPreloadedValue(DAG, *MFI, VT,
                              AMDGPUFunctionArgInfo::WORKGROUP_ID_Y);
   case Intrinsic::amdgcn_workgroup_id_z:
   case Intrinsic::r600_read_tgid_z:
     return getPreloadedValue(DAG, *MFI, VT,
                              AMDGPUFunctionArgInfo::WORKGROUP_ID_Z);
-  case Intrinsic::amdgcn_workitem_id_x: {
+  case Intrinsic::amdgcn_workitem_id_x:
   case Intrinsic::r600_read_tidig_x:
     return loadInputValue(DAG, &AMDGPU::VGPR_32RegClass, MVT::i32,
                           SDLoc(DAG.getEntryNode()),
                           MFI->getArgInfo().WorkItemIDX);
-  }
   case Intrinsic::amdgcn_workitem_id_y:
   case Intrinsic::r600_read_tidig_y:
     return loadInputValue(DAG, &AMDGPU::VGPR_32RegClass, MVT::i32,
                           SDLoc(DAG.getEntryNode()),
                           MFI->getArgInfo().WorkItemIDY);
   case Intrinsic::amdgcn_workitem_id_z:
   case Intrinsic::r600_read_tidig_z:
     return loadInputValue(DAG, &AMDGPU::VGPR_32RegClass, MVT::i32,

llvm/trunk/lib/Target/BPF/AsmParser/BPFAsmParser.cpp

if (getLexer().getKind() == AsmToken::Identifier) {
     return MatchOperand_NoMatch;
   }
 
   switch (getLexer().getKind()) {
   case AsmToken::Minus:
   case AsmToken::Plus: {
     if (getLexer().peekTok().is(AsmToken::Integer))
       return MatchOperand_NoMatch;
+    LLVM_FALLTHROUGH;
   }
-  // Fall through.
 
   case AsmToken::Equal:
   case AsmToken::Greater:
   case AsmToken::Less:
   case AsmToken::Pipe:
   case AsmToken::Star:
   case AsmToken::LParen:
   case AsmToken::RParen:

llvm/trunk/lib/Target/Hexagon/HexagonConstExtenders.cpp

switch (Opc) {
       case Hexagon::A2_subri:         // (Rd: ## - Rs<<0)
         ED.Rd = MI.getOperand(0);
         ED.Expr.Rs = MI.getOperand(OpNum+1);
         ED.Expr.Neg = true;
         break;
       case Hexagon::S4_subaddi:       // (__: ## - Rs<<0)
         ED.Expr.Rs = MI.getOperand(OpNum+1);
         ED.Expr.Neg = true;
+        break;
       default:                        // (__: ## + __<<_)
         break;
     }
   }
 
   ED.UseMI = &MI;
 
   // Ignore unnamed globals.

llvm/trunk/lib/Target/Hexagon/HexagonConstPropagation.cpp

APInt HexagonConstEvaluator::getCmpImm(unsigned Opc, unsigned OpX,
   bool Signed = false;
   switch (Opc) {
     case Hexagon::A4_cmpbgtui:   // u7
     case Hexagon::A4_cmphgtui:   // u7
       break;
     case Hexagon::A4_cmpheqi:    // s8
     case Hexagon::C4_cmpneqi:   // s8
       Signed = true;
+      break;
     case Hexagon::A4_cmpbeqi:    // u8
       break;
     case Hexagon::C2_cmpgtui:      // u9
     case Hexagon::C4_cmplteui:  // u9
       break;
     case Hexagon::C2_cmpeqi:       // s10
     case Hexagon::C2_cmpgti:       // s10
     case Hexagon::C4_cmpltei:   // s10

llvm/trunk/lib/Target/Hexagon/HexagonISelDAGToDAG.cpp

if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Val.getOperand(0))) {
       }
     }
     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Val.getOperand(1))) {
       if ((C->getZExtValue() & Mask) == 0) {
         Src = Val.getOperand(0);
         return true;
       }
     }
+    break;
   }
   default:
     break;
   }
   return false;
 }
 
 bool HexagonDAGToDAGISel::isAlignedMemNode(const MemSDNode *N) const {

llvm/trunk/lib/Target/Hexagon/HexagonMachineScheduler.cpp

if (!SU || !SU->getInstr())
     return false;
 
   // First see if the pipeline could receive this instruction
   // in the current cycle.
   switch (SU->getInstr()->getOpcode()) {
   default:
     if (!ResourcesModel->canReserveResources(*SU->getInstr()))
       return false;
+    break;
   case TargetOpcode::EXTRACT_SUBREG:
   case TargetOpcode::INSERT_SUBREG:
   case TargetOpcode::SUBREG_TO_REG:
   case TargetOpcode::REG_SEQUENCE:
   case TargetOpcode::IMPLICIT_DEF:
   case TargetOpcode::COPY:
   case TargetOpcode::INLINEASM:
     break;

llvm/trunk/lib/Target/Hexagon/HexagonVLIWPacketizer.cpp

if (DepType == SDep::Data && J.getOpcode() == Hexagon::S2_allocframe) {
             // Since this store is to be glued with allocframe in the same
             // packet, it will use SP of the previous stack frame, i.e.
             // caller's SP. Therefore, we need to recalculate offset
             // according to this change.
             GlueAllocframeStore = useCallersSP(I);
             if (GlueAllocframeStore)
               continue;
           }
+          break;
         default:
           break;
       }
     }
 
     // There are certain anti-dependencies that cannot be ignored.
     // Specifically:
     //   J2_call ... implicit-def %r0   ; SUJ

llvm/trunk/lib/Target/Mips/AsmParser/MipsAsmParser.cpp

private:
   } Kind;
 
 public:
   MipsOperand(KindTy K, MipsAsmParser &Parser)
       : MCParsedAsmOperand(), Kind(K), AsmParser(Parser) {}
 
   ~MipsOperand() override {
     switch (Kind) {
-    case k_Immediate:
-      break;
     case k_Memory:
       delete Mem.Base;
       break;
     case k_RegList:
       delete RegList.List;
+      break;
+    case k_Immediate:
     case k_RegisterIndex:
     case k_Token:
       break;
     }
   }
 
 private:
   /// For diagnostics, and checking the assembler temporary

llvm/trunk/lib/Target/Mips/MipsAsmPrinter.cpp

case 'M': // High order register of a double word register operand
           return true;
         const MachineOperand &MO = MI->getOperand(RegOp);
         if (!MO.isReg())
           return true;
         unsigned Reg = MO.getReg();
         O << '$' << MipsInstPrinter::getRegisterName(Reg);
         return false;
       }
+      break;
     }
     case 'w':
       // Print MSA registers for the 'f' constraint
       // In LLVM, the 'w' modifier doesn't need to do anything.
       // We can just call printOperand as normal.
       break;
     }
   }

llvm/trunk/lib/Target/Mips/MipsSEISelDAGToDAG.cpp

for (auto &MI: MBB) {
         addDSPCtrlRegOperands(true, MI, MF);
         break;
       case Mips::BuildPairF64_64:
       case Mips::ExtractElementF64_64:
         if (!Subtarget->useOddSPReg()) {
           MI.addOperand(MachineOperand::CreateReg(Mips::SP, false, true));
           break;
         }
-      // fallthrough
+        LLVM_FALLTHROUGH;
       case Mips::BuildPairF64:
       case Mips::ExtractElementF64:
         if (Subtarget->isABI_FPXX() && !Subtarget->hasMTHC1())
           MI.addOperand(MachineOperand::CreateReg(Mips::SP, false, true));
         break;
       default:
         replaceUsesWithZeroReg(MRI, MI);
       }

llvm/trunk/lib/Target/PowerPC/PPCFastISel.cpp

case MVT::f64:
         }
       } else
         CmpOpc = PPC::FCMPUD;
       break;
     case MVT::i1:
     case MVT::i8:
     case MVT::i16:
       NeedsExt = true;
-      // Intentional fall-through.
+      LLVM_FALLTHROUGH;
     case MVT::i32:
       if (!UseImm)
         CmpOpc = IsZExt ? PPC::CMPLW : PPC::CMPW;
       else
         CmpOpc = IsZExt ? PPC::CMPLWI : PPC::CMPWI;
       break;
     case MVT::i64:
       if (!UseImm)

llvm/trunk/lib/Target/PowerPC/PPCISelLowering.cpp

case MVT::f128:
         }
         if (CallConv != CallingConv::Fast || needsLoad)
           ArgOffset += 16;
         break;
       } // not QPX
 
       assert(ObjectVT.getSimpleVT().SimpleTy == MVT::v4f32 &&
              "Invalid QPX parameter type");
-      /* fall through */
+      LLVM_FALLTHROUGH;
 
     case MVT::v4f64:
     case MVT::v4i1:
       // QPX vectors are treated like their scalar floating-point subregisters
       // (except that they're larger).
       unsigned Sz = ObjectVT.getSimpleVT().SimpleTy == MVT::v4f32 ? 16 : 32;
       if (QFPR_idx != Num_QFPR_Regs) {
         const TargetRegisterClass *RC;
case MVT::f128:
       if (CallConv != CallingConv::Fast)
         ArgOffset += 16;
       break;
       } // not QPX
 
       assert(Arg.getValueType().getSimpleVT().SimpleTy == MVT::v4f32 &&
              "Invalid QPX parameter type");
 
-      /* fall through */
+      LLVM_FALLTHROUGH;
     case MVT::v4f64:
     case MVT::v4i1: {
       bool IsF32 = Arg.getValueType().getSimpleVT().SimpleTy == MVT::v4f32;
       if (isVarArg) {
         assert(HasParameterArea &&
                "Parameter area must exist if we have a varargs call.");
         // We could elide this store in the case where the object fits
         // entirely in R registers.  Maybe later.

llvm/trunk/lib/Target/SystemZ/SystemZISelDAGToDAG.cpp

bool SystemZDAGToDAGISel::tryFoldLoadStoreIntoMemOperand(SDNode *Node) {
   EVT MemVT = StoreNode->getMemoryVT();
   unsigned NewOpc = 0;
   bool NegateOperand = false;
   switch (Opc) {
   default:
     return false;
   case SystemZISD::SSUBO:
     NegateOperand = true;
-    /* fall through */
+    LLVM_FALLTHROUGH;
   case SystemZISD::SADDO:
     if (MemVT == MVT::i32)
       NewOpc = SystemZ::ASI;
     else if (MemVT == MVT::i64)
       NewOpc = SystemZ::AGSI;
     else
       return false;
     break;
   case SystemZISD::USUBO:
     NegateOperand = true;
-    /* fall through */
+    LLVM_FALLTHROUGH;
   case SystemZISD::UADDO:
     if (MemVT == MVT::i32)
       NewOpc = SystemZ::ALSI;
     else if (MemVT == MVT::i64)
       NewOpc = SystemZ::ALGSI;
     else
       return false;
     break;

llvm/trunk/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

unsigned WebAssemblyFastISel::zeroExtendToI32(unsigned Reg, const Value *V,
   case MVT::i1:
     // If the value is naturally an i1, we don't need to mask it.
     // TODO: Recursively examine selects, phis, and, or, xor, constants.
     if (From == MVT::i1 && V != nullptr) {
       if (isa<CmpInst>(V) ||
           (isa<Argument>(V) && cast<Argument>(V)->hasZExtAttr()))
         return copyValue(Reg);
     }
+    break;
   case MVT::i8:
   case MVT::i16:
     break;
   case MVT::i32:
     return copyValue(Reg);
   default:
     return 0;
   }

llvm/trunk/lib/Target/X86/Disassembler/X86DisassemblerDecoder.cpp

case 0x0:
         break;
       default:
         insn->eaBase = (EABase)(eaBaseBase + rm);
         break;
       }
       break;
     case 0x1:
       insn->displacementSize = 1;
-      /* FALLTHROUGH */
+      LLVM_FALLTHROUGH;
     case 0x2:
       insn->eaDisplacement = (mod == 0x1 ? EA_DISP_8 : EA_DISP_32);
       switch (rm & 7) {
       case 0x4: // SIB byte is present
         insn->eaBase = EA_BASE_sib;
         if (readSIB(insn) || readDisplacement(insn))
           return -1;
         break;

polly/trunk/lib/Analysis/ScopBuilder.cpp

bool ScopBuilder::buildAccessCallInst(MemAccInst Inst, ScopStmt *Stmt) {
   case FMRB_OnlyAccessesInaccessibleMem:
   case FMRB_OnlyAccessesInaccessibleOrArgMem:
     return false;
   case FMRB_OnlyReadsMemory:
     GlobalReads.emplace_back(Stmt, CI);
     return true;
   case FMRB_OnlyReadsArgumentPointees:
     ReadOnly = true;
-  // Fall through
+    LLVM_FALLTHROUGH;
   case FMRB_OnlyAccessesArgumentPointees: {
     auto AccType = ReadOnly ? MemoryAccess::READ : MemoryAccess::MAY_WRITE;
     Loop *L = LI.getLoopFor(Inst->getParent());
     for (const auto &Arg : CI->arg_operands()) {
       if (!Arg->getType()->isPointerTy())
         continue;
 
       auto *ArgSCEV = SE.getSCEVAtScope(Arg, L);

 static MemoryAccess::ReductionType getReductionType(const BinaryOperator *BinOp,
                                                     const Instruction *Load) {
   if (!BinOp)
     return MemoryAccess::RT_NONE;
   switch (BinOp->getOpcode()) {
   case Instruction::FAdd:
     if (!BinOp->isFast())
       return MemoryAccess::RT_NONE;
-    // Fall through
+    LLVM_FALLTHROUGH;
   case Instruction::Add:
     return MemoryAccess::RT_ADD;
   case Instruction::Or:
     return MemoryAccess::RT_BOR;
   case Instruction::Xor:
     return MemoryAccess::RT_BXOR;
   case Instruction::And:
     return MemoryAccess::RT_BAND;
   case Instruction::FMul:
     if (!BinOp->isFast())
       return MemoryAccess::RT_NONE;
-    // Fall through
+    LLVM_FALLTHROUGH;
   case Instruction::Mul:
     if (DisableMultiplicativeReductions)
       return MemoryAccess::RT_NONE;
     return MemoryAccess::RT_MUL;
   default:
     return MemoryAccess::RT_NONE;
   }
 }

polly/trunk/lib/Analysis/ScopDetection.cpp

bool ScopDetection::isValidIntrinsicInst(IntrinsicInst &II,
   case Intrinsic::memcpy:
     AF = SE.getSCEVAtScope(cast<MemTransferInst>(II).getSource(), L);
     if (!AF->isZero()) {
       BP = dyn_cast<SCEVUnknown>(SE.getPointerBase(AF));
       // Bail if the source pointer is not valid.
       if (!isValidAccess(&II, AF, BP, Context))
         return false;
     }
-  // Fall through
+    LLVM_FALLTHROUGH;
   case Intrinsic::memset:
     AF = SE.getSCEVAtScope(cast<MemIntrinsic>(II).getDest(), L);
     if (!AF->isZero()) {
       BP = dyn_cast<SCEVUnknown>(SE.getPointerBase(AF));
       // Bail if the destination pointer is not valid.
       if (!isValidAccess(&II, AF, BP, Context))
         return false;
     }