[Coverity] Fix uninitialized scalar members in MC

[akshaykhadse]

Summary

This change fixes static code analysis errors

[pengfei]

llvm/include/llvm/MC/MCMachObjectWriter.h

35

0

llvm/include/llvm/MC/MCObjectStreamer.h

49

0

[akshaykhadse]

Address review comments

[pengfei]

LGTM.

llvm/include/llvm/MC/MCAsmMacro.h

enum TokenKind {
     PercentDtprel_Lo, PercentGot, PercentGot_Disp, PercentGot_Hi, PercentGot_Lo,
     PercentGot_Ofst, PercentGot_Page, PercentGottprel, PercentGp_Rel, PercentHi,
     PercentHigher, PercentHighest, PercentLo, PercentNeg, PercentPcrel_Hi,
     PercentPcrel_Lo, PercentTlsgd, PercentTlsldm, PercentTprel_Hi,
     PercentTprel_Lo
   };
 
 private:
-  TokenKind Kind;
+  TokenKind Kind = TokenKind::Eof;
 
   /// A reference to the entire token contents; this is always a pointer into
   /// a memory buffer owned by the source manager.
   StringRef Str;
 
   APInt IntVal;
 
 public:

llvm/include/llvm/MC/MCDwarf.h

 private:
   OpType Operation;
   MCSymbol *Label;
   unsigned Register;
   union {
     int Offset;
     unsigned Register2;
   };
-  unsigned AddressSpace;
+  unsigned AddressSpace = ~0u;
   std::vector<char> Values;
   std::string Comment;
 
   MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V,
                    StringRef Comment = "")
       : Operation(Op), Label(L), Register(R), Offset(O),
         Values(V.begin(), V.end()), Comment(Comment) {
     assert(Op != OpRegister && Op != OpLLVMDefAspaceCfa);

llvm/include/llvm/MC/MCMachObjectWriter.h

 class MachObjectWriter;
 
 class MCMachObjectTargetWriter : public MCObjectTargetWriter {
   const unsigned Is64Bit : 1;
   const uint32_t CPUType;
 protected:
   uint32_t CPUSubtype;
 public:
-  unsigned LocalDifference_RIT;
+  unsigned LocalDifference_RIT = 0;
 
 protected:
   MCMachObjectTargetWriter(bool Is64Bit_, uint32_t CPUType_,
                            uint32_t CPUSubtype_);
 
   void setLocalDifferenceRelocationType(unsigned Type) {
     LocalDifference_RIT = Type;
   }

llvm/include/llvm/MC/MCObjectStreamer.h

 /// implementation.
 class MCObjectStreamer : public MCStreamer {
   std::unique_ptr<MCAssembler> Assembler;
   MCSection::iterator CurInsertionPoint;
   bool EmitEHFrame;
   bool EmitDebugFrame;
   SmallVector<MCSymbol *, 2> PendingLabels;
   SmallSetVector<MCSection *, 4> PendingLabelSections;
-  unsigned CurSubsectionIdx;
+  unsigned CurSubsectionIdx = 0;
   struct PendingMCFixup {
     const MCSymbol *Sym;
     MCFixup Fixup;
     MCDataFragment *DF;
     PendingMCFixup(const MCSymbol *McSym, MCDataFragment *F, MCFixup McFixup)
         : Sym(McSym), Fixup(McFixup), DF(F) {}
   };
   SmallVector<PendingMCFixup, 2> PendingFixups;

llvm/include/llvm/MC/MCParser/MCAsmLexer.h

class MCAsmLexer {
 
   /// The location and description of the current error
   SMLoc ErrLoc;
   std::string Err;
 
 protected: // Can only create subclasses.
   const char *TokStart = nullptr;
   bool SkipSpace = true;
-  bool AllowAtInIdentifier;
+  bool AllowAtInIdentifier = false;
   bool AllowHashInIdentifier = false;
   bool IsAtStartOfStatement = true;
   bool LexMasmHexFloats = false;
   bool LexMasmIntegers = false;
   bool LexMasmStrings = false;
   bool LexMotorolaIntegers = false;
   bool UseMasmDefaultRadix = false;
   unsigned DefaultRadix = 10;

llvm/include/llvm/MC/MCParser/MCParsedAsmOperand.h

 
 /// MCParsedAsmOperand - This abstract class represents a source-level assembly
 /// instruction operand.  It should be subclassed by target-specific code.  This
 /// base class is used by target-independent clients and is the interface
 /// between parsing an asm instruction and recognizing it.
 class MCParsedAsmOperand {
   /// MCOperandNum - The corresponding MCInst operand number.  Only valid when
   /// parsing MS-style inline assembly.
-  unsigned MCOperandNum;
+  unsigned MCOperandNum = ~0u;
 
   /// Constraint - The constraint on this operand.  Only valid when parsing
   /// MS-style inline assembly.
   std::string Constraint;
 
 protected:
   // This only seems to need to be movable (by ARMOperand) but ARMOperand has
   // lots of members and MSVC doesn't support defaulted move ops, so to avoid

llvm/include/llvm/MC/MCRegisterInfo.h

public:
 
   /// Forward iterator using DiffListIterator.
   template <class SubT>
   class mc_difflist_iterator
       : public iterator_facade_base<mc_difflist_iterator<SubT>,
                                     std::forward_iterator_tag, MCPhysReg> {
     MCRegisterInfo::DiffListIterator Iter;
     /// Current value as MCPhysReg, so we can return a reference to it.
-    MCPhysReg Val;
+    MCPhysReg Val = 0;
 
   protected:
     mc_difflist_iterator(MCRegisterInfo::DiffListIterator Iter) : Iter(Iter) {}
 
     // Allow conversion between instantiations where valid.
     mc_difflist_iterator(MCRegister Reg, const MCPhysReg *DiffList) {
       Iter.init(Reg, DiffList);
       Val = *Iter;

llvm/include/llvm/MC/MCSection.h

 private:
   MCSymbol *Begin;
   MCSymbol *End = nullptr;
   /// The alignment requirement of this section.
   Align Alignment;
   /// The section index in the assemblers section list.
   unsigned Ordinal = 0;
   /// The index of this section in the layout order.
-  unsigned LayoutOrder;
+  unsigned LayoutOrder = 0;
 
   /// Keeping track of bundle-locked state.
   BundleLockStateType BundleLockState = NotBundleLocked;
 
   /// Current nesting depth of bundle_lock directives.
   unsigned BundleLockNestingDepth = 0;
 
   /// We've seen a bundle_lock directive but not its first instruction

llvm/lib/MC/ELFObjectWriter.cpp

struct ELFWriter {
   /// @name Symbol Table Data
   /// @{
 
   StringTableBuilder StrTabBuilder{StringTableBuilder::ELF};
 
   /// @}
 
   // This holds the symbol table index of the last local symbol.
-  unsigned LastLocalSymbolIndex;
+  unsigned LastLocalSymbolIndex = ~0u;
   // This holds the .strtab section index.
-  unsigned StringTableIndex;
+  unsigned StringTableIndex = ~0u;
   // This holds the .symtab section index.
-  unsigned SymbolTableIndex;
+  unsigned SymbolTableIndex = ~0u;
 
   // Sections in the order they are to be output in the section table.
   std::vector<const MCSectionELF *> SectionTable;
   unsigned addToSectionTable(const MCSectionELF *Sec);
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const;
   bool usesRela(const MCSectionELF &Sec) const;

llvm/lib/MC/WinCOFFObjectWriter.cpp

 
 class COFFSymbol {
 public:
   COFF::symbol Data = {};
 
   using AuxiliarySymbols = SmallVector<AuxSymbol, 1>;
 
   name Name;
-  int Index;
+  int Index = 0;
   AuxiliarySymbols Aux;
   COFFSymbol *Other = nullptr;
   COFFSection *Section = nullptr;
   int Relocations = 0;
   const MCSymbol *MC = nullptr;
 
   COFFSymbol(StringRef Name) : Name(Name) {}
 

 
 using relocations = std::vector<COFFRelocation>;
 
 class COFFSection {
 public:
   COFF::section Header = {};
 
   std::string Name;
-  int Number;
+  int Number = 0;
   MCSectionCOFF const *MCSection = nullptr;
   COFFSymbol *Symbol = nullptr;
   relocations Relocations;
 
   COFFSection(StringRef Name) : Name(std::string(Name)) {}
 
   SmallVector<COFFSymbol *, 1> OffsetSymbols;
 };

llvm/lib/MC/XCOFFObjectWriter.cpp

struct DwarfSectionEntry : public SectionEntry {
 
   DwarfSectionEntry(DwarfSectionEntry &&s) = default;
 
   virtual ~DwarfSectionEntry() = default;
 };
 
 struct ExceptionTableEntry {
   const MCSymbol *Trap;
-  uint64_t TrapAddress;
+  uint64_t TrapAddress = ~0ul;
   unsigned Lang;
   unsigned Reason;
 
   ExceptionTableEntry(const MCSymbol *Trap, unsigned Lang, unsigned Reason)
       : Trap(Trap), Lang(Lang), Reason(Reason) {}
 };
 
 struct ExceptionInfo {