Fallthrough (#4843)

A common source of bugs. Although many of these were harmless, some were
not. By eliminating them and enabling this warning as an error, we won't
add more in the future.


Fixed a real SPIRV bug that required a test update to expect the correct behavior.
SPIRV testing was expecting incorrect results that came from a fallthrough error

cmake/modules/HandleLLVMOptions.cmake

@@ -379,7 +379,7 @@ if( MSVC )
 
 elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
   if (LLVM_ENABLE_WARNINGS)
-    append("-Wall -W -Wno-unused-parameter -Wwrite-strings" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+    append("-Wall -W -Wno-unused-parameter -Wwrite-strings -Wimplicit-fallthrough" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     append("-Wcast-qual" CMAKE_CXX_FLAGS)
 
     # Disable unknown pragma warnings because the output is just too long with them.

external/CMakeLists.txt

@@ -39,6 +39,11 @@ if (${ENABLE_SPIRV_CODEGEN})
 
   if (NOT TARGET SPIRV-Tools)
     if (IS_DIRECTORY ${DXC_SPIRV_TOOLS_DIR})
+      # Avoid implicit fallthrough warning from clang
+      # This add_compile_options() will only affect the current directory and its subdirectories.
+      if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        add_compile_options(-Wno-implicit-fallthrough)
+      endif(NOT WIN32)
       # We only need the library from SPIRV-Tools.
       set(SPIRV_SKIP_EXECUTABLES ON CACHE BOOL "Skip building SPIRV-Tools executables")
       if (NOT HLSL_ENABLE_DEBUG_ITERATORS)

include/dxc/DXIL/DxilSigPoint.inl

@@ -166,11 +166,13 @@ DXIL::SigPointKind SigPoint::GetKind(DXIL::ShaderKind shaderKind, DXIL::Signatur
   if (isSpecialInput) {
     switch (shaderKind) {
     case DXIL::ShaderKind::Hull:
-    if (sigKind == DXIL::SignatureKind::Input)
-      return isPatchConstantFunction ? DXIL::SigPointKind::PCIn : DXIL::SigPointKind::HSIn;
+      if (sigKind == DXIL::SignatureKind::Input)
+        return isPatchConstantFunction ? DXIL::SigPointKind::PCIn : DXIL::SigPointKind::HSIn;
+          break;
     case DXIL::ShaderKind::Geometry:
       if (sigKind == DXIL::SignatureKind::Input)
         return DXIL::SigPointKind::GSIn;
+      break;
     default:
       break;
     }

include/dxc/Support/WinAdapter.h

@@ -312,7 +312,6 @@
 
 #define _Printf_format_string_
 #define _Null_terminated_
-#define __fallthrough
 
 #define _Field_size_(size)
 #define _Field_size_full_(size)

include/llvm/Support/Compiler.h

@@ -220,6 +220,17 @@
 #define LLVM_ATTRIBUTE_RETURNS_NOALIAS
 #endif
 
+#if __cplusplus > 201402L
+#define LLVM_FALLTHROUGH [[fallthrough]]
+#elif defined(__clang__)
+#define LLVM_FALLTHROUGH [[clang::fallthrough]]
+#elif defined(_MSC_VER)
+#define LLVM_FALLTHROUGH __fallthrough
+#else
+#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
+#endif
+
+
 /// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
 /// pedantic diagnostics.
 #ifdef __GNUC__

lib/Analysis/BasicAliasAnalysis.cpp

@@ -216,7 +216,7 @@ static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
         if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), DL, 0, AC,
                                BOp, DT))
           break;
-        // FALL THROUGH.
+        LLVM_FALLTHROUGH; // HLSL Change
       case Instruction::Add:
         V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, Extension,
                                 DL, Depth + 1, AC, DT);

lib/Analysis/InstructionSimplify.cpp

@@ -2721,7 +2721,7 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                      Q.CxtI, Q.DT);
       if (!KnownNonNegative)
         break;
-      // fall-through
+      LLVM_FALLTHROUGH; // HLSL Change
     case ICmpInst::ICMP_EQ:
     case ICmpInst::ICMP_UGT:
     case ICmpInst::ICMP_UGE:
@@ -2732,7 +2732,7 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                      Q.CxtI, Q.DT);
       if (!KnownNonNegative)
         break;
-      // fall-through
+      LLVM_FALLTHROUGH; // HLSL Change
     case ICmpInst::ICMP_NE:
     case ICmpInst::ICMP_ULT:
     case ICmpInst::ICMP_ULE:
@@ -2752,7 +2752,7 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                      Q.CxtI, Q.DT);
       if (!KnownNonNegative)
         break;
-      // fall-through
+      LLVM_FALLTHROUGH; // HLSL Change
     case ICmpInst::ICMP_NE:
     case ICmpInst::ICMP_UGT:
     case ICmpInst::ICMP_UGE:
@@ -2763,7 +2763,7 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                      Q.CxtI, Q.DT);
       if (!KnownNonNegative)
         break;
-      // fall-through
+      LLVM_FALLTHROUGH; // HLSL Change
     case ICmpInst::ICMP_EQ:
     case ICmpInst::ICMP_ULT:
     case ICmpInst::ICMP_ULE:
@@ -2823,7 +2823,7 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
     case Instruction::LShr:
       if (ICmpInst::isSigned(Pred))
         break;
-      // fall-through
+      LLVM_FALLTHROUGH; // HLSL Change
     case Instruction::SDiv:
     case Instruction::AShr:
       if (!LBO->isExact() || !RBO->isExact())

lib/Analysis/MemoryDependenceAnalysis.cpp

@@ -641,6 +641,7 @@ MemDepResult MemoryDependenceAnalysis::getPointerDependencyFrom(
       // load query, we can safely ignore it (scan past it).
       if (isLoad)
         continue;
+      LLVM_FALLTHROUGH; // HLSL Change
     default:
       // Otherwise, there is a potential dependence.  Return a clobber.
       return MemDepResult::getClobber(Inst);
@@ -1014,6 +1015,7 @@ SortNonLocalDepInfoCache(MemoryDependenceAnalysis::NonLocalDepInfo &Cache,
       std::upper_bound(Cache.begin(), Cache.end()-1, Val);
     Cache.insert(Entry, Val);
     // FALL THROUGH.
+    LLVM_FALLTHROUGH; // HLSL Change
   }
   case 1:
     // One new entry, Just insert the new value at the appropriate position.

lib/Analysis/ScalarEvolution.cpp

@@ -4380,7 +4380,7 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
       case ICmpInst::ICMP_SLT:
       case ICmpInst::ICMP_SLE:
         std::swap(LHS, RHS);
-        // fall through
+        LLVM_FALLTHROUGH; // HLSL Change
       case ICmpInst::ICMP_SGT:
       case ICmpInst::ICMP_SGE:
         // a >s b ? a+x : b+x  ->  smax(a, b)+x
@@ -4404,7 +4404,7 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
       case ICmpInst::ICMP_ULT:
       case ICmpInst::ICMP_ULE:
         std::swap(LHS, RHS);
-        // fall through
+        LLVM_FALLTHROUGH; // HLSL Change
       case ICmpInst::ICMP_UGT:
       case ICmpInst::ICMP_UGE:
         // a >u b ? a+x : b+x  ->  umax(a, b)+x
@@ -4458,7 +4458,7 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
       default:
         break;
       }
-    }
+    } break;
 
   default: // We cannot analyze this expression.
     break;
@@ -6696,6 +6696,7 @@ ScalarEvolution::isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
     llvm_unreachable("Unexpected ICmpInst::Predicate value!");
   case ICmpInst::ICMP_SGT:
     std::swap(LHS, RHS);
+    LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_SLT: {
     ConstantRange LHSRange = getSignedRange(LHS);
     ConstantRange RHSRange = getSignedRange(RHS);
@@ -6707,6 +6708,7 @@ ScalarEvolution::isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
   }
   case ICmpInst::ICMP_SGE:
     std::swap(LHS, RHS);
+    LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_SLE: {
     ConstantRange LHSRange = getSignedRange(LHS);
     ConstantRange RHSRange = getSignedRange(RHS);
@@ -6718,6 +6720,7 @@ ScalarEvolution::isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
   }
   case ICmpInst::ICMP_UGT:
     std::swap(LHS, RHS);
+    LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_ULT: {
     ConstantRange LHSRange = getUnsignedRange(LHS);
     ConstantRange RHSRange = getUnsignedRange(RHS);
@@ -6729,6 +6732,7 @@ ScalarEvolution::isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
   }
   case ICmpInst::ICMP_UGE:
     std::swap(LHS, RHS);
