Eliminate many benign instances of "potentially uninitialized local variable" warnings

[ariccio]

Summary

Currently, the "potentially uninitialized local variable" & "potentially uninitialized local pointer variable" warnings are turned off. At some point we should probably turn them back on, because they can find serious problems. This patch eliminates the most obviously benign offenders.

Assuming that I did everything correctly, there should be no behavior change. In several places, I added defensive checks to bulletproof against future changes.

This leaves about ~33 not-so-obviously benign offenders. which I'll include here for convenience:

Severity	Code	Description	Project	File	Line
Warning	C4703	potentially uninitialized local pointer variable 'ExprOffset' used	LLVMMipsAsmParser	c:\llvm\llvm\lib\target\mips\asmparser\mipsasmparser.cpp	2668
Warning	C4701	potentially uninitialized local variable 'Encoding' used	clangCodeGen	c:\llvm\llvm\tools\clang\lib\codegen\cgdebuginfo.cpp	573
Warning	C4701	potentially uninitialized local variable 'result' used	clangCodeGen	c:\llvm\llvm\tools\clang\lib\codegen\cgobjc.cpp	2675
Warning	C4701	potentially uninitialized local variable 'Nullability' used	clangParse	c:\llvm\llvm\tools\clang\lib\parse\parseobjc.cpp	1202
Warning	C4701	potentially uninitialized local variable 'RepresentationMethod' used	clangParse	c:\llvm\llvm\tools\clang\lib\parse\parsepragma.cpp	1582
Warning	C4701	potentially uninitialized local variable 'FirstOpKind' used	clangSema	c:\llvm\llvm\tools\clang\lib\sema\sematemplate.cpp	4464
Warning	C4701	potentially uninitialized local variable 'FnEntry8BitAbbrev' used	LLVMBitWriter	c:\llvm\llvm\lib\bitcode\writer\bitcodewriter.cpp	2353
Warning	C4701	potentially uninitialized local variable 'FnEntry7BitAbbrev' used	LLVMBitWriter	c:\llvm\llvm\lib\bitcode\writer\bitcodewriter.cpp	2357
Warning	C4701	potentially uninitialized local variable 'FnEntry6BitAbbrev' used	LLVMBitWriter	c:\llvm\llvm\lib\bitcode\writer\bitcodewriter.cpp	2355
Warning	C4701	potentially uninitialized local variable 'OutIt' used	LLVMCodeGen	c:\llvm\llvm\lib\codegen\liveinterval.cpp	876
Warning	C4701	potentially uninitialized local variable 'mid' used	LLVMHexagonCodeGen	c:\llvm\build\lib\target\hexagon\hexagongeninstrinfo.inc	9722
Warning	C4701	potentially uninitialized local variable 'RealEightBitCounterArray' used	LLVMInstrumentation	c:\llvm\llvm\lib\transforms\instrumentation\sanitizercoverage.cpp	294
Warning	C4701	potentially uninitialized local variable 'LoOffset' used	LLVMMipsAsmParser	c:\llvm\llvm\lib\target\mips\asmparser\mipsasmparser.cpp	2668
Warning	C4701	potentially uninitialized local variable 'HiOffset' used	LLVMMipsAsmParser	c:\llvm\llvm\lib\target\mips\asmparser\mipsasmparser.cpp	2659
Warning	C4701	potentially uninitialized local variable 'ExprOffset' used	LLVMMipsAsmParser	c:\llvm\llvm\lib\target\mips\asmparser\mipsasmparser.cpp	2668
Warning	C4701	potentially uninitialized local variable 'BranchTargetNoTraps' used	LLVMMipsAsmParser	c:\llvm\llvm\lib\target\mips\asmparser\mipsasmparser.cpp	3072
Warning	C4701	potentially uninitialized local variable 'MatImm' used	LLVMPowerPCCodeGen	c:\llvm\llvm\lib\target\powerpc\ppciseldagtodag.cpp	808
Warning	C4701	potentially uninitialized local variable 'MaskEnd' used	LLVMPowerPCCodeGen	c:\llvm\llvm\lib\target\powerpc\ppciseldagtodag.cpp	809
Warning	C4701	potentially uninitialized local variable 'FirstLP' used	LLVMScalarOpts	c:\llvm\llvm\lib\transforms\scalar\loadcombine.cpp	198
Warning	C4701	potentially uninitialized local variable 'CC' used	LLVMSelectionDAG	c:\llvm\llvm\lib\codegen\selectiondag\dagcombiner.cpp	13889
Warning	C4701	potentially uninitialized local variable 'Operation' used	llvm-ar	c:\llvm\llvm\tools\llvm-ar\llvm-ar.cpp	287
Warning	C4701	potentially uninitialized local variable 'Kind' used	llvm-ar	c:\llvm\llvm\tools\llvm-ar\llvm-ar.cpp	602
Warning	C4701	potentially uninitialized local variable 'CurSegAddress' used	llvm-objdump	c:\llvm\llvm\tools\llvm-objdump\machodump.cpp	8548
Warning	C4701	potentially uninitialized local variable 'objc_class' used	llvm-objdump	c:\llvm\llvm\tools\llvm-objdump\machodump.cpp	5435
Warning	C4701	potentially uninitialized local variable 'r_type' used	llvm-objdump	c:\llvm\llvm\tools\llvm-objdump\machodump.cpp	1781
Warning	C4701	potentially uninitialized local variable 'r_value' used	llvm-objdump	c:\llvm\llvm\tools\llvm-objdump\machodump.cpp	1783
Warning	C4701	potentially uninitialized local variable 'pair_r_value' used	llvm-objdump	c:\llvm\llvm\tools\llvm-objdump\machodump.cpp	1784
Warning	C4701	potentially uninitialized local variable 'r_value' used	llvm-objdump	c:\llvm\llvm\tools\llvm-objdump\machodump.cpp	1970
Warning	C4701	potentially uninitialized local variable 'other_half' used	llvm-objdump	c:\llvm\llvm\tools\llvm-objdump\machodump.cpp	1940
Warning	C4701	potentially uninitialized local variable 'pair_r_value' used	llvm-objdump	c:\llvm\llvm\tools\llvm-objdump\machodump.cpp	1980
Warning	C4703	potentially uninitialized local pointer variable 'result' used	clangCodeGen	c:\llvm\llvm\tools\clang\lib\codegen\cgobjc.cpp	2675
Warning	C4703	potentially uninitialized local pointer variable 'OutIt' used	LLVMCodeGen	c:\llvm\llvm\lib\codegen\liveinterval.cpp	876
Warning	C4703	potentially uninitialized local pointer variable 'RealEightBitCounterArray' used	LLVMInstrumentation	c:\llvm\llvm\lib\transforms\instrumentation\sanitizercoverage.cpp	294

[dsanders]

Thanks for working on this.

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

2715–2718

I think this should be Mips::NoRegister.

llvm/lib/Target/Mips/MipsAsmPrinter.cpp

889–938

These two are false positives since all the enum values are covered.

The default labels cause warnings when clang is the compiler:

lib/Target/Mips/MipsAsmPrinter.cpp:911:3: warning: default label in switch which covers all enumeration values [-Wcovered-switch-default]

which will cause -Werror builders to fail.

I'd suggest dropping the default labels to avoid the clang warning, but keeping the initializations to keep your compiler happy.

[s.egerton]

Hello. I will take a look at fixing the warnings coming from LLVMMipsAsmParser.

[dblaikie]

I think we had a discussion about this before.

Clang has a few versions of this warning. One version is probably as
aggressive as the warning you are trying to quiet (-Wmaybe-uninitialized)
and we made a deliberate choice not to enable it for the project. I think
we should probably make the same choice here and not enable it.

Initializations we never expect to use (eg because we have a covered switch
that initializes in all cases, or some slightly complex control flow the
compiler can't see through) hinder our ability to find uses of those with
tools like msan.

We do enable clangs -Wsometimes-uninitialized which is more restrictive
(fewer false positives. At the cost of more false negatives).

[tejohnson]

Thanks for doing this!

I will fix these 3, which one of my changes would have provoked. It is a benign case since we do have an assert at the use site checking the same condition that the inits are guarded with, but there is no reason not to 0 init these to avoid the bogus warning.

Warning C4701 potentially uninitialized local variable 'FnEntry8BitAbbrev' used LLVMBitWriter c:\llvm\llvm\lib\bitcode\writer\bitcodewriter.cpp 2353
Warning C4701 potentially uninitialized local variable 'FnEntry7BitAbbrev' used LLVMBitWriter c:\llvm\llvm\lib\bitcode\writer\bitcodewriter.cpp 2357
Warning C4701 potentially uninitialized local variable 'FnEntry6BitAbbrev' used LLVMBitWriter c:\llvm\llvm\lib\bitcode\writer\bitcodewriter.cpp 2355

[ariccio]

In D17983#370717, @dblaikie wrote:

Initializations we never expect to use (eg because we have a covered switch
that initializes in all cases, or some slightly complex control flow the
compiler can't see through) hinder our ability to find uses of those with
tools like msan.

Too bad... Maybe msan should have a way to specify that you're default initializing a variable, and treat it as if you're not initializing it at all?

That said, I'm not sure that I agree with keeping Potentially uninitialized local pointer variable 'name' used off (that's C4703, not C4701), because uninitialized local pointer bugs are more dangerous (I'm thinking of write-what-where uninitialized pointer vulnerabilities), and I'd rather crash on a nullptr deref than some undefined behavior.

I will drop the default cases as @dsanders noted, but should I drop all the local variable inits too? In several cases (which I didn't specifically note) I chose default initialization values that would trigger pre-existing asserts if nobody assigned anything else to them.

Regarding the 33 warnings I noted, i couldn't tell whether they're obviously false positives, which I think warrants someone other than me carefully looking through it. Some of the warnings are caused by assigning to a variable inside of a loop with a dynamically sized bound; for those, I'd much rather (a) assert that the bound is nonzero/loop will be executed at least once, or (b) assign the variable some sentinel value, and then assert it before the variable is actually used. Thoughts?

[ariccio]

Oh, and by the way, what's the policy on using enum classes instead of C style enums? I bet the compiler would have fewer false positives with strongly typed enums?

[ariccio]

For some reason, this smaller diff was harder to upload than the first diff.

[TheOneRing]

Hi is there any update on this issue, which is blocking https://llvm.org/bugs/show_bug.cgi?id=11446 ?

[iamsergio]

@ariccio, are you blocked on this or waiting for reviewers ? This seems to be blocking the patch that fixes plugins on MSVC, thanks

[mehdi_amini]

@dblaikie mentioned before that it is not clear that this is something we want to do at all (initialize all local variables).
Would it be something we should have policy on in the first place before integrating such a patch? (Reminds me of constructor that don't initializes all members "on purpose").
Maybe send an RFC to LLVM-dev and codify this in the coding guidelines?

In D17983#371040, @ariccio wrote:

... I'd rather crash on a nullptr deref than some undefined behavior.

Wait... Isn't nullptr deref UB?

[iamsergio]

In D17983#527399, @iamsergio wrote:

@ariccio, are you blocked on this or waiting for reviewers ? This seems to be blocking the patch that fixes plugins on MSVC, thanks

https://llvm.org/bugs/show_bug.cgi?id=11446 comment #6 links to this review, but I think it might have been a mistake and unrelated.

llvm/lib/Analysis/CFLAliasAnalysis.cpp

while (!Worklist.empty()) {
           Added = Builder.addAbove(CurValue, OtherValue);
           break;
         case Level::Below:
           Added = Builder.addBelow(CurValue, OtherValue);
           break;
         case Level::Same:
           Added = Builder.addWith(CurValue, OtherValue);
           break;
+        default:
+          llvm_unreachable("Unexpected Level!");
         }
 
         auto Aliasing = Weight.second;
         if (auto MaybeCurIndex = valueToAttrIndex(CurValue))
           Aliasing.set(*MaybeCurIndex);
         if (auto MaybeOtherIndex = valueToAttrIndex(OtherValue))
           Aliasing.set(*MaybeOtherIndex);
         Builder.noteAttributes(CurValue, Aliasing);

llvm/lib/Analysis/DependenceAnalysis.cpp

if (Level <= CommonLevels && !SE->isLoopInvariant(Expression, LoopNest))
       Loops.set(Level);
     LoopNest = LoopNest->getParentLoop();
   }
 }
 
 void DependenceAnalysis::unifySubscriptType(ArrayRef<Subscript *> Pairs) {
 
   unsigned widestWidthSeen = 0;
-  Type *widestType;
+  Type *widestType = nullptr;
 
   // Go through each pair and find the widest bit to which we need
   // to extend all of them.
   for (unsigned i = 0; i < Pairs.size(); i++) {
     const SCEV *Src = Pairs[i]->Src;
     const SCEV *Dst = Pairs[i]->Dst;
     IntegerType *SrcTy = dyn_cast<IntegerType>(Src->getType());
     IntegerType *DstTy = dyn_cast<IntegerType>(Dst->getType());

llvm/lib/Analysis/InstructionSimplify.cpp

if (match(Op0, m_And(m_Value(A), m_Value(C))) &&
       match(Op1, m_And(m_Value(B), m_Value(D)))) {
     ConstantInt *C1 = dyn_cast<ConstantInt>(C);
     ConstantInt *C2 = dyn_cast<ConstantInt>(D);
     if (C1 && C2 && (C1->getValue() == ~C2->getValue())) {
       // (A & C1)|(B & C2)
       // If we have: ((V + N) & C1) | (V & C2)
       // .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0
       // replace with V+N.
-      Value *V1, *V2;
+      Value *V1 = nullptr, *V2 = nullptr;
       if ((C2->getValue() & (C2->getValue() + 1)) == 0 && // C2 == 0+1+
           match(A, m_Add(m_Value(V1), m_Value(V2)))) {
         // Add commutes, try both ways.
         if (V1 == B &&
             MaskedValueIsZero(V2, C2->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
           return A;
         if (V2 == B &&
             MaskedValueIsZero(V1, C2->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
case Instruction::Shl: {
       break;
     }
     }
   }
 
   // Simplify comparisons involving max/min.
   Value *A, *B;
   CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE;
-  CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B".
+
+  // Initialized to BAD_ICMP_PREDICATE so we don't use garbage in the
+  // next switch statement.
+  // Chosen so that "A == max/min(A,B)" iff "A EqP B".
+  CmpInst::Predicate EqP = CmpInst::BAD_ICMP_PREDICATE;
+
 
   // Signed variants on "max(a,b)>=a -> true".
   if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) {
     if (A != RHS) std::swap(A, B); // smax(A, B) pred A.
     EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B".
     // We analyze this as smax(A, B) pred A.
     P = Pred;
   } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) &&
if (isa<UndefValue>(FalseVal))   // select C, X, undef -> X
     return TrueVal;
 
   if (const auto *ICI = dyn_cast<ICmpInst>(CondVal)) {
     unsigned BitWidth = Q.DL.getTypeSizeInBits(TrueVal->getType());
     ICmpInst::Predicate Pred = ICI->getPredicate();
     Value *CmpLHS = ICI->getOperand(0);
     Value *CmpRHS = ICI->getOperand(1);
     APInt MinSignedValue = APInt::getSignBit(BitWidth);
-    Value *X;
-    const APInt *Y;
-    bool TrueWhenUnset;
+    Value *X = nullptr;
+    const APInt *Y = nullptr;
+    bool TrueWhenUnset = false;
     bool IsBitTest = false;
     if (ICmpInst::isEquality(Pred) &&
         match(CmpLHS, m_And(m_Value(X), m_APInt(Y))) &&
         match(CmpRHS, m_Zero())) {
       IsBitTest = true;
       TrueWhenUnset = Pred == ICmpInst::ICMP_EQ;
     } else if (Pred == ICmpInst::ICMP_SLT && match(CmpRHS, m_Zero())) {
       X = CmpLHS;

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
   case lltok::kw_getelementptr:
   case lltok::kw_shufflevector:
   case lltok::kw_insertelement:
   case lltok::kw_extractelement:
   case lltok::kw_select: {
     unsigned Opc = Lex.getUIntVal();
     SmallVector<Constant*, 16> Elts;
     bool InBounds = false;
-    Type *Ty;
+    Type *Ty = nullptr;
     Lex.Lex();
 
     if (Opc == Instruction::GetElementPtr)
       InBounds = EatIfPresent(lltok::kw_inbounds);
 
     if (ParseToken(lltok::lparen, "expected '(' in constantexpr"))
       return true;
 

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

if (GO) {
     }
   }
   return V;
 }
 
 /// Parse the value symbol table at either the current parsing location or
 /// at the given bit offset if provided.
 std::error_code BitcodeReader::parseValueSymbolTable(uint64_t Offset) {
-  uint64_t CurrentBit;
+  uint64_t CurrentBit = 0;
   // Pass in the Offset to distinguish between calling for the module-level
   // VST (where we want to jump to the VST offset) and the function-level
   // VST (where we don't).
   if (Offset > 0) {
     // Save the current parsing location so we can jump back at the end
     // of the VST read.
     CurrentBit = Stream.GetCurrentBitNo();
     Stream.JumpToBit(Offset * 32);
#endif
   Triple TT(TheModule->getTargetTriple());
 
   // Read all the records for this value table.
   SmallString<128> ValueName;
   while (1) {
     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
+    default:
+      llvm_unreachable("Unexpected Kind!");
     case BitstreamEntry::SubBlock: // Handled for us already.
     case BitstreamEntry::Error:
       return error("Malformed block");
     case BitstreamEntry::EndBlock:
       if (Offset > 0)
         Stream.JumpToBit(CurrentBit);
       return std::error_code();
     case BitstreamEntry::Record:

llvm/lib/CodeGen/AtomicExpandPass.cpp

for (auto I : AtomicInsts) {
     auto SI = dyn_cast<StoreInst>(I);
     auto RMWI = dyn_cast<AtomicRMWInst>(I);
     auto CASI = dyn_cast<AtomicCmpXchgInst>(I);
     assert((LI || SI || RMWI || CASI || isa<FenceInst>(I)) &&
            "Unknown atomic instruction");
 
     if (TLI->getInsertFencesForAtomic()) {
       auto FenceOrdering = Monotonic;
-      bool IsStore, IsLoad;
+      bool IsStore = false, IsLoad = false;
       if (LI && isAtLeastAcquire(LI->getOrdering())) {
         FenceOrdering = LI->getOrdering();
         LI->setOrdering(Monotonic);
         IsStore = false;
         IsLoad = true;
       } else if (SI && isAtLeastRelease(SI->getOrdering())) {
         FenceOrdering = SI->getOrdering();
         SI->setOrdering(Monotonic);
Value *StoreSuccess = TLI->emitStoreConditional(
       Builder, CI->getNewValOperand(), Addr, MemOpOrder);
   StoreSuccess = Builder.CreateICmpEQ(
       StoreSuccess, ConstantInt::get(Type::getInt32Ty(Ctx), 0), "success");
   BasicBlock *RetryBB = HasReleasedLoadBB ? ReleasedLoadBB : StartBB;
   Builder.CreateCondBr(StoreSuccess, SuccessBB,
                        CI->isWeak() ? FailureBB : RetryBB);
 
   Builder.SetInsertPoint(ReleasedLoadBB);
-  Value *SecondLoad;
+  Value *SecondLoad = false;
   if (HasReleasedLoadBB) {
     SecondLoad = TLI->emitLoadLinked(Builder, Addr, MemOpOrder);
     ShouldStore = Builder.CreateICmpEQ(SecondLoad, CI->getCompareOperand(),
                                        "should_store");
 
     // If the cmpxchg doesn't actually need any ordering when it fails, we can
     // jump straight past that fence instruction (if it exists).
     Builder.CreateCondBr(ShouldStore, TryStoreBB, NoStoreBB);

llvm/lib/CodeGen/LiveInterval.cpp

if (Event == BEGIN_SEGMENT) {
         CurrentSegment.end = Pos;
         append(CurrentSegment);
         ConstructingSegment = false;
       }
 
       // Start a new segment if necessary.
       if (!ConstructingSegment) {
         // Determine value number for the segment.
-        VNInfo *VNI;
+        VNInfo *VNI = nullptr;
         if (IsDef) {
           VNI = getNextValue(Pos, VNIAllocator);
         } else {
           // We have to reuse an existing value number, if we are lucky
           // then we already passed one of the predecessor blocks and determined
           // its value number (with blocks in reverse postorder this would be
           // always true but we have no such guarantee).
           assert(Pos.isBlock());

llvm/lib/CodeGen/MIRParser/MIRParser.cpp

case SourceMgr::DK_Error:
     Kind = DS_Error;
     break;
   case SourceMgr::DK_Warning:
     Kind = DS_Warning;
     break;
   case SourceMgr::DK_Note:
     Kind = DS_Note;
     break;
+  default:
+    llvm_unreachable("Unexpected DiagKind!");
   }
   Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag));
 }
 
 static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
   reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
 }
 

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

if (IsCIE) {
       StringRef AugmentationData("");
       uint32_t FDEPointerEncoding = DW_EH_PE_omit;
       uint32_t LSDAPointerEncoding = DW_EH_PE_omit;
       if (IsEH) {
         Optional<uint32_t> PersonalityEncoding;
         Optional<uint64_t> Personality;
 
         Optional<uint64_t> AugmentationLength;
-        uint32_t StartAugmentationOffset;
-        uint32_t EndAugmentationOffset;
+        uint32_t StartAugmentationOffset = 0;
+        uint32_t EndAugmentationOffset = 0;
 
         // Walk the augmentation string to get all the augmentation data.
         for (unsigned i = 0, e = AugmentationString.size(); i != e; ++i) {
           switch (AugmentationString[i]) {
             default:
               ReportError("Unknown augmentation character in entry at %lx");
             case 'L':
               LSDAPointerEncoding = Data.getU8(&Offset);

llvm/lib/IR/Core.cpp

LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS,
                               LLVMValueRef RHS, const char *Name) {
   return wrap(unwrap(B)->CreatePtrDiff(unwrap(LHS), unwrap(RHS), Name));
 }
 
 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,
                                LLVMValueRef PTR, LLVMValueRef Val,
                                LLVMAtomicOrdering ordering,
                                LLVMBool singleThread) {
-  AtomicRMWInst::BinOp intop;
+  AtomicRMWInst::BinOp intop = AtomicRMWInst::BAD_BINOP;
   switch (op) {
     case LLVMAtomicRMWBinOpXchg: intop = AtomicRMWInst::Xchg; break;
     case LLVMAtomicRMWBinOpAdd: intop = AtomicRMWInst::Add; break;
     case LLVMAtomicRMWBinOpSub: intop = AtomicRMWInst::Sub; break;
     case LLVMAtomicRMWBinOpAnd: intop = AtomicRMWInst::And; break;
     case LLVMAtomicRMWBinOpNand: intop = AtomicRMWInst::Nand; break;
     case LLVMAtomicRMWBinOpOr: intop = AtomicRMWInst::Or; break;
     case LLVMAtomicRMWBinOpXor: intop = AtomicRMWInst::Xor; break;
     case LLVMAtomicRMWBinOpMax: intop = AtomicRMWInst::Max; break;
     case LLVMAtomicRMWBinOpMin: intop = AtomicRMWInst::Min; break;
     case LLVMAtomicRMWBinOpUMax: intop = AtomicRMWInst::UMax; break;
     case LLVMAtomicRMWBinOpUMin: intop = AtomicRMWInst::UMin; break;
+    default: llvm_unreachable("Unexpected LLVMAtomicRMWBinOp!");
   }
   return wrap(unwrap(B)->CreateAtomicRMW(intop, unwrap(PTR), unwrap(Val),
     mapFromLLVMOrdering(ordering), singleThread ? SingleThread : CrossThread));
 }
 
 
 /*===-- Module providers --------------------------------------------------===*/
 

llvm/lib/LTO/LTOCodeGenerator.cpp

case DS_Warning:
     Severity = LTO_DS_WARNING;
     break;
   case DS_Remark:
     Severity = LTO_DS_REMARK;
     break;
   case DS_Note:
     Severity = LTO_DS_NOTE;
     break;
+  default:
+    llvm_unreachable("Unexpected DiagnosticSeverity!");
   }
   // Create the string that will be reported to the external diagnostic handler.
   std::string MsgStorage;
   raw_string_ostream Stream(MsgStorage);
   DiagnosticPrinterRawOStream DP(Stream);
   DI.print(DP);
   Stream.flush();
 

llvm/lib/MC/MCAsmStreamer.cpp

void MCAsmStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
                                        unsigned Line, unsigned Column,
                                        bool PrologueEnd, bool IsStmt,
                                        StringRef FileName) {
   OS << "\t.cv_loc\t" << FunctionId << " " << FileNo << " " << Line << " "
      << Column;
   if (PrologueEnd)
     OS << " prologue_end";
 
-  unsigned OldIsStmt = getContext().getCurrentCVLoc().isStmt();
+  bool OldIsStmt = getContext().getCurrentCVLoc().isStmt();
   if (IsStmt != OldIsStmt) {
     OS << " is_stmt ";
 
     if (IsStmt)
       OS << "1";
     else
       OS << "0";
   }

llvm/lib/MC/MachObjectWriter.cpp

void MachObjectWriter::writeNlist(MachSymbolData &MSD,
   const MCSymbol &Data = *Symbol;
   const MCSymbol *AliasedSymbol = &findAliasedSymbol(*Symbol);
   uint8_t SectionIndex = MSD.SectionIndex;
   uint8_t Type = 0;
   uint64_t Address = 0;
   bool IsAlias = Symbol != AliasedSymbol;
 
   const MCSymbol &OrigSymbol = *Symbol;
-  MachSymbolData *AliaseeInfo;
+  MachSymbolData *AliaseeInfo = nullptr;
   if (IsAlias) {
     AliaseeInfo = findSymbolData(*AliasedSymbol);
     if (AliaseeInfo)
       SectionIndex = AliaseeInfo->SectionIndex;
     Symbol = AliasedSymbol;
     // FIXME: Should this update Data as well?  Do we need OrigSymbol at all?
   }
 
case MCVM_IOSVersionMin:
       LCType = MachO::LC_VERSION_MIN_IPHONEOS;
       break;
     case MCVM_TvOSVersionMin:
       LCType = MachO::LC_VERSION_MIN_TVOS;
       break;
     case MCVM_WatchOSVersionMin:
       LCType = MachO::LC_VERSION_MIN_WATCHOS;
       break;
+    default:
+      llvm_unreachable("Unexpected MCVersionMinType!");
     }
     write32(LCType);
     write32(sizeof(MachO::version_min_command));
     write32(EncodedVersion);
     write32(0);         // reserved.
   }
 
   // Write the data-in-code load command, if used.

llvm/lib/Support/Windows/Path.inc

std::error_code mapped_file_region::init(int FD, uint64_t Offset,
   // Make sure that the requested size fits within SIZE_T.
   if (Size > std::numeric_limits<SIZE_T>::max())
     return make_error_code(errc::invalid_argument);
 
   HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
   if (FileHandle == INVALID_HANDLE_VALUE)
     return make_error_code(errc::bad_file_descriptor);
 
-  DWORD flprotect;
+  DWORD flprotect = 0;
   switch (Mode) {
   case readonly:  flprotect = PAGE_READONLY; break;
   case readwrite: flprotect = PAGE_READWRITE; break;
   case priv:      flprotect = PAGE_WRITECOPY; break;
+  default: llvm_unreachable("Unexpected mapmode!");
   }
 
   HANDLE FileMappingHandle =
       ::CreateFileMappingW(FileHandle, 0, flprotect,
                            (Offset + Size) >> 32,
                            (Offset + Size) & 0xffffffff,
                            0);
   if (FileMappingHandle == NULL) {
     std::error_code ec = mapWindowsError(GetLastError());
     return ec;
   }
 
-  DWORD dwDesiredAccess;
+  DWORD dwDesiredAccess = 0;
   switch (Mode) {
   case readonly:  dwDesiredAccess = FILE_MAP_READ; break;
   case readwrite: dwDesiredAccess = FILE_MAP_WRITE; break;
   case priv:      dwDesiredAccess = FILE_MAP_COPY; break;
+  default: llvm_unreachable("Unexpected mapmode!");
   }
   Mapping = ::MapViewOfFile(FileMappingHandle,
                             dwDesiredAccess,
                             Offset >> 32,
                             Offset & 0xffffffff,
                             Size);
   if (Mapping == NULL) {
     std::error_code ec = mapWindowsError(GetLastError());

llvm/lib/Support/YAMLParser.cpp

bool Scanner::scanBlockScalarHeader(char &ChompingIndicator,
   }
   return true;
 }
 
 bool Scanner::findBlockScalarIndent(unsigned &BlockIndent,
                                     unsigned BlockExitIndent,
                                     unsigned &LineBreaks, bool &IsDone) {
   unsigned MaxAllSpaceLineCharacters = 0;
-  StringRef::iterator LongestAllSpaceLine;
+  StringRef::iterator LongestAllSpaceLine = nullptr;
 
   while (true) {
     advanceWhile(&Scanner::skip_s_space);
     if (skip_nb_char(Current) != Current) {
       // This line isn't empty, so try and find the indentation.
       if (Column <= BlockExitIndent) { // End of the block literal.
         IsDone = true;
         return true;

llvm/lib/Target/AArch64/AArch64AdvSIMDScalarPass.cpp

void AArch64AdvSIMDScalar::transformInstruction(MachineInstr *MI) {
   MachineBasicBlock *MBB = MI->getParent();
   unsigned OldOpc = MI->getOpcode();
   unsigned NewOpc = getTransformOpcode(OldOpc);
   assert(OldOpc != NewOpc && "transform an instruction to itself?!");
 
   // Check if we need a copy for the source registers.
   unsigned OrigSrc0 = MI->getOperand(1).getReg();
   unsigned OrigSrc1 = MI->getOperand(2).getReg();
-  unsigned Src0 = 0, SubReg0;
-  unsigned Src1 = 0, SubReg1;
+  unsigned Src0 = 0, SubReg0 = 0;
+  unsigned Src1 = 0, SubReg1 = 0;
   if (!MRI->def_empty(OrigSrc0)) {
     MachineRegisterInfo::def_instr_iterator Def =
         MRI->def_instr_begin(OrigSrc0);
     assert(std::next(Def) == MRI->def_instr_end() && "Multiple def in SSA!");
     Src0 = getSrcFromCopy(&*Def, MRI, SubReg0);
     // If there are no other users of the original source, we can delete
     // that instruction.
     if (Src0 && MRI->hasOneNonDBGUse(OrigSrc0)) {

llvm/lib/Target/AArch64/AArch64FastISel.cpp

 }
 
 /// \brief Optimize selects of i1 if one of the operands has a 'true' or 'false'
 /// value.
 bool AArch64FastISel::optimizeSelect(const SelectInst *SI) {
   if (!SI->getType()->isIntegerTy(1))
     return false;
 
-  const Value *Src1Val, *Src2Val;
+  const Value *Src1Val = nullptr, *Src2Val = nullptr;
   unsigned Opc = 0;
   bool NeedExtraOp = false;
   if (auto *CI = dyn_cast<ConstantInt>(SI->getTrueValue())) {
     if (CI->isOne()) {
       Src1Val = SI->getCondition();
       Src2Val = SI->getFalseValue();
       Opc = AArch64::ORRWrr;
     } else {

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

if (!isLegalArithImmed(C)) {
           C = (VT == MVT::i32) ? (uint32_t)(C + 1) : C + 1;
           RHS = DAG.getConstant(C, dl, VT);
         }
         break;
       }
     }
   }
   SDValue Cmp;
-  AArch64CC::CondCode AArch64CC;
+  AArch64CC::CondCode AArch64CC = AArch64CC::Invalid;
   if ((CC == ISD::SETEQ || CC == ISD::SETNE) && isa<ConstantSDNode>(RHS)) {
     const ConstantSDNode *RHSC = cast<ConstantSDNode>(RHS);
 
     // The imm operand of ADDS is an unsigned immediate, in the range 0 to 4095.
     // For the i8 operand, the largest immediate is 255, so this can be easily
     // encoded in the compare instruction. For the i16 operand, however, the
     // largest immediate cannot be encoded in the compare.
     // Therefore, use a sign extending load and cmn to avoid materializing the

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

bool AArch64AsmParser::parseRegister(OperandVector &Operands) {
   }
 
   return false;
 }
 
 bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) {
   MCAsmParser &Parser = getParser();
   bool HasELFModifier = false;
-  AArch64MCExpr::VariantKind RefKind;
+  AArch64MCExpr::VariantKind RefKind = AArch64MCExpr::VK_INVALID;
 
   if (Parser.getTok().is(AsmToken::Colon)) {
     Parser.Lex(); // Eat ':"
     HasELFModifier = true;
 
     if (Parser.getTok().isNot(AsmToken::Identifier)) {
       Error(Parser.getTok().getLoc(),
             "expect relocation specifier in operand after ':'");

llvm/lib/Target/AMDGPU/AMDILCFGStructurizer.cpp

do {
     SmallVectorImpl<MachineBasicBlock *>::const_iterator E =
         OrderedBlks.end();
 
     SmallVectorImpl<MachineBasicBlock *>::const_iterator SccBeginIter =
         It;
     MachineBasicBlock *SccBeginMBB = nullptr;
     int SccNumBlk = 0;  // The number of active blocks, init to a
                         // maximum possible number.
-    int SccNumIter;     // Number of iteration in this SCC.
+    int SccNumIter = 0;     // Number of iteration in this SCC.
 
     while (It != E) {
       MBB = *It;
 
       if (!SccBeginMBB) {
         SccBeginIter = It;
         SccBeginMBB = MBB;
         SccNumIter = 0;

llvm/lib/Target/AMDGPU/R600InstrInfo.cpp

R600InstrInfo::fitsReadPortLimitations(const std::vector<MachineInstr *> &IG,
                                        const DenseMap<unsigned, unsigned> &PV,
                                        std::vector<BankSwizzle> &ValidSwizzle,
                                        bool isLastAluTrans)
     const {
   //Todo : support shared src0 - src1 operand
 
   std::vector<std::vector<std::pair<int, unsigned> > > IGSrcs;
   ValidSwizzle.clear();
-  unsigned ConstCount;
+  unsigned ConstCount = 0;
   BankSwizzle TransBS = ALU_VEC_012_SCL_210;
   for (unsigned i = 0, e = IG.size(); i < e; ++i) {
     IGSrcs.push_back(ExtractSrcs(IG[i], PV, ConstCount));
     unsigned Op = getOperandIdx(IG[i]->getOpcode(),
         AMDGPU::OpName::bank_swizzle);
     ValidSwizzle.push_back( (R600InstrInfo::BankSwizzle)
         IG[i]->getOperand(Op).getImm());
   }

llvm/lib/Target/ARM/ARMFastISel.cpp

unsigned ARMFastISel::ARMEmitIntExt(MVT SrcVT, unsigned SrcReg, MVT DestVT,
   ARM_AM::ShiftOpc Shift = (ARM_AM::ShiftOpc) ITP->Shift;
   assert(((Shift == ARM_AM::no_shift) == (Opc != ARM::MOVsi)) &&
          "only MOVsi has shift operand addressing mode");
   unsigned Imm = ITP->Imm;
 
   // 16-bit Thumb instructions always set CPSR (unless they're in an IT block).
   bool setsCPSR = &ARM::tGPRRegClass == RC;
   unsigned LSLOpc = isThumb2 ? ARM::tLSLri : ARM::MOVsi;
-  unsigned ResultReg;
+
+  // 0 is treated as a failure code all the way up. We intialize ResultReg
+  // to 0, so that if the forthcoming loop does not execute, we're already
+  // returning a failure code. This will trigger an assertion in several
+  // places, which is much better than returning garbage.
+  unsigned ResultReg = 0;
+
   // MOVsi encodes shift and immediate in shift operand addressing mode.
   // The following condition has the same value when emitting two
   // instruction sequences: both are shifts.
   bool ImmIsSO = (Shift != ARM_AM::no_shift);
 
   // Either one or two instructions are emitted.
   // They're always of the form:
   //   dst = in OP imm
if (isThumb2)
     return false;
 
   // Only handle i32 now.
   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
   if (DestVT != MVT::i32)
     return false;
 
   unsigned Opc = ARM::MOVsr;
-  unsigned ShiftImm;
+  unsigned ShiftImm = 0;
   Value *Src2Value = I->getOperand(1);
   if (const ConstantInt *CI = dyn_cast<ConstantInt>(Src2Value)) {
     ShiftImm = CI->getZExtValue();
 
     // Fall back to selection DAG isel if the shift amount
     // is zero or greater than the width of the value type.
     if (ShiftImm == 0 || ShiftImm >=32)
       return false;
bool ARMFastISel::tryToFoldLoadIntoMI(MachineInstr *MI, unsigned OpNo,
   // ldrb r1, [r0]       ldrb r1, [r0]
   // uxtb r2, r1     =>
   // mov  r3, r2         mov  r3, r1
   if (MI->getNumOperands() < 3 || !MI->getOperand(2).isImm())
     return false;
   const uint64_t Imm = MI->getOperand(2).getImm();
 
   bool Found = false;
-  bool isZExt;
+  bool isZExt = false;
   for (unsigned i = 0, e = array_lengthof(FoldableLoadExtends);
        i != e; ++i) {
     if (FoldableLoadExtends[i].Opc[isThumb2] == MI->getOpcode() &&
         (uint64_t)FoldableLoadExtends[i].ExpectedImm == Imm &&
         MVT((MVT::SimpleValueType)FoldableLoadExtends[i].ExpectedVT) == VT) {
       Found = true;
       isZExt = FoldableLoadExtends[i].isZExt;
     }

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

const auto &Prefix =
                    [&IDVal](const PrefixEntry &PE) {
                       return PE.Spelling == IDVal;
                    });
   if (Prefix == std::end(PrefixEntries)) {
     Error(Parser.getTok().getLoc(), "unexpected prefix in operand");
     return true;
   }
 
-  uint8_t CurrentFormat;
+  // (~Prefix->SupportedFormats & 255) should always fail?
+  uint8_t CurrentFormat = 255;
   switch (getContext().getObjectFileInfo()->getObjectFileType()) {
   case MCObjectFileInfo::IsMachO:
     CurrentFormat = MACHO;
     break;
   case MCObjectFileInfo::IsELF:
     CurrentFormat = ELF;
     break;
   case MCObjectFileInfo::IsCOFF:
     CurrentFormat = COFF;
     break;
+  default:
+    llvm_unreachable("Unexpected Environment!");
   }
 
   if (~Prefix->SupportedFormats & CurrentFormat) {
     Error(Parser.getTok().getLoc(),
           "cannot represent relocation in the current file format");
     return true;
   }
 

llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp

Value =
       adjustFixupValue(Fixup, Value, IsPCRel, nullptr, IsLittleEndian, true);
   if (!Value)
     return; // Doesn't change encoding.
 
   unsigned Offset = Fixup.getOffset();
   assert(Offset + NumBytes <= DataSize && "Invalid fixup offset!");
 
   // Used to point to big endian bytes.
-  unsigned FullSizeBytes;
+  unsigned FullSizeBytes = 0;
   if (!IsLittleEndian) {
     FullSizeBytes = getFixupKindContainerSizeBytes(Fixup.getKind());
     assert((Offset + FullSizeBytes) <= DataSize && "Invalid fixup size!");
     assert(NumBytes <= FullSizeBytes && "Invalid fixup size!");
   }
 
   // For each byte of the fragment that the fixup touches, mask in the bits from
   // the fixup value. The Value has been "split up" into the appropriate

llvm/lib/Target/Hexagon/HexagonBitSimplify.cpp

case Hexagon::S2_storerb_io:
       V = int8_t(U);
       break;
     case Hexagon::S2_storerh_io:
       V = int16_t(U);
       break;
     case Hexagon::S2_storeri_io:
       V = int32_t(U);
       break;
+    default:
+      llvm_unreachable("Unexpected opcode, V not initialized!");
   }
   if (!isInt<8>(V))
     return false;
 
   MI->RemoveOperand(2);
   switch (Opc) {
     case Hexagon::S2_storerb_io:
       MI->setDesc(HII.get(Hexagon::S4_storeirb_io));

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCShuffler.cpp

if (!HexagonMCInstrInfo::bundleSize(MCB)) {
     DEBUG(dbgs() << "Skipping empty bundle");
     return HexagonShuffler::SHUFFLE_SUCCESS;
   } else if (!HexagonMCInstrInfo::isBundle(MCB)) {
     DEBUG(dbgs() << "Skipping stand-alone insn");
     return HexagonShuffler::SHUFFLE_SUCCESS;
   }
 
   bool doneShuffling = false;
-  unsigned shuffleError;
+  unsigned shuffleError = HexagonShuffler::SHUFFLE_ERROR_UNKNOWN;
   while (possibleDuplexes.size() > 0 && (!doneShuffling)) {
     // case of Duplex Found
     DuplexCandidate duplexToTry = possibleDuplexes.pop_back_val();
     MCInst Attempt(MCB);
     HexagonMCInstrInfo::replaceDuplex(Context, Attempt, duplexToTry);
     HexagonMCShuffler MCS(MCII, STI, Attempt); // copy packet to the shuffler
     if (MCS.size() == 1) {                     // case of one duplex
       // copy the created duplex in the shuffler to the bundle

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

bool MipsAsmParser::expandCondBranches(MCInst &Inst, SMLoc IDLoc,
   unsigned PseudoOpcode = Inst.getOpcode();
   unsigned SrcReg = Inst.getOperand(0).getReg();
   const MCOperand &TrgOp = Inst.getOperand(1);
   const MCExpr *OffsetExpr = Inst.getOperand(2).getExpr();
 
   unsigned ZeroSrcOpcode, ZeroTrgOpcode;
   bool ReverseOrderSLT, IsUnsigned, IsLikely, AcceptsEquality;
 
-  unsigned TrgReg;
+  // TrgReg should never normally be assigned NUM_TARGET_REGS.
+  // If you end up with NUM_TARGET_REGS, you have a bug.
+  // FIXME: is there a better way to ensure TrgReg is assigned something?
+  unsigned TrgReg = Mips::NUM_TARGET_REGS;
   if (TrgOp.isReg())
     TrgReg = TrgOp.getReg();
   else if (TrgOp.isImm()) {
     warnIfNoMacro(IDLoc);
     EmittedNoMacroWarning = true;
 
     TrgReg = getATReg(IDLoc);
     if (!TrgReg)

llvm/lib/Target/Mips/MipsAsmPrinter.cpp

void MipsAsmPrinter::EmitFPCallStub(
   std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
       TM.getTargetTriple().str(), TM.getTargetCPU(),
       TM.getTargetFeatureString()));
 
   //
   // .global xxxx
   //
   OutStreamer->EmitSymbolAttribute(MSymbol, MCSA_Global);
-  const char *RetType;
+  const char *RetType = "";
   //
   // make the comment field identifying the return and parameter
   // types of the floating point stub
   // # Stub function to call rettype xxxx (params)
   //
   switch (Signature->RetSig) {
   case FRet:
     RetType = "float";
     break;
   case DRet:
     RetType = "double";
     break;
   case CFRet:
     RetType = "complex";
     break;
   case CDRet:
     RetType = "double complex";
     break;
   case NoFPRet:
     RetType = "";
     break;
+  default:
+    llvm_unreachable("Unexpected FPReturnVariant!");
   }
-  const char *Parms;
+  const char *Parms = "";
   switch (Signature->ParamSig) {
   case FSig:
     Parms = "float";
     break;
   case FFSig:
     Parms = "float, float";
     break;
   case FDSig:
     Parms = "float, double";
     break;
   case DSig:
     Parms = "double";
     break;
   case DDSig:
     Parms = "double, double";
     break;
   case DFSig:
     Parms = "double, float";
     break;
   case NoSig:
     Parms = "";
     break;
+  default:
+    llvm_unreachable("Unexpected FPParamVariant!");
   }
   OutStreamer->AddComment("\t# Stub function to call " + Twine(RetType) + " " +
                           Twine(Symbol) + " (" + Twine(Parms) + ")");
   //
   // probably not necessary but we save and restore the current section state
   //
   OutStreamer->PushSection();
   //

llvm/lib/Target/TargetRecip.cpp

bool TargetRecip::parseGlobalParams(const std::string &Arg) {
   size_t RefPos;
   uint8_t RefSteps;
   StringRef RefStepString;
   if (parseRefinementStep(ArgSub, RefPos, RefSteps)) {
     // Split the string for further processing.
     RefStepString = ArgSub.substr(RefPos + 1);
     ArgSub = ArgSub.substr(0, RefPos);
   }
-  bool Enable;
+  bool Enable = false;
   bool UseDefaults;
   if (ArgSub == "all") {
     UseDefaults = false;
     Enable = true;
   } else if (ArgSub == "none") {
     UseDefaults = false;
     Enable = false;
   } else if (ArgSub == "default") {

llvm/lib/Target/X86/X86FastISel.cpp

if (const auto *CI = dyn_cast<ConstantInt>(RHS)) {
         BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
                 TII.get(Opc[IsDec][VT.SimpleTy-MVT::i8]), ResultReg)
           .addReg(LHSReg, getKillRegState(LHSIsKill));
       } else
         ResultReg = fastEmit_ri(VT, VT, BaseOpc, LHSReg, LHSIsKill,
                                 CI->getZExtValue());
     }
 
-    unsigned RHSReg;
-    bool RHSIsKill;
+    unsigned RHSReg = 0;
+    bool RHSIsKill = false;
     if (!ResultReg) {
       RHSReg = getRegForValue(RHS);
       if (RHSReg == 0)
         return false;
       RHSIsKill = hasTrivialKill(RHS);
       ResultReg = fastEmit_rr(VT, VT, BaseOpc, LHSReg, LHSIsKill, RHSReg,
                               RHSIsKill);
     }

llvm/lib/Target/X86/X86FixupLEAs.cpp

 bool FixupLEAPass::fixupIncDec(MachineBasicBlock::iterator &I,
                                MachineFunction::iterator MFI) const {
   MachineInstr *MI = I;
   int Opcode = MI->getOpcode();
   if (!isLEA(Opcode))
     return false;
 
   if (isLEASimpleIncOrDec(MI) && TII->isSafeToClobberEFLAGS(*MFI, I)) {
-    int NewOpcode;
+    int NewOpcode = X86::INSTRUCTION_LIST_END;
     bool isINC = MI->getOperand(4).getImm() == 1;
     switch (Opcode) {
     case X86::LEA16r:
       NewOpcode = isINC ? X86::INC16r : X86::DEC16r;
       break;
     case X86::LEA32r:
     case X86::LEA64_32r:
       NewOpcode = isINC ? X86::INC32r : X86::DEC32r;
       break;
     case X86::LEA64r:
       NewOpcode = isINC ? X86::INC64r : X86::DEC64r;
       break;
+    default:
+      llvm_unreachable("Unexpected X86 opcode!");
     }
 
     MachineInstr *NewMI =
         BuildMI(*MFI, I, MI->getDebugLoc(), TII->get(NewOpcode))
             .addOperand(MI->getOperand(0))
             .addOperand(MI->getOperand(1));
     MFI->erase(I);
     I = static_cast<MachineBasicBlock::iterator>(NewMI);

llvm/lib/Target/X86/X86ISelLowering.cpp

if (isHorizontalBinOp(BV, ISD::FSUB, DAG, 0, Half, InVec0, InVec1) &&
         ((InVec0.getOpcode() == ISD::UNDEF ||
           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
         ((InVec1.getOpcode() == ISD::UNDEF ||
           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
       return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
   } else if (VT == MVT::v8i32 || VT == MVT::v16i16) {
     // Try to match an AVX2 horizontal add/sub of signed integers.
     SDValue InVec2, InVec3;
-    unsigned X86Opcode;
+    unsigned X86Opcode = 0;
     bool CanFold = true;
 
     if (isHorizontalBinOp(BV, ISD::ADD, DAG, 0, Half, InVec0, InVec1) &&
         isHorizontalBinOp(BV, ISD::ADD, DAG, Half, NumElts, InVec2, InVec3) &&
         ((InVec0.getOpcode() == ISD::UNDEF ||
           InVec2.getOpcode() == ISD::UNDEF) || InVec0 == InVec2) &&
         ((InVec1.getOpcode() == ISD::UNDEF ||
           InVec3.getOpcode() == ISD::UNDEF) || InVec1 == InVec3))
assert(AToAInputs.size() + BToAInputs.size() == 4 &&
            "Must call this with either 3:1 or 1:3 inputs (summing to 4).");
 
     bool ThreeAInputs = AToAInputs.size() == 3;
 
     // Compute the index of dword with only one word among the three inputs in
     // a half by taking the sum of the half with three inputs and subtracting
     // the sum of the actual three inputs. The difference is the remaining
     // slot.
-    int ADWord, BDWord;
+    int ADWord = 0, BDWord = 0;
     int &TripleDWord = ThreeAInputs ? ADWord : BDWord;
     int &OneInputDWord = ThreeAInputs ? BDWord : ADWord;
     int TripleInputOffset = ThreeAInputs ? AOffset : BOffset;
     ArrayRef<int> TripleInputs = ThreeAInputs ? AToAInputs : BToAInputs;
     int OneInput = ThreeAInputs ? BToAInputs[0] : AToAInputs[0];
     int TripleInputSum = 0 + 1 + 2 + 3 + (4 * TripleInputOffset);
     int TripleNonInputIdx =
         TripleInputSum - std::accumulate(TripleInputs.begin(), TripleInputs.end(), 0);
static SDValue LowerIntVSETCC_AVX512(SDValue Op, SelectionDAG &DAG,
   assert(Op0.getSimpleValueType().getVectorElementType().getSizeInBits() >= 8 &&
          Op.getSimpleValueType().getVectorElementType() == MVT::i1 &&
          "Cannot set masked compare for this operation");
 
   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
   unsigned  Opc = 0;
   bool Unsigned = false;
   bool Swap = false;
-  unsigned SSECC;
+  unsigned SSECC = 0;
   switch (SetCCOpcode) {
   default: llvm_unreachable("Unexpected SETCC condition");
   case ISD::SETNE:  SSECC = 4; break;
   case ISD::SETEQ:  Opc = X86ISD::PCMPEQM; break;
   case ISD::SETUGT: SSECC = 6; Unsigned = true; break;
   case ISD::SETLT:  Swap = true; //fall-through
   case ISD::SETGT:  Opc = X86ISD::PCMPGTM; break;
   case ISD::SETULT: SSECC = 1; Unsigned = true; break;

llvm/lib/Target/X86/X86InstrInfo.cpp

if (IsIntrinOpcode) {
     GroupsNum = array_lengthof(IntrinOpcodeGroups);
     OpcodeGroups = IntrinOpcodeGroups;
   } else {
     GroupsNum = array_lengthof(RegularOpcodeGroups);
     OpcodeGroups = RegularOpcodeGroups;
   }
 
   const uint16_t *FoundOpcodesGroup = nullptr;
-  size_t FormIndex;
+  size_t FormIndex = 0;
 
   // Look for the input opcode in the corresponding opcodes table.
   for (size_t GroupIndex = 0; GroupIndex < GroupsNum && !FoundOpcodesGroup;
          ++GroupIndex) {
     for (FormIndex = 0; FormIndex < FormsNum; ++FormIndex) {
       if (OpcodeGroups[GroupIndex][FormIndex] == Opc) {
         FoundOpcodesGroup = OpcodeGroups[GroupIndex];
         break;

llvm/lib/Target/X86/X86WinEHState.cpp

void WinEHStatePass::addStateStores(Function &F, WinEHFuncInfo &FuncInfo) {
   // FinalStates yields the state of the last call-site for a BasicBlock.
   DenseMap<BasicBlock *, int> FinalStates;
   // Worklist used to revisit BasicBlocks with indeterminate
   // Initial/Final-States.
   std::deque<BasicBlock *> Worklist;
   // Fill in InitialStates and FinalStates for BasicBlocks with call-sites.
   for (BasicBlock *BB : RPOT) {
     int InitialState = OverdefinedState;
-    int FinalState;
+    int FinalState = 0;
     if (&F.getEntryBlock() == BB)
       InitialState = FinalState = ParentBaseState;
     for (Instruction &I : *BB) {
       CallSite CS(&I);
       if (!isStateStoreNeeded(Personality, CS))
         continue;
 
       int State = getStateForCallSite(BlockColors, FuncInfo, CS);

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

Instruction *InstCombiner::visitAdd(BinaryOperator &I) {
   if (Constant *CRHS = dyn_cast<Constant>(RHS)) {
     Value *X;
     if (match(LHS, m_Not(m_Value(X)))) // ~X + C --> (C-1) - X
       return BinaryOperator::CreateSub(SubOne(CRHS), X);
   }
 
   if (ConstantInt *CRHS = dyn_cast<ConstantInt>(RHS)) {
     // (X & FF00) + xx00  -> (X+xx00) & FF00
-    Value *X;
-    ConstantInt *C2;
+    Value *X = nullptr;
+    ConstantInt *C2 = nullptr;
     if (LHS->hasOneUse() &&
         match(LHS, m_And(m_Value(X), m_ConstantInt(C2))) &&
         CRHS->getValue() == (CRHS->getValue() & C2->getValue())) {
       // See if all bits from the first bit set in the Add RHS up are included
       // in the mask.  First, get the rightmost bit.
       const APInt &AddRHSV = CRHS->getValue();
 
       // Form a mask of all bits from the lowest bit added through the top.
Instruction *InstCombiner::visitFAdd(BinaryOperator &I) {
 
   // select C, 0, B + select C, A, 0 -> select C, A, B
   {
     Value *A1, *B1, *C1, *A2, *B2, *C2;
     if (match(LHS, m_Select(m_Value(C1), m_Value(A1), m_Value(B1))) &&
         match(RHS, m_Select(m_Value(C2), m_Value(A2), m_Value(B2)))) {
       if (C1 == C2) {
         Constant *Z1=nullptr, *Z2=nullptr;
-        Value *A, *B, *C=C1;
+        Value *A = nullptr, *B = nullptr, *C=C1;
         if (match(A1, m_AnyZero()) && match(B2, m_AnyZero())) {
             Z1 = dyn_cast<Constant>(A1); A = A2;
             Z2 = dyn_cast<Constant>(B2); B = B1;
         } else if (match(B1, m_AnyZero()) && match(A2, m_AnyZero())) {
             Z1 = dyn_cast<Constant>(B1); B = B2;
             Z2 = dyn_cast<Constant>(A2); A = A1;
         }
 

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

Value *InstCombiner::FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS) {
   }
 
   // (trunc x) == C1 & (and x, CA) == C2 -> (and x, CA|CMAX) == C1|C2
   // where CMAX is the all ones value for the truncated type,
   // iff the lower bits of C2 and CA are zero.
   if (LHSCC == ICmpInst::ICMP_EQ && LHSCC == RHSCC &&
       LHS->hasOneUse() && RHS->hasOneUse()) {
     Value *V;
-    ConstantInt *AndCst, *SmallCst = nullptr, *BigCst = nullptr;
+    ConstantInt *AndCst = nullptr, *SmallCst = nullptr, *BigCst = nullptr;
 
     // (trunc x) == C1 & (and x, CA) == C2
     // (and x, CA) == C2 & (trunc x) == C1
     if (match(Val2, m_Trunc(m_Value(V))) &&
         match(Val, m_And(m_Specific(V), m_ConstantInt(AndCst)))) {
       SmallCst = RHSCst;
       BigCst = LHSCst;
     } else if (match(Val, m_Trunc(m_Value(V))) &&

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

if (CmpLHS == TrueVal && Pred == ICmpInst::ICMP_EQ) {
       SI.setOperand(2, CmpRHS);
       Changed = true;
     }
   }
 
   {
     unsigned BitWidth = DL.getTypeSizeInBits(TrueVal->getType());
     APInt MinSignedValue = APInt::getSignBit(BitWidth);
-    Value *X;
-    const APInt *Y, *C;
-    bool TrueWhenUnset;
+    Value *X = nullptr;
+    const APInt *Y = nullptr, *C;
+    bool TrueWhenUnset = false;
     bool IsBitTest = false;
     if (ICmpInst::isEquality(Pred) &&
         match(CmpLHS, m_And(m_Value(X), m_Power2(Y))) &&
         match(CmpRHS, m_Zero())) {
       IsBitTest = true;
       TrueWhenUnset = Pred == ICmpInst::ICMP_EQ;
     } else if (Pred == ICmpInst::ICMP_SLT && match(CmpRHS, m_Zero())) {
       X = CmpLHS;

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();
         IRB.CreateMemCpy(Base, MSV.getShadowPtr(A, IRB.getInt8Ty(), IRB),
                          ArgSize, kShadowTLSAlignment);
       } else {
         ArgKind AK = classifyArgument(A);
         if (AK == AK_GeneralPurpose && GpOffset >= AMD64GpEndOffset)
           AK = AK_Memory;
         if (AK == AK_FloatingPoint && FpOffset >= AMD64FpEndOffset)
           AK = AK_Memory;
-        Value *Base;
+        Value *Base = nullptr;
         switch (AK) {
+          default:
+            llvm_unreachable("Unexpected ArgKind!");
           case AK_GeneralPurpose:
             Base = getShadowPtrForVAArgument(A->getType(), IRB, GpOffset);
             GpOffset += 8;
             break;
           case AK_FloatingPoint:
             Base = getShadowPtrForVAArgument(A->getType(), IRB, FpOffset);
             FpOffset += 16;
             break;
void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
     for (CallSite::arg_iterator ArgIt = CS.arg_begin() + 1, End = CS.arg_end();
          ArgIt != End; ++ArgIt) {
       Value *A = *ArgIt;
       ArgKind AK = classifyArgument(A);
       if (AK == AK_GeneralPurpose && GrOffset >= AArch64GrEndOffset)
         AK = AK_Memory;
       if (AK == AK_FloatingPoint && VrOffset >= AArch64VrEndOffset)
         AK = AK_Memory;
-      Value *Base;
+      Value *Base = nullptr;
       switch (AK) {
+        default:
+          llvm_unreachable("Unexpected ArgKind!");
         case AK_GeneralPurpose:
           Base = getShadowPtrForVAArgument(A->getType(), IRB, GrOffset);
           GrOffset += 8;
           break;
         case AK_FloatingPoint:
           Base = getShadowPtrForVAArgument(A->getType(), IRB, VrOffset);
           VrOffset += 16;
           break;
         case AK_Memory:
           uint64_t ArgSize = DL.getTypeAllocSize(A->getType());
           Base = getShadowPtrForVAArgument(A->getType(), IRB, OverflowOffset);
           OverflowOffset += alignTo(ArgSize, 8);
           break;
+
       }
       IRB.CreateAlignedStore(MSV.getShadow(A), Base, kShadowTLSAlignment);
     }
     Constant *OverflowSize =
       ConstantInt::get(IRB.getInt64Ty(), OverflowOffset - AArch64VAEndOffset);
     IRB.CreateStore(OverflowSize, MS.VAArgOverflowSizeTLS);
   }
 

llvm/lib/Transforms/Scalar/SROA.cpp

static Value *getAdjustedPtr(IRBuilderTy &IRB, const DataLayout &DL, Value *Ptr,
   SmallPtrSet<Value *, 4> Visited;
   Visited.insert(Ptr);
   SmallVector<Value *, 4> Indices;
 
   // We may end up computing an offset pointer that has the wrong type. If we
   // never are able to compute one directly that has the correct type, we'll
   // fall back to it, so keep it and the base it was computed from around here.
   Value *OffsetPtr = nullptr;
-  Value *OffsetBasePtr;
+  Value *OffsetBasePtr = nullptr;
 
   // Remember any i8 pointer we come across to re-use if we need to do a raw
   // byte offset.
   Value *Int8Ptr = nullptr;
   APInt Int8PtrOffset(Offset.getBitWidth(), 0);
 
   Type *TargetTy = PointerTy->getPointerElementType();
 

llvm/lib/Transforms/Utils/MemorySSA.cpp

 
 /// \brief Verify the domination properties of MemorySSA by checking that each
 /// definition dominates all of its uses.
 void MemorySSA::verifyDomination(Function &F) const {
   for (BasicBlock &B : F) {
     // Phi nodes are attached to basic blocks
     if (MemoryPhi *MP = getMemoryAccess(&B)) {
       for (User *U : MP->users()) {
-        BasicBlock *UseBlock;
+        BasicBlock *UseBlock = nullptr;
         // Phi operands are used on edges, we simulate the right domination by
         // acting as if the use occurred at the end of the predecessor block.
         if (MemoryPhi *P = dyn_cast<MemoryPhi>(U)) {
           for (const auto &Arg : P->operands()) {
             if (Arg == MP) {
               UseBlock = P->getIncomingBlock(Arg);
               break;
             }
           }
         } else {
           UseBlock = cast<MemoryAccess>(U)->getBlock();
         }
         (void)UseBlock;
         assert(DT->dominates(MP->getBlock(), UseBlock) &&
                "Memory PHI does not dominate it's uses");
       }
     }
 
     for (Instruction &I : B) {
       MemoryAccess *MD = dyn_cast_or_null<MemoryDef>(getMemoryAccess(&I));
       if (!MD)
         continue;
 
       for (User *U : MD->users()) {
-        BasicBlock *UseBlock;
+        BasicBlock *UseBlock = nullptr;
         // Things are allowed to flow to phi nodes over their predecessor edge.
         if (auto *P = dyn_cast<MemoryPhi>(U)) {
           for (const auto &Arg : P->operands()) {
             if (Arg == MD) {
               UseBlock = P->getIncomingBlock(Arg);
               break;
             }
           }

llvm/tools/clang/include/clang/Sema/Lookup.h

if (Decls.empty()) {
       if (ResultKind != NotFoundInCurrentInstantiation)
         ResultKind = NotFound;
 
       if (Paths) {
         deletePaths(Paths);
         Paths = nullptr;
       }
     } else {
-      AmbiguityKind SavedAK;
+      AmbiguityKind SavedAK = Ambiguity;
       bool WasAmbiguous = false;
       if (ResultKind == Ambiguous) {
         SavedAK = Ambiguity;
         WasAmbiguous = true;
       }
       ResultKind = Found;
       resolveKind();
 

llvm/tools/clang/lib/AST/ExprConstant.cpp

case Builtin::BI__builtin_ffsll: {
     unsigned N = Val.countTrailingZeros();
     return Success(N == Val.getBitWidth() ? 0 : N + 1, E);
   }
 
   case Builtin::BI__builtin_fpclassify: {
     APFloat Val(0.0);
     if (!EvaluateFloat(E->getArg(5), Val, Info))
       return false;
-    unsigned Arg;
+    unsigned Arg = ~0;
     switch (Val.getCategory()) {
     case APFloat::fcNaN: Arg = 0; break;
     case APFloat::fcInfinity: Arg = 1; break;
     case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break;
     case APFloat::fcZero: Arg = 4; break;
+    default: llvm_unreachable("Unexpected fltCategory!");
     }
     return Visit(E->getArg(Arg));
   }
 
   case Builtin::BI__builtin_isinf_sign: {
     APFloat Val(0.0);
     return EvaluateFloat(E->getArg(0), Val, Info) &&
            Success(Val.isInfinity() ? (Val.isNegative() ? -1 : 1) : 0, E);

llvm/tools/clang/lib/AST/MicrosoftMangle.cpp

 // <vtordispex-shift>   ::= <offset-to-vbptr> <vbase-offset-offset>
 //                          <offset-to-vtordisp>
 static void mangleThunkThisAdjustment(const CXXMethodDecl *MD,
                                       const ThisAdjustment &Adjustment,
                                       MicrosoftCXXNameMangler &Mangler,
                                       raw_ostream &Out) {
   if (!Adjustment.Virtual.isEmpty()) {
     Out << '$';
-    char AccessSpec;
+    char AccessSpec = '\0';
     switch (MD->getAccess()) {
+    default:
+      llvm_unreachable("Unexpected AccessSpecifier!");
     case AS_none:
       llvm_unreachable("Unsupported access specifier");
     case AS_private:
       AccessSpec = '0';
       break;
     case AS_protected:
       AccessSpec = '2';
       break;

llvm/tools/clang/lib/CodeGen/CGClass.cpp

void CodeGenFunction::EmitVTablePtrCheck(const CXXRecordDecl *RD,
   case CFITCK_DerivedCast:
     SSK = llvm::SanStat_CFI_DerivedCast;
     break;
   case CFITCK_UnrelatedCast:
     SSK = llvm::SanStat_CFI_UnrelatedCast;
     break;
   case CFITCK_ICall:
     llvm_unreachable("not expecting CFITCK_ICall");
+  default:
+    llvm_unreachable("Unexpected CFITypeCheckKind!");
   }
   EmitSanitizerStatReport(SSK);
 
   llvm::Metadata *MD =
       CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
   llvm::Value *BitSetName = llvm::MetadataAsValue::get(getLLVMContext(), MD);
 
   llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);

llvm/tools/clang/lib/CodeGen/CGCleanup.h

public:
   EHScope *get() const { 
     return reinterpret_cast<EHScope*>(Ptr);
   }
 
   EHScope *operator->() const { return get(); }
   EHScope &operator*() const { return *get(); }
 
   iterator &operator++() {
-    size_t Size;
+    size_t Size = 0;
     switch (get()->getKind()) {
     case EHScope::Catch:
       Size = EHCatchScope::getSizeForNumHandlers(
           static_cast<const EHCatchScope *>(get())->getNumHandlers());
       break;
 
     case EHScope::Filter:
       Size = EHFilterScope::getSizeForNumFilters(
           static_cast<const EHFilterScope *>(get())->getNumFilters());
       break;
 
     case EHScope::Cleanup:
       Size = static_cast<const EHCleanupScope *>(get())->getAllocatedSize();
       break;
 
     case EHScope::Terminate:
       Size = EHTerminateScope::getSize();
       break;
 
     case EHScope::PadEnd:
       Size = EHPadEndScope::getSize();
       break;
+    default:
+      llvm_unreachable("Unexpected Kind!");
     }
     Ptr += llvm::alignTo(Size, ScopeStackAlignment);
     return *this;
   }
 
   iterator next() {
     iterator copy = *this;
     ++copy;

llvm/tools/clang/lib/CodeGen/CGExprScalar.cpp

Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,
 
   return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
                               E->getExprLoc());
 }
 
 Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
   bool Ignore = TestAndClearIgnoreResultAssign();
 
-  Value *RHS;
+  Value *RHS = nullptr;
   LValue LHS;
 
   switch (E->getLHS()->getType().getObjCLifetime()) {
+  default:
+    llvm_unreachable("Unexpected ObjCLifetime!");
   case Qualifiers::OCL_Strong:
     std::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
     break;
 
   case Qualifiers::OCL_Autoreleasing:
     std::tie(LHS, RHS) = CGF.EmitARCStoreAutoreleasing(E);
     break;
 

llvm/tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp

void CGOpenMPRuntime::emitProcBindClause(CodeGenFunction &CGF,
   case OMPC_PROC_BIND_close:
     RuntimeProcBind = ProcBindClose;
     break;
   case OMPC_PROC_BIND_spread:
     RuntimeProcBind = ProcBindSpread;
     break;
   case OMPC_PROC_BIND_unknown:
     llvm_unreachable("Unsupported proc_bind value.");
+  default:
+    llvm_unreachable("Unexpected OpenMPProcBindClauseKind!");
   }
   // Build call __kmpc_push_proc_bind(&loc, global_tid, proc_bind)
   llvm::Value *Args[] = {
       emitUpdateLocation(CGF, Loc), getThreadID(CGF, Loc),
       llvm::ConstantInt::get(CGM.IntTy, RuntimeProcBind, /*isSigned=*/true)};
   CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_push_proc_bind), Args);
 }
 

llvm/tools/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp

CGRecordLowering::accumulateBitFields(RecordDecl::field_iterator Field,
   // used as a special value to note that we don't have a current run.  A
   // bitfield run is a contiguous collection of bitfields that can be stored in
   // the same storage block.  Zero-sized bitfields and bitfields that would
   // cross an alignment boundary break a run and start a new one.
   RecordDecl::field_iterator Run = FieldEnd;
   // Tail is the offset of the first bit off the end of the current run.  It's
   // used to determine if the ASTRecordLayout is treating these two bitfields as
   // contiguous.  StartBitOffset is offset of the beginning of the Run.
-  uint64_t StartBitOffset, Tail = 0;
+  uint64_t StartBitOffset = 0, Tail = 0;
   if (isDiscreteBitFieldABI()) {
     for (; Field != FieldEnd; ++Field) {
       uint64_t BitOffset = getFieldBitOffset(*Field);
       // Zero-width bitfields end runs.
       if (Field->getBitWidthValue(Context) == 0) {
         Run = FieldEnd;
         continue;
       }

llvm/tools/clang/lib/CodeGen/CGStmtOpenMP.cpp

static std::pair<bool, RValue> emitOMPAtomicRMW(CodeGenFunction &CGF, LValue X,
   case BO_XorAssign:
   case BO_MulAssign:
   case BO_DivAssign:
   case BO_RemAssign:
   case BO_ShlAssign:
   case BO_ShrAssign:
   case BO_Comma:
     llvm_unreachable("Unsupported atomic update operation");
+  default:
+    llvm_unreachable("Unexpected BinaryOperatorKind!");
   }
   auto *UpdateVal = Update.getScalarVal();
   if (auto *IC = dyn_cast<llvm::ConstantInt>(UpdateVal)) {
     UpdateVal = CGF.Builder.CreateIntCast(
         IC, X.getAddress().getElementType(),
         X.getType()->hasSignedIntegerRepresentation());
   }
   auto *Res = CGF.Builder.CreateAtomicRMW(RMWOp, X.getPointer(), UpdateVal, AO);

llvm/tools/clang/lib/CodeGen/CodeGenAction.cpp

void BackendConsumer::InlineAsmDiagHandler2(const llvm::SMDiagnostic &D,
   if (Message.startswith("error: "))
     Message = Message.substr(7);
 
   // If the SMDiagnostic has an inline asm source location, translate it.
   FullSourceLoc Loc;
   if (D.getLoc() != SMLoc())
     Loc = ConvertBackendLocation(D, Context->getSourceManager());
 
-  unsigned DiagID;
+  unsigned DiagID = 0;
   switch (D.getKind()) {
   case llvm::SourceMgr::DK_Error:
     DiagID = diag::err_fe_inline_asm;
     break;
   case llvm::SourceMgr::DK_Warning:
     DiagID = diag::warn_fe_inline_asm;
     break;
   case llvm::SourceMgr::DK_Note:
     DiagID = diag::note_fe_inline_asm;
     break;
+  default:
+    llvm_unreachable("Unexpected DiagKind!");
   }
   // If this problem has clang-level source location information, report the
   // issue in the source with a note showing the instantiated
   // code.
   if (LocCookie.isValid()) {
     Diags.Report(LocCookie, DiagID).AddString(Message);
     
     if (D.getLoc().isValid()) {
do {                                                                         \
     case llvm::DS_Note:                                                        \
       DiagID = diag::note_fe_##GroupName;                                      \
       break;                                                                   \
     }                                                                          \
   } while (false)
 
 bool
 BackendConsumer::InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D) {
-  unsigned DiagID;
+  unsigned DiagID = 0;
   ComputeDiagID(D.getSeverity(), inline_asm, DiagID);
   std::string Message = D.getMsgStr().str();
 
   // If this problem has clang-level source location information, report the
   // issue as being a problem in the source with a note showing the instantiated
   // code.
   SourceLocation LocCookie =
       SourceLocation::getFromRawEncoding(D.getLocCookie());

llvm/tools/clang/lib/CodeGen/TargetInfo.cpp

void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
     const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
     if (!FD)
       return;
 
     const ARMInterruptAttr *Attr = FD->getAttr<ARMInterruptAttr>();
     if (!Attr)
       return;
 
-    const char *Kind;
+    const char *Kind = "";
     switch (Attr->getInterrupt()) {
     case ARMInterruptAttr::Generic: Kind = ""; break;
     case ARMInterruptAttr::IRQ:     Kind = "IRQ"; break;
     case ARMInterruptAttr::FIQ:     Kind = "FIQ"; break;
     case ARMInterruptAttr::SWI:     Kind = "SWI"; break;
     case ARMInterruptAttr::ABORT:   Kind = "ABORT"; break;
     case ARMInterruptAttr::UNDEF:   Kind = "UNDEF"; break;
+    default:
+      llvm_unreachable("Unexpected InterruptType!");
     }
 
     llvm::Function *Fn = cast<llvm::Function>(GV);
 
     Fn->addFnAttr("interrupt", Kind);
 
     ARMABIInfo::ABIKind ABI = cast<ARMABIInfo>(getABIInfo()).getABIKind();
     if (ABI == ARMABIInfo::APCS)
void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
     else if (FD->hasAttr<NoMips16Attr>()) {
       Fn->addFnAttr("nomips16");
     }
 
     const MipsInterruptAttr *Attr = FD->getAttr<MipsInterruptAttr>();
     if (!Attr)
       return;
 
-    const char *Kind;
+    const char *Kind = "";
     switch (Attr->getInterrupt()) {
     case MipsInterruptAttr::eic:     Kind = "eic"; break;
     case MipsInterruptAttr::sw0:     Kind = "sw0"; break;
     case MipsInterruptAttr::sw1:     Kind = "sw1"; break;
     case MipsInterruptAttr::hw0:     Kind = "hw0"; break;
     case MipsInterruptAttr::hw1:     Kind = "hw1"; break;
     case MipsInterruptAttr::hw2:     Kind = "hw2"; break;
     case MipsInterruptAttr::hw3:     Kind = "hw3"; break;
     case MipsInterruptAttr::hw4:     Kind = "hw4"; break;
     case MipsInterruptAttr::hw5:     Kind = "hw5"; break;
+    default:
+      llvm_unreachable("Unexpected InterruptType!");
     }
 
     Fn->addFnAttr("interrupt", Kind);
 
   }
 
   bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
                                llvm::Value *Address) const override;

llvm/tools/clang/lib/Driver/ToolChain.cpp

else if (Name == "libstdc++")
     Type = ToolChain::CST_Libstdcxx;
   else
     return false;
 
   return true;
 }
 
 ToolChain::CXXStdlibType ToolChain::GetCXXStdlibType(const ArgList &Args) const{
-  ToolChain::CXXStdlibType Type;
+  ToolChain::CXXStdlibType Type = ToolChain::CST_Libcxx;
   bool HasValidType = false;
 
   const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
   if (A) {
     HasValidType = ParseCXXStdlibType(A->getValue(), Type);
     if (!HasValidType)
       getDriver().Diag(diag::err_drv_invalid_stdlib_name)
         << A->getAsString(Args);

llvm/tools/clang/lib/Lex/Preprocessor.cpp

if (LastTokenWasAt && II.isModulesImport() && !InMacroArgs &&
     ModuleImportExpectsIdentifier = true;
     CurLexerKind = CLK_LexAfterModuleImport;
   }
   return true;
 }
 
 void Preprocessor::Lex(Token &Result) {
   // We loop here until a lex function returns a token; this avoids recursion.
-  bool ReturnedToken;
+  bool ReturnedToken = false;
   do {
     switch (CurLexerKind) {
     case CLK_Lexer:
       ReturnedToken = CurLexer->Lex(Result);
       break;
     case CLK_PTHLexer:
       ReturnedToken = CurPTHLexer->Lex(Result);
       break;
     case CLK_TokenLexer:
       ReturnedToken = CurTokenLexer->Lex(Result);
       break;
     case CLK_CachingLexer:
       CachingLex(Result);
       ReturnedToken = true;
       break;
     case CLK_LexAfterModuleImport:
       LexAfterModuleImport(Result);
       ReturnedToken = true;
       break;
+    default:
+      llvm_unreachable("Unexpected CurLexerKind!");
     }
   } while (!ReturnedToken);
 
   LastTokenWasAt = Result.is(tok::at);
 }
 
 
 /// \brief Lex a token following the 'import' contextual keyword.

llvm/tools/clang/lib/Parse/ParseObjc.cpp

for (unsigned i = 0; i != objc_NumQuals; ++i) {
       if (II != ObjCTypeQuals[i] ||
           NextToken().is(tok::less) ||
           NextToken().is(tok::coloncolon))
         continue;
 
       ObjCDeclSpec::ObjCDeclQualifier Qual;
       NullabilityKind Nullability;
       switch (i) {
-      default: llvm_unreachable("Unknown decl qualifier");
+      default: llvm_unreachable("Unknown ObjCTypeQual!");
       case objc_in:     Qual = ObjCDeclSpec::DQ_In; break;
       case objc_out:    Qual = ObjCDeclSpec::DQ_Out; break;
       case objc_inout:  Qual = ObjCDeclSpec::DQ_Inout; break;
       case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break;
       case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break;
       case objc_byref:  Qual = ObjCDeclSpec::DQ_Byref; break;
 
       case objc_nonnull: 

llvm/tools/clang/lib/Sema/SemaDecl.cpp

if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
     //   overloaded functions any member of which is a function template if 
     //   this is followed by a <, the < is always taken as the delimiter of a
     //   template-argument-list and never as the less-than operator.
     if (!IsFilteredTemplateName)
       FilterAcceptableTemplateNames(Result);
     
     if (!Result.empty()) {
       bool IsFunctionTemplate;
-      bool IsVarTemplate;
+      bool IsVarTemplate = false;
       TemplateName Template;
       if (Result.end() - Result.begin() > 1) {
         IsFunctionTemplate = true;
         Template = Context.getOverloadedTemplateName(Result.begin(), 
                                                      Result.end());
       } else {
         TemplateDecl *TD
           = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());

llvm/tools/clang/lib/Sema/SemaDeclAttr.cpp

 
 static void DoEmitAvailabilityWarning(Sema &S, Sema::AvailabilityDiagnostic K,
                                       Decl *Ctx, const NamedDecl *D,
                                       StringRef Message, SourceLocation Loc,
                                       const ObjCInterfaceDecl *UnknownObjCClass,
                                       const ObjCPropertyDecl *ObjCProperty,
                                       bool ObjCPropertyAccess) {
   // Diagnostics for deprecated or unavailable.
-  unsigned diag, diag_message, diag_fwdclass_message;
+  // FIXME: What're reasonable defaults for these three?
+  unsigned diag = 0, diag_message = 0, diag_fwdclass_message = 0;
   unsigned diag_available_here = diag::note_availability_specified_here;
 
   // Matches 'diag::note_property_attribute' options.
   unsigned property_note_select;
 
   // Matches diag::note_availability_specified_here.
   unsigned available_here_select_kind;
 
if (auto attr = D->getAttr<UnavailableAttr>()) {
           flagARCError();
           diag_available_here = diag::note_arc_init_returns_unrelated;
           break;
 
         case UnavailableAttr::IR_ARCFieldWithOwnership:
           flagARCError();
           diag_available_here = diag::note_arc_field_with_ownership;
           break;
+        default:
+          llvm_unreachable("Unexpected UnavailableAttr!");
         }
       }
     }
     break;
 
   case Sema::AD_Partial:
     diag = diag::warn_partial_availability;
     diag_message = diag::warn_partial_message;
     diag_fwdclass_message = diag::warn_partial_fwdclass_message;
     property_note_select = /* partial */ 2;
     available_here_select_kind = /* partial */ 3;
     break;
+  default:
+    llvm_unreachable("Unexpected AvailabilityDiagnostic!");
   }
 
   if (!Message.empty()) {
     S.Diag(Loc, diag_message) << D << Message;
     if (ObjCProperty)
       S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
           << ObjCProperty->getDeclName() << property_note_select;
   } else if (!UnknownObjCClass) {

llvm/tools/clang/lib/Sema/SemaDeclCXX.cpp

static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc,
                                       QualType SubType, bool ConstRHS,
                                       Sema::CXXSpecialMember CSM,
                                       TrivialSubobjectKind Kind,
                                       bool Diagnose) {
   CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
   if (!SubRD)
     return true;
 
-  CXXMethodDecl *Selected;
+  // If we had SAL, we might be able to assume that findTrivialSpecialMember
+  // properly initializes the _Outptr_ parameter, but alas, we don't, we can't.
+  CXXMethodDecl *Selected = nullptr;
   if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
                                ConstRHS, Diagnose ? &Selected : nullptr))
     return true;
 
   if (Diagnose) {
     if (ConstRHS)
       SubType.addConst();
 

llvm/tools/clang/lib/Sema/SemaInit.cpp

static void TryConstructorInitialization(Sema &S,
   bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
 
   //   - Otherwise, if T is a class type, constructors are considered. The
   //     applicable constructors are enumerated, and the best one is chosen
   //     through overload resolution.
   DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
 
   OverloadingResult Result = OR_No_Viable_Function;
-  OverloadCandidateSet::iterator Best;
+  OverloadCandidateSet::iterator Best = nullptr;
   bool AsInitializerList = false;
 
   // C++11 [over.match.list]p1, per DR1467:
   //   When objects of non-aggregate type T are list-initialized, such that
   //   8.5.4 [dcl.init.list] specifies that overload resolution is performed
   //   according to the rules in this section, overload resolution selects
   //   the constructor in two phases:
   //

llvm/tools/clang/lib/Sema/SemaLambda.cpp

if (C->Init.isUsable()) {
       // If the initializer expression is usable, but the InitCaptureType
       // is not, then an error has occurred - so ignore the capture for now.
       // for e.g., [n{0}] { }; <-- if no <initializer_list> is included.
       // FIXME: we should create the init capture variable and mark it invalid 
       // in this case.
       if (C->InitCaptureType.get().isNull()) 
         continue;
 
-      unsigned InitStyle;
+      unsigned InitStyle = 0;
       switch (C->InitKind) {
       case LambdaCaptureInitKind::NoInit:
         llvm_unreachable("not an init-capture?");
       case LambdaCaptureInitKind::CopyInit:
         InitStyle = VarDecl::CInit;
         break;
       case LambdaCaptureInitKind::DirectInit:
         InitStyle = VarDecl::CallInit;
         break;
       case LambdaCaptureInitKind::ListInit:
         InitStyle = VarDecl::ListInit;
         break;
+      default:
+        llvm_unreachable("Unexpected LambdaCaptureInitKind!");
       }
       Var = createLambdaInitCaptureVarDecl(C->Loc, C->InitCaptureType.get(),
                                            C->Id, InitStyle, C->Init.get());
       // C++1y [expr.prim.lambda]p11:
       //   An init-capture behaves as if it declares and explicitly
       //   captures a variable [...] whose declarative region is the
       //   lambda-expression's compound-statement
       if (Var)

llvm/tools/clang/lib/Sema/SemaLookup.cpp

if (SM == CXXDestructor) {
     return Result;
   }
 
   // Prepare for overload resolution. Here we construct a synthetic argument
   // if necessary and make sure that implicit functions are declared.
   CanQualType CanTy = Context.getCanonicalType(Context.getTagDeclType(RD));
   DeclarationName Name;
   Expr *Arg = nullptr;
-  unsigned NumArgs;
+  unsigned NumArgs = 0;
 
   QualType ArgType = CanTy;
   ExprValueKind VK = VK_LValue;
 
   if (SM == CXXDefaultConstructor) {
     Name = Context.DeclarationNames.getCXXConstructorName(CanTy);
     NumArgs = 0;
     if (RD->needsImplicitDefaultConstructor())
if (Modules.size() > 1) {
 
     Diag(UseLoc, diag::err_module_unimported_use_multiple)
       << (int)MIK << Decl << ModuleList;
   } else {
     Diag(UseLoc, diag::err_module_unimported_use)
       << (int)MIK << Decl << Modules[0]->getFullModuleName();
   }
 
-  unsigned DiagID;
+  unsigned DiagID = 0;
   switch (MIK) {
   case MissingImportKind::Declaration:
     DiagID = diag::note_previous_declaration;
     break;
   case MissingImportKind::Definition:
     DiagID = diag::note_previous_definition;
     break;
   case MissingImportKind::DefaultArgument:
     DiagID = diag::note_default_argument_declared_here;
     break;
+  default:
+    llvm_unreachable("Unexpected MissingImportKind!");
   }
   Diag(DeclLoc, DiagID);
 
   // Try to recover by implicitly importing this module.
   if (Recover)
     createImplicitModuleImportForErrorRecovery(UseLoc, Modules[0]);
 }
 

llvm/tools/clang/lib/Sema/SemaStmtAttr.cpp

for (const auto *I : Attrs) {
     case LoopHintAttr::Interleave:
     case LoopHintAttr::InterleaveCount:
       Category = Interleave;
       break;
     case LoopHintAttr::Unroll:
     case LoopHintAttr::UnrollCount:
       Category = Unroll;
       break;
+    default:
+      llvm_unreachable("Unexpected OptionType!");
     };
 
     auto &CategoryState = HintAttrs[Category];
     const LoopHintAttr *PrevAttr;
     if (Option == LoopHintAttr::Vectorize ||
         Option == LoopHintAttr::Interleave || Option == LoopHintAttr::Unroll) {
       // Enable|Disable|AssumeSafety hint.  For example, vectorize(enable).
       PrevAttr = CategoryState.StateAttr;

llvm/tools/clang/lib/Serialization/ASTReader.cpp

Data = (uint64_t)Reader.getLocalIdentifier(
         F, endian::readNext<uint32_t, little, unaligned>(d));
     break;
   case DeclarationName::CXXConstructorName:
   case DeclarationName::CXXDestructorName:
   case DeclarationName::CXXConversionFunctionName:
   case DeclarationName::CXXUsingDirective:
     Data = 0;
     break;
+  default:
+    llvm_unreachable("Unexpected NameKind!");
   }
 
   return DeclarationNameKey(Kind, Data);
 }
 
 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
                                                  const unsigned char *d,
                                                  unsigned DataLen,
PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
   ModuleFile &M = *SLocMapI->second;
   typedef const PPEntityOffset *pp_iterator;
   pp_iterator pp_begin = M.PreprocessedEntityOffsets;
   pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
 
   size_t Count = M.NumPreprocessedEntities;
   size_t Half;
   pp_iterator First = pp_begin;
-  pp_iterator PPI;
+  pp_iterator PPI = nullptr;
 
   if (EndsAfter) {
     PPI = std::upper_bound(pp_begin, pp_end, Loc,
                            PPEntityComp<&PPEntityOffset::Begin>(*this, M));
   } else {
+    assert(Count > 0 && "PPI will not be set if this loop doesn't execute!");
     // Do a binary search manually instead of using std::lower_bound because
     // The end locations of entities may be unordered (when a macro expansion
     // is inside another macro argument), but for this case it is not important
     // whether we get the first macro expansion or its containing macro.
     while (Count > 0) {
       Half = Count / 2;
       PPI = First;
       std::advance(PPI, Half);
       if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End),
                                               Loc)) {
         First = PPI;
         ++First;
+        assert(Count > Half && "size_t is unsigned, subtracing (Half + 1) from Count"
+                               "will cause unsigned integer wraparound!");
         Count = Count - Half - 1;
       } else
         Count = Half;
     }
   }
 
   if (PPI == pp_end)
     return findNextPreprocessedEntity(SLocMapI);

llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp

 #include "clang/Basic/OpenMPKinds.def"
   OMPClause *readClause();
   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
 };
 }
 
 OMPClause *OMPClauseReader::readClause() {
-  OMPClause *C;
+  OMPClause *C = nullptr;
   switch (Record[Idx++]) {
   case OMPC_if:
     C = new (Context) OMPIfClause();
     break;
   case OMPC_final:
     C = new (Context) OMPFinalClause();
     break;
   case OMPC_num_threads:
case OMPC_hint:
     C = new (Context) OMPHintClause();
     break;
   case OMPC_dist_schedule:
     C = new (Context) OMPDistScheduleClause();
     break;
   case OMPC_defaultmap:
     C = new (Context) OMPDefaultmapClause();
     break;
+  default:
+    llvm_unreachable("Unexpected OpenMP clause!");
   }
   Visit(C);
   C->setLocStart(Reader->ReadSourceLocation(Record, Idx));
   C->setLocEnd(Reader->ReadSourceLocation(Record, Idx));
 
   return C;
 }
 

llvm/tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp

 }
 
 void WalkAST::VisitCallExpr(CallExpr *CE) {
   StringRef Name = getCalleeName(CE);
   if (Name.empty())
     return;
 
   const Expr *Arg = nullptr;
-  unsigned ArgNum;
+  unsigned ArgNum = 0;
 
   if (Name.equals("CFArrayCreate") || Name.equals("CFSetCreate")) {
     if (CE->getNumArgs() != 4)
       return;
     ArgNum = 1;
     Arg = CE->getArg(ArgNum)->IgnoreParenCasts();
     if (hasPointerToPointerSizedType(Arg))
         return;

llvm/tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp

CheckObjCMessageContext(ObjCMessageVisitKind visitKind,
                             const ObjCMethodCall &msg, ExprEngine &eng,
                             bool wasInlined)
       : Kind(visitKind), WasInlined(wasInlined), Checkers(checkers),
         Msg(msg), Eng(eng) { }
 
     void runChecker(CheckerManager::CheckObjCMessageFunc checkFn,
                     NodeBuilder &Bldr, ExplodedNode *Pred) {
 
-      bool IsPreVisit;
+      bool IsPreVisit = false;
 
       switch (Kind) {
         case ObjCMessageVisitKind::Pre:
           IsPreVisit = true;
           break;
         case ObjCMessageVisitKind::MessageNil:
         case ObjCMessageVisitKind::Post:
           IsPreVisit = false;
           break;
+        default:
+          llvm_unreachable("Unexpected ObjCMessageVisitKind!");
       }
 
       const ProgramPoint &L = Msg.getProgramPoint(IsPreVisit,checkFn.Checker);
       CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
 
       checkFn(*Msg.cloneWithState<ObjCMethodCall>(Pred->getState()), C);
     }
   };

llvm/tools/clang/lib/StaticAnalyzer/Core/SymbolManager.cpp

 }
 
 bool SymbolReaper::isLive(SymbolRef sym) {
   if (TheLiving.count(sym)) {
     markDependentsLive(sym);
     return true;
   }
 
-  bool KnownLive;
+  bool KnownLive = false;
 
   switch (sym->getKind()) {
   case SymExpr::SymbolRegionValueKind:
     KnownLive = isLiveRegion(cast<SymbolRegionValue>(sym)->getRegion());
     break;
   case SymExpr::SymbolConjuredKind:
     KnownLive = false;
     break;
case SymExpr::IntSymExprKind:
     break;
   case SymExpr::SymSymExprKind:
     KnownLive = isLive(cast<SymSymExpr>(sym)->getLHS()) &&
                 isLive(cast<SymSymExpr>(sym)->getRHS());
     break;
   case SymExpr::SymbolCastKind:
     KnownLive = isLive(cast<SymbolCast>(sym)->getOperand());
     break;
+  default:
+    llvm_unreachable("Unexpected symbol kind!");
   }
 
   if (KnownLive)
     markLive(sym);
 
   return KnownLive;
 }