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.

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: {

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());

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:

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);
       }

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);

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";

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;

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:

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() &&

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:

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:

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())

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;

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;

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);

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(

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;
 

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;

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;
   }
 }

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;

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;

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.

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);
 

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()),

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())

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:

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();

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;

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);
         }

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:

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;

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);
 }
 
 //===----------------------------------------------------------------------===//

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);
       }

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))