+    LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_ULE: {
     ConstantRange LHSRange = getUnsignedRange(LHS);
     ConstantRange RHSRange = getUnsignedRange(RHS);
@@ -7052,6 +7056,7 @@ bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred,
           if (isImpliedCondOperands(Pred, LHS, RHS, V,
                                     getConstant(SharperMin)))
             return true;
+          LLVM_FALLTHROUGH; // HLSL Change
 
         case ICmpInst::ICMP_SGT:
         case ICmpInst::ICMP_UGT:
@@ -7066,7 +7071,7 @@ bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred,
 
           if (isImpliedCondOperands(Pred, LHS, RHS, V, getConstant(Min)))
             return true;
-
+          break;
         default:
           // No change
           break;
@@ -7163,7 +7168,7 @@ static bool IsKnownPredicateViaMinOrMax(ScalarEvolution &SE,
 
   case ICmpInst::ICMP_SGE:
     std::swap(LHS, RHS);
-    // fall through
+    LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_SLE:
     return
       // min(A, ...) <= A
@@ -7173,7 +7178,7 @@ static bool IsKnownPredicateViaMinOrMax(ScalarEvolution &SE,
 
   case ICmpInst::ICMP_UGE:
     std::swap(LHS, RHS);
-    // fall through
+    LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_ULE:
     return
       // min(A, ...) <= A
@@ -8423,6 +8428,7 @@ ScalarEvolution::computeBlockDisposition(const SCEV *S, const BasicBlock *BB) {
       return DoesNotDominateBlock;
   }
   // FALL THROUGH into SCEVNAryExpr handling.
+  LLVM_FALLTHROUGH; // HLSL Change
   case scAddExpr:
   case scMulExpr:
   case scUMaxExpr:

lib/Analysis/ValueTracking.cpp

@@ -2182,6 +2182,7 @@ bool llvm::ComputeMultiple(Value *V, unsigned Base, Value *&Multiple,
   case Instruction::SExt:
     if (!LookThroughSExt) return false;
     // otherwise fall through to ZExt
+    LLVM_FALLTHROUGH; // HLSL Change
   case Instruction::ZExt:
     return ComputeMultiple(I->getOperand(0), Base, Multiple,
                            LookThroughSExt, Depth+1);
@@ -2331,7 +2332,7 @@ bool llvm::CannotBeOrderedLessThanZero(const Value *V, unsigned Depth) {
     // x*x is always non-negative or a NaN.
     if (I->getOperand(0) == I->getOperand(1)) 
       return true;
-    // Fall through
+    LLVM_FALLTHROUGH; // HLSL Change
   case Instruction::FAdd:
   case Instruction::FDiv:
   case Instruction::FRem:

lib/Bitcode/Reader/BitcodeReader.cpp

@@ -1863,7 +1863,7 @@ std::error_code BitcodeReader::parseSelectNamedMetadata(ArrayRef<StringRef> Name
     }
     case bitc::METADATA_DISTINCT_NODE:
       IsDistinct = true;
-      // fallthrough...
+      LLVM_FALLTHROUGH; // HLSL Change
     case bitc::METADATA_NODE: {
       SmallVector<Metadata *, 8> Elts;
       Elts.reserve(Record.size());
@@ -2066,7 +2066,7 @@ std::error_code BitcodeReader::parseMetadata() {
     }
     case bitc::METADATA_DISTINCT_NODE:
       IsDistinct = true;
-      // fallthrough...
+      LLVM_FALLTHROUGH; // HLSL Change
     case bitc::METADATA_NODE: {
       SmallVector<Metadata *, 8> Elts;
       Elts.reserve(Record.size());
@@ -2987,7 +2987,7 @@ std::error_code BitcodeReader::parseUseLists() {
       break;
     case bitc::USELIST_CODE_BB:
       IsBB = true;
-      // fallthrough
+      LLVM_FALLTHROUGH; // HLSL Change
     case bitc::USELIST_CODE_DEFAULT: {
       unsigned RecordLength = Record.size();
       if (RecordLength < 3)

lib/DXIL/DxilCompType.cpp

@@ -204,22 +204,22 @@ bool CompType::Is16Bit() const {
 CompType CompType::GetBaseCompType() const {
   switch (m_Kind) {
   case Kind::I1:        return CompType(Kind::I1);
-  case Kind::I16:       __fallthrough;
-  case Kind::PackedS8x32: __fallthrough;
-  case Kind::PackedU8x32: __fallthrough;
+  case Kind::I16:       LLVM_FALLTHROUGH;
+  case Kind::PackedS8x32: LLVM_FALLTHROUGH;
+  case Kind::PackedU8x32: LLVM_FALLTHROUGH;
   case Kind::I32:       return CompType(Kind::I32);
   case Kind::I64:       return CompType(Kind::I64);
-  case Kind::U16:       __fallthrough;
+  case Kind::U16:       LLVM_FALLTHROUGH;
   case Kind::U32:       return CompType(Kind::U32);
   case Kind::U64:       return CompType(Kind::U64);
-  case Kind::SNormF16:  __fallthrough;
-  case Kind::UNormF16:  __fallthrough;
-  case Kind::F16:       __fallthrough;
-  case Kind::SNormF32:  __fallthrough;
-  case Kind::UNormF32:  __fallthrough;
+  case Kind::SNormF16:  LLVM_FALLTHROUGH;
+  case Kind::UNormF16:  LLVM_FALLTHROUGH;
+  case Kind::F16:       LLVM_FALLTHROUGH;
+  case Kind::SNormF32:  LLVM_FALLTHROUGH;
+  case Kind::UNormF32:  LLVM_FALLTHROUGH;
   case Kind::F32:       return CompType(Kind::F32);
-  case Kind::SNormF64:  __fallthrough;
-  case Kind::UNormF64:  __fallthrough;
+  case Kind::SNormF64:  LLVM_FALLTHROUGH;
+  case Kind::UNormF64:  LLVM_FALLTHROUGH;
   case Kind::F64:       return CompType(Kind::F64);
   default:
     DXASSERT(false, "invalid type kind");

lib/DXIL/DxilMetadataHelper.cpp

@@ -1348,6 +1348,7 @@ const Function *DxilMDHelper::LoadDxilFunctionProps(const MDTuple *pProps,
   case DXIL::ShaderKind::AnyHit:
   case DXIL::ShaderKind::ClosestHit:
     bRayAttributes = true;
+    LLVM_FALLTHROUGH;
   case DXIL::ShaderKind::Miss:
   case DXIL::ShaderKind::Callable:
     // payload/params unioned and first:
@@ -1711,6 +1712,7 @@ DxilMDHelper::EmitDxilFunctionProps(const hlsl::DxilFunctionProps *props,
   case DXIL::ShaderKind::AnyHit:
   case DXIL::ShaderKind::ClosestHit:
     bRayAttributes = true;
+    LLVM_FALLTHROUGH;
   case DXIL::ShaderKind::Miss:
   case DXIL::ShaderKind::Callable:
     // payload/params unioned and first:
@@ -1859,7 +1861,7 @@ Metadata *DxilMDHelper::EmitSubobject(const DxilSubobject &obj) {
   }
   case DXIL::SubobjectKind::LocalRootSignature:
     bLocalRS = true;
-    __fallthrough;
+    LLVM_FALLTHROUGH;
   case DXIL::SubobjectKind::GlobalRootSignature: {
     const char * Text;
     const void * Data;
@@ -1947,7 +1949,7 @@ void DxilMDHelper::LoadSubobject(const llvm::MDNode &MD, DxilSubobjects &Subobje
   }
   case DXIL::SubobjectKind::LocalRootSignature:
     bLocalRS = true;
-    __fallthrough;
+    LLVM_FALLTHROUGH;
   case DXIL::SubobjectKind::GlobalRootSignature: {
     const MDNode *pDataMDWrapper = dyn_cast<MDNode>(MD.getOperand(i++));
     IFTBOOL(pDataMDWrapper != nullptr, DXC_E_INCORRECT_DXIL_METADATA);

lib/DXIL/DxilOperations.cpp

@@ -458,6 +458,7 @@ unsigned OP::GetTypeSlot(Type *pType) {
     case 32:              return 7;
     case 64:              return 8;
     }
+    llvm_unreachable("Invalid Bits size");
   }
   case Type::PointerTyID: return 9;
   case Type::StructTyID:  return 10;

lib/DXIL/DxilShaderFlags.cpp

@@ -481,7 +481,7 @@ ShaderFlags ShaderFlags::CollectShaderFlags(const Function *F,
               !isa<Constant>(CI->getArgOperand(DXIL::OperandIndex::kTextureLoadOffset1OpIdx)) ||
               !isa<Constant>(CI->getArgOperand(DXIL::OperandIndex::kTextureLoadOffset2OpIdx)))
             hasAdvancedTextureOps = true;
-          __fallthrough;
+          LLVM_FALLTHROUGH;
         case DXIL::OpCode::BufferLoad: {
           if (hasMulticomponentUAVLoads) continue;
           // This is the old-style computation (overestimating requirements).
@@ -551,7 +551,7 @@ ShaderFlags ShaderFlags::CollectShaderFlags(const Function *F,
               !isa<Constant>(CI->getArgOperand(DXIL::OperandIndex::kTextureSampleOffset1OpIdx)) ||
               !isa<Constant>(CI->getArgOperand(DXIL::OperandIndex::kTextureSampleOffset2OpIdx)))
             hasAdvancedTextureOps = true;
-          __fallthrough;
+          LLVM_FALLTHROUGH;
         case DXIL::OpCode::DerivFineX:
         case DXIL::OpCode::DerivFineY:
         case DXIL::OpCode::DerivCoarseX:
@@ -579,7 +579,7 @@ ShaderFlags ShaderFlags::CollectShaderFlags(const Function *F,
         } break;
         case DXIL::OpCode::TextureStoreSample:
           hasWriteableMSAATextures = true;
-          __fallthrough;
+          LLVM_FALLTHROUGH;
         case DXIL::OpCode::SampleCmpLevel:
         case DXIL::OpCode::TextureGatherRaw:
           hasAdvancedTextureOps = true;

lib/DxilContainer/DxilContainerAssembler.cpp

@@ -102,7 +102,7 @@ static DxilProgramSigSemantic KindToSystemValue(Semantic::Kind kind, DXIL::Tesse
   case Semantic::Kind::DepthLessEqual: return DxilProgramSigSemantic::DepthLE;
   case Semantic::Kind::DepthGreaterEqual: return DxilProgramSigSemantic::DepthGE;
   case Semantic::Kind::StencilRef:
-    __fallthrough;
+    LLVM_FALLTHROUGH;
   default:
     DXASSERT(kind == Semantic::Kind::StencilRef, "else Invalid or switch is missing a case");
     return DxilProgramSigSemantic::StencilRef;
@@ -127,7 +127,7 @@ static DxilProgramSigCompType CompTypeToSigCompType(hlsl::CompType value, bool i
   case CompType::Kind::U64: return DxilProgramSigCompType::UInt64;
   case CompType::Kind::F16: return DxilProgramSigCompType::Float16;
   case CompType::Kind::F64: return DxilProgramSigCompType::Float64;
-  case CompType::Kind::Invalid: __fallthrough;
+  case CompType::Kind::Invalid: LLVM_FALLTHROUGH;
   default:
     return DxilProgramSigCompType::Unknown;
   }
@@ -139,13 +139,13 @@ static DxilProgramSigMinPrecision CompTypeToSigMinPrecision(hlsl::CompType value
   case CompType::Kind::U32: return DxilProgramSigMinPrecision::Default;
   case CompType::Kind::F32: return DxilProgramSigMinPrecision::Default;
   case CompType::Kind::I1: return DxilProgramSigMinPrecision::Default;
-  case CompType::Kind::U64: __fallthrough;
-  case CompType::Kind::I64: __fallthrough;
+  case CompType::Kind::U64: LLVM_FALLTHROUGH;
+  case CompType::Kind::I64: LLVM_FALLTHROUGH;
   case CompType::Kind::F64: return DxilProgramSigMinPrecision::Default;
   case CompType::Kind::I16: return DxilProgramSigMinPrecision::SInt16;
   case CompType::Kind::U16: return DxilProgramSigMinPrecision::UInt16;
   case CompType::Kind::F16: return DxilProgramSigMinPrecision::Float16; // Float2_8 is not supported in DXIL.
-  case CompType::Kind::Invalid: __fallthrough;
+  case CompType::Kind::Invalid: LLVM_FALLTHROUGH;
   default:
     return DxilProgramSigMinPrecision::Default;
   }
@@ -1142,7 +1142,7 @@ private:
         break;
       case DXIL::SubobjectKind::LocalRootSignature:
         bLocalRS = true;
-        __fallthrough;
+        LLVM_FALLTHROUGH;
       case DXIL::SubobjectKind::GlobalRootSignature: {
         const void *Data;
         obj.GetRootSignature(bLocalRS, Data, info.RootSignature.Data.Size);

lib/DxilContainer/RDATDxilSubobjects.cpp

@@ -34,6 +34,7 @@ bool LoadSubobjectsFromRDAT(DxilSubobjects &subobjects, const RDAT::DxilRuntimeD
         break;
       case DXIL::SubobjectKind::LocalRootSignature:
         bLocalRS = true;
+        LLVM_FALLTHROUGH;
       case DXIL::SubobjectKind::GlobalRootSignature:
         if (!reader.getRootSignature()) {
           result = false;

lib/HLSL/DxilContainerReflection.cpp

@@ -1060,6 +1060,7 @@ HRESULT CShaderReflectionType::Initialize(
       OutputDebugStringA("DxilContainerReflection.cpp: error: unknown matrix orientation\n");
 #endif
     // Note: column-major layout is the default
+    LLVM_FALLTHROUGH; // HLSL Change
     case hlsl::MatrixOrientation::Undefined:
     case hlsl::MatrixOrientation::ColumnMajor:
       m_Desc.Class = D3D_SVC_MATRIX_COLUMNS;
@@ -2682,10 +2683,10 @@ void DxilLibraryReflection::AddResourceDependencies() {
       switch (prevClass) {
       case DXIL::ResourceClass::Sampler:
         SamplersStart = i;
-        __fallthrough;
+        LLVM_FALLTHROUGH;
       case DXIL::ResourceClass::SRV:
         SRVsStart = i;
-        __fallthrough;
+        LLVM_FALLTHROUGH;
       case DXIL::ResourceClass::UAV:
         UAVsStart = i;
         break;

lib/HLSL/DxilLinker.cpp

@@ -540,10 +540,10 @@ void DxilLinkJob::AddResourceToDM(DxilModule &DM) {
       *ptr = *(static_cast<DxilSampler *>(res));
       ID = DM.AddSampler(std::move(pSampler));
       basePtr = &DM.GetSampler(ID);
-    }
+
+    } break;
     default:
-      DXASSERT(res->GetClass() == DXIL::ResourceClass::Sampler,
-               "else invalid resource");
+      DXASSERT(false, "Invalid resource class");
       break;
     }
     // Update ID.

lib/HLSL/DxilValidation.cpp

@@ -4083,7 +4083,7 @@ static void ValidateSignatureElement(DxilSignatureElement &SE,
   case DXIL::SemanticInterpretationKind::NotInSig:
   case DXIL::SemanticInterpretationKind::Invalid:
     bAllowedInSig = false;
-    __fallthrough;
+    LLVM_FALLTHROUGH;
   case DXIL::SemanticInterpretationKind::NotPacked:
   case DXIL::SemanticInterpretationKind::Shadow:
     bShouldBeAllocated = false;
@@ -4127,7 +4127,7 @@ static void ValidateSignatureElement(DxilSignatureElement &SE,
     break;
   case DXIL::SemanticKind::Coverage:
     DXASSERT(!SE.IsInput() || !bAllowedInSig, "else internal inconsistency between semantic interpretation table and validation code");
-    __fallthrough;
+    LLVM_FALLTHROUGH;
   case DXIL::SemanticKind::InnerCoverage:
   case DXIL::SemanticKind::OutputControlPointID:
     if (compKind != CompType::Kind::U32 || SE.GetCols() != 1) {
@@ -4569,6 +4569,7 @@ static void ValidateEntrySignatures(ValidationContext &ValCtx,
           Ty = Ty->getPointerElementType();
         attrSize = (unsigned)std::min(DL.getTypeAllocSize(Ty), (uint64_t)UINT_MAX);
       }
+      LLVM_FALLTHROUGH;
     case DXIL::ShaderKind::Miss:
     case DXIL::ShaderKind::Callable:
       if (itPayload != F.arg_end()) {

lib/HLSL/HLLowerUDT.cpp

@@ -316,7 +316,7 @@ void hlsl::ReplaceUsesForLoweredUDT(Value *V, Value *NewV) {
         switch (opcode) {
         case HLMatLoadStoreOpcode::ColMatLoad:
           bColMajor = true;
-          __fallthrough;
+          LLVM_FALLTHROUGH;
         case HLMatLoadStoreOpcode::RowMatLoad: {
           Value *val = UndefValue::get(
             VectorType::get(NewTy->getArrayElementType(),
@@ -354,7 +354,7 @@ void hlsl::ReplaceUsesForLoweredUDT(Value *V, Value *NewV) {
         } break;
         case HLMatLoadStoreOpcode::ColMatStore:
           bColMajor = true;
-          __fallthrough;
+          LLVM_FALLTHROUGH;
         case HLMatLoadStoreOpcode::RowMatStore: {
           // HLCast matrix value to vector
           unsigned newOpcode = (unsigned)(bColMajor ?
@@ -391,7 +391,7 @@ void hlsl::ReplaceUsesForLoweredUDT(Value *V, Value *NewV) {
           break;
         case HLSubscriptOpcode::ColMatElement:
           bColMajor = true;
-          __fallthrough;
+          LLVM_FALLTHROUGH;
         case HLSubscriptOpcode::RowMatElement: {
           ConstantDataSequential *cIdx = cast<ConstantDataSequential>(
             CI->getArgOperand(HLOperandIndex::kMatSubscriptSubOpIdx));
@@ -401,7 +401,7 @@ void hlsl::ReplaceUsesForLoweredUDT(Value *V, Value *NewV) {
         } break;
         case HLSubscriptOpcode::ColMatSubscript:
           bColMajor = true;
-          __fallthrough;
+          LLVM_FALLTHROUGH;
         case HLSubscriptOpcode::RowMatSubscript: {
           for (unsigned Idx = HLOperandIndex::kMatSubscriptSubOpIdx; Idx < CI->getNumArgOperands(); ++Idx) {
             ElemIndices.emplace_back(CI->getArgOperand(Idx));

lib/HLSL/HLOperationLower.cpp

@@ -1108,7 +1108,7 @@ Value *TranslateQuadReadAcross(CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
   switch (IOP) {
   case IntrinsicOp::IOP_QuadReadAcrossX: opKind = DXIL::QuadOpKind::ReadAcrossX; break;
   case IntrinsicOp::IOP_QuadReadAcrossY: opKind = DXIL::QuadOpKind::ReadAcrossY; break;
-  default: DXASSERT_NOMSG(IOP == IntrinsicOp::IOP_QuadReadAcrossDiagonal);
+  default: DXASSERT_NOMSG(IOP == IntrinsicOp::IOP_QuadReadAcrossDiagonal); LLVM_FALLTHROUGH;
   case IntrinsicOp::IOP_QuadReadAcrossDiagonal: opKind = DXIL::QuadOpKind::ReadAcrossDiagonal; break;
   }
   Constant *OpArg = hlslOP->GetI8Const((unsigned)opKind);
@@ -8154,8 +8154,10 @@ void TranslateHLBuiltinOperation(Function *F, HLOperationLowerHelper &helper,
           switch (opcode) {
           case HLCastOpcode::RowMatrixToColMatrix:
             bColDest = true;
+            LLVM_FALLTHROUGH;
           case HLCastOpcode::ColMatrixToRowMatrix:
             bTranspose = true;
+            LLVM_FALLTHROUGH;
           case HLCastOpcode::ColMatrixToVecCast:
           case HLCastOpcode::RowMatrixToVecCast: {
             Value *matVal = CI->getArgOperand(HLOperandIndex::kInitFirstArgOpIdx);

lib/HLSL/HLOperations.cpp

@@ -73,6 +73,7 @@ static HLOpcodeGroup GetHLOpcodeGroupInternal(StringRef group) {
       case 'r': // createhandle
         return HLOpcodeGroup::HLCreateHandle;
       }
+      llvm_unreachable("unrecognized group code");
     case 'i': // init
       return HLOpcodeGroup::HLInit;
     case 'b': // binaryOp
@@ -86,6 +87,7 @@ static HLOpcodeGroup GetHLOpcodeGroupInternal(StringRef group) {
       case 'e':
         return HLOpcodeGroup::HLSelect;
       }
+      llvm_unreachable("unrecognized group code");
     case 'm': // matldst
       return HLOpcodeGroup::HLMatLoadStore;
     case 'a': // annotatehandle

lib/IR/ConstantFold.cpp

@@ -925,7 +925,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
         // Handle undef ^ undef -> 0 special case. This is a common
         // idiom (misuse).
         return Constant::getNullValue(C1->getType());
-      // Fallthrough
+      LLVM_FALLTHROUGH; // HLSL Change
     case Instruction::Add:
     case Instruction::Sub:
       return UndefValue::get(C1->getType());
@@ -1657,7 +1657,7 @@ static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2,
           }
         }
       }
-    }
+    } break;
     default:
       break;
     }

lib/IR/Function.cpp

@@ -705,9 +705,9 @@ static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
   case IIT_EMPTYSTRUCT:
     OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
     return;
-  case IIT_STRUCT5: ++StructElts; // FALL THROUGH.
-  case IIT_STRUCT4: ++StructElts; // FALL THROUGH.
-  case IIT_STRUCT3: ++StructElts; // FALL THROUGH.
+  case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH; // HLSL Change
+  case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH; // HLSL Change
+  case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH; // HLSL Change
   case IIT_STRUCT2: {
     OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
 

lib/IR/InlineAsm.cpp

@@ -264,6 +264,7 @@ bool InlineAsm::Verify(FunctionType *Ty, StringRef ConstStr) {
       }
       ++NumIndirect;
       // FALLTHROUGH for Indirect Outputs.
+      LLVM_FALLTHROUGH; // HLSL Change
     case InlineAsm::isInput:
       if (NumClobbers) return false;               // inputs before clobbers.
       ++NumInputs;

lib/IR/Value.cpp

@@ -439,7 +439,7 @@ static Value *stripPointerCastsAndOffsets(Value *V) {
       case PSK_InBoundsConstantIndices:
         if (!GEP->hasAllConstantIndices())
           return V;
-        // fallthrough
+        LLVM_FALLTHROUGH; // HLSL Change
       case PSK_InBounds:
         if (!GEP->isInBounds())
           return V;
@@ -731,7 +731,7 @@ void ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) {
       // virtual (or inline) interface to handle this though, so instead we make
       // the TrackingVH accessors guarantee that a client never sees this value.
 
-      // FALLTHROUGH
+      LLVM_FALLTHROUGH; // HLSL CHANGE
     case Weak:
       // Weak goes to the new value, which will unlink it from Old's list.
       Entry->operator=(New);

lib/Option/OptTable.cpp

@@ -348,7 +348,7 @@ static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
   case Option::SeparateClass: case Option::JoinedOrSeparateClass:
   case Option::RemainingArgsClass:
     Name += ' ';
-    // FALLTHROUGH
+    LLVM_FALLTHROUGH; // HLSL Change
   case Option::JoinedClass: case Option::CommaJoinedClass:
   case Option::JoinedAndSeparateClass:
     if (const char *MetaVarName = Opts.getOptionMetaVar(Id))

lib/Support/APFloat.cpp

@@ -1554,11 +1554,13 @@ APFloat::divideSpecials(const APFloat &rhs)
   case PackCategoriesIntoKey(fcInfinity, fcNaN):
     category = fcNaN;
     copySignificand(rhs);
+    LLVM_FALLTHROUGH; // HLSL Change
   case PackCategoriesIntoKey(fcNaN, fcZero):
   case PackCategoriesIntoKey(fcNaN, fcNormal):
   case PackCategoriesIntoKey(fcNaN, fcInfinity):
   case PackCategoriesIntoKey(fcNaN, fcNaN):
     sign = false;
+    LLVM_FALLTHROUGH; // HLSL Change
   case PackCategoriesIntoKey(fcInfinity, fcZero):
   case PackCategoriesIntoKey(fcInfinity, fcNormal):
   case PackCategoriesIntoKey(fcZero, fcInfinity):

lib/Support/CommandLine.cpp

@@ -1037,6 +1037,7 @@ void CommandLineParser::ParseCommandLineOptions(int argc,
         case cl::Optional:
           Done = true; // Optional arguments want _at most_ one value
         // FALL THROUGH
+        LLVM_FALLTHROUGH; // HLSL Change
         case cl::ZeroOrMore: // Zero or more will take all they can get...
         case cl::OneOrMore:  // One or more will take all they can get...
           ProvidePositionalOption(PositionalOpts[i],
@@ -1091,6 +1092,7 @@ void CommandLineParser::ParseCommandLineOptions(int argc,
         ErrorParsing = true;
       }
     // Fall through
+    LLVM_FALLTHROUGH; // HLSL Change
     default:
       break;
     }
@@ -1142,6 +1144,7 @@ bool Option::addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
     if (NumOccurrences > 1)
       return error("must occur exactly one time!", ArgName);
   // Fall through
+  LLVM_FALLTHROUGH; // HLSL Change
   case OneOrMore:
   case ZeroOrMore:
   case ConsumeAfter:

lib/Support/ConvertUTF.c

@@ -53,6 +53,13 @@
 #endif
 #include <assert.h>
 
+#if !defined(_WIN32) && !defined(__clang__)
+// Disable gcc's warning for fallthrough
+// this file uses it extensively without annotation
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+#endif
+
 static const int halfShift  = 10; /* used for shifting by 10 bits */
 
 static const UTF32 halfBase = 0x0010000UL;

lib/Support/FoldingSet.cpp

@@ -128,7 +128,9 @@ void FoldingSetNodeID::AddString(StringRef String) {
   // No need to take endianness into account here - this is always executed.
   switch (Pos - Size) {
   case 1: V = (V << 8) | (unsigned char)String[Size - 3]; // Fall thru.
+    LLVM_FALLTHROUGH; // HLSL Change
   case 2: V = (V << 8) | (unsigned char)String[Size - 2]; // Fall thru.
+    LLVM_FALLTHROUGH; // HLSL Change
   case 3: V = (V << 8) | (unsigned char)String[Size - 1]; break;
   default: return; // Nothing left.
   }

lib/Support/FormattedStream.cpp

@@ -32,6 +32,7 @@ static void UpdatePosition(std::pair<unsigned, unsigned> &Position, const char *
     switch (*Ptr) {
     case '\n':
       Line += 1;
+      LLVM_FALLTHROUGH; // HLSL Change
     case '\r':
       Column = 0;
       break;

lib/Support/GraphWriter.cpp

@@ -47,6 +47,7 @@ std::string llvm::DOT::EscapeString(const std::string &Label) {
             Str.erase(Str.begin()+i); continue;
           default: break;
         }
+      LLVM_FALLTHROUGH; // HLSL Change
     case '{': case '}':
     case '<': case '>':
     case '|': case '"':

lib/Support/Path.cpp

@@ -1017,6 +1017,7 @@ file_magic identify_magic(StringRef Magic) {
     case 0xc4: // ARMNT Windows
       if (Magic[1] == 0x01)
         return file_magic::coff_object;
+      LLVM_FALLTHROUGH; // HLSL Change
 
     case 0x90: // PA-RISC Windows
     case 0x68: // mc68K Windows

lib/Support/YAMLParser.cpp

@@ -2146,6 +2146,7 @@ void MappingNode::increment() {
       break;
     default:
       setError("Unexpected token. Expected Key or Block End", T);
+      LLVM_FALLTHROUGH; // HLSL Change
     case Token::TK_Error:
       IsAtEnd = true;
       CurrentEntry = nullptr;
@@ -2158,6 +2159,7 @@ void MappingNode::increment() {
       return increment();
     case Token::TK_FlowMappingEnd:
       getNext();
+      LLVM_FALLTHROUGH; // HLSL Change
     case Token::TK_Error:
       // Set this to end iterator.
       IsAtEnd = true;
@@ -2200,6 +2202,7 @@ void SequenceNode::increment() {
     default:
       setError( "Unexpected token. Expected Block Entry or Block End."
               , T);
+      LLVM_FALLTHROUGH; // HLSL Change
     case Token::TK_Error:
       IsAtEnd = true;
       CurrentEntry = nullptr;
@@ -2228,6 +2231,7 @@ void SequenceNode::increment() {
       return increment();
     case Token::TK_FlowSequenceEnd:
       getNext();
+      LLVM_FALLTHROUGH; // HLSL Change
     case Token::TK_Error:
       // Set this to end iterator.
       IsAtEnd = true;

lib/Support/raw_ostream.cpp

@@ -372,10 +372,10 @@ void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
   // Handle short strings specially, memcpy isn't very good at very short
   // strings.
   switch (Size) {
-  case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH
-  case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH
-  case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH
-  case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH
+  case 4: OutBufCur[3] = Ptr[3]; LLVM_FALLTHROUGH; // HLSL Change
+  case 3: OutBufCur[2] = Ptr[2]; LLVM_FALLTHROUGH; // HLSL Change
+  case 2: OutBufCur[1] = Ptr[1]; LLVM_FALLTHROUGH; // HLSL Change
+  case 1: OutBufCur[0] = Ptr[0]; LLVM_FALLTHROUGH; // HLSL Change
   case 0: break;
   default:
     memcpy(OutBufCur, Ptr, Size);

lib/TableGen/TGLexer.cpp

@@ -155,7 +155,7 @@ tgtok::TokKind TGLexer::LexToken() {
         case '0': case '1': 
           if (NextChar == 'b')
             return LexNumber();
-          // Fallthrough
+          LLVM_FALLTHROUGH; // HLSL Change
         case '2': case '3': case '4': case '5':
         case '6': case '7': case '8': case '9':
         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
@@ -222,7 +222,7 @@ tgtok::TokKind TGLexer::LexString() {
     case '\0':
       if (CurPtr == CurBuf.end())
         return ReturnError(StrStart, "End of file in string literal");
-      // FALL THROUGH
+      LLVM_FALLTHROUGH; // HLSL Change
     default:
       return ReturnError(CurPtr, "invalid escape in string literal");
     }

lib/Transforms/IPO/FunctionAttrs.cpp

@@ -774,7 +774,7 @@ bool FunctionAttrs::IsFunctionMallocLike(Function *F,
           if (CS.getCalledFunction() &&
               SCCNodes.count(CS.getCalledFunction()))
             break;
-        } // fall-through
+        } LLVM_FALLTHROUGH; // HLSL Change
         default:
           return false;  // Did not come from an allocation.
       }

lib/Transforms/InstCombine/InstCombineCalls.cpp

@@ -493,7 +493,7 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
       II->setArgOperand(1, LHS);
       return II;
     }
-    // fall through
+    LLVM_FALLTHROUGH; // HLSL Change
 
   case Intrinsic::usub_with_overflow:
   case Intrinsic::ssub_with_overflow: {

lib/Transforms/InstCombine/InstCombineCompares.cpp

@@ -2159,6 +2159,7 @@ bool InstCombiner::OptimizeOverflowCheck(OverflowCheckFlavor OCF, Value *LHS,
       return SetResult(Builder->CreateAdd(LHS, RHS), Builder->getTrue(), true);
   }
   // FALL THROUGH uadd into sadd
+  LLVM_FALLTHROUGH; // HLSL Change
   case OCF_SIGNED_ADD: {
     // X + 0 -> {X, false}
     if (match(RHS, m_Zero()))
@@ -2198,7 +2199,7 @@ bool InstCombiner::OptimizeOverflowCheck(OverflowCheckFlavor OCF, Value *LHS,
                        true);
     if (OR == OverflowResult::AlwaysOverflows)
       return SetResult(Builder->CreateMul(LHS, RHS), Builder->getTrue(), true);
-  } // FALL THROUGH
+  } LLVM_FALLTHROUGH; // HLSL CHANGE
   case OCF_SIGNED_MUL:
     // X * undef -> undef
     if (isa<UndefValue>(RHS))
@@ -2704,28 +2705,28 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
 
     case ICmpInst::ICMP_UGT:
       std::swap(Op0, Op1);                   // Change icmp ugt -> icmp ult
-      // FALL THROUGH
+      LLVM_FALLTHROUGH; // HLSL CHANGE
     case ICmpInst::ICMP_ULT:{               // icmp ult i1 A, B -> ~A & B
       Value *Not = Builder->CreateNot(Op0, I.getName()+"tmp");
       return BinaryOperator::CreateAnd(Not, Op1);
     }
     case ICmpInst::ICMP_SGT:
       std::swap(Op0, Op1);                   // Change icmp sgt -> icmp slt
-      // FALL THROUGH
+      LLVM_FALLTHROUGH; // HLSL CHANGE
     case ICmpInst::ICMP_SLT: {               // icmp slt i1 A, B -> A & ~B
       Value *Not = Builder->CreateNot(Op1, I.getName()+"tmp");
       return BinaryOperator::CreateAnd(Not, Op0);
     }
     case ICmpInst::ICMP_UGE:
       std::swap(Op0, Op1);                   // Change icmp uge -> icmp ule
-      // FALL THROUGH
+      LLVM_FALLTHROUGH; // HLSL CHANGE
     case ICmpInst::ICMP_ULE: {               //  icmp ule i1 A, B -> ~A | B
       Value *Not = Builder->CreateNot(Op0, I.getName()+"tmp");
       return BinaryOperator::CreateOr(Not, Op1);
     }
     case ICmpInst::ICMP_SGE:
       std::swap(Op0, Op1);                   // Change icmp sge -> icmp sle
-      // FALL THROUGH
+      LLVM_FALLTHROUGH; // HLSL CHANGE
     case ICmpInst::ICMP_SLE: {               //  icmp sle i1 A, B -> A | ~B
       Value *Not = Builder->CreateNot(Op1, I.getName()+"tmp");
       return BinaryOperator::CreateOr(Not, Op0);
@@ -3476,7 +3477,7 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
       case Instruction::LShr:
         if (I.isSigned())
           break;
-        // fall-through
+        LLVM_FALLTHROUGH; // HLSL Change
       case Instruction::SDiv:
       case Instruction::AShr:
         if (!BO0->isExact() || !BO1->isExact())

lib/Transforms/InstCombine/InstCombineShifts.cpp

@@ -456,7 +456,7 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, Constant *Op1,
         }
       }
 
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH; // HLSL CHANGE
       case Instruction::Sub: {
         // Turn ((X >> C) + Y) << C  ->  (X + (Y << C)) & (~0 << C)
         if (isLeftShift && Op0BO->getOperand(0)->hasOneUse() &&

lib/Transforms/InstCombine/InstructionCombining.cpp

@@ -1885,7 +1885,7 @@ isAllocSiteRemovable(Instruction *AI, SmallVectorImpl<WeakVH> &Users,
             if (MI->isVolatile() || MI->getRawDest() != PI)
               return false;
           }
-          // fall through
+          LLVM_FALLTHROUGH; // HLSL Change
           case Intrinsic::dbg_declare:
           case Intrinsic::dbg_value:
           case Intrinsic::invariant_start:

lib/Transforms/Scalar/IndVarSimplify.cpp

@@ -1485,6 +1485,7 @@ static PHINode *getLoopPhiForCounter(Value *IncV, Loop *L, DominatorTree *DT) {
     // An IV counter must preserve its type.
     if (IncI->getNumOperands() == 2)
       break;
+    LLVM_FALLTHROUGH; // HLSL Change
   default:
     return nullptr;
   }

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

@@ -281,7 +281,7 @@ InductiveRangeCheck::parseRangeCheckICmp(Loop *L, ICmpInst *ICI,
 
   case ICmpInst::ICMP_SLE:
     std::swap(LHS, RHS);
-  // fallthrough
+  LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_SGE:
     if (match(RHS, m_ConstantInt<0>())) {
       Index = LHS;
@@ -291,7 +291,7 @@ InductiveRangeCheck::parseRangeCheckICmp(Loop *L, ICmpInst *ICI,
 
   case ICmpInst::ICMP_SLT:
     std::swap(LHS, RHS);
-  // fallthrough
+  LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_SGT:
     if (match(RHS, m_ConstantInt<-1>())) {
       Index = LHS;
@@ -307,7 +307,7 @@ InductiveRangeCheck::parseRangeCheckICmp(Loop *L, ICmpInst *ICI,
 
   case ICmpInst::ICMP_ULT:
     std::swap(LHS, RHS);
-  // fallthrough
+  LLVM_FALLTHROUGH; // HLSL Change
   case ICmpInst::ICMP_UGT:
     if (IsNonNegativeAndNotLoopVarying(LHS)) {
       Index = RHS;

lib/Transforms/Scalar/LoopRotation.cpp

@@ -228,6 +228,7 @@ static bool shouldSpeculateInstrs(BasicBlock::iterator Begin,
       if (!cast<GEPOperator>(I)->hasAllConstantIndices())
         return false;
       // fall-thru to increment case
+      LLVM_FALLTHROUGH; // HLSL Change
     case Instruction::Add:
     case Instruction::Sub:
     case Instruction::And:

lib/Transforms/Scalar/LoopUnswitch.cpp

@@ -747,7 +747,7 @@ static void copyMetadata(Instruction *DstInst, const Instruction *SrcInst,
           MD.second = NewMD;
         }
       }
-      // fallthrough.
+      LLVM_FALLTHROUGH; // HLSL Change
     case LLVMContext::MD_dbg:
       DstInst->setMetadata(MD.first, MD.second);
     }

lib/Transforms/Scalar/ScalarReplAggregatesHLSL.cpp

@@ -2738,7 +2738,7 @@ void SROA_Helper::RewriteCall(CallInst *CI) {
           break;
         }
       }
-      __fallthrough;
+      LLVM_FALLTHROUGH;
       default:
         // RayQuery this pointer replacement.
         if (OldVal->getType()->isPointerTy() &&

lib/Transforms/Utils/SimplifyLibCalls.cpp

@@ -141,7 +141,7 @@ static bool checkStringCopyLibFuncSignature(Function *F, LibFunc::Func Func) {
     llvm_unreachable("Can't check signature for non-string-copy libfunc.");
   case LibFunc::stpncpy_chk:
   case LibFunc::strncpy_chk:
-    --NumParams; // fallthrough
+    --NumParams; LLVM_FALLTHROUGH; // HLSL Change
   case LibFunc::stpncpy:
   case LibFunc::strncpy: {
     if (NumParams != 3 || FT->getParamType(0) != FT->getParamType(1) ||
@@ -151,7 +151,7 @@ static bool checkStringCopyLibFuncSignature(Function *F, LibFunc::Func Func) {
   }
   case LibFunc::strcpy_chk:
   case LibFunc::stpcpy_chk:
-    --NumParams; // fallthrough
+    --NumParams; LLVM_FALLTHROUGH; // HLSL Change
   case LibFunc::stpcpy:
   case LibFunc::strcpy: {
     if (NumParams != 2 || FT->getParamType(0) != FT->getParamType(1) ||
@@ -161,7 +161,7 @@ static bool checkStringCopyLibFuncSignature(Function *F, LibFunc::Func Func) {
   }
   case LibFunc::memmove_chk:
   case LibFunc::memcpy_chk:
-    --NumParams; // fallthrough
+    --NumParams; LLVM_FALLTHROUGH; // HLSL Change
   case LibFunc::memmove:
   case LibFunc::memcpy: {
     if (NumParams != 3 || !FT->getParamType(0)->isPointerTy() ||
@@ -170,7 +170,7 @@ static bool checkStringCopyLibFuncSignature(Function *F, LibFunc::Func Func) {
     break;
   }
   case LibFunc::memset_chk:
-    --NumParams; // fallthrough
+    --NumParams; LLVM_FALLTHROUGH; // HLSL Change
   case LibFunc::memset: {
     if (NumParams != 3 || !FT->getParamType(0)->isPointerTy() ||
         !FT->getParamType(1)->isIntegerTy() || FT->getParamType(2) != SizeTTy)

projects/dxilconv/lib/DxbcConverter/DxbcConverter.cpp

@@ -1655,7 +1655,7 @@ void DxbcConverter::AnalyzeShader(D3D10ShaderBinary::CShaderCodeParser &Parser)
       case D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_GREATER_EQUAL:
       case D3D11_SB_OPERAND_TYPE_OUTPUT_DEPTH_LESS_EQUAL:
         m_DepthRegType = RegType;
-        __fallthrough;
+        LLVM_FALLTHROUGH;
       case D3D11_SB_OPERAND_TYPE_OUTPUT_STENCIL_REF:
       case D3D10_SB_OPERAND_TYPE_OUTPUT_COVERAGE_MASK: {
         m_bHasStencilRef = RegType == D3D11_SB_OPERAND_TYPE_OUTPUT_STENCIL_REF;
@@ -4260,7 +4260,7 @@ void DxbcConverter::ConvertInstructions(D3D10ShaderBinary::CShaderCodeParser &Pa
         switch (Comp) {
         case 0: Out[c] = pOpRetClamped; break;
         case 1: Out[c] = pOpRetUnclamped; break;
-        case 2: __fallthrough;
+        case 2: LLVM_FALLTHROUGH;
         case 3: Out[c] = m_pOP->GetFloatConst(0.f); break;
         default: DXASSERT_DXBC(false);
         }
@@ -4282,9 +4282,9 @@ void DxbcConverter::ConvertInstructions(D3D10ShaderBinary::CShaderCodeParser &Pa
       break;
     }
 
-    case D3D10_SB_OPCODE_DERIV_RTX:         __fallthrough;
+    case D3D10_SB_OPCODE_DERIV_RTX:         LLVM_FALLTHROUGH;
     case D3D11_SB_OPCODE_DERIV_RTX_COARSE:  ConvertUnary(OP::OpCode::DerivCoarseX, CompType::getF32(), Inst); break;
-    case D3D10_SB_OPCODE_DERIV_RTY:         __fallthrough;
+    case D3D10_SB_OPCODE_DERIV_RTY:         LLVM_FALLTHROUGH;
     case D3D11_SB_OPCODE_DERIV_RTY_COARSE:  ConvertUnary(OP::OpCode::DerivCoarseY, CompType::getF32(), Inst); break;
     case D3D11_SB_OPCODE_DERIV_RTX_FINE:    ConvertUnary(OP::OpCode::DerivFineX, CompType::getF32(), Inst); break;
     case D3D11_SB_OPCODE_DERIV_RTY_FINE:    ConvertUnary(OP::OpCode::DerivFineY, CompType::getF32(), Inst); break;
@@ -5769,12 +5769,12 @@ void DxbcConverter::LoadOperand(OperandValue &SrcVal,
         SrcVal[c] = CastDxbcValue(LoadConstFloat(O.m_Valuef[Comp]), CompType::Kind::F32, CompType::Kind::F16);
         break;
 
-      case CompType::Kind::I32: __fallthrough;
+      case CompType::Kind::I32: LLVM_FALLTHROUGH;
       case CompType::Kind::U32:
         SrcVal[c] = m_pOP->GetU32Const(O.m_Value[Comp]);
         break;
 
-      case CompType::Kind::I16: __fallthrough;
+      case CompType::Kind::I16: LLVM_FALLTHROUGH;
       case CompType::Kind::U16:
         SrcVal[c] = CastDxbcValue(m_pOP->GetU32Const(O.m_Value[Comp]), CompType::Kind::U32, CompType::Kind::I16);
         break;
@@ -6806,7 +6806,7 @@ Value *DxbcConverter::CastDxbcValue(Value *pValue, const CompType &SrcType, cons
       return m_pBuilder->CreateBitCast(m_pBuilder->CreateSExt(pValue, Type::getInt16Ty(m_Ctx)), Type::getHalfTy(m_Ctx));
     case CompType::Kind::F32:
       return m_pBuilder->CreateBitCast(m_pBuilder->CreateSExt(pValue, Type::getInt32Ty(m_Ctx)), Type::getFloatTy(m_Ctx));
-    default: __fallthrough;
+    default: LLVM_FALLTHROUGH;
     }
     break;
 
@@ -6830,7 +6830,7 @@ Value *DxbcConverter::CastDxbcValue(Value *pValue, const CompType &SrcType, cons
       pValue = m_pBuilder->CreateSExt(pValue, Type::getInt32Ty(m_Ctx));
       return CreateBitCast(pValue, CompType::getI32(), CompType::getF32());
     }
-    default: __fallthrough;
+    default: LLVM_FALLTHROUGH;
     }
     break;
 
@@ -6854,7 +6854,7 @@ Value *DxbcConverter::CastDxbcValue(Value *pValue, const CompType &SrcType, cons
       pValue = m_pBuilder->CreateZExt(pValue, Type::getInt32Ty(m_Ctx));
       return CreateBitCast(pValue, CompType::getI32(), CompType::getF32());
     }
-    default: __fallthrough;
+    default: LLVM_FALLTHROUGH;
     }
     break;
 
@@ -6876,7 +6876,7 @@ Value *DxbcConverter::CastDxbcValue(Value *pValue, const CompType &SrcType, cons
     }
     case CompType::Kind::F32:
       return CreateBitCast(pValue, CompType::getI32(), CompType::getF32());
-    default: __fallthrough;
+    default: LLVM_FALLTHROUGH;
     }
     break;
 
@@ -6896,7 +6896,7 @@ Value *DxbcConverter::CastDxbcValue(Value *pValue, const CompType &SrcType, cons
     }
     case CompType::Kind::F32:
       return m_pBuilder->CreateFPExt(pValue, Type::getFloatTy(m_Ctx));
-    default: __fallthrough;
+    default: LLVM_FALLTHROUGH;
     }
     break;
 
@@ -6916,11 +6916,11 @@ Value *DxbcConverter::CastDxbcValue(Value *pValue, const CompType &SrcType, cons
       return CreateBitCast(pValue, CompType::getF32(), CompType::getI32());
     case CompType::Kind::F16:
       return m_pBuilder->CreateFPTrunc(pValue, Type::getHalfTy(m_Ctx));
-    default: __fallthrough;
+    default: LLVM_FALLTHROUGH;
     }
     break;
 
-  default: __fallthrough;
+  default: LLVM_FALLTHROUGH;
   }
 
   DXASSERT(false, "unsupported cast combination");
@@ -7083,7 +7083,7 @@ CompType DxbcConverter::InferOperandType(const D3D10ShaderBinary::CInstruction &
       }
     }
 
-    default: __fallthrough;
+    default: LLVM_FALLTHROUGH;
     }
   }
 

projects/dxilconv/lib/DxbcConverter/DxbcUtil.cpp

@@ -407,7 +407,7 @@ CompType GetCompTypeWithMinPrec(D3D_REGISTER_COMPONENT_TYPE BaseCompTy,
   case D3D_REGISTER_COMPONENT_FLOAT32:
     switch (MinPrec) {
     case D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT:   return CompType::getF32();
-    case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_16:  __fallthrough;
+    case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_16:  LLVM_FALLTHROUGH;
     case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_2_8: return CompType::getF16();
     }
     break;
@@ -436,7 +436,7 @@ CompType GetCompTypeWithMinPrec(CompType BaseCompTy,
   case CompType::Kind::F32:
     switch (MinPrec) {
     case D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT:   return CompType::getF32();
-    case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_16:  __fallthrough;
+    case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_16:  LLVM_FALLTHROUGH;
     case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_2_8: return CompType::getF16();
     }
     break;
@@ -474,7 +474,7 @@ CompType GetCompTypeFromMinPrec(D3D11_SB_OPERAND_MIN_PRECISION MinPrec,
                                 CompType DefaultPrecCompType) {
   switch (MinPrec) {
   case D3D11_SB_OPERAND_MIN_PRECISION_DEFAULT:    return GetFullPrecCompType(DefaultPrecCompType);
-  case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_16:   __fallthrough;
+  case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_16:   LLVM_FALLTHROUGH;
   case D3D11_SB_OPERAND_MIN_PRECISION_FLOAT_2_8:  return CompType::getF16();
   case D3D11_SB_OPERAND_MIN_PRECISION_SINT_16:    return CompType::getI16();
   case D3D11_SB_OPERAND_MIN_PRECISION_UINT_16:    return CompType::getU16();
@@ -821,10 +821,10 @@ DXIL::PrimitiveTopology GetPrimitiveTopology(D3D10_SB_PRIMITIVE_TOPOLOGY Topolog
   case D3D10_SB_PRIMITIVE_TOPOLOGY_LINESTRIP:           return DXIL::PrimitiveTopology::LineStrip;
   case D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLELIST:        return DXIL::PrimitiveTopology::TriangleList;
   case D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP:       return DXIL::PrimitiveTopology::TriangleStrip;
-  case D3D10_SB_PRIMITIVE_TOPOLOGY_LINELIST_ADJ:        __fallthrough;  // The ADJ versions are redundant in DXBC and are ot used, probably put there by mistake.
-  case D3D10_SB_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ:       __fallthrough;
-  case D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ:    __fallthrough;
-  case D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ:   __fallthrough;
+  case D3D10_SB_PRIMITIVE_TOPOLOGY_LINELIST_ADJ:        LLVM_FALLTHROUGH;  // The ADJ versions are redundant in DXBC and are ot used, probably put there by mistake.
+  case D3D10_SB_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ:       LLVM_FALLTHROUGH;
+  case D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ:    LLVM_FALLTHROUGH;
+  case D3D10_SB_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ:   LLVM_FALLTHROUGH;
   }
 
   IFTBOOL(false, DXC_E_INCORRECT_DXBC);

tools/clang/lib/AST/ASTContext.cpp

@@ -5799,6 +5799,7 @@ void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
       S += "{objc_class=}";
       return;
     }
+    LLVM_FALLTHROUGH; // HLSL Change
   }
   
   case Type::ObjCInterface: {

tools/clang/lib/AST/ASTContextHLSL.cpp

@@ -132,6 +132,7 @@ static HLSLScalarType FindScalarTypeByName(const char *typeName, const size_t ty
           return HLSLScalarType_int64;
         }
       }
+      break;
     case 8: // min12int, min16int, uint64_t
       if (typeName[0] == 'm' && typeName[1] == 'i') {
         if (typeName[4] == '2') {
@@ -210,6 +211,7 @@ static HLSLScalarType FindScalarTypeByName(const char *typeName, const size_t ty
           return HLSLScalarType_int32;
         }
       }
+      break;
     case 8: // uint16_t, uint32_t
       if (!langOptions.UseMinPrecision) {
         if (typeName[0] == 'u' && typeName[1] == 'i') {
@@ -225,6 +227,7 @@ static HLSLScalarType FindScalarTypeByName(const char *typeName, const size_t ty
           break;
         return HLSLScalarType_uint32;
       }
+      break;
     case 9: // float16_t, float32_t, float64_t
       if (typeName[0] == 'f' && typeName[1] == 'l') {
         if (!langOptions.UseMinPrecision) {

tools/clang/lib/AST/ASTDiagnostic.cpp

@@ -317,6 +317,7 @@ void clang::FormatASTNodeDiagnosticArgument(
       Modifier = StringRef();
       Argument = StringRef();
       // Fall through
+      LLVM_FALLTHROUGH; // HLSL Change
     }
     case DiagnosticsEngine::ak_qualtype: {
       assert(Modifier.empty() && Argument.empty() &&

tools/clang/lib/AST/ASTDumper.cpp

@@ -1394,7 +1394,7 @@ void ASTDumper::VisitTemplateDeclSpecialization(const SpecializationDecl *D,
     case TSK_ExplicitInstantiationDefinition:
       if (!DumpExplicitInst)
         break;
-      // Fall through.
+      LLVM_FALLTHROUGH; // HLSL Change
     case TSK_Undeclared:
     case TSK_ImplicitInstantiation:
       if (DumpRefOnly)

tools/clang/lib/AST/ASTImporter.cpp

@@ -612,6 +612,7 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
       return false;
     
     // Fall through to check the bits common with FunctionNoProtoType.
+    LLVM_FALLTHROUGH; // HLSL Change
   }
       
   case Type::FunctionNoProto: {

tools/clang/lib/AST/Decl.cpp

@@ -409,7 +409,7 @@ static bool hasDirectVisibilityAttribute(const NamedDecl *D,
   case LVForExplicitType:
     if (D->hasAttr<TypeVisibilityAttr>())
       return true;
-    // fallthrough
+    LLVM_FALLTHROUGH; // HLSL Change
   case LVForValue:
   case LVForExplicitValue:
     if (D->hasAttr<VisibilityAttr>())
@@ -3410,7 +3410,7 @@ SourceRange FieldDecl::getSourceRange() const {
   case ISK_InClassListInit:
     if (const Expr *E = static_cast<const Expr *>(InitStorage.getPointer()))
       return SourceRange(getInnerLocStart(), E->getLocEnd());
-    // FALLTHROUGH
+    LLVM_FALLTHROUGH; // HLSL Change
 
   case ISK_CapturedVLAType:
     return DeclaratorDecl::getSourceRange();

tools/clang/lib/AST/Expr.cpp

@@ -1517,6 +1517,7 @@ bool CastExpr::CastConsistency() const {
     assert(getSubExpr()->getType()->isPointerType());
     assert(getType()->getPointeeType().getAddressSpace() !=
            getSubExpr()->getType()->getPointeeType().getAddressSpace());
+    goto CheckNoBasePath;
   // These should not have an inheritance path.
   case CK_Dynamic:
   case CK_ToUnion:
@@ -2189,6 +2190,7 @@ bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc,
     }
 
     // Fallthrough for generic call handling.
+    LLVM_FALLTHROUGH; // HLSL Change
   }
   case CallExprClass:
   case CXXMemberCallExprClass:
@@ -3110,7 +3112,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx,
     if (DCE->getTypeAsWritten()->isReferenceType() &&
         DCE->getCastKind() == CK_Dynamic)
       return true;
-  } // Fall through.
+  } LLVM_FALLTHROUGH; // HLSL Change.
   case ImplicitCastExprClass:
   case CStyleCastExprClass:
   case CXXStaticCastExprClass:

tools/clang/lib/AST/ExprCXX.cpp

@@ -901,7 +901,7 @@ LambdaCapture::LambdaCapture(SourceLocation Loc, bool Implicit,
 
   case LCK_ByCopy:
     Bits |= Capture_ByCopy;
-    // Fall through 
+    LLVM_FALLTHROUGH; // HLSL Change
   case LCK_ByRef:
     assert(Var && "capture must have a variable!");
     break;

tools/clang/lib/AST/ExprClassification.cpp

@@ -345,7 +345,7 @@ static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
     // C-style casts will be lvalue for shortened matrices and vectors;
     // perform regular processing otherwise, which is based purely on type.
     if (Lang.HLSL && E->getValueKind() == VK_LValue) return Cl::CL_LValue;
-    __fallthrough;
+    LLVM_FALLTHROUGH;
     // HLSL Change Ends  
   case Expr::CXXFunctionalCastExprClass:
   case Expr::CXXStaticCastExprClass:

tools/clang/lib/AST/ExprConstant.cpp

@@ -641,6 +641,7 @@ namespace {
               break;
             // We've had side-effects; we want the diagnostic from them, not
             // some later problem.
+            LLVM_FALLTHROUGH; // HLSL Change
           case EM_ConstantExpression:
           case EM_PotentialConstantExpression:
           case EM_ConstantExpressionUnevaluated:
@@ -6571,6 +6572,7 @@ bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
     case EvalInfo::EM_PotentialConstantExpressionUnevaluated:
       return Success(-1ULL, E);
     }
+    llvm_unreachable("Invalid EvalMode!");
   }
 
   case Builtin::BI__builtin_bswap16:
@@ -6710,7 +6712,7 @@ bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
         << /*isConstexpr*/0 << /*isConstructor*/0 << "'strlen'";
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change.
   case Builtin::BI__builtin_strlen: {
     // As an extension, we support __builtin_strlen() as a constant expression,
     // and support folding strlen() to a constant.
@@ -9189,7 +9191,8 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
       return CheckICE(Exp->getSubExpr(), Ctx);
     }
 
-    // OffsetOf falls through here.
+    return CheckEvalInICE(E, Ctx); // HLSL Change - avoid dead-code fallthrough
+
   }
   case Expr::OffsetOfExprClass: {
     // Note that per C99, offsetof must be an ICE. And AFAIK, using
@@ -9292,6 +9295,7 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
       return Worst(LHSResult, RHSResult);
     }
     }
+    llvm_unreachable("Invalid binary operator!");
   }
   case Expr::ImplicitCastExprClass:
   case Expr::CStyleCastExprClass:

tools/clang/lib/AST/ItaniumMangle.cpp

@@ -1081,7 +1081,7 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND,
         if (!MD->isStatic())
           Arity++;
     }
-  // FALLTHROUGH
+    LLVM_FALLTHROUGH; // HLSL Change
   case DeclarationName::CXXConversionFunctionName:
   case DeclarationName::CXXLiteralOperatorName:
     mangleOperatorName(Name, Arity);
@@ -3177,6 +3177,7 @@ recurse:
     Out << "v1U" << Kind.size() << Kind;
   }
   // Fall through to mangle the cast itself.
+  LLVM_FALLTHROUGH; // HLSL Change
       
   case Expr::CStyleCastExprClass:
     mangleCastExpression(E, "cv");

tools/clang/lib/AST/NestedNameSpecifier.cpp

@@ -284,6 +284,7 @@ NestedNameSpecifier::print(raw_ostream &OS,
   case TypeSpecWithTemplate:
     OS << "template ";
     // Fall through to print the type.
+    LLVM_FALLTHROUGH; // HLSL Change
 
   case TypeSpec: {
     const Type *T = getAsType();

tools/clang/lib/AST/TypeLoc.cpp

@@ -181,7 +181,7 @@ SourceLocation TypeLoc::getBeginLoc() const {
         LeftMost = Cur;
         break;
       }
-      /* Fall through */
+      LLVM_FALLTHROUGH; // HLSL Change
     case FunctionNoProto:
     case ConstantArray:
     case DependentSizedArray:

tools/clang/lib/AST/TypePrinter.cpp

@@ -228,7 +228,7 @@ bool TypePrinter::canPrefixQualifiers(const Type *T,
     case Type::VariableArray:
     case Type::DependentSizedArray:
       NeedARCStrongQualifier = true;
-      // Fall through
+      LLVM_FALLTHROUGH; // HLSL Change
       
     case Type::Adjusted:
     case Type::Decayed:

tools/clang/lib/Analysis/PseudoConstantAnalysis.cpp

@@ -110,7 +110,7 @@ void PseudoConstantAnalysis::RunAnalysis() {
         if (LHSDecl == RHSDecl)
           // Do not visit the children
           continue;
-
+        LLVM_FALLTHROUGH; // HLSL Change
       }
       case BO_AddAssign:
       case BO_SubAssign:

tools/clang/lib/Analysis/ReachableCode.cpp

@@ -188,7 +188,7 @@ static bool isConfigurationValue(const Stmt *S,
       return isConfigurationValue(cast<DeclRefExpr>(S)->getDecl(), PP);
     case Stmt::ObjCBoolLiteralExprClass:
       IgnoreYES_NO = true;
-      // Fallthrough.
+      LLVM_FALLTHROUGH; // HLSL Change
     case Stmt::CXXBoolLiteralExprClass:
     case Stmt::IntegerLiteralClass: {
       const Expr *E = cast<Expr>(S);

tools/clang/lib/Basic/IdentifierTable.cpp

@@ -534,8 +534,10 @@ ObjCInstanceTypeFamily Selector::getInstTypeMethodFamily(Selector sel) {
     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; // HLSL Change
     default:
       break;
   }

tools/clang/lib/Basic/OpenMPKinds.cpp

@@ -159,6 +159,7 @@ const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
     return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
+    llvm_unreachable("Invalid OpenMP 'schedule' clause type");
   case OMPC_depend:
     switch (Type) {
     case OMPC_DEPEND_unknown:

tools/clang/lib/Basic/TargetInfo.cpp

@@ -132,9 +132,11 @@ const char *TargetInfo::getTypeConstantSuffix(IntType T) const {
   case UnsignedChar:
     if (getCharWidth() < getIntWidth())
       return "";
+    LLVM_FALLTHROUGH; // HLSL Change
   case UnsignedShort:
     if (getShortWidth() < getIntWidth())
       return "";
+    LLVM_FALLTHROUGH; // HLSL Change
   case UnsignedInt:      return "U";
   case UnsignedLong:     return "UL";
   case UnsignedLongLong: return "ULL";

tools/clang/lib/CodeGen/CGAtomic.cpp

@@ -573,7 +573,7 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
 
   case AtomicExpr::AO__atomic_add_fetch:
     PostOp = llvm::Instruction::Add;
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case AtomicExpr::AO__c11_atomic_fetch_add:
   case AtomicExpr::AO__atomic_fetch_add:
     Op = llvm::AtomicRMWInst::Add;
@@ -581,7 +581,7 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
 
   case AtomicExpr::AO__atomic_sub_fetch:
     PostOp = llvm::Instruction::Sub;
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case AtomicExpr::AO__c11_atomic_fetch_sub:
   case AtomicExpr::AO__atomic_fetch_sub:
     Op = llvm::AtomicRMWInst::Sub;
@@ -589,7 +589,7 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
 
   case AtomicExpr::AO__atomic_and_fetch:
     PostOp = llvm::Instruction::And;
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case AtomicExpr::AO__c11_atomic_fetch_and:
   case AtomicExpr::AO__atomic_fetch_and:
     Op = llvm::AtomicRMWInst::And;
@@ -597,7 +597,7 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
 
   case AtomicExpr::AO__atomic_or_fetch:
     PostOp = llvm::Instruction::Or;
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case AtomicExpr::AO__c11_atomic_fetch_or:
   case AtomicExpr::AO__atomic_fetch_or:
     Op = llvm::AtomicRMWInst::Or;
@@ -605,7 +605,7 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
 
   case AtomicExpr::AO__atomic_xor_fetch:
     PostOp = llvm::Instruction::Xor;
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case AtomicExpr::AO__c11_atomic_fetch_xor:
   case AtomicExpr::AO__atomic_fetch_xor:
     Op = llvm::AtomicRMWInst::Xor;
@@ -613,7 +613,7 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
 
   case AtomicExpr::AO__atomic_nand_fetch:
     PostOp = llvm::Instruction::And;
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case AtomicExpr::AO__atomic_fetch_nand:
     Op = llvm::AtomicRMWInst::Nand;
     break;
@@ -748,7 +748,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
       EmitStoreOfScalar(Val1Scalar, MakeAddrLValue(Val1, Val1Ty));
       break;
     }
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case AtomicExpr::AO__atomic_fetch_add:
   case AtomicExpr::AO__atomic_fetch_sub:
   case AtomicExpr::AO__atomic_add_fetch:

tools/clang/lib/CodeGen/CGCall.cpp

@@ -1590,7 +1590,7 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
       RetAttrs.addAttribute(llvm::Attribute::SExt);
     else if (RetTy->hasUnsignedIntegerRepresentation())
       RetAttrs.addAttribute(llvm::Attribute::ZExt);
-    // FALL THROUGH
+    LLVM_FALLTHROUGH; // HLSL Change
   case ABIArgInfo::Direct:
     if (RetAI.getInReg())
       RetAttrs.addAttribute(llvm::Attribute::InReg);
@@ -1672,7 +1672,7 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
         else
           Attrs.addAttribute(llvm::Attribute::ZExt);
       }
-      // FALL THROUGH
+      LLVM_FALLTHROUGH; // HLSL Change
     case ABIArgInfo::Direct:
       if (ArgNo == 0 && FI.isChainCall())
         Attrs.addAttribute(llvm::Attribute::Nest);

tools/clang/lib/CodeGen/CGClass.cpp

@@ -1461,7 +1461,7 @@ void CodeGenFunction::EmitDestructorBody(FunctionArgList &Args) {
     }
 #endif // HLSL Change - no support for exception handling
     // Fallthrough: act like we're in the base variant.
-
+    LLVM_FALLTHROUGH;
   case Dtor_Base:
     assert(Body);
 

tools/clang/lib/CodeGen/CGExprAgg.cpp

@@ -697,7 +697,7 @@ void AggExprEmitter::VisitCastExpr(CastExpr *E) {
       return Visit(E->getSubExpr());
     }
 
-    // fallthrough
+    LLVM_FALLTHROUGH; // HLSL Change
 
   case CK_NoOp:
   case CK_UserDefinedConversion:

tools/clang/lib/CodeGen/CGExprCXX.cpp

@@ -614,7 +614,7 @@ CodeGenFunction::EmitCXXConstructExpr(const CXXConstructExpr *E,
 
      case CXXConstructExpr::CK_VirtualBase:
       ForVirtualBase = true;
-      // fall-through
+      LLVM_FALLTHROUGH; // HLSL Change
 
      case CXXConstructExpr::CK_NonVirtualBase:
       Type = Ctor_Base;

tools/clang/lib/CodeGen/CGExprConstant.cpp

@@ -874,6 +874,7 @@ public:
           return llvm::Constant::getNullValue(destType);
         }
       }
+      return nullptr;
     }
 
     case CK_FlatConversion:
@@ -918,6 +919,8 @@ public:
         llvm::Constant *destVal = llvm::Constant::getNullValue(destType);
         return destVal;
       }
+      llvm_unreachable("Invalid cast target");
+      return nullptr;
     }
     case CK_HLSLMatrixTruncationCast: {
       if (llvm::ConstantStruct *CS = dyn_cast<llvm::ConstantStruct>(C)) {
@@ -942,6 +945,8 @@ public:
         llvm::Constant *destVal = llvm::Constant::getNullValue(destType);
         return destVal;
       }
+      llvm_unreachable("Invalid cast target");
+      return nullptr;
     }
     // HLSL Change Ends.
     }

tools/clang/lib/CodeGen/CGExprScalar.cpp

@@ -504,7 +504,7 @@ public:
       case LangOptions::SOB_Undefined:
         if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
           return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
-        // Fall through.
+        LLVM_FALLTHROUGH; // HLSL Change
       case LangOptions::SOB_Trapping:
         return EmitOverflowCheckedBinOp(Ops);
       }
@@ -1783,7 +1783,7 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     } else if (E->getType()->isScalarType()) {
       return Builder.CreateExtractElement(val, (uint64_t)0);
     }
-  }
+  } break;
   case CK_HLSLCC_FloatingToIntegral:
   case CK_HLSLCC_FloatingCast: {
     return EmitScalarConversion(Visit(E), E->getType(), DestTy);
@@ -1899,7 +1899,7 @@ llvm::Value *ScalarExprEmitter::EmitIncDecConsiderOverflowBehavior(
   case LangOptions::SOB_Undefined:
     if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
       return Builder.CreateNSWAdd(InVal, Amount, Name);
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case LangOptions::SOB_Trapping:
     return EmitOverflowCheckedBinOp(createBinOpInfoFromIncDec(E, InVal, IsInc));
   }
@@ -2908,7 +2908,7 @@ Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &op) {
     case LangOptions::SOB_Undefined:
       if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
         return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
-      // Fall through.
+      LLVM_FALLTHROUGH; // HLSL Change
     case LangOptions::SOB_Trapping:
       return EmitOverflowCheckedBinOp(op);
     }
@@ -2939,7 +2939,7 @@ Value *ScalarExprEmitter::EmitSub(const BinOpInfo &op) {
       case LangOptions::SOB_Undefined:
         if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
           return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
-        // Fall through.
+        LLVM_FALLTHROUGH; // HLSL Change
       case LangOptions::SOB_Trapping:
         return EmitOverflowCheckedBinOp(op);
       }

tools/clang/lib/CodeGen/CGHLSLMS.cpp

@@ -2183,6 +2183,7 @@ void CGMSHLSLRuntime::AddHLSLFunctionInfo(Function *F, const FunctionDecl *FD) {
             << (funcProps->shaderKind == DXIL::ShaderKind::RayGeneration ?
                 "raygeneration" : "intersection");
         rayShaderHaveErrors = true;
+        break;
       case DXIL::ShaderKind::AnyHit:
       case DXIL::ShaderKind::ClosestHit:
         if (0 == ArgNo && dxilInputQ != DxilParamInputQual::Inout) {
@@ -2299,8 +2300,10 @@ void CGMSHLSLRuntime::AddHLSLFunctionInfo(Function *F, const FunctionDecl *FD) {
     case DXIL::ShaderKind::AnyHit:
     case DXIL::ShaderKind::ClosestHit:
       bNeedsAttributes = true;
+      LLVM_FALLTHROUGH;
     case DXIL::ShaderKind::Miss:
       bNeedsPayload = true;
+      LLVM_FALLTHROUGH;
     case DXIL::ShaderKind::Callable:
       if (0 == funcProps->ShaderProps.Ray.payloadSizeInBytes) {
         unsigned DiagID = bNeedsPayload ?
@@ -3048,7 +3051,7 @@ void CGMSHLSLRuntime::CreateSubobject(DXIL::SubobjectKind kind, const StringRef
     }
     case DXIL::SubobjectKind::LocalRootSignature:
       flags = DxilRootSignatureCompilationFlags::LocalRootSignature;
-      __fallthrough;
+      LLVM_FALLTHROUGH;
     case DXIL::SubobjectKind::GlobalRootSignature: {
       DXASSERT_NOMSG(argCount == 1);
       StringRef signature;

tools/clang/lib/CodeGen/CGStmt.cpp

@@ -708,7 +708,7 @@ void CodeGenFunction::EmitCondBrHints(llvm::LLVMContext &Context,
       }
       // Vectorization/interleaving is disabled, set width/count to 1.
       ValueInt = 1;
-      // Fallthrough.
+      LLVM_FALLTHROUGH; // HLSL Change
     case LoopHintAttr::VectorizeWidth:
     case LoopHintAttr::InterleaveCount:
     case LoopHintAttr::UnrollCount:

tools/clang/lib/CodeGen/CodeGenModule.cpp

@@ -3390,6 +3390,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
     // Skip variable templates
     if (cast<VarDecl>(D)->getDescribedVarTemplate())
       return;
+    LLVM_FALLTHROUGH; // HLSL Change
   case Decl::VarTemplateSpecialization:
     EmitGlobal(cast<VarDecl>(D));
     // HLSL Change Start - add resource or subobject for global variables

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

@@ -2603,7 +2603,7 @@ void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) {
     }
 
     assert(isa<ObjCInterfaceType>(Ty));
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
 
   case Type::ObjCInterface:
     if (cast<ObjCInterfaceType>(Ty)->getDecl()->getSuperClass()) {
@@ -3480,7 +3480,7 @@ static void InitCatchParam(CodeGenFunction &CGF,
       switch (CatchType.getQualifiers().getObjCLifetime()) {
       case Qualifiers::OCL_Strong:
         CastExn = CGF.EmitARCRetainNonBlock(CastExn);
-        // fallthrough
+        LLVM_FALLTHROUGH; // HLSL Change
 
       case Qualifiers::OCL_None:
       case Qualifiers::OCL_ExplicitNone:

tools/clang/lib/Frontend/CompilerInvocation.cpp

@@ -863,7 +863,7 @@ static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
       Opts.ProgramAction = frontend::EmitObj; break;
     case OPT_fixit_EQ:
       Opts.FixItSuffix = A->getValue();
-      // fall-through!
+      LLVM_FALLTHROUGH; // HLSL Change
     case OPT_fixit:
       Opts.ProgramAction = frontend::FixIt; break;
     case OPT_emit_module:

tools/clang/lib/Frontend/Rewrite/InclusionRewriter.cpp

@@ -556,7 +556,7 @@ bool InclusionRewriter::Process(FileID FileId,
                               LocalEOL, Line, /*EnsureNewline=*/ true);
             WriteLineInfo(FileName, Line, FileType);
             RawLex.SetKeepWhitespaceMode(false);
-          }
+          } break;
           default:
             break;
         }

tools/clang/lib/Frontend/SerializedDiagnosticReader.cpp

@@ -126,6 +126,7 @@ SerializedDiagnosticReader::readMetaBlock(llvm::BitstreamCursor &Stream) {
     case Cursor::BlockBegin:
       if (Stream.SkipBlock())
         return SDError::MalformedMetadataBlock;
+      LLVM_FALLTHROUGH; // HLSL Change
     case Cursor::BlockEnd:
       if (!VersionChecked)
         return SDError::MissingVersion;

tools/clang/lib/Index/CommentToXML.cpp

@@ -732,6 +732,7 @@ void CommentASTToXMLConverter::visitBlockCommandComment(
   case CommandTraits::KCI_version:
   case CommandTraits::KCI_warning:
     ParagraphKind = C->getCommandName(Traits);
+    break;
   default:
     break;
   }

tools/clang/lib/Index/USRGeneration.cpp

@@ -796,7 +796,7 @@ void USRGenerator::VisitTemplateArgument(const TemplateArgument &Arg) {
 
   case TemplateArgument::TemplateExpansion:
     Out << 'P'; // pack expansion of...
-    // Fall through
+    LLVM_FALLTHROUGH; // HLSL Change
   case TemplateArgument::Template:
     VisitTemplateName(Arg.getAsTemplateOrTemplatePattern());
     break;

tools/clang/lib/Lex/Lexer.cpp

@@ -2467,7 +2467,7 @@ void Lexer::ReadToEndOfLine(SmallVectorImpl<char> *Result) {
           Result->push_back(Char);
         break;
       }
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH; // HLSL Change
     case '\r':
     case '\n':
       // Okay, we found the end of the line. First, back up past the \0, \r, \n.
@@ -3179,6 +3179,7 @@ LexNextToken:
       return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
                              tok::wide_char_constant);
     // FALL THROUGH, treating L like the start of an identifier.
+    LLVM_FALLTHROUGH; // HLSL Change
 
   // C99 6.4.2: Identifiers.
   case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':

tools/clang/lib/Lex/LiteralSupport.cpp

@@ -444,8 +444,11 @@ static void EncodeUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf,
   ResultBuf += bytesToWrite;
   switch (bytesToWrite) { // note: everything falls through.
   case 4: *--ResultBuf = (UTF8)((UcnVal | byteMark) & byteMask); UcnVal >>= 6;
+    LLVM_FALLTHROUGH; // HLSL Change
   case 3: *--ResultBuf = (UTF8)((UcnVal | byteMark) & byteMask); UcnVal >>= 6;
+    LLVM_FALLTHROUGH; // HLSL Change
   case 2: *--ResultBuf = (UTF8)((UcnVal | byteMark) & byteMask); UcnVal >>= 6;
+    LLVM_FALLTHROUGH; // HLSL Change
   case 1: *--ResultBuf = (UTF8) (UcnVal | firstByteMark[bytesToWrite]);
   }
   // Update the buffer.
@@ -679,7 +682,7 @@ NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
       // "i", "if", and "il" are user-defined suffixes in C++1y.
       if (*s == 'i' && PP.getLangOpts().CPlusPlus14)
         break;
-      // fall through.
+      LLVM_FALLTHROUGH; // HLSL Change
     case 'j':
     case 'J':
       if (isImaginary) break;   // Cannot be repeated.

tools/clang/lib/Parse/ParseCXXInlineMethods.cpp

@@ -761,7 +761,7 @@ bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
     case tok::semi:
       if (StopAtSemi)
         return false;
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH; // HLSL CHANGE.
     default:
       // consume this token.
       Toks.push_back(Tok);
@@ -1109,17 +1109,19 @@ bool Parser::ConsumeAndStoreInitializer(CachedTokens &Toks,
       break;
 
     case tok::greatergreatergreater:
-      if (!getLangOpts().CPlusPlus11)
-        goto consume_token;
-      if (AngleCount) --AngleCount;
-      if (KnownTemplateCount) --KnownTemplateCount;
-      // Fall through.
+      // HLSL Change - refactor to satisfy GCC and clang fallthrough detects
+      if (getLangOpts().CPlusPlus11) {
+        if (AngleCount) AngleCount -= 3;
+        if (KnownTemplateCount){ KnownTemplateCount -= 3;}
+      }
+      goto consume_token;
     case tok::greatergreater:
-      if (!getLangOpts().CPlusPlus11)
-        goto consume_token;
-      if (AngleCount) --AngleCount;
-      if (KnownTemplateCount) --KnownTemplateCount;
-      // Fall through.
+      if (getLangOpts().CPlusPlus11) {
+        if (AngleCount) AngleCount-= 2;
+        if (KnownTemplateCount){ KnownTemplateCount -= 2;}
+      }
+      goto consume_token;
+      // End HLSL Change
     case tok::greater:
       if (AngleCount) --AngleCount;
       if (KnownTemplateCount) --KnownTemplateCount;
@@ -1224,7 +1226,7 @@ bool Parser::ConsumeAndStoreInitializer(CachedTokens &Toks,
     case tok::semi:
       if (CIK == CIK_DefaultInitializer)
         return true; // End of the default initializer.
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH; // HLSL CHANGE.
     default:
     consume_token:
       Toks.push_back(Tok);

tools/clang/lib/Parse/ParseDecl.cpp

@@ -3020,7 +3020,7 @@ bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
           Tok.setIdentifierInfo(II);
         }
       }
-      // Fall through.
+      LLVM_FALLTHROUGH; // HLSL Change
     }
     case tok::comma:
     case tok::equal:
@@ -4221,6 +4221,8 @@ HLSLReservedKeyword:
         isInvalid = true;
         break;
       };
+      ParseOpenCLQualifiers(DS.getAttributes()); // HLSL Change -
+      break; // avoid dead-code fallthrough
     case tok::kw___private:
     case tok::kw___global:
     case tok::kw___local:
@@ -5139,7 +5141,7 @@ bool Parser::isTypeSpecifierQualifier() {
   case tok::identifier:   // foo::bar
     if (TryAltiVecVectorToken())
       return true;
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change.
   case tok::kw_typename:  // typename T::type
     // Annotate typenames and C++ scope specifiers.  If we get one, just
     // recurse to handle whatever we get.
@@ -5268,7 +5270,7 @@ bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
       return false;
     if (TryAltiVecVectorToken())
       return true;
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change.
   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
@@ -5628,6 +5630,7 @@ void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, unsigned AttrReqs,
           continue; // do *not* consume the next token!
         }
         // otherwise, FALL THROUGH!
+        LLVM_FALLTHROUGH; // HLSL Change
       default:
         // If this is not a type-qualifier token, we're done reading type
         // qualifiers.  First verify that DeclSpec's are consistent.
@@ -5687,6 +5690,7 @@ void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, unsigned AttrReqs,
         if (TryKeywordIdentFallback(false))
           continue;
       }
+    LLVM_FALLTHROUGH; // HLSL Change
     case tok::kw___sptr:
     case tok::kw___w64:
     case tok::kw___ptr64:
@@ -5736,6 +5740,7 @@ void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, unsigned AttrReqs,
         continue; // do *not* consume the next token!
       }
       // otherwise, FALL THROUGH!
+      LLVM_FALLTHROUGH; // HLSL Change
     default:
       DoneWithTypeQuals:
       // If this is not a type-qualifier token, we're done reading type

tools/clang/lib/Parse/ParseDeclCXX.cpp

@@ -361,7 +361,7 @@ Decl *Parser::ParseLinkage(ParsingDeclSpec &DS, unsigned Context) {
     case tok::r_brace:
       if (!NestedModules)
         break;
-      // Fall through.
+      LLVM_FALLTHROUGH; // HLSL Change.
     default:
       ParsedAttributesWithRange attrs(AttrFactory);
       MaybeParseCXX11Attributes(attrs);
@@ -4000,6 +4000,7 @@ void Parser::ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType,
     Diag(Result.KeywordLoc, diag::warn_microsoft_dependent_exists)
       << Result.IsIfExists;
     // Fall through to skip.
+    LLVM_FALLTHROUGH; // HLSL Change
       
   case IEB_Skip:
     Braces.skipToEnd();

tools/clang/lib/Parse/ParseExpr.cpp

@@ -804,7 +804,7 @@ HLSLReservedKeyword:
     // Similarly 'indices', 'vertices', 'primitives' and 'payload' are keywords when used
     // as a type qualifer in mesh shader, but may still be used as a variable name.
     Tok.setKind(tok::identifier);
-    __fallthrough;
+    LLVM_FALLTHROUGH;
     // HLSL Change Ends
   case tok::identifier: {      // primary-expression: identifier
                                // unqualified-id: identifier
@@ -1134,7 +1134,7 @@ HLSLReservedKeyword:
   case tok::kw__Alignof:   // unary-expression: '_Alignof' '(' type-name ')'
     if (!getLangOpts().C11)
       Diag(Tok, diag::ext_c11_alignment) << Tok.getName();
-    // fallthrough
+    LLVM_FALLTHROUGH; // HLSL Change
   case tok::kw_alignof:    // unary-expression: 'alignof' '(' type-id ')'
   case tok::kw___alignof:  // unary-expression: '__alignof' unary-expression
                            // unary-expression: '__alignof' '(' type-name ')'
@@ -1218,7 +1218,7 @@ HLSLReservedKeyword:
                                            Ty.get(), nullptr);
       break;
     }
-    // Fall through
+    LLVM_FALLTHROUGH; // HLSL Change
 
   case tok::annot_decltype:
   case tok::kw_char:
@@ -1338,6 +1338,7 @@ HLSLReservedKeyword:
     }
 
     // Fall through to treat the template-id as an id-expression.
+    LLVM_FALLTHROUGH; // HLSL Change
   }
 
   case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id
@@ -1459,9 +1460,9 @@ HLSLReservedKeyword:
       Res = ParseObjCMessageExpression();
       break;
     }
-    // FALL THROUGH.
-  tok_default_case: // HLSL Change - add to target cases dead-code'd by HLSL
+    LLVM_FALLTHROUGH; // HLSL Change
   default:
+  tok_default_case: // HLSL Change - add to target cases dead-code'd by HLSL
     NotCastExpr = true;
     return ExprError();
   }
@@ -1517,6 +1518,7 @@ Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
       }
         
       // Fall through; this isn't a message send.
+      LLVM_FALLTHROUGH; // HLSL Change
                 
     default:  // Not a postfix-expression suffix.
       return LHS;

tools/clang/lib/Parse/ParseInit.cpp

@@ -515,6 +515,7 @@ bool Parser::ParseMicrosoftIfExistsBraceInitializer(ExprVector &InitExprs,
     Diag(Result.KeywordLoc, diag::warn_microsoft_dependent_exists)
       << Result.IsIfExists;
     // Fall through to skip.
+    LLVM_FALLTHROUGH; // HLSL Change
       
   case IEB_Skip:
     Braces.skipToEnd();

tools/clang/lib/Parse/ParseOpenMP.cpp

@@ -193,6 +193,7 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) {
       // pseudo-clause OMPFlushClause.
       PP.EnterToken(Tok);
     }
+    LLVM_FALLTHROUGH; // HLSL Change
   case OMPD_taskyield:
   case OMPD_barrier:
   case OMPD_taskwait:
@@ -204,6 +205,7 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) {
     }
     HasAssociatedStatement = false;
     // Fall through for further analysis.
+    LLVM_FALLTHROUGH; // HLSL Change
   case OMPD_parallel:
   case OMPD_simd:
   case OMPD_for:

tools/clang/lib/Parse/ParseStmt.cpp

@@ -191,7 +191,7 @@ Retry:
     // E.g., center = <RHS>.
     if (tok::isPunctuator(NextToken().getKind())) {
       Tok.setKind(tok::identifier);
-      __fallthrough;
+      LLVM_FALLTHROUGH;
     } else {
       goto tok_default_case;
     }
@@ -235,9 +235,9 @@ Retry:
 
     // Fall through
   }
-
-  tok_default_case: // HLSL Change - add to target cases dead-code'd by HLSL
+  LLVM_FALLTHROUGH; // HLSL Change
   default: {
+  tok_default_case: // HLSL Change - add to target cases dead-code'd by HLSL
     if ((getLangOpts().CPlusPlus || !OnlyStatement) && isDeclarationStatement()) {
       SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
       DeclGroupPtrTy Decl = ParseDeclaration(Declarator::BlockContext,

tools/clang/lib/Parse/ParseTentative.cpp

@@ -151,7 +151,7 @@ Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
       ConsumeToken();
       break;
     }
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case tok::kw_typeof:
   case tok::kw___attribute:
   case tok::kw___underlying_type: {
@@ -208,7 +208,7 @@ Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
 
   case tok::annot_cxxscope:
     ConsumeToken();
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   default:
     ConsumeToken();
 
@@ -1203,7 +1203,7 @@ Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
                      tok::kw_delete))   // ::delete
       return TPResult::False;
   }
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case tok::kw___super:
   case tok::kw_decltype:
     // Annotate typenames and C++ scope specifiers.  If we get one, just
@@ -1430,6 +1430,7 @@ Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
     //
 
     // simple-type-specifier:
+    LLVM_FALLTHROUGH; // HLSL Change
 
   case tok::annot_typename:
   case_typename:
@@ -1456,6 +1457,7 @@ Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
       
       return TPResult::True;
     }
+    LLVM_FALLTHROUGH; // HLSL Change
       
   case tok::kw_char:
   case tok::kw_wchar_t:

tools/clang/lib/Parse/Parser.cpp

@@ -354,7 +354,7 @@ bool Parser::SkipUntil(ArrayRef<tok::TokenKind> Toks, SkipUntilFlags Flags) {
     case tok::semi:
       if (HasFlagsSet(Flags, StopAtSemi))
         return false;
-      // FALL THROUGH.
+      LLVM_FALLTHROUGH; // HLSL Change
     default:
       // Skip this token.
       ConsumeToken();
@@ -1505,7 +1505,7 @@ Parser::TryAnnotateName(bool IsAddressOfOperand,
         AnnotateScopeToken(SS, !WasScopeAnnotation);
       return ANK_TemplateName;
     }
-    // Fall through.
+    LLVM_FALLTHROUGH; // HLSL Change
   case Sema::NC_VarTemplate:
   case Sema::NC_FunctionTemplate: {
     // We have a type, variable or function template followed by '<'.
@@ -1831,6 +1831,7 @@ bool Parser::isTokenEqualOrEqualTypo() {
     Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal)
         << Kind
         << FixItHint::CreateReplacement(SourceRange(Tok.getLocation()), "=");
+    LLVM_FALLTHROUGH; // HLSL Change
   case tok::equal:
     return true;
   }

tools/clang/lib/Rewrite/HTMLRewrite.cpp

@@ -400,13 +400,14 @@ void html::SyntaxHighlight(Rewriter &R, FileID FID, const Preprocessor &PP) {
       ++TokOffs;
       --TokLen;
       // FALL THROUGH to chop the 8
+      LLVM_FALLTHROUGH; // HLSL Change
     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; // HLSL Change
     case tok::string_literal:
       // FIXME: Exclude the optional ud-suffix from the highlighted range.
       HighlightRange(RB, TokOffs, TokOffs+TokLen, BufferStart,

tools/clang/lib/SPIRV/CapabilityVisitor.cpp

@@ -559,6 +559,7 @@ bool CapabilityVisitor::visitInstruction(SpirvInstruction *instr) {
       addCapability(spv::Capability::RayTracingKHR);
       addExtension(Extension::KHR_ray_tracing, "SPV_KHR_ray_tracing", {});
     }
+    break;
   }
 
   case spv::Op::OpSetMeshOutputsEXT:
@@ -725,6 +726,7 @@ bool CapabilityVisitor::visit(SpirvExtInst *instr) {
     case GLSLstd450::GLSLstd450InterpolateAtOffset:
       addExtension(Extension::AMD_gpu_shader_half_float, "16-bit float",
                    instr->getSourceLocation());
+      break;
     default:
       break;
     }

tools/clang/lib/SPIRV/DeclResultIdMapper.cpp

@@ -2578,7 +2578,7 @@ bool DeclResultIdMapper::createStageVars(
             break;
           }
         }
-        // fall through
+        LLVM_FALLTHROUGH;
       default:
         emitError("invalid usage of semantic '%0' in shader profile %1", loc)
             << semanticToUse->str
@@ -3399,6 +3399,7 @@ SpirvVariable *DeclResultIdMapper::getBuiltinVar(spv::BuiltIn builtIn,
   case spv::BuiltIn::SubgroupSize:
   case spv::BuiltIn::SubgroupLocalInvocationId:
     needsLegalization = true;
+    LLVM_FALLTHROUGH;
   case spv::BuiltIn::HitTNV:
   case spv::BuiltIn::RayTmaxNV:
   case spv::BuiltIn::RayTminNV